void jacobi(double **a, int n, double d[], double **v, int *nrot) {
  int j, iq, ip, i;
  double tresh, theta, tau, t, sm, s, h, g, c, *b, *z;
  b = dvector(1, n);
  z = dvector(1, n);
  for (ip = 1; ip <= n; ip++) {
    for (iq = 1; iq <= n; iq++)
      v[ip][iq] = 0.0;
    v[ip][ip] = 1.0;
  }
  for (ip = 1; ip <= n; ip++) {
    b[ip] = d[ip] = a[ip][ip];
    z[ip] = 0.0;
  }
  *nrot = 0;
  for (i = 1; i <= 50; i++) {
    sm = 0.0;
    for (ip = 1; ip <= n - 1; ip++) {
      for (iq = ip + 1; iq <= n; iq++)
        sm += fabs(a[ip][iq]);
    }
    if (sm == 0.0) {
      free_dvector(z, 1, n);
      free_dvector(b, 1, n);
      return;
    }
    if (i < 4)
      tresh = 0.2 * sm / (n * n);
    else
      tresh = 0.0;
    for (ip = 1; ip <= n - 1; ip++) {
      for (iq = ip + 1; iq <= n; iq++) {
        g = 100.0 * fabs(a[ip][iq]);
        if (i > 4 && (fabs(d[ip]) + g) == fabs(d[ip]) &&
            (fabs(d[iq]) + g) == fabs(d[iq]))
          a[ip][iq] = 0.0;
        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.5 * h / (a[ip][iq]);
            t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta));
            if (theta < 0.0)
              t = -t;
          }
          c = 1.0 / sqrt(1 + t * t);
          s = t * c;
          tau = s / (1.0 + c);
          h = t * a[ip][iq];
          z[ip] -= h;
          z[iq] += h;
          d[ip] -= h;
          d[iq] += h;
          a[ip][iq] = 0.0;
          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.0;
    }
  }
  nrerror("Too many iterations in routine jacobi");
}


