#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 */
double sin(double);
void fourn(float data[], unsigned int nn[], int ndim, int isign) {
  int idim;
  unsigned long i1, i2, i3, i2rev, i3rev, ip1, ip2, ip3, ifp1, ifp2;
  unsigned long ibit, k1, k2, n, nprev, nrem, ntot;
  float tempi, tempr;
  double theta, wi, wpi, wpr, wr, wtemp;
  for (ntot = 1, idim = 1; idim <= ndim; idim++)
    ntot *= nn[idim];
  nprev = 1;
  for (idim = ndim; idim >= 1; idim--) {
    n = nn[idim];
    nrem = ntot / (n * nprev);
    ip1 = nprev << 1;
    ip2 = ip1 * n;
    ip3 = ip2 * nrem;
    i2rev = 1;
    for (i2 = 1; i2 <= ip2; i2 += ip1) {
      if (i2 < i2rev) {
        for (i1 = i2; i1 <= i2 + ip1 - 2; i1 += 2) {
          for (i3 = i1; i3 <= ip3; i3 += ip2) {
            i3rev = i2rev + i3 - i2;
            tempr = (data[i3]);
            (data[i3]) = (data[i3rev]);
            (data[i3rev]) = tempr;
            tempr = (data[i3 + 1]);
            (data[i3 + 1]) = (data[i3rev + 1]);
            (data[i3rev + 1]) = tempr;
          }
        }
      }
      ibit = ip2 >> 1;
      while (ibit >= ip1 && i2rev > ibit) {
        i2rev -= ibit;
        ibit >>= 1;
      }
      i2rev += ibit;
    }
    ifp1 = ip1;
    while (ifp1 < ip2) {
      ifp2 = ifp1 << 1;
      theta = isign * 6.28318530717959 / (ifp2 / ip1);
      wtemp = sin(0.5 * theta);
      wpr = -2.0 * wtemp * wtemp;
      wpi = sin(theta);
      wr = 1.0;
      wi = 0.0;
      for (i3 = 1; i3 <= ifp1; i3 += ip1) {
        for (i1 = i3; i1 <= i3 + ip1 - 2; i1 += 2) {
          for (i2 = i1; i2 <= ip3; i2 += ifp2) {
            k1 = i2;
            k2 = k1 + ifp1;
            tempr = (float)wr * data[k2] - (float)wi * data[k2 + 1];
            tempi = (float)wr * data[k2 + 1] + (float)wi * data[k2];
            data[k2] = data[k1] - tempr;
            data[k2 + 1] = data[k1 + 1] - tempi;
            data[k1] += tempr;
            data[k1 + 1] += tempi;
          }
        }
        wr = (wtemp = wr) * wpr - wi * wpi + wr;
        wi = wi * wpr + wtemp * wpi + wi;
      }
      ifp1 = ifp2;
    }
    nprev *= n;
  }
}


