void daub4(float b[], unsigned long n, int isign) {
  float wksp[4097];
  float *a = b - 1;
  unsigned long nh, nh1, i, j;
  if (n < 4) {
    return;
  }
  nh1 = (nh = n >> 1) + 1;
  if (isign >= 0) {
    for (i = 1, j = 1; j <= n - 3; j += 2, i++) {
      wksp[i] = 0.4829629131445341 * a[j] + 0.8365163037378079 * a[j + 1] +
                0.2241438680420134 * a[j + 2] + -0.1294095225512604 * a[j + 3];
      wksp[i + nh] =
          -0.1294095225512604 * a[j] - 0.2241438680420134 * a[j + 1] +
          0.8365163037378079 * a[j + 2] - 0.4829629131445341 * a[j + 3];
    }
    wksp[i] = 0.4829629131445341 * a[n - 1] + 0.8365163037378079 * a[n] +
              0.2241438680420134 * a[1] + -0.1294095225512604 * a[2];
    wksp[i + nh] = -0.1294095225512604 * a[n - 1] - 0.2241438680420134 * a[n] +
                   0.8365163037378079 * a[1] - 0.4829629131445341 * a[2];
  } else {
    wksp[1] = 0.2241438680420134 * a[nh] + 0.8365163037378079 * a[n] +
              0.4829629131445341 * a[1] + -0.1294095225512604 * a[nh1];
    wksp[2] = -0.1294095225512604 * a[nh] - 0.4829629131445341 * a[n] +
              0.8365163037378079 * a[1] - 0.2241438680420134 * a[nh1];
    for (i = 1, j = 3; i < nh; i++) {
      wksp[j++] = 0.2241438680420134 * a[i] + 0.8365163037378079 * a[i + nh] +
                  0.4829629131445341 * a[i + 1] +
                  -0.1294095225512604 * a[i + nh1];
      wksp[j++] = -0.1294095225512604 * a[i] - 0.4829629131445341 * a[i + nh] +
                  0.8365163037378079 * a[i + 1] -
                  0.2241438680420134 * a[i + nh1];
    }
  }
  for (i = 1; i <= n; i++) {
    a[i] = wksp[i];
  }
}


