#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 */
int /*<<< orphan*/ evsort(int, double *, double *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ eye(int, double *);
double fabs(double);
int /*<<< orphan*/ printf(char *);
double sqrt(int);
int /*<<< orphan*/ transpose(int, double *);
int /*<<< orphan*/ zero(int, double *);
int jacobi(double *a, int n, double d[], double *v, double *b, double *z) {
  int j, iq, ip, i, nrot = 0;
  double tresh, theta, tau, t, sm, s, h, g, c;
  eye(n, v);
  zero(n, z);
  for (ip = 0; ip < n; ip++) {
    b[ip] = d[ip] = a[ip + ip * n];
  }
  for (i = 1; i <= 50; i++) {
    sm = 0.0;
    for (ip = 0; ip < n - 1; ip++) {
      for (iq = ip + 1; iq < n; iq++)
        sm += fabs(a[iq + ip * n]);
    }
    if (sm == 0.0) {
      transpose(n, v);
      evsort(n, d, v);
      return nrot;
    }
    if (i < 4)
      tresh = 0.2 * sm / (n * n);
    else
      tresh = 0.0;
    for (ip = 0; ip < n - 1; ip++) {
      for (iq = ip + 1; iq < n; iq++) {
        g = 100.0 * fabs(a[iq + ip * n]);
        if (i > 4 && (fabs(d[ip]) + g) == fabs(d[ip]) &&
            (fabs(d[iq]) + g) == fabs(d[iq]))
          a[iq + ip * n] = 0.0;
        else if (fabs(a[iq + ip * n]) > tresh) {
          h = d[iq] - d[ip];
          if ((fabs(h) + g) == fabs(h))
            t = (a[iq + ip * n]) / h;
          else {
            theta = 0.5 * h / (a[iq + ip * n]);
            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[iq + ip * n];
          z[ip] -= h;
          z[iq] += h;
          d[ip] -= h;
          d[iq] += h;
          a[iq + ip * n] = 0.0;
          for (j = 0; j < ip; j++) {
            g = a[ip + j * n];
            h = a[iq + j * n];
            a[ip + j * n] = g - s * (h + g * tau);
            a[iq + j * n] = h + s * (g - h * tau);
          }
          for (j = ip + 1; j < iq; j++) {
            g = a[j + ip * n];
            h = a[iq + j * n];
            a[j + ip * n] = g - s * (h + g * tau);
            a[iq + j * n] = h + s * (g - h * tau);
          }
          for (j = iq + 1; j < n; j++) {
            g = a[j + ip * n];
            h = a[j + iq * n];
            a[j + ip * n] = g - s * (h + g * tau);
            a[j + iq * n] = h + s * (g - h * tau);
          }
          for (j = 0; j < n; j++) {
            g = v[ip + j * n];
            h = v[iq + j * n];
            v[ip + j * n] = g - s * (h + g * tau);
            v[iq + j * n] = h + s * (g - h * tau);
          }
          nrot++;
        }
      }
    }
    for (ip = 0; ip < n; ip++) {
      b[ip] += z[ip];
      d[ip] = b[ip];
      z[ip] = 0.0;
    }
  }
  printf("Too many iterations in routine jacobi");
  exit(1);
}


x86 assembly (clang, -O0):
<jacobi>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0xc(%rbp),%edi
mov    -0x20(%rbp),%rsi
call   1050 <eye@plt>
mov    -0xc(%rbp),%edi
mov    -0x30(%rbp),%rsi
call   1070 <zero@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1204 <jacobi+0x94>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11b8 <jacobi+0x48>
movl   $0x1,-0x40(%rbp)
cmpl   $0x32,-0x40(%rbp)
jg     1bac <jacobi+0xa3c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1298 <jacobi+0x128>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1285 <jacobi+0x115>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdb7(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    123e <jacobi+0xce>
jmp    128a <jacobi+0x11a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1224 <jacobi+0xb4>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12d8 <jacobi+0x168>
jp     12d8 <jacobi+0x168>
mov    -0xc(%rbp),%edi
mov    -0x20(%rbp),%rsi
call   1040 <transpose@plt>
mov    -0xc(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
call   1060 <evsort@plt>
mov    -0x44(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret
cmpl   $0x4,-0x40(%rbp)
jge    1308 <jacobi+0x198>
movsd  0xd16(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1310 <jacobi+0x1a0>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1b2f <jacobi+0x9bf>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b1c <jacobi+0x9ac>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xcc4(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xca0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x4,-0x40(%rbp)
jle    142e <jacobi+0x2be>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc8e(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xc6e(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    142e <jacobi+0x2be>
jp     142e <jacobi+0x2be>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc46(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xc26(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    142e <jacobi+0x2be>
jp     142e <jacobi+0x2be>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b09 <jacobi+0x999>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xbd3(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    1b04 <jacobi+0x994>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movaps 0xb99(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
movaps 0xb81(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    14da <jacobi+0x36a>
jp     14da <jacobi+0x36a>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1590 <jacobi+0x420>
movsd  0xb36(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movaps 0xb10(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xade(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1080 <sqrt@plt>
movsd  -0x98(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  0xabd(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    158b <jacobi+0x41b>
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1590 <jacobi+0x420>
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa6a(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1080 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xa52(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  0xa27(%rip),%xmm1
addsd  -0x90(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    17b2 <jacobi+0x642>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm3
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16a2 <jacobi+0x532>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    18cb <jacobi+0x75b>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm3
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17bb <jacobi+0x64b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19e4 <jacobi+0x874>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm3
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18d4 <jacobi+0x764>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1afb <jacobi+0x98b>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm3
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19eb <jacobi+0x87b>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1b09 <jacobi+0x999>
jmp    1b0e <jacobi+0x99e>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1331 <jacobi+0x1c1>
jmp    1b21 <jacobi+0x9b1>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1317 <jacobi+0x1a7>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b99 <jacobi+0xa29>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b36 <jacobi+0x9c6>
jmp    1b9e <jacobi+0xa2e>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    120b <jacobi+0x9b>
lea    0x47d(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>

x86 assembly (clang, -O2):
<jacobi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r9,%r15
mov    %r8,%r13
mov    %rdx,%r14
mov    %esi,%ebp
mov    %rdi,%r12
mov    %esi,%edi
mov    %rcx,0x80(%rsp)
mov    %rcx,%rsi
call   1050 <eye@plt>
mov    %ebp,%edi
mov    %r15,0x50(%rsp)
mov    %r15,%rsi
call   1070 <zero@plt>
mov    %r14,%r9
mov    %ebp,%r8d
test   %ebp,%ebp
mov    %r12,0x10(%rsp)
mov    %r8,0x20(%rsp)
mov    %rbp,%rbx
jle    1278 <jacobi+0x108>
xor    %ecx,%ecx
cmp    $0x1,%ebp
jne    11d6 <jacobi+0x66>
xor    %eax,%eax
jmp    124c <jacobi+0xdc>
and    $0xfffffffe,%r8d
lea    0x0(%rbp,%rbp,1),%r10d
mov    $0x1,%r14d
xor    %eax,%eax
mov    0x10(%rsp),%rsi
mov    0x10(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rbp
lea    (%r14,%rbp,1),%r11
movslq %ecx,%rcx
lea    (%rax,%rcx,1),%rdx
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
movsd  %xmm0,0x0(%r13,%rax,8)
mov    0x10(%rsp),%rdx
movsd  (%rdx,%r11,8),%xmm0
movsd  %xmm0,0x8(%r9,%rax,8)
movsd  %xmm0,0x8(%r13,%rax,8)
add    $0x2,%rax
add    %r10d,%ecx
add    $0x2,%r14
add    %r10d,%ebp
cmp    %rax,%r8
jne    1200 <jacobi+0x90>
mov    0x20(%rsp),%r8
test   $0x1,%r8b
mov    %rbx,%rbp
je     1278 <jacobi+0x108>
mov    %eax,%ecx
imul   %ebp,%ecx
movslq %ecx,%rcx
add    %rax,%rcx
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
movsd  %xmm0,0x0(%r13,%rax,8)
mov    %ebp,%eax
imul   %ebp,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x110(%rsp)
lea    0x0(,%r8,8),%rax
add    %r13,%rax
lea    (%r9,%r8,8),%r14
and    $0xfffffffc,%r8d
mov    %r8,0xe8(%rsp)
lea    -0x4(%r8),%rcx
mov    %rcx,0xe0(%rsp)
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
cmp    %r13,%r14
seta   %dl
mov    0x50(%rsp),%rdi
mov    0x20(%rsp),%rcx
lea    (%rdi,%rcx,8),%rbp
cmp    %r9,%rax
seta   %cl
and    %dl,%cl
cmp    %r13,%rbp
seta   %dl
cmp    %rdi,%rax
seta   %al
and    %dl,%al
or     %cl,%al
cmp    %r9,%rbp
seta   %dl
lea    -0x1(%rbx),%ebp
cmp    %rdi,%r14
seta   %cl
movslq %ebx,%r8
and    %dl,%cl
mov    0x20(%rsp),%r11
mov    %rbx,%r15
or     %al,%cl
mov    %cl,0xf(%rsp)
mov    %rsi,%rax
mov    %rsi,0xd8(%rsp)
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rax
mov    %rax,0xd0(%rsp)
mov    %r11,%rax
neg    %rax
mov    %rax,0xf0(%rsp)
lea    0x0(,%r8,8),%r14
lea    0x8(,%r8,8),%rbx
lea    (%r12,%r8,8),%rax
add    $0x8,%rax
mov    %rax,0x108(%rsp)
lea    0x8(%r12),%rax
mov    %rax,0x100(%rsp)
lea    (%r12,%r8,8),%rax
mov    %rax,0xf8(%rsp)
xor    %eax,%eax
mov    %rax,0x58(%rsp)
movl   $0x1,0x1c(%rsp)
movapd 0xc7b(%rip),%xmm4
movsd  0xc9b(%rip),%xmm5
mov    %r9,0x140(%rsp)
mov    %r15,0x88(%rsp)
mov    %r13,0x118(%rsp)
mov    %rbp,0x128(%rsp)
mov    %r8,0x40(%rsp)
mov    %rbx,0x120(%rsp)
jmp    13d4 <jacobi+0x264>
nopl   0x0(%rax)
mov    0x1c(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x1c(%rsp)
cmp    $0x33,%eax
je     1d75 <jacobi+0xc05>
cmp    $0x2,%r15d
jl     1d38 <jacobi+0xbc8>
xorpd  %xmm0,%xmm0
mov    0x10(%rsp),%rcx
xor    %edx,%edx
jmp    1401 <jacobi+0x291>
nopl   0x0(%rax,%rax,1)
add    %rbx,%rcx
add    $0xffffffffffffffff,%r11
cmp    %rbp,%rdx
mov    0x40(%rsp),%rsi
je     1430 <jacobi+0x2c0>
add    $0x1,%rdx
cmp    %rsi,%rdx
jge    13f0 <jacobi+0x280>
mov    $0x1,%esi
nop
movsd  (%rcx,%rsi,8),%xmm1
andpd  %xmm4,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%r11
jne    1410 <jacobi+0x2a0>
jmp    13f0 <jacobi+0x280>
nopl   0x0(%rax,%rax,1)
ucomisd 0xc08(%rip),%xmm0
mov    0x20(%rsp),%r11
jne    1445 <jacobi+0x2d5>
jnp    1d38 <jacobi+0xbc8>
xorpd  %xmm6,%xmm6
cmpl   $0x3,0x1c(%rsp)
ja     1465 <jacobi+0x2f5>
mulsd  0xbc8(%rip),%xmm0
divsd  0x110(%rsp),%xmm0
movapd %xmm0,%xmm6
cmp    $0x2,%r15d
jl     1b10 <jacobi+0x9a0>
mov    $0x1,%eax
mov    %rax,0x78(%rsp)
movl   $0x2,0x3c(%rsp)
mov    $0x8,%r15d
mov    0xf8(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    %rsi,0x68(%rsp)
mov    0x10(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    0x100(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    0x108(%rsp),%rax
mov    %rax,0x60(%rsp)
xor    %r13d,%r13d
xor    %r8d,%r8d
movsd  %xmm6,0x148(%rsp)
jmp    1530 <jacobi+0x3c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addq   $0x1,0x78(%rsp)
addl   $0x1,0x3c(%rsp)
mov    0x130(%rsp),%r15
add    $0x8,%r15
add    $0x8,%r13
mov    0x120(%rsp),%rbx
add    %rbx,0x60(%rsp)
add    %rbx,0x90(%rsp)
add    %r14,0x30(%rsp)
add    %rsi,0x68(%rsp)
add    %r14,0x70(%rsp)
mov    0x128(%rsp),%rbp
cmp    %rbp,%r8
je     1b10 <jacobi+0x9a0>
mov    %r8,%r10
add    $0x1,%r8
cmp    %rsi,%r8
mov    %r15,0x130(%rsp)
jge    14e0 <jacobi+0x370>
mov    %r10,%rdi
imul   %rsi,%rdi
lea    (%rdi,%rsi,1),%rbx
mov    %rbx,0x138(%rsp)
mov    0x70(%rsp),%rbx
mov    0x68(%rsp),%rbp
mov    %rbp,0xb0(%rsp)
mov    0x60(%rsp),%rbp
mov    %rbp,0xb8(%rsp)
xor    %ebp,%ebp
mov    0x78(%rsp),%rax
mov    0x3c(%rsp),%ecx
mov    %r8,0xa8(%rsp)
mov    %r10,0xa0(%rsp)
mov    %rdi,0x98(%rsp)
jmp    1613 <jacobi+0x4a3>
nopl   0x0(%rax,%rax,1)
mov    0x58(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x58(%rsp)
movapd 0xa4b(%rip),%xmm4
movsd  0xa6b(%rip),%xmm5
movsd  0x148(%rsp),%xmm6
mov    0xa8(%rsp),%r8
mov    0xa0(%rsp),%r10
mov    0x98(%rsp),%rdi
mov    0x2c(%rsp),%ecx
mov    0x48(%rsp),%rax
add    $0x1,%rax
add    $0x1,%ecx
add    $0x1,%rbp
add    $0x8,%r15
addq   $0x8,0xb8(%rsp)
add    %rsi,0xb0(%rsp)
add    %r14,%rbx
cmp    %r11,%rax
je     14e0 <jacobi+0x370>
mov    %ecx,0x2c(%rsp)
movslq %ecx,%r12
lea    0x1(%r12),%rcx
cmp    %rsi,%rcx
cmovle %rsi,%rcx
mov    %rax,%rdx
mov    %rax,0x48(%rsp)
lea    (%rax,%rdi,1),%rdx
mov    0x10(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm7
movapd %xmm7,%xmm1
andpd  %xmm4,%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm5,%xmm0
cmpl   $0x5,0x1c(%rsp)
jb     16b0 <jacobi+0x540>
movsd  (%r9,%r10,8),%xmm2
andpd  %xmm4,%xmm2
movapd %xmm0,%xmm3
addsd  %xmm2,%xmm3
ucomisd %xmm2,%xmm3
jne    16b0 <jacobi+0x540>
jp     16b0 <jacobi+0x540>
mov    %rdx,%rax
mov    0x48(%rsp),%rdx
movsd  (%r9,%rdx,8),%xmm2
mov    %rax,%rdx
andpd  %xmm4,%xmm2
movapd %xmm0,%xmm3
addsd  %xmm2,%xmm3
ucomisd %xmm2,%xmm3
jne    16b0 <jacobi+0x540>
jp     16b0 <jacobi+0x540>
mov    0x10(%rsp),%rax
movq   $0x0,(%rax,%rdx,8)
jmp    15de <jacobi+0x46e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
ucomisd %xmm6,%xmm1
jbe    15de <jacobi+0x46e>
mov    %rdx,0x158(%rsp)
mov    %rcx,0x150(%rsp)
mov    0x48(%rsp),%rax
movsd  (%r9,%rax,8),%xmm2
subsd  (%r9,%r10,8),%xmm2
movapd %xmm2,%xmm1
andpd  %xmm4,%xmm1
addsd  %xmm1,%xmm0
ucomisd %xmm1,%xmm0
jne    16f5 <jacobi+0x585>
jp     16f5 <jacobi+0x585>
divsd  %xmm2,%xmm7
jmp    1770 <jacobi+0x600>
mulsd  0x933(%rip),%xmm2
divsd  %xmm7,%xmm2
movapd %xmm2,0x160(%rsp)
movapd %xmm2,%xmm0
andpd  %xmm4,%xmm0
movapd %xmm0,0xc0(%rsp)
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
movsd  0x90d(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1080 <sqrt@plt>
addsd  0xc0(%rsp),%xmm0
movsd  0x8ef(%rip),%xmm7
divsd  %xmm0,%xmm7
xorpd  %xmm0,%xmm0
ucomisd 0x160(%rsp),%xmm0
jbe    1770 <jacobi+0x600>
xorpd  0x8ac(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm7,0xc0(%rsp)
movapd %xmm7,%xmm0
mulsd  %xmm7,%xmm0
movsd  0x8af(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1080 <sqrt@plt>
movsd  0x89a(%rip),%xmm1
movapd %xmm1,%xmm2
divsd  %xmm0,%xmm2
movapd 0xc0(%rsp),%xmm3
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
mov    0x10(%rsp),%rdx
mov    0x158(%rsp),%rsi
mulsd  (%rdx,%rsi,8),%xmm3
addsd  %xmm1,%xmm2
mov    0x50(%rsp),%rax
mov    0xa0(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
mov    0x48(%rsp),%rdi
movsd  (%rax,%rdi,8),%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rax,%rdi,8)
mov    0x140(%rsp),%r9
movsd  (%r9,%rcx,8),%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%r9,%rcx,8)
movapd %xmm0,%xmm1
addsd  (%r9,%rdi,8),%xmm3
divsd  %xmm2,%xmm1
movsd  %xmm3,(%r9,%rdi,8)
movq   $0x0,(%rdx,%rsi,8)
test   %rcx,%rcx
movapd 0x7d5(%rip),%xmm9
je     1899 <jacobi+0x729>
movapd %xmm0,%xmm2
xorpd  %xmm9,%xmm2
mov    %rcx,%rax
mov    %rdx,%rcx
nopl   0x0(%rax)
movsd  (%rcx,%r13,1),%xmm3
movsd  (%rcx,%r15,1),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rcx,%r13,1)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rcx,%r15,1)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
jne    1850 <jacobi+0x6e0>
cmp    %rdi,0xa8(%rsp)
mov    0x88(%rsp),%r10
mov    0x20(%rsp),%r11
mov    0x40(%rsp),%rsi
mov    0x90(%rsp),%rdx
jae    1916 <jacobi+0x7a6>
movapd %xmm0,%xmm2
xorpd  %xmm9,%xmm2
xor    %eax,%eax
mov    0xb8(%rsp),%rcx
movsd  (%rdx,%rax,8),%xmm3
movsd  (%rcx),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rdx,%rax,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rcx)
add    %r14,%rcx
add    $0x1,%rax
cmp    %rax,%rbp
jne    18d0 <jacobi+0x760>
lea    0x1(%rdi),%rax
cmp    %rsi,%rax
mov    %r10,%rdx
jge    1a99 <jacobi+0x929>
mov    0x150(%rsp),%rax
mov    %rax,%r8
sub    %r12,%r8
movapd %xmm0,%xmm2
xorpd  %xmm9,%xmm2
cmp    $0x2,%r8
jae    194d <jacobi+0x7dd>
mov    0x30(%rsp),%rax
jmp    1a50 <jacobi+0x8e0>
mov    %rbp,%rcx
imul   %rsi,%rcx
add    0x138(%rsp),%rcx
mov    0x98(%rsp),%rdx
lea    (%rdx,%r12,1),%r11
lea    (%rax,%rcx,1),%rsi
mov    0x10(%rsp),%rdi
lea    (%rdi,%r11,8),%r11
lea    (%rdi,%rsi,8),%rsi
cmp    %rsi,%r11
jae    19a8 <jacobi+0x838>
add    %rdx,%rax
add    %r12,%rcx
lea    (%rdi,%rax,8),%rdx
lea    (%rdi,%rcx,8),%rcx
cmp    %rdx,%rcx
jae    19a8 <jacobi+0x838>
mov    0x20(%rsp),%r11
mov    0x40(%rsp),%rsi
mov    0x30(%rsp),%rax
mov    %r10,%rdx
jmp    1a50 <jacobi+0x8e0>
mov    0xb0(%rsp),%rax
lea    (%rax,%r12,1),%rsi
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
mov    0x30(%rsp),%rax
lea    (%rax,%r12,8),%rdx
lea    (%rdi,%rsi,8),%rsi
add    %rcx,%r12
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm2,%xmm8
unpcklpd %xmm2,%xmm8
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd (%rdx,%rax,8),%xmm4
movupd (%rsi,%rax,8),%xmm7
movapd %xmm4,%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm7,%xmm6
mulpd  %xmm8,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm6,(%rdx,%rax,8)
movapd %xmm7,%xmm6
mulpd  %xmm3,%xmm6
subpd  %xmm6,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm4,(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    19f0 <jacobi+0x880>
cmp    %rcx,%r8
mov    0x20(%rsp),%r11
mov    0x40(%rsp),%rsi
mov    0x30(%rsp),%rax
mov    %r10,%rdx
je     1a99 <jacobi+0x929>
nopl   (%rax)
movsd  (%rax,%r12,8),%xmm3
movsd  (%rbx,%r12,8),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rax,%r12,8)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rbx,%r12,8)
add    $0x1,%r12
cmp    %rsi,%r12
jl     1a50 <jacobi+0x8e0>
test   %edx,%edx
jle    15a0 <jacobi+0x430>
movapd %xmm0,%xmm2
xorpd  %xmm9,%xmm2
mov    %r11,%rax
mov    0x80(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%r13,1),%xmm3
movsd  (%rcx,%r15,1),%xmm4
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rcx,%r13,1)
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm5,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rcx,%r15,1)
add    %r14,%rcx
add    $0xffffffffffffffff,%rax
jne    1ac0 <jacobi+0x950>
jmp    15a0 <jacobi+0x430>
xchg   %ax,%ax
mov    0x88(%rsp),%r15
test   %r15d,%r15d
mov    0x118(%rsp),%r13
mov    0x50(%rsp),%rdi
jle    13c0 <jacobi+0x250>
cmp    $0x4,%r15d
setb   %al
or     0xf(%rsp),%al
je     1b50 <jacobi+0x9e0>
xor    %ecx,%ecx
jmp    1c80 <jacobi+0xb10>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpq   $0x0,0xe0(%rsp)
je     1d23 <jacobi+0xbb3>
mov    0xd0(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movupd (%rdi,%rax,8),%xmm0
xorpd  %xmm3,%xmm3
movupd 0x10(%rdi,%rax,8),%xmm1
movupd 0x0(%r13,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r13,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm0,0x10(%r13,%rax,8)
movupd %xmm2,(%r9,%rax,8)
movupd %xmm0,0x10(%r9,%rax,8)
movupd %xmm3,(%rdi,%rax,8)
movupd %xmm3,0x10(%rdi,%rax,8)
movupd 0x20(%rdi,%rax,8),%xmm0
movupd 0x30(%rdi,%rax,8),%xmm1
movupd 0x20(%r13,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x30(%r13,%rax,8),%xmm0
addpd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
movupd %xmm2,0x20(%r13,%rax,8)
movupd %xmm0,0x30(%r13,%rax,8)
movupd %xmm2,0x20(%r9,%rax,8)
movupd %xmm0,0x30(%r9,%rax,8)
movupd %xmm1,0x20(%rdi,%rax,8)
movupd %xmm1,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1b70 <jacobi+0xa00>
testb  $0x1,0xd8(%rsp)
01
je     1c6c <jacobi+0xafc>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
movupd 0x0(%r13,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r13,%rax,8),%xmm0
addpd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm0,0x10(%r13,%rax,8)
movupd %xmm2,(%r9,%rax,8)
movupd %xmm0,0x10(%r9,%rax,8)
movupd %xmm1,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
mov    0xe8(%rsp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
je     13c0 <jacobi+0x250>
mov    %rcx,%rax
test   $0x1,%r11b
je     1cb1 <jacobi+0xb41>
movsd  (%rdi,%rcx,8),%xmm0
addsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
movsd  %xmm0,(%r9,%rcx,8)
movq   $0x0,(%rdi,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xf0(%rsp),%rcx
je     13c0 <jacobi+0x250>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm0
addsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  %xmm0,(%r9,%rax,8)
movq   $0x0,(%rdi,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
addsd  0x8(%r13,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  %xmm0,0x8(%r9,%rax,8)
movq   $0x0,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r11
jne    1cd0 <jacobi+0xb60>
jmp    13c0 <jacobi+0x250>
xor    %eax,%eax
testb  $0x1,0xd8(%rsp)
01
jne    1c21 <jacobi+0xab1>
jmp    1c6c <jacobi+0xafc>
mov    %r15d,%edi
mov    0x80(%rsp),%rbx
mov    %rbx,%rsi
mov    %r9,%r14
mov    %r15,%rbp
call   1040 <transpose@plt>
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1060 <evsort@plt>
mov    0x58(%rsp),%rax
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x2cc(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>

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

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