void fn_invFDaubechiesWT2p2(float *a_da, float *a_ka,
                            const unsigned int const cuci_N,
                            unsigned int cuic_w) {
  float a_buff[cuci_N];
  unsigned int ui_j;
  unsigned int ui_i;
  unsigned int ui_step = 0;
  unsigned int ui_ord = cuci_N;
  float *p_p1 = &a_buff[0];
  float *p_p2 = &a_buff[cuci_N >> 1];
  float *p_temp;
  switch (cuic_w) {
  case 0:
    break;
  case 1:
    for (ui_j = 0; ui_j < cuci_N; ui_j = ui_j + 2) {
      a_da[ui_j] = (a_ka[(ui_j >> 1) + (cuci_N >> 1)]) * 0.707106781;
      a_da[ui_j + 1] = (a_ka[(ui_j >> 1) + (cuci_N >> 1)]) * 0.707106781;
      a_da[ui_j] = a_da[ui_j] + (a_ka[(ui_j >> 1)]) * 0.707106781;
      a_da[ui_j + 1] = a_da[ui_j + 1] - (a_ka[(ui_j >> 1)]) * 0.707106781;
    }
    break;
  default:
    ui_ord = ui_ord >> cuic_w;
    ui_step = cuci_N - ui_ord;
    for (ui_j = 0; ui_j < (ui_ord << 1); ui_j = ui_j + 2) {
      a_buff[ui_j] = (a_ka[(ui_j >> 1) + ui_step]) * 0.707106781;
      a_buff[ui_j + 1] = (a_ka[(ui_j >> 1) + ui_step]) * 0.707106781;
    }
    ui_ord = ui_ord << 1;
    ui_step = cuci_N - ui_ord;
    for (ui_j = 0; ui_j < ui_ord; ui_j = ui_j + 2) {
      a_buff[ui_j] = a_buff[ui_j] + (a_ka[(ui_j >> 1) + ui_step]) * 0.707106781;
      a_buff[ui_j + 1] =
          a_buff[ui_j + 1] - (a_ka[(ui_j >> 1) + ui_step]) * 0.707106781;
    }
    for (ui_i = 1; ui_i < (cuic_w - 1); ui_i++) {
      ui_ord = ui_ord << 1;
      ui_step = cuci_N - ui_ord;
      for (ui_j = 0; ui_j < ui_ord; ui_j = ui_j + 2) {
        p_p2[ui_j] = (p_p1[ui_j >> 1]) * 0.707106781;
        p_p2[ui_j + 1] = (p_p1[ui_j >> 1]) * 0.707106781;
        p_p2[ui_j] = p_p2[ui_j] + (a_ka[(ui_j >> 1) + ui_step]) * 0.707106781;
        p_p2[ui_j + 1] =
            p_p2[ui_j + 1] - (a_ka[(ui_j >> 1) + ui_step]) * 0.707106781;
      }
      p_temp = p_p1;
      p_p1 = p_p2;
      p_p2 = p_temp;
    }
    for (ui_j = 0; ui_j < cuci_N; ui_j = ui_j + 2) {
      a_da[ui_j] = (p_p1[ui_j >> 1]) * 0.707106781;
      a_da[ui_j + 1] = (p_p1[ui_j >> 1]) * 0.707106781;
      a_da[ui_j] = a_da[ui_j] + (a_ka[ui_j >> 1]) * 0.707106781;
      a_da[ui_j + 1] = a_da[ui_j + 1] - (a_ka[ui_j >> 1]) * 0.707106781;
    }
    break;
  }
  return;
}