x86 assembly (clang, -O0):
<jacobi>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <dvector@plt>
cltq
mov    %rax,-0x88(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <dvector@plt>
cltq
mov    %rax,-0x90(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1205 <jacobi+0xc5>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11da <jacobi+0x9a>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11a8 <jacobi+0x68>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  0xe1e(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1195 <jacobi+0x55>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     126b <jacobi+0x12b>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    120c <jacobi+0xcc>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x38(%rbp)
cmpl   $0x32,-0x38(%rbp)
jg     1baf <jacobi+0xa6f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1306 <jacobi+0x1c6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12f3 <jacobi+0x1b3>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd49(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12af <jacobi+0x16f>
jmp    12f8 <jacobi+0x1b8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1295 <jacobi+0x155>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    134f <jacobi+0x20f>
jp     134f <jacobi+0x20f>
mov    -0x90(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1050 <free_dvector@plt>
mov    -0x88(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1050 <free_dvector@plt>
jmp    1bbd <jacobi+0xa7d>
cmpl   $0x4,-0x38(%rbp)
jge    137f <jacobi+0x23f>
movsd  0xc9f(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1387 <jacobi+0x247>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1b26 <jacobi+0x9e6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b13 <jacobi+0x9d3>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xc50(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xc2c(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x4,-0x38(%rbp)
jle    1496 <jacobi+0x356>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc1d(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xc00(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    1496 <jacobi+0x356>
jp     1496 <jacobi+0x356>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xbd8(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xbbb(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    1496 <jacobi+0x356>
jp     1496 <jacobi+0x356>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b00 <jacobi+0x9c0>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xb6e(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1afb <jacobi+0x9bb>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movaps 0xb34(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movaps 0xb1f(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    1539 <jacobi+0x3f9>
jp     1539 <jacobi+0x3f9>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    15e8 <jacobi+0x4a8>
movsd  0xad7(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0xab4(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa82(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  -0x98(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  0xa65(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    15e3 <jacobi+0x4a3>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    15e8 <jacobi+0x4a8>
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa12(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x9fe(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  0x9d9(%rip),%xmm1
addsd  -0x80(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
mov    -0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     17ea <jacobi+0x6aa>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm2
movsd  -0x50(%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    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm3
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%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    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16ed <jacobi+0x5ad>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     18f0 <jacobi+0x7b0>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm2
movsd  -0x50(%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    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm3
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%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    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17f3 <jacobi+0x6b3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     19f1 <jacobi+0x8b1>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm2
movsd  -0x50(%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    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm3
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%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    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18f9 <jacobi+0x7b9>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1af0 <jacobi+0x9b0>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm2
movsd  -0x50(%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 -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm3
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%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 -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19f8 <jacobi+0x8b8>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1b00 <jacobi+0x9c0>
jmp    1b05 <jacobi+0x9c5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13a8 <jacobi+0x268>
jmp    1b18 <jacobi+0x9d8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    138e <jacobi+0x24e>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b9c <jacobi+0xa5c>
mov    -0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b2d <jacobi+0x9ed>
jmp    1ba1 <jacobi+0xa61>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    127c <jacobi+0x13c>
lea    0x47a(%rip),%rdi
mov    $0x0,%al
call   1030 <nrerror@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jacobi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r8,0x98(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rdx,0x10(%rsp)
mov    %esi,%ebx
mov    %rdi,0x20(%rsp)
mov    $0x1,%edi
xor    %eax,%eax
call   1050 <dvector@plt>
movslq %eax,%r12
mov    $0x1,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <dvector@plt>
movslq %eax,%rdi
mov    %ebx,%r13d
test   %ebx,%ebx
mov    %rbx,0x30(%rsp)
mov    %rdi,0x60(%rsp)
mov    %r13,0x58(%rsp)
mov    %r12,0x80(%rsp)
jle    138c <jacobi+0x23c>
lea    0x0(,%r13,8),%r15
lea    -0x1(%r13),%rax
and    $0x3,%r13d
mov    $0x1,%ebx
mov    %rax,0x28(%rsp)
cmp    $0x3,%rax
jb     1291 <jacobi+0x141>
mov    0x58(%rsp),%r12
and    $0xfffffffc,%r12d
xor    %ebx,%ebx
mov    0x38(%rsp),%r14
mov    0x8(%r14,%rbx,8),%rbp
lea    0x8(%rbp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x8(%rbp,%rbx,8)
mov    0x10(%r14,%rbx,8),%rbp
lea    0x8(%rbp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x10(%rbp,%rbx,8)
mov    0x18(%r14,%rbx,8),%rbp
lea    0x8(%rbp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x18(%rbp,%rbx,8)
mov    0x20(%r14,%rbx,8),%rbp
lea    0x8(%rbp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x20(%rbp,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r12
jne    11f0 <jacobi+0xa0>
add    $0x1,%rbx
mov    0x80(%rsp),%r12
test   %r13,%r13
mov    0x38(%rsp),%r14
je     12cb <jacobi+0x17b>
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rbx,8),%rbp
lea    0x8(%rbp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%r13
jne    12a0 <jacobi+0x150>
mov    0x30(%rsp),%rbx
test   %ebx,%ebx
mov    0x60(%rsp),%rdi
mov    0x58(%rsp),%r13
jle    138c <jacobi+0x23c>
cmpq   $0x0,0x28(%rsp)
je     1ddf <jacobi+0xc8f>
mov    %r13d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
mov    $0x1,%eax
mov    0x10(%rsp),%rsi
mov    0x20(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp,%rax,8),%rdx
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  %xmm0,(%r12,%rax,8)
movq   $0x0,(%rdi,%rax,8)
mov    0x8(%rbp,%rax,8),%rdx
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
movsd  %xmm0,0x8(%r12,%rax,8)
movq   $0x0,0x8(%rdi,%rax,8)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    1310 <jacobi+0x1c0>
test   $0x1,%r13b
je     138c <jacobi+0x23c>
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    0x10(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  %xmm0,(%r12,%rax,8)
movq   $0x0,(%rdi,%rax,8)
lea    0x1(%rbx),%esi
mov    %ebx,%eax
imul   %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xe0(%rsp)
mov    0x98(%rsp),%rax
movl   $0x0,(%rax)
lea    0x8(%r12),%rax
lea    (%r12,%rsi,8),%rcx
mov    0x10(%rsp),%rbp
lea    0x8(%rbp),%r10
lea    0x0(%rbp,%rsi,8),%r8
lea    0x8(%rdi),%r9
lea    -0x1(%r13),%rbx
mov    %rbx,%rdx
mov    %rbx,0xf8(%rsp)
mov    %rbx,%r15
and    $0xfffffffffffffffe,%r15
cmp    %r8,%rax
setb   %bl
cmp    %rcx,%r10
setb   %dl
and    %bl,%dl
lea    (%rdi,%rsi,8),%rbx
cmp    %rbx,%rax
setb   %al
cmp    %rcx,%r9
movslq 0x30(%rsp),%rcx
mov    %rcx,0x110(%rsp)
setb   %cl
and    %al,%cl
or     %dl,%cl
lea    -0x1(%rsi),%rdx
cmp    %rbx,%r10
mov    0x30(%rsp),%rbx
setb   %r11b
cmp    %r8,%r9
setb   %al
and    %r11b,%al
or     %cl,%al
mov    %al,0xf(%rsp)
mov    %rdx,0x78(%rsp)
mov    %rdx,%r13
and    $0xfffffffffffffffc,%r13
lea    0x1(%r13),%rax
mov    %rax,0xc8(%rsp)
mov    %rsi,%rax
neg    %rax
mov    %rax,0xd0(%rsp)
mov    0x20(%rsp),%rax
mov    %rax,%r10
add    $0x10,%rax
mov    %rax,0xd8(%rsp)
xorpd  %xmm9,%xmm9
movapd 0xb87(%rip),%xmm10
movsd  0xba6(%rip),%xmm11
movsd  0xbad(%rip),%xmm12
movapd 0xb7c(%rip),%xmm13
mov    0x38(%rsp),%r9
movl   $0x1,0x1c(%rsp)
mov    %rsi,0xa0(%rsp)
mov    %r15,0xf0(%rsp)
mov    %r13,0xe8(%rsp)
jmp    14d4 <jacobi+0x384>
nopl   0x0(%rax,%rax,1)
mov    0x1c(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x1c(%rsp)
cmp    $0x33,%eax
je     1dc0 <jacobi+0xc70>
cmp    $0x2,%ebx
jl     1d90 <jacobi+0xc40>
xorpd  %xmm0,%xmm0
mov    $0x2,%eax
mov    $0x1,%r14d
je     1578 <jacobi+0x428>
mov    %rsi,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rsi,8),%rcx
mov    (%r10,%r14,8),%rbp
add    %rcx,%rbp
mov    $0x2,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rbx,8),%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    1520 <jacobi+0x3d0>
add    0x8(%r10,%r14,8),%rcx
add    $0x2,%r14
mov    $0x3,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rbp,8),%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1550 <jacobi+0x400>
add    $0x2,%rax
add    $0x2,%rsi
add    $0xfffffffffffffffe,%rdx
cmp    %r15,%rsi
jne    1500 <jacobi+0x3b0>
testb  $0x1,0xf8(%rsp)
01
mov    0xa0(%rsp),%rsi
je     15a7 <jacobi+0x457>
mov    (%r10,%r14,8),%rcx
xchg   %ax,%ax
movsd  (%rcx,%rax,8),%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rax
cmp    %rax,%rsi
jne    1590 <jacobi+0x440>
ucomisd %xmm9,%xmm0
mov    0x30(%rsp),%rbx
jne    15b9 <jacobi+0x469>
jnp    1d90 <jacobi+0xc40>
xorpd  %xmm14,%xmm14
cmpl   $0x3,0x1c(%rsp)
ja     15db <jacobi+0x48b>
mulsd  0xa53(%rip),%xmm0
divsd  0xe0(%rsp),%xmm0
movapd %xmm0,%xmm14
cmp    $0x2,%ebx
mov    %r10,%rdi
jl     1c40 <jacobi+0xaf0>
mov    $0x2,%r14d
mov    $0x1,%ebp
mov    $0xfffffffd,%ecx
mov    $0x3,%r15d
mov    0xd8(%rsp),%r10
xor    %eax,%eax
movsd  %xmm14,0x90(%rsp)
jmp    165f <jacobi+0x50f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x88(%rsp),%r14
add    $0x1,%r14
mov    0x50(%rsp),%rax
add    $0x1,%rax
add    $0x8,%r10
mov    0x74(%rsp),%ecx
add    $0xffffffff,%ecx
mov    0x100(%rsp),%r15
add    $0x1,%r15
mov    0xa8(%rsp),%rbp
cmp    0x58(%rsp),%rbp
je     1c40 <jacobi+0xaf0>
lea    0x3(%rax),%rdx
mov    %rax,0x50(%rsp)
add    $0x4,%rax
mov    %rax,0x108(%rsp)
lea    0x1(%rbp),%rax
mov    %rax,0xa8(%rsp)
mov    (%rdi,%rbp,8),%rax
mov    %r15,0x100(%rsp)
mov    %ecx,0x74(%rsp)
mov    %ecx,%r13d
xor    %r12d,%r12d
mov    %r14,%rcx
mov    %r14,0x88(%rsp)
mov    %r13d,%ecx
mov    %r10,0x48(%rsp)
mov    %rdx,0x118(%rsp)
jmp    16ef <jacobi+0x59f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x98(%rsp),%rcx
addl   $0x1,(%rcx)
mov    0x118(%rsp),%rdx
mov    0x44(%rsp),%ecx
add    $0x1,%r14
add    $0x1,%r12
add    $0x1,%r15
add    $0xffffffff,%ecx
cmp    %rsi,%r14
je     1620 <jacobi+0x4d0>
mov    %rdi,%r8
cmp    %r15d,%ebx
mov    %r15d,%r13d
cmovg  %ebx,%r13d
lea    (%rdx,%r12,1),%edi
cmp    %edi,%ebx
cmovg  %ebx,%edi
mov    %rdi,0x28(%rsp)
lea    (%rdx,%r12,1),%r11
cmp    %r11d,%ebx
mov    %r11d,%edi
cmovg  %ebx,%edi
mov    %rdi,0x120(%rsp)
movsd  (%rax,%r14,8),%xmm4
movapd %xmm4,%xmm1
andpd  %xmm10,%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm11,%xmm0
cmpl   $0x5,0x1c(%rsp)
jb     1790 <jacobi+0x640>
mov    0x10(%rsp),%rdi
movsd  (%rdi,%rbp,8),%xmm2
andpd  %xmm10,%xmm2
movapd %xmm0,%xmm3
addsd  %xmm2,%xmm3
ucomisd %xmm2,%xmm3
jne    1790 <jacobi+0x640>
jp     1790 <jacobi+0x640>
mov    0x10(%rsp),%rdi
movsd  (%rdi,%r14,8),%xmm2
andpd  %xmm10,%xmm2
movapd %xmm0,%xmm3
addsd  %xmm2,%xmm3
ucomisd %xmm2,%xmm3
jne    1790 <jacobi+0x640>
jp     1790 <jacobi+0x640>
movq   $0x0,(%rax,%r14,8)
mov    %r8,%rdi
jmp    16d7 <jacobi+0x587>
nopl   (%rax)
ucomisd %xmm14,%xmm1
mov    %r8,%rdi
jbe    16d7 <jacobi+0x587>
mov    0x10(%rsp),%rdx
movsd  (%rdx,%r14,8),%xmm2
subsd  (%rdx,%rbp,8),%xmm2
movapd %xmm2,%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm1,%xmm0
ucomisd %xmm1,%xmm0
mov    %ecx,0x44(%rsp)
jne    17d0 <jacobi+0x680>
jp     17d0 <jacobi+0x680>
divsd  %xmm2,%xmm4
jmp    1880 <jacobi+0x730>
mulsd  0x858(%rip),%xmm2
divsd  %xmm4,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm12,%xmm0
ucomisd %xmm9,%xmm0
jb     17f6 <jacobi+0x6a6>
sqrtsd %xmm0,%xmm0
jmp    185e <jacobi+0x70e>
mov    %r11,0x68(%rsp)
movapd %xmm2,0xb0(%rsp)
call   1070 <sqrt@plt>
movapd 0xb0(%rsp),%xmm2
mov    0x68(%rsp),%r11
mov    0x48(%rsp),%r10
movsd  0x90(%rsp),%xmm14
movapd 0x7e1(%rip),%xmm13
movsd  0x800(%rip),%xmm12
movsd  0x7e7(%rip),%xmm11
movapd 0x7b6(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rdx
mov    0x38(%rsp),%r9
ucomisd %xmm2,%xmm9
andpd  %xmm10,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm12,%xmm4
divsd  %xmm2,%xmm4
jbe    1880 <jacobi+0x730>
xorpd  %xmm13,%xmm4
nopl   0x0(%rax)
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm12,%xmm0
ucomisd %xmm9,%xmm0
jb     18a0 <jacobi+0x750>
sqrtsd %xmm0,%xmm0
jmp    1908 <jacobi+0x7b8>
nopw   0x0(%rax,%rax,1)
mov    %r11,0x68(%rsp)
movapd %xmm4,0xb0(%rsp)
call   1070 <sqrt@plt>
movapd 0xb0(%rsp),%xmm4
mov    0x68(%rsp),%r11
mov    0x48(%rsp),%r10
movsd  0x90(%rsp),%xmm14
movapd 0x737(%rip),%xmm13
movsd  0x756(%rip),%xmm12
movsd  0x73d(%rip),%xmm11
movapd 0x70c(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rdx
mov    0x38(%rsp),%r9
mov    0x50(%rsp),%rsi
movapd %xmm12,%xmm2
divsd  %xmm0,%xmm2
movapd %xmm4,%xmm0
mulsd  %xmm2,%xmm0
mov    (%rdi,%rbp,8),%rax
mulsd  (%rax,%r14,8),%xmm4
addsd  %xmm12,%xmm2
mov    0x60(%rsp),%rcx
movsd  (%rcx,%rbp,8),%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
movsd  (%rcx,%r14,8),%xmm1
addsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx,%r14,8)
movsd  (%rdx,%rbp,8),%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,(%rdx,%rbp,8)
movapd %xmm0,%xmm1
addsd  (%rdx,%r14,8),%xmm4
divsd  %xmm2,%xmm1
movsd  %xmm4,(%rdx,%r14,8)
movq   $0x0,(%rax,%r14,8)
cmp    $0x2,%rbp
jb     19dc <jacobi+0x88c>
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    0x8(%rdi,%rcx,8),%rdx
movsd  (%rdx,%rbp,8),%xmm3
movsd  (%rdx,%r14,8),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rdx,%rbp,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rdx,%r14,8)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1990 <jacobi+0x840>
cmp    %r14,0xa8(%rsp)
jae    1a4b <jacobi+0x8fb>
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
mov    0x88(%rsp),%rcx
lea    (%rax,%rcx,8),%rcx
xor    %edx,%edx
nopl   (%rax)
movsd  (%rcx,%rdx,8),%xmm3
mov    (%r10,%rdx,8),%rsi
movsd  (%rsi,%r14,8),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rcx,%rdx,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rsi,%r14,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1a00 <jacobi+0x8b0>
cmp    0x110(%rsp),%r14
jge    1bcb <jacobi+0xa7b>
mov    0x50(%rsp),%rcx
add    %r12d,%ecx
mov    $0xfffffffd,%esi
sub    %ecx,%esi
mov    (%rdi,%r14,8),%rcx
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
mov    %r14,%rdx
mov    0x28(%rsp),%r8
add    %esi,%r8d
mov    %r8,0x28(%rsp)
je     1b80 <jacobi+0xa30>
mov    0x108(%rsp),%rdx
add    %r12,%rdx
mov    0x120(%rsp),%rdi
add    %esi,%edi
add    %rdx,%rdi
lea    (%rax,%r11,8),%rdx
lea    (%rcx,%rdi,8),%rsi
cmp    %rsi,%rdx
jae    1ad1 <jacobi+0x981>
mov    %rdi,%r10
lea    (%rax,%rdi,8),%rsi
lea    (%rcx,%r11,8),%rdi
mov    %r14,%rdx
cmp    %rsi,%rdi
mov    0x20(%rsp),%rdi
mov    0x48(%rsp),%r10
jb     1b80 <jacobi+0xa30>
add    0x44(%rsp),%r13d
add    $0x1,%r13
and    $0xfffffffffffffffe,%r13
mov    0x28(%rsp),%r8
add    $0x1,%r8
mov    %r8,0x28(%rsp)
and    $0xfffffffffffffffe,%r8
lea    (%r14,%r8,1),%rdx
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm2,%xmm8
unpcklpd %xmm2,%xmm8
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
lea    (%rcx,%r15,8),%rdi
lea    (%rax,%r15,8),%rsi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movupd (%rsi,%rbx,8),%xmm4
movupd (%rdi,%rbx,8),%xmm7
movapd %xmm4,%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm7,%xmm6
mulpd  %xmm8,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm6,(%rsi,%rbx,8)
movapd %xmm7,%xmm6
mulpd  %xmm3,%xmm6
subpd  %xmm6,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm4,(%rdi,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r13
jne    1b20 <jacobi+0x9d0>
cmp    %r8,0x28(%rsp)
mov    0x30(%rsp),%rbx
mov    0x48(%rsp),%r10
mov    0x20(%rsp),%rdi
je     1bcb <jacobi+0xa7b>
nopl   0x0(%rax)
movsd  0x8(%rax,%rdx,8),%xmm3
movsd  0x8(%rcx,%rdx,8),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,0x8(%rax,%rdx,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,0x8(%rcx,%rdx,8)
lea    0x1(%rdx),%rsi
mov    %rsi,%rdx
cmp    %ebx,%esi
jl     1b80 <jacobi+0xa30>
test   %ebx,%ebx
mov    0xa0(%rsp),%rsi
jle    16c0 <jacobi+0x570>
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
mov    $0x1,%ecx
nopl   0x0(%rax)
mov    (%r9,%rcx,8),%rdx
movsd  (%rdx,%rbp,8),%xmm3
movsd  (%rdx,%r14,8),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rdx,%rbp,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rdx,%r14,8)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1bf0 <jacobi+0xaa0>
jmp    16c0 <jacobi+0x570>
mov    %rdi,%r10
test   %ebx,%ebx
mov    0x80(%rsp),%r12
mov    0x60(%rsp),%rdi
mov    0xf0(%rsp),%r15
mov    0xe8(%rsp),%r13
mov    0x10(%rsp),%rbp
jle    14c0 <jacobi+0x370>
cmpq   $0x4,0x78(%rsp)
setb   %al
or     0xf(%rsp),%al
mov    $0x1,%ecx
jne    1cf8 <jacobi+0xba8>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x8(%rdi,%rax,8),%xmm0
movupd 0x18(%rdi,%rax,8),%xmm1
movupd 0x8(%r12,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x18(%r12,%rax,8),%xmm0
addpd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
movupd %xmm2,0x8(%r12,%rax,8)
movupd %xmm0,0x18(%r12,%rax,8)
movupd %xmm2,0x8(%rbp,%rax,8)
movupd %xmm0,0x18(%rbp,%rax,8)
movupd %xmm1,0x8(%rdi,%rax,8)
movupd %xmm1,0x18(%rdi,%rax,8)
add    $0x4,%rax
cmp    %rax,%r13
jne    1c90 <jacobi+0xb40>
mov    0xc8(%rsp),%rcx
cmp    %r13,0x78(%rsp)
je     14c0 <jacobi+0x370>
mov    %rcx,%rax
test   $0x1,%sil
jne    1d24 <jacobi+0xbd4>
movsd  (%rdi,%rcx,8),%xmm0
addsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
movsd  %xmm0,0x0(%rbp,%rcx,8)
movq   $0x0,(%rdi,%rcx,8)
lea    0x1(%rcx),%rax
not    %rcx
cmp    0xd0(%rsp),%rcx
je     14c0 <jacobi+0x370>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rax,8),%xmm0
addsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  %xmm0,0x0(%rbp,%rax,8)
movq   $0x0,(%rdi,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
addsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
movsd  %xmm0,0x8(%rbp,%rax,8)
movq   $0x0,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rsi
jne    1d40 <jacobi+0xbf0>
jmp    14c0 <jacobi+0x370>
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1060 <free_dvector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <free_dvector@plt>
lea    0x279(%rip),%rdi
xor    %eax,%eax
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <nrerror@plt>
mov    $0x1,%eax
test   $0x1,%r13b
jne    1366 <jacobi+0x216>
jmp    138c <jacobi+0x23c>

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

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