void jacobi(a, n, d, v, nrot) float **a, d[], **v;
int n, *nrot;
{
  int j, iq, ip, i;
  float tresh, theta, tau, t, sm, s, h, g, c, *b, *z;
  b = fvector(1, n);
  z = fvector(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_fvector(z, 1, n);
      free_fvector(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    $0x80,%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 <fvector@plt>
cltq
mov    %rax,-0x68(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1050 <fvector@plt>
cltq
mov    %rax,-0x70(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11ff <jacobi+0xbf>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11d4 <jacobi+0x94>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11a2 <jacobi+0x62>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  0xe44(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    118f <jacobi+0x4f>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     125f <jacobi+0x11f>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1206 <jacobi+0xc6>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x38(%rbp)
cmpl   $0x32,-0x38(%rbp)
jg     1bcb <jacobi+0xa8b>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     130a <jacobi+0x1ca>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12f7 <jacobi+0x1b7>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0xd51(%rip),%xmm0
pand   %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12a3 <jacobi+0x163>
jmp    12fc <jacobi+0x1bc>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1289 <jacobi+0x149>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1351 <jacobi+0x211>
jp     1351 <jacobi+0x211>
mov    -0x70(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <free_fvector@plt>
mov    -0x68(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <free_fvector@plt>
jmp    1bd9 <jacobi+0xa99>
cmpl   $0x4,-0x38(%rbp)
jge    138d <jacobi+0x24d>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc94(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    1395 <jacobi+0x255>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1b4e <jacobi+0xa0e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b3b <jacobi+0x9fb>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0xc3e(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xc1a(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x4,-0x38(%rbp)
jle    14cc <jacobi+0x38c>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xc03(%rip),%xmm1
pand   %xmm1,%xmm0
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0xbda(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    14cc <jacobi+0x38c>
jp     14cc <jacobi+0x38c>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xbae(%rip),%xmm1
pand   %xmm1,%xmm0
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0xb85(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    14cc <jacobi+0x38c>
jp     14cc <jacobi+0x38c>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1b28 <jacobi+0x9e8>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xb34(%rip),%xmm1
pand   %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b23 <jacobi+0x9e3>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xaee(%rip),%xmm1
pand   %xmm1,%xmm0
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movss  -0x54(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0xacd(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    158b <jacobi+0x44b>
jp     158b <jacobi+0x44b>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    164e <jacobi+0x50e>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa7c(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xa4a(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa1b(%rip),%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  -0x78(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  0xa01(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1649 <jacobi+0x509>
movss  -0x48(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    164e <jacobi+0x50e>
movss  -0x48(%rbp),%xmm0
movss  -0x48(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0x9cc(%rip),%xmm1
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x994(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x5c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x95e(%rip),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     184e <jacobi+0x70e>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x54(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
movss  -0x44(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x58(%rbp),%xmm3
movss  -0x54(%rbp),%xmm2
movss  -0x44(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1765 <jacobi+0x625>
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     1940 <jacobi+0x800>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x54(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
movss  -0x44(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x58(%rbp),%xmm3
movss  -0x54(%rbp),%xmm2
movss  -0x44(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1857 <jacobi+0x717>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1a2d <jacobi+0x8ed>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x54(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
movss  -0x44(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x58(%rbp),%xmm3
movss  -0x54(%rbp),%xmm2
movss  -0x44(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1949 <jacobi+0x809>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b18 <jacobi+0x9d8>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x54(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
movss  -0x44(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x58(%rbp),%xmm3
movss  -0x54(%rbp),%xmm2
movss  -0x44(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a34 <jacobi+0x8f4>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1b28 <jacobi+0x9e8>
jmp    1b2d <jacobi+0x9ed>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13b6 <jacobi+0x276>
jmp    1b40 <jacobi+0xa00>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    139c <jacobi+0x25c>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1bb8 <jacobi+0xa78>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b55 <jacobi+0xa15>
jmp    1bbd <jacobi+0xa7d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1270 <jacobi+0x130>
lea    0x462(%rip),%rdi
mov    $0x0,%al
call   1040 <nrerror@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jacobi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r8,0x90(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rdx,0x18(%rsp)
mov    %esi,%ebx
mov    %rdi,0x28(%rsp)
mov    $0x1,%edi
xor    %eax,%eax
call   1060 <fvector@plt>
movslq %eax,%r13
mov    $0x1,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1060 <fvector@plt>
movslq %eax,%rdi
mov    %ebx,%r12d
test   %ebx,%ebx
mov    %rbx,0x20(%rsp)
mov    %rdi,0x50(%rsp)
mov    %r12,0x48(%rsp)
mov    %r13,0x78(%rsp)
jle    135b <jacobi+0x20b>
lea    0x0(,%r12,4),%r14
lea    -0x1(%r12),%rax
and    $0x3,%r12d
mov    $0x1,%ebx
mov    %rax,0x60(%rsp)
cmp    $0x3,%rax
jb     126e <jacobi+0x11e>
mov    0x48(%rsp),%r15
and    $0xfffffffc,%r15d
xor    %ebx,%ebx
mov    0x30(%rsp),%r13
xchg   %ax,%ax
mov    0x8(%r13,%rbx,8),%rbp
lea    0x4(%rbp),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1050 <memset@plt>
movl   $0x3f800000,0x4(%rbp,%rbx,4)
3f
mov    0x10(%r13,%rbx,8),%rbp
lea    0x4(%rbp),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1050 <memset@plt>
movl   $0x3f800000,0x8(%rbp,%rbx,4)
3f
mov    0x18(%r13,%rbx,8),%rbp
lea    0x4(%rbp),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1050 <memset@plt>
movl   $0x3f800000,0xc(%rbp,%rbx,4)
3f
mov    0x20(%r13,%rbx,8),%rbp
lea    0x4(%rbp),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1050 <memset@plt>
movl   $0x3f800000,0x10(%rbp,%rbx,4)
3f
add    $0x4,%rbx
cmp    %rbx,%r15
jne    11f0 <jacobi+0xa0>
add    $0x1,%rbx
mov    0x78(%rsp),%r13
test   %r12,%r12
mov    0x30(%rsp),%r15
je     12a4 <jacobi+0x154>
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbx,8),%rbp
lea    0x4(%rbp),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1050 <memset@plt>
movl   $0x3f800000,0x0(%rbp,%rbx,4)
3f
add    $0x1,%rbx
add    $0xffffffffffffffff,%r12
jne    1280 <jacobi+0x130>
mov    0x20(%rsp),%rbx
test   %ebx,%ebx
mov    0x50(%rsp),%rdi
mov    0x48(%rsp),%r12
jle    135b <jacobi+0x20b>
cmpq   $0x0,0x60(%rsp)
je     1dd0 <jacobi+0xc80>
mov    %r12d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
mov    $0x1,%eax
mov    0x18(%rsp),%rsi
mov    0x28(%rsp),%rbp
nop
mov    0x0(%rbp,%rax,8),%rdx
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm0,0x0(%r13,%rax,4)
movl   $0x0,(%rdi,%rax,4)
mov    0x8(%rbp,%rax,8),%rdx
movss  0x4(%rdx,%rax,4),%xmm0
movss  %xmm0,0x4(%rsi,%rax,4)
movss  %xmm0,0x4(%r13,%rax,4)
movl   $0x0,0x4(%rdi,%rax,4)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    12e0 <jacobi+0x190>
test   $0x1,%r12b
je     135b <jacobi+0x20b>
mov    0x28(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
movss  (%rcx,%rax,4),%xmm0
mov    0x18(%rsp),%rcx
movss  %xmm0,(%rcx,%rax,4)
movss  %xmm0,0x0(%r13,%rax,4)
movl   $0x0,(%rdi,%rax,4)
lea    0x1(%rbx),%esi
mov    0x90(%rsp),%rax
movl   $0x0,(%rax)
mov    %ebx,%eax
imul   %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xd8(%rsp)
lea    0x4(%r13),%rax
lea    0x0(%r13,%rsi,4),%rcx
mov    0x18(%rsp),%rbp
lea    0x4(%rbp),%r10
lea    0x0(%rbp,%rsi,4),%r8
lea    0x4(%rdi),%r9
lea    -0x1(%r12),%rbx
mov    %rbx,%rdx
mov    %rbx,0xf0(%rsp)
mov    %rbx,%r15
and    $0xfffffffffffffffe,%r15
cmp    %r8,%rax
setb   %bl
cmp    %rcx,%r10
setb   %dl
and    %bl,%dl
lea    (%rdi,%rsi,4),%rbx
cmp    %rbx,%rax
setb   %al
cmp    %rcx,%r9
movslq 0x20(%rsp),%rcx
mov    %rcx,0x108(%rsp)
setb   %cl
and    %al,%cl
or     %dl,%cl
lea    -0x1(%rsi),%rdx
cmp    %rbx,%r10
mov    0x20(%rsp),%rbx
setb   %r11b
cmp    %r8,%r9
setb   %al
and    %r11b,%al
or     %cl,%al
mov    %al,0x7(%rsp)
mov    %rdx,0x70(%rsp)
mov    %rdx,%r12
and    $0xfffffffffffffff8,%r12
lea    0x1(%r12),%rax
mov    %rax,0xc0(%rsp)
mov    %rsi,0x8(%rsp)
neg    %rsi
mov    %rsi,0xc8(%rsp)
mov    %rbp,%r10
mov    0x28(%rsp),%r11
lea    0x10(%r11),%rax
mov    %rax,0xd0(%rsp)
movaps 0xbba(%rip),%xmm9
movss  0xbf9(%rip),%xmm10
movaps 0xbb9(%rip),%xmm11
xorpd  %xmm12,%xmm12
movsd  0xbdb(%rip),%xmm13
movaps 0xbb3(%rip),%xmm14
mov    0x30(%rsp),%r9
movl   $0x1,0x14(%rsp)
mov    %r15,0xe8(%rsp)
mov    %r12,0xe0(%rsp)
jmp    14a4 <jacobi+0x354>
nopl   0x0(%rax)
mov    0x14(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x14(%rsp)
cmp    $0x33,%eax
je     1db1 <jacobi+0xc61>
cmp    $0x2,%ebx
jl     1d81 <jacobi+0xc31>
xorpd  %xmm0,%xmm0
mov    $0x2,%eax
mov    $0x1,%r14d
je     1547 <jacobi+0x3f7>
mov    0x8(%rsp),%rdx
xor    %esi,%esi
nopl   0x0(%rax)
lea    0x0(,%rsi,4),%rcx
mov    (%r11,%r14,8),%rbp
add    %rcx,%rbp
mov    $0x2,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x0(%rbp,%rbx,4),%xmm1
andps  %xmm9,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    14f0 <jacobi+0x3a0>
add    0x8(%r11,%r14,8),%rcx
add    $0x2,%r14
mov    $0x3,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rcx,%rbp,4),%xmm1
andps  %xmm9,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1520 <jacobi+0x3d0>
add    $0x2,%rax
add    $0x2,%rsi
add    $0xfffffffffffffffe,%rdx
cmp    %r15,%rsi
jne    14d0 <jacobi+0x380>
testb  $0x1,0xf0(%rsp)
01
mov    0x8(%rsp),%rdx
je     1576 <jacobi+0x426>
mov    (%r11,%r14,8),%rcx
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rax,4),%xmm1
andps  %xmm9,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rax
cmp    %rax,%rdx
jne    1560 <jacobi+0x410>
ucomiss 0xad3(%rip),%xmm0
mov    0x20(%rsp),%rbx
jne    158a <jacobi+0x43a>
jnp    1d81 <jacobi+0xc31>
xorps  %xmm1,%xmm1
cmpl   $0x3,0x14(%rsp)
ja     15b0 <jacobi+0x460>
cvtss2sd %xmm0,%xmm0
mulsd  0xa90(%rip),%xmm0
divsd  0xd8(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
cmp    $0x2,%ebx
mov    0x8(%rsp),%rdi
jl     1c40 <jacobi+0xaf0>
cvtss2sd %xmm1,%xmm15
mov    $0x2,%r14d
mov    $0x1,%ebp
mov    $0xfffffffd,%ecx
mov    $0x3,%r15d
mov    0xd0(%rsp),%rax
xor    %edx,%edx
movsd  %xmm15,0x88(%rsp)
jmp    1637 <jacobi+0x4e7>
nop
mov    0x80(%rsp),%r14
add    $0x1,%r14
mov    0x58(%rsp),%rdx
add    $0x1,%rdx
mov    0xa0(%rsp),%rax
add    $0x8,%rax
mov    0x6c(%rsp),%ecx
add    $0xffffffff,%ecx
mov    0xf8(%rsp),%r15
add    $0x1,%r15
mov    0x98(%rsp),%rbp
cmp    0x48(%rsp),%rbp
je     1c40 <jacobi+0xaf0>
mov    %rax,0xa0(%rsp)
lea    0x3(%rdx),%rax
mov    %rax,0x110(%rsp)
mov    %rdx,0x58(%rsp)
lea    0x4(%rdx),%rax
mov    %rax,0x100(%rsp)
lea    0x1(%rbp),%rax
mov    %rax,0x98(%rsp)
mov    (%r11,%rbp,8),%rax
mov    %r15,0xf8(%rsp)
mov    %ecx,0x6c(%rsp)
mov    %ecx,%edx
xor    %r12d,%r12d
mov    %r14,%rcx
mov    %r14,0x80(%rsp)
jmp    16b7 <jacobi+0x567>
nopw   0x0(%rax,%rax,1)
mov    0x90(%rsp),%rcx
addl   $0x1,(%rcx)
mov    0x44(%rsp),%edx
add    $0x1,%r14
add    $0x1,%r12
add    $0x1,%r15
add    $0xffffffff,%edx
cmp    %rdi,%r14
je     15f0 <jacobi+0x4a0>
cmp    %r15d,%ebx
mov    %r15d,%r13d
cmovg  %ebx,%r13d
mov    0x110(%rsp),%rsi
lea    (%rsi,%r12,1),%ecx
cmp    %ecx,%ebx
cmovg  %ebx,%ecx
lea    (%rsi,%r12,1),%r8
cmp    %r8d,%ebx
mov    %r8d,%esi
cmovg  %ebx,%esi
mov    %rsi,0x60(%rsp)
movss  (%rax,%r14,4),%xmm5
movaps %xmm5,%xmm0
andps  %xmm9,%xmm0
mulss  %xmm10,%xmm0
cmpl   $0x5,0x14(%rsp)
jb     1750 <jacobi+0x600>
movss  (%r10,%rbp,4),%xmm1
andps  %xmm9,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movaps %xmm1,%xmm3
addsd  %xmm2,%xmm3
ucomisd %xmm2,%xmm3
jne    1750 <jacobi+0x600>
jp     1750 <jacobi+0x600>
movss  (%r10,%r14,4),%xmm2
andps  %xmm9,%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm2,%xmm1
jne    1750 <jacobi+0x600>
jp     1750 <jacobi+0x600>
movl   $0x0,(%rax,%r14,4)
jmp    169f <jacobi+0x54f>
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtss2sd %xmm5,%xmm1
movaps %xmm1,%xmm2
andps  %xmm11,%xmm2
ucomisd %xmm15,%xmm2
jbe    169f <jacobi+0x54f>
movss  (%r10,%r14,4),%xmm2
subss  (%r10,%rbp,4),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm2,%xmm3
movaps %xmm3,%xmm4
andps  %xmm11,%xmm4
cvtss2sd %xmm0,%xmm0
addsd  %xmm4,%xmm0
ucomisd %xmm4,%xmm0
mov    %edx,0x44(%rsp)
mov    %rcx,0x38(%rsp)
mov    %r8,0xa8(%rsp)
jne    17ad <jacobi+0x65d>
jp     17ad <jacobi+0x65d>
divss  %xmm2,%xmm5
jmp    1870 <jacobi+0x720>
mulsd  0x883(%rip),%xmm3
divsd  %xmm1,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
movaps %xmm2,%xmm0
mulss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm13,%xmm0
ucomisd %xmm12,%xmm0
jb     17dd <jacobi+0x68d>
sqrtsd %xmm0,%xmm0
jmp    183f <jacobi+0x6ef>
movaps %xmm2,0xb0(%rsp)
call   1070 <sqrt@plt>
movaps 0xb0(%rsp),%xmm2
movsd  0x88(%rsp),%xmm15
movaps 0x81c(%rip),%xmm14
movsd  0x833(%rip),%xmm13
xorpd  %xmm12,%xmm12
movaps 0x7f6(%rip),%xmm11
movss  0x825(%rip),%xmm10
movaps 0x7d5(%rip),%xmm9
mov    0x8(%rsp),%rdi
mov    0x28(%rsp),%r11
mov    0x18(%rsp),%r10
mov    0x30(%rsp),%r9
xorps  %xmm1,%xmm1
ucomiss %xmm2,%xmm1
andps  %xmm9,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm13,%xmm0
divsd  %xmm1,%xmm0
xorps  %xmm5,%xmm5
cvtsd2ss %xmm0,%xmm5
jbe    1870 <jacobi+0x720>
xorps  %xmm14,%xmm5
nopw   0x0(%rax,%rax,1)
movaps %xmm5,%xmm0
mulss  %xmm5,%xmm0
addss  0x7cd(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm12,%xmm0
jb     1890 <jacobi+0x740>
sqrtsd %xmm0,%xmm0
jmp    18f2 <jacobi+0x7a2>
movaps %xmm5,0xb0(%rsp)
call   1070 <sqrt@plt>
movaps 0xb0(%rsp),%xmm5
movsd  0x88(%rsp),%xmm15
movaps 0x769(%rip),%xmm14
movsd  0x780(%rip),%xmm13
xorpd  %xmm12,%xmm12
movaps 0x743(%rip),%xmm11
movss  0x772(%rip),%xmm10
movaps 0x722(%rip),%xmm9
mov    0x8(%rsp),%rdi
mov    0x28(%rsp),%r11
mov    0x18(%rsp),%r10
mov    0x30(%rsp),%r9
movapd %xmm13,%xmm1
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movaps %xmm5,%xmm0
mulss  %xmm1,%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
cvtss2sd %xmm1,%xmm1
addsd  %xmm13,%xmm1
divsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
mov    (%r11,%rbp,8),%rax
mulss  (%rax,%r14,4),%xmm5
mov    0x50(%rsp),%rcx
movss  (%rcx,%rbp,4),%xmm2
subss  %xmm5,%xmm2
movss  %xmm2,(%rcx,%rbp,4)
movss  (%rcx,%r14,4),%xmm2
addss  %xmm5,%xmm2
movss  %xmm2,(%rcx,%r14,4)
movss  (%r10,%rbp,4),%xmm2
subss  %xmm5,%xmm2
movss  %xmm2,(%r10,%rbp,4)
addss  (%r10,%r14,4),%xmm5
movss  %xmm5,(%r10,%r14,4)
movl   $0x0,(%rax,%r14,4)
cmp    $0x2,%rbp
mov    0x58(%rsp),%rsi
jb     19da <jacobi+0x88a>
movaps %xmm0,%xmm2
xorps  %xmm14,%xmm2
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%r11,%rcx,8),%rdx
movss  (%rdx,%rbp,4),%xmm3
movss  (%rdx,%r14,4),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,(%rdx,%rbp,4)
movaps %xmm4,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm5,%xmm3
mulss  %xmm0,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,(%rdx,%r14,4)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1990 <jacobi+0x840>
cmp    %r14,0x98(%rsp)
mov    0xa0(%rsp),%r8
jae    1a59 <jacobi+0x909>
movaps %xmm0,%xmm2
xorps  %xmm14,%xmm2
mov    0x80(%rsp),%rcx
lea    (%rax,%rcx,4),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rdx,4),%xmm3
mov    (%r8,%rdx,8),%rsi
movss  (%rsi,%r14,4),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,(%rcx,%rdx,4)
movaps %xmm4,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm5,%xmm3
mulss  %xmm0,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,(%rsi,%r14,4)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1a10 <jacobi+0x8c0>
cmp    0x108(%rsp),%r14
jge    1bc9 <jacobi+0xa79>
mov    0x58(%rsp),%rcx
add    %r12d,%ecx
mov    $0xfffffffd,%esi
sub    %ecx,%esi
mov    0x38(%rsp),%r8
add    %esi,%r8d
mov    (%r11,%r14,8),%rcx
movaps %xmm0,%xmm2
xorps  %xmm14,%xmm2
mov    %r14,%rdx
mov    %r8,0x38(%rsp)
cmp    $0x3,%r8d
jb     1b80 <jacobi+0xa30>
mov    0x100(%rsp),%rdx
add    %r12,%rdx
mov    0x60(%rsp),%rdi
add    %esi,%edi
add    %rdx,%rdi
mov    0xa8(%rsp),%rdx
lea    (%rax,%rdx,4),%rdx
lea    (%rcx,%rdi,4),%rsi
cmp    %rsi,%rdx
jae    1ae9 <jacobi+0x999>
mov    %rdi,%r8
lea    (%rax,%rdi,4),%rsi
mov    0xa8(%rsp),%rdx
lea    (%rcx,%rdx,4),%rdi
mov    %r14,%rdx
cmp    %rsi,%rdi
mov    0x8(%rsp),%rdi
jb     1b80 <jacobi+0xa30>
add    0x44(%rsp),%r13d
add    $0x1,%r13
and    $0xfffffffffffffffc,%r13
mov    0x38(%rsp),%r8
add    $0x1,%r8
mov    %r8,0x38(%rsp)
and    $0xfffffffffffffffc,%r8
lea    (%r14,%r8,1),%rdx
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
movaps %xmm2,%xmm8
shufps $0x0,%xmm2,%xmm8
movaps %xmm0,%xmm5
shufps $0x0,%xmm0,%xmm5
lea    (%rcx,%r15,4),%rdi
lea    (%rax,%r15,4),%rsi
xor    %ebx,%ebx
nopl   (%rax)
movups (%rsi,%rbx,4),%xmm4
movups (%rdi,%rbx,4),%xmm7
movaps %xmm4,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm7,%xmm6
mulps  %xmm8,%xmm6
addps  %xmm4,%xmm6
movups %xmm6,(%rsi,%rbx,4)
movaps %xmm7,%xmm6
mulps  %xmm3,%xmm6
subps  %xmm6,%xmm4
mulps  %xmm5,%xmm4
addps  %xmm7,%xmm4
movups %xmm4,(%rdi,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r13
jne    1b30 <jacobi+0x9e0>
cmp    %r8,0x38(%rsp)
mov    0x20(%rsp),%rbx
mov    0x8(%rsp),%rdi
je     1bc9 <jacobi+0xa79>
nopl   0x0(%rax)
movss  0x4(%rax,%rdx,4),%xmm3
movss  0x4(%rcx,%rdx,4),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,0x4(%rax,%rdx,4)
movaps %xmm4,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm5,%xmm3
mulss  %xmm0,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,0x4(%rcx,%rdx,4)
lea    0x1(%rdx),%rsi
mov    %rsi,%rdx
cmp    %ebx,%esi
jl     1b80 <jacobi+0xa30>
test   %ebx,%ebx
mov    0x18(%rsp),%r10
jle    1690 <jacobi+0x540>
movaps %xmm0,%xmm2
xorps  %xmm14,%xmm2
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r9,%rcx,8),%rdx
movss  (%rdx,%rbp,4),%xmm3
movss  (%rdx,%r14,4),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,(%rdx,%rbp,4)
movaps %xmm4,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm5,%xmm3
mulss  %xmm0,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,(%rdx,%r14,4)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1bf0 <jacobi+0xaa0>
jmp    1690 <jacobi+0x540>
xchg   %ax,%ax
test   %ebx,%ebx
mov    0x78(%rsp),%r13
mov    %rdi,%rdx
mov    0x50(%rsp),%rdi
mov    0xe8(%rsp),%r15
mov    0xe0(%rsp),%r12
jle    1490 <jacobi+0x340>
cmpq   $0x8,0x70(%rsp)
setb   %al
or     0x7(%rsp),%al
mov    $0x1,%ecx
jne    1ce2 <jacobi+0xb92>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups 0x4(%rdi,%rax,4),%xmm0
movups 0x14(%rdi,%rax,4),%xmm1
movups 0x4(%r13,%rax,4),%xmm2
addps  %xmm0,%xmm2
movups 0x14(%r13,%rax,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x4(%r13,%rax,4)
movups %xmm0,0x14(%r13,%rax,4)
movups %xmm2,0x4(%r10,%rax,4)
xorps  %xmm1,%xmm1
movups %xmm0,0x14(%r10,%rax,4)
movups %xmm1,0x4(%rdi,%rax,4)
movups %xmm1,0x14(%rdi,%rax,4)
add    $0x8,%rax
cmp    %rax,%r12
jne    1c80 <jacobi+0xb30>
mov    0xc0(%rsp),%rcx
cmp    %r12,0x70(%rsp)
mov    0x8(%rsp),%rdx
je     1490 <jacobi+0x340>
mov    %rcx,%rax
test   $0x1,%dl
jne    1d0e <jacobi+0xbbe>
movss  (%rdi,%rcx,4),%xmm0
addss  0x0(%r13,%rcx,4),%xmm0
movss  %xmm0,0x0(%r13,%rcx,4)
movss  %xmm0,(%r10,%rcx,4)
movl   $0x0,(%rdi,%rcx,4)
lea    0x1(%rcx),%rax
not    %rcx
cmp    0xc8(%rsp),%rcx
mov    0x8(%rsp),%rcx
je     1490 <jacobi+0x340>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdi,%rax,4),%xmm0
addss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,0x0(%r13,%rax,4)
movss  %xmm0,(%r10,%rax,4)
movl   $0x0,(%rdi,%rax,4)
movss  0x4(%rdi,%rax,4),%xmm0
addss  0x4(%r13,%rax,4),%xmm0
movss  %xmm0,0x4(%r13,%rax,4)
movss  %xmm0,0x4(%r10,%rax,4)
movl   $0x0,0x4(%rdi,%rax,4)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1d30 <jacobi+0xbe0>
jmp    1490 <jacobi+0x340>
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1030 <free_fvector@plt>
mov    %r13,%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    1030 <free_fvector@plt>
lea    0x29c(%rip),%rdi
xor    %eax,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <nrerror@plt>
mov    $0x1,%eax
test   $0x1,%r12b
jne    1335 <jacobi+0x1e5>
jmp    135b <jacobi+0x20b>

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

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