void djacobi(a, n, d, v, nrot) double **a, *d, **v;
int n, *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;
    }
  }
  for (i = 1; i <= n; i++) {
    printf("\n");
    for (j = 1; j <= n; j++)
      printf("%lf ", a[i][j]);
  }
  nrerror("Too many iterations in routine JACOBI");
}


x86 assembly (clang, -O0):
<djacobi>:
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   1050 <dvector@plt>
cltq
mov    %rax,-0x88(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1050 <dvector@plt>
cltq
mov    %rax,-0x90(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1215 <djacobi+0xc5>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11ea <djacobi+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    11b8 <djacobi+0x68>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  0xe0e(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a5 <djacobi+0x55>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     127b <djacobi+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    121c <djacobi+0xcc>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x38(%rbp)
cmpl   $0x32,-0x38(%rbp)
jg     1bbf <djacobi+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     1316 <djacobi+0x1c6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1303 <djacobi+0x1b3>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd39(%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    12bf <djacobi+0x16f>
jmp    1308 <djacobi+0x1b8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12a5 <djacobi+0x155>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    135f <djacobi+0x20f>
jp     135f <djacobi+0x20f>
mov    -0x90(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1060 <free_dvector@plt>
mov    -0x88(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1060 <free_dvector@plt>
jmp    1c45 <djacobi+0xaf5>
cmpl   $0x4,-0x38(%rbp)
jge    138f <djacobi+0x23f>
movsd  0xc8f(%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    1397 <djacobi+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     1b36 <djacobi+0x9e6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b23 <djacobi+0x9d3>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xc40(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xc1c(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x4,-0x38(%rbp)
jle    14a6 <djacobi+0x356>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc0d(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xbf0(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    14a6 <djacobi+0x356>
jp     14a6 <djacobi+0x356>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xbc8(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xbab(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    14a6 <djacobi+0x356>
jp     14a6 <djacobi+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    1b10 <djacobi+0x9c0>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xb5e(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1b0b <djacobi+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 0xb24(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movaps 0xb0f(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    1549 <djacobi+0x3f9>
jp     1549 <djacobi+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    15f8 <djacobi+0x4a8>
movsd  0xac7(%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 0xaa4(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa72(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <sqrt@plt>
movsd  -0x98(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  0xa55(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    15f3 <djacobi+0x4a3>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    15f8 <djacobi+0x4a8>
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa02(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x9ee(%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  0x9c9(%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     17fa <djacobi+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    16fd <djacobi+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     1900 <djacobi+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    1803 <djacobi+0x6b3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1a01 <djacobi+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    1909 <djacobi+0x7b9>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b00 <djacobi+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    1a08 <djacobi+0x8b8>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1b10 <djacobi+0x9c0>
jmp    1b15 <djacobi+0x9c5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13b8 <djacobi+0x268>
jmp    1b28 <djacobi+0x9d8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    139e <djacobi+0x24e>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1bac <djacobi+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    1b3d <djacobi+0x9ed>
jmp    1bb1 <djacobi+0xa61>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    128c <djacobi+0x13c>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1c37 <djacobi+0xae7>
lea    0x457(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1c24 <djacobi+0xad4>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x423(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1be7 <djacobi+0xa97>
jmp    1c29 <djacobi+0xad9>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1bc6 <djacobi+0xa76>
lea    0x3f9(%rip),%rdi
mov    $0x0,%al
call   1030 <nrerror@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<djacobi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r8,0x88(%rsp)
mov    %rcx,0x58(%rsp)
mov    %rdx,0x38(%rsp)
mov    %esi,%ebx
mov    %rdi,0x18(%rsp)
mov    $0x1,%edi
xor    %eax,%eax
call   1070 <dvector@plt>
cltq
mov    %rax,0x40(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1070 <dvector@plt>
mov    %rbx,%r9
movslq %eax,%rdi
mov    %r9d,%eax
mov    %rax,0x28(%rsp)
test   %r9d,%r9d
mov    %rbx,0x50(%rsp)
mov    %rdi,0x10(%rsp)
jle    13bd <djacobi+0x24d>
mov    0x28(%rsp),%r13
lea    0x0(,%r13,8),%r15
lea    -0x1(%r13),%r12
and    $0x3,%r13d
mov    $0x1,%ebx
cmp    $0x3,%r12
jb     12be <djacobi+0x14e>
mov    %r12,0x20(%rsp)
mov    0x28(%rsp),%r12
and    $0xfffffffc,%r12d
xor    %ebx,%ebx
mov    0x58(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%r14,%rbx,8),%rbp
lea    0x8(%rbp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <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   1060 <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   1060 <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   1060 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x20(%rbp,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r12
jne    1220 <djacobi+0xb0>
add    $0x1,%rbx
mov    0x20(%rsp),%r12
test   %r13,%r13
mov    0x58(%rsp),%r14
je     12fb <djacobi+0x18b>
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rbx,8),%rbp
lea    0x8(%rbp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%r13
jne    12d0 <djacobi+0x160>
mov    0x50(%rsp),%r9
test   %r9d,%r9d
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rdi
jle    13bd <djacobi+0x24d>
mov    %rdi,%r8
test   %r12,%r12
je     1e51 <djacobi+0xce1>
mov    0x28(%rsp),%rcx
and    $0xfffffffe,%ecx
neg    %rcx
mov    $0x1,%eax
mov    0x38(%rsp),%rbx
mov    0x40(%rsp),%rbp
mov    %r8,%rdi
nopl   0x0(%rax)
mov    (%rsi,%rax,8),%rdx
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  %xmm0,0x0(%rbp,%rax,8)
movq   $0x0,(%rdi,%rax,8)
mov    0x8(%rsi,%rax,8),%rdx
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  %xmm0,0x8(%rbp,%rax,8)
movq   $0x0,0x8(%rdi,%rax,8)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    1340 <djacobi+0x1d0>
testb  $0x1,0x28(%rsp)
je     13bd <djacobi+0x24d>
mov    (%rsi,%rax,8),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    0x38(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
mov    0x40(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
mov    %r8,%rdi
movq   $0x0,(%r8,%rax,8)
mov    0x88(%rsp),%rax
movl   $0x0,(%rax)
cmp    $0x2,%r9d
mov    0x38(%rsp),%rdi
jl     1e16 <djacobi+0xca6>
lea    0x1(%r9),%r10d
mov    %r9d,%eax
imul   %r9d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xd8(%rsp)
movslq %r9d,%rax
mov    %rax,0x100(%rsp)
mov    0x40(%rsp),%rcx
lea    0x8(%rcx),%rax
lea    (%rcx,%r10,8),%rcx
lea    0x8(%rdi),%r14
mov    0x10(%rsp),%rsi
lea    (%rdi,%r10,8),%r8
lea    0x8(%rsi),%r12
mov    0x28(%rsp),%rdx
lea    -0x1(%rdx),%rbx
mov    %rbx,%rdx
mov    %rbx,0xe8(%rsp)
mov    %rbx,%r15
and    $0xfffffffffffffffe,%r15
cmp    %r8,%rax
setb   %bl
cmp    %rcx,%r14
setb   %dl
and    %bl,%dl
lea    (%rsi,%r10,8),%rbx
cmp    %rbx,%rax
setb   %al
cmp    %rcx,%r12
lea    -0x1(%r10),%rsi
setb   %cl
and    %al,%cl
or     %dl,%cl
cmp    %rbx,%r14
mov    0x18(%rsp),%r11
setb   %al
cmp    %r8,%r12
setb   %dl
and    %al,%dl
or     %cl,%dl
mov    %dl,0xb(%rsp)
mov    %rsi,0x68(%rsp)
mov    %rsi,%r14
and    $0xfffffffffffffffc,%r14
lea    0x1(%r14),%rax
mov    %rax,0xc0(%rsp)
mov    %r10,%rax
neg    %rax
mov    %rax,0xc8(%rsp)
lea    0x10(%r11),%rax
mov    %rax,0xd0(%rsp)
mov    $0x1,%ebp
xorpd  %xmm9,%xmm9
movapd 0xb43(%rip),%xmm10
movsd  0xb62(%rip),%xmm11
movsd  0xb69(%rip),%xmm12
movapd 0xb38(%rip),%xmm13
mov    %r10,0x30(%rsp)
mov    %r15,0x70(%rsp)
mov    %r14,0xe0(%rsp)
jmp    150e <djacobi+0x39e>
nopl   0x0(%rax)
add    $0x1,%ebp
cmp    $0x33,%ebp
mov    %rsi,%rdi
je     1e66 <djacobi+0xcf6>
cmp    $0x1,%r9d
mov    0x18(%rsp),%r11
jle    1e16 <djacobi+0xca6>
mov    %ebp,0xc(%rsp)
cmp    $0x2,%r9d
jne    1530 <djacobi+0x3c0>
mov    $0x2,%eax
mov    $0x1,%r8d
xorpd  %xmm0,%xmm0
jmp    15cd <djacobi+0x45d>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
mov    $0x2,%eax
mov    $0x1,%r8d
mov    0x30(%rsp),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
lea    0x0(,%rsi,8),%rcx
mov    (%r11,%r8,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    1570 <djacobi+0x400>
mov    0x18(%rsp),%rbp
add    0x8(%rbp,%r8,8),%rcx
add    $0x2,%r8
mov    $0x3,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rbp,8),%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    15a0 <djacobi+0x430>
add    $0x2,%rax
add    $0x2,%rsi
add    $0xfffffffffffffffe,%rdx
cmp    %r15,%rsi
mov    0x18(%rsp),%r11
jne    1550 <djacobi+0x3e0>
testb  $0x1,0xe8(%rsp)
01
mov    0x30(%rsp),%rbp
je     15f7 <djacobi+0x487>
mov    (%r11,%r8,8),%rcx
movsd  (%rcx,%rax,8),%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rax
cmp    %rax,%rbp
jne    15e0 <djacobi+0x470>
ucomisd %xmm9,%xmm0
mov    0xc(%rsp),%eax
jne    1608 <djacobi+0x498>
jnp    1e16 <djacobi+0xca6>
mov    %rbp,%r10
xorpd  %xmm14,%xmm14
mov    %eax,%ebp
cmp    $0x3,%eax
ja     162d <djacobi+0x4bd>
mulsd  0xa01(%rip),%xmm0
divsd  0xd8(%rsp),%xmm0
movapd %xmm0,%xmm14
cmp    $0x2,%r9d
jl     1cc0 <djacobi+0xb50>
mov    $0x2,%r15d
mov    $0x1,%r14d
mov    $0xfffffffd,%ecx
mov    $0x3,%r12d
mov    0xd0(%rsp),%rax
xor    %ebx,%ebx
movsd  %xmm14,0x80(%rsp)
jmp    16b7 <djacobi+0x547>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x78(%rsp),%r15
add    $0x1,%r15
mov    0x98(%rsp),%rbx
add    $0x1,%rbx
mov    0xa0(%rsp),%rax
add    $0x8,%rax
mov    0x64(%rsp),%ecx
add    $0xffffffff,%ecx
mov    0xf0(%rsp),%r12
add    $0x1,%r12
mov    0x90(%rsp),%r14
cmp    0x28(%rsp),%r14
je     1cc0 <djacobi+0xb50>
mov    %rax,0xa0(%rsp)
lea    0x3(%rbx),%rax
mov    %rax,0x110(%rsp)
mov    %rbx,0x98(%rsp)
lea    0x4(%rbx),%rax
mov    %rax,0xf8(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x90(%rsp)
mov    (%r11,%r14,8),%rax
mov    %r12,0xf0(%rsp)
mov    %ecx,0x64(%rsp)
mov    %ecx,%r13d
xor    %ebx,%ebx
mov    %r15,%rcx
mov    %r15,0x78(%rsp)
mov    %r13d,%ecx
jmp    1741 <djacobi+0x5d1>
nopl   (%rax)
mov    0x88(%rsp),%rcx
addl   $0x1,(%rcx)
mov    0x18(%rsp),%r11
mov    0x38(%rsp),%rdi
mov    0x4c(%rsp),%ecx
add    $0x1,%r15
add    $0x1,%rbx
add    $0x1,%r12
add    $0xffffffff,%ecx
cmp    %r10,%r15
je     1670 <djacobi+0x500>
cmp    %r12d,%r9d
mov    %r12d,%r13d
cmovg  %r9d,%r13d
mov    0x110(%rsp),%rdx
lea    (%rdx,%rbx,1),%r8d
cmp    %r8d,%r9d
cmovg  %r9d,%r8d
mov    %r8,0x20(%rsp)
add    %rbx,%rdx
cmp    %edx,%r9d
mov    %edx,%esi
cmovg  %r9d,%esi
movsd  (%rax,%r15,8),%xmm4
movapd %xmm4,%xmm1
andpd  %xmm10,%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm11,%xmm0
cmp    $0x5,%ebp
jb     17d0 <djacobi+0x660>
movsd  (%rdi,%r14,8),%xmm2
andpd  %xmm10,%xmm2
movapd %xmm0,%xmm3
addsd  %xmm2,%xmm3
ucomisd %xmm2,%xmm3
jne    17d0 <djacobi+0x660>
jp     17d0 <djacobi+0x660>
movsd  (%rdi,%r15,8),%xmm2
andpd  %xmm10,%xmm2
movapd %xmm0,%xmm3
addsd  %xmm2,%xmm3
ucomisd %xmm2,%xmm3
jne    17d0 <djacobi+0x660>
jp     17d0 <djacobi+0x660>
movq   $0x0,(%rax,%r15,8)
jmp    1729 <djacobi+0x5b9>
nop
ucomisd %xmm14,%xmm1
jbe    1729 <djacobi+0x5b9>
movsd  (%rdi,%r15,8),%xmm2
subsd  (%rdi,%r14,8),%xmm2
movapd %xmm2,%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm1,%xmm0
ucomisd %xmm1,%xmm0
mov    %ecx,0x4c(%rsp)
mov    %rdx,0xa8(%rsp)
mov    %rsi,0x108(%rsp)
jne    181e <djacobi+0x6ae>
jp     181e <djacobi+0x6ae>
divsd  %xmm2,%xmm4
mov    0x10(%rsp),%rcx
jmp    18d0 <djacobi+0x760>
mulsd  0x80a(%rip),%xmm2
divsd  %xmm4,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm12,%xmm0
ucomisd %xmm9,%xmm0
jb     1849 <djacobi+0x6d9>
sqrtsd %xmm0,%xmm0
mov    0x10(%rsp),%rcx
jmp    18b0 <djacobi+0x740>
movapd %xmm2,0xb0(%rsp)
call   1090 <sqrt@plt>
movapd 0xb0(%rsp),%xmm2
movsd  0x80(%rsp),%xmm14
mov    0x18(%rsp),%r11
movapd 0x798(%rip),%xmm13
movsd  0x7b7(%rip),%xmm12
movsd  0x79e(%rip),%xmm11
movapd 0x76d(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0xc(%rsp),%ebp
mov    0x30(%rsp),%r10
mov    0x10(%rsp),%rcx
mov    0x38(%rsp),%rdi
mov    0x50(%rsp),%r9
ucomisd %xmm2,%xmm9
andpd  %xmm10,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm12,%xmm4
divsd  %xmm2,%xmm4
jbe    18d0 <djacobi+0x760>
xorpd  %xmm13,%xmm4
xchg   %ax,%ax
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm12,%xmm0
ucomisd %xmm9,%xmm0
jb     18f0 <djacobi+0x780>
sqrtsd %xmm0,%xmm0
jmp    1957 <djacobi+0x7e7>
nopw   0x0(%rax,%rax,1)
movapd %xmm4,0xb0(%rsp)
call   1090 <sqrt@plt>
movapd 0xb0(%rsp),%xmm4
movsd  0x80(%rsp),%xmm14
mov    0x18(%rsp),%r11
movapd 0x6f1(%rip),%xmm13
movsd  0x710(%rip),%xmm12
movsd  0x6f7(%rip),%xmm11
movapd 0x6c6(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0xc(%rsp),%ebp
mov    0x30(%rsp),%r10
mov    0x10(%rsp),%rcx
mov    0x38(%rsp),%rdi
mov    0x50(%rsp),%r9
movapd %xmm12,%xmm2
divsd  %xmm0,%xmm2
movapd %xmm4,%xmm0
mulsd  %xmm2,%xmm0
mov    (%r11,%r14,8),%rax
mulsd  (%rax,%r15,8),%xmm4
addsd  %xmm12,%xmm2
movsd  (%rcx,%r14,8),%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx,%r14,8)
movsd  (%rcx,%r15,8),%xmm1
addsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx,%r15,8)
movsd  (%rdi,%r14,8),%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,(%rdi,%r14,8)
movapd %xmm0,%xmm1
addsd  (%rdi,%r15,8),%xmm4
divsd  %xmm2,%xmm1
movsd  %xmm4,(%rdi,%r15,8)
movq   $0x0,(%rax,%r15,8)
cmp    $0x2,%r14
mov    0x98(%rsp),%rdi
jb     1a2e <djacobi+0x8be>
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    0x8(%r11,%rcx,8),%rdx
movsd  (%rdx,%r14,8),%xmm3
movsd  (%rdx,%r15,8),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rdx,%r14,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rdx,%r15,8)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    19e0 <djacobi+0x870>
cmp    %r15,0x90(%rsp)
mov    0xa0(%rsp),%r8
jae    1aab <djacobi+0x93b>
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
mov    0x78(%rsp),%rcx
lea    (%rax,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rcx,%rdx,8),%xmm3
mov    (%r8,%rdx,8),%rsi
movsd  (%rsi,%r15,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,%r15,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    1a60 <djacobi+0x8f0>
cmp    0x100(%rsp),%r15
jge    1c3c <djacobi+0xacc>
mov    $0xfffffffd,%esi
sub    %edi,%esi
sub    %ebx,%esi
mov    0x18(%rsp),%rcx
mov    (%rcx,%r15,8),%rcx
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
mov    %r15,%rdx
mov    0x20(%rsp),%rdi
add    %esi,%edi
mov    %rdi,0x20(%rsp)
je     1bf0 <djacobi+0xa80>
mov    0xf8(%rsp),%rdx
add    %rbx,%rdx
mov    0x108(%rsp),%rdi
add    %esi,%edi
add    %rdx,%rdi
mov    0xa8(%rsp),%rdx
lea    (%rax,%rdx,8),%rdx
lea    (%rcx,%rdi,8),%rsi
cmp    %rsi,%rdx
jae    1b3e <djacobi+0x9ce>
mov    %rdi,%rbp
lea    (%rax,%rdi,8),%r8
mov    0xa8(%rsp),%rdx
lea    (%rcx,%rdx,8),%rsi
mov    %r15,%rdx
cmp    %r8,%rsi
mov    0xc(%rsp),%ebp
mov    0x30(%rsp),%r10
jb     1bf0 <djacobi+0xa80>
add    0x4c(%rsp),%r13d
add    $0x1,%r13
and    $0xfffffffffffffffe,%r13
mov    0x20(%rsp),%r8
add    $0x1,%r8
mov    %r8,0x20(%rsp)
and    $0xfffffffffffffffe,%r8
lea    (%r15,%r8,1),%rdx
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm2,%xmm8
unpcklpd %xmm2,%xmm8
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
lea    (%rcx,%r12,8),%rdi
lea    (%rax,%r12,8),%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%rsi,%rbp,8),%xmm4
movupd (%rdi,%rbp,8),%xmm7
movapd %xmm4,%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm7,%xmm6
mulpd  %xmm8,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm6,(%rsi,%rbp,8)
movapd %xmm7,%xmm6
mulpd  %xmm3,%xmm6
subpd  %xmm6,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm4,(%rdi,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r13
jne    1b90 <djacobi+0xa20>
cmp    %r8,0x20(%rsp)
mov    0x30(%rsp),%r10
mov    0xc(%rsp),%ebp
je     1c3c <djacobi+0xacc>
cs nopw 0x0(%rax,%rax,1)
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    %r9d,%esi
jl     1bf0 <djacobi+0xa80>
test   %r9d,%r9d
mov    0x58(%rsp),%rsi
jle    1710 <djacobi+0x5a0>
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
mov    $0x1,%ecx
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rcx,8),%rdx
movsd  (%rdx,%r14,8),%xmm3
movsd  (%rdx,%r15,8),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rdx,%r14,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rdx,%r15,8)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    1c60 <djacobi+0xaf0>
jmp    1710 <djacobi+0x5a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %r9d,%r9d
jle    1e00 <djacobi+0xc90>
cmpq   $0x4,0x68(%rsp)
setb   %al
or     0xb(%rsp),%al
mov    $0x1,%ecx
mov    %rdi,%rsi
mov    0x40(%rsp),%rdx
mov    0x70(%rsp),%r15
mov    0xe0(%rsp),%r14
mov    0x10(%rsp),%rdi
jne    1d64 <djacobi+0xbf4>
xor    %eax,%eax
mov    %rdi,%rcx
nopl   0x0(%rax)
movupd 0x8(%rcx,%rax,8),%xmm0
movupd 0x18(%rcx,%rax,8),%xmm1
movupd 0x8(%rdx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x18(%rdx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
movupd %xmm2,0x8(%rdx,%rax,8)
movupd %xmm0,0x18(%rdx,%rax,8)
movupd %xmm2,0x8(%rsi,%rax,8)
movupd %xmm0,0x18(%rsi,%rax,8)
movupd %xmm1,0x8(%rcx,%rax,8)
movupd %xmm1,0x18(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    1d00 <djacobi+0xb90>
mov    0xc0(%rsp),%rcx
cmp    %r14,0x68(%rsp)
je     14f0 <djacobi+0x380>
mov    %rcx,%rax
test   $0x1,%r10b
jne    1d92 <djacobi+0xc22>
mov    0x10(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
addsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  %xmm0,(%rsi,%rcx,8)
movq   $0x0,(%rax,%rcx,8)
lea    0x1(%rcx),%rax
not    %rcx
cmp    0xc8(%rsp),%rcx
mov    0x10(%rsp),%rcx
je     14f0 <djacobi+0x380>
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
movsd  %xmm0,(%rsi,%rax,8)
movq   $0x0,(%rcx,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm0
addsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rax,8)
movsd  %xmm0,0x8(%rsi,%rax,8)
movq   $0x0,0x8(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1db0 <djacobi+0xc40>
jmp    14f0 <djacobi+0x380>
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebp
cmp    $0x33,%ebp
mov    0x70(%rsp),%r15
jne    14ff <djacobi+0x38f>
jmp    1ec9 <djacobi+0xd59>
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    %r9d,%edx
xor    %eax,%eax
mov    %r9,%rbx
call   1080 <free_dvector@plt>
mov    0x40(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1080 <free_dvector@plt>
mov    $0x1,%eax
testb  $0x1,0x28(%rsp)
jne    1395 <djacobi+0x225>
jmp    13bd <djacobi+0x24d>
test   %r9d,%r9d
jle    1ec9 <djacobi+0xd59>
mov    $0x1,%r15d
lea    0x1c8(%rip),%r14
mov    0x18(%rsp),%rbp
nopl   (%rax)
mov    $0xa,%edi
mov    %r10,%r12
call   1030 <putchar@plt>
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%rbp,%r15,8),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1ea0 <djacobi+0xd30>
add    $0x1,%r15
cmp    %r12,%r15
mov    %r12,%r10
jne    1e80 <djacobi+0xd10>
lea    0x175(%rip),%rdi
xor    %eax,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <nrerror@plt>

LLVM IR (-O0):
@.str = [2 x i8] c"\0A\00"
@.str.1 = [5 x i8] c"%lf \00"
@.str.2 = [38 x i8] c"Too many iterations in routine JACOBI\00"
define void @djacobi(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 %678
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
store i32 1, i32* %14
br label %648
648: ; preds = %673, %647
%649 = load i32, i32* %14
%650 = load i32, i32* %7
%651 = icmp sle i32 %649, %650
br i1 %651, label %652, label %676
652: ; preds = %648
%653 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %11
br label %654
654: ; preds = %669, %652
%655 = load i32, i32* %11
%656 = load i32, i32* %7
%657 = icmp sle i32 %655, %656
br i1 %657, label %658, label %672
658: ; preds = %654
%659 = load double**, double*** %6
%660 = load i32, i32* %14
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds double*, double** %659, i64 %661
%663 = load double*, double** %662
%664 = load i32, i32* %11
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds double, double* %663, i64 %665
%667 = load double, double* %666
%668 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), double %667)
br label %669
669: ; preds = %658
%670 = load i32, i32* %11
%671 = add nsw i32 %670, 1
store i32 %671, i32* %11
br label %654
672: ; preds = %654
br label %673
673: ; preds = %672
%674 = load i32, i32* %14
%675 = add nsw i32 %674, 1
store i32 %675, i32* %14
br label %648
676: ; preds = %648
%677 = call i32 (i8*, ...) bitcast (i32 (...)* @nrerror to i32 (i8*, ...)*)(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.2, i64 0, i64 0))
br label %678
678: ; preds = %676, %138
ret void
}

LLVM IR (-O2):
@.str.1 = [5 x i8] c"%lf \00"
@.str.2 = [38 x i8] c"Too many iterations in routine JACOBI\00"
define void @djacobi(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
br i1 %107, label %115, label %206
115: ; preds = %105
%116 = getelementptr double, double* %8, i64 1
%117 = getelementptr double, double* %8, i64 %111
%118 = getelementptr double, double* %2, i64 1
%119 = getelementptr double, double* %2, i64 %111
%120 = getelementptr double, double* %11, i64 1
%121 = getelementptr double, double* %11, i64 %111
%122 = add nsw i64 %111, -1
%123 = add nsw i64 %112, -1
%124 = and i64 %123, 1
%125 = icmp eq i32 %1, 2
%126 = and i64 %123, -2
%127 = icmp eq i64 %124, 0
%128 = icmp ult i64 %122, 4
%129 = icmp ult double* %116, %119
%130 = icmp ult double* %118, %117
%131 = and i1 %129, %130
%132 = icmp ult double* %116, %121
%133 = icmp ult double* %120, %117
%134 = and i1 %132, %133
%135 = or i1 %131, %134
%136 = icmp ult double* %118, %121
%137 = icmp ult double* %120, %119
%138 = and i1 %136, %137
%139 = or i1 %135, %138
%140 = and i64 %122, -4
%141 = or i64 %140, 1
%142 = icmp eq i64 %122, %140
%143 = and i64 %113, 1
%144 = icmp eq i64 %143, 0
%145 = sub nsw i64 0, %113
br label %146
146: ; preds = %115, %506
%147 = phi i32 [ 1, %115 ], [ %507, %506 ]
br i1 %125, label %186, label %169
148: ; preds = %503
br i1 %12, label %526, label %149
149: ; preds = %148
%150 = zext i32 %106 to i64
br label %511
151: ; preds = %177
%152 = or i64 %171, 1
%153 = add nuw nsw i64 %170, 2
%154 = getelementptr inbounds double*, double** %0, i64 %174
%155 = load double*, double** %154
br label %156
156: ; preds = %156, %151
%157 = phi i64 [ %152, %151 ], [ %163, %156 ]
%158 = phi double [ %183, %151 ], [ %162, %156 ]
%159 = getelementptr inbounds double, double* %155, i64 %157
%160 = load double, double* %159
%161 = tail call double @llvm.fabs.f64(double %160)
%162 = fadd double %158, %161
%163 = add nuw nsw i64 %157, 1
%164 = icmp eq i64 %163, %111
br i1 %164, label %165, label %156
165: ; preds = %156
%166 = add nuw nsw i64 %171, 2
%167 = add i64 %173, 2
%168 = icmp eq i64 %167, %126
br i1 %168, label %186, label %169
169: ; preds = %146, %165
%170 = phi i64 [ %153, %165 ], [ 1, %146 ]
%171 = phi i64 [ %166, %165 ], [ 2, %146 ]
%172 = phi double [ %162, %165 ], [ 0.000000e+00, %146 ]
%173 = phi i64 [ %167, %165 ], [ 0, %146 ]
%174 = add nuw nsw i64 %170, 1
%175 = getelementptr inbounds double*, double** %0, i64 %170
%176 = load double*, double** %175
br label %177
177: ; preds = %169, %177
%178 = phi i64 [ %171, %169 ], [ %184, %177 ]
%179 = phi double [ %172, %169 ], [ %183, %177 ]
%180 = getelementptr inbounds double, double* %176, i64 %178
%181 = load double, double* %180
%182 = tail call double @llvm.fabs.f64(double %181)
%183 = fadd double %179, %182
%184 = add nuw nsw i64 %178, 1
%185 = icmp eq i64 %184, %111
br i1 %185, label %151, label %177
186: ; preds = %165, %146
%187 = phi double [ undef, %146 ], [ %162, %165 ]
%188 = phi i64 [ 1, %146 ], [ %153, %165 ]
%189 = phi i64 [ 2, %146 ], [ %166, %165 ]
%190 = phi double [ 0.000000e+00, %146 ], [ %162, %165 ]
br i1 %127, label %203, label %191
191: ; preds = %186
%192 = getelementptr inbounds double*, double** %0, i64 %188
%193 = load double*, double** %192
br label %194
194: ; preds = %194, %191
%195 = phi i64 [ %189, %191 ], [ %201, %194 ]
%196 = phi double [ %190, %191 ], [ %200, %194 ]
%197 = getelementptr inbounds double, double* %193, i64 %195
%198 = load double, double* %197
%199 = tail call double @llvm.fabs.f64(double %198)
%200 = fadd double %196, %199
%201 = add nuw nsw i64 %195, 1
%202 = icmp eq i64 %201, %111
br i1 %202, label %203, label %194
203: ; preds = %194, %186
%204 = phi double [ %187, %186 ], [ %200, %194 ]
%205 = fcmp oeq double %204, 0.000000e+00
br i1 %205, label %206, label %209
206: ; preds = %203, %506, %105
%207 = tail call i32 (double*, i32, i32, ...) bitcast (i32 (...)* @free_dvector to i32 (double*, i32, i32, ...)*)(double* %11, i32 1, i32 %1)
%208 = tail call i32 (double*, i32, i32, ...) bitcast (i32 (...)* @free_dvector to i32 (double*, i32, i32, ...)*)(double* %8, i32 1, i32 %1)
br label %528
209: ; preds = %203
%210 = icmp ult i32 %147, 4
br i1 %210, label %211, label %214
211: ; preds = %209
%212 = fmul double %204, 2.000000e-01
%213 = fdiv double %212, %109
br label %214
214: ; preds = %209, %211
%215 = phi double [ %213, %211 ], [ 0.000000e+00, %209 ]
br i1 %107, label %216, label %222
216: ; preds = %214
%217 = icmp ugt i32 %147, 4
br label %267
218: ; preds = %481
%219 = add nuw nsw i64 %270, 1
%220 = icmp eq i64 %274, %112
%221 = add i64 %268, 1
br i1 %220, label %222, label %267
222: ; preds = %218, %214
br i1 %12, label %508, label %223
223: ; preds = %222
%224 = select i1 %128, i1 true, i1 %139
br i1 %224, label %253, label %225
225: ; preds = %223, %225
%226 = phi i64 [ %250, %225 ], [ 0, %223 ]
%227 = or i64 %226, 1
%228 = getelementptr inbounds double, double* %11, i64 %227
%229 = bitcast double* %228 to <2 x double>*
%230 = load <2 x double>, <2 x double>* %229
%231 = getelementptr inbounds double, double* %228, i64 2
%232 = bitcast double* %231 to <2 x double>*
%233 = load <2 x double>, <2 x double>* %232
%234 = getelementptr inbounds double, double* %8, i64 %227
%235 = bitcast double* %234 to <2 x double>*
%236 = load <2 x double>, <2 x double>* %235
%237 = getelementptr inbounds double, double* %234, i64 2
%238 = bitcast double* %237 to <2 x double>*
%239 = load <2 x double>, <2 x double>* %238
%240 = fadd <2 x double> %230, %236
%241 = fadd <2 x double> %233, %239
%242 = bitcast double* %234 to <2 x double>*
store <2 x double> %240, <2 x double>* %242
%243 = bitcast double* %237 to <2 x double>*
store <2 x double> %241, <2 x double>* %243
%244 = getelementptr inbounds double, double* %2, i64 %227
%245 = bitcast double* %244 to <2 x double>*
store <2 x double> %240, <2 x double>* %245
%246 = getelementptr inbounds double, double* %244, i64 2
%247 = bitcast double* %246 to <2 x double>*
store <2 x double> %241, <2 x double>* %247
%248 = bitcast double* %228 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %248
%249 = bitcast double* %231 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %249
%250 = add nuw i64 %226, 4
%251 = icmp eq i64 %250, %140
br i1 %251, label %252, label %225
252: ; preds = %225
br i1 %142, label %503, label %253
253: ; preds = %223, %252
%254 = phi i64 [ 1, %223 ], [ %141, %252 ]
%255 = xor i64 %254, -1
br i1 %144, label %256, label %264
256: ; preds = %253
%257 = getelementptr inbounds double, double* %11, i64 %254
%258 = load double, double* %257
%259 = getelementptr inbounds double, double* %8, i64 %254
%260 = load double, double* %259
%261 = fadd double %258, %260
store double %261, double* %259
%262 = getelementptr inbounds double, double* %2, i64 %254
store double %261, double* %262
store double 0.000000e+00, double* %257
%263 = add nuw nsw i64 %254, 1
br label %264
264: ; preds = %256, %253
%265 = phi i64 [ %254, %253 ], [ %263, %256 ]
%266 = icmp eq i64 %255, %145
br i1 %266, label %503, label %486
267: ; preds = %218, %216
%268 = phi i64 [ %221, %218 ], [ 0, %216 ]
%269 = phi i64 [ %274, %218 ], [ 1, %216 ]
%270 = phi i64 [ %219, %218 ], [ 2, %216 ]
%271 = add i64 %268, 3
%272 = add i64 %268, 3
%273 = add i64 %268, 4
%274 = add nuw nsw i64 %269, 1
%275 = getelementptr inbounds double*, double** %0, i64 %269
%276 = getelementptr inbounds double, double* %2, i64 %269
%277 = getelementptr inbounds double, double* %11, i64 %269
%278 = icmp ugt i64 %269, 1
%279 = load double*, double** %275
br label %280
280: ; preds = %267, %481
%281 = phi i64 [ 0, %267 ], [ %485, %481 ]
%282 = phi double* [ %279, %267 ], [ %482, %481 ]
%283 = phi i64 [ %270, %267 ], [ %483, %481 ]
%284 = add i64 %271, %281
%285 = trunc i64 %284 to i32
%286 = call i32 @llvm.smax.i32(i32 %1, i32 %285)
%287 = add i64 %268, %281
%288 = trunc i64 %287 to i32
%289 = sub i32 -3, %288
%290 = add i32 %286, %289
%291 = zext i32 %290 to i64
%292 = add nuw nsw i64 %291, 1
%293 = add i64 %272, %281
%294 = add i64 %273, %281
%295 = trunc i64 %293 to i32
%296 = call i32 @llvm.smax.i32(i32 %1, i32 %295)
%297 = add i64 %268, %281
%298 = trunc i64 %297 to i32
%299 = sub i32 -3, %298
%300 = add i32 %296, %299
%301 = zext i32 %300 to i64
%302 = add i64 %294, %301
%303 = getelementptr inbounds double, double* %282, i64 %283
%304 = load double, double* %303
%305 = tail call double @llvm.fabs.f64(double %304)
%306 = fmul double %305, 1.000000e+02
br i1 %217, label %307, label %319
307: ; preds = %280
%308 = load double, double* %276
%309 = tail call double @llvm.fabs.f64(double %308)
%310 = fadd double %306, %309
%311 = fcmp oeq double %310, %309
br i1 %311, label %312, label %319
312: ; preds = %307
%313 = getelementptr inbounds double, double* %2, i64 %283
%314 = load double, double* %313
%315 = tail call double @llvm.fabs.f64(double %314)
%316 = fadd double %306, %315
%317 = fcmp oeq double %316, %315
br i1 %317, label %318, label %319
318: ; preds = %312
store double 0.000000e+00, double* %303
br label %481
319: ; preds = %312, %307, %280
%320 = fcmp ogt double %305, %215
br i1 %320, label %321, label %481
321: ; preds = %319
%322 = getelementptr inbounds double, double* %2, i64 %283
%323 = load double, double* %322
%324 = load double, double* %276
%325 = fsub double %323, %324
%326 = tail call double @llvm.fabs.f64(double %325)
%327 = fadd double %306, %326
%328 = fcmp oeq double %327, %326
br i1 %328, label %329, label %331
329: ; preds = %321
%330 = fdiv double %304, %325
br label %342
331: ; preds = %321
%332 = fmul double %325, 5.000000e-01
%333 = fdiv double %332, %304
%334 = tail call double @llvm.fabs.f64(double %333)
%335 = tail call double @llvm.fmuladd.f64(double %333, double %333, double 1.000000e+00)
%336 = tail call double @sqrt(double %335)
%337 = fadd double %334, %336
%338 = fdiv double 1.000000e+00, %337
%339 = fcmp olt double %333, 0.000000e+00
br i1 %339, label %340, label %342
340: ; preds = %331
%341 = fneg double %338
br label %342
342: ; preds = %331, %340, %329
%343 = phi double [ %330, %329 ], [ %341, %340 ], [ %338, %331 ]
%344 = tail call double @llvm.fmuladd.f64(double %343, double %343, double 1.000000e+00)
%345 = tail call double @sqrt(double %344)
%346 = fdiv double 1.000000e+00, %345
%347 = fmul double %343, %346
%348 = fadd double %346, 1.000000e+00
%349 = fdiv double %347, %348
%350 = load double*, double** %275
%351 = getelementptr inbounds double, double* %350, i64 %283
%352 = load double, double* %351
%353 = fmul double %343, %352
%354 = load double, double* %277
%355 = fsub double %354, %353
store double %355, double* %277
%356 = getelementptr inbounds double, double* %11, i64 %283
%357 = load double, double* %356
%358 = fadd double %353, %357
store double %358, double* %356
%359 = load double, double* %276
%360 = fsub double %359, %353
store double %360, double* %276
%361 = load double, double* %322
%362 = fadd double %353, %361
store double %362, double* %322
store double 0.000000e+00, double* %351
br i1 %278, label %363, label %365
363: ; preds = %342
%364 = fneg double %347
br label %369
365: ; preds = %369, %342
%366 = icmp ult i64 %274, %283
br i1 %366, label %367, label %384
367: ; preds = %365
%368 = fneg double %347
br label %431
369: ; preds = %363, %369
%370 = phi i64 [ 1, %363 ], [ %382, %369 ]
%371 = getelementptr inbounds double*, double** %0, i64 %370
%372 = load double*, double** %371
%373 = getelementptr inbounds double, double* %372, i64 %269
%374 = load double, double* %373
%375 = getelementptr inbounds double, double* %372, i64 %283
%376 = load double, double* %375
%377 = tail call double @llvm.fmuladd.f64(double %374, double %349, double %376)
%378 = tail call double @llvm.fmuladd.f64(double %364, double %377, double %374)
store double %378, double* %373
%379 = fneg double %376
%380 = tail call double @llvm.fmuladd.f64(double %379, double %349, double %374)
%381 = tail call double @llvm.fmuladd.f64(double %347, double %380, double %376)
store double %381, double* %375
%382 = add nuw nsw i64 %370, 1
%383 = icmp eq i64 %382, %269
br i1 %383, label %365, label %369
384: ; preds = %431, %365
%385 = icmp slt i64 %283, %110
br i1 %385, label %386, label %446
386: ; preds = %384
%387 = getelementptr inbounds double*, double** %0, i64 %283
%388 = load double*, double** %387
%389 = fneg double %347
%390 = icmp eq i32 %290, 0
br i1 %390, label %429, label %391
391: ; preds = %386
%392 = getelementptr double, double* %350, i64 %293
%393 = getelementptr double, double* %350, i64 %302
%394 = getelementptr double, double* %388, i64 %293
%395 = getelementptr double, double* %388, i64 %302
%396 = icmp ult double* %392, %395
%397 = icmp ult double* %394, %393
%398 = and i1 %396, %397
br i1 %398, label %429, label %399
399: ; preds = %391
%400 = and i64 %292, 8589934590
%401 = add nuw i64 %283, %400
%402 = insertelement <2 x double> poison, double %349, i64 0
%403 = shufflevector <2 x double> %402, <2 x double> poison, <2 x i32> zeroinitializer
%404 = insertelement <2 x double> poison, double %389, i64 0
%405 = shufflevector <2 x double> %404, <2 x double> poison, <2 x i32> zeroinitializer
%406 = insertelement <2 x double> poison, double %347, i64 0
%407 = shufflevector <2 x double> %406, <2 x double> poison, <2 x i32> zeroinitializer
br label %408
408: ; preds = %408, %399
%409 = phi i64 [ 0, %399 ], [ %425, %408 ]
%410 = add i64 %283, %409
%411 = add nuw nsw i64 %410, 1
%412 = getelementptr inbounds double, double* %350, i64 %411
%413 = bitcast double* %412 to <2 x double>*
%414 = load <2 x double>, <2 x double>* %413
%415 = getelementptr inbounds double, double* %388, i64 %411
%416 = bitcast double* %415 to <2 x double>*
%417 = load <2 x double>, <2 x double>* %416
%418 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %414, <2 x double> %403, <2 x double> %417)
%419 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %405, <2 x double> %418, <2 x double> %414)
%420 = bitcast double* %412 to <2 x double>*
store <2 x double> %419, <2 x double>* %420
%421 = fneg <2 x double> %417
%422 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %421, <2 x double> %403, <2 x double> %414)
%423 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %407, <2 x double> %422, <2 x double> %417)
%424 = bitcast double* %415 to <2 x double>*
store <2 x double> %423, <2 x double>* %424
%425 = add nuw i64 %409, 2
%426 = icmp eq i64 %425, %400
br i1 %426, label %427, label %408
427: ; preds = %408
%428 = icmp eq i64 %292, %400
br i1 %428, label %446, label %429
429: ; preds = %391, %386, %427
%430 = phi i64 [ %283, %391 ], [ %283, %386 ], [ %401, %427 ]
br label %449
431: ; preds = %367, %431
%432 = phi i64 [ %270, %367 ], [ %444, %431 ]
%433 = getelementptr inbounds double, double* %350, i64 %432
%434 = load double, double* %433
%435 = getelementptr inbounds double*, double** %0, i64 %432
%436 = load double*, double** %435
%437 = getelementptr inbounds double, double* %436, i64 %283
%438 = load double, double* %437
%439 = tail call double @llvm.fmuladd.f64(double %434, double %349, double %438)
%440 = tail call double @llvm.fmuladd.f64(double %368, double %439, double %434)
store double %440, double* %433
%441 = fneg double %438
%442 = tail call double @llvm.fmuladd.f64(double %441, double %349, double %434)
%443 = tail call double @llvm.fmuladd.f64(double %347, double %442, double %438)
store double %443, double* %437
%444 = add nuw nsw i64 %432, 1
%445 = icmp eq i64 %444, %283
br i1 %445, label %384, label %431
446: ; preds = %449, %427, %384
br i1 %12, label %478, label %447
447: ; preds = %446
%448 = fneg double %347
br label %463
449: ; preds = %429, %449
%450 = phi i64 [ %451, %449 ], [ %430, %429 ]
%451 = add nuw nsw i64 %450, 1
%452 = getelementptr inbounds double, double* %350, i64 %451
%453 = load double, double* %452
%454 = getelementptr inbounds double, double* %388, i64 %451
%455 = load double, double* %454
%456 = tail call double @llvm.fmuladd.f64(double %453, double %349, double %455)
%457 = tail call double @llvm.fmuladd.f64(double %389, double %456, double %453)
store double %457, double* %452
%458 = fneg double %455
%459 = tail call double @llvm.fmuladd.f64(double %458, double %349, double %453)
%460 = tail call double @llvm.fmuladd.f64(double %347, double %459, double %455)
store double %460, double* %454
%461 = trunc i64 %451 to i32
%462 = icmp slt i32 %461, %1
br i1 %462, label %449, label %446
463: ; preds = %447, %463
%464 = phi i64 [ 1, %447 ], [ %476, %463 ]
%465 = getelementptr inbounds double*, double** %3, i64 %464
%466 = load double*, double** %465
%467 = getelementptr inbounds double, double* %466, i64 %269
%468 = load double, double* %467
%469 = getelementptr inbounds double, double* %466, i64 %283
%470 = load double, double* %469
%471 = tail call double @llvm.fmuladd.f64(double %468, double %349, double %470)
%472 = tail call double @llvm.fmuladd.f64(double %448, double %471, double %468)
store double %472, double* %467
%473 = fneg double %470
%474 = tail call double @llvm.fmuladd.f64(double %473, double %349, double %468)
%475 = tail call double @llvm.fmuladd.f64(double %347, double %474, double %470)
store double %475, double* %469
%476 = add nuw nsw i64 %464, 1
%477 = icmp eq i64 %476, %113
br i1 %477, label %478, label %463
478: ; preds = %463, %446
%479 = load i32, i32* %4
%480 = add nsw i32 %479, 1
store i32 %480, i32* %4
br label %481
481: ; preds = %318, %478, %319
%482 = phi double* [ %282, %318 ], [ %350, %478 ], [ %282, %319 ]
%483 = add nuw nsw i64 %283, 1
%484 = icmp eq i64 %483, %113
%485 = add i64 %281, 1
br i1 %484, label %218, label %280
486: ; preds = %264, %486
%487 = phi i64 [ %501, %486 ], [ %265, %264 ]
%488 = getelementptr inbounds double, double* %11, i64 %487
%489 = load double, double* %488
%490 = getelementptr inbounds double, double* %8, i64 %487
%491 = load double, double* %490
%492 = fadd double %489, %491
store double %492, double* %490
%493 = getelementptr inbounds double, double* %2, i64 %487
store double %492, double* %493
store double 0.000000e+00, double* %488
%494 = add nuw nsw i64 %487, 1
%495 = getelementptr inbounds double, double* %11, i64 %494
%496 = load double, double* %495
%497 = getelementptr inbounds double, double* %8, i64 %494
%498 = load double, double* %497
%499 = fadd double %496, %498
store double %499, double* %497
%500 = getelementptr inbounds double, double* %2, i64 %494
store double %499, double* %500
store double 0.000000e+00, double* %495
%501 = add nuw nsw i64 %487, 2
%502 = icmp eq i64 %501, %114
br i1 %502, label %503, label %486
503: ; preds = %264, %486, %252
%504 = add nuw nsw i32 %147, 1
%505 = icmp eq i32 %504, 51
br i1 %505, label %148, label %506
506: ; preds = %503, %508
%507 = phi i32 [ %504, %503 ], [ %509, %508 ]
br i1 %107, label %146, label %206
508: ; preds = %222
%509 = add nuw nsw i32 %147, 1
%510 = icmp eq i32 %509, 51
br i1 %510, label %526, label %506
511: ; preds = %523, %149
%512 = phi i64 [ 1, %149 ], [ %524, %523 ]
%513 = tail call i32 @putchar(i32 10)
%514 = getelementptr inbounds double*, double** %0, i64 %512
br label %515
515: ; preds = %511, %515
%516 = phi i64 [ 1, %511 ], [ %521, %515 ]
%517 = load double*, double** %514
%518 = getelementptr inbounds double, double* %517, i64 %516
%519 = load double, double* %518
%520 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), double %519)
%521 = add nuw nsw i64 %516, 1
%522 = icmp eq i64 %521, %150
br i1 %522, label %523, label %515
523: ; preds = %515
%524 = add nuw nsw i64 %512, 1
%525 = icmp eq i64 %524, %150
br i1 %525, label %526, label %511
526: ; preds = %508, %523, %148
%527 = tail call i32 (i8*, ...) bitcast (i32 (...)* @nrerror to i32 (i8*, ...)*)(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.2, i64 0, i64 0))
br label %528
528: ; preds = %526, %206
ret void
}