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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
float fabs(double);
float sqrt(float);
int jacobi(double **a, double *d, double **v) {
  int nrot = 0;
  const unsigned int nmax = 100, n = 3;
  double b[nmax], z[nmax], tresh, sm, g, h, t, theta, c, s, tau;
  int i, j, ip, iq;
  for (ip = 1; ip <= n; ip++) {
    for (iq = 1; iq <= n; iq++)
      v[ip][iq] = 0.0f;
    v[ip][ip] = 1.0f;
  }
  for (ip = 1; ip <= n; ip++) {
    b[ip] = d[ip] = a[ip][ip];
    z[ip] = 0.0f;
  }
  for (i = 1; i <= 50; i++) {
    sm = 0.0f;
    for (ip = 1; ip <= n - 1; ip++) {
      for (iq = ip + 1; iq <= n; iq++)
        sm += fabs(a[ip][iq]);
    }
    if (sm == 0.0f)
      return (0);
    if (i < 4) {
      tresh = 0.2f * sm / (n * n);
    } else {
      tresh = 0.0f;
    }
    for (ip = 1; ip <= n - 1; ip++) {
      for (iq = ip + 1; iq <= n; iq++) {
        g = 100.0f * fabs(a[ip][iq]);
        if ((i > 4) && (double)(fabs(d[ip]) + g) == (double)fabs(d[ip]) &&
            (double)(fabs(d[iq]) + g) == (double)fabs(d[iq]))
          a[ip][iq] = 0.0f;
        else if (fabs(a[ip][iq]) > tresh) {
          h = d[iq] - d[ip];
          if ((fabs(h) + g) == fabs(h))
            t = a[ip][iq] / h;
          else {
            theta = 0.5f * h / (a[ip][iq]);
            t = 1.0f / (fabs(theta) + sqrt(1.0f + theta * theta));
            if (theta < 0.0f)
              t *= -1.0f;
          }
          c = 1.0f / sqrt(1.0f + t * t);
          s = t * c;
          tau = s / (1.0f + c);
          h = t * a[ip][iq];
          z[ip] -= h;
          z[iq] += h;
          d[ip] -= h;
          d[iq] += h;
          a[ip][iq] = 0.0f;
          for (j = 1; j <= ip - 1; j++) {
            g = a[j][ip];
            h = a[j][iq];
            a[j][ip] = g - s * (h + g * tau);
            a[j][iq] = h + s * (g - h * tau);
            ;
          }
          for (j = ip + 1; j <= iq - 1; j++) {
            g = a[ip][j];
            h = a[j][iq];
            a[ip][j] = g - s * (h + g * tau);
            a[j][iq] = h + s * (g - h * tau);
            ;
          }
          for (j = iq + 1; j <= n; j++) {
            g = a[ip][j];
            h = a[iq][j];
            a[ip][j] = g - s * (h + g * tau);
            a[iq][j] = h + s * (g - h * tau);
            ;
          }
          for (j = 1; j <= n; j++) {
            g = v[j][ip];
            h = v[j][iq];
            v[j][ip] = g - s * (h + g * tau);
            v[j][iq] = h + s * (g - h * tau);
            ;
          }
          ++nrot;
        }
      }
    }
    for (ip = 1; ip <= n; ip++) {
      b[ip] += z[ip];
      d[ip] = b[ip];
      z[ip] = 0.0f;
    }
  }
  assert(i < 50);
  return 1;
}


