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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(float);
int /*<<< orphan*/ free_vector(float *, int, int);
int /*<<< orphan*/ printf(char *);
double sqrt(int);
float *vector(int, int);
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;
    }
  }
  free_vector(z, 1, n);
  free_vector(b, 1, n);
  printf("Error(jacobi): too many iterations\n");
}


x86 assembly (clang, -O0):
<jacobi>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%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
call   1060 <vector@plt>
mov    %rax,-0x68(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1060 <vector@plt>
mov    %rax,-0x70(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1207 <jacobi+0xb7>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11dc <jacobi+0x8c>
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    11aa <jacobi+0x5a>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  0xe2c(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1197 <jacobi+0x47>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1267 <jacobi+0x117>
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    120e <jacobi+0xbe>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x38(%rbp)
cmpl   $0x32,-0x38(%rbp)
jg     1bb7 <jacobi+0xa67>
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     130b <jacobi+0x1bb>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12f8 <jacobi+0x1a8>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movaps %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    12ab <jacobi+0x15b>
jmp    12fd <jacobi+0x1ad>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1291 <jacobi+0x141>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    134e <jacobi+0x1fe>
jp     134e <jacobi+0x1fe>
mov    -0x70(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
mov    -0x68(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
jmp    1be5 <jacobi+0xa95>
cmpl   $0x4,-0x38(%rbp)
jge    138a <jacobi+0x23a>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc97(%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    1392 <jacobi+0x242>
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     1b3a <jacobi+0x9ea>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b27 <jacobi+0x9d7>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0xc24(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x4,-0x38(%rbp)
jle    14c2 <jacobi+0x372>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14c2 <jacobi+0x372>
jp     14c2 <jacobi+0x372>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x78(%rbp),%xmm0
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14c2 <jacobi+0x372>
jp     14c2 <jacobi+0x372>
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    1b14 <jacobi+0x9c4>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b0f <jacobi+0x9bf>
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
call   1050 <fabs@plt>
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x54(%rbp),%xmm0
call   1050 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x7c(%rbp),%xmm0
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1577 <jacobi+0x427>
jp     1577 <jacobi+0x427>
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    163a <jacobi+0x4ea>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa90(%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
call   1050 <fabs@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa36(%rip),%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1070 <sqrt@plt>
movsd  -0x88(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  0xa15(%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    1635 <jacobi+0x4e5>
movss  -0x48(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    163a <jacobi+0x4ea>
movss  -0x48(%rbp),%xmm0
movss  -0x48(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0x9d0(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1070 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x9a8(%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  0x972(%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     183a <jacobi+0x6ea>
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    1751 <jacobi+0x601>
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     192c <jacobi+0x7dc>
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    1843 <jacobi+0x6f3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1a19 <jacobi+0x8c9>
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    1935 <jacobi+0x7e5>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b04 <jacobi+0x9b4>
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    1a20 <jacobi+0x8d0>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1b14 <jacobi+0x9c4>
jmp    1b19 <jacobi+0x9c9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13b3 <jacobi+0x263>
jmp    1b2c <jacobi+0x9dc>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1399 <jacobi+0x249>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1ba4 <jacobi+0xa54>
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    1b41 <jacobi+0x9f1>
jmp    1ba9 <jacobi+0xa59>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1278 <jacobi+0x128>
mov    -0x70(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
mov    -0x68(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
lea    0x444(%rip),%rdi
call   1030 <printf@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jacobi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %r8,0xa0(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rdx,%rbp
mov    %esi,%ebx
mov    %rdi,0x20(%rsp)
mov    $0x1,%edi
call   1070 <vector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %ebx,%esi
call   1070 <vector@plt>
mov    %rax,%rdi
mov    %ebx,%r13d
test   %ebx,%ebx
mov    %rbx,0x28(%rsp)
mov    %rbp,0x40(%rsp)
mov    %rax,0x68(%rsp)
mov    %r13,0x90(%rsp)
jle    1375 <jacobi+0x215>
lea    0x0(,%r13,4),%rax
mov    %rax,0x10(%rsp)
lea    -0x1(%r13),%rax
mov    %r13d,%r12d
and    $0x3,%r12d
mov    $0x1,%ebx
mov    %rax,0x30(%rsp)
cmp    $0x3,%rax
jb     1289 <jacobi+0x129>
and    $0xfffffffc,%r13d
xor    %ebx,%ebx
mov    0x70(%rsp),%r14
nopl   (%rax)
mov    0x8(%r14,%rbx,8),%rbp
lea    0x4(%rbp),%rdi
xor    %esi,%esi
mov    0x10(%rsp),%rdx
call   1050 <memset@plt>
movl   $0x3f800000,0x4(%rbp,%rbx,4)
3f
mov    0x10(%r14,%rbx,8),%rbp
lea    0x4(%rbp),%rdi
xor    %esi,%esi
mov    0x10(%rsp),%rdx
call   1050 <memset@plt>
movl   $0x3f800000,0x8(%rbp,%rbx,4)
3f
mov    0x18(%r14,%rbx,8),%rbp
lea    0x4(%rbp),%rdi
xor    %esi,%esi
mov    0x10(%rsp),%rdx
call   1050 <memset@plt>
movl   $0x3f800000,0xc(%rbp,%rbx,4)
3f
mov    0x20(%r14,%rbx,8),%rbp
lea    0x4(%rbp),%rdi
xor    %esi,%esi
mov    0x10(%rsp),%rdx
call   1050 <memset@plt>
movl   $0x3f800000,0x10(%rbp,%rbx,4)
3f
add    $0x4,%rbx
cmp    %rbx,%r13
jne    1200 <jacobi+0xa0>
add    $0x1,%rbx
mov    0x90(%rsp),%r13
test   %r12,%r12
mov    0x70(%rsp),%r14
je     12c6 <jacobi+0x166>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r14,%rbx,8),%rbp
lea    0x4(%rbp),%rdi
xor    %esi,%esi
mov    0x10(%rsp),%rdx
call   1050 <memset@plt>
movl   $0x3f800000,0x0(%rbp,%rbx,4)
3f
add    $0x1,%rbx
add    $0xffffffffffffffff,%r12
jne    12a0 <jacobi+0x140>
mov    0x28(%rsp),%rbx
test   %ebx,%ebx
mov    0x40(%rsp),%rbp
mov    0x68(%rsp),%rdi
jle    1375 <jacobi+0x215>
cmpq   $0x0,0x30(%rsp)
je     1e77 <jacobi+0xd17>
mov    %r13d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
mov    $0x1,%eax
mov    0x20(%rsp),%rsi
nopl   0x0(%rax)
mov    (%rsi,%rax,8),%rdx
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
movss  %xmm0,(%r15,%rax,4)
movl   $0x0,(%rdi,%rax,4)
mov    0x8(%rsi,%rax,8),%rdx
movss  0x4(%rdx,%rax,4),%xmm0
movss  %xmm0,0x4(%rbp,%rax,4)
movss  %xmm0,0x4(%r15,%rax,4)
movl   $0x0,0x4(%rdi,%rax,4)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    1300 <jacobi+0x1a0>
test   $0x1,%r13b
je     1375 <jacobi+0x215>
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
movss  %xmm0,(%r15,%rax,4)
movl   $0x0,(%rdi,%rax,4)
lea    0x1(%rbx),%esi
mov    %ebx,%eax
imul   %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xe0(%rsp)
mov    0xa0(%rsp),%rax
movl   $0x0,(%rax)
lea    (%r15,%rsi,4),%rax
mov    %r15,%rcx
add    $0x4,%rcx
lea    0x4(%rbp),%r9
lea    0x0(,%rsi,4),%r8
add    %rbp,%r8
mov    %rdi,%rbp
add    $0x4,%rbp
lea    -0x1(%r13),%rbx
mov    %rbx,%rdx
mov    %rbx,0xf0(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0xf8(%rsp)
cmp    %r8,%rcx
setb   %bl
cmp    %rax,%r9
setb   %dl
and    %bl,%dl
lea    (%rdi,%rsi,4),%rbx
cmp    %rbx,%rcx
setb   %cl
cmp    %rax,%rbp
movslq 0x28(%rsp),%rax
mov    %rax,0x110(%rsp)
setb   %al
and    %cl,%al
or     %dl,%al
lea    -0x1(%rsi),%rdx
cmp    %rbx,%r9
mov    0x28(%rsp),%rcx
setb   %r9b
cmp    %r8,%rbp
setb   %bl
and    %r9b,%bl
or     %al,%bl
mov    %bl,0xf(%rsp)
mov    %rdx,0x80(%rsp)
and    $0xfffffffffffffff8,%rdx
mov    %rdx,0xe8(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0xc8(%rsp)
mov    %rsi,%rax
neg    %rax
mov    %rax,0xd0(%rsp)
mov    0x20(%rsp),%rax
add    $0x10,%rax
mov    %rax,0xd8(%rsp)
mov    $0x1,%ebp
mov    %rsi,0x30(%rsp)
mov    %r15,0x88(%rsp)
jmp    148c <jacobi+0x32c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebp
cmp    $0x33,%ebp
je     1e3c <jacobi+0xcdc>
cmp    $0x2,%ecx
jl     1e0d <jacobi+0xcad>
mov    %ebp,0x3c(%rsp)
xorps  %xmm1,%xmm1
mov    $0x2,%r13d
mov    $0x1,%r14d
jne    14c0 <jacobi+0x360>
mov    0x20(%rsp),%r15
jmp    156b <jacobi+0x40b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %r12d,%r12d
mov    0x20(%rsp),%r15
nopl   0x0(%rax,%rax,1)
mov    %r14,%rbp
mov    %r13,%rbx
cs nopw 0x0(%rax,%rax,1)
movss  %xmm1,0x10(%rsp)
mov    (%r15,%rbp,8),%rax
movss  (%rax,%rbx,4),%xmm0
call   1060 <fabs@plt>
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
add    $0x1,%rbx
cmp    %rbx,0x30(%rsp)
jne    14e0 <jacobi+0x380>
mov    %r13,%rbx
or     $0x1,%rbx
lea    0x2(%rbp),%r14
nopl   0x0(%rax)
movss  %xmm1,0x10(%rsp)
mov    0x8(%r15,%rbp,8),%rax
movss  (%rax,%rbx,4),%xmm0
call   1060 <fabs@plt>
mov    0x30(%rsp),%rsi
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    1520 <jacobi+0x3c0>
add    $0x2,%r13
add    $0x2,%r12
cmp    0xf8(%rsp),%r12
jne    14d0 <jacobi+0x370>
testb  $0x1,0xf0(%rsp)
01
je     15b5 <jacobi+0x455>
cs nopw 0x0(%rax,%rax,1)
nop
movss  %xmm1,0x10(%rsp)
mov    (%r15,%r14,8),%rax
movss  (%rax,%r13,4),%xmm0
call   1060 <fabs@plt>
mov    0x30(%rsp),%rsi
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
add    $0x1,%r13
cmp    %r13,%rsi
jne    1580 <jacobi+0x420>
ucomiss 0xa78(%rip),%xmm1
mov    0x28(%rsp),%rcx
mov    0x88(%rsp),%r15
mov    0x3c(%rsp),%ebp
mov    0x68(%rsp),%rdi
jne    15da <jacobi+0x47a>
jnp    1e0d <jacobi+0xcad>
xorpd  %xmm0,%xmm0
cmp    $0x3,%ebp
ja     15ff <jacobi+0x49f>
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  0xa0e(%rip),%xmm0
divsd  0xe0(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
cmp    $0x2,%ecx
mov    0x20(%rsp),%r15
jl     1ce0 <jacobi+0xb80>
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x120(%rsp)
mov    $0x2,%r14d
mov    $0x1,%r12d
mov    $0xfffffffd,%eax
mov    $0x3,%edx
mov    0xd8(%rsp),%rdi
xor    %ebx,%ebx
jmp    168d <jacobi+0x52d>
nopl   0x0(%rax)
mov    0x98(%rsp),%r14
add    $0x1,%r14
mov    0xb0(%rsp),%rbx
add    $0x1,%rbx
mov    0xb8(%rsp),%rdi
add    $0x8,%rdi
mov    0x7c(%rsp),%eax
add    $0xffffffff,%eax
mov    0x100(%rsp),%rdx
add    $0x1,%rdx
mov    0xa8(%rsp),%r12
cmp    0x90(%rsp),%r12
je     1ce0 <jacobi+0xb80>
mov    %rdi,0xb8(%rsp)
lea    0x3(%rbx),%rsi
mov    %rbx,0xb0(%rsp)
lea    0x4(%rbx),%rdi
mov    %rdi,0x108(%rsp)
mov    %rsi,%rbx
lea    0x1(%r12),%rsi
mov    %rsi,0xa8(%rsp)
mov    %rdx,0x100(%rsp)
mov    %eax,0x7c(%rsp)
mov    %eax,0x4c(%rsp)
xor    %r13d,%r13d
mov    %r14,%rax
mov    %r14,0x98(%rsp)
mov    %rbx,0x118(%rsp)
jmp    1730 <jacobi+0x5d0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0xa0(%rsp),%rax
addl   $0x1,(%rax)
mov    0x3c(%rsp),%ebp
mov    0x118(%rsp),%rbx
add    $0x1,%r14
add    $0x1,%r13
mov    0x10(%rsp),%rdx
add    $0x1,%rdx
addl   $0xffffffff,0x4c(%rsp)
mov    0x30(%rsp),%rsi
cmp    %rsi,%r14
mov    0x28(%rsp),%rcx
je     1640 <jacobi+0x4e0>
cmp    %edx,%ecx
mov    %rdx,0x10(%rsp)
cmovg  %ecx,%edx
mov    %rdx,0x130(%rsp)
lea    (%rbx,%r13,1),%eax
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %rax,0x140(%rsp)
lea    (%rbx,%r13,1),%rdx
cmp    %edx,%ecx
mov    %rdx,0xc0(%rsp)
cmovg  %ecx,%edx
mov    %rdx,0x138(%rsp)
mov    (%r15,%r12,8),%rax
movss  (%rax,%r14,4),%xmm0
call   1060 <fabs@plt>
mulsd  0x885(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x50(%rsp)
cmp    $0x5,%ebp
jb     1840 <jacobi+0x6e0>
mov    0x40(%rsp),%r15
movss  (%r15,%r12,4),%xmm0
call   1060 <fabs@plt>
movss  0x50(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,0x128(%rsp)
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x18(%rsp)
movss  (%r15,%r12,4),%xmm0
mov    0x20(%rsp),%r15
call   1060 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  0x18(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    1840 <jacobi+0x6e0>
jp     1840 <jacobi+0x6e0>
mov    0x40(%rsp),%rbp
movss  0x0(%rbp,%r14,4),%xmm0
call   1060 <fabs@plt>
addsd  0x128(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x18(%rsp)
movss  0x0(%rbp,%r14,4),%xmm0
mov    0x3c(%rsp),%ebp
call   1060 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  0x18(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    1840 <jacobi+0x6e0>
jp     1840 <jacobi+0x6e0>
mov    (%r15,%r12,8),%rax
movl   $0x0,(%rax,%r14,4)
jmp    1707 <jacobi+0x5a7>
xchg   %ax,%ax
mov    (%r15,%r12,8),%rax
movss  (%rax,%r14,4),%xmm0
call   1060 <fabs@plt>
ucomisd 0x120(%rsp),%xmm0
jbe    1707 <jacobi+0x5a7>
mov    0x40(%rsp),%rax
movss  (%rax,%r14,4),%xmm0
subss  (%rax,%r12,4),%xmm0
movss  %xmm0,0x18(%rsp)
call   1060 <fabs@plt>
movss  0x50(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x50(%rsp)
movss  0x18(%rsp),%xmm0
call   1060 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  0x50(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    18c6 <jacobi+0x766>
jp     18c6 <jacobi+0x766>
mov    (%r15,%r12,8),%rax
movss  (%rax,%r14,4),%xmm1
divss  0x18(%rsp),%xmm1
jmp    1950 <jacobi+0x7f0>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0x738(%rip),%xmm0
mov    (%r15,%r12,8),%rax
movss  (%rax,%r14,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x50(%rsp)
call   1060 <fabs@plt>
movsd  %xmm0,0x18(%rsp)
movss  0x50(%rsp),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x703(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1080 <sqrt@plt>
addsd  0x18(%rsp),%xmm0
movsd  0x6e8(%rip),%xmm1
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
xorpd  %xmm0,%xmm0
ucomiss 0x50(%rsp),%xmm0
jbe    1950 <jacobi+0x7f0>
xorps  0x6d6(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movaps %xmm1,0x50(%rsp)
movaps %xmm1,%xmm0
mulss  %xmm1,%xmm0
addss  0x6cc(%rip),%xmm0
cvttss2si %xmm0,%edi
call   1080 <sqrt@plt>
movsd  0x6a3(%rip),%xmm3
movapd %xmm3,%xmm1
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movaps 0x50(%rsp),%xmm4
movaps %xmm4,%xmm0
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm2
cvtss2sd %xmm1,%xmm1
addsd  %xmm3,%xmm1
divsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
mov    (%r15,%r12,8),%rax
mulss  (%rax,%r14,4),%xmm4
mov    0x68(%rsp),%rcx
movss  (%rcx,%r12,4),%xmm2
subss  %xmm4,%xmm2
movss  %xmm2,(%rcx,%r12,4)
movss  (%rcx,%r14,4),%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,(%rcx,%r14,4)
mov    0x40(%rsp),%rcx
movss  (%rcx,%r12,4),%xmm2
subss  %xmm4,%xmm2
movss  %xmm2,(%rcx,%r12,4)
addss  (%rcx,%r14,4),%xmm4
movss  %xmm4,(%rcx,%r14,4)
movl   $0x0,(%rax,%r14,4)
cmp    $0x2,%r12
mov    0xb0(%rsp),%rbx
jb     1a6c <jacobi+0x90c>
movaps %xmm0,%xmm2
xorps  0x60c(%rip),%xmm2
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%r15,%rcx,8),%rdx
movss  (%rdx,%r12,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,%r12,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,%rbx
jne    1a20 <jacobi+0x8c0>
cmp    %r14,0xa8(%rsp)
mov    0x30(%rsp),%r9
mov    0x28(%rsp),%rbp
mov    0xb8(%rsp),%rdi
mov    0x140(%rsp),%r10
jae    1af9 <jacobi+0x999>
movaps %xmm0,%xmm2
xorps  0x586(%rip),%xmm2
mov    0x98(%rsp),%rcx
lea    (%rax,%rcx,4),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rdx,4),%xmm3
mov    (%rdi,%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,%r13
jne    1ab0 <jacobi+0x950>
cmp    0x110(%rsp),%r14
jge    1c69 <jacobi+0xb09>
mov    $0xfffffffd,%esi
sub    %ebx,%esi
sub    %r13d,%esi
add    %esi,%r10d
mov    (%r15,%r14,8),%rcx
movaps %xmm0,%xmm2
xorps  0x4fe(%rip),%xmm2
mov    %r14,%rdx
cmp    $0x3,%r10d
jb     1c20 <jacobi+0xac0>
mov    0x108(%rsp),%rdx
add    %r13,%rdx
mov    0x138(%rsp),%rdi
add    %esi,%edi
add    %rdx,%rdi
mov    0xc0(%rsp),%rdx
lea    (%rax,%rdx,4),%rdx
lea    (%rcx,%rdi,4),%rsi
cmp    %rsi,%rdx
jae    1b7b <jacobi+0xa1b>
mov    %rdi,%rbx
lea    (%rax,%rdi,4),%rsi
mov    0xc0(%rsp),%rdx
lea    (%rcx,%rdx,4),%rdi
mov    %r14,%rdx
cmp    %rsi,%rdi
jb     1c20 <jacobi+0xac0>
mov    0x130(%rsp),%rbx
add    0x4c(%rsp),%ebx
add    $0x1,%rbx
and    $0xfffffffffffffffc,%rbx
add    $0x1,%r10
mov    %r10,%r8
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
mov    0x10(%rsp),%rsi
lea    (%rcx,%rsi,4),%rdi
lea    (%rax,%rsi,4),%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rsi,%rbp,4),%xmm4
movups (%rdi,%rbp,4),%xmm7
movaps %xmm4,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm7,%xmm6
mulps  %xmm8,%xmm6
addps  %xmm4,%xmm6
movups %xmm6,(%rsi,%rbp,4)
movaps %xmm7,%xmm6
mulps  %xmm3,%xmm6
subps  %xmm6,%xmm4
mulps  %xmm5,%xmm4
addps  %xmm7,%xmm4
movups %xmm4,(%rdi,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%rbx
jne    1bd0 <jacobi+0xa70>
cmp    %r8,%r10
mov    0x28(%rsp),%rbp
je     1c69 <jacobi+0xb09>
cs nopw 0x0(%rax,%rax,1)
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    %ebp,%esi
jl     1c20 <jacobi+0xac0>
test   %ebp,%ebp
mov    0x70(%rsp),%rdx
jle    16f0 <jacobi+0x590>
movaps %xmm0,%xmm2
xorps  0x3a0(%rip),%xmm2
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdx,%rax,8),%rcx
movss  (%rcx,%r12,4),%xmm3
movss  (%rcx,%r14,4),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,(%rcx,%r12,4)
movaps %xmm4,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm5,%xmm3
mulss  %xmm0,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,(%rcx,%r14,4)
add    $0x1,%rax
cmp    %rax,%r9
jne    1c90 <jacobi+0xb30>
jmp    16f0 <jacobi+0x590>
test   %ecx,%ecx
mov    0x88(%rsp),%r15
mov    0x40(%rsp),%rdx
mov    0x68(%rsp),%rdi
mov    0xe8(%rsp),%rbx
xorpd  %xmm3,%xmm3
jle    1480 <jacobi+0x320>
cmpq   $0x8,0x80(%rsp)
setb   %al
or     0xf(%rsp),%al
mov    $0x1,%r8d
jne    1d7d <jacobi+0xc1d>
xor    %eax,%eax
movups 0x4(%rdi,%rax,4),%xmm0
movups 0x14(%rdi,%rax,4),%xmm1
movups 0x4(%r15,%rax,4),%xmm2
addps  %xmm0,%xmm2
movups 0x14(%r15,%rax,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x4(%r15,%rax,4)
movups %xmm0,0x14(%r15,%rax,4)
movups %xmm2,0x4(%rdx,%rax,4)
movups %xmm0,0x14(%rdx,%rax,4)
movupd %xmm3,0x4(%rdi,%rax,4)
movupd %xmm3,0x14(%rdi,%rax,4)
add    $0x8,%rax
cmp    %rax,%rbx
jne    1d20 <jacobi+0xbc0>
mov    0xc8(%rsp),%r8
cmp    %rbx,0x80(%rsp)
je     1480 <jacobi+0x320>
mov    %r8,%rax
test   $0x1,%sil
jne    1daa <jacobi+0xc4a>
movss  (%rdi,%r8,4),%xmm0
addss  (%r15,%r8,4),%xmm0
movss  %xmm0,(%r15,%r8,4)
movss  %xmm0,(%rdx,%r8,4)
movl   $0x0,(%rdi,%r8,4)
lea    0x1(%r8),%rax
not    %r8
cmp    0xd0(%rsp),%r8
je     1480 <jacobi+0x320>
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rax,4),%xmm0
addss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%r15,%rax,4)
movss  %xmm0,(%rdx,%rax,4)
movl   $0x0,(%rdi,%rax,4)
movss  0x4(%rdi,%rax,4),%xmm0
addss  0x4(%r15,%rax,4),%xmm0
movss  %xmm0,0x4(%r15,%rax,4)
movss  %xmm0,0x4(%rdx,%rax,4)
movl   $0x0,0x4(%rdi,%rax,4)
add    $0x2,%rax
cmp    %rax,%rsi
jne    1dc0 <jacobi+0xc60>
jmp    1480 <jacobi+0x320>
mov    $0x1,%esi
mov    %ecx,%edx
mov    %rcx,%rbx
call   1040 <free_vector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_vector@plt>
mov    $0x1,%esi
mov    %ecx,%edx
mov    %rcx,%rbx
call   1040 <free_vector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1040 <free_vector@plt>
lea    0x1d7(%rip),%rdi
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <puts@plt>
mov    $0x1,%eax
test   $0x1,%r13b
jne    1354 <jacobi+0x1f4>
jmp    1375 <jacobi+0x215>

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

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