void jacobi(float **a, int n, float d[], float **v, int *nrot) {
  int j, iq, ip, i;
  float tresh, theta, tau, t, sm, s, h, g, c, *b, *z;
  b = vector(1, n);
  z = vector(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_vector(z, 1, n);
      free_vector(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 && (float)(fabs(d[ip]) + g) == (float)fabs(d[ip]) &&
            (float)(fabs(d[iq]) + g) == (float)fabs(d[iq]))
          a[ip][iq] = 0.0;
        else if (fabs(a[ip][iq]) > tresh) {
          h = d[iq] - d[ip];
          if ((float)(fabs(h) + g) == (float)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 <vector@plt>
cltq
mov    %rax,-0x68(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1050 <vector@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     1be0 <jacobi+0xaa0>
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   1040 <free_vector@plt>
mov    -0x68(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1040 <free_vector@plt>
jmp    1bee <jacobi+0xaae>
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     1b63 <jacobi+0xa23>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b50 <jacobi+0xa10>
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    14da <jacobi+0x39a>
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
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0xbd6(%rip),%xmm2
pand   %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14da <jacobi+0x39a>
jp     14da <jacobi+0x39a>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xba7(%rip),%xmm1
pand   %xmm1,%xmm0
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0xb7a(%rip),%xmm2
pand   %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14da <jacobi+0x39a>
jp     14da <jacobi+0x39a>
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    1b3d <jacobi+0x9fd>
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 0xb26(%rip),%xmm1
pand   %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b38 <jacobi+0x9f8>
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 0xae0(%rip),%xmm1
pand   %xmm1,%xmm0
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  -0x54(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0xabb(%rip),%xmm2
pand   %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    15a0 <jacobi+0x460>
jp     15a0 <jacobi+0x460>
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    1663 <jacobi+0x523>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa67(%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 0xa35(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa06(%rip),%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  -0x78(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  0x9ec(%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    165e <jacobi+0x51e>
movss  -0x48(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    1663 <jacobi+0x523>
movss  -0x48(%rbp),%xmm0
movss  -0x48(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0x9b7(%rip),%xmm1
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x97f(%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  0x949(%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     1863 <jacobi+0x723>
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    177a <jacobi+0x63a>
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     1955 <jacobi+0x815>
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    186c <jacobi+0x72c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1a42 <jacobi+0x902>
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    195e <jacobi+0x81e>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b2d <jacobi+0x9ed>
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    1a49 <jacobi+0x909>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1b3d <jacobi+0x9fd>
jmp    1b42 <jacobi+0xa02>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13b6 <jacobi+0x276>
jmp    1b55 <jacobi+0xa15>
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     1bcd <jacobi+0xa8d>
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    1b6a <jacobi+0xa2a>
jmp    1bd2 <jacobi+0xa92>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1270 <jacobi+0x130>
lea    0x44d(%rip),%rdi
mov    $0x0,%al
call   1030 <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 <vector@plt>
movslq %eax,%r13
mov    $0x1,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1060 <vector@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     1740 <jacobi+0x5f0>
movss  (%r10,%rbp,4),%xmm1
andps  %xmm9,%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
ucomiss %xmm1,%xmm2
jne    1740 <jacobi+0x5f0>
jp     1740 <jacobi+0x5f0>
movss  (%r10,%r14,4),%xmm1
andps  %xmm9,%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
ucomiss %xmm1,%xmm2
jne    1740 <jacobi+0x5f0>
jp     1740 <jacobi+0x5f0>
movl   $0x0,(%rax,%r14,4)
jmp    169f <jacobi+0x54f>
nopw   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
cvtsd2ss %xmm0,%xmm0
cvtsd2ss %xmm4,%xmm4
ucomiss %xmm4,%xmm0
mov    %edx,0x44(%rsp)
mov    %rcx,0x38(%rsp)
mov    %r8,0xa8(%rsp)
jne    17a4 <jacobi+0x654>
jp     17a4 <jacobi+0x654>
divss  %xmm2,%xmm5
jmp    1870 <jacobi+0x720>
mulsd  0x88c(%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     17d4 <jacobi+0x684>
sqrtsd %xmm0,%xmm0
jmp    1836 <jacobi+0x6e6>
movaps %xmm2,0xb0(%rsp)
call   1070 <sqrt@plt>
movaps 0xb0(%rsp),%xmm2
movsd  0x88(%rsp),%xmm15
movaps 0x825(%rip),%xmm14
movsd  0x83c(%rip),%xmm13
xorpd  %xmm12,%xmm12
movaps 0x7ff(%rip),%xmm11
movss  0x82e(%rip),%xmm10
movaps 0x7de(%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
cs nopw 0x0(%rax,%rax,1)
nopl   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   1040 <free_vector@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    1040 <free_vector@plt>
lea    0x29c(%rip),%rdi
xor    %eax,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <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 (...)* @vector 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 (...)* @vector 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 = %682, %97
%100 = load i32, i32* %14
%101 = icmp sle i32 %100, 50
br i1 %101, label %102, label %685
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_vector 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_vector to i32 (float*, i32, i32, ...)*)(float* %146, i32 1, i32 %147)
br label %687
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 = %645, %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 %648
169: ; preds = %164
%170 = load i32, i32* %13
%171 = add nsw i32 %170, 1
store i32 %171, i32* %12
br label %172
172: ; preds = %641, %169
%173 = load i32, i32* %12
%174 = load i32, i32* %7
%175 = icmp sle i32 %173, %174
br i1 %175, label %176, label %644
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 %243
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 = fptrunc double %202 to float
%204 = load float*, float** %8
%205 = load i32, i32* %13
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %204, i64 %206
%208 = load float, float* %207
%209 = fpext float %208 to double
%210 = call double @llvm.fabs.f64(double %209)
%211 = fptrunc double %210 to float
%212 = fcmp oeq float %203, %211
br i1 %212, label %213, label %243
213: ; preds = %192
%214 = load float*, float** %8
%215 = load i32, i32* %12
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds float, float* %214, i64 %216
%218 = load float, float* %217
%219 = fpext float %218 to double
%220 = call double @llvm.fabs.f64(double %219)
%221 = load float, float* %22
%222 = fpext float %221 to double
%223 = fadd double %220, %222
%224 = fptrunc double %223 to float
%225 = load float*, float** %8
%226 = load i32, i32* %12
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds float, float* %225, i64 %227
%229 = load float, float* %228
%230 = fpext float %229 to double
%231 = call double @llvm.fabs.f64(double %230)
%232 = fptrunc double %231 to float
%233 = fcmp oeq float %224, %232
br i1 %233, label %234, label %243
234: ; preds = %213
%235 = load float**, float*** %6
%236 = load i32, i32* %13
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds float*, float** %235, i64 %237
%239 = load float*, float** %238
%240 = load i32, i32* %12
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds float, float* %239, i64 %241
store float 0.000000e+00, float* %242
br label %640
243: ; preds = %213, %192, %176
%244 = load float**, float*** %6
%245 = load i32, i32* %13
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds float*, float** %244, i64 %246
%248 = load float*, float** %247
%249 = load i32, i32* %12
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds float, float* %248, i64 %250
%252 = load float, float* %251
%253 = fpext float %252 to double
%254 = call double @llvm.fabs.f64(double %253)
%255 = load float, float* %15
%256 = fpext float %255 to double
%257 = fcmp ogt double %254, %256
br i1 %257, label %258, label %639
258: ; preds = %243
%259 = load float*, float** %8
%260 = load i32, i32* %12
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds float, float* %259, i64 %261
%263 = load float, float* %262
%264 = load float*, float** %8
%265 = load i32, i32* %13
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds float, float* %264, i64 %266
%268 = load float, float* %267
%269 = fsub float %263, %268
store float %269, float* %21
%270 = load float, float* %21
%271 = fpext float %270 to double
%272 = call double @llvm.fabs.f64(double %271)
%273 = load float, float* %22
%274 = fpext float %273 to double
%275 = fadd double %272, %274
%276 = fptrunc double %275 to float
%277 = load float, float* %21
%278 = fpext float %277 to double
%279 = call double @llvm.fabs.f64(double %278)
%280 = fptrunc double %279 to float
%281 = fcmp oeq float %276, %280
br i1 %281, label %282, label %294
282: ; preds = %258
%283 = load float**, float*** %6
%284 = load i32, i32* %13
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds float*, float** %283, i64 %285
%287 = load float*, float** %286
%288 = load i32, i32* %12
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds float, float* %287, i64 %289
%291 = load float, float* %290
%292 = load float, float* %21
%293 = fdiv float %291, %292
store float %293, float* %18
br label %329
294: ; preds = %258
%295 = load float, float* %21
%296 = fpext float %295 to double
%297 = fmul double 5.000000e-01, %296
%298 = load float**, float*** %6
%299 = load i32, i32* %13
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds float*, float** %298, i64 %300
%302 = load float*, float** %301
%303 = load i32, i32* %12
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds float, float* %302, i64 %304
%306 = load float, float* %305
%307 = fpext float %306 to double
%308 = fdiv double %297, %307
%309 = fptrunc double %308 to float
store float %309, float* %16
%310 = load float, float* %16
%311 = fpext float %310 to double
%312 = call double @llvm.fabs.f64(double %311)
%313 = load float, float* %16
%314 = load float, float* %16
%315 = fmul float %313, %314
%316 = fpext float %315 to double
%317 = fadd double 1.000000e+00, %316
%318 = call double @sqrt(double %317)
%319 = fadd double %312, %318
%320 = fdiv double 1.000000e+00, %319
%321 = fptrunc double %320 to float
store float %321, float* %18
%322 = load float, float* %16
%323 = fpext float %322 to double
%324 = fcmp olt double %323, 0.000000e+00
br i1 %324, label %325, label %328
325: ; preds = %294
%326 = load float, float* %18
%327 = fneg float %326
store float %327, float* %18
br label %328
328: ; preds = %325, %294
br label %329
329: ; preds = %328, %282
%330 = load float, float* %18
%331 = load float, float* %18
%332 = call float @llvm.fmuladd.f32(float %330, float %331, float 1.000000e+00)
%333 = fpext float %332 to double
%334 = call double @sqrt(double %333)
%335 = fdiv double 1.000000e+00, %334
%336 = fptrunc double %335 to float
store float %336, float* %23
%337 = load float, float* %18
%338 = load float, float* %23
%339 = fmul float %337, %338
store float %339, float* %20
%340 = load float, float* %20
%341 = fpext float %340 to double
%342 = load float, float* %23
%343 = fpext float %342 to double
%344 = fadd double 1.000000e+00, %343
%345 = fdiv double %341, %344
%346 = fptrunc double %345 to float
store float %346, float* %17
%347 = load float, float* %18
%348 = load float**, float*** %6
%349 = load i32, i32* %13
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds float*, float** %348, i64 %350
%352 = load float*, float** %351
%353 = load i32, i32* %12
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds float, float* %352, i64 %354
%356 = load float, float* %355
%357 = fmul float %347, %356
store float %357, float* %21
%358 = load float, float* %21
%359 = load float*, float** %25
%360 = load i32, i32* %13
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds float, float* %359, i64 %361
%363 = load float, float* %362
%364 = fsub float %363, %358
store float %364, float* %362
%365 = load float, float* %21
%366 = load float*, float** %25
%367 = load i32, i32* %12
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds float, float* %366, i64 %368
%370 = load float, float* %369
%371 = fadd float %370, %365
store float %371, float* %369
%372 = load float, float* %21
%373 = load float*, float** %8
%374 = load i32, i32* %13
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds float, float* %373, i64 %375
%377 = load float, float* %376
%378 = fsub float %377, %372
store float %378, float* %376
%379 = load float, float* %21
%380 = load float*, float** %8
%381 = load i32, i32* %12
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds float, float* %380, i64 %382
%384 = load float, float* %383
%385 = fadd float %384, %379
store float %385, float* %383
%386 = load float**, float*** %6
%387 = load i32, i32* %13
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds float*, float** %386, i64 %388
%390 = load float*, float** %389
%391 = load i32, i32* %12
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds float, float* %390, i64 %392
store float 0.000000e+00, float* %393
store i32 1, i32* %11
br label %394
394: ; preds = %450, %329
%395 = load i32, i32* %11
%396 = load i32, i32* %13
%397 = sub nsw i32 %396, 1
%398 = icmp sle i32 %395, %397
br i1 %398, label %399, label %453
399: ; preds = %394
%400 = load float**, float*** %6
%401 = load i32, i32* %11
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds float*, float** %400, i64 %402
%404 = load float*, float** %403
%405 = load i32, i32* %13
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds float, float* %404, i64 %406
%408 = load float, float* %407
store float %408, float* %22
%409 = load float**, float*** %6
%410 = load i32, i32* %11
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds float*, float** %409, i64 %411
%413 = load float*, float** %412
%414 = load i32, i32* %12
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds float, float* %413, i64 %415
%417 = load float, float* %416
store float %417, float* %21
%418 = load float, float* %22
%419 = load float, float* %20
%420 = load float, float* %21
%421 = load float, float* %22
%422 = load float, float* %17
%423 = call float @llvm.fmuladd.f32(float %421, float %422, float %420)
%424 = fneg float %419
%425 = call float @llvm.fmuladd.f32(float %424, float %423, float %418)
%426 = load float**, float*** %6
%427 = load i32, i32* %11
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds float*, float** %426, i64 %428
%430 = load float*, float** %429
%431 = load i32, i32* %13
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds float, float* %430, i64 %432
store float %425, float* %433
%434 = load float, float* %21
%435 = load float, float* %20
%436 = load float, float* %22
%437 = load float, float* %21
%438 = load float, float* %17
%439 = fneg float %437
%440 = call float @llvm.fmuladd.f32(float %439, float %438, float %436)
%441 = call float @llvm.fmuladd.f32(float %435, float %440, float %434)
%442 = load float**, float*** %6
%443 = load i32, i32* %11
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds float*, float** %442, i64 %444
%446 = load float*, float** %445
%447 = load i32, i32* %12
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds float, float* %446, i64 %448
store float %441, float* %449
br label %450
450: ; preds = %399
%451 = load i32, i32* %11
%452 = add nsw i32 %451, 1
store i32 %452, i32* %11
br label %394
453: ; preds = %394
%454 = load i32, i32* %13
%455 = add nsw i32 %454, 1
store i32 %455, i32* %11
br label %456
456: ; preds = %512, %453
%457 = load i32, i32* %11
%458 = load i32, i32* %12
%459 = sub nsw i32 %458, 1
%460 = icmp sle i32 %457, %459
br i1 %460, label %461, label %515
461: ; preds = %456
%462 = load float**, float*** %6
%463 = load i32, i32* %13
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds float*, float** %462, i64 %464
%466 = load float*, float** %465
%467 = load i32, i32* %11
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds float, float* %466, i64 %468
%470 = load float, float* %469
store float %470, float* %22
%471 = load float**, float*** %6
%472 = load i32, i32* %11
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds float*, float** %471, i64 %473
%475 = load float*, float** %474
%476 = load i32, i32* %12
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds float, float* %475, i64 %477
%479 = load float, float* %478
store float %479, float* %21
%480 = load float, float* %22
%481 = load float, float* %20
%482 = load float, float* %21
%483 = load float, float* %22
%484 = load float, float* %17
%485 = call float @llvm.fmuladd.f32(float %483, float %484, float %482)
%486 = fneg float %481
%487 = call float @llvm.fmuladd.f32(float %486, float %485, float %480)
%488 = load float**, float*** %6
%489 = load i32, i32* %13
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds float*, float** %488, i64 %490
%492 = load float*, float** %491
%493 = load i32, i32* %11
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds float, float* %492, i64 %494
store float %487, float* %495
%496 = load float, float* %21
%497 = load float, float* %20
%498 = load float, float* %22
%499 = load float, float* %21
%500 = load float, float* %17
%501 = fneg float %499
%502 = call float @llvm.fmuladd.f32(float %501, float %500, float %498)
%503 = call float @llvm.fmuladd.f32(float %497, float %502, float %496)
%504 = load float**, float*** %6
%505 = load i32, i32* %11
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds float*, float** %504, i64 %506
%508 = load float*, float** %507
%509 = load i32, i32* %12
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds float, float* %508, i64 %510
store float %503, float* %511
br label %512
512: ; preds = %461
%513 = load i32, i32* %11
%514 = add nsw i32 %513, 1
store i32 %514, i32* %11
br label %456
515: ; preds = %456
%516 = load i32, i32* %12
%517 = add nsw i32 %516, 1
store i32 %517, i32* %11
br label %518
518: ; preds = %573, %515
%519 = load i32, i32* %11
%520 = load i32, i32* %7
%521 = icmp sle i32 %519, %520
br i1 %521, label %522, label %576
522: ; preds = %518
%523 = load float**, float*** %6
%524 = load i32, i32* %13
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds float*, float** %523, i64 %525
%527 = load float*, float** %526
%528 = load i32, i32* %11
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds float, float* %527, i64 %529
%531 = load float, float* %530
store float %531, float* %22
%532 = load float**, float*** %6
%533 = load i32, i32* %12
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds float*, float** %532, i64 %534
%536 = load float*, float** %535
%537 = load i32, i32* %11
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds float, float* %536, i64 %538
%540 = load float, float* %539
store float %540, float* %21
%541 = load float, float* %22
%542 = load float, float* %20
%543 = load float, float* %21
%544 = load float, float* %22
%545 = load float, float* %17
%546 = call float @llvm.fmuladd.f32(float %544, float %545, float %543)
%547 = fneg float %542
%548 = call float @llvm.fmuladd.f32(float %547, float %546, float %541)
%549 = load float**, float*** %6
%550 = load i32, i32* %13
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds float*, float** %549, i64 %551
%553 = load float*, float** %552
%554 = load i32, i32* %11
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds float, float* %553, i64 %555
store float %548, float* %556
%557 = load float, float* %21
%558 = load float, float* %20
%559 = load float, float* %22
%560 = load float, float* %21
%561 = load float, float* %17
%562 = fneg float %560
%563 = call float @llvm.fmuladd.f32(float %562, float %561, float %559)
%564 = call float @llvm.fmuladd.f32(float %558, float %563, float %557)
%565 = load float**, float*** %6
%566 = load i32, i32* %12
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds float*, float** %565, i64 %567
%569 = load float*, float** %568
%570 = load i32, i32* %11
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds float, float* %569, i64 %571
store float %564, float* %572
br label %573
573: ; preds = %522
%574 = load i32, i32* %11
%575 = add nsw i32 %574, 1
store i32 %575, i32* %11
br label %518
576: ; preds = %518
store i32 1, i32* %11
br label %577
577: ; preds = %632, %576
%578 = load i32, i32* %11
%579 = load i32, i32* %7
%580 = icmp sle i32 %578, %579
br i1 %580, label %581, label %635
581: ; preds = %577
%582 = load float**, float*** %9
%583 = load i32, i32* %11
%584 = sext i32 %583 to i64
%585 = getelementptr inbounds float*, float** %582, i64 %584
%586 = load float*, float** %585
%587 = load i32, i32* %13
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds float, float* %586, i64 %588
%590 = load float, float* %589
store float %590, float* %22
%591 = load float**, float*** %9
%592 = load i32, i32* %11
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds float*, float** %591, i64 %593
%595 = load float*, float** %594
%596 = load i32, i32* %12
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds float, float* %595, i64 %597
%599 = load float, float* %598
store float %599, float* %21
%600 = load float, float* %22
%601 = load float, float* %20
%602 = load float, float* %21
%603 = load float, float* %22
%604 = load float, float* %17
%605 = call float @llvm.fmuladd.f32(float %603, float %604, float %602)
%606 = fneg float %601
%607 = call float @llvm.fmuladd.f32(float %606, float %605, float %600)
%608 = load float**, float*** %9
%609 = load i32, i32* %11
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds float*, float** %608, i64 %610
%612 = load float*, float** %611
%613 = load i32, i32* %13
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds float, float* %612, i64 %614
store float %607, float* %615
%616 = load float, float* %21
%617 = load float, float* %20
%618 = load float, float* %22
%619 = load float, float* %21
%620 = load float, float* %17
%621 = fneg float %619
%622 = call float @llvm.fmuladd.f32(float %621, float %620, float %618)
%623 = call float @llvm.fmuladd.f32(float %617, float %622, float %616)
%624 = load float**, float*** %9
%625 = load i32, i32* %11
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds float*, float** %624, i64 %626
%628 = load float*, float** %627
%629 = load i32, i32* %12
%630 = sext i32 %629 to i64
%631 = getelementptr inbounds float, float* %628, i64 %630
store float %623, float* %631
br label %632
632: ; preds = %581
%633 = load i32, i32* %11
%634 = add nsw i32 %633, 1
store i32 %634, i32* %11
br label %577
635: ; preds = %577
%636 = load i32*, i32** %10
%637 = load i32, i32* %636
%638 = add nsw i32 %637, 1
store i32 %638, i32* %636
br label %639
639: ; preds = %635, %243
br label %640
640: ; preds = %639, %234
br label %641
641: ; preds = %640
%642 = load i32, i32* %12
%643 = add nsw i32 %642, 1
store i32 %643, i32* %12
br label %172
644: ; preds = %172
br label %645
645: ; preds = %644
%646 = load i32, i32* %13
%647 = add nsw i32 %646, 1
store i32 %647, i32* %13
br label %164
648: ; preds = %164
store i32 1, i32* %13
br label %649
649: ; preds = %678, %648
%650 = load i32, i32* %13
%651 = load i32, i32* %7
%652 = icmp sle i32 %650, %651
br i1 %652, label %653, label %681
653: ; preds = %649
%654 = load float*, float** %25
%655 = load i32, i32* %13
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds float, float* %654, i64 %656
%658 = load float, float* %657
%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 = fadd float %663, %658
store float %664, float* %662
%665 = load float*, float** %24
%666 = load i32, i32* %13
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds float, float* %665, i64 %667
%669 = load float, float* %668
%670 = load float*, float** %8
%671 = load i32, i32* %13
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds float, float* %670, i64 %672
store float %669, float* %673
%674 = load float*, float** %25
%675 = load i32, i32* %13
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds float, float* %674, i64 %676
store float 0.000000e+00, float* %677
br label %678
678: ; preds = %653
%679 = load i32, i32* %13
%680 = add nsw i32 %679, 1
store i32 %680, i32* %13
br label %649
681: ; preds = %649
br label %682
682: ; preds = %681
%683 = load i32, i32* %14
%684 = add nsw i32 %683, 1
store i32 %684, i32* %14
br label %99
685: ; preds = %99
%686 = 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 %687
687: ; preds = %685, %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 (...)* @vector 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 (...)* @vector 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, %519
%146 = phi i32 [ 1, %105 ], [ %520, %519 ]
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_vector to i32 (float*, i32, i32, ...)*)(float* %11, i32 1, i32 %1)
%206 = tail call i32 (float*, i32, i32, ...) bitcast (i32 (...)* @free_vector to i32 (float*, i32, i32, ...)*)(float* %8, i32 1, i32 %1)
br label %524
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 = %497
%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 %519, 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 %519, 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 %519, label %502
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, %497
%281 = phi i64 [ 0, %267 ], [ %501, %497 ]
%282 = phi float* [ %279, %267 ], [ %498, %497 ]
%283 = phi i64 [ %270, %267 ], [ %499, %497 ]
%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 %319
307: ; preds = %280
%308 = load float, float* %276
%309 = tail call float @llvm.fabs.f32(float %308)
%310 = fadd float %306, %309
%311 = fcmp oeq float %310, %309
br i1 %311, label %312, label %319
312: ; preds = %307
%313 = getelementptr inbounds float, float* %2, i64 %283
%314 = load float, float* %313
%315 = tail call float @llvm.fabs.f32(float %314)
%316 = fadd float %306, %315
%317 = fcmp oeq float %316, %315
br i1 %317, label %318, label %319
318: ; preds = %312
store float 0.000000e+00, float* %303
br label %497
319: ; preds = %312, %307, %280
%320 = fpext float %304 to double
%321 = tail call double @llvm.fabs.f64(double %320)
%322 = fcmp ogt double %321, %217
br i1 %322, label %323, label %497
323: ; preds = %319
%324 = getelementptr inbounds float, float* %2, i64 %283
%325 = load float, float* %324
%326 = load float, float* %276
%327 = fsub float %325, %326
%328 = fpext float %327 to double
%329 = tail call double @llvm.fabs.f64(double %328)
%330 = fpext float %306 to double
%331 = fadd double %329, %330
%332 = fptrunc double %331 to float
%333 = fptrunc double %329 to float
%334 = fcmp oeq float %332, %333
br i1 %334, label %335, label %337
335: ; preds = %323
%336 = fdiv float %304, %327
br label %353
337: ; preds = %323
%338 = fmul double %328, 5.000000e-01
%339 = fdiv double %338, %320
%340 = fptrunc double %339 to float
%341 = tail call float @llvm.fabs.f32(float %340)
%342 = fpext float %341 to double
%343 = fmul float %340, %340
%344 = fpext float %343 to double
%345 = fadd double %344, 1.000000e+00
%346 = tail call double @sqrt(double %345)
%347 = fadd double %346, %342
%348 = fdiv double 1.000000e+00, %347
%349 = fptrunc double %348 to float
%350 = fcmp olt float %340, 0.000000e+00
br i1 %350, label %351, label %353
351: ; preds = %337
%352 = fneg float %349
br label %353
353: ; preds = %337, %351, %335
%354 = phi float [ %336, %335 ], [ %352, %351 ], [ %349, %337 ]
%355 = tail call float @llvm.fmuladd.f32(float %354, float %354, float 1.000000e+00)
%356 = fpext float %355 to double
%357 = tail call double @sqrt(double %356)
%358 = fdiv double 1.000000e+00, %357
%359 = fptrunc double %358 to float
%360 = fmul float %354, %359
%361 = fpext float %360 to double
%362 = fpext float %359 to double
%363 = fadd double %362, 1.000000e+00
%364 = fdiv double %361, %363
%365 = fptrunc double %364 to float
%366 = load float*, float** %275
%367 = getelementptr inbounds float, float* %366, i64 %283
%368 = load float, float* %367
%369 = fmul float %354, %368
%370 = load float, float* %277
%371 = fsub float %370, %369
store float %371, float* %277
%372 = getelementptr inbounds float, float* %11, i64 %283
%373 = load float, float* %372
%374 = fadd float %369, %373
store float %374, float* %372
%375 = load float, float* %276
%376 = fsub float %375, %369
store float %376, float* %276
%377 = load float, float* %324
%378 = fadd float %369, %377
store float %378, float* %324
store float 0.000000e+00, float* %367
br i1 %278, label %379, label %381
379: ; preds = %353
%380 = fneg float %360
br label %385
381: ; preds = %385, %353
%382 = icmp ult i64 %274, %283
br i1 %382, label %383, label %400
383: ; preds = %381
%384 = fneg float %360
br label %447
385: ; preds = %379, %385
%386 = phi i64 [ 1, %379 ], [ %398, %385 ]
%387 = getelementptr inbounds float*, float** %0, i64 %386
%388 = load float*, float** %387
%389 = getelementptr inbounds float, float* %388, i64 %269
%390 = load float, float* %389
%391 = getelementptr inbounds float, float* %388, i64 %283
%392 = load float, float* %391
%393 = tail call float @llvm.fmuladd.f32(float %390, float %365, float %392)
%394 = tail call float @llvm.fmuladd.f32(float %380, float %393, float %390)
store float %394, float* %389
%395 = fneg float %392
%396 = tail call float @llvm.fmuladd.f32(float %395, float %365, float %390)
%397 = tail call float @llvm.fmuladd.f32(float %360, float %396, float %392)
store float %397, float* %391
%398 = add nuw nsw i64 %386, 1
%399 = icmp eq i64 %398, %269
br i1 %399, label %381, label %385
400: ; preds = %447, %381
%401 = icmp slt i64 %283, %110
br i1 %401, label %402, label %462
402: ; preds = %400
%403 = getelementptr inbounds float*, float** %0, i64 %283
%404 = load float*, float** %403
%405 = fneg float %360
%406 = icmp ult i32 %290, 3
br i1 %406, label %445, label %407
407: ; preds = %402
%408 = getelementptr float, float* %366, i64 %293
%409 = getelementptr float, float* %366, i64 %302
%410 = getelementptr float, float* %404, i64 %293
%411 = getelementptr float, float* %404, i64 %302
%412 = icmp ult float* %408, %411
%413 = icmp ult float* %410, %409
%414 = and i1 %412, %413
br i1 %414, label %445, label %415
415: ; preds = %407
%416 = and i64 %292, 8589934588
%417 = add nuw i64 %283, %416
%418 = insertelement <4 x float> poison, float %365, i64 0
%419 = shufflevector <4 x float> %418, <4 x float> poison, <4 x i32> zeroinitializer
%420 = insertelement <4 x float> poison, float %405, i64 0
%421 = shufflevector <4 x float> %420, <4 x float> poison, <4 x i32> zeroinitializer
%422 = insertelement <4 x float> poison, float %360, i64 0
%423 = shufflevector <4 x float> %422, <4 x float> poison, <4 x i32> zeroinitializer
br label %424
424: ; preds = %424, %415
%425 = phi i64 [ 0, %415 ], [ %441, %424 ]
%426 = add i64 %283, %425
%427 = add nuw nsw i64 %426, 1
%428 = getelementptr inbounds float, float* %366, i64 %427
%429 = bitcast float* %428 to <4 x float>*
%430 = load <4 x float>, <4 x float>* %429
%431 = getelementptr inbounds float, float* %404, i64 %427
%432 = bitcast float* %431 to <4 x float>*
%433 = load <4 x float>, <4 x float>* %432
%434 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %430, <4 x float> %419, <4 x float> %433)
%435 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %421, <4 x float> %434, <4 x float> %430)
%436 = bitcast float* %428 to <4 x float>*
store <4 x float> %435, <4 x float>* %436
%437 = fneg <4 x float> %433
%438 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %437, <4 x float> %419, <4 x float> %430)
%439 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %423, <4 x float> %438, <4 x float> %433)
%440 = bitcast float* %431 to <4 x float>*
store <4 x float> %439, <4 x float>* %440
%441 = add nuw i64 %425, 4
%442 = icmp eq i64 %441, %416
br i1 %442, label %443, label %424
443: ; preds = %424
%444 = icmp eq i64 %292, %416
br i1 %444, label %462, label %445
445: ; preds = %407, %402, %443
%446 = phi i64 [ %283, %407 ], [ %283, %402 ], [ %417, %443 ]
br label %465
447: ; preds = %383, %447
%448 = phi i64 [ %270, %383 ], [ %460, %447 ]
%449 = getelementptr inbounds float, float* %366, i64 %448
%450 = load float, float* %449
%451 = getelementptr inbounds float*, float** %0, i64 %448
%452 = load float*, float** %451
%453 = getelementptr inbounds float, float* %452, i64 %283
%454 = load float, float* %453
%455 = tail call float @llvm.fmuladd.f32(float %450, float %365, float %454)
%456 = tail call float @llvm.fmuladd.f32(float %384, float %455, float %450)
store float %456, float* %449
%457 = fneg float %454
%458 = tail call float @llvm.fmuladd.f32(float %457, float %365, float %450)
%459 = tail call float @llvm.fmuladd.f32(float %360, float %458, float %454)
store float %459, float* %453
%460 = add nuw nsw i64 %448, 1
%461 = icmp eq i64 %460, %283
br i1 %461, label %400, label %447
462: ; preds = %465, %443, %400
br i1 %12, label %494, label %463
463: ; preds = %462
%464 = fneg float %360
br label %479
465: ; preds = %445, %465
%466 = phi i64 [ %467, %465 ], [ %446, %445 ]
%467 = add nuw nsw i64 %466, 1
%468 = getelementptr inbounds float, float* %366, i64 %467
%469 = load float, float* %468
%470 = getelementptr inbounds float, float* %404, i64 %467
%471 = load float, float* %470
%472 = tail call float @llvm.fmuladd.f32(float %469, float %365, float %471)
%473 = tail call float @llvm.fmuladd.f32(float %405, float %472, float %469)
store float %473, float* %468
%474 = fneg float %471
%475 = tail call float @llvm.fmuladd.f32(float %474, float %365, float %469)
%476 = tail call float @llvm.fmuladd.f32(float %360, float %475, float %471)
store float %476, float* %470
%477 = trunc i64 %467 to i32
%478 = icmp slt i32 %477, %1
br i1 %478, label %465, label %462
479: ; preds = %463, %479
%480 = phi i64 [ 1, %463 ], [ %492, %479 ]
%481 = getelementptr inbounds float*, float** %3, i64 %480
%482 = load float*, float** %481
%483 = getelementptr inbounds float, float* %482, i64 %269
%484 = load float, float* %483
%485 = getelementptr inbounds float, float* %482, i64 %283
%486 = load float, float* %485
%487 = tail call float @llvm.fmuladd.f32(float %484, float %365, float %486)
%488 = tail call float @llvm.fmuladd.f32(float %464, float %487, float %484)
store float %488, float* %483
%489 = fneg float %486
%490 = tail call float @llvm.fmuladd.f32(float %489, float %365, float %484)
%491 = tail call float @llvm.fmuladd.f32(float %360, float %490, float %486)
store float %491, float* %485
%492 = add nuw nsw i64 %480, 1
%493 = icmp eq i64 %492, %113
br i1 %493, label %494, label %479
494: ; preds = %479, %462
%495 = load i32, i32* %4
%496 = add nsw i32 %495, 1
store i32 %496, i32* %4
br label %497
497: ; preds = %318, %494, %319
%498 = phi float* [ %282, %318 ], [ %366, %494 ], [ %282, %319 ]
%499 = add nuw nsw i64 %283, 1
%500 = icmp eq i64 %499, %113
%501 = add i64 %281, 1
br i1 %500, label %218, label %280
502: ; preds = %264, %502
%503 = phi i64 [ %517, %502 ], [ %265, %264 ]
%504 = getelementptr inbounds float, float* %11, i64 %503
%505 = load float, float* %504
%506 = getelementptr inbounds float, float* %8, i64 %503
%507 = load float, float* %506
%508 = fadd float %505, %507
store float %508, float* %506
%509 = getelementptr inbounds float, float* %2, i64 %503
store float %508, float* %509
store float 0.000000e+00, float* %504
%510 = add nuw nsw i64 %503, 1
%511 = getelementptr inbounds float, float* %11, i64 %510
%512 = load float, float* %511
%513 = getelementptr inbounds float, float* %8, i64 %510
%514 = load float, float* %513
%515 = fadd float %512, %514
store float %515, float* %513
%516 = getelementptr inbounds float, float* %2, i64 %510
store float %515, float* %516
store float 0.000000e+00, float* %511
%517 = add nuw nsw i64 %503, 2
%518 = icmp eq i64 %517, %114
br i1 %518, label %519, label %502
519: ; preds = %264, %502, %252, %222
%520 = add nuw nsw i32 %146, 1
%521 = icmp eq i32 %520, 51
br i1 %521, label %522, label %145
522: ; preds = %519
%523 = 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 %524
524: ; preds = %522, %204
ret void
}