x86 assembly (clang, -O0):
<jacobi>:
push   %rbp
mov    %rsp,%rbp
sub    $0x700,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x64,-0x28(%rbp)
movl   $0x3,-0x2c(%rbp)
mov    %rsp,%rax
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x8c(%rbp)
cmpl   $0x3,-0x8c(%rbp)
ja     11fa <jacobi+0xca>
movl   $0x1,-0x90(%rbp)
cmpl   $0x3,-0x90(%rbp)
ja     11c3 <jacobi+0x93>
mov    -0x20(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1184 <jacobi+0x54>
mov    -0x20(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  0xe2f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    116d <jacobi+0x3d>
movl   $0x1,-0x8c(%rbp)
cmpl   $0x3,-0x8c(%rbp)
ja     1273 <jacobi+0x143>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x8c(%rbp),%rax
movsd  %xmm0,-0x3c0(%rbp,%rax,8)
ff ff
movslq -0x8c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x6e0(%rbp,%rax,8)
ff ff
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1204 <jacobi+0xd4>
movl   $0x1,-0x84(%rbp)
cmpl   $0x32,-0x84(%rbp)
jg     1ce1 <jacobi+0xbb1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x1,-0x8c(%rbp)
cmpl   $0x2,-0x8c(%rbp)
ja     1320 <jacobi+0x1f0>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x3,-0x90(%rbp)
ja     1307 <jacobi+0x1d7>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    12b8 <jacobi+0x188>
jmp    130c <jacobi+0x1dc>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    129c <jacobi+0x16c>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    134e <jacobi+0x21e>
jp     134e <jacobi+0x21e>
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x94(%rbp)
jmp    1d06 <jacobi+0xbd6>
cmpl   $0x4,-0x84(%rbp)
jge    137e <jacobi+0x24e>
movsd  0xca5(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  0xc90(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1386 <jacobi+0x256>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x1,-0x8c(%rbp)
cmpl   $0x2,-0x8c(%rbp)
ja     1c41 <jacobi+0xb11>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x3,-0x90(%rbp)
ja     1c28 <jacobi+0xaf8>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movss  0xc44(%rip),%xmm0
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
cmpl   $0x4,-0x84(%rbp)
jle    14d5 <jacobi+0x3a5>
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x6e8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movsd  -0x6e8(%rbp),%xmm0
ff
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14d5 <jacobi+0x3a5>
jp     14d5 <jacobi+0x3a5>
mov    -0x18(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x6f0(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movsd  -0x6f0(%rbp),%xmm0
ff
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14d5 <jacobi+0x3a5>
jp     14d5 <jacobi+0x3a5>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c0f <jacobi+0xadf>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1c0a <jacobi+0xada>
mov    -0x18(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x6f8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movsd  -0x6f8(%rbp),%xmm0
ff
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1597 <jacobi+0x467>
jp     1597 <jacobi+0x467>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    163f <jacobi+0x50f>
movsd  0xa79(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x6fc(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa24(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1050 <sqrt@plt>
movss  -0x6fc(%rbp),%xmm1
addss  %xmm0,%xmm1
movss  0xa1f(%rip),%xmm0
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    163a <jacobi+0x50a>
movsd  0x9f0(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    163f <jacobi+0x50f>
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x9bb(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movss  0x9bf(%rip),%xmm0
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  0x97a(%rip),%xmm1
addsd  -0x70(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movslq -0x8c(%rbp),%rax
movsd  -0x6e0(%rbp,%rax,8),%xmm0
ff ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x6e0(%rbp,%rax,8)
ff ff
movsd  -0x58(%rbp),%xmm0
movslq -0x90(%rbp),%rax
addsd  -0x6e0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x6e0(%rbp,%rax,8)
ff ff
movsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x90(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x8c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     188a <jacobi+0x75a>
mov    -0x10(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm3
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm3
movsd  -0x58(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1769 <jacobi+0x639>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x90(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     19ba <jacobi+0x88a>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm3
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm3
movsd  -0x58(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1899 <jacobi+0x769>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
cmpl   $0x3,-0x88(%rbp)
ja     1ae0 <jacobi+0x9b0>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm3
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm3
movsd  -0x58(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    19c9 <jacobi+0x899>
movl   $0x1,-0x88(%rbp)
cmpl   $0x3,-0x88(%rbp)
ja     1c01 <jacobi+0xad1>
mov    -0x20(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm3
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm3
movsd  -0x58(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1aea <jacobi+0x9ba>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1c0f <jacobi+0xadf>
jmp    1c14 <jacobi+0xae4>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    13ac <jacobi+0x27c>
jmp    1c2d <jacobi+0xafd>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1390 <jacobi+0x260>
movl   $0x1,-0x8c(%rbp)
cmpl   $0x3,-0x8c(%rbp)
ja     1cc8 <jacobi+0xb98>
movslq -0x8c(%rbp),%rax
movsd  -0x6e0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x8c(%rbp),%rax
addsd  -0x3c0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3c0(%rbp,%rax,8)
ff ff
movslq -0x8c(%rbp),%rax
movsd  -0x3c0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x8c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x6e0(%rbp,%rax,8)
ff ff
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1c4b <jacobi+0xb1b>
jmp    1ccd <jacobi+0xb9d>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    127d <jacobi+0x14d>
cmpl   $0x32,-0x84(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
movl   $0x1,-0x4(%rbp)
movl   $0x1,-0x94(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
add    $0x700,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jacobi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x378,%rsp
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%r15
mov    0x8(%rdx),%rax
xorps  %xmm0,%xmm0
movups %xmm0,0x10(%rax)
movabs $0x3ff0000000000000,%rcx
mov    %rcx,0x8(%rax)
mov    0x10(%rdx),%rax
movups %xmm0,0x8(%rax)
movq   $0x0,0x18(%rax)
mov    %rcx,0x10(%rax)
mov    0x18(%rdx),%rax
movups %xmm0,0x8(%rax)
mov    %rcx,0x18(%rax)
movups %xmm0,0x58(%rsp)
movq   $0x0,0x68(%rsp)
mov    0x8(%rdi),%rax
movsd  0x8(%rax),%xmm1
movsd  %xmm1,0x8(%rsi)
mov    0x10(%rdi),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rsi)
mov    0x18(%rdi),%rax
movsd  0x18(%rax),%xmm2
movsd  %xmm2,0x18(%rsi)
unpcklpd %xmm0,%xmm1
mov    $0x1,%ebp
jmp    1215 <jacobi+0xe5>
cs nopw 0x0(%rax,%rax,1)
movupd 0x58(%rsp),%xmm0
movapd 0x40(%rsp),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0x8(%rbx)
xorpd  %xmm0,%xmm0
movupd %xmm0,0x58(%rsp)
movsd  0x30(%rsp),%xmm2
addsd  0x68(%rsp),%xmm2
movsd  %xmm2,0x18(%rbx)
movq   $0x0,0x68(%rsp)
add    $0x1,%ebp
cmp    $0x33,%ebp
je     1769 <jacobi+0x639>
movsd  %xmm2,0x30(%rsp)
movapd %xmm1,0x40(%rsp)
mov    0x8(%r15),%rax
movsd  0x10(%rax),%xmm0
call   1030 <fabs@plt>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    0x8(%r15),%rax
movsd  0x18(%rax),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x10(%r15),%rax
movsd  0x18(%rax),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
addsd  0x10(%rsp),%xmm0
ucomisd 0xd9f(%rip),%xmm0
jne    1289 <jacobi+0x159>
jnp    1777 <jacobi+0x647>
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x28(%rsp)
cmp    $0x3,%ebp
ja     12ae <jacobi+0x17e>
mulsd  0xd60(%rip),%xmm0
divsd  0xd60(%rip),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    $0x2,%r12d
mov    $0x1,%r13d
jmp    12d8 <jacobi+0x1a8>
nopl   0x0(%rax)
mov    0x38(%rsp),%r12
add    $0x1,%r12
mov    0x20(%rsp),%r13
cmp    $0x3,%r13
je     11d0 <jacobi+0xa0>
lea    0x1(%r13),%rax
mov    %rax,0x20(%rsp)
mov    %r12,0x38(%rsp)
jmp    1416 <jacobi+0x2e6>
nopl   0x0(%rax,%rax,1)
mov    (%r15,%r12,8),%rcx
movapd %xmm0,%xmm2
xorpd  0xd40(%rip),%xmm2
movsd  0x18(%rax),%xmm3
movsd  0x18(%rcx),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm0,%xmm5
movapd %xmm3,%xmm6
subsd  %xmm5,%xmm6
movsd  %xmm6,0x18(%rax)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,0x18(%rcx)
mov    0x8(%r14),%rax
movsd  (%rax,%r13,8),%xmm3
movsd  (%rax,%r12,8),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rax,%r13,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rax,%r12,8)
mov    0x10(%r14),%rax
movsd  (%rax,%r13,8),%xmm3
movsd  (%rax,%r12,8),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rax,%r13,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rax,%r12,8)
mov    0x18(%r14),%rax
movsd  (%rax,%r13,8),%xmm3
movsd  (%rax,%r12,8),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rax,%r13,8)
mulsd  %xmm4,%xmm1
subsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rax,%r12,8)
add    $0x1,%r12
cmp    $0x4,%r12
je     12c0 <jacobi+0x190>
mov    (%r15,%r13,8),%rax
movsd  (%rax,%r12,8),%xmm0
call   1030 <fabs@plt>
mulss  0xbfb(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
cmp    $0x5,%ebp
jb     14d0 <jacobi+0x3a0>
movsd  (%rbx,%r13,8),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%rbx,%r13,8),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jne    14d0 <jacobi+0x3a0>
jp     14d0 <jacobi+0x3a0>
movsd  (%rbx,%r12,8),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%rbx,%r12,8),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jne    14d0 <jacobi+0x3a0>
jp     14d0 <jacobi+0x3a0>
mov    (%r15,%r13,8),%rax
movq   $0x0,(%rax,%r12,8)
jmp    1408 <jacobi+0x2d8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r15,%r13,8),%rax
movsd  (%rax,%r12,8),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
ucomisd 0x28(%rsp),%xmm0
jbe    1408 <jacobi+0x2d8>
movsd  (%rbx,%r12,8),%xmm0
subsd  (%rbx,%r13,8),%xmm0
movsd  %xmm0,0x8(%rsp)
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
movsd  0x10(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
cvtss2sd %xmm0,%xmm0
movsd  0x10(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jne    154c <jacobi+0x41c>
jp     154c <jacobi+0x41c>
mov    (%r15,%r13,8),%rax
movsd  (%rax,%r12,8),%xmm3
divsd  0x8(%rsp),%xmm3
jmp    15e0 <jacobi+0x4b0>
movsd  0x8(%rsp),%xmm0
mulsd  0xab6(%rip),%xmm0
mov    (%r15,%r13,8),%rax
divsd  (%rax,%r12,8),%xmm0
movsd  %xmm0,0x8(%rsp)
call   1030 <fabs@plt>
movapd %xmm0,%xmm2
movsd  0x8(%rsp),%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
addsd  0xa8f(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
ucomiss 0xa9c(%rip),%xmm0
jb     159c <jacobi+0x46c>
sqrtss %xmm0,%xmm0
jmp    15b3 <jacobi+0x483>
movss  %xmm2,0x10(%rsp)
call   1050 <sqrt@plt>
movss  0x10(%rsp),%xmm2
movsd  0x8(%rsp),%xmm1
addss  %xmm0,%xmm2
movss  0xa6d(%rip),%xmm0
divss  %xmm2,%xmm0
xorps  %xmm3,%xmm3
cvtss2sd %xmm0,%xmm3
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    15e0 <jacobi+0x4b0>
xorps  0xa66(%rip),%xmm3
nopw   0x0(%rax,%rax,1)
movaps %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  0xa29(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
ucomiss 0xa36(%rip),%xmm0
jb     1610 <jacobi+0x4e0>
sqrtss %xmm0,%xmm0
jmp    161f <jacobi+0x4ef>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps %xmm3,0x10(%rsp)
call   1050 <sqrt@plt>
movaps 0x10(%rsp),%xmm3
movss  0xa05(%rip),%xmm1
divss  %xmm0,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
movaps %xmm3,%xmm0
mulsd  %xmm2,%xmm0
mov    (%r15,%r13,8),%rax
mulsd  (%rax,%r12,8),%xmm3
addsd  0x9cd(%rip),%xmm2
movsd  0x50(%rsp,%r13,8),%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,0x50(%rsp,%r13,8)
movsd  0x50(%rsp,%r12,8),%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,0x50(%rsp,%r12,8)
movsd  (%rbx,%r13,8),%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rbx,%r13,8)
movapd %xmm0,%xmm1
addsd  (%rbx,%r12,8),%xmm3
divsd  %xmm2,%xmm1
movsd  %xmm3,(%rbx,%r12,8)
movq   $0x0,(%rax,%r12,8)
cmp    $0x2,%r13
jne    16e7 <jacobi+0x5b7>
mov    0x8(%r15),%rcx
movsd  0x10(%rcx),%xmm2
movsd  (%rcx,%r12,8),%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm4
movapd %xmm2,%xmm5
subsd  %xmm4,%xmm5
movsd  %xmm5,0x10(%rcx)
movapd %xmm3,%xmm4
mulsd  %xmm1,%xmm4
subsd  %xmm4,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%rcx,%r12,8)
cmp    %r12,0x20(%rsp)
jae    174e <jacobi+0x61e>
mov    0x10(%r15),%rcx
movapd %xmm0,%xmm2
xorpd  0x942(%rip),%xmm2
movsd  (%rcx,%r12,8),%xmm3
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x10(%rax),%xmm4
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm3,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,0x10(%rax)
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rcx,%r12,8)
cmp    $0x3,%r12
ja     1710 <jacobi+0x5e0>
cmp    $0x3,%r12
jb     12f0 <jacobi+0x1c0>
movapd %xmm0,%xmm2
xorpd  0x8dc(%rip),%xmm2
jmp    1340 <jacobi+0x210>
xor    %edi,%edi
call   1040 <assert@plt>
mov    $0x1,%eax
jmp    1779 <jacobi+0x649>
xor    %eax,%eax
add    $0x378,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @jacobi(double** %0, double* %1, double** %2) {
%4 = alloca i32
%5 = alloca double**
%6 = alloca double*
%7 = alloca double**
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
store double** %0, double*** %5
store double* %1, double** %6
store double** %2, double*** %7
store i32 0, i32* %8
store i32 100, i32* %9
store i32 3, i32* %10
%26 = call i8* @llvm.stacksave()
store i8* %26, i8** %11
%27 = alloca double, i64 100
%28 = alloca double, i64 100
store i32 1, i32* %23
br label %29
29: ; preds = %57, %3
%30 = load i32, i32* %23
%31 = icmp ule i32 %30, 3
br i1 %31, label %32, label %60
32: ; preds = %29
store i32 1, i32* %24
br label %33
33: ; preds = %45, %32
%34 = load i32, i32* %24
%35 = icmp ule i32 %34, 3
br i1 %35, label %36, label %48
36: ; preds = %33
%37 = load double**, double*** %7
%38 = load i32, i32* %23
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double*, double** %37, i64 %39
%41 = load double*, double** %40
%42 = load i32, i32* %24
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %41, i64 %43
store double 0.000000e+00, double* %44
br label %45
45: ; preds = %36
%46 = load i32, i32* %24
%47 = add nsw i32 %46, 1
store i32 %47, i32* %24
br label %33
48: ; preds = %33
%49 = load double**, double*** %7
%50 = load i32, i32* %23
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double*, double** %49, i64 %51
%53 = load double*, double** %52
%54 = load i32, i32* %23
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %53, i64 %55
store double 1.000000e+00, double* %56
br label %57
57: ; preds = %48
%58 = load i32, i32* %23
%59 = add nsw i32 %58, 1
store i32 %59, i32* %23
br label %29
60: ; preds = %29
store i32 1, i32* %23
br label %61
61: ; preds = %84, %60
%62 = load i32, i32* %23
%63 = icmp ule i32 %62, 3
br i1 %63, label %64, label %87
64: ; preds = %61
%65 = load double**, double*** %5
%66 = load i32, i32* %23
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double*, double** %65, i64 %67
%69 = load double*, double** %68
%70 = load i32, i32* %23
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds double, double* %69, i64 %71
%73 = load double, double* %72
%74 = load double*, double** %6
%75 = load i32, i32* %23
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double, double* %74, i64 %76
store double %73, double* %77
%78 = load i32, i32* %23
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %27, i64 %79
store double %73, double* %80
%81 = load i32, i32* %23
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds double, double* %28, i64 %82
store double 0.000000e+00, double* %83
br label %84
84: ; preds = %64
%85 = load i32, i32* %23
%86 = add nsw i32 %85, 1
store i32 %86, i32* %23
br label %61
87: ; preds = %61
store i32 1, i32* %21
br label %88
88: ; preds = %620, %87
%89 = load i32, i32* %21
%90 = icmp sle i32 %89, 50
br i1 %90, label %91, label %623
91: ; preds = %88
store double 0.000000e+00, double* %13
store i32 1, i32* %23
br label %92
92: ; preds = %119, %91
%93 = load i32, i32* %23
%94 = icmp ule i32 %93, 2
br i1 %94, label %95, label %122
95: ; preds = %92
%96 = load i32, i32* %23
%97 = add nsw i32 %96, 1
store i32 %97, i32* %24
br label %98
98: ; preds = %115, %95
%99 = load i32, i32* %24
%100 = icmp ule i32 %99, 3
br i1 %100, label %101, label %118
101: ; preds = %98
%102 = load double**, double*** %5
%103 = load i32, i32* %23
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double*, double** %102, i64 %104
%106 = load double*, double** %105
%107 = load i32, i32* %24
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double, double* %106, i64 %108
%110 = load double, double* %109
%111 = call float @fabs(double %110)
%112 = fpext float %111 to double
%113 = load double, double* %13
%114 = fadd double %113, %112
store double %114, double* %13
br label %115
115: ; preds = %101
%116 = load i32, i32* %24
%117 = add nsw i32 %116, 1
store i32 %117, i32* %24
br label %98
118: ; preds = %98
br label %119
119: ; preds = %118
%120 = load i32, i32* %23
%121 = add nsw i32 %120, 1
store i32 %121, i32* %23
br label %92
122: ; preds = %92
%123 = load double, double* %13
%124 = fcmp oeq double %123, 0.000000e+00
br i1 %124, label %125, label %126
125: ; preds = %122
store i32 0, i32* %4
store i32 1, i32* %25
br label %628
126: ; preds = %122
%127 = load i32, i32* %21
%128 = icmp slt i32 %127, 4
br i1 %128, label %129, label %133
129: ; preds = %126
%130 = load double, double* %13
%131 = fmul double 0x3FC99999A0000000, %130
%132 = fdiv double %131, 9.000000e+00
store double %132, double* %12
br label %134
133: ; preds = %126
store double 0.000000e+00, double* %12
br label %134
134: ; preds = %133, %129
store i32 1, i32* %23
br label %135
135: ; preds = %588, %134
%136 = load i32, i32* %23
%137 = icmp ule i32 %136, 2
br i1 %137, label %138, label %591
138: ; preds = %135
%139 = load i32, i32* %23
%140 = add nsw i32 %139, 1
store i32 %140, i32* %24
br label %141
141: ; preds = %584, %138
%142 = load i32, i32* %24
%143 = icmp ule i32 %142, 3
br i1 %143, label %144, label %587
144: ; preds = %141
%145 = load double**, double*** %5
%146 = load i32, i32* %23
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds double*, double** %145, i64 %147
%149 = load double*, double** %148
%150 = load i32, i32* %24
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds double, double* %149, i64 %151
%153 = load double, double* %152
%154 = call float @fabs(double %153)
%155 = fmul float 1.000000e+02, %154
%156 = fpext float %155 to double
store double %156, double* %14
%157 = load i32, i32* %21
%158 = icmp sgt i32 %157, 4
br i1 %158, label %159, label %204
159: ; preds = %144
%160 = load double*, double** %6
%161 = load i32, i32* %23
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %160, i64 %162
%164 = load double, double* %163
%165 = call float @fabs(double %164)
%166 = fpext float %165 to double
%167 = load double, double* %14
%168 = fadd double %166, %167
%169 = load double*, double** %6
%170 = load i32, i32* %23
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %169, i64 %171
%173 = load double, double* %172
%174 = call float @fabs(double %173)
%175 = fpext float %174 to double
%176 = fcmp oeq double %168, %175
br i1 %176, label %177, label %204
177: ; preds = %159
%178 = load double*, double** %6
%179 = load i32, i32* %24
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %178, i64 %180
%182 = load double, double* %181
%183 = call float @fabs(double %182)
%184 = fpext float %183 to double
%185 = load double, double* %14
%186 = fadd double %184, %185
%187 = load double*, double** %6
%188 = load i32, i32* %24
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds double, double* %187, i64 %189
%191 = load double, double* %190
%192 = call float @fabs(double %191)
%193 = fpext float %192 to double
%194 = fcmp oeq double %186, %193
br i1 %194, label %195, label %204
195: ; preds = %177
%196 = load double**, double*** %5
%197 = load i32, i32* %23
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds double*, double** %196, i64 %198
%200 = load double*, double** %199
%201 = load i32, i32* %24
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %200, i64 %202
store double 0.000000e+00, double* %203
br label %583
204: ; preds = %177, %159, %144
%205 = load double**, double*** %5
%206 = load i32, i32* %23
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double*, double** %205, i64 %207
%209 = load double*, double** %208
%210 = load i32, i32* %24
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %209, i64 %211
%213 = load double, double* %212
%214 = call float @fabs(double %213)
%215 = fpext float %214 to double
%216 = load double, double* %12
%217 = fcmp ogt double %215, %216
br i1 %217, label %218, label %582
218: ; preds = %204
%219 = load double*, double** %6
%220 = load i32, i32* %24
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double, double* %219, i64 %221
%223 = load double, double* %222
%224 = load double*, double** %6
%225 = load i32, i32* %23
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %224, i64 %226
%228 = load double, double* %227
%229 = fsub double %223, %228
store double %229, double* %15
%230 = load double, double* %15
%231 = call float @fabs(double %230)
%232 = fpext float %231 to double
%233 = load double, double* %14
%234 = fadd double %232, %233
%235 = load double, double* %15
%236 = call float @fabs(double %235)
%237 = fpext float %236 to double
%238 = fcmp oeq double %234, %237
br i1 %238, label %239, label %251
239: ; preds = %218
%240 = load double**, double*** %5
%241 = load i32, i32* %23
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds double*, double** %240, i64 %242
%244 = load double*, double** %243
%245 = load i32, i32* %24
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double, double* %244, i64 %246
%248 = load double, double* %247
%249 = load double, double* %15
%250 = fdiv double %248, %249
store double %250, double* %16
br label %280
251: ; preds = %218
%252 = load double, double* %15
%253 = fmul double 5.000000e-01, %252
%254 = load double**, double*** %5
%255 = load i32, i32* %23
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double*, double** %254, i64 %256
%258 = load double*, double** %257
%259 = load i32, i32* %24
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double, double* %258, i64 %260
%262 = load double, double* %261
%263 = fdiv double %253, %262
store double %263, double* %17
%264 = load double, double* %17
%265 = call float @fabs(double %264)
%266 = load double, double* %17
%267 = load double, double* %17
%268 = call double @llvm.fmuladd.f64(double %266, double %267, double 1.000000e+00)
%269 = fptrunc double %268 to float
%270 = call float @sqrt(float %269)
%271 = fadd float %265, %270
%272 = fdiv float 1.000000e+00, %271
%273 = fpext float %272 to double
store double %273, double* %16
%274 = load double, double* %17
%275 = fcmp olt double %274, 0.000000e+00
br i1 %275, label %276, label %279
276: ; preds = %251
%277 = load double, double* %16
%278 = fmul double %277, -1.000000e+00
store double %278, double* %16
br label %279
279: ; preds = %276, %251
br label %280
280: ; preds = %279, %239
%281 = load double, double* %16
%282 = load double, double* %16
%283 = call double @llvm.fmuladd.f64(double %281, double %282, double 1.000000e+00)
%284 = fptrunc double %283 to float
%285 = call float @sqrt(float %284)
%286 = fdiv float 1.000000e+00, %285
%287 = fpext float %286 to double
store double %287, double* %18
%288 = load double, double* %16
%289 = load double, double* %18
%290 = fmul double %288, %289
store double %290, double* %19
%291 = load double, double* %19
%292 = load double, double* %18
%293 = fadd double 1.000000e+00, %292
%294 = fdiv double %291, %293
store double %294, double* %20
%295 = load double, double* %16
%296 = load double**, double*** %5
%297 = load i32, i32* %23
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double*, double** %296, i64 %298
%300 = load double*, double** %299
%301 = load i32, i32* %24
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds double, double* %300, i64 %302
%304 = load double, double* %303
%305 = fmul double %295, %304
store double %305, double* %15
%306 = load double, double* %15
%307 = load i32, i32* %23
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds double, double* %28, i64 %308
%310 = load double, double* %309
%311 = fsub double %310, %306
store double %311, double* %309
%312 = load double, double* %15
%313 = load i32, i32* %24
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds double, double* %28, i64 %314
%316 = load double, double* %315
%317 = fadd double %316, %312
store double %317, double* %315
%318 = load double, double* %15
%319 = load double*, double** %6
%320 = load i32, i32* %23
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds double, double* %319, i64 %321
%323 = load double, double* %322
%324 = fsub double %323, %318
store double %324, double* %322
%325 = load double, double* %15
%326 = load double*, double** %6
%327 = load i32, i32* %24
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds double, double* %326, i64 %328
%330 = load double, double* %329
%331 = fadd double %330, %325
store double %331, double* %329
%332 = load double**, double*** %5
%333 = load i32, i32* %23
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds double*, double** %332, i64 %334
%336 = load double*, double** %335
%337 = load i32, i32* %24
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds double, double* %336, i64 %338
store double 0.000000e+00, double* %339
store i32 1, i32* %22
br label %340
340: ; preds = %396, %280
%341 = load i32, i32* %22
%342 = load i32, i32* %23
%343 = sub nsw i32 %342, 1
%344 = icmp sle i32 %341, %343
br i1 %344, label %345, label %399
345: ; preds = %340
%346 = load double**, double*** %5
%347 = load i32, i32* %22
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds double*, double** %346, i64 %348
%350 = load double*, double** %349
%351 = load i32, i32* %23
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %350, i64 %352
%354 = load double, double* %353
store double %354, double* %14
%355 = load double**, double*** %5
%356 = load i32, i32* %22
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds double*, double** %355, i64 %357
%359 = load double*, double** %358
%360 = load i32, i32* %24
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds double, double* %359, i64 %361
%363 = load double, double* %362
store double %363, double* %15
%364 = load double, double* %14
%365 = load double, double* %19
%366 = load double, double* %15
%367 = load double, double* %14
%368 = load double, double* %20
%369 = call double @llvm.fmuladd.f64(double %367, double %368, double %366)
%370 = fneg double %365
%371 = call double @llvm.fmuladd.f64(double %370, double %369, double %364)
%372 = load double**, double*** %5
%373 = load i32, i32* %22
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds double*, double** %372, i64 %374
%376 = load double*, double** %375
%377 = load i32, i32* %23
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds double, double* %376, i64 %378
store double %371, double* %379
%380 = load double, double* %15
%381 = load double, double* %19
%382 = load double, double* %14
%383 = load double, double* %15
%384 = load double, double* %20
%385 = fneg double %383
%386 = call double @llvm.fmuladd.f64(double %385, double %384, double %382)
%387 = call double @llvm.fmuladd.f64(double %381, double %386, double %380)
%388 = load double**, double*** %5
%389 = load i32, i32* %22
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds double*, double** %388, i64 %390
%392 = load double*, double** %391
%393 = load i32, i32* %24
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds double, double* %392, i64 %394
store double %387, double* %395
br label %396
396: ; preds = %345
%397 = load i32, i32* %22
%398 = add nsw i32 %397, 1
store i32 %398, i32* %22
br label %340
399: ; preds = %340
%400 = load i32, i32* %23
%401 = add nsw i32 %400, 1
store i32 %401, i32* %22
br label %402
402: ; preds = %458, %399
%403 = load i32, i32* %22
%404 = load i32, i32* %24
%405 = sub nsw i32 %404, 1
%406 = icmp sle i32 %403, %405
br i1 %406, label %407, label %461
407: ; preds = %402
%408 = load double**, double*** %5
%409 = load i32, i32* %23
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds double*, double** %408, i64 %410
%412 = load double*, double** %411
%413 = load i32, i32* %22
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double, double* %412, i64 %414
%416 = load double, double* %415
store double %416, double* %14
%417 = load double**, double*** %5
%418 = load i32, i32* %22
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds double*, double** %417, i64 %419
%421 = load double*, double** %420
%422 = load i32, i32* %24
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds double, double* %421, i64 %423
%425 = load double, double* %424
store double %425, double* %15
%426 = load double, double* %14
%427 = load double, double* %19
%428 = load double, double* %15
%429 = load double, double* %14
%430 = load double, double* %20
%431 = call double @llvm.fmuladd.f64(double %429, double %430, double %428)
%432 = fneg double %427
%433 = call double @llvm.fmuladd.f64(double %432, double %431, double %426)
%434 = load double**, double*** %5
%435 = load i32, i32* %23
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds double*, double** %434, i64 %436
%438 = load double*, double** %437
%439 = load i32, i32* %22
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds double, double* %438, i64 %440
store double %433, double* %441
%442 = load double, double* %15
%443 = load double, double* %19
%444 = load double, double* %14
%445 = load double, double* %15
%446 = load double, double* %20
%447 = fneg double %445
%448 = call double @llvm.fmuladd.f64(double %447, double %446, double %444)
%449 = call double @llvm.fmuladd.f64(double %443, double %448, double %442)
%450 = load double**, double*** %5
%451 = load i32, i32* %22
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds double*, double** %450, i64 %452
%454 = load double*, double** %453
%455 = load i32, i32* %24
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds double, double* %454, i64 %456
store double %449, double* %457
br label %458
458: ; preds = %407
%459 = load i32, i32* %22
%460 = add nsw i32 %459, 1
store i32 %460, i32* %22
br label %402
461: ; preds = %402
%462 = load i32, i32* %24
%463 = add nsw i32 %462, 1
store i32 %463, i32* %22
br label %464
464: ; preds = %518, %461
%465 = load i32, i32* %22
%466 = icmp ule i32 %465, 3
br i1 %466, label %467, label %521
467: ; preds = %464
%468 = load double**, double*** %5
%469 = load i32, i32* %23
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds double*, double** %468, i64 %470
%472 = load double*, double** %471
%473 = load i32, i32* %22
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds double, double* %472, i64 %474
%476 = load double, double* %475
store double %476, double* %14
%477 = load double**, double*** %5
%478 = load i32, i32* %24
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds double*, double** %477, i64 %479
%481 = load double*, double** %480
%482 = load i32, i32* %22
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds double, double* %481, i64 %483
%485 = load double, double* %484
store double %485, double* %15
%486 = load double, double* %14
%487 = load double, double* %19
%488 = load double, double* %15
%489 = load double, double* %14
%490 = load double, double* %20
%491 = call double @llvm.fmuladd.f64(double %489, double %490, double %488)
%492 = fneg double %487
%493 = call double @llvm.fmuladd.f64(double %492, double %491, double %486)
%494 = load double**, double*** %5
%495 = load i32, i32* %23
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds double*, double** %494, i64 %496
%498 = load double*, double** %497
%499 = load i32, i32* %22
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double, double* %498, i64 %500
store double %493, double* %501
%502 = load double, double* %15
%503 = load double, double* %19
%504 = load double, double* %14
%505 = load double, double* %15
%506 = load double, double* %20
%507 = fneg double %505
%508 = call double @llvm.fmuladd.f64(double %507, double %506, double %504)
%509 = call double @llvm.fmuladd.f64(double %503, double %508, double %502)
%510 = load double**, double*** %5
%511 = load i32, i32* %24
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds double*, double** %510, i64 %512
%514 = load double*, double** %513
%515 = load i32, i32* %22
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds double, double* %514, i64 %516
store double %509, double* %517
br label %518
518: ; preds = %467
%519 = load i32, i32* %22
%520 = add nsw i32 %519, 1
store i32 %520, i32* %22
br label %464
521: ; preds = %464
store i32 1, i32* %22
br label %522
522: ; preds = %576, %521
%523 = load i32, i32* %22
%524 = icmp ule i32 %523, 3
br i1 %524, label %525, label %579
525: ; preds = %522
%526 = load double**, double*** %7
%527 = load i32, i32* %22
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds double*, double** %526, i64 %528
%530 = load double*, double** %529
%531 = load i32, i32* %23
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds double, double* %530, i64 %532
%534 = load double, double* %533
store double %534, double* %14
%535 = load double**, double*** %7
%536 = load i32, i32* %22
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds double*, double** %535, i64 %537
%539 = load double*, double** %538
%540 = load i32, i32* %24
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds double, double* %539, i64 %541
%543 = load double, double* %542
store double %543, double* %15
%544 = load double, double* %14
%545 = load double, double* %19
%546 = load double, double* %15
%547 = load double, double* %14
%548 = load double, double* %20
%549 = call double @llvm.fmuladd.f64(double %547, double %548, double %546)
%550 = fneg double %545
%551 = call double @llvm.fmuladd.f64(double %550, double %549, double %544)
%552 = load double**, double*** %7
%553 = load i32, i32* %22
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds double*, double** %552, i64 %554
%556 = load double*, double** %555
%557 = load i32, i32* %23
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds double, double* %556, i64 %558
store double %551, double* %559
%560 = load double, double* %15
%561 = load double, double* %19
%562 = load double, double* %14
%563 = load double, double* %15
%564 = load double, double* %20
%565 = fneg double %563
%566 = call double @llvm.fmuladd.f64(double %565, double %564, double %562)
%567 = call double @llvm.fmuladd.f64(double %561, double %566, double %560)
%568 = load double**, double*** %7
%569 = load i32, i32* %22
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds double*, double** %568, i64 %570
%572 = load double*, double** %571
%573 = load i32, i32* %24
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds double, double* %572, i64 %574
store double %567, double* %575
br label %576
576: ; preds = %525
%577 = load i32, i32* %22
%578 = add nsw i32 %577, 1
store i32 %578, i32* %22
br label %522
579: ; preds = %522
%580 = load i32, i32* %8
%581 = add nsw i32 %580, 1
store i32 %581, i32* %8
br label %582
582: ; preds = %579, %204
br label %583
583: ; preds = %582, %195
br label %584
584: ; preds = %583
%585 = load i32, i32* %24
%586 = add nsw i32 %585, 1
store i32 %586, i32* %24
br label %141
587: ; preds = %141
br label %588
588: ; preds = %587
%589 = load i32, i32* %23
%590 = add nsw i32 %589, 1
store i32 %590, i32* %23
br label %135
591: ; preds = %135
store i32 1, i32* %23
br label %592
592: ; preds = %616, %591
%593 = load i32, i32* %23
%594 = icmp ule i32 %593, 3
br i1 %594, label %595, label %619
595: ; preds = %592
%596 = load i32, i32* %23
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds double, double* %28, i64 %597
%599 = load double, double* %598
%600 = load i32, i32* %23
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds double, double* %27, i64 %601
%603 = load double, double* %602
%604 = fadd double %603, %599
store double %604, double* %602
%605 = load i32, i32* %23
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds double, double* %27, i64 %606
%608 = load double, double* %607
%609 = load double*, double** %6
%610 = load i32, i32* %23
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds double, double* %609, i64 %611
store double %608, double* %612
%613 = load i32, i32* %23
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds double, double* %28, i64 %614
store double 0.000000e+00, double* %615
br label %616
616: ; preds = %595
%617 = load i32, i32* %23
%618 = add nsw i32 %617, 1
store i32 %618, i32* %23
br label %592
619: ; preds = %592
br label %620
620: ; preds = %619
%621 = load i32, i32* %21
%622 = add nsw i32 %621, 1
store i32 %622, i32* %21
br label %88
623: ; preds = %88
%624 = load i32, i32* %21
%625 = icmp slt i32 %624, 50
%626 = zext i1 %625 to i32
%627 = call i32 @assert(i32 %626)
store i32 1, i32* %4
store i32 1, i32* %25
br label %628
628: ; preds = %623, %125
%629 = load i8*, i8** %11
%630 = load i32, i32* %4
ret i32 %630
}

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