void hybwin(int lpsize, int framesize, int nrsize, float old_input[],
            float new_input[], float output[], float window[], float rec[],
            float decay) {
  int N1 = lpsize + framesize;
  int N2 = lpsize + nrsize;
  int N3 = lpsize + framesize + nrsize;
  int i;
  float ws[N3];
  float tmp1[lpsize + 1], tmp2[lpsize + 1];
  for (i = 0; i < N2; i++)
    old_input[i] = old_input[i + framesize];
  for (i = 0; i < framesize; i++)
    old_input[N2 + i] = new_input[i];
  {
    typeof(&old_input[0]) __xp = old_input;
    typeof(&window[0]) __yp = window;
    typeof(&ws[0]) __zp = ws;
    int i;
    typeof(old_input[0]) __xi = *__xp++;
    typeof(window[0]) __yi = *__yp++;
    typeof(ws[0]) __zi;
    for (i = 1; i < N3; i++) {
      __zi = __xi * __yi;
      __xi = *__xp++;
      __yi = *__yp++;
      *__zp++ = __zi;
    }
    __zi = __xi * __yi;
    *__zp = __zi;
  };
  {
    int __k, __i, __M1 = lpsize + 1;
    typeof(&tmp1[0]) __rp = tmp1;
    typeof(*tmp1) __corr = 0;
    for (__k = 0; __k <= lpsize; __k++) {
      typeof(*tmp1) __t;
      typeof(&ws[0]) __xip = ws + lpsize, __xkp = __xip - __k;
      typeof(ws[0]) __xi, __xk;
      __corr = __corr - __corr;
      __xi = *__xip++;
      __xk = *__xkp++;
      for (__i = __M1; __i < N1; __i++) {
        __t = __xi * __xk;
        __xi = *__xip++;
        __corr += __t;
        __xk = *__xkp++;
      }
      __t = __xi * __xk;
      __corr += __t;
      *(__rp++) = __corr;
    }
  };
  for (i = 0; i <= lpsize; i++)
    rec[i] = decay * rec[i] + tmp1[i];
  {
    int __k, __i, __M1 = N1 + 1;
    typeof(&tmp2[0]) __rp = tmp2;
    typeof(*tmp2) __corr = 0;
    for (__k = 0; __k <= lpsize; __k++) {
      typeof(*tmp2) __t;
      typeof(&ws[0]) __xip = ws + N1, __xkp = __xip - __k;
      typeof(ws[0]) __xi, __xk;
      __corr = __corr - __corr;
      __xi = *__xip++;
      __xk = *__xkp++;
      for (__i = __M1; __i < N3; __i++) {
        __t = __xi * __xk;
        __xi = *__xip++;
        __corr += __t;
        __xk = *__xkp++;
      }
      __t = __xi * __xk;
      __corr += __t;
      *(__rp++) = __corr;
    }
  };
  for (i = 0; i <= lpsize; i++)
    output[i] = rec[i] + tmp2[i];
  output[0] *= (257. / 256.);
}


