#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 sqrt(double);
void invert(double a[], double ai[], double c[][16], int n, double *d,
            int *ifault) {
  double sum[29], b[29], bi[29];
  double tol, su;
  int jt, ij, ik, jj, ke, ijt, jk, i, ijl, j, i1, j1, ij1, j2, j3, j4, j5, ii,
      l, kl, n2, k;
  tol = 5.0e-08;
  *d = 1.0;
  *ifault = 4;
  jt = n * (n + 1) / 2 + 1;
  ij = jt - 1;
  c[1][1] = 1.0 / a[ij];
  for (i = 1; i <= ij; i++)
    sum[i] = 0.;
  for (ij = 1; ij <= n; ij++) {
    ik = n - ij;
    jt--;
    if (a[jt] <= sum[jt] + tol)
      return;
    b[jt] = sqrt(a[jt] - sum[jt]);
    (*d) *= b[jt] * b[jt];
    if (ik == 0)
      break;
    ijt = jt;
    for (jj = 1; jj <= ik; jj++) {
      jt--;
      b[jt] = (a[jt] - sum[jt]) / b[ijt];
    }
    i = 0;
    ke = ijt - 1;
    for (jj = jt; jj <= ke; jj++) {
      for (jk = jt; jk <= jj; jk++) {
        i++;
        sum[i] += b[jj] * b[jk];
      }
    }
  }
  bi[1] = 1. / b[1];
  for (i = 2; i <= n; i++) {
    ijt = i * (i + 1) / 2;
    bi[ijt] = 1. / b[ijt];
    ijl = ijt - i;
    ij = i - 1;
    for (j = 1; j <= ij; j++) {
      jt = ijt - j;
      kl = i - j + 1;
      su = 0.;
      for (k = kl; k <= i; k++)
        su += bi[ijl + k] * b[k * (k - 1) / 2 + kl - 1];
      bi[jt] = -su / b[kl * (kl - 1) / 2];
    }
  }
  if (n != 3) {
    n2 = n - 2;
    for (i1 = 2; i1 <= n2; i1++) {
      i = n - i1 + 1;
      j = 0;
      for (j1 = 1; j1 <= i1; j1++) {
        ij1 = ((i + j1 - 1) * (i + j1 - 2)) / 2;
        for (j2 = 1; j2 <= j1; j2++) {
          j++;
          c[i1][j] = 0.;
          j4 = i + j2 - 1;
          j5 = (j4 * (j4 - 1)) / 2;
          for (j3 = i; j3 <= j4; j3++)
            c[i1][j] += bi[ij1 + j3] * bi[j5 + j3];
        }
      }
    }
  }
  jt = 0;
  for (j = 1; j <= n; j++) {
    jj = j * (j - 1) / 2;
    for (i = 1; i <= j; i++) {
      ii = i * (i - 1) / 2;
      jt = jt + 1;
      ai[jt] = 0.;
      for (l = 1; l <= i; l++)
        ai[jt] += bi[ii + l] * bi[jj + l];
    }
  }
  *ifault = 0;
  return;
}