x86 assembly (clang, -O0):
<fn_invFDaubechiesWT2p2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
mov    %rsp,%rax
mov    %rax,-0x20(%rbp)
lea    0xf(,%rcx,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rax
sub    %rdx,%rax
mov    %rax,-0x60(%rbp)
mov    %rax,%rsp
mov    %rcx,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x14(%rbp),%ecx
mov    %ecx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
shr    %ecx
lea    (%rax,%rcx,4),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x54(%rbp)
test   %eax,%eax
je     1181 <fn_invFDaubechiesWT2p2+0x81>
jmp    1170 <fn_invFDaubechiesWT2p2+0x70>
mov    -0x54(%rbp),%eax
sub    $0x1,%eax
je     1186 <fn_invFDaubechiesWT2p2+0x86>
jmp    12ce <fn_invFDaubechiesWT2p2+0x1ce>
jmp    170a <fn_invFDaubechiesWT2p2+0x60a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    12c9 <fn_invFDaubechiesWT2p2+0x1c9>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe42(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe09(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdc3(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xd62(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    118d <fn_invFDaubechiesWT2p2+0x8d>
jmp    170a <fn_invFDaubechiesWT2p2+0x60a>
mov    -0x38(%rbp),%eax
mov    -0x18(%rbp),%ecx
shr    %cl,%eax
mov    %eax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jae    1371 <fn_invFDaubechiesWT2p2+0x271>
mov    -0x60(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x2c(%rbp),%edx
shr    $0x1,%edx
add    -0x34(%rbp),%edx
mov    %edx,%edx
movss  (%rcx,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xce2(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rcx
mov    -0x2c(%rbp),%edx
shr    $0x1,%edx
add    -0x34(%rbp),%edx
mov    %edx,%edx
movss  (%rcx,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcb2(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    12e9 <fn_invFDaubechiesWT2p2+0x1e9>
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jae    1449 <fn_invFDaubechiesWT2p2+0x349>
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rcx
mov    -0x2c(%rbp),%edx
shr    $0x1,%edx
add    -0x34(%rbp),%edx
mov    %edx,%edx
movss  (%rcx,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc3a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rcx
mov    -0x2c(%rbp),%edx
shr    $0x1,%edx
add    -0x34(%rbp),%edx
mov    %edx,%edx
movss  (%rcx,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
movsd  0xbde(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    138a <fn_invFDaubechiesWT2p2+0x28a>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    15d2 <fn_invFDaubechiesWT2p2+0x4d2>
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jae    15ac <fn_invFDaubechiesWT2p2+0x4ac>
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb5d(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb2c(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
add    -0x34(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xae3(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
add    -0x34(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xa7f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    147a <fn_invFDaubechiesWT2p2+0x37a>
mov    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1450 <fn_invFDaubechiesWT2p2+0x350>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1705 <fn_invFDaubechiesWT2p2+0x605>
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9fe(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9cd(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x987(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x926(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    15d9 <fn_invFDaubechiesWT2p2+0x4d9>
jmp    170a <fn_invFDaubechiesWT2p2+0x60a>
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fn_invFDaubechiesWT2p2>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %edx,%r9d
mov    %rsp,%r12
lea    0xf(,%r9,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r12
mov    %r12,%rsp
test   %ecx,%ecx
je     1717 <fn_invFDaubechiesWT2p2+0x617>
mov    %edx,%r13d
shr    %r13d
cmp    $0x1,%ecx
jne    1155 <fn_invFDaubechiesWT2p2+0x55>
test   %edx,%edx
je     1717 <fn_invFDaubechiesWT2p2+0x617>
lea    -0x1(%r9),%r10
cmp    $0x2,%r10
jae    1194 <fn_invFDaubechiesWT2p2+0x94>
xor    %eax,%eax
jmp    1267 <fn_invFDaubechiesWT2p2+0x167>
mov    %edx,%r8d
shr    %cl,%r8d
lea    (%r8,%r8,1),%r10d
test   %r8d,%r8d
je     1570 <fn_invFDaubechiesWT2p2+0x470>
mov    %r10d,%r11d
cmp    $0x3,%r11
mov    $0x2,%eax
mov    $0x2,%r15d
cmovae %r11,%r15
add    $0xffffffffffffffff,%r15
cmp    $0x6,%r15
jae    1302 <fn_invFDaubechiesWT2p2+0x202>
xor    %r14d,%r14d
jmp    13cc <fn_invFDaubechiesWT2p2+0x2cc>
shr    %r10
lea    0x1(%r9),%rax
and    $0xfffffffffffffffe,%rax
lea    (%rdi,%rax,4),%rax
lea    (%rsi,%r10,4),%rcx
add    $0x4,%rcx
lea    (%rsi,%r13,4),%r8
cmp    %rdi,%rcx
seta   %bl
lea    (%r10,%r13,1),%rcx
cmp    %rsi,%rax
seta   %dl
lea    (%rsi,%rcx,4),%rcx
add    $0x4,%rcx
cmp    %rdi,%rcx
seta   %cl
cmp    %rax,%r8
setb   %r8b
xor    %eax,%eax
test   %dl,%bl
jne    1267 <fn_invFDaubechiesWT2p2+0x167>
and    %r8b,%cl
jne    1267 <fn_invFDaubechiesWT2p2+0x167>
add    $0x1,%r10
movabs $0x7ffffffffffffffe,%r8
ff ff 7f
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
lea    (%r11,%r11,1),%rax
xor    %ecx,%ecx
movapd 0xdf6(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rbx
and    %r8,%rbx
lea    (%rbx,%r13,1),%rdx
cvtps2pd (%rsi,%rdx,4),%xmm1
mulpd  %xmm0,%xmm1
cvtpd2ps %xmm1,%xmm1
cvtps2pd %xmm1,%xmm2
unpcklps %xmm1,%xmm1
movupd %xmm1,(%rdi,%rcx,8)
cvtps2pd (%rsi,%rbx,4),%xmm1
mulpd  %xmm0,%xmm1
movapd %xmm1,%xmm3
addpd  %xmm2,%xmm3
cvtpd2ps %xmm3,%xmm3
subpd  %xmm1,%xmm2
cvtpd2ps %xmm2,%xmm1
unpcklps %xmm1,%xmm3
movupd %xmm3,(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r11
jne    1210 <fn_invFDaubechiesWT2p2+0x110>
cmp    %r11,%r10
je     1717 <fn_invFDaubechiesWT2p2+0x617>
mov    %rax,%rdx
shr    %rdx
lea    (%rsi,%rdx,4),%rcx
add    %r13,%rdx
lea    (%rsi,%rdx,4),%rdx
movsd  0xd90(%rip),%xmm0
movss  (%rdx),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rdi,%rax,4)
movss  (%rdx),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x4(%rdi,%rax,4)
cvtss2sd %xmm1,%xmm1
movss  (%rcx),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
movss  %xmm1,(%rdi,%rax,4)
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
movss  (%rcx),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x4(%rdi,%rax,4)
add    $0x2,%rax
add    $0x4,%rcx
add    $0x4,%rdx
cmp    %r9,%rax
jb     1280 <fn_invFDaubechiesWT2p2+0x180>
jmp    1717 <fn_invFDaubechiesWT2p2+0x617>
cmp    $0x3,%r11
cmovae %r11,%rax
add    $0xffffffffffffffff,%rax
mov    %r8,%r14
mov    %rax,%r8
shr    %r8
mov    %edx,%ebx
not    %ebx
mov    %r14,-0x38(%rbp)
add    %r14d,%ebx
xor    %r14d,%r14d
cmp    %r8d,%ebx
jb     13c8 <fn_invFDaubechiesWT2p2+0x2c8>
movabs $0x1fffffffe,%rbx
or     $0x1,%rbx
cmp    %rbx,%rax
mov    -0x38(%rbp),%r8
ja     13cc <fn_invFDaubechiesWT2p2+0x2cc>
mov    %r13,-0x30(%rbp)
shr    %r15
add    $0x1,%r15
movabs $0x7ffffffffffffffe,%r13
ff ff 7f
add    $0xfffffffffffffffe,%r13
and    %r15,%r13
mov    %r13,%r14
add    %r13,%r14
mov    %edx,%ebx
sub    %r8d,%ebx
xor    %r8d,%r8d
movapd 0xc85(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
lea    (%rbx,%r8,1),%eax
cvtps2pd (%rsi,%rax,4),%xmm1
cvtps2pd 0x8(%rsi,%rax,4),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm2,%xmm2
unpcklps %xmm1,%xmm1
movapd %xmm1,(%r12,%r8,8)
unpcklps %xmm2,%xmm2
movapd %xmm2,0x10(%r12,%r8,8)
add    $0x4,%r8
cmp    %r8,%r13
jne    1380 <fn_invFDaubechiesWT2p2+0x280>
cmp    %r13,%r15
mov    -0x30(%rbp),%r13
mov    -0x38(%rbp),%r8
jne    13cc <fn_invFDaubechiesWT2p2+0x2cc>
jmp    140c <fn_invFDaubechiesWT2p2+0x30c>
mov    -0x38(%rbp),%r8
mov    %r14,%rax
shr    %rax
add    %edx,%eax
sub    %r8d,%eax
movsd  0xc31(%rip),%xmm0
nop
mov    %eax,%ebx
movss  (%rsi,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r12,%r14,4)
movss  %xmm1,0x4(%r12,%r14,4)
add    $0x2,%r14
add    $0x1,%eax
cmp    %r11,%r14
jb     13e0 <fn_invFDaubechiesWT2p2+0x2e0>
test   %r8d,%r8d
je     1570 <fn_invFDaubechiesWT2p2+0x470>
cmp    $0x3,%r11
mov    $0x2,%r15d
mov    $0x2,%eax
cmovae %r11,%rax
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
jne    143a <fn_invFDaubechiesWT2p2+0x33a>
xor    %r14d,%r14d
jmp    14fe <fn_invFDaubechiesWT2p2+0x3fe>
cmp    $0x3,%r11
cmovae %r11,%r15
add    $0xffffffffffffffff,%r15
mov    %r15,%r8
shr    %r8
mov    %edx,%ebx
not    %ebx
add    %r10d,%ebx
xor    %r14d,%r14d
cmp    %r8d,%ebx
jb     14fe <fn_invFDaubechiesWT2p2+0x3fe>
movabs $0x1fffffffe,%rbx
or     $0x1,%rbx
cmp    %rbx,%r15
ja     14fe <fn_invFDaubechiesWT2p2+0x3fe>
mov    %r13,-0x30(%rbp)
shr    %rax
add    $0x1,%rax
movabs $0x7ffffffffffffffe,%r15
ff ff 7f
and    %rax,%r15
lea    (%r15,%r15,1),%r14
mov    %edx,%r13d
sub    %r10d,%r13d
xor    %r8d,%r8d
movapd 0xb5d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps (%r12,%r8,8),%xmm1
movaps %xmm1,%xmm2
shufps $0xe8,%xmm1,%xmm2
shufps $0xed,%xmm1,%xmm1
cvtps2pd %xmm2,%xmm2
lea    0x0(%r13,%r8,1),%ebx
cvtps2pd (%rsi,%rbx,4),%xmm3
mulpd  %xmm0,%xmm3
addpd  %xmm3,%xmm2
cvtpd2ps %xmm2,%xmm2
cvtps2pd %xmm1,%xmm1
subpd  %xmm3,%xmm1
cvtpd2ps %xmm1,%xmm1
unpcklps %xmm1,%xmm2
movapd %xmm2,(%r12,%r8,8)
add    $0x2,%r8
cmp    %r8,%r15
jne    14b0 <fn_invFDaubechiesWT2p2+0x3b0>
cmp    %r15,%rax
mov    -0x30(%rbp),%r13
je     1570 <fn_invFDaubechiesWT2p2+0x470>
mov    %r14,%rbx
shr    %rbx
add    %edx,%ebx
sub    %r10d,%ebx
movsd  0xaff(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r12,%r14,4),%xmm1
movss  0x4(%r12,%r14,4),%xmm2
cvtss2sd %xmm1,%xmm1
mov    %ebx,%eax
movss  (%rsi,%rax,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm3,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r12,%r14,4)
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
subsd  %xmm3,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x4(%r12,%r14,4)
add    $0x2,%r14
add    $0x1,%ebx
cmp    %r11,%r14
jb     1520 <fn_invFDaubechiesWT2p2+0x420>
add    $0xffffffff,%ecx
cmp    $0x2,%ecx
jb     1650 <fn_invFDaubechiesWT2p2+0x550>
lea    (%r12,%r13,4),%rax
mov    $0x1,%r8d
movsd  0xa82(%rip),%xmm0
jmp    15a3 <fn_invFDaubechiesWT2p2+0x4a3>
add    $0x1,%r8d
mov    %r12,%rax
mov    %r14,%r12
cmp    %ecx,%r8d
je     1653 <fn_invFDaubechiesWT2p2+0x553>
mov    %rax,%r14
add    %r10d,%r10d
je     1590 <fn_invFDaubechiesWT2p2+0x490>
mov    %r10d,%r11d
mov    %edx,%ebx
sub    %r10d,%ebx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r12,%rax,2),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r14,%rax,4)
movss  (%r12,%rax,2),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x4(%r14,%rax,4)
cvtss2sd %xmm1,%xmm1
mov    %ebx,%r15d
movss  (%rsi,%r15,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
movss  %xmm1,(%r14,%rax,4)
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
movss  (%rsi,%r15,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x4(%r14,%rax,4)
add    $0x2,%rax
add    $0x1,%ebx
cmp    %r11,%rax
jb     15c0 <fn_invFDaubechiesWT2p2+0x4c0>
jmp    1590 <fn_invFDaubechiesWT2p2+0x490>
mov    %r12,%r14
test   %edx,%edx
je     1717 <fn_invFDaubechiesWT2p2+0x617>
lea    -0x1(%r9),%r8
cmp    $0x2,%r8
jae    1726 <fn_invFDaubechiesWT2p2+0x626>
xor    %ecx,%ecx
lea    (%rdi,%rcx,4),%rdx
add    $0x4,%rdx
lea    (%rcx,%rcx,1),%rax
and    $0xfffffffffffffffc,%rax
add    %rax,%r14
add    %rax,%rsi
xor    %eax,%eax
movsd  0x985(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rax,2),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,-0x4(%rdx,%rax,4)
movss  (%r14,%rax,2),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%rdx,%rax,4)
cvtss2sd %xmm1,%xmm1
movss  (%rsi,%rax,2),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
movss  %xmm1,-0x4(%rdx,%rax,4)
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
movss  (%rsi,%rax,2),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rdx,%rax,4)
lea    (%rcx,%rax,1),%rdi
add    $0x2,%rdi
add    $0x2,%rax
cmp    %r9,%rdi
jb     1690 <fn_invFDaubechiesWT2p2+0x590>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%r9,%r9,1),%rax
add    $0xfffffffffffffffe,%rax
and    $0xfffffffffffffffc,%rax
lea    0x1(%r9),%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%rdi,%rcx,4),%rcx
lea    (%r14,%rax,1),%rdx
add    $0x4,%rdx
add    %rsi,%rax
add    $0x4,%rax
cmp    %rdi,%rdx
seta   %bl
cmp    %rcx,%r14
setb   %dl
cmp    %rdi,%rax
seta   %al
cmp    %rsi,%rcx
seta   %r10b
xor    %ecx,%ecx
test   %dl,%bl
jne    166b <fn_invFDaubechiesWT2p2+0x56b>
and    %r10b,%al
jne    166b <fn_invFDaubechiesWT2p2+0x56b>
shr    %r8
add    $0x1,%r8
movabs $0x7ffffffffffffffe,%r10
ff ff 7f
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rax,%rax,1),%rcx
xor    %edx,%edx
movapd 0x861(%rip),%xmm0
nop
mov    %rdx,%rbx
and    %r10,%rbx
cvtps2pd (%r14,%rbx,4),%xmm1
mulpd  %xmm0,%xmm1
cvtpd2ps %xmm1,%xmm1
cvtps2pd %xmm1,%xmm2
unpcklps %xmm1,%xmm1
movupd %xmm1,(%rdi,%rdx,8)
cvtps2pd (%rsi,%rbx,4),%xmm1
mulpd  %xmm0,%xmm1
movapd %xmm1,%xmm3
addpd  %xmm2,%xmm3
cvtpd2ps %xmm3,%xmm3
subpd  %xmm1,%xmm2
cvtpd2ps %xmm2,%xmm1
unpcklps %xmm1,%xmm3
movupd %xmm3,(%rdi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    17a0 <fn_invFDaubechiesWT2p2+0x6a0>
cmp    %rax,%r8
jne    166b <fn_invFDaubechiesWT2p2+0x56b>
jmp    1717 <fn_invFDaubechiesWT2p2+0x617>

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

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