x86 assembly (clang, -O0):
<daub4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3fd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x4028(%rbp)
cmpq   $0x4,-0x10(%rbp)
jae    1135 <daub4+0x35>
jmp    1817 <daub4+0x717>
mov    -0x10(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x4030(%rbp)
add    $0x1,%rax
mov    %rax,-0x4038(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     1487 <daub4+0x387>
movq   $0x1,-0x4040(%rbp)
movq   $0x1,-0x4048(%rbp)
mov    -0x4048(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x3,%rcx
cmp    %rcx,%rax
ja     132c <daub4+0x22c>
mov    -0x4028(%rbp),%rax
mov    -0x4048(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x4048(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xe4a(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xe4e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x4048(%rbp),%rcx
movss  0x8(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xe2e(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x4028(%rbp),%rax
mov    -0x4048(%rbp),%rcx
movss  0xc(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdf6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x4040(%rbp),%rax
movss  %xmm0,-0x4020(%rbp,%rax,4)
ff ff
mov    -0x4028(%rbp),%rax
mov    -0x4048(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x4048(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xdb3(%rip),%xmm1
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xd80(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x4048(%rbp),%rcx
movss  0x8(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xd50(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x4028(%rbp),%rax
mov    -0x4048(%rbp),%rcx
movss  0xc(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd48(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x4040(%rbp),%rax
add    -0x4030(%rbp),%rax
movss  %xmm0,-0x4020(%rbp,%rax,4)
ff ff
mov    -0x4048(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x4048(%rbp)
mov    -0x4040(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x4040(%rbp)
jmp    116f <daub4+0x6f>
mov    -0x4028(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xca8(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xcac(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x4028(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xc94(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x4028(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc64(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x4040(%rbp),%rax
movss  %xmm0,-0x4020(%rbp,%rax,4)
ff ff
mov    -0x4028(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xc24(%rip),%xmm1
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xbf1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x4028(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xbc9(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x4028(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbc9(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x4040(%rbp),%rax
add    -0x4030(%rbp),%rax
movss  %xmm0,-0x4020(%rbp,%rax,4)
ff ff
jmp    17c1 <daub4+0x6c1>
mov    -0x4028(%rbp),%rax
mov    -0x4030(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xb4e(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xb5a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x4028(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xb32(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x4028(%rbp),%rax
mov    -0x4038(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb03(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x401c(%rbp)
ff
mov    -0x4028(%rbp),%rax
mov    -0x4030(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xac4(%rip),%xmm1
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xa99(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x4028(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xa71(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x4028(%rbp),%rax
mov    -0x4038(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa42(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4018(%rbp)
ff
movq   $0x1,-0x4040(%rbp)
movq   $0x3,-0x4048(%rbp)
mov    -0x4040(%rbp),%rax
cmp    -0x4030(%rbp),%rax
jae    17bc <daub4+0x6bc>
mov    -0x4028(%rbp),%rax
mov    -0x4040(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x4040(%rbp),%rcx
add    -0x4030(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x9cf(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x9db(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x4040(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x9ab(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x4028(%rbp),%rax
mov    -0x4040(%rbp),%rcx
add    -0x4038(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x975(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x4048(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x4048(%rbp)
movss  %xmm0,-0x4020(%rbp,%rax,4)
ff ff
mov    -0x4028(%rbp),%rax
mov    -0x4040(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x4040(%rbp),%rcx
add    -0x4030(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x916(%rip),%xmm1
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x8eb(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x4028(%rbp),%rax
mov    -0x4040(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x8bb(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x4028(%rbp),%rax
mov    -0x4040(%rbp),%rcx
add    -0x4038(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x885(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x4048(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x4048(%rbp)
movss  %xmm0,-0x4020(%rbp,%rax,4)
ff ff
mov    -0x4040(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x4040(%rbp)
jmp    15e8 <daub4+0x4e8>
jmp    17c1 <daub4+0x6c1>
movq   $0x1,-0x4040(%rbp)
mov    -0x4040(%rbp),%rax
cmp    -0x10(%rbp),%rax
ja     1817 <daub4+0x717>
mov    -0x4040(%rbp),%rax
movss  -0x4020(%rbp,%rax,4),%xmm0
ff ff
mov    -0x4028(%rbp),%rax
mov    -0x4040(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4040(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x4040(%rbp)
jmp    17cc <daub4+0x6cc>
add    $0x3fd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<daub4>:
cmp    $0x4,%rsi
jb     17fe <daub4+0x6ee>
push   %r15
push   %r14
push   %rbx
sub    $0x4020,%rsp
mov    %rsi,%r15
shr    %r15
test   %edx,%edx
js     1162 <daub4+0x52>
lea    -0x4(%rsi),%rax
mov    %rax,%r14
shr    %r14
lea    0x2(%r14),%r9
movss  (%rdi),%xmm13
mov    $0x1,%r8d
cmp    $0x6,%rax
jae    1449 <daub4+0x339>
movaps %xmm13,%xmm1
mov    $0x1,%r10d
jmp    1634 <daub4+0x524>
movss  -0x4(%rdi,%r15,4),%xmm0
movss  (%rdi,%r15,4),%xmm1
cvtss2sd %xmm0,%xmm3
movss  -0x4(%rdi,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm8
movsd  0xe79(%rip),%xmm14
movaps %xmm8,%xmm2
mulsd  %xmm14,%xmm2
movsd  0xe70(%rip),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm2,%xmm5
movss  (%rdi),%xmm7
cvtss2sd %xmm7,%xmm6
movsd  0xe60(%rip),%xmm2
mulsd  %xmm6,%xmm2
addsd  %xmm5,%xmm2
cvtss2sd %xmm1,%xmm4
movsd  0xe53(%rip),%xmm15
movaps %xmm4,%xmm5
mulsd  %xmm15,%xmm5
addsd  %xmm2,%xmm5
cvtsd2ss %xmm5,%xmm5
movss  %xmm5,0x14(%rsp)
mulsd  0xe3c(%rip),%xmm8
mulsd  %xmm15,%xmm3
addsd  %xmm8,%xmm3
mulsd  %xmm14,%xmm6
addsd  %xmm3,%xmm6
mulsd  0xe29(%rip),%xmm4
addsd  %xmm6,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm3,0x18(%rsp)
lea    -0x1(%r15),%rbx
mov    $0x1,%r8d
mov    $0x3,%r9d
cmp    $0x2,%rbx
jb     136e <daub4+0x25e>
lea    -0x2(%r15),%rax
mov    $0x8,%ecx
mul    %rcx
lea    0x1c(%rsp),%r10
seto   %cl
lea    (%rsp,%rax,1),%rdx
add    $0x1c,%rdx
cmp    %r10,%rdx
jb     136e <daub4+0x25e>
test   %cl,%cl
jne    136e <daub4+0x25e>
lea    0x20(%rsp),%rdx
add    %rsp,%rax
add    $0x20,%rax
cmp    %rdx,%rax
jb     136e <daub4+0x25e>
test   %cl,%cl
jne    136e <daub4+0x25e>
mov    %rbx,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rbx,%rbx,1),%r9
or     $0x3,%r9
mov    %rbx,%r8
or     $0x1,%r8
shufps $0x0,%xmm7,%xmm7
lea    (%rdi,%r15,4),%rcx
add    $0x4,%rcx
xor    %edx,%edx
movapd 0xd8f(%rip),%xmm12
movapd 0xd96(%rip),%xmm8
movapd 0xd9d(%rip),%xmm9
movapd 0xda4(%rip),%xmm13
movapd 0xdab(%rip),%xmm10
movapd 0xdb2(%rip),%xmm11
xchg   %ax,%ax
cvtps2pd -0x4(%rcx,%rdx,4),%xmm4
movaps %xmm7,%xmm3
movapd %xmm4,%xmm5
mulpd  %xmm12,%xmm5
movsd  0x4(%rdi,%rdx,4),%xmm7
movaps %xmm7,%xmm2
shufps $0x10,%xmm3,%xmm2
shufps $0xe2,%xmm3,%xmm2
cvtps2pd %xmm2,%xmm2
movapd %xmm2,%xmm3
mulpd  %xmm8,%xmm3
addpd  %xmm5,%xmm3
cvtps2pd %xmm7,%xmm6
movapd %xmm6,%xmm5
mulpd  %xmm9,%xmm5
addpd  %xmm3,%xmm5
cvtps2pd (%rcx,%rdx,4),%xmm0
movapd %xmm0,%xmm3
mulpd  %xmm13,%xmm3
addpd  %xmm5,%xmm3
cvtpd2ps %xmm3,%xmm3
mulpd  %xmm10,%xmm4
mulpd  %xmm13,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm12,%xmm6
addpd  %xmm2,%xmm6
mulpd  %xmm11,%xmm0
addpd  %xmm6,%xmm0
cvtpd2ps %xmm0,%xmm0
unpcklps %xmm0,%xmm3
movupd %xmm3,0x1c(%rsp,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    12d0 <daub4+0x1c0>
cmp    %rax,%rbx
je     17d4 <daub4+0x6c4>
shufps $0x55,%xmm7,%xmm7
lea    (%rsp,%r9,4),%rax
add    $0x14,%rax
lea    (%r8,%r15,1),%rcx
sub    %r8,%r15
lea    (%rdi,%rcx,4),%rcx
lea    (%rdi,%r8,4),%rdx
xor    %ebx,%ebx
movsd  0xc78(%rip),%xmm8
movsd  0xc77(%rip),%xmm9
movsd  0xc7e(%rip),%xmm10
movsd  0xc7e(%rip),%xmm6
nopw   0x0(%rax,%rax,1)
xorps  %xmm3,%xmm3
cvtss2sd %xmm7,%xmm3
movss  -0x4(%rcx,%rbx,4),%xmm2
movss  (%rcx,%rbx,4),%xmm1
cvtss2sd %xmm2,%xmm2
movaps %xmm2,%xmm7
mulsd  %xmm14,%xmm7
movaps %xmm3,%xmm0
mulsd  %xmm8,%xmm0
addsd  %xmm7,%xmm0
movss  (%rdx,%rbx,4),%xmm7
xorps  %xmm5,%xmm5
cvtss2sd %xmm7,%xmm5
movaps %xmm5,%xmm4
mulsd  %xmm9,%xmm4
addsd  %xmm0,%xmm4
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movaps %xmm0,%xmm1
mulsd  %xmm15,%xmm1
addsd  %xmm4,%xmm1
cvtsd2ss %xmm1,%xmm1
mulsd  %xmm10,%xmm2
mulsd  %xmm15,%xmm3
addsd  %xmm2,%xmm3
mulsd  %xmm14,%xmm5
addsd  %xmm3,%xmm5
mulsd  %xmm6,%xmm0
addsd  %xmm5,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm1,-0x4(%rax,%rbx,8)
movss  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    13b0 <daub4+0x2a0>
jmp    17d4 <daub4+0x6c4>
lea    0x14(%rsp),%rcx
lea    (%rsp,%r15,4),%rax
add    $0x14,%rax
lea    (%r15,%r14,1),%rdx
lea    (%rsp,%rdx,4),%rdx
add    $0x18,%rdx
cmp    %rdx,%rcx
jae    1482 <daub4+0x372>
lea    (%rsp,%r9,4),%rcx
add    $0x10,%rcx
movaps %xmm13,%xmm1
mov    $0x1,%r10d
cmp    %rcx,%rax
jb     1634 <daub4+0x524>
lea    0x1(%r14),%r11
mov    %r11,%rbx
and    $0xfffffffffffffffc,%rbx
lea    (%rbx,%rbx,1),%r8
add    $0x1,%r8
lea    0x1(%rbx),%r10
movaps %xmm13,(%rsp)
movaps %xmm13,%xmm1
shufps $0x0,%xmm13,%xmm1
xor    %edx,%edx
movapd 0xb7e(%rip),%xmm13
movapd 0xba5(%rip),%xmm14
movapd 0xbac(%rip),%xmm12
movapd 0xb73(%rip),%xmm11
nopl   (%rax)
movss  0x1c(%rdi,%rdx,8),%xmm0
movss  0x14(%rdi,%rdx,8),%xmm2
unpcklps %xmm0,%xmm2
movss  0xc(%rdi,%rdx,8),%xmm0
movss  0x4(%rdi,%rdx,8),%xmm3
unpcklps %xmm0,%xmm3
movlhps %xmm2,%xmm3
cvtps2pd %xmm3,%xmm15
cvtps2pd %xmm2,%xmm8
movaps %xmm1,%xmm2
movapd %xmm15,%xmm7
mulpd  %xmm13,%xmm7
movapd %xmm8,%xmm3
mulpd  %xmm13,%xmm3
movups 0x18(%rdi,%rdx,8),%xmm0
movups 0x8(%rdi,%rdx,8),%xmm5
movaps %xmm5,%xmm1
shufps $0x88,%xmm0,%xmm1
shufps $0xc7,%xmm5,%xmm2
shufps $0xdd,%xmm0,%xmm5
shufps $0x98,%xmm1,%xmm2
cvtps2pd %xmm2,%xmm6
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm9
movapd %xmm9,%xmm4
movapd 0xb0c(%rip),%xmm2
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movapd %xmm6,%xmm3
mulpd  %xmm2,%xmm3
addpd  %xmm7,%xmm3
cvtps2pd %xmm1,%xmm10
movaps %xmm0,%xmm2
shufps $0xe8,%xmm0,%xmm2
cvtps2pd %xmm2,%xmm2
movapd %xmm10,%xmm7
mulpd  %xmm11,%xmm7
addpd  %xmm3,%xmm7
movapd %xmm2,%xmm3
mulpd  %xmm11,%xmm3
cvtps2pd %xmm5,%xmm5
addpd  %xmm4,%xmm3
shufps $0xed,%xmm0,%xmm0
cvtps2pd %xmm0,%xmm0
movapd %xmm0,%xmm4
mulpd  %xmm14,%xmm4
addpd  %xmm3,%xmm4
movapd %xmm5,%xmm3
mulpd  %xmm14,%xmm3
addpd  %xmm7,%xmm3
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm4,%xmm3
movupd %xmm3,0x14(%rsp,%rdx,4)
movapd 0xac1(%rip),%xmm3
mulpd  %xmm3,%xmm8
mulpd  %xmm14,%xmm9
addpd  %xmm8,%xmm9
mulpd  %xmm3,%xmm15
mulpd  %xmm14,%xmm6
addpd  %xmm15,%xmm6
mulpd  %xmm13,%xmm10
addpd  %xmm6,%xmm10
mulpd  %xmm13,%xmm2
addpd  %xmm9,%xmm2
mulpd  %xmm12,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm12,%xmm5
addpd  %xmm10,%xmm5
cvtpd2ps %xmm5,%xmm2
cvtpd2ps %xmm0,%xmm0
unpcklpd %xmm0,%xmm2
movupd %xmm2,(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    14d0 <daub4+0x3c0>
cmp    %rbx,%r11
movaps (%rsp),%xmm13
je     172a <daub4+0x61a>
shufps $0xff,%xmm1,%xmm1
lea    (%rdi,%r8,4),%rax
add    $0x8,%rax
lea    (%rsp,%r10,4),%rdx
add    $0x10,%rdx
lea    (%rdx,%r15,4),%r8
mov    %r14,%rcx
sub    %r10,%rcx
add    $0x2,%rcx
xor    %ebx,%ebx
movsd  0x9a3(%rip),%xmm12
movsd  0x9aa(%rip),%xmm8
movsd  0x999(%rip),%xmm9
movsd  0x9a1(%rip),%xmm4
movsd  0x9a8(%rip),%xmm10
movsd  0x997(%rip),%xmm11
nopl   0x0(%rax)
xorps  %xmm5,%xmm5
cvtss2sd %xmm1,%xmm5
movss  -0x8(%rax,%rbx,8),%xmm2
movss  -0x4(%rax,%rbx,8),%xmm1
xorps  %xmm3,%xmm3
cvtss2sd %xmm2,%xmm3
movaps %xmm3,%xmm2
mulsd  %xmm12,%xmm2
movaps %xmm5,%xmm7
mulsd  %xmm8,%xmm7
addsd  %xmm2,%xmm7
xorps  %xmm6,%xmm6
cvtss2sd %xmm1,%xmm6
movaps %xmm6,%xmm2
mulsd  %xmm9,%xmm2
addsd  %xmm7,%xmm2
movss  (%rax,%rbx,8),%xmm7
xorps  %xmm0,%xmm0
cvtss2sd %xmm7,%xmm0
movaps %xmm0,%xmm7
mulsd  %xmm4,%xmm7
addsd  %xmm2,%xmm7
xorps  %xmm2,%xmm2
cvtsd2ss %xmm7,%xmm2
mulsd  %xmm10,%xmm3
mulsd  %xmm4,%xmm5
addsd  %xmm3,%xmm5
mulsd  %xmm12,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm11,%xmm0
addsd  %xmm6,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm2,(%rdx,%rbx,4)
movss  %xmm0,(%r8,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rcx
jne    1690 <daub4+0x580>
movss  -0x8(%rdi,%rsi,4),%xmm0
movss  -0x4(%rdi,%rsi,4),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
movsd  0x8ba(%rip),%xmm2
movaps %xmm1,%xmm3
mulsd  %xmm2,%xmm3
movsd  0x8bb(%rip),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm13,%xmm3
movsd  0x89b(%rip),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movss  0x4(%rdi),%xmm4
cvtss2sd %xmm4,%xmm4
movsd  0x892(%rip),%xmm6
movaps %xmm4,%xmm7
mulsd  %xmm6,%xmm7
addsd  %xmm5,%xmm7
xorps  %xmm5,%xmm5
cvtsd2ss %xmm7,%xmm5
mulsd  0x888(%rip),%xmm1
movss  %xmm5,0x18(%rsp,%r14,4)
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
mulsd  0x861(%rip),%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm0,%xmm0
cvtsd2ss %xmm4,%xmm0
add    %r15,%r9
movss  %xmm0,0x10(%rsp,%r9,4)
lea    0x14(%rsp),%rax
cmp    $0x2,%rsi
mov    $0x1,%edx
cmovae %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rsi
call   1030 <memcpy@plt>
add    $0x4020,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @daub4(float* nocapture %0, i64 %1, i32 %2) {
%4 = bitcast float* %0 to i8*
%5 = alloca [4097 x float]
%6 = bitcast [4097 x float]* %5 to i8*
%7 = getelementptr inbounds float, float* %0, i64 -1
%8 = icmp ult i64 %1, 4
br i1 %8, label %279, label %9
9: ; preds = %3
%10 = lshr i64 %1, 1
%11 = icmp sgt i32 %2, -1
br i1 %11, label %12, label %148
12: ; preds = %9
%13 = add i64 %1, -4
%14 = lshr i64 %13, 1
%15 = add nuw i64 %14, 2
%16 = load float, float* %0
%17 = add nuw i64 %14, 1
%18 = icmp ult i64 %13, 6
br i1 %18, label %88, label %19
19: ; preds = %12
%20 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 1
%21 = getelementptr [4097 x float], [4097 x float]* %5, i64 0, i64 %15
%22 = add nuw i64 %10, 1
%23 = getelementptr [4097 x float], [4097 x float]* %5, i64 0, i64 %22
%24 = add nuw i64 %10, %14
%25 = add i64 %24, 2
%26 = getelementptr [4097 x float], [4097 x float]* %5, i64 0, i64 %25
%27 = icmp ult float* %20, %26
%28 = icmp ult float* %23, %21
%29 = and i1 %27, %28
br i1 %29, label %88, label %30
30: ; preds = %19
%31 = and i64 %17, -4
%32 = shl i64 %31, 1
%33 = or i64 %32, 1
%34 = or i64 %31, 1
%35 = insertelement <4 x float> poison, float %16, i64 3
br label %36
36: ; preds = %36, %30
%37 = phi i64 [ 0, %30 ], [ %83, %36 ]
%38 = phi <4 x float> [ %35, %30 ], [ %63, %36 ]
%39 = shl i64 %37, 1
%40 = or i64 %39, 1
%41 = or i64 %39, 3
%42 = or i64 %39, 5
%43 = or i64 %39, 7
%44 = or i64 %37, 1
%45 = getelementptr inbounds float, float* %0, i64 %40
%46 = getelementptr inbounds float, float* %0, i64 %41
%47 = getelementptr inbounds float, float* %0, i64 %42
%48 = getelementptr inbounds float, float* %0, i64 %43
%49 = load float, float* %45
%50 = load float, float* %46
%51 = load float, float* %47
%52 = load float, float* %48
%53 = insertelement <4 x float> poison, float %49, i64 0
%54 = insertelement <4 x float> %53, float %50, i64 1
%55 = insertelement <4 x float> %54, float %51, i64 2
%56 = insertelement <4 x float> %55, float %52, i64 3
%57 = fpext <4 x float> %56 to <4 x double>
%58 = fmul <4 x double> %57, <double 0x3FEAC4BDD6E3FD71, double 0x3FEAC4BDD6E3FD71, double 0x3FEAC4BDD6E3FD71, double 0x3FEAC4BDD6E3FD71>
%59 = or i64 %39, 3
%60 = getelementptr inbounds float, float* %7, i64 %59
%61 = bitcast float* %60 to <8 x float>*
%62 = load <8 x float>, <8 x float>* %61
%63 = shufflevector <8 x float> %62, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%64 = shufflevector <8 x float> %62, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%65 = shufflevector <4 x float> %38, <4 x float> %63, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%66 = fpext <4 x float> %65 to <4 x double>
%67 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %66, <4 x double> <double 0x3FDEE8DD4748BF14, double 0x3FDEE8DD4748BF14, double 0x3FDEE8DD4748BF14, double 0x3FDEE8DD4748BF14>, <4 x double> %58)
%68 = fpext <4 x float> %63 to <4 x double>
%69 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %68, <4 x double> <double 0x3FCCB0BF0B6B7109, double 0x3FCCB0BF0B6B7109, double 0x3FCCB0BF0B6B7109, double 0x3FCCB0BF0B6B7109>, <4 x double> %67)
%70 = fpext <4 x float> %64 to <4 x double>
%71 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %70, <4 x double> <double 0xBFC0907DC1930691, double 0xBFC0907DC1930691, double 0xBFC0907DC1930691, double 0xBFC0907DC1930691>, <4 x double> %69)
%72 = fptrunc <4 x double> %71 to <4 x float>
%73 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 %44
%74 = bitcast float* %73 to <4 x float>*
store <4 x float> %72, <4 x float>* %74
%75 = fmul <4 x double> %57, <double 0xBFCCB0BF0B6B7109, double 0xBFCCB0BF0B6B7109, double 0xBFCCB0BF0B6B7109, double 0xBFCCB0BF0B6B7109>
%76 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %66, <4 x double> <double 0xBFC0907DC1930691, double 0xBFC0907DC1930691, double 0xBFC0907DC1930691, double 0xBFC0907DC1930691>, <4 x double> %75)
%77 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %68, <4 x double> <double 0x3FEAC4BDD6E3FD71, double 0x3FEAC4BDD6E3FD71, double 0x3FEAC4BDD6E3FD71, double 0x3FEAC4BDD6E3FD71>, <4 x double> %76)
%78 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %70, <4 x double> <double 0xBFDEE8DD4748BF14, double 0xBFDEE8DD4748BF14, double 0xBFDEE8DD4748BF14, double 0xBFDEE8DD4748BF14>, <4 x double> %77)
%79 = fptrunc <4 x double> %78 to <4 x float>
%80 = add nuw i64 %44, %10
%81 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 %80
%82 = bitcast float* %81 to <4 x float>*
store <4 x float> %79, <4 x float>* %82
%83 = add nuw i64 %37, 4
%84 = icmp eq i64 %83, %31
br i1 %84, label %85, label %36
85: ; preds = %36
%86 = icmp eq i64 %17, %31
%87 = extractelement <8 x float> %62, i64 6
br i1 %86, label %123, label %88
88: ; preds = %19, %12, %85
%89 = phi float [ %87, %85 ], [ %16, %12 ], [ %16, %19 ]
%90 = phi i64 [ %33, %85 ], [ 1, %12 ], [ 1, %19 ]
%91 = phi i64 [ %34, %85 ], [ 1, %12 ], [ 1, %19 ]
br label %92
92: ; preds = %88, %92
%93 = phi float [ %104, %92 ], [ %89, %88 ]
%94 = phi i64 [ %102, %92 ], [ %90, %88 ]
%95 = phi i64 [ %121, %92 ], [ %91, %88 ]
%96 = fpext float %93 to double
%97 = getelementptr inbounds float, float* %0, i64 %94
%98 = load float, float* %97
%99 = fpext float %98 to double
%100 = fmul double %99, 0x3FEAC4BDD6E3FD71
%101 = tail call double @llvm.fmuladd.f64(double %96, double 0x3FDEE8DD4748BF14, double %100)
%102 = add nuw i64 %94, 2
%103 = getelementptr inbounds float, float* %7, i64 %102
%104 = load float, float* %103
%105 = fpext float %104 to double
%106 = tail call double @llvm.fmuladd.f64(double %105, double 0x3FCCB0BF0B6B7109, double %101)
%107 = add i64 %94, 3
%108 = getelementptr inbounds float, float* %7, i64 %107
%109 = load float, float* %108
%110 = fpext float %109 to double
%111 = tail call double @llvm.fmuladd.f64(double %110, double 0xBFC0907DC1930691, double %106)
%112 = fptrunc double %111 to float
%113 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 %95
store float %112, float* %113
%114 = fmul double %99, 0xBFCCB0BF0B6B7109
%115 = tail call double @llvm.fmuladd.f64(double %96, double 0xBFC0907DC1930691, double %114)
%116 = tail call double @llvm.fmuladd.f64(double %105, double 0x3FEAC4BDD6E3FD71, double %115)
%117 = tail call double @llvm.fmuladd.f64(double %110, double 0xBFDEE8DD4748BF14, double %116)
%118 = fptrunc double %117 to float
%119 = add nuw i64 %95, %10
%120 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 %119
store float %118, float* %120
%121 = add nuw i64 %95, 1
%122 = icmp eq i64 %121, %15
br i1 %122, label %123, label %92
123: ; preds = %92, %85
%124 = add i64 %1, -1
%125 = getelementptr inbounds float, float* %7, i64 %124
%126 = load float, float* %125
%127 = fpext float %126 to double
%128 = getelementptr inbounds float, float* %7, i64 %1
%129 = load float, float* %128
%130 = fpext float %129 to double
%131 = fmul double %130, 0x3FEAC4BDD6E3FD71
%132 = tail call double @llvm.fmuladd.f64(double %127, double 0x3FDEE8DD4748BF14, double %131)
%133 = fpext float %16 to double
%134 = tail call double @llvm.fmuladd.f64(double %133, double 0x3FCCB0BF0B6B7109, double %132)
%135 = getelementptr inbounds float, float* %0, i64 1
%136 = load float, float* %135
%137 = fpext float %136 to double
%138 = tail call double @llvm.fmuladd.f64(double %137, double 0xBFC0907DC1930691, double %134)
%139 = fptrunc double %138 to float
%140 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 %15
store float %139, float* %140
%141 = fmul double %130, 0xBFCCB0BF0B6B7109
%142 = tail call double @llvm.fmuladd.f64(double %127, double 0xBFC0907DC1930691, double %141)
%143 = tail call double @llvm.fmuladd.f64(double %133, double 0x3FEAC4BDD6E3FD71, double %142)
%144 = tail call double @llvm.fmuladd.f64(double %137, double 0xBFDEE8DD4748BF14, double %143)
%145 = fptrunc double %144 to float
%146 = add nuw i64 %15, %10
%147 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 %146
store float %145, float* %147
br label %274
148: ; preds = %9
%149 = getelementptr inbounds float, float* %7, i64 %10
%150 = load float, float* %149
%151 = fpext float %150 to double
%152 = getelementptr inbounds float, float* %7, i64 %1
%153 = load float, float* %152
%154 = fpext float %153 to double
%155 = fmul double %154, 0x3FEAC4BDD6E3FD71
%156 = tail call double @llvm.fmuladd.f64(double %151, double 0x3FCCB0BF0B6B7109, double %155)
%157 = load float, float* %0
%158 = fpext float %157 to double
%159 = tail call double @llvm.fmuladd.f64(double %158, double 0x3FDEE8DD4748BF14, double %156)
%160 = getelementptr inbounds float, float* %0, i64 %10
%161 = load float, float* %160
%162 = fpext float %161 to double
%163 = tail call double @llvm.fmuladd.f64(double %162, double 0xBFC0907DC1930691, double %159)
%164 = fptrunc double %163 to float
%165 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 1
store float %164, float* %165
%166 = fmul double %154, 0xBFDEE8DD4748BF14
%167 = tail call double @llvm.fmuladd.f64(double %151, double 0xBFC0907DC1930691, double %166)
%168 = tail call double @llvm.fmuladd.f64(double %158, double 0x3FEAC4BDD6E3FD71, double %167)
%169 = tail call double @llvm.fmuladd.f64(double %162, double 0xBFCCB0BF0B6B7109, double %168)
%170 = fptrunc double %169 to float
%171 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 2
store float %170, float* %171
%172 = add nsw i64 %10, -1
%173 = icmp ult i64 %172, 2
br i1 %173, label %239, label %174
174: ; preds = %148
%175 = add nsw i64 %10, -2
%176 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 3
%177 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %175, i64 8)
%178 = extractvalue { i64, i1 } %177, 0
%179 = extractvalue { i64, i1 } %177, 1
%180 = bitcast float* %176 to i8*
%181 = getelementptr i8, i8* %180, i64 %178
%182 = icmp ult i8* %181, %180
%183 = or i1 %182, %179
%184 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 4
%185 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %175, i64 8)
%186 = extractvalue { i64, i1 } %185, 0
%187 = extractvalue { i64, i1 } %185, 1
%188 = bitcast float* %184 to i8*
%189 = getelementptr i8, i8* %188, i64 %186
%190 = icmp ult i8* %189, %188
%191 = or i1 %190, %187
%192 = or i1 %183, %191
br i1 %192, label %239, label %193
193: ; preds = %174
%194 = and i64 %172, -2
%195 = shl i64 %172, 1
%196 = or i64 %195, 3
%197 = or i64 %172, 1
%198 = insertelement <2 x float> poison, float %157, i64 1
br label %199
199: ; preds = %199, %193
%200 = phi i64 [ 0, %193 ], [ %234, %199 ]
%201 = phi <2 x float> [ %198, %193 ], [ %212, %199 ]
%202 = shl i64 %200, 1
%203 = or i64 %200, 1
%204 = add nuw i64 %203, %10
%205 = getelementptr inbounds float, float* %7, i64 %204
%206 = bitcast float* %205 to <2 x float>*
%207 = load <2 x float>, <2 x float>* %206
%208 = fpext <2 x float> %207 to <2 x double>
%209 = fmul <2 x double> %208, <double 0x3FEAC4BDD6E3FD71, double 0x3FEAC4BDD6E3FD71>
%210 = getelementptr inbounds float, float* %0, i64 %203
%211 = bitcast float* %210 to <2 x float>*
%212 = load <2 x float>, <2 x float>* %211
%213 = shufflevector <2 x float> %201, <2 x float> %212, <2 x i32> <i32 1, i32 2>
%214 = fpext <2 x float> %213 to <2 x double>
%215 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %214, <2 x double> <double 0x3FCCB0BF0B6B7109, double 0x3FCCB0BF0B6B7109>, <2 x double> %209)
%216 = fpext <2 x float> %212 to <2 x double>
%217 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %216, <2 x double> <double 0x3FDEE8DD4748BF14, double 0x3FDEE8DD4748BF14>, <2 x double> %215)
%218 = getelementptr inbounds float, float* %0, i64 %204
%219 = bitcast float* %218 to <2 x float>*
%220 = load <2 x float>, <2 x float>* %219
%221 = fpext <2 x float> %220 to <2 x double>
%222 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %221, <2 x double> <double 0xBFC0907DC1930691, double 0xBFC0907DC1930691>, <2 x double> %217)
%223 = fptrunc <2 x double> %222 to <2 x float>
%224 = add i64 %202, 4
%225 = fmul <2 x double> %208, <double 0xBFDEE8DD4748BF14, double 0xBFDEE8DD4748BF14>
%226 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %214, <2 x double> <double 0xBFC0907DC1930691, double 0xBFC0907DC1930691>, <2 x double> %225)
%227 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %216, <2 x double> <double 0x3FEAC4BDD6E3FD71, double 0x3FEAC4BDD6E3FD71>, <2 x double> %226)
%228 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %221, <2 x double> <double 0xBFCCB0BF0B6B7109, double 0xBFCCB0BF0B6B7109>, <2 x double> %227)
%229 = fptrunc <2 x double> %228 to <2 x float>
%230 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 %224
%231 = getelementptr inbounds float, float* %230, i64 -1
%232 = bitcast float* %231 to <4 x float>*
%233 = shufflevector <2 x float> %223, <2 x float> %229, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x float> %233, <4 x float>* %232
%234 = add nuw i64 %200, 2
%235 = icmp eq i64 %234, %194
br i1 %235, label %236, label %199
236: ; preds = %199
%237 = icmp eq i64 %172, %194
%238 = extractelement <2 x float> %212, i64 1
br i1 %237, label %274, label %239
239: ; preds = %174, %148, %236
%240 = phi float [ %238, %236 ], [ %157, %148 ], [ %157, %174 ]
%241 = phi i64 [ %196, %236 ], [ 3, %148 ], [ 3, %174 ]
%242 = phi i64 [ %197, %236 ], [ 1, %148 ], [ 1, %174 ]
br label %243
243: ; preds = %239, %243
%244 = phi float [ %256, %243 ], [ %240, %239 ]
%245 = phi i64 [ %273, %243 ], [ %241, %239 ]
%246 = phi i64 [ %254, %243 ], [ %242, %239 ]
%247 = fpext float %244 to double
%248 = add nuw i64 %246, %10
%249 = getelementptr inbounds float, float* %7, i64 %248
%250 = load float, float* %249
%251 = fpext float %250 to double
%252 = fmul double %251, 0x3FEAC4BDD6E3FD71
%253 = tail call double @llvm.fmuladd.f64(double %247, double 0x3FCCB0BF0B6B7109, double %252)
%254 = add nuw nsw i64 %246, 1
%255 = getelementptr inbounds float, float* %0, i64 %246
%256 = load float, float* %255
%257 = fpext float %256 to double
%258 = tail call double @llvm.fmuladd.f64(double %257, double 0x3FDEE8DD4748BF14, double %253)
%259 = getelementptr inbounds float, float* %0, i64 %248
%260 = load float, float* %259
%261 = fpext float %260 to double
%262 = tail call double @llvm.fmuladd.f64(double %261, double 0xBFC0907DC1930691, double %258)
%263 = fptrunc double %262 to float
%264 = add nuw i64 %245, 1
%265 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 %245
store float %263, float* %265
%266 = fmul double %251, 0xBFDEE8DD4748BF14
%267 = tail call double @llvm.fmuladd.f64(double %247, double 0xBFC0907DC1930691, double %266)
%268 = tail call double @llvm.fmuladd.f64(double %257, double 0x3FEAC4BDD6E3FD71, double %267)
%269 = tail call double @llvm.fmuladd.f64(double %261, double 0xBFCCB0BF0B6B7109, double %268)
%270 = fptrunc double %269 to float
%271 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 %264
store float %270, float* %271
%272 = icmp eq i64 %254, %10
%273 = add nuw i64 %245, 2
br i1 %272, label %274, label %243
274: ; preds = %243, %236, %123
%275 = getelementptr inbounds [4097 x float], [4097 x float]* %5, i64 0, i64 1
%276 = bitcast float* %275 to i8*
%277 = call i64 @llvm.umax.i64(i64 %1, i64 1)
%278 = shl i64 %277, 2
br label %279
279: ; preds = %274, %3
ret void
}