x86 assembly (clang, -O0):
<invert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x370,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  0xece(%rip),%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0xeb2(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
movl   $0x4,(%rax)
mov    -0x1c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x314(%rbp)
mov    -0x314(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x318(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x318(%rbp),%rcx
movsd  0xe65(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x88(%rax)
movl   $0x1,-0x330(%rbp)
mov    -0x330(%rbp),%eax
cmp    -0x318(%rbp),%eax
jg     11ef <invert+0xdf>
movslq -0x330(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
mov    -0x330(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x330(%rbp)
jmp    11b6 <invert+0xa6>
movl   $0x1,-0x318(%rbp)
mov    -0x318(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1446 <invert+0x336>
mov    -0x1c(%rbp),%eax
sub    -0x318(%rbp),%eax
mov    %eax,-0x31c(%rbp)
mov    -0x314(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x314(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x314(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x314(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x308(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     125d <invert+0x14d>
jmp    198b <invert+0x87b>
mov    -0x8(%rbp),%rax
movslq -0x314(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x314(%rbp),%rax
subsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
call   1030 <sqrt@plt>
movslq -0x314(%rbp),%rax
movsd  %xmm0,-0x210(%rbp,%rax,8)
ff ff
movslq -0x314(%rbp),%rax
movsd  -0x210(%rbp,%rax,8),%xmm0
ff ff
movslq -0x314(%rbp),%rax
mulsd  -0x210(%rbp,%rax,8),%xmm0
ff ff
mov    -0x28(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
cmpl   $0x0,-0x31c(%rbp)
jne    12d0 <invert+0x1c0>
jmp    1446 <invert+0x336>
mov    -0x314(%rbp),%eax
mov    %eax,-0x328(%rbp)
movl   $0x1,-0x320(%rbp)
mov    -0x320(%rbp),%eax
cmp    -0x31c(%rbp),%eax
jg     135b <invert+0x24b>
mov    -0x314(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x314(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x314(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x314(%rbp),%rax
subsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
movslq -0x328(%rbp),%rax
divsd  -0x210(%rbp,%rax,8),%xmm0
ff ff
movslq -0x314(%rbp),%rax
movsd  %xmm0,-0x210(%rbp,%rax,8)
ff ff
mov    -0x320(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x320(%rbp)
jmp    12e6 <invert+0x1d6>
movl   $0x0,-0x330(%rbp)
mov    -0x328(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x324(%rbp)
mov    -0x314(%rbp),%eax
mov    %eax,-0x320(%rbp)
mov    -0x320(%rbp),%eax
cmp    -0x324(%rbp),%eax
jg     142d <invert+0x31d>
mov    -0x314(%rbp),%eax
mov    %eax,-0x32c(%rbp)
mov    -0x32c(%rbp),%eax
cmp    -0x320(%rbp),%eax
jg     1414 <invert+0x304>
mov    -0x330(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x330(%rbp)
movslq -0x320(%rbp),%rax
movsd  -0x210(%rbp,%rax,8),%xmm0
ff ff
movslq -0x32c(%rbp),%rax
movsd  -0x210(%rbp,%rax,8),%xmm2
ff ff
movslq -0x330(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
mov    -0x32c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x32c(%rbp)
jmp    139e <invert+0x28e>
jmp    1419 <invert+0x309>
mov    -0x320(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x320(%rbp)
jmp    1380 <invert+0x270>
jmp    1432 <invert+0x322>
mov    -0x318(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x318(%rbp)
jmp    11f9 <invert+0xe9>
movsd  0xbb2(%rip),%xmm0
divsd  -0x208(%rbp),%xmm0
ff
movsd  %xmm0,-0x2f8(%rbp)
ff
movl   $0x2,-0x330(%rbp)
mov    -0x330(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     163e <invert+0x52e>
mov    -0x330(%rbp),%eax
mov    -0x330(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x328(%rbp)
movslq -0x328(%rbp),%rax
movsd  0xb5a(%rip),%xmm0
divsd  -0x210(%rbp,%rax,8),%xmm0
ff ff
movslq -0x328(%rbp),%rax
movsd  %xmm0,-0x300(%rbp,%rax,8)
ff ff
mov    -0x328(%rbp),%eax
sub    -0x330(%rbp),%eax
mov    %eax,-0x334(%rbp)
mov    -0x330(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x318(%rbp)
movl   $0x1,-0x338(%rbp)
mov    -0x338(%rbp),%eax
cmp    -0x318(%rbp),%eax
jg     1625 <invert+0x515>
mov    -0x328(%rbp),%eax
sub    -0x338(%rbp),%eax
mov    %eax,-0x314(%rbp)
mov    -0x330(%rbp),%eax
sub    -0x338(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x360(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
mov    -0x360(%rbp),%eax
mov    %eax,-0x368(%rbp)
mov    -0x368(%rbp),%eax
cmp    -0x330(%rbp),%eax
jg     15bd <invert+0x4ad>
mov    -0x334(%rbp),%eax
add    -0x368(%rbp),%eax
cltq
movsd  -0x300(%rbp,%rax,8),%xmm0
ff ff
mov    -0x368(%rbp),%eax
mov    -0x368(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    -0x360(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x210(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x310(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
mov    -0x368(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x368(%rbp)
jmp    153a <invert+0x42a>
movsd  -0x310(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x360(%rbp),%eax
mov    -0x360(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
divsd  -0x210(%rbp,%rax,8),%xmm0
ff ff
movslq -0x314(%rbp),%rax
movsd  %xmm0,-0x300(%rbp,%rax,8)
ff ff
mov    -0x338(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x338(%rbp)
jmp    14ea <invert+0x3da>
jmp    162a <invert+0x51a>
mov    -0x330(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x330(%rbp)
jmp    1468 <invert+0x358>
cmpl   $0x3,-0x1c(%rbp)
je     1833 <invert+0x723>
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x364(%rbp)
movl   $0x2,-0x33c(%rbp)
mov    -0x33c(%rbp),%eax
cmp    -0x364(%rbp),%eax
jg     182e <invert+0x71e>
mov    -0x1c(%rbp),%eax
sub    -0x33c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x330(%rbp)
movl   $0x0,-0x338(%rbp)
movl   $0x1,-0x340(%rbp)
mov    -0x340(%rbp),%eax
cmp    -0x33c(%rbp),%eax
jg     1815 <invert+0x705>
mov    -0x330(%rbp),%eax
add    -0x340(%rbp),%eax
sub    $0x1,%eax
mov    -0x330(%rbp),%ecx
add    -0x340(%rbp),%ecx
sub    $0x2,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x344(%rbp)
movl   $0x1,-0x348(%rbp)
mov    -0x348(%rbp),%eax
cmp    -0x340(%rbp),%eax
jg     17fc <invert+0x6ec>
mov    -0x338(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x338(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x33c(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x338(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x330(%rbp),%eax
add    -0x348(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x350(%rbp)
mov    -0x350(%rbp),%eax
mov    -0x350(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x354(%rbp)
mov    -0x330(%rbp),%eax
mov    %eax,-0x34c(%rbp)
mov    -0x34c(%rbp),%eax
cmp    -0x350(%rbp),%eax
jg     17e3 <invert+0x6d3>
mov    -0x344(%rbp),%eax
add    -0x34c(%rbp),%eax
cltq
movsd  -0x300(%rbp,%rax,8),%xmm0
ff ff
mov    -0x354(%rbp),%eax
add    -0x34c(%rbp),%eax
cltq
movsd  -0x300(%rbp,%rax,8),%xmm2
ff ff
mov    -0x18(%rbp),%rax
movslq -0x33c(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x338(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34c(%rbp)
jmp    1764 <invert+0x654>
jmp    17e8 <invert+0x6d8>
mov    -0x348(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x348(%rbp)
jmp    16e1 <invert+0x5d1>
jmp    1801 <invert+0x6f1>
mov    -0x340(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x340(%rbp)
jmp    1696 <invert+0x586>
jmp    181a <invert+0x70a>
mov    -0x33c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x33c(%rbp)
jmp    165e <invert+0x54e>
jmp    1833 <invert+0x723>
movl   $0x0,-0x314(%rbp)
movl   $0x1,-0x338(%rbp)
mov    -0x338(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1981 <invert+0x871>
mov    -0x338(%rbp),%eax
mov    -0x338(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x320(%rbp)
movl   $0x1,-0x330(%rbp)
mov    -0x330(%rbp),%eax
cmp    -0x338(%rbp),%eax
jg     1968 <invert+0x858>
mov    -0x330(%rbp),%eax
mov    -0x330(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x358(%rbp)
mov    -0x314(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x314(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x314(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x35c(%rbp)
mov    -0x35c(%rbp),%eax
cmp    -0x330(%rbp),%eax
jg     194f <invert+0x83f>
mov    -0x358(%rbp),%eax
add    -0x35c(%rbp),%eax
cltq
movsd  -0x300(%rbp,%rax,8),%xmm0
ff ff
mov    -0x320(%rbp),%eax
add    -0x35c(%rbp),%eax
cltq
movsd  -0x300(%rbp,%rax,8),%xmm2
ff ff
mov    -0x10(%rbp),%rax
movslq -0x314(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x35c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x35c(%rbp)
jmp    18de <invert+0x7ce>
jmp    1954 <invert+0x844>
mov    -0x330(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x330(%rbp)
jmp    1880 <invert+0x770>
jmp    196d <invert+0x85d>
mov    -0x338(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x338(%rbp)
jmp    1847 <invert+0x737>
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
add    $0x370,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x338,%rsp
mov    %ecx,%r13d
mov    %rsi,0x60(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %r8,0x40(%rsp)
mov    %rax,(%r8)
mov    %r9,0x58(%rsp)
movl   $0x4,(%r9)
lea    0x1(%r13),%ebp
mov    %ebp,%eax
imul   %ecx,%eax
mov    %eax,%r14d
shr    $0x1f,%r14d
add    %eax,%r14d
sar    %r14d
movslq %r14d,%r12
movsd  0xe88(%rip),%xmm0
divsd  (%rdi,%r12,8),%xmm0
mov    %rdx,0x68(%rsp)
movsd  %xmm0,0x88(%rdx)
cmp    $0x2,%eax
mov    %rdi,0x8(%rsp)
jl     11b5 <invert+0x95>
lea    0x258(%rsp),%rdi
lea    -0x1(%r14),%eax
lea    0x8(,%rax,8),%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x8(%rsp),%rdi
test   %r13d,%r13d
jle    1828 <invert+0x708>
mov    %ebp,0x4c(%rsp)
movsd  (%rdi,%r12,8),%xmm0
movsd  0x250(%rsp,%r12,8),%xmm1
movsd  0xe2e(%rip),%xmm2
addsd  %xmm1,%xmm2
ucomisd %xmm0,%xmm2
jae    1833 <invert+0x713>
lea    0x1(%r14),%r15d
lea    -0x1(%r13),%ebp
lea    -0x2(%r13),%eax
lea    -0x3(%r13),%ecx
mov    %ecx,0x30(%rsp)
lea    -0x18(%rdi),%rcx
mov    %rcx,0x50(%rsp)
mov    $0x1,%ebx
xor    %r9d,%r9d
xorpd  %xmm6,%xmm6
movsd  0xdef(%rip),%xmm7
mov    %eax,0x28(%rsp)
mov    %eax,%r10d
mov    %r13d,%r11d
mov    %r13,(%rsp)
jmp    1277 <invert+0x157>
nopl   0x0(%rax)
mov    (%rsp),%r13
mov    %r14d,%r15d
add    $0x1,%ebx
add    $0xffffffff,%r11d
mov    %r13d,%ebp
sub    %ebx,%ebp
lea    -0x1(%r15),%r14d
movslq %r15d,%rax
lea    -0x1(%rax),%r12
movsd  -0x8(%rdi,%rax,8),%xmm0
movsd  0x248(%rsp,%rax,8),%xmm1
movapd %xmm1,%xmm2
addsd  %xmm7,%xmm2
add    $0x1,%r9d
add    $0xffffffff,%r10d
ucomisd %xmm0,%xmm2
jae    1833 <invert+0x713>
subsd  %xmm1,%xmm0
mov    %r10d,%r13d
and    $0xfffffffe,%r13d
ucomisd %xmm6,%xmm0
jb     1290 <invert+0x170>
sqrtsd %xmm0,%xmm0
jmp    12ca <invert+0x1aa>
xchg   %ax,%ax
mov    %r11d,0x18(%rsp)
mov    %r15,0x10(%rsp)
mov    %r9,%r15
mov    %r10d,0x20(%rsp)
call   1040 <sqrt@plt>
mov    0x20(%rsp),%r10d
movsd  0xd54(%rip),%xmm7
xorpd  %xmm6,%xmm6
mov    %r15,%r9
mov    0x10(%rsp),%r15
mov    0x18(%rsp),%r11d
mov    0x8(%rsp),%rdi
neg    %r13d
mov    0x28(%rsp),%eax
sub    %r9d,%eax
movsd  %xmm0,0x70(%rsp,%r12,8)
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mov    0x40(%rsp),%rcx
mulsd  (%rcx),%xmm1
movsd  %xmm1,(%rcx)
test   %ebp,%ebp
je     1554 <invert+0x434>
jle    1230 <invert+0x110>
movslq %r15d,%rsi
movsd  -0x10(%rdi,%rsi,8),%xmm1
subsd  0x240(%rsp,%rsi,8),%xmm1
lea    -0x2(%rsi),%r8
divsd  %xmm0,%xmm1
movsd  %xmm1,0x60(%rsp,%rsi,8)
cmp    $0x2,%r11d
jne    1330 <invert+0x210>
mov    (%rsp),%r13
jmp    13c7 <invert+0x2a7>
nopl   (%rax)
cmp    %r9d,0x30(%rsp)
je     139c <invert+0x27c>
lea    0x58(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
lea    0x238(%rsp),%rdx
lea    (%rdx,%rsi,8),%rdx
mov    0x50(%rsp),%rbp
lea    0x0(%rbp,%rsi,8),%rbp
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,8),%xmm0
subsd  (%rdx,%rsi,8),%xmm0
divsd  0x70(%rsp,%r12,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movsd  -0x8(%rbp,%rsi,8),%xmm0
subsd  -0x8(%rdx,%rsi,8),%xmm0
divsd  0x70(%rsp,%r12,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rsi,8)
add    $0xfffffffffffffffe,%rsi
cmp    %esi,%r13d
jne    1360 <invert+0x240>
add    %rsi,%r8
test   $0x1,%al
mov    (%rsp),%r13
je     13c7 <invert+0x2a7>
movsd  -0x8(%rdi,%r8,8),%xmm0
subsd  0x248(%rsp,%r8,8),%xmm0
divsd  0x70(%rsp,%r12,8),%xmm0
movsd  %xmm0,0x68(%rsp,%r8,8)
add    $0xffffffffffffffff,%r8
add    $0xfffffffe,%r15d
cmp    %r8d,%r15d
jge    13e0 <invert+0x2c0>
mov    %r8d,%r14d
jmp    1234 <invert+0x114>
nopl   0x0(%rax,%rax,1)
mov    %r11d,0x18(%rsp)
mov    %r10d,0x20(%rsp)
mov    %r9,0x38(%rsp)
mov    %ebx,0x10(%rsp)
movslq %r8d,%r9
lea    0x58(%rsp),%rax
lea    (%rax,%r9,8),%rdx
add    $0x28,%rdx
lea    0x1(%r8),%r13d
xor    %r15d,%r15d
mov    $0x1,%eax
mov    %r9,%rcx
xor    %r10d,%r10d
jmp    1435 <invert+0x315>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x1,%rax
add    $0x1,%r13d
cmp    %ecx,%r14d
je     1530 <invert+0x410>
add    $0x1,%r15
cmp    %r9,%rcx
jl     1420 <invert+0x300>
movsd  0x70(%rsp,%rcx,8),%xmm0
movslq %r10d,%rsi
cmp    $0x4,%r15
jae    1460 <invert+0x340>
mov    %rsi,%r10
mov    %r9,%r11
jmp    14d3 <invert+0x3b3>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,%rbp
and    $0xfffffffffffffffc,%rbp
mov    %r15,%r12
and    $0xfffffffffffffffc,%r12
lea    (%r12,%rsi,1),%r10
lea    (%r9,%r12,1),%r11
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    0x238(%rsp),%rdi
lea    (%rdi,%rsi,8),%rbx
add    $0x30,%rbx
xor    %edi,%edi
movupd -0x10(%rdx,%rdi,8),%xmm2
movupd (%rdx,%rdi,8),%xmm3
movupd -0x10(%rbx,%rdi,8),%xmm4
movupd (%rbx,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%rbx,%rdi,8)
movupd %xmm3,(%rbx,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    1490 <invert+0x370>
cmp    %r12,%r15
je     1420 <invert+0x300>
lea    0x238(%rsp),%rsi
lea    (%rsi,%r10,8),%rdi
add    $0x20,%rdi
lea    (%rsp,%r11,8),%rbx
add    $0x70,%rbx
mov    %r13d,%ebp
sub    %r11d,%ebp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rsi,8),%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
add    $0x1,%rsi
cmp    %esi,%ebp
jne    1500 <invert+0x3e0>
add    %rsi,%r10
jmp    1420 <invert+0x300>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r8d,%r14d
mov    (%rsp),%r13
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%ebx
mov    0x38(%rsp),%r9
mov    0x20(%rsp),%r10d
mov    0x18(%rsp),%r11d
jmp    1234 <invert+0x114>
movsd  0xaa4(%rip),%xmm0
divsd  0x78(%rsp),%xmm0
movsd  %xmm0,0x168(%rsp)
cmpl   $0x2,(%rsp)
jl     16f4 <invert+0x5d4>
mov    0x4c(%rsp),%eax
mov    %rax,0x30(%rsp)
mov    $0x2,%r9d
movabs $0x100000001,%r11
mov    $0x6,%r13d
mov    $0x1,%r14d
movapd 0xa6e(%rip),%xmm0
mov    $0x6,%eax
nopw   0x0(%rax,%rax,1)
mov    %eax,0x10(%rsp)
mov    %r13d,0x8(%rsp)
shr    %r13d
lea    0x1(%r9),%rax
mov    %rax,0x38(%rsp)
imul   %r9d,%eax
shr    %eax
movsd  0xa2d(%rip),%xmm1
divsd  0x70(%rsp,%rax,8),%xmm1
mov    %rax,0x18(%rsp)
movsd  %xmm1,0x160(%rsp,%rax,8)
mov    %r14,0x28(%rsp)
mov    %r11,0x40(%rsp)
mov    $0x1,%edi
mov    %r9,%r8
nopl   0x0(%rax)
mov    0x18(%rsp),%rax
sub    %rdi,%rax
mov    %rax,0x20(%rsp)
mov    %r9,%rbp
sub    %rdi,%rbp
lea    0x1(%rbp),%rbx
xorpd  %xmm1,%xmm1
mov    %r14,%rsi
mov    %r13d,%r10d
mov    %r11,%rax
mov    %r8,%rcx
nopw   0x0(%rax,%rax,1)
movslq %r10d,%r10
movsd  0x160(%rsp,%r10,8),%xmm2
mov    %eax,%r12d
imul   %ecx,%r12d
mov    %r12d,%r15d
shr    $0x1f,%r15d
add    %r12d,%r15d
sar    %r15d
add    %ebp,%r15d
movslq %r15d,%rdx
mulsd  0x70(%rsp,%rdx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
add    $0x1,%rax
add    $0x1,%r10d
add    $0x1,%rsi
cmp    %r9,%rsi
jl     1630 <invert+0x510>
xorpd  %xmm0,%xmm1
imul   %ebp,%ebx
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
cltq
divsd  0x70(%rsp,%rax,8),%xmm1
mov    0x20(%rsp),%rax
movsd  %xmm1,0x160(%rsp,%rax,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%r8
add    $0xffffffffffffffff,%r11
add    $0xffffffff,%r13d
add    $0xffffffffffffffff,%r14
cmp    %r9,%rdi
jne    1600 <invert+0x4e0>
mov    0x40(%rsp),%r11
add    $0x1,%r11
mov    0x8(%rsp),%r13d
mov    0x10(%rsp),%eax
add    %eax,%r13d
add    $0x2,%eax
mov    0x28(%rsp),%r14
add    $0x1,%r14
mov    0x38(%rsp),%r9
cmp    0x30(%rsp),%r9
jne    15b0 <invert+0x490>
cmpl   $0x4,(%rsp)
jge    1845 <invert+0x725>
mov    (%rsp),%r13
test   %r13d,%r13d
jle    1828 <invert+0x708>
lea    0x168(%rsp),%r10
mov    $0x1,%r9d
xor    %r8d,%r8d
jmp    1730 <invert+0x610>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%r9),%eax
cmp    %r13d,%r9d
mov    %eax,%r9d
je     1828 <invert+0x708>
lea    -0x1(%r9),%eax
imul   %r9d,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
movslq %ecx,%r11
movslq %r8d,%r12
lea    (%r12,%r9,1),%r8d
movslq %r8d,%r14
lea    (%r10,%r11,8),%rbx
mov    $0x1,%ebp
xor    %r15d,%r15d
jmp    1774 <invert+0x654>
nopl   0x0(%rax)
mov    0x60(%rsp),%rax
movsd  %xmm0,(%rax,%r12,8)
add    $0x1,%rbp
cmp    %r14,%r12
je     1720 <invert+0x600>
mov    %r15,%rcx
add    $0x1,%r15
lea    -0x1(%rbp),%eax
imul   %ebp,%eax
mov    %eax,%edx
shr    $0x1f,%edx
add    %eax,%edx
sar    %edx
movslq %edx,%rax
test   %rcx,%rcx
je     17f0 <invert+0x6d0>
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
lea    (%r10,%rax,8),%rcx
xorpd  %xmm1,%xmm1
mov    $0x1,%esi
nopl   0x0(%rax)
movsd  -0x8(%rcx,%rsi,8),%xmm2
mulsd  -0x8(%rbx,%rsi,8),%xmm2
movsd  (%rcx,%rsi,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  (%rbx,%rsi,8),%xmm0
addsd  %xmm2,%xmm0
lea    (%rdx,%rsi,1),%rdi
add    $0x2,%rdi
add    $0x2,%rsi
movapd %xmm0,%xmm1
cmp    $0x1,%rdi
jne    17b0 <invert+0x690>
jmp    17f9 <invert+0x6d9>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
mov    $0x1,%esi
add    $0x1,%r12
test   $0x1,%r15b
je     1760 <invert+0x640>
add    %rsi,%rax
movsd  0x160(%rsp,%rax,8),%xmm1
add    %r11,%rsi
mulsd  0x160(%rsp,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1760 <invert+0x640>
mov    0x58(%rsp),%rax
movl   $0x0,(%rax)
add    $0x338,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    (%rsp),%rax
lea    -0x2(%rax),%ecx
add    $0xffffffff,%eax
movl   $0x3,0x8(%rsp)
mov    $0x2,%r13d
xorpd  %xmm0,%xmm0
mov    %rax,0x30(%rsp)
mov    %rax,0x28(%rsp)
jmp    1891 <invert+0x771>
nopl   (%rax)
add    $0x1,%r13
mov    0x38(%rsp),%ecx
add    $0xffffffff,%ecx
addl   $0x1,0x8(%rsp)
addq   $0xffffffffffffffff,0x28(%rsp)
cmp    0x30(%rsp),%r13
je     16f4 <invert+0x5d4>
mov    %ecx,0x38(%rsp)
movslq %ecx,%rbp
mov    (%rsp),%rax
sub    %r13d,%eax
lea    -0x1(%rax),%ecx
mov    %rcx,0x10(%rsp)
lea    0x1(%rbp),%rcx
xor    %ebx,%ebx
mov    $0x1,%edi
jmp    18d2 <invert+0x7b2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x18(%rsp),%rdi
add    $0x1,%edi
cmp    0x8(%rsp),%edi
mov    0x40(%rsp),%ebx
je     1870 <invert+0x750>
lea    (%rdi,%rax,1),%edx
mov    0x10(%rsp),%rsi
add    %edi,%esi
imul   %edx,%esi
mov    %esi,%edx
shr    $0x1f,%edx
add    %esi,%edx
sar    %edx
movslq %edx,%rsi
movslq %ebx,%r14
mov    %rdi,0x18(%rsp)
lea    (%r14,%rdi,1),%edx
mov    %edx,0x40(%rsp)
movslq %edx,%rdx
lea    (%rcx,%rsi,1),%rdi
mov    %rdi,0x20(%rsp)
lea    0x170(%rsp),%rdi
lea    (%rdi,%rsi,8),%r9
mov    0x28(%rsp),%r11
xor    %r10d,%r10d
mov    $0x1,%r12d
jmp    1954 <invert+0x834>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdi,%r14,8),%rsi
add    $0x8,%rsi
movsd  %xmm1,(%rsi)
add    $0x1,%r12d
add    $0x1,%r10d
add    $0x1,%r11
mov    %r15,%r14
cmp    %rdx,%r15
je     18c0 <invert+0x7a0>
lea    0x1(%r14),%r15
mov    %r13,%rdi
shl    $0x7,%rdi
add    0x68(%rsp),%rdi
movq   $0x0,0x8(%rdi,%r14,8)
lea    (%r12,%rax,1),%esi
cmp    %esi,%eax
jge    193c <invert+0x81c>
lea    -0x1(%rsi),%ebx
imul   %esi,%ebx
mov    %ebx,%esi
shr    $0x1f,%esi
add    %ebx,%esi
sar    %esi
movslq %esi,%rsi
xorpd  %xmm2,%xmm2
mov    %rbp,%rbx
test   $0x1,%r12b
je     19ba <invert+0x89a>
mov    0x20(%rsp),%rbx
movsd  0x160(%rsp,%rbx,8),%xmm1
lea    (%rcx,%rsi,1),%rbx
mulsd  0x160(%rsp,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
mov    %rcx,%rbx
movapd %xmm1,%xmm2
test   %r10d,%r10d
je     1930 <invert+0x810>
lea    0x170(%rsp),%r8
lea    (%r8,%rsi,8),%rsi
nop
movsd  -0x8(%r9,%rbx,8),%xmm3
movsd  (%r9,%rbx,8),%xmm1
mulsd  -0x8(%rsi,%rbx,8),%xmm3
mulsd  (%rsi,%rbx,8),%xmm1
addsd  %xmm2,%xmm3
add    $0x2,%rbx
addsd  %xmm3,%xmm1
movapd %xmm1,%xmm2
cmp    %ebx,%r11d
jne    19d0 <invert+0x8b0>
jmp    1930 <invert+0x810>

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

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