x86 assembly (clang, -O0):
<hybwin>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
mov    -0x4(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x4(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    %ecx,%eax
mov    -0xc(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x48(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x110(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x108(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x100(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1209 <hybwin+0x109>
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x8(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11d0 <hybwin+0xd0>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1249 <hybwin+0x149>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1210 <hybwin+0x110>
mov    -0x110(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    %rcx,-0x68(%rbp)
mov    0x10(%rbp),%rcx
mov    %rcx,-0x70(%rbp)
mov    %rax,-0x78(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x68(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x70(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movl   $0x1,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    131b <hybwin+0x21b>
movss  -0x80(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x68(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x70(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x78(%rbp)
movss  %xmm0,(%rax)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    129e <hybwin+0x19e>
mov    -0x108(%rbp),%rax
movss  -0x80(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rcx
movss  %xmm0,(%rcx)
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x94(%rbp)
mov    %rax,-0xa0(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1518 <hybwin+0x418>
mov    -0x110(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
movslq -0x8c(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xb8(%rbp)
movss  -0xa4(%rbp),%xmm0
ff
subss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0xb0(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xb0(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
mov    -0xb8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xb8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
mov    -0x94(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    14b3 <hybwin+0x3b3>
movss  -0xbc(%rbp),%xmm0
ff
mulss  -0xc0(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0xb0(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xb0(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
addss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0xb8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xb8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    141e <hybwin+0x31e>
movss  -0xbc(%rbp),%xmm0
ff
mulss  -0xc0(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
addss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xa0(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xa0(%rbp)
movss  %xmm0,(%rax)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    136f <hybwin+0x26f>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1570 <hybwin+0x470>
mov    -0x108(%rbp),%rax
movss  -0x2c(%rbp),%xmm0
mov    0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    151f <hybwin+0x41f>
mov    -0x100(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0xcc(%rbp)
mov    %rax,-0xd8(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1748 <hybwin+0x648>
mov    -0x110(%rbp),%rax
movslq -0x30(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rax
movslq -0xc4(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
movss  -0xdc(%rbp),%xmm0
ff
subss  -0xdc(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xe8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xf0(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
mov    -0xcc(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    16e3 <hybwin+0x5e3>
movss  -0xf4(%rbp),%xmm0
ff
mulss  -0xf8(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xe8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
addss  -0xdc(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xf0(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    164e <hybwin+0x54e>
movss  -0xf4(%rbp),%xmm0
ff
mulss  -0xf8(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
addss  -0xdc(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xd8(%rbp)
movss  %xmm0,(%rax)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    159f <hybwin+0x49f>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1793 <hybwin+0x693>
mov    -0x100(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
movslq -0x3c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    174f <hybwin+0x64f>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x859(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x48(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hybwin>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,-0x68(%rbp)
mov    %rdi,-0x40(%rbp)
mov    %rsi,%rax
mov    %rsi,-0x38(%rbp)
lea    (%rsi,%rdi,1),%r11d
lea    (%rdx,%rdi,1),%esi
mov    %rdx,-0x58(%rbp)
lea    (%r11,%rdx,1),%r10d
lea    0xf(,%r10,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r14
sub    %rax,%r14
mov    %r14,%rsp
lea    0x1(%rdi),%r15d
mov    %rsp,%r13
lea    0xf(,%r15,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r13
mov    %r13,%rsp
mov    %rsp,%rdx
sub    %rax,%rdx
mov    %rdx,-0x60(%rbp)
mov    %rdx,%rsp
test   %esi,%esi
mov    %r13,-0x48(%rbp)
jle    133b <hybwin+0x23b>
movslq -0x38(%rbp),%rbx
mov    %esi,%edi
cmp    $0x8,%esi
jb     11a3 <hybwin+0xa3>
lea    (%rbx,%rdi,1),%rax
lea    (%rcx,%rax,4),%rax
cmp    %rcx,%rax
jbe    1244 <hybwin+0x144>
lea    (%rcx,%rdi,4),%rax
lea    (%rcx,%rbx,4),%rdx
cmp    %rax,%rdx
jae    1244 <hybwin+0x144>
xor    %r12d,%r12d
mov    %r12,%rdx
not    %rdx
add    %rdi,%rdx
mov    %rdi,%rax
and    $0x3,%rax
je     11e1 <hybwin+0xe1>
mov    %rbx,%r9
lea    (%rcx,%rbx,4),%rbx
nop
movss  (%rbx,%r12,4),%xmm1
movss  %xmm1,(%rcx,%r12,4)
add    $0x1,%r12
add    $0xffffffffffffffff,%rax
jne    11c0 <hybwin+0xc0>
cmp    $0x3,%rdx
jae    11ee <hybwin+0xee>
jmp    133b <hybwin+0x23b>
mov    %rbx,%r9
cmp    $0x3,%rdx
jb     133b <hybwin+0x23b>
lea    0xc(%rcx),%rax
lea    (%rcx,%r9,4),%rdx
add    $0xc,%rdx
nopw   0x0(%rax,%rax,1)
movss  -0xc(%rdx,%r12,4),%xmm1
movss  %xmm1,-0xc(%rax,%r12,4)
movss  -0x8(%rdx,%r12,4),%xmm1
movss  %xmm1,-0x8(%rax,%r12,4)
movss  -0x4(%rdx,%r12,4),%xmm1
movss  %xmm1,-0x4(%rax,%r12,4)
movss  (%rdx,%r12,4),%xmm1
movss  %xmm1,(%rax,%r12,4)
add    $0x4,%r12
cmp    %r12,%rdi
jne    1200 <hybwin+0x100>
jmp    133b <hybwin+0x23b>
mov    %rbx,-0x30(%rbp)
mov    %esi,-0x4c(%rbp)
mov    %edi,%r12d
and    $0xfffffff8,%r12d
lea    -0x8(%r12),%rax
mov    %rax,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%esi
and    $0x3,%esi
cmp    $0x18,%rax
jae    1274 <hybwin+0x174>
xor    %edx,%edx
jmp    12f1 <hybwin+0x1f1>
and    $0xfffffffffffffffc,%rbx
mov    -0x30(%rbp),%rax
lea    (%rcx,%rax,4),%r13
add    $0x70,%r13
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups -0x70(%r13,%rdx,4),%xmm1
movups -0x60(%r13,%rdx,4),%xmm2
movups %xmm1,(%rcx,%rdx,4)
movups %xmm2,0x10(%rcx,%rdx,4)
movups -0x50(%r13,%rdx,4),%xmm1
movups -0x40(%r13,%rdx,4),%xmm2
movups %xmm1,0x20(%rcx,%rdx,4)
movups %xmm2,0x30(%rcx,%rdx,4)
movups -0x30(%r13,%rdx,4),%xmm1
movups -0x20(%r13,%rdx,4),%xmm2
movups %xmm1,0x40(%rcx,%rdx,4)
movups %xmm2,0x50(%rcx,%rdx,4)
movups -0x10(%r13,%rdx,4),%xmm1
movups 0x0(%r13,%rdx,4),%xmm2
movups %xmm1,0x60(%rcx,%rdx,4)
movups %xmm2,0x70(%rcx,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rbx
jne    1290 <hybwin+0x190>
test   %rsi,%rsi
je     132b <hybwin+0x22b>
lea    (%rcx,%rdx,4),%rax
add    $0x10,%rax
mov    -0x30(%rbp),%rdx
lea    (%rax,%rdx,4),%rdx
shl    $0x5,%rsi
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x10(%rdx,%rbx,1),%xmm1
movups (%rdx,%rbx,1),%xmm2
movups %xmm1,-0x10(%rax,%rbx,1)
movups %xmm2,(%rax,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rsi
jne    1310 <hybwin+0x210>
cmp    %rdi,%r12
mov    -0x4c(%rbp),%esi
mov    -0x30(%rbp),%rbx
jne    11a6 <hybwin+0xa6>
mov    0x10(%rbp),%r12
cmpl   $0x0,-0x38(%rbp)
mov    -0x68(%rbp),%r9
jle    1520 <hybwin+0x420>
movslq %esi,%rsi
mov    -0x38(%rbp),%rax
mov    %eax,%edi
cmp    $0x8,%eax
jb     137d <hybwin+0x27d>
lea    (%rcx,%rsi,4),%rax
lea    (%r8,%rdi,4),%rdx
cmp    %rdx,%rax
jae    1414 <hybwin+0x314>
lea    (%rsi,%rdi,1),%rax
lea    (%rcx,%rax,4),%rax
cmp    %r8,%rax
jbe    1414 <hybwin+0x314>
xor    %r13d,%r13d
mov    %r13,%rdx
not    %rdx
add    %rdi,%rdx
mov    %rdi,%rax
and    $0x3,%rax
je     13b6 <hybwin+0x2b6>
lea    (%rcx,%rsi,4),%rbx
cs nopw 0x0(%rax,%rax,1)
movss  (%r8,%r13,4),%xmm1
movss  %xmm1,(%rbx,%r13,4)
add    $0x1,%r13
add    $0xffffffffffffffff,%rax
jne    13a0 <hybwin+0x2a0>
cmp    $0x3,%rdx
jb     1520 <hybwin+0x420>
lea    (%rcx,%rsi,4),%rax
add    $0xc,%rax
nopl   0x0(%rax,%rax,1)
movss  (%r8,%r13,4),%xmm1
movss  %xmm1,-0xc(%rax,%r13,4)
movss  0x4(%r8,%r13,4),%xmm1
movss  %xmm1,-0x8(%rax,%r13,4)
movss  0x8(%r8,%r13,4),%xmm1
movss  %xmm1,-0x4(%rax,%r13,4)
movss  0xc(%r8,%r13,4),%xmm1
movss  %xmm1,(%rax,%r13,4)
add    $0x4,%r13
cmp    %r13,%rdi
jne    13d0 <hybwin+0x2d0>
jmp    1520 <hybwin+0x420>
mov    %rsi,-0x30(%rbp)
mov    %edi,%r13d
and    $0xfffffff8,%r13d
lea    -0x8(%r13),%rax
mov    %rax,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%esi
and    $0x3,%esi
cmp    $0x18,%rax
mov    %r15,-0x70(%rbp)
jae    1445 <hybwin+0x345>
xor    %r9d,%r9d
jmp    14c8 <hybwin+0x3c8>
and    $0xfffffffffffffffc,%rbx
mov    -0x30(%rbp),%rax
lea    (%rcx,%rax,4),%r15
add    $0x70,%r15
xor    %r9d,%r9d
nopl   0x0(%rax,%rax,1)
movups (%r8,%r9,4),%xmm1
movups 0x10(%r8,%r9,4),%xmm2
movups %xmm1,-0x70(%r15,%r9,4)
movups %xmm2,-0x60(%r15,%r9,4)
movups 0x20(%r8,%r9,4),%xmm1
movups 0x30(%r8,%r9,4),%xmm2
movups %xmm1,-0x50(%r15,%r9,4)
movups %xmm2,-0x40(%r15,%r9,4)
movups 0x40(%r8,%r9,4),%xmm1
movups 0x50(%r8,%r9,4),%xmm2
movups %xmm1,-0x30(%r15,%r9,4)
movups %xmm2,-0x20(%r15,%r9,4)
movups 0x60(%r8,%r9,4),%xmm1
movups 0x70(%r8,%r9,4),%xmm2
movups %xmm1,-0x10(%r15,%r9,4)
movups %xmm2,(%r15,%r9,4)
add    $0x20,%r9
add    $0xfffffffffffffffc,%rbx
jne    1460 <hybwin+0x360>
test   %rsi,%rsi
je     150b <hybwin+0x40b>
mov    -0x30(%rbp),%rax
add    %r9,%rax
lea    (%rcx,%rax,4),%rax
add    $0x10,%rax
lea    (%r8,%r9,4),%rbx
add    $0x10,%rbx
shl    $0x5,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rbx,%rdx,1),%xmm1
movups (%rbx,%rdx,1),%xmm2
movups %xmm1,-0x10(%rax,%rdx,1)
movups %xmm2,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    14f0 <hybwin+0x3f0>
cmp    %rdi,%r13
mov    -0x68(%rbp),%r9
mov    -0x70(%rbp),%r15
mov    -0x30(%rbp),%rsi
jne    1380 <hybwin+0x280>
movss  (%rcx),%xmm1
movss  (%r12),%xmm2
cmp    $0x2,%r10d
jl     1562 <hybwin+0x462>
mov    -0x58(%rbp),%rax
mov    -0x38(%rbp),%rdx
add    %edx,%eax
mov    -0x40(%rbp),%rsi
lea    (%rsi,%rax,1),%r8d
add    $0xffffffff,%r8d
add    %esi,%eax
add    $0xfffffffe,%eax
cmp    $0x3,%eax
jae    156e <hybwin+0x46e>
mov    %r14,%rdi
test   $0x3,%r8b
jne    15eb <hybwin+0x4eb>
jmp    1625 <hybwin+0x525>
mov    %r14,%rdi
mov    -0x40(%rbp),%rsi
jmp    1625 <hybwin+0x525>
mov    %r8d,%edx
and    $0xfffffffc,%edx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
mulss  %xmm1,%xmm2
movss  0x4(%rcx,%rdi,1),%xmm1
mulss  0x4(%r12,%rdi,1),%xmm1
movss  %xmm2,(%r14,%rdi,1)
movss  0x8(%rcx,%rdi,1),%xmm2
mulss  0x8(%r12,%rdi,1),%xmm2
movss  %xmm1,0x4(%r14,%rdi,1)
movss  0xc(%rcx,%rdi,1),%xmm3
mulss  0xc(%r12,%rdi,1),%xmm3
movss  %xmm2,0x8(%r14,%rdi,1)
movss  0x10(%rcx,%rdi,1),%xmm1
movss  0x10(%r12,%rdi,1),%xmm2
movss  %xmm3,0xc(%r14,%rdi,1)
add    $0x10,%rdi
add    $0xfffffffc,%edx
jne    1580 <hybwin+0x480>
add    %rdi,%rcx
add    %rdi,%r12
add    %r14,%rdi
test   $0x3,%r8b
je     1625 <hybwin+0x525>
and    $0x3,%r8d
shl    $0x2,%r8
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm2,%xmm3
mulss  %xmm1,%xmm3
movss  0x4(%rcx,%rax,1),%xmm1
movss  0x4(%r12,%rax,1),%xmm2
movss  %xmm3,(%rdi,%rax,1)
add    $0x4,%rax
cmp    %eax,%r8d
jne    1600 <hybwin+0x500>
add    %rax,%rdi
mulss  %xmm2,%xmm1
movss  %xmm1,(%rdi)
test   %esi,%esi
js     1a2c <hybwin+0x92c>
mov    0x18(%rbp),%r8
mov    %esi,%r12d
lea    (%r14,%r12,4),%r13
movss  (%r14,%r12,4),%xmm1
lea    0x4(%r14),%rdx
xorps  %xmm2,%xmm2
xor    %ebx,%ebx
mov    %rdx,%rdi
mov    -0x48(%rbp),%rcx
jmp    1680 <hybwin+0x580>
nopl   0x0(%rax,%rax,1)
movaps %xmm1,%xmm4
mulss  %xmm4,%xmm3
addss  %xmm3,%xmm2
movss  %xmm2,(%rcx)
add    $0x4,%rcx
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rdi
cmp    %r15,%rbx
je     16d0 <hybwin+0x5d0>
lea    0x0(,%rbx,4),%rax
mov    %r13,%rsi
sub    %rax,%rsi
subss  %xmm2,%xmm2
movss  (%rsi),%xmm3
cmpl   $0x2,-0x38(%rbp)
jl     1660 <hybwin+0x560>
mov    %r12,%rax
movaps %xmm1,%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mulss  %xmm3,%xmm4
addss  %xmm4,%xmm2
movss  (%rdi,%rax,4),%xmm3
movss  (%rdx,%rax,4),%xmm4
add    $0x1,%rax
lea    0x1(%rax),%esi
cmp    %r11d,%esi
jl     16b0 <hybwin+0x5b0>
jmp    1663 <hybwin+0x563>
mov    -0x40(%rbp),%rbx
test   %ebx,%ebx
mov    -0x60(%rbp),%r12
js     1a2c <hybwin+0x92c>
cmp    $0x8,%r15d
jae    16f1 <hybwin+0x5f1>
xor    %esi,%esi
mov    -0x48(%rbp),%rax
jmp    17c0 <hybwin+0x6c0>
mov    %r15d,%esi
and    $0xfffffff8,%esi
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rsi),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rax,%rax
mov    -0x48(%rbp),%rax
je     196b <hybwin+0x86b>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
and    %rdx,%rdi
xor    %ecx,%ecx
nopl   (%rax)
movups (%r8,%rcx,4),%xmm2
movups 0x10(%r8,%rcx,4),%xmm3
movups 0x20(%r8,%rcx,4),%xmm4
movups 0x30(%r8,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
addps  (%rax,%rcx,4),%xmm2
mulps  %xmm1,%xmm3
addps  0x10(%rax,%rcx,4),%xmm3
movups %xmm2,(%r8,%rcx,4)
movups %xmm3,0x10(%r8,%rcx,4)
mulps  %xmm1,%xmm4
addps  0x20(%rax,%rcx,4),%xmm4
mulps  %xmm1,%xmm5
addps  0x30(%rax,%rcx,4),%xmm5
movups %xmm4,0x20(%r8,%rcx,4)
movups %xmm5,0x30(%r8,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1730 <hybwin+0x630>
test   $0x1,%dl
je     17b1 <hybwin+0x6b1>
movups (%r8,%rcx,4),%xmm2
movups 0x10(%r8,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
addps  (%rax,%rcx,4),%xmm2
mulps  %xmm1,%xmm3
addps  0x10(%rax,%rcx,4),%xmm3
movups %xmm2,(%r8,%rcx,4)
movups %xmm3,0x10(%r8,%rcx,4)
cmp    %r15,%rsi
je     17de <hybwin+0x6de>
cs nopw 0x0(%rax,%rax,1)
movss  (%r8,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rax,%rsi,4),%xmm1
movss  %xmm1,(%r8,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r15
jne    17c0 <hybwin+0x6c0>
test   %ebx,%ebx
js     1a2c <hybwin+0x92c>
mov    %r15,%r13
mov    %r12,%rdx
mov    %r9,%r12
movslq %r11d,%rax
lea    (%r14,%rax,4),%r15
movss  (%r14,%rax,4),%xmm0
add    $0x1,%r11d
lea    (%r14,%rax,4),%r9
add    $0x4,%r9
xorps  %xmm1,%xmm1
xor    %edi,%edi
xor    %ebx,%ebx
mov    -0x58(%rbp),%r14
jmp    1840 <hybwin+0x740>
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm0,%xmm3
mulss  %xmm3,%xmm2
addss  %xmm2,%xmm1
movss  %xmm1,(%rdx)
add    $0x4,%rdx
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rdi
cmp    %r13,%rbx
je     188f <hybwin+0x78f>
lea    0x0(,%rbx,4),%rax
mov    %r15,%rcx
sub    %rax,%rcx
subss  %xmm1,%xmm1
movss  (%rcx),%xmm2
cmp    $0x2,%r14d
jl     1820 <hybwin+0x720>
mov    %r9,%rcx
mov    %r11d,%esi
movaps %xmm0,%xmm3
cs nopw 0x0(%rax,%rax,1)
nop
mulss  %xmm2,%xmm3
addss  %xmm3,%xmm1
movss  (%rcx,%rdi,1),%xmm2
movss  (%rcx),%xmm3
add    $0x1,%esi
add    $0x4,%rcx
cmp    %r10d,%esi
jl     1870 <hybwin+0x770>
jmp    1823 <hybwin+0x723>
cmpl   $0x0,-0x40(%rbp)
mov    %r12,%r9
mov    -0x60(%rbp),%rbx
js     1a2c <hybwin+0x92c>
mov    %r13,%rdi
cmp    $0x8,%edi
jb     18c2 <hybwin+0x7c2>
lea    (%r8,%rdi,4),%rax
cmp    %r9,%rax
jbe    197b <hybwin+0x87b>
lea    (%r9,%rdi,4),%rax
cmp    %r8,%rax
jbe    197b <hybwin+0x87b>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    %rdi,%rdx
and    $0x3,%rdx
je     18fb <hybwin+0x7fb>
cs nopw 0x0(%rax,%rax,1)
movss  (%r8,%rax,4),%xmm0
addss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%r9,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    18e0 <hybwin+0x7e0>
cmp    $0x3,%rcx
jb     1a2c <hybwin+0x92c>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r8,%rax,4),%xmm0
addss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%r9,%rax,4)
movss  0x4(%r8,%rax,4),%xmm0
addss  0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%r9,%rax,4)
movss  0x8(%r8,%rax,4),%xmm0
addss  0x8(%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%r9,%rax,4)
movss  0xc(%r8,%rax,4),%xmm0
addss  0xc(%rbx,%rax,4),%xmm0
movss  %xmm0,0xc(%r9,%rax,4)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1910 <hybwin+0x810>
jmp    1a2c <hybwin+0x92c>
xor    %ecx,%ecx
test   $0x1,%dl
jne    178c <hybwin+0x68c>
jmp    17b1 <hybwin+0x6b1>
mov    %edi,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     19fd <hybwin+0x8fd>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
or     $0x2,%rsi
and    %rcx,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups (%r8,%rdx,4),%xmm0
movups 0x10(%r8,%rdx,4),%xmm1
addps  (%rbx,%rdx,4),%xmm0
addps  0x10(%rbx,%rdx,4),%xmm1
movups %xmm0,(%r9,%rdx,4)
movups %xmm1,0x10(%r9,%rdx,4)
movups 0x20(%r8,%rdx,4),%xmm0
movups 0x30(%r8,%rdx,4),%xmm1
addps  0x20(%rbx,%rdx,4),%xmm0
addps  0x30(%rbx,%rdx,4),%xmm1
movups %xmm0,0x20(%r9,%rdx,4)
movups %xmm1,0x30(%r9,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    19b0 <hybwin+0x8b0>
jmp    19ff <hybwin+0x8ff>
xor    %edx,%edx
test   $0x1,%cl
je     1a23 <hybwin+0x923>
movups (%r8,%rdx,4),%xmm0
movups 0x10(%r8,%rdx,4),%xmm1
addps  (%rbx,%rdx,4),%xmm0
addps  0x10(%rbx,%rdx,4),%xmm1
movups %xmm0,(%r9,%rdx,4)
movups %xmm1,0x10(%r9,%rdx,4)
cmp    %rdi,%rax
jne    18c4 <hybwin+0x7c4>
movss  (%r9),%xmm0
mulss  0x5c7(%rip),%xmm0
movss  %xmm0,(%r9)
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @hybwin(i32 %0, i32 %1, i32 %2, float* nocapture %3, float* nocapture %4, float* nocapture %5, float* nocapture %6, float* nocapture %7, float %8) {
%10 = add nsw i32 %1, %0
%11 = add i32 %2, %0
%12 = add i32 %10, %2
%13 = zext i32 %12 to i64
%14 = alloca float, i64 %13
%15 = add i32 %0, 1
%16 = zext i32 %15 to i64
%17 = alloca float, i64 %16
%18 = alloca float, i64 %16
%19 = icmp sgt i32 %11, 0
br i1 %19, label %20, label %135
20: ; preds = %9
%21 = sext i32 %1 to i64
%22 = zext i32 %11 to i64
%23 = icmp ult i32 %11, 8
br i1 %23, label %116, label %24
24: ; preds = %20
%25 = getelementptr float, float* %3, i64 %22
%26 = getelementptr float, float* %3, i64 %21
%27 = add nsw i64 %21, %22
%28 = getelementptr float, float* %3, i64 %27
%29 = icmp ugt float* %28, %3
%30 = icmp ult float* %26, %25
%31 = and i1 %29, %30
br i1 %31, label %116, label %32
32: ; preds = %24
%33 = and i64 %22, 4294967288
%34 = add nsw i64 %33, -8
%35 = lshr exact i64 %34, 3
%36 = add nuw nsw i64 %35, 1
%37 = and i64 %36, 3
%38 = icmp ult i64 %34, 24
br i1 %38, label %94, label %39
39: ; preds = %32
%40 = and i64 %36, 4611686018427387900
br label %41
41: ; preds = %41, %39
%42 = phi i64 [ 0, %39 ], [ %91, %41 ]
%43 = phi i64 [ 0, %39 ], [ %92, %41 ]
%44 = add nsw i64 %42, %21
%45 = getelementptr inbounds float, float* %3, i64 %44
%46 = bitcast float* %45 to <4 x float>*
%47 = load <4 x float>, <4 x float>* %46
%48 = getelementptr inbounds float, float* %45, i64 4
%49 = bitcast float* %48 to <4 x float>*
%50 = load <4 x float>, <4 x float>* %49
%51 = getelementptr inbounds float, float* %3, i64 %42
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> %47, <4 x float>* %52
%53 = getelementptr inbounds float, float* %51, i64 4
%54 = bitcast float* %53 to <4 x float>*
store <4 x float> %50, <4 x float>* %54
%55 = or i64 %42, 8
%56 = add nsw i64 %55, %21
%57 = getelementptr inbounds float, float* %3, i64 %56
%58 = bitcast float* %57 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = getelementptr inbounds float, float* %57, i64 4
%61 = bitcast float* %60 to <4 x float>*
%62 = load <4 x float>, <4 x float>* %61
%63 = getelementptr inbounds float, float* %3, i64 %55
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> %59, <4 x float>* %64
%65 = getelementptr inbounds float, float* %63, i64 4
%66 = bitcast float* %65 to <4 x float>*
store <4 x float> %62, <4 x float>* %66
%67 = or i64 %42, 16
%68 = add nsw i64 %67, %21
%69 = getelementptr inbounds float, float* %3, i64 %68
%70 = bitcast float* %69 to <4 x float>*
%71 = load <4 x float>, <4 x float>* %70
%72 = getelementptr inbounds float, float* %69, i64 4
%73 = bitcast float* %72 to <4 x float>*
%74 = load <4 x float>, <4 x float>* %73
%75 = getelementptr inbounds float, float* %3, i64 %67
%76 = bitcast float* %75 to <4 x float>*
store <4 x float> %71, <4 x float>* %76
%77 = getelementptr inbounds float, float* %75, i64 4
%78 = bitcast float* %77 to <4 x float>*
store <4 x float> %74, <4 x float>* %78
%79 = or i64 %42, 24
%80 = add nsw i64 %79, %21
%81 = getelementptr inbounds float, float* %3, i64 %80
%82 = bitcast float* %81 to <4 x float>*
%83 = load <4 x float>, <4 x float>* %82
%84 = getelementptr inbounds float, float* %81, i64 4
%85 = bitcast float* %84 to <4 x float>*
%86 = load <4 x float>, <4 x float>* %85
%87 = getelementptr inbounds float, float* %3, i64 %79
%88 = bitcast float* %87 to <4 x float>*
store <4 x float> %83, <4 x float>* %88
%89 = getelementptr inbounds float, float* %87, i64 4
%90 = bitcast float* %89 to <4 x float>*
store <4 x float> %86, <4 x float>* %90
%91 = add nuw i64 %42, 32
%92 = add i64 %43, 4
%93 = icmp eq i64 %92, %40
br i1 %93, label %94, label %41
94: ; preds = %41, %32
%95 = phi i64 [ 0, %32 ], [ %91, %41 ]
%96 = icmp eq i64 %37, 0
br i1 %96, label %114, label %97
97: ; preds = %94, %97
%98 = phi i64 [ %111, %97 ], [ %95, %94 ]
%99 = phi i64 [ %112, %97 ], [ 0, %94 ]
%100 = add nsw i64 %98, %21
%101 = getelementptr inbounds float, float* %3, i64 %100
%102 = bitcast float* %101 to <4 x float>*
%103 = load <4 x float>, <4 x float>* %102
%104 = getelementptr inbounds float, float* %101, i64 4
%105 = bitcast float* %104 to <4 x float>*
%106 = load <4 x float>, <4 x float>* %105
%107 = getelementptr inbounds float, float* %3, i64 %98
%108 = bitcast float* %107 to <4 x float>*
store <4 x float> %103, <4 x float>* %108
%109 = getelementptr inbounds float, float* %107, i64 4
%110 = bitcast float* %109 to <4 x float>*
store <4 x float> %106, <4 x float>* %110
%111 = add nuw i64 %98, 8
%112 = add i64 %99, 1
%113 = icmp eq i64 %112, %37
br i1 %113, label %114, label %97
114: ; preds = %97, %94
%115 = icmp eq i64 %33, %22
br i1 %115, label %135, label %116
116: ; preds = %24, %20, %114
%117 = phi i64 [ 0, %24 ], [ 0, %20 ], [ %33, %114 ]
%118 = xor i64 %117, -1
%119 = add nsw i64 %118, %22
%120 = and i64 %22, 3
%121 = icmp eq i64 %120, 0
br i1 %121, label %132, label %122
122: ; preds = %116, %122
%123 = phi i64 [ %129, %122 ], [ %117, %116 ]
%124 = phi i64 [ %130, %122 ], [ 0, %116 ]
%125 = add nsw i64 %123, %21
%126 = getelementptr inbounds float, float* %3, i64 %125
%127 = load float, float* %126
%128 = getelementptr inbounds float, float* %3, i64 %123
store float %127, float* %128
%129 = add nuw nsw i64 %123, 1
%130 = add i64 %124, 1
%131 = icmp eq i64 %130, %120
br i1 %131, label %132, label %122
132: ; preds = %122, %116
%133 = phi i64 [ %117, %116 ], [ %129, %122 ]
%134 = icmp ult i64 %119, 3
br i1 %134, label %135, label %252
135: ; preds = %132, %252, %114, %9
%136 = icmp sgt i32 %1, 0
br i1 %136, label %137, label %298
137: ; preds = %135
%138 = sext i32 %11 to i64
%139 = zext i32 %1 to i64
%140 = icmp ult i32 %1, 8
br i1 %140, label %233, label %141
141: ; preds = %137
%142 = getelementptr float, float* %3, i64 %138
%143 = add nsw i64 %138, %139
%144 = getelementptr float, float* %3, i64 %143
%145 = getelementptr float, float* %4, i64 %139
%146 = icmp ult float* %142, %145
%147 = icmp ugt float* %144, %4
%148 = and i1 %146, %147
br i1 %148, label %233, label %149
149: ; preds = %141
%150 = and i64 %139, 4294967288
%151 = add nsw i64 %150, -8
%152 = lshr exact i64 %151, 3
%153 = add nuw nsw i64 %152, 1
%154 = and i64 %153, 3
%155 = icmp ult i64 %151, 24
br i1 %155, label %211, label %156
156: ; preds = %149
%157 = and i64 %153, 4611686018427387900
br label %158
158: ; preds = %158, %156
%159 = phi i64 [ 0, %156 ], [ %208, %158 ]
%160 = phi i64 [ 0, %156 ], [ %209, %158 ]
%161 = getelementptr inbounds float, float* %4, i64 %159
%162 = bitcast float* %161 to <4 x float>*
%163 = load <4 x float>, <4 x float>* %162
%164 = getelementptr inbounds float, float* %161, i64 4
%165 = bitcast float* %164 to <4 x float>*
%166 = load <4 x float>, <4 x float>* %165
%167 = add nsw i64 %159, %138
%168 = getelementptr inbounds float, float* %3, i64 %167
%169 = bitcast float* %168 to <4 x float>*
store <4 x float> %163, <4 x float>* %169
%170 = getelementptr inbounds float, float* %168, i64 4
%171 = bitcast float* %170 to <4 x float>*
store <4 x float> %166, <4 x float>* %171
%172 = or i64 %159, 8
%173 = getelementptr inbounds float, float* %4, i64 %172
%174 = bitcast float* %173 to <4 x float>*
%175 = load <4 x float>, <4 x float>* %174
%176 = getelementptr inbounds float, float* %173, i64 4
%177 = bitcast float* %176 to <4 x float>*
%178 = load <4 x float>, <4 x float>* %177
%179 = add nsw i64 %172, %138
%180 = getelementptr inbounds float, float* %3, i64 %179
%181 = bitcast float* %180 to <4 x float>*
store <4 x float> %175, <4 x float>* %181
%182 = getelementptr inbounds float, float* %180, i64 4
%183 = bitcast float* %182 to <4 x float>*
store <4 x float> %178, <4 x float>* %183
%184 = or i64 %159, 16
%185 = getelementptr inbounds float, float* %4, i64 %184
%186 = bitcast float* %185 to <4 x float>*
%187 = load <4 x float>, <4 x float>* %186
%188 = getelementptr inbounds float, float* %185, i64 4
%189 = bitcast float* %188 to <4 x float>*
%190 = load <4 x float>, <4 x float>* %189
%191 = add nsw i64 %184, %138
%192 = getelementptr inbounds float, float* %3, i64 %191
%193 = bitcast float* %192 to <4 x float>*
store <4 x float> %187, <4 x float>* %193
%194 = getelementptr inbounds float, float* %192, i64 4
%195 = bitcast float* %194 to <4 x float>*
store <4 x float> %190, <4 x float>* %195
%196 = or i64 %159, 24
%197 = getelementptr inbounds float, float* %4, i64 %196
%198 = bitcast float* %197 to <4 x float>*
%199 = load <4 x float>, <4 x float>* %198
%200 = getelementptr inbounds float, float* %197, i64 4
%201 = bitcast float* %200 to <4 x float>*
%202 = load <4 x float>, <4 x float>* %201
%203 = add nsw i64 %196, %138
%204 = getelementptr inbounds float, float* %3, i64 %203
%205 = bitcast float* %204 to <4 x float>*
store <4 x float> %199, <4 x float>* %205
%206 = getelementptr inbounds float, float* %204, i64 4
%207 = bitcast float* %206 to <4 x float>*
store <4 x float> %202, <4 x float>* %207
%208 = add nuw i64 %159, 32
%209 = add i64 %160, 4
%210 = icmp eq i64 %209, %157
br i1 %210, label %211, label %158
211: ; preds = %158, %149
%212 = phi i64 [ 0, %149 ], [ %208, %158 ]
%213 = icmp eq i64 %154, 0
br i1 %213, label %231, label %214
214: ; preds = %211, %214
%215 = phi i64 [ %228, %214 ], [ %212, %211 ]
%216 = phi i64 [ %229, %214 ], [ 0, %211 ]
%217 = getelementptr inbounds float, float* %4, i64 %215
%218 = bitcast float* %217 to <4 x float>*
%219 = load <4 x float>, <4 x float>* %218
%220 = getelementptr inbounds float, float* %217, i64 4
%221 = bitcast float* %220 to <4 x float>*
%222 = load <4 x float>, <4 x float>* %221
%223 = add nsw i64 %215, %138
%224 = getelementptr inbounds float, float* %3, i64 %223
%225 = bitcast float* %224 to <4 x float>*
store <4 x float> %219, <4 x float>* %225
%226 = getelementptr inbounds float, float* %224, i64 4
%227 = bitcast float* %226 to <4 x float>*
store <4 x float> %222, <4 x float>* %227
%228 = add nuw i64 %215, 8
%229 = add i64 %216, 1
%230 = icmp eq i64 %229, %154
br i1 %230, label %231, label %214
231: ; preds = %214, %211
%232 = icmp eq i64 %150, %139
br i1 %232, label %298, label %233
233: ; preds = %141, %137, %231
%234 = phi i64 [ 0, %141 ], [ 0, %137 ], [ %150, %231 ]
%235 = xor i64 %234, -1
%236 = add nsw i64 %235, %139
%237 = and i64 %139, 3
%238 = icmp eq i64 %237, 0
br i1 %238, label %249, label %239
239: ; preds = %233, %239
%240 = phi i64 [ %246, %239 ], [ %234, %233 ]
%241 = phi i64 [ %247, %239 ], [ 0, %233 ]
%242 = getelementptr inbounds float, float* %4, i64 %240
%243 = load float, float* %242
%244 = add nsw i64 %240, %138
%245 = getelementptr inbounds float, float* %3, i64 %244
store float %243, float* %245
%246 = add nuw nsw i64 %240, 1
%247 = add i64 %241, 1
%248 = icmp eq i64 %247, %237
br i1 %248, label %249, label %239
249: ; preds = %239, %233
%250 = phi i64 [ %234, %233 ], [ %246, %239 ]
%251 = icmp ult i64 %236, 3
br i1 %251, label %298, label %275
252: ; preds = %132, %252
%253 = phi i64 [ %273, %252 ], [ %133, %132 ]
%254 = add nsw i64 %253, %21
%255 = getelementptr inbounds float, float* %3, i64 %254
%256 = load float, float* %255
%257 = getelementptr inbounds float, float* %3, i64 %253
store float %256, float* %257
%258 = add nuw nsw i64 %253, 1
%259 = add nsw i64 %258, %21
%260 = getelementptr inbounds float, float* %3, i64 %259
%261 = load float, float* %260
%262 = getelementptr inbounds float, float* %3, i64 %258
store float %261, float* %262
%263 = add nuw nsw i64 %253, 2
%264 = add nsw i64 %263, %21
%265 = getelementptr inbounds float, float* %3, i64 %264
%266 = load float, float* %265
%267 = getelementptr inbounds float, float* %3, i64 %263
store float %266, float* %267
%268 = add nuw nsw i64 %253, 3
%269 = add nsw i64 %268, %21
%270 = getelementptr inbounds float, float* %3, i64 %269
%271 = load float, float* %270
%272 = getelementptr inbounds float, float* %3, i64 %268
store float %271, float* %272
%273 = add nuw nsw i64 %253, 4
%274 = icmp eq i64 %273, %22
br i1 %274, label %135, label %252
275: ; preds = %249, %275
%276 = phi i64 [ %296, %275 ], [ %250, %249 ]
%277 = getelementptr inbounds float, float* %4, i64 %276
%278 = load float, float* %277
%279 = add nsw i64 %276, %138
%280 = getelementptr inbounds float, float* %3, i64 %279
store float %278, float* %280
%281 = add nuw nsw i64 %276, 1
%282 = getelementptr inbounds float, float* %4, i64 %281
%283 = load float, float* %282
%284 = add nsw i64 %281, %138
%285 = getelementptr inbounds float, float* %3, i64 %284
store float %283, float* %285
%286 = add nuw nsw i64 %276, 2
%287 = getelementptr inbounds float, float* %4, i64 %286
%288 = load float, float* %287
%289 = add nsw i64 %286, %138
%290 = getelementptr inbounds float, float* %3, i64 %289
store float %288, float* %290
%291 = add nuw nsw i64 %276, 3
%292 = getelementptr inbounds float, float* %4, i64 %291
%293 = load float, float* %292
%294 = add nsw i64 %291, %138
%295 = getelementptr inbounds float, float* %3, i64 %294
store float %293, float* %295
%296 = add nuw nsw i64 %276, 4
%297 = icmp eq i64 %296, %139
br i1 %297, label %298, label %275
298: ; preds = %249, %275, %231, %135
%299 = load float, float* %3
%300 = load float, float* %6
%301 = icmp sgt i32 %12, 1
br i1 %301, label %302, label %369
302: ; preds = %298
%303 = add i32 %2, %1
%304 = add i32 %303, %0
%305 = add i32 %304, -1
%306 = add i32 %304, -2
%307 = and i32 %305, 3
%308 = icmp ult i32 %306, 3
br i1 %308, label %344, label %309
309: ; preds = %302
%310 = and i32 %305, -4
br label %311
311: ; preds = %311, %309
%312 = phi float* [ %3, %309 ], [ %337, %311 ]
%313 = phi float* [ %6, %309 ], [ %336, %311 ]
%314 = phi float [ %300, %309 ], [ %340, %311 ]
%315 = phi float [ %299, %309 ], [ %339, %311 ]
%316 = phi float* [ %14, %309 ], [ %341, %311 ]
%317 = phi i32 [ 0, %309 ], [ %342, %311 ]
%318 = getelementptr inbounds float, float* %313, i64 1
%319 = getelementptr inbounds float, float* %312, i64 1
%320 = fmul float %315, %314
%321 = load float, float* %319
%322 = load float, float* %318
%323 = getelementptr inbounds float, float* %316, i64 1
store float %320, float* %316
%324 = getelementptr inbounds float, float* %313, i64 2
%325 = getelementptr inbounds float, float* %312, i64 2
%326 = fmul float %321, %322
%327 = load float, float* %325
%328 = load float, float* %324
%329 = getelementptr inbounds float, float* %316, i64 2
store float %326, float* %323
%330 = getelementptr inbounds float, float* %313, i64 3
%331 = getelementptr inbounds float, float* %312, i64 3
%332 = fmul float %327, %328
%333 = load float, float* %331
%334 = load float, float* %330
%335 = getelementptr inbounds float, float* %316, i64 3
store float %332, float* %329
%336 = getelementptr inbounds float, float* %313, i64 4
%337 = getelementptr inbounds float, float* %312, i64 4
%338 = fmul float %333, %334
%339 = load float, float* %337
%340 = load float, float* %336
%341 = getelementptr inbounds float, float* %316, i64 4
store float %338, float* %335
%342 = add i32 %317, 4
%343 = icmp eq i32 %342, %310
br i1 %343, label %344, label %311
344: ; preds = %311, %302
%345 = phi float [ undef, %302 ], [ %339, %311 ]
%346 = phi float [ undef, %302 ], [ %340, %311 ]
%347 = phi float* [ undef, %302 ], [ %341, %311 ]
%348 = phi float* [ %3, %302 ], [ %337, %311 ]
%349 = phi float* [ %6, %302 ], [ %336, %311 ]
%350 = phi float [ %300, %302 ], [ %340, %311 ]
%351 = phi float [ %299, %302 ], [ %339, %311 ]
%352 = phi float* [ %14, %302 ], [ %341, %311 ]
%353 = icmp eq i32 %307, 0
br i1 %353, label %369, label %354
354: ; preds = %344, %354
%355 = phi float* [ %362, %354 ], [ %348, %344 ]
%356 = phi float* [ %361, %354 ], [ %349, %344 ]
%357 = phi float [ %365, %354 ], [ %350, %344 ]
%358 = phi float [ %364, %354 ], [ %351, %344 ]
%359 = phi float* [ %366, %354 ], [ %352, %344 ]
%360 = phi i32 [ %367, %354 ], [ 0, %344 ]
%361 = getelementptr inbounds float, float* %356, i64 1
%362 = getelementptr inbounds float, float* %355, i64 1
%363 = fmul float %358, %357
%364 = load float, float* %362
%365 = load float, float* %361
%366 = getelementptr inbounds float, float* %359, i64 1
store float %363, float* %359
%367 = add i32 %360, 1
%368 = icmp eq i32 %367, %307
br i1 %368, label %369, label %354
369: ; preds = %344, %354, %298
%370 = phi float* [ %14, %298 ], [ %347, %344 ], [ %366, %354 ]
%371 = phi float [ %299, %298 ], [ %345, %344 ], [ %364, %354 ]
%372 = phi float [ %300, %298 ], [ %346, %344 ], [ %365, %354 ]
%373 = fmul float %371, %372
store float %373, float* %370
%374 = icmp slt i32 %0, 0
br i1 %374, label %676, label %375
375: ; preds = %369
%376 = zext i32 %0 to i64
%377 = getelementptr inbounds float, float* %14, i64 %376
%378 = load float, float* %377
%379 = icmp sgt i32 %1, 1
br label %459
380: ; preds = %482
br i1 %374, label %676, label %381
381: ; preds = %380
%382 = icmp ult i32 %15, 8
br i1 %382, label %457, label %383
383: ; preds = %381
%384 = and i64 %16, 4294967288
%385 = insertelement <4 x float> poison, float %8, i64 0
%386 = shufflevector <4 x float> %385, <4 x float> poison, <4 x i32> zeroinitializer
%387 = insertelement <4 x float> poison, float %8, i64 0
%388 = shufflevector <4 x float> %387, <4 x float> poison, <4 x i32> zeroinitializer
%389 = add nsw i64 %384, -8
%390 = lshr exact i64 %389, 3
%391 = add nuw nsw i64 %390, 1
%392 = and i64 %391, 1
%393 = icmp eq i64 %389, 0
br i1 %393, label %435, label %394
394: ; preds = %383
%395 = and i64 %391, 4611686018427387902
br label %396
396: ; preds = %396, %394
%397 = phi i64 [ 0, %394 ], [ %432, %396 ]
%398 = phi i64 [ 0, %394 ], [ %433, %396 ]
%399 = getelementptr inbounds float, float* %7, i64 %397
%400 = bitcast float* %399 to <4 x float>*
%401 = load <4 x float>, <4 x float>* %400
%402 = getelementptr inbounds float, float* %399, i64 4
%403 = bitcast float* %402 to <4 x float>*
%404 = load <4 x float>, <4 x float>* %403
%405 = getelementptr inbounds float, float* %17, i64 %397
%406 = bitcast float* %405 to <4 x float>*
%407 = load <4 x float>, <4 x float>* %406
%408 = getelementptr inbounds float, float* %405, i64 4
%409 = bitcast float* %408 to <4 x float>*
%410 = load <4 x float>, <4 x float>* %409
%411 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %386, <4 x float> %401, <4 x float> %407)
%412 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %388, <4 x float> %404, <4 x float> %410)
%413 = bitcast float* %399 to <4 x float>*
store <4 x float> %411, <4 x float>* %413
%414 = bitcast float* %402 to <4 x float>*
store <4 x float> %412, <4 x float>* %414
%415 = or i64 %397, 8
%416 = getelementptr inbounds float, float* %7, i64 %415
%417 = bitcast float* %416 to <4 x float>*
%418 = load <4 x float>, <4 x float>* %417
%419 = getelementptr inbounds float, float* %416, i64 4
%420 = bitcast float* %419 to <4 x float>*
%421 = load <4 x float>, <4 x float>* %420
%422 = getelementptr inbounds float, float* %17, i64 %415
%423 = bitcast float* %422 to <4 x float>*
%424 = load <4 x float>, <4 x float>* %423
%425 = getelementptr inbounds float, float* %422, i64 4
%426 = bitcast float* %425 to <4 x float>*
%427 = load <4 x float>, <4 x float>* %426
%428 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %386, <4 x float> %418, <4 x float> %424)
%429 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %388, <4 x float> %421, <4 x float> %427)
%430 = bitcast float* %416 to <4 x float>*
store <4 x float> %428, <4 x float>* %430
%431 = bitcast float* %419 to <4 x float>*
store <4 x float> %429, <4 x float>* %431
%432 = add nuw i64 %397, 16
%433 = add i64 %398, 2
%434 = icmp eq i64 %433, %395
br i1 %434, label %435, label %396
435: ; preds = %396, %383
%436 = phi i64 [ 0, %383 ], [ %432, %396 ]
%437 = icmp eq i64 %392, 0
br i1 %437, label %455, label %438
438: ; preds = %435
%439 = getelementptr inbounds float, float* %7, i64 %436
%440 = bitcast float* %439 to <4 x float>*
%441 = load <4 x float>, <4 x float>* %440
%442 = getelementptr inbounds float, float* %439, i64 4
%443 = bitcast float* %442 to <4 x float>*
%444 = load <4 x float>, <4 x float>* %443
%445 = getelementptr inbounds float, float* %17, i64 %436
%446 = bitcast float* %445 to <4 x float>*
%447 = load <4 x float>, <4 x float>* %446
%448 = getelementptr inbounds float, float* %445, i64 4
%449 = bitcast float* %448 to <4 x float>*
%450 = load <4 x float>, <4 x float>* %449
%451 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %386, <4 x float> %441, <4 x float> %447)
%452 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %388, <4 x float> %444, <4 x float> %450)
%453 = bitcast float* %439 to <4 x float>*
store <4 x float> %451, <4 x float>* %453
%454 = bitcast float* %442 to <4 x float>*
store <4 x float> %452, <4 x float>* %454
br label %455
455: ; preds = %435, %438
%456 = icmp eq i64 %384, %16
br i1 %456, label %491, label %457
457: ; preds = %381, %455
%458 = phi i64 [ 0, %381 ], [ %384, %455 ]
br label %498
459: ; preds = %375, %482
%460 = phi i64 [ 0, %375 ], [ %489, %482 ]
%461 = phi float [ 0.000000e+00, %375 ], [ %487, %482 ]
%462 = phi float* [ %17, %375 ], [ %488, %482 ]
%463 = sub nsw i64 0, %460
%464 = getelementptr inbounds float, float* %377, i64 %463
%465 = fsub float %461, %461
%466 = load float, float* %464
br i1 %379, label %467, label %482
467: ; preds = %459, %467
%468 = phi float [ %480, %467 ], [ %378, %459 ]
%469 = phi float [ %479, %467 ], [ %466, %459 ]
%470 = phi float* [ %474, %467 ], [ %464, %459 ]
%471 = phi float* [ %475, %467 ], [ %377, %459 ]
%472 = phi float [ %477, %467 ], [ %465, %459 ]
%473 = phi i32 [ %478, %467 ], [ %15, %459 ]
%474 = getelementptr inbounds float, float* %470, i64 1
%475 = getelementptr inbounds float, float* %471, i64 1
%476 = fmul float %469, %468
%477 = fadd float %472, %476
%478 = add nsw i32 %473, 1
%479 = load float, float* %474
%480 = load float, float* %475
%481 = icmp slt i32 %478, %10
br i1 %481, label %467, label %482
482: ; preds = %467, %459
%483 = phi float [ %465, %459 ], [ %477, %467 ]
%484 = phi float [ %466, %459 ], [ %479, %467 ]
%485 = phi float [ %378, %459 ], [ %480, %467 ]
%486 = fmul float %484, %485
%487 = fadd float %483, %486
%488 = getelementptr inbounds float, float* %462, i64 1
store float %487, float* %462
%489 = add nuw nsw i64 %460, 1
%490 = icmp eq i64 %489, %16
br i1 %490, label %380, label %459
491: ; preds = %498, %455
br i1 %374, label %676, label %492
492: ; preds = %491
%493 = sext i32 %10 to i64
%494 = getelementptr inbounds float, float* %14, i64 %493
%495 = load float, float* %494
%496 = add nsw i32 %10, 1
%497 = icmp sgt i32 %2, 1
br label %613
498: ; preds = %457, %498
%499 = phi i64 [ %505, %498 ], [ %458, %457 ]
%500 = getelementptr inbounds float, float* %7, i64 %499
%501 = load float, float* %500
%502 = getelementptr inbounds float, float* %17, i64 %499
%503 = load float, float* %502
%504 = tail call float @llvm.fmuladd.f32(float %8, float %501, float %503)
store float %504, float* %500
%505 = add nuw nsw i64 %499, 1
%506 = icmp eq i64 %505, %16
br i1 %506, label %491, label %498
507: ; preds = %636
br i1 %374, label %676, label %508
508: ; preds = %507
%509 = icmp ult i32 %15, 8
br i1 %509, label %592, label %510
510: ; preds = %508
%511 = getelementptr float, float* %5, i64 %16
%512 = getelementptr float, float* %7, i64 %16
%513 = icmp ugt float* %512, %5
%514 = icmp ugt float* %511, %7
%515 = and i1 %513, %514
br i1 %515, label %592, label %516
516: ; preds = %510
%517 = and i64 %16, 4294967288
%518 = add nsw i64 %517, -8
%519 = lshr exact i64 %518, 3
%520 = add nuw nsw i64 %519, 1
%521 = and i64 %520, 1
%522 = icmp eq i64 %518, 0
br i1 %522, label %568, label %523
523: ; preds = %516
%524 = and i64 %520, 4611686018427387902
br label %525
525: ; preds = %525, %523
%526 = phi i64 [ 0, %523 ], [ %565, %525 ]
%527 = phi i64 [ 0, %523 ], [ %566, %525 ]
%528 = getelementptr inbounds float, float* %7, i64 %526
%529 = bitcast float* %528 to <4 x float>*
%530 = load <4 x float>, <4 x float>* %529
%531 = getelementptr inbounds float, float* %528, i64 4
%532 = bitcast float* %531 to <4 x float>*
%533 = load <4 x float>, <4 x float>* %532
%534 = getelementptr inbounds float, float* %18, i64 %526
%535 = bitcast float* %534 to <4 x float>*
%536 = load <4 x float>, <4 x float>* %535
%537 = getelementptr inbounds float, float* %534, i64 4
%538 = bitcast float* %537 to <4 x float>*
%539 = load <4 x float>, <4 x float>* %538
%540 = fadd <4 x float> %530, %536
%541 = fadd <4 x float> %533, %539
%542 = getelementptr inbounds float, float* %5, i64 %526
%543 = bitcast float* %542 to <4 x float>*
store <4 x float> %540, <4 x float>* %543
%544 = getelementptr inbounds float, float* %542, i64 4
%545 = bitcast float* %544 to <4 x float>*
store <4 x float> %541, <4 x float>* %545
%546 = or i64 %526, 8
%547 = getelementptr inbounds float, float* %7, i64 %546
%548 = bitcast float* %547 to <4 x float>*
%549 = load <4 x float>, <4 x float>* %548
%550 = getelementptr inbounds float, float* %547, i64 4
%551 = bitcast float* %550 to <4 x float>*
%552 = load <4 x float>, <4 x float>* %551
%553 = getelementptr inbounds float, float* %18, i64 %546
%554 = bitcast float* %553 to <4 x float>*
%555 = load <4 x float>, <4 x float>* %554
%556 = getelementptr inbounds float, float* %553, i64 4
%557 = bitcast float* %556 to <4 x float>*
%558 = load <4 x float>, <4 x float>* %557
%559 = fadd <4 x float> %549, %555
%560 = fadd <4 x float> %552, %558
%561 = getelementptr inbounds float, float* %5, i64 %546
%562 = bitcast float* %561 to <4 x float>*
store <4 x float> %559, <4 x float>* %562
%563 = getelementptr inbounds float, float* %561, i64 4
%564 = bitcast float* %563 to <4 x float>*
store <4 x float> %560, <4 x float>* %564
%565 = add nuw i64 %526, 16
%566 = add i64 %527, 2
%567 = icmp eq i64 %566, %524
br i1 %567, label %568, label %525
568: ; preds = %525, %516
%569 = phi i64 [ 0, %516 ], [ %565, %525 ]
%570 = icmp eq i64 %521, 0
br i1 %570, label %590, label %571
571: ; preds = %568
%572 = getelementptr inbounds float, float* %7, i64 %569
%573 = bitcast float* %572 to <4 x float>*
%574 = load <4 x float>, <4 x float>* %573
%575 = getelementptr inbounds float, float* %572, i64 4
%576 = bitcast float* %575 to <4 x float>*
%577 = load <4 x float>, <4 x float>* %576
%578 = getelementptr inbounds float, float* %18, i64 %569
%579 = bitcast float* %578 to <4 x float>*
%580 = load <4 x float>, <4 x float>* %579
%581 = getelementptr inbounds float, float* %578, i64 4
%582 = bitcast float* %581 to <4 x float>*
%583 = load <4 x float>, <4 x float>* %582
%584 = fadd <4 x float> %574, %580
%585 = fadd <4 x float> %577, %583
%586 = getelementptr inbounds float, float* %5, i64 %569
%587 = bitcast float* %586 to <4 x float>*
store <4 x float> %584, <4 x float>* %587
%588 = getelementptr inbounds float, float* %586, i64 4
%589 = bitcast float* %588 to <4 x float>*
store <4 x float> %585, <4 x float>* %589
br label %590
590: ; preds = %568, %571
%591 = icmp eq i64 %517, %16
br i1 %591, label %676, label %592
592: ; preds = %510, %508, %590
%593 = phi i64 [ 0, %510 ], [ 0, %508 ], [ %517, %590 ]
%594 = xor i64 %593, -1
%595 = add nsw i64 %594, %16
%596 = and i64 %16, 3
%597 = icmp eq i64 %596, 0
br i1 %597, label %610, label %598
598: ; preds = %592, %598
%599 = phi i64 [ %607, %598 ], [ %593, %592 ]
%600 = phi i64 [ %608, %598 ], [ 0, %592 ]
%601 = getelementptr inbounds float, float* %7, i64 %599
%602 = load float, float* %601
%603 = getelementptr inbounds float, float* %18, i64 %599
%604 = load float, float* %603
%605 = fadd float %602, %604
%606 = getelementptr inbounds float, float* %5, i64 %599
store float %605, float* %606
%607 = add nuw nsw i64 %599, 1
%608 = add i64 %600, 1
%609 = icmp eq i64 %608, %596
br i1 %609, label %610, label %598
610: ; preds = %598, %592
%611 = phi i64 [ %593, %592 ], [ %607, %598 ]
%612 = icmp ult i64 %595, 3
br i1 %612, label %676, label %645
613: ; preds = %492, %636
%614 = phi i64 [ 0, %492 ], [ %643, %636 ]
%615 = phi float [ 0.000000e+00, %492 ], [ %641, %636 ]
%616 = phi float* [ %18, %492 ], [ %642, %636 ]
%617 = sub nsw i64 0, %614
%618 = getelementptr inbounds float, float* %494, i64 %617
%619 = fsub float %615, %615
%620 = load float, float* %618
br i1 %497, label %621, label %636
621: ; preds = %613, %621
%622 = phi i32 [ %634, %621 ], [ %496, %613 ]
%623 = phi float [ %633, %621 ], [ %495, %613 ]
%624 = phi float [ %632, %621 ], [ %620, %613 ]
%625 = phi float* [ %628, %621 ], [ %618, %613 ]
%626 = phi float* [ %629, %621 ], [ %494, %613 ]
%627 = phi float [ %631, %621 ], [ %619, %613 ]
%628 = getelementptr inbounds float, float* %625, i64 1
%629 = getelementptr inbounds float, float* %626, i64 1
%630 = fmul float %624, %623
%631 = fadd float %627, %630
%632 = load float, float* %628
%633 = load float, float* %629
%634 = add nsw i32 %622, 1
%635 = icmp slt i32 %634, %12
br i1 %635, label %621, label %636
636: ; preds = %621, %613
%637 = phi float [ %619, %613 ], [ %631, %621 ]
%638 = phi float [ %620, %613 ], [ %632, %621 ]
%639 = phi float [ %495, %613 ], [ %633, %621 ]
%640 = fmul float %638, %639
%641 = fadd float %637, %640
%642 = getelementptr inbounds float, float* %616, i64 1
store float %641, float* %616
%643 = add nuw nsw i64 %614, 1
%644 = icmp eq i64 %643, %16
br i1 %644, label %507, label %613
645: ; preds = %610, %645
%646 = phi i64 [ %674, %645 ], [ %611, %610 ]
%647 = getelementptr inbounds float, float* %7, i64 %646
%648 = load float, float* %647
%649 = getelementptr inbounds float, float* %18, i64 %646
%650 = load float, float* %649
%651 = fadd float %648, %650
%652 = getelementptr inbounds float, float* %5, i64 %646
store float %651, float* %652
%653 = add nuw nsw i64 %646, 1
%654 = getelementptr inbounds float, float* %7, i64 %653
%655 = load float, float* %654
%656 = getelementptr inbounds float, float* %18, i64 %653
%657 = load float, float* %656
%658 = fadd float %655, %657
%659 = getelementptr inbounds float, float* %5, i64 %653
store float %658, float* %659
%660 = add nuw nsw i64 %646, 2
%661 = getelementptr inbounds float, float* %7, i64 %660
%662 = load float, float* %661
%663 = getelementptr inbounds float, float* %18, i64 %660
%664 = load float, float* %663
%665 = fadd float %662, %664
%666 = getelementptr inbounds float, float* %5, i64 %660
store float %665, float* %666
%667 = add nuw nsw i64 %646, 3
%668 = getelementptr inbounds float, float* %7, i64 %667
%669 = load float, float* %668
%670 = getelementptr inbounds float, float* %18, i64 %667
%671 = load float, float* %670
%672 = fadd float %669, %671
%673 = getelementptr inbounds float, float* %5, i64 %667
store float %672, float* %673
%674 = add nuw nsw i64 %646, 4
%675 = icmp eq i64 %674, %16
br i1 %675, label %676, label %645
676: ; preds = %610, %645, %590, %369, %380, %491, %507
%677 = load float, float* %5
%678 = fmul float %677, 0x3FF0100000000000
store float %678, float* %5
ret void
}