x86 assembly (clang, -O0):
<fourn>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movq   $0x1,-0xa8(%rbp)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     116f <fourn+0x5f>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0xa8(%rbp),%rax
ff
mov    %rax,-0xa8(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    113b <fourn+0x2b>
movq   $0x1,-0x98(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jl     16f7 <fourn+0x5e7>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %rax,-0x90(%rbp)
mov    -0xa8(%rbp),%rax
mov    -0x90(%rbp),%rcx
imul   -0x98(%rbp),%rcx
ff
xor    %edx,%edx
div    %rcx
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
imul   -0x90(%rbp),%rax
ff
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
imul   -0xa0(%rbp),%rax
ff
mov    %rax,-0x60(%rbp)
movq   $0x1,-0x40(%rbp)
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x58(%rbp),%rax
ja     139b <fourn+0x28b>
mov    -0x30(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    1318 <fourn+0x208>
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x50(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
ja     1313 <fourn+0x203>
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x60(%rbp),%rax
ja     12fd <fourn+0x1ed>
mov    -0x40(%rbp),%rax
add    -0x38(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    1242 <fourn+0x132>
jmp    1302 <fourn+0x1f2>
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1221 <fourn+0x111>
jmp    1318 <fourn+0x208>
mov    -0x58(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rcx
xor    %eax,%eax
cmp    -0x50(%rbp),%rcx
mov    %al,-0xe1(%rbp)
jb     134b <fourn+0x23b>
mov    -0x40(%rbp),%rax
cmp    -0x78(%rbp),%rax
seta   %al
mov    %al,-0xe1(%rbp)
mov    -0xe1(%rbp),%al
test   $0x1,%al
jne    135e <fourn+0x24e>
jmp    137e <fourn+0x26e>
mov    -0x78(%rbp),%rcx
mov    -0x40(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x78(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    1324 <fourn+0x214>
mov    -0x78(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x50(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    11fd <fourn+0xed>
mov    -0x50(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x58(%rbp),%rax
jae    16d3 <fourn+0x5c3>
mov    -0x68(%rbp),%rax
add    %rax,%rax
mov    %rax,-0x70(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  0xc4f(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x50(%rbp),%rcx
xor    %edx,%edx
div    %rcx
movq   %rax,%xmm1
movaps 0xc3a(%rip),%xmm2
punpckldq %xmm2,%xmm1
movapd 0xc3e(%rip),%xmm2
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xbfb(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  0xbd6(%rip),%xmm0
mulsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0xb99(%rip),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x68(%rbp),%rax
ja     16c6 <fourn+0x5b6>
mov    -0x38(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    -0x50(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
ja     1626 <fourn+0x516>
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x60(%rbp),%rax
ja     1610 <fourn+0x500>
mov    -0x30(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
add    -0x68(%rbp),%rax
mov    %rax,-0x88(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
cvtsd2ss %xmm1,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%rcx
mulss  0x4(%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
cvtsd2ss %xmm1,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
subss  -0xac(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x80(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xac(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x80(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    14b9 <fourn+0x3a9>
jmp    1615 <fourn+0x505>
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1498 <fourn+0x388>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  -0xc8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x50(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    1482 <fourn+0x372>
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
jmp    13a3 <fourn+0x293>
mov    -0x90(%rbp),%rax
imul   -0x98(%rbp),%rax
ff
mov    %rax,-0x98(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1180 <fourn+0x70>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fourn>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
test   %edx,%edx
jle    156b <fourn+0x45b>
mov    %rdi,%rbx
mov    %edx,%r11d
lea    -0x1(%r11),%rax
mov    %r11d,%r8d
and    $0x7,%r8d
cmp    $0x7,%rax
jae    1151 <fourn+0x41>
mov    $0x1,%ebp
mov    $0x1,%eax
test   %r8,%r8
jne    11b6 <fourn+0xa6>
jmp    11d1 <fourn+0xc1>
mov    %r11d,%r9d
and    $0xfffffff8,%r9d
mov    $0x1,%eax
xor    %ebp,%ebp
nop
mov    0x4(%rsi,%rbp,4),%r14d
mov    0x8(%rsi,%rbp,4),%r10d
imul   %rax,%r14
mov    0xc(%rsi,%rbp,4),%eax
imul   %r10,%rax
imul   %r14,%rax
mov    0x10(%rsi,%rbp,4),%edi
mov    0x14(%rsi,%rbp,4),%r10d
imul   %rdi,%r10
mov    0x18(%rsi,%rbp,4),%edi
imul   %r10,%rdi
imul   %rax,%rdi
mov    0x1c(%rsi,%rbp,4),%r10d
mov    0x20(%rsi,%rbp,4),%eax
imul   %r10,%rax
imul   %rdi,%rax
add    $0x8,%rbp
cmp    %rbp,%r9
jne    1160 <fourn+0x50>
add    $0x1,%rbp
test   %r8,%r8
je     11d1 <fourn+0xc1>
lea    (%rsi,%rbp,4),%r9
xor    %edi,%edi
nopl   0x0(%rax)
mov    (%r9,%rdi,4),%ebp
imul   %rbp,%rax
add    $0x1,%rdi
cmp    %rdi,%r8
jne    11c0 <fourn+0xb0>
test   %edx,%edx
jle    156b <fourn+0x45b>
cvtsi2sd %ecx,%xmm0
mulsd  0xe1b(%rip),%xmm0
movsd  %xmm0,0x38(%rsp)
lea    0x8(%rbx),%rcx
mov    %rcx,0x8(%rsp)
lea    0x4(%rbx),%r13
mov    $0x1,%r8d
mov    $0x1,%edi
mov    %rsi,0x20(%rsp)
mov    %rax,0x18(%rsp)
mov    %r13,0x10(%rsp)
jmp    124a <fourn+0x13a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x30(%rsp),%rcx
lea    -0x1(%rcx),%r11
mov    0x28(%rsp),%rdi
mov    %rdi,%r8
cmp    $0x1,%rcx
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%r13
jle    156b <fourn+0x45b>
mov    (%rsi,%r11,4),%r15d
imul   %r15,%rdi
mov    %rax,%rcx
or     %rdi,%rcx
shr    $0x20,%rcx
mov    %r11,0x30(%rsp)
mov    %rdi,0x28(%rsp)
je     1280 <fourn+0x170>
xor    %edx,%edx
div    %rdi
mov    %rax,%r12
jmp    1287 <fourn+0x177>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %edx,%edx
div    %edi
mov    %eax,%r12d
lea    (%r8,%r8,1),%r14
imul   %r14,%r15
imul   %r15,%r12
test   %r15,%r15
je     1390 <fourn+0x280>
shl    $0x3,%r8
mov    $0x1,%r10d
mov    0x8(%rsp),%r9
mov    $0x1,%esi
jmp    12d5 <fourn+0x1c5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %rcx,%rax
add    %r14,%r10
add    %r8,%r9
mov    %rax,%rsi
cmp    %r15,%r10
ja     1390 <fourn+0x280>
cmp    %r10,%rsi
jbe    12e7 <fourn+0x1d7>
lea    (%r10,%r14,1),%r11
add    $0xfffffffffffffffe,%r11
cmp    %r11,%r10
jbe    1310 <fourn+0x200>
mov    %r15,%rcx
nopw   0x0(%rax,%rax,1)
mov    %rsi,%rax
shr    %rcx
cmp    %r14,%rcx
jb     12c0 <fourn+0x1b0>
mov    %rax,%rsi
sub    %rcx,%rsi
ja     12f0 <fourn+0x1e0>
jmp    12c0 <fourn+0x1b0>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x0(,%rsi,4),%rcx
add    %r13,%rcx
mov    %r9,%rdx
mov    %r10,%rax
jmp    1341 <fourn+0x231>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x2,%rax
add    $0x8,%rdx
add    $0x8,%rcx
cmp    %r11,%rax
ja     12e7 <fourn+0x1d7>
cmp    %r12,%rax
ja     1330 <fourn+0x220>
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rdx,%rdi,4),%xmm0
movss  -0x4(%rcx,%rdi,4),%xmm1
movss  %xmm1,-0x4(%rdx,%rdi,4)
movss  %xmm0,-0x4(%rcx,%rdi,4)
movss  (%rdx,%rdi,4),%xmm0
movss  (%rcx,%rdi,4),%xmm1
movss  %xmm1,(%rdx,%rdi,4)
movss  %xmm0,(%rcx,%rdi,4)
add    %r15,%rdi
lea    (%rax,%rdi,1),%rbp
cmp    %r12,%rbp
jbe    1350 <fourn+0x240>
jmp    1330 <fourn+0x220>
nopw   0x0(%rax,%rax,1)
mov    %r14,%r13
cmp    %r15,%r14
jb     13a9 <fourn+0x299>
jmp    1220 <fourn+0x110>
nopl   (%rax)
cmp    %r15,%r13
jae    1220 <fourn+0x110>
mov    %r13,%rbp
add    %r13,%r13
mov    %r13,%rax
or     %r14,%rax
shr    $0x20,%rax
je     13d0 <fourn+0x2c0>
mov    %r13,%rax
xor    %edx,%edx
div    %r14
jmp    13d8 <fourn+0x2c8>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13d,%eax
xor    %edx,%edx
div    %r14d
movq   %rax,%xmm0
punpckldq 0xc3b(%rip),%xmm0
subpd  0xc43(%rip),%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  0x38(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x48(%rsp)
mulsd  0xbf7(%rip),%xmm0
call   1030 <sin@plt>
movapd %xmm0,0x50(%rsp)
movapd %xmm0,%xmm1
mulsd  0xbe8(%rip),%xmm1
movsd  %xmm1,0x40(%rsp)
movsd  0x48(%rsp),%xmm0
call   1030 <sin@plt>
movapd 0x50(%rsp),%xmm10
test   %rbp,%rbp
movaps 0xbf5(%rip),%xmm9
je     13a0 <fourn+0x290>
mulsd  0x40(%rsp),%xmm10
unpcklpd %xmm0,%xmm0
unpcklpd %xmm10,%xmm10
lea    (%rbx,%rbp,4),%rax
add    $0x4,%rax
mov    $0x1,%edx
movsd  0xba1(%rip),%xmm8
jmp    14aa <fourn+0x39a>
nopl   0x0(%rax)
xorps  %xmm9,%xmm2
movlhps %xmm8,%xmm2
mulpd  %xmm0,%xmm2
movaps %xmm8,%xmm1
mulpd  %xmm10,%xmm1
addpd  %xmm2,%xmm1
addpd  %xmm1,%xmm8
mov    %rcx,%rdx
cmp    %rbp,%rcx
ja     13a0 <fourn+0x290>
lea    (%rdx,%r14,1),%rcx
lea    (%rdx,%r14,1),%rsi
add    $0xfffffffffffffffe,%rsi
movaps %xmm8,%xmm2
unpckhpd %xmm8,%xmm2
cmp    %rsi,%rdx
ja     1480 <fourn+0x370>
xorps  %xmm1,%xmm1
cvtsd2ss %xmm8,%xmm1
xorps  %xmm4,%xmm4
cvtsd2ss %xmm2,%xmm4
jmp    14e9 <fourn+0x3d9>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rdx
cmp    %rsi,%rdx
ja     1480 <fourn+0x370>
cmp    %r12,%rdx
ja     14e0 <fourn+0x3d0>
mov    %rdx,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rax,%rdi,4),%xmm5
movss  (%rax,%rdi,4),%xmm6
movaps %xmm4,%xmm7
mulss  %xmm6,%xmm7
movaps %xmm1,%xmm3
mulss  %xmm5,%xmm3
subss  %xmm7,%xmm3
mulss  %xmm4,%xmm5
mulss  %xmm1,%xmm6
addss  %xmm5,%xmm6
movss  (%rbx,%rdi,4),%xmm5
subss  %xmm3,%xmm5
movss  %xmm5,-0x4(%rax,%rdi,4)
movss  0x4(%rbx,%rdi,4),%xmm5
movaps %xmm5,%xmm7
subss  %xmm6,%xmm7
movss  %xmm7,(%rax,%rdi,4)
addss  (%rbx,%rdi,4),%xmm3
movss  %xmm3,(%rbx,%rdi,4)
addss  %xmm5,%xmm6
movss  %xmm6,0x4(%rbx,%rdi,4)
add    %r13,%rdi
cmp    %r12,%rdi
jbe    1500 <fourn+0x3f0>
jmp    14e0 <fourn+0x3d0>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @fourn(float* nocapture %0, i32* nocapture %1, i32 %2, i32 %3) {
%5 = icmp slt i32 %2, 1
br i1 %5, label %215, label %6
6: ; preds = %4
%7 = add nuw i32 %2, 1
%8 = zext i32 %7 to i64
%9 = add nsw i64 %8, -1
%10 = add nsw i64 %8, -2
%11 = and i64 %9, 7
%12 = icmp ult i64 %10, 7
br i1 %12, label %15, label %13
13: ; preds = %6
%14 = and i64 %9, -8
br label %38
15: ; preds = %38, %6
%16 = phi i64 [ undef, %6 ], [ %80, %38 ]
%17 = phi i64 [ 1, %6 ], [ %81, %38 ]
%18 = phi i64 [ 1, %6 ], [ %80, %38 ]
%19 = icmp eq i64 %11, 0
br i1 %19, label %31, label %20
20: ; preds = %15, %20
%21 = phi i64 [ %28, %20 ], [ %17, %15 ]
%22 = phi i64 [ %27, %20 ], [ %18, %15 ]
%23 = phi i64 [ %29, %20 ], [ 0, %15 ]
%24 = getelementptr inbounds i32, i32* %1, i64 %21
%25 = load i32, i32* %24
%26 = zext i32 %25 to i64
%27 = mul i64 %22, %26
%28 = add nuw nsw i64 %21, 1
%29 = add i64 %23, 1
%30 = icmp eq i64 %29, %11
br i1 %30, label %31, label %20
31: ; preds = %20, %15
%32 = phi i64 [ %16, %15 ], [ %27, %20 ]
%33 = icmp sgt i32 %2, 0
br i1 %33, label %34, label %215
34: ; preds = %31
%35 = sitofp i32 %3 to double
%36 = fmul double %35, 0x401921FB54442D1C
%37 = zext i32 %2 to i64
br label %84
38: ; preds = %38, %13
%39 = phi i64 [ 1, %13 ], [ %81, %38 ]
%40 = phi i64 [ 1, %13 ], [ %80, %38 ]
%41 = phi i64 [ 0, %13 ], [ %82, %38 ]
%42 = getelementptr inbounds i32, i32* %1, i64 %39
%43 = load i32, i32* %42
%44 = zext i32 %43 to i64
%45 = mul i64 %40, %44
%46 = add nuw nsw i64 %39, 1
%47 = getelementptr inbounds i32, i32* %1, i64 %46
%48 = load i32, i32* %47
%49 = zext i32 %48 to i64
%50 = mul i64 %45, %49
%51 = add nuw nsw i64 %39, 2
%52 = getelementptr inbounds i32, i32* %1, i64 %51
%53 = load i32, i32* %52
%54 = zext i32 %53 to i64
%55 = mul i64 %50, %54
%56 = add nuw nsw i64 %39, 3
%57 = getelementptr inbounds i32, i32* %1, i64 %56
%58 = load i32, i32* %57
%59 = zext i32 %58 to i64
%60 = mul i64 %55, %59
%61 = add nuw nsw i64 %39, 4
%62 = getelementptr inbounds i32, i32* %1, i64 %61
%63 = load i32, i32* %62
%64 = zext i32 %63 to i64
%65 = mul i64 %60, %64
%66 = add nuw nsw i64 %39, 5
%67 = getelementptr inbounds i32, i32* %1, i64 %66
%68 = load i32, i32* %67
%69 = zext i32 %68 to i64
%70 = mul i64 %65, %69
%71 = add nuw nsw i64 %39, 6
%72 = getelementptr inbounds i32, i32* %1, i64 %71
%73 = load i32, i32* %72
%74 = zext i32 %73 to i64
%75 = mul i64 %70, %74
%76 = add nuw nsw i64 %39, 7
%77 = getelementptr inbounds i32, i32* %1, i64 %76
%78 = load i32, i32* %77
%79 = zext i32 %78 to i64
%80 = mul i64 %75, %79
%81 = add nuw nsw i64 %39, 8
%82 = add i64 %41, 8
%83 = icmp eq i64 %82, %14
br i1 %83, label %15, label %38
84: ; preds = %34, %212
%85 = phi i64 [ %37, %34 ], [ %213, %212 ]
%86 = phi i64 [ 1, %34 ], [ %90, %212 ]
%87 = getelementptr inbounds i32, i32* %1, i64 %85
%88 = load i32, i32* %87
%89 = zext i32 %88 to i64
%90 = mul i64 %86, %89
%91 = udiv i64 %32, %90
%92 = shl i64 %86, 1
%93 = mul i64 %92, %89
%94 = mul i64 %93, %91
%95 = icmp eq i64 %93, 0
br i1 %95, label %96, label %98
96: ; preds = %138, %84
%97 = icmp ult i64 %92, %93
br i1 %97, label %144, label %212
98: ; preds = %84, %138
%99 = phi i64 [ %140, %138 ], [ 1, %84 ]
%100 = phi i64 [ %139, %138 ], [ 1, %84 ]
%101 = icmp ugt i64 %100, %99
br i1 %101, label %102, label %129
102: ; preds = %98
%103 = add i64 %99, %92
%104 = add i64 %103, -2
%105 = icmp ugt i64 %99, %104
br i1 %105, label %129, label %106
106: ; preds = %102
%107 = sub i64 %100, %99
br label %108
108: ; preds = %106, %126
%109 = phi i64 [ %99, %106 ], [ %127, %126 ]
%110 = icmp ugt i64 %109, %94
br i1 %110, label %126, label %111
111: ; preds = %108, %111
%112 = phi i64 [ %124, %111 ], [ %109, %108 ]
%113 = add i64 %107, %112
%114 = getelementptr inbounds float, float* %0, i64 %112
%115 = load float, float* %114
%116 = getelementptr inbounds float, float* %0, i64 %113
%117 = load float, float* %116
store float %117, float* %114
store float %115, float* %116
%118 = add i64 %112, 1
%119 = getelementptr inbounds float, float* %0, i64 %118
%120 = load float, float* %119
%121 = add i64 %113, 1
%122 = getelementptr inbounds float, float* %0, i64 %121
%123 = load float, float* %122
store float %123, float* %119
store float %120, float* %122
%124 = add i64 %112, %93
%125 = icmp ugt i64 %124, %94
br i1 %125, label %126, label %111
126: ; preds = %111, %108
%127 = add i64 %109, 2
%128 = icmp ugt i64 %127, %104
br i1 %128, label %129, label %108
129: ; preds = %126, %102, %98
br label %130
130: ; preds = %129, %130
%131 = phi i64 [ %133, %130 ], [ %93, %129 ]
%132 = phi i64 [ %137, %130 ], [ %100, %129 ]
%133 = lshr i64 %131, 1
%134 = icmp uge i64 %133, %92
%135 = icmp ugt i64 %132, %133
%136 = select i1 %134, i1 %135, i1 false
%137 = sub i64 %132, %133
br i1 %136, label %130, label %138
138: ; preds = %130
%139 = add i64 %132, %133
%140 = add i64 %99, %92
%141 = icmp ugt i64 %140, %93
br i1 %141, label %96, label %98
142: ; preds = %203, %144
%143 = icmp ult i64 %146, %93
br i1 %143, label %144, label %212
144: ; preds = %96, %142
%145 = phi i64 [ %146, %142 ], [ %92, %96 ]
%146 = shl i64 %145, 1
%147 = udiv i64 %146, %92
%148 = uitofp i64 %147 to double
%149 = fdiv double %36, %148
%150 = fmul double %149, 5.000000e-01
%151 = tail call double @sin(double %150)
%152 = fmul double %151, -2.000000e+00
%153 = fmul double %151, %152
%154 = tail call double @sin(double %149)
%155 = icmp eq i64 %145, 0
br i1 %155, label %142, label %156
156: ; preds = %144
%157 = insertelement <2 x double> poison, double %154, i64 0
%158 = shufflevector <2 x double> %157, <2 x double> poison, <2 x i32> zeroinitializer
%159 = insertelement <2 x double> poison, double %153, i64 0
%160 = shufflevector <2 x double> %159, <2 x double> poison, <2 x i32> zeroinitializer
br label %161
161: ; preds = %156, %203
%162 = phi i64 [ %164, %203 ], [ 1, %156 ]
%163 = phi <2 x double> [ %210, %203 ], [ <double 1.000000e+00, double 0.000000e+00>, %156 ]
%164 = add i64 %162, %92
%165 = add i64 %164, -2
%166 = icmp ugt i64 %162, %165
br i1 %166, label %203, label %167
167: ; preds = %161
%168 = extractelement <2 x double> %163, i64 0
%169 = fptrunc double %168 to float
%170 = extractelement <2 x double> %163, i64 1
%171 = fptrunc double %170 to float
br label %172
172: ; preds = %167, %200
%173 = phi i64 [ %162, %167 ], [ %201, %200 ]
%174 = icmp ugt i64 %173, %94
br i1 %174, label %200, label %175
175: ; preds = %172, %175
%176 = phi i64 [ %198, %175 ], [ %173, %172 ]
%177 = add i64 %176, %145
%178 = getelementptr inbounds float, float* %0, i64 %177
%179 = load float, float* %178
%180 = add i64 %177, 1
%181 = getelementptr inbounds float, float* %0, i64 %180
%182 = load float, float* %181
%183 = fneg float %182
%184 = fmul float %171, %183
%185 = tail call float @llvm.fmuladd.f32(float %169, float %179, float %184)
%186 = fmul float %179, %171
%187 = tail call float @llvm.fmuladd.f32(float %169, float %182, float %186)
%188 = getelementptr inbounds float, float* %0, i64 %176
%189 = load float, float* %188
%190 = fsub float %189, %185
store float %190, float* %178
%191 = add i64 %176, 1
%192 = getelementptr inbounds float, float* %0, i64 %191
%193 = load float, float* %192
%194 = fsub float %193, %187
store float %194, float* %181
%195 = load float, float* %188
%196 = fadd float %185, %195
store float %196, float* %188
%197 = fadd float %187, %193
store float %197, float* %192
%198 = add i64 %176, %146
%199 = icmp ugt i64 %198, %94
br i1 %199, label %200, label %175
200: ; preds = %175, %172
%201 = add i64 %173, 2
%202 = icmp ugt i64 %201, %165
br i1 %202, label %203, label %172
203: ; preds = %200, %161
%204 = extractelement <2 x double> %163, i64 1
%205 = fneg double %204
%206 = insertelement <2 x double> poison, double %205, i64 0
%207 = shufflevector <2 x double> %206, <2 x double> %163, <2 x i32> <i32 0, i32 2>
%208 = fmul <2 x double> %158, %207
%209 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %163, <2 x double> %160, <2 x double> %208)
%210 = fadd <2 x double> %163, %209
%211 = icmp ugt i64 %164, %145
br i1 %211, label %142, label %161
212: ; preds = %142, %96
%213 = add nsw i64 %85, -1
%214 = icmp sgt i64 %85, 1
br i1 %214, label %84, label %215
215: ; preds = %212, %4, %31
ret void
}