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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free_vector(float *, int, unsigned long);
float *vector(int, unsigned long);
void daub4(float a[], unsigned long n, int isign) {
  float *wksp;
  unsigned long nh, nh1, i, j;
  if (n < 4)
    return;
  wksp = vector(1, n);
  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];
  free_vector(wksp, 1, n);
}


x86 assembly (clang, -O0):
<daub4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
cmpq   $0x4,-0x10(%rbp)
jae    1143 <daub4+0x23>
jmp    1743 <daub4+0x623>
mov    -0x10(%rbp),%rsi
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x28(%rbp)
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     1432 <daub4+0x312>
movq   $0x1,-0x38(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x3,%rcx
cmp    %rcx,%rax
ja     12f8 <daub4+0x1d8>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xe45(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xe49(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x8(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xe2f(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0xc(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdfd(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xdc9(%rip),%xmm1
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xd96(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x8(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xd6c(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0xc(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd6a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1183 <daub4+0x63>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xce2(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xce6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xcd1(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xca4(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xc6d(%rip),%xmm1
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xc3a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xc15(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc18(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    16f0 <daub4+0x5d0>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xbac(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xbb8(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xb93(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb6a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xb33(%rip),%xmm1
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xb08(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xae3(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xaba(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
movq   $0x1,-0x38(%rbp)
movq   $0x3,-0x40(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    16eb <daub4+0x5cb>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xa61(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xa6d(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xa43(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa16(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x9cc(%rip),%xmm1
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x9a1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x977(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x94a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    156b <daub4+0x44b>
jmp    16f0 <daub4+0x5d0>
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
ja     1731 <daub4+0x611>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    16f8 <daub4+0x5d8>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rdx
mov    $0x1,%esi
call   1030 <free_vector@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<daub4>:
cmp    $0x4,%rsi
jae    1127 <daub4+0x7>
ret
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %edx,%ebp
mov    %rsi,%r14
mov    %rdi,%rbx
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,%rdi
mov    %r14,%rcx
shr    %rcx
test   %ebp,%ebp
js     12fe <daub4+0x1de>
lea    -0x4(%r14),%r9
shr    %r9
lea    0x2(%r9),%r8
lea    0x4(%rdi),%rsi
lea    (%rdi,%rcx,4),%rbp
add    $0x4,%rbp
lea    0x1(%r9),%rax
xor    %edx,%edx
movsd  0xe8a(%rip),%xmm0
movsd  0xe92(%rip),%xmm2
movsd  0xe82(%rip),%xmm3
movsd  0xe8a(%rip),%xmm1
movsd  0xe92(%rip),%xmm4
movsd  0xe82(%rip),%xmm5
xchg   %ax,%ax
movss  0x4(%rbx,%rdx,8),%xmm6
movss  0x8(%rbx,%rdx,8),%xmm7
cvtss2sd %xmm6,%xmm6
cvtss2sd %xmm7,%xmm7
mulsd  %xmm0,%xmm7
mulsd  %xmm2,%xmm6
addsd  %xmm7,%xmm6
movss  0xc(%rbx,%rdx,8),%xmm7
cvtss2sd %xmm7,%xmm7
mulsd  %xmm3,%xmm7
addsd  %xmm6,%xmm7
movss  0x10(%rbx,%rdx,8),%xmm6
cvtss2sd %xmm6,%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm7,%xmm6
cvtsd2ss %xmm6,%xmm6
movss  %xmm6,(%rsi,%rdx,4)
movss  0x4(%rbx,%rdx,8),%xmm6
movss  0x8(%rbx,%rdx,8),%xmm7
cvtss2sd %xmm6,%xmm6
cvtss2sd %xmm7,%xmm7
mulsd  %xmm4,%xmm7
mulsd  %xmm1,%xmm6
addsd  %xmm7,%xmm6
movss  0xc(%rbx,%rdx,8),%xmm7
cvtss2sd %xmm7,%xmm7
mulsd  %xmm0,%xmm7
addsd  %xmm6,%xmm7
movss  0x10(%rbx,%rdx,8),%xmm6
cvtss2sd %xmm6,%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm7,%xmm6
cvtsd2ss %xmm6,%xmm6
movss  %xmm6,0x0(%rbp,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    11a0 <daub4+0x80>
add    %rcx,%r8
movss  -0x4(%rbx,%r14,4),%xmm2
movss  (%rbx,%r14,4),%xmm3
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm3,%xmm3
mulsd  %xmm0,%xmm3
mulsd  0xda4(%rip),%xmm2
addsd  %xmm3,%xmm2
movss  0x4(%rbx),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  0xd87(%rip),%xmm3
movss  0x8(%rbx),%xmm4
addsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x8(%rdi,%r9,4)
movss  -0x4(%rbx,%r14,4),%xmm2
movss  (%rbx,%r14,4),%xmm3
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm3,%xmm3
mulsd  0xd67(%rip),%xmm3
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
movss  0x4(%rbx),%xmm1
movss  0x8(%rbx),%xmm3
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
cvtss2sd %xmm3,%xmm0
mulsd  0xd35(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rdi,%r8,4)
jmp    14d1 <daub4+0x3b1>
movss  (%rbx,%rcx,4),%xmm0
movss  0x4(%rbx,%rcx,4),%xmm1
cvtss2sd %xmm0,%xmm2
movss  (%rbx,%r14,4),%xmm0
cvtss2sd %xmm0,%xmm3
movsd  0xce0(%rip),%xmm14
mulsd  %xmm14,%xmm3
mulsd  0xcdb(%rip),%xmm2
addsd  %xmm3,%xmm2
movss  0x4(%rbx),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  0xcce(%rip),%xmm3
addsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
movsd  0xcc2(%rip),%xmm15
mulsd  %xmm15,%xmm2
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x4(%rdi)
movss  (%rbx,%rcx,4),%xmm2
movss  0x4(%rbx,%rcx,4),%xmm3
cvtss2sd %xmm2,%xmm2
movss  (%rbx,%r14,4),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  0xc97(%rip),%xmm4
mulsd  %xmm15,%xmm2
addsd  %xmm4,%xmm2
movss  0x4(%rbx),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm14,%xmm4
addsd  %xmm2,%xmm4
xorps  %xmm2,%xmm2
cvtss2sd %xmm3,%xmm2
mulsd  0xc75(%rip),%xmm2
addsd  %xmm4,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x8(%rdi)
lea    -0x1(%rcx),%r9
mov    $0x1,%r10d
mov    $0x3,%r8d
cmp    $0x2,%r9
jae    153f <daub4+0x41f>
lea    (%rdi,%r8,4),%rax
add    $0x4,%rax
lea    (%r10,%rcx,1),%rdx
lea    (%rbx,%rdx,4),%rdx
add    $0x4,%rdx
sub    %r10,%rcx
lea    (%rbx,%r10,4),%rsi
add    $0x4,%rsi
xor    %ebp,%ebp
movsd  0xc05(%rip),%xmm2
movsd  0xc05(%rip),%xmm3
movsd  0xc0d(%rip),%xmm4
movsd  0xc0d(%rip),%xmm5
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rsi,%rbp,4),%xmm6
movss  (%rsi,%rbp,4),%xmm7
cvtss2sd %xmm6,%xmm6
movss  -0x4(%rdx,%rbp,4),%xmm0
movss  (%rdx,%rbp,4),%xmm1
cvtss2sd %xmm0,%xmm0
mulsd  %xmm14,%xmm0
mulsd  %xmm2,%xmm6
addsd  %xmm0,%xmm6
xorps  %xmm0,%xmm0
cvtss2sd %xmm7,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm6,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm15,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,-0x4(%rax,%rbp,8)
movss  -0x4(%rsi,%rbp,4),%xmm0
movss  (%rsi,%rbp,4),%xmm1
cvtss2sd %xmm0,%xmm0
movss  -0x4(%rdx,%rbp,4),%xmm6
movss  (%rdx,%rbp,4),%xmm7
cvtss2sd %xmm6,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm15,%xmm0
addsd  %xmm6,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm7,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rcx
jne    1420 <daub4+0x300>
cmp    $0x2,%r14
mov    $0x1,%ecx
mov    $0x1,%eax
cmovae %r14,%rax
cmp    $0x8,%rax
jb     1765 <daub4+0x645>
lea    0x4(%rbx),%rdx
lea    (%rdi,%rax,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rdx
jae    1513 <daub4+0x3f3>
lea    (%rbx,%rax,4),%rdx
add    $0x4,%rdx
lea    0x4(%rdi),%rsi
cmp    %rdx,%rsi
jb     1765 <daub4+0x645>
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ebp
and    $0x3,%ebp
cmp    $0x18,%rsi
jae    16bb <daub4+0x59b>
xor    %esi,%esi
jmp    172a <daub4+0x60a>
lea    -0x2(%rcx),%rax
mov    $0x8,%edx
mul    %rdx
lea    0xc(%rdi),%r11
seto   %dl
lea    (%rdi,%rax,1),%rsi
add    $0xc,%rsi
cmp    %r11,%rsi
jb     13da <daub4+0x2ba>
test   %dl,%dl
jne    13da <daub4+0x2ba>
lea    0x10(%rdi),%rsi
add    %rdi,%rax
add    $0x10,%rax
cmp    %rsi,%rax
jb     13da <daub4+0x2ba>
test   %dl,%dl
jne    13da <daub4+0x2ba>
lea    0x1(%rcx),%rax
lea    0x0(,%r14,4),%rdx
or     $0x4,%rdx
lea    (%rdi,%rdx,1),%rsi
lea    (%rbx,%rax,4),%rax
add    %rbx,%rdx
lea    0x4(%rbx),%rbp
cmp    %rdx,%r11
setb   %r15b
cmp    %rsi,%rax
setb   %dl
cmp    %rax,%r11
setb   %al
cmp    %rsi,%rbp
setb   %sil
test   %dl,%r15b
jne    13da <daub4+0x2ba>
and    %sil,%al
jne    13da <daub4+0x2ba>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
lea    (%r9,%r9,1),%r8
or     $0x3,%r8
mov    %r9,%r10
or     $0x1,%r10
lea    0x8(%rbx),%rbp
lea    (%rbx,%rcx,4),%rsi
add    $0x8,%rsi
xor    %edx,%edx
movapd 0xa31(%rip),%xmm12
movapd 0xa38(%rip),%xmm8
movapd 0xa3f(%rip),%xmm9
movapd 0xa46(%rip),%xmm13
movapd 0xa4d(%rip),%xmm10
movapd 0xa54(%rip),%xmm11
nopl   0x0(%rax)
cvtps2pd -0x4(%rbp,%rdx,4),%xmm7
cvtps2pd -0x4(%rsi,%rdx,4),%xmm6
movapd %xmm6,%xmm4
mulpd  %xmm12,%xmm4
movapd %xmm7,%xmm3
mulpd  %xmm8,%xmm3
addpd  %xmm4,%xmm3
cvtps2pd 0x0(%rbp,%rdx,4),%xmm2
movapd %xmm2,%xmm4
mulpd  %xmm9,%xmm4
addpd  %xmm3,%xmm4
cvtps2pd (%rsi,%rdx,4),%xmm5
movapd %xmm5,%xmm3
mulpd  %xmm13,%xmm3
addpd  %xmm4,%xmm3
cvtpd2ps %xmm3,%xmm3
mulpd  %xmm10,%xmm6
mulpd  %xmm13,%xmm7
addpd  %xmm6,%xmm7
mulpd  %xmm12,%xmm2
addpd  %xmm7,%xmm2
mulpd  %xmm11,%xmm5
addpd  %xmm2,%xmm5
cvtpd2ps %xmm5,%xmm2
unpcklps %xmm2,%xmm3
movupd %xmm3,(%r11,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    1630 <daub4+0x510>
cmp    %rax,%r9
jne    13da <daub4+0x2ba>
jmp    14d1 <daub4+0x3b1>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x4(%rdi,%rsi,4),%xmm0
movups 0x14(%rdi,%rsi,4),%xmm1
movups %xmm0,0x4(%rbx,%rsi,4)
movups %xmm1,0x14(%rbx,%rsi,4)
movups 0x24(%rdi,%rsi,4),%xmm0
movups 0x34(%rdi,%rsi,4),%xmm1
movups %xmm0,0x24(%rbx,%rsi,4)
movups %xmm1,0x34(%rbx,%rsi,4)
movups 0x44(%rdi,%rsi,4),%xmm0
movups 0x54(%rdi,%rsi,4),%xmm1
movups %xmm0,0x44(%rbx,%rsi,4)
movups %xmm1,0x54(%rbx,%rsi,4)
movups 0x64(%rdi,%rsi,4),%xmm0
movups 0x74(%rdi,%rsi,4),%xmm1
movups %xmm0,0x64(%rbx,%rsi,4)
movups %xmm1,0x74(%rbx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    16d0 <daub4+0x5b0>
test   %rbp,%rbp
je     1758 <daub4+0x638>
nop
lea    0x0(,%rsi,4),%rdx
or     $0x4,%rdx
movups (%rdi,%rdx,1),%xmm0
movups 0x10(%rdi,%rdx,1),%xmm1
movups %xmm0,(%rbx,%rdx,1)
movups %xmm1,0x10(%rbx,%rdx,1)
add    $0x8,%rsi
add    $0xffffffffffffffff,%rbp
jne    1730 <daub4+0x610>
cmp    %rcx,%rax
je     17f7 <daub4+0x6d7>
or     $0x1,%rcx
mov    %eax,%esi
sub    %ecx,%esi
add    $0x1,%esi
mov    %rax,%rdx
sub    %rcx,%rdx
and    $0x3,%rsi
je     1794 <daub4+0x674>
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1780 <daub4+0x660>
cmp    $0x3,%rdx
jb     17f7 <daub4+0x6d7>
sub    %rcx,%rax
lea    (%rbx,%rcx,4),%rdx
add    $0xc,%rdx
lea    (%rdi,%rcx,4),%rcx
add    $0xc,%rcx
mov    $0xffffffffffffffff,%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x8(%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rdx,%rsi,4)
movss  -0x4(%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rsi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movss  0x4(%rcx,%rsi,4),%xmm0
movss  %xmm0,0x4(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rax
jne    17c0 <daub4+0x6a0>
mov    $0x1,%esi
mov    %r14,%rdx
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_vector@plt>

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

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