#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 *dvector(int, long);
int /*<<< orphan*/ eigsrt(double *, double **, long);
double fabs(double);
int /*<<< orphan*/ free_dvector(double *, int, long);
int /*<<< orphan*/ identity_matrix(double **, long);
int /*<<< orphan*/ nrerror(char *);
int /*<<< orphan*/ rotate(double **, long, long, long, long, double *, double *,
                          double, double);
double sqrt(int);
void jacobi(double **a, long n, double *d, double **v) {
  long i, j, iq, ip;
  double tresh, theta, tau, t, sm, s, h, g, c, *b, *z;
  b = dvector(1, n);
  z = dvector(1, n);
  identity_matrix(v, n);
  for (ip = 1; ip <= n; ip++) {
    b[ip] = d[ip] = a[ip][ip];
    z[ip] = 0.0;
  }
  for (i = 1; i <= 100; 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 < 1.0e-7) {
      free_dvector(z, 1, n);
      free_dvector(b, 1, n);
      eigsrt(d, v, n);
      return;
    }
    if (i < 4)
      tresh = 0.2 * sm / (n * n);
    else
      tresh = 0.0;
    for (ip = 1; ip <= n - 1; ip++) {
      for (iq = ip + 1; iq <= n; iq++) {
        g = 100.0 * fabs(a[ip][iq]);
        if (i > 4 && (fabs(d[ip]) + g) == fabs(d[ip]) &&
            (fabs(d[iq]) + g) == fabs(d[iq]))
          a[ip][iq] = 0.0;
        else if (fabs(a[ip][iq]) > tresh) {
          h = d[iq] - d[ip];
          if ((fabs(h) + g) == fabs(h))
            t = a[ip][iq] / h;
          else {
            theta = 0.5 * h / a[ip][iq];
            t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta));
            if (theta < 0.0)
              t = -t;
          }
          c = 1.0 / sqrt(1 + t * t);
          s = t * c;
          tau = s / (1.0 + c);
          h = t * a[ip][iq];
          z[ip] -= h;
          z[iq] += h;
          d[ip] -= h;
          d[iq] += h;
          a[ip][iq] = 0.0;
          for (j = 1; j <= ip - 1; j++)
            rotate(a, j, ip, j, iq, &g, &h, s, tau);
          for (j = ip + 1; j <= iq - 1; j++)
            rotate(a, ip, j, j, iq, &g, &h, s, tau);
          for (j = iq + 1; j <= n; j++)
            rotate(a, ip, j, iq, j, &g, &h, s, tau);
          for (j = 1; j <= n; j++)
            rotate(v, j, ip, j, iq, &g, &h, s, tau);
        }
      }
    }
    for (ip = 1; ip <= n; ip++) {
      b[ip] += z[ip];
      d[ip] = b[ip];
      z[ip] = 0.0;
    }
  }
  nrerror("too many iterations");
}


x86 assembly (clang, -O0):
<jacobi>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x10(%rbp),%rsi
mov    $0x1,%edi
call   1060 <dvector@plt>
mov    %rax,-0x90(%rbp)
mov    -0x10(%rbp),%rsi
mov    $0x1,%edi
call   1060 <dvector@plt>
mov    %rax,-0x98(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1090 <identity_matrix@plt>
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jg     122e <jacobi+0xbe>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11ca <jacobi+0x5a>
movq   $0x1,-0x28(%rbp)
cmpq   $0x64,-0x28(%rbp)
jg     1911 <jacobi+0x7a1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     12d1 <jacobi+0x161>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
jg     12bb <jacobi+0x14b>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd94(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1272 <jacobi+0x102>
jmp    12c0 <jacobi+0x150>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1251 <jacobi+0xe1>
movsd  0xd27(%rip),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1324 <jacobi+0x1b4>
mov    -0x98(%rbp),%rdi
mov    -0x10(%rbp),%rdx
mov    $0x1,%esi
call   1070 <free_dvector@plt>
mov    -0x90(%rbp),%rdi
mov    -0x10(%rbp),%rdx
mov    $0x1,%esi
call   1070 <free_dvector@plt>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x10(%rbp),%rdx
call   1050 <eigsrt@plt>
jmp    191d <jacobi+0x7ad>
cmpq   $0x4,-0x28(%rbp)
jge    1358 <jacobi+0x1e8>
movsd  0xcd1(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
imul   -0x10(%rbp),%rax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1360 <jacobi+0x1f0>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     187f <jacobi+0x70f>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
jg     1869 <jacobi+0x6f9>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xc7d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xc51(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
cmpq   $0x4,-0x28(%rbp)
jle    147a <jacobi+0x30a>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc49(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xc2c(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    147a <jacobi+0x30a>
jp     147a <jacobi+0x30a>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc04(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xbe7(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    147a <jacobi+0x30a>
jp     147a <jacobi+0x30a>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1853 <jacobi+0x6e3>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xb9a(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    184e <jacobi+0x6de>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movaps 0xb60(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
movaps 0xb4b(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jne    151d <jacobi+0x3ad>
jp     151d <jacobi+0x3ad>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    15d0 <jacobi+0x460>
movsd  0xafb(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movaps 0xae0(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xaa6(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1080 <sqrt@plt>
movsd  -0xa0(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  0xa85(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    15cb <jacobi+0x45b>
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    15d0 <jacobi+0x460>
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa32(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1080 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xa1a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  0x9ef(%rip),%xmm1
addsd  -0x88(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm1
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x98(%rbp),%rax
mov    -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     1738 <jacobi+0x5c8>
mov    -0x8(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
movsd  -0x70(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
lea    -0x80(%rbp),%r9
lea    -0x78(%rbp),%rax
mov    %rax,(%rsp)
call   1040 <rotate@plt>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    16e3 <jacobi+0x573>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     1799 <jacobi+0x629>
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
movsd  -0x70(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
lea    -0x80(%rbp),%r9
lea    -0x78(%rbp),%rax
mov    %rax,(%rsp)
call   1040 <rotate@plt>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1744 <jacobi+0x5d4>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jg     17f3 <jacobi+0x683>
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%r8
movsd  -0x70(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
lea    -0x80(%rbp),%r9
lea    -0x78(%rbp),%rax
mov    %rax,(%rsp)
call   1040 <rotate@plt>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    17a5 <jacobi+0x635>
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jg     1849 <jacobi+0x6d9>
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
movsd  -0x70(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
lea    -0x80(%rbp),%r9
lea    -0x78(%rbp),%rax
mov    %rax,(%rsp)
call   1040 <rotate@plt>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    17fb <jacobi+0x68b>
jmp    184e <jacobi+0x6de>
jmp    1853 <jacobi+0x6e3>
jmp    1858 <jacobi+0x6e8>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1389 <jacobi+0x219>
jmp    186e <jacobi+0x6fe>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1368 <jacobi+0x1f8>
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jg     18fb <jacobi+0x78b>
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
mov    -0x40(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1887 <jacobi+0x717>
jmp    1900 <jacobi+0x790>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1236 <jacobi+0xc6>
lea    0x728(%rip),%rdi
call   1030 <nrerror@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jacobi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %rcx,%r14
mov    %rdx,%rbp
mov    %rsi,%r15
mov    %rdi,%rbx
mov    $0x1,%edi
call   1060 <dvector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    %r15,%rsi
call   1060 <dvector@plt>
mov    %rax,%r13
mov    %r14,0x78(%rsp)
mov    %r14,%rdi
mov    %r15,%rsi
call   1090 <identity_matrix@plt>
test   %r15,%r15
mov    %r15,0x10(%rsp)
jle    126a <jacobi+0xfa>
mov    $0x1,%eax
cmp    $0x1,%r15
je     1241 <jacobi+0xd1>
mov    0x10(%rsp),%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rbx,%rax,8),%rdx
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  %xmm0,(%r12,%rax,8)
movq   $0x0,0x0(%r13,%rax,8)
mov    0x8(%rbx,%rax,8),%rdx
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
movsd  %xmm0,0x8(%r12,%rax,8)
movq   $0x0,0x8(%r13,%rax,8)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    11f0 <jacobi+0x80>
mov    0x10(%rsp),%r15
test   $0x1,%r15b
je     126a <jacobi+0xfa>
mov    (%rbx,%rax,8),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  %xmm0,(%r12,%rax,8)
movq   $0x0,0x0(%r13,%rax,8)
mov    %r15,%rax
imul   %r15,%rax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  %xmm0,0xb8(%rsp)
lea    0x1(%r15),%r10
lea    (%r12,%r15,8),%rsi
add    $0x8,%rsi
mov    %r12,%rcx
add    $0x8,%rcx
lea    0x8(%rbp),%r9
lea    0x8(,%r15,8),%r8
add    %rbp,%r8
lea    0x8(,%r15,8),%rdi
add    %r13,%rdi
mov    %rbp,0x18(%rsp)
mov    %r13,%rbp
add    $0x8,%rbp
lea    -0x1(%r15),%rdx
mov    %rdx,%rax
mov    %rdx,0xe0(%rsp)
mov    %rdx,%r11
and    $0xfffffffffffffffe,%r11
cmp    %r8,%rcx
setb   %al
cmp    %rsi,%r9
setb   %dl
and    %al,%dl
cmp    %rdi,%rcx
setb   %cl
cmp    %rsi,%rbp
setb   %al
and    %cl,%al
or     %dl,%al
cmp    %rdi,%r9
setb   %cl
cmp    %r8,%rbp
setb   %dl
and    %cl,%dl
or     %al,%dl
mov    %dl,0xf(%rsp)
mov    %r15,%r8
and    $0xfffffffffffffffc,%r8
lea    0x1(%r8),%rax
mov    %rax,0xb0(%rsp)
neg    %r15
mov    $0x1,%eax
mov    %rax,0x38(%rsp)
movapd 0xcd5(%rip),%xmm3
mov    0x78(%rsp),%r9
mov    %r12,0xd8(%rsp)
mov    %r13,0x80(%rsp)
mov    %r10,0xd0(%rsp)
mov    %r11,0xc8(%rsp)
mov    %r8,0xc0(%rsp)
mov    %r15,0xf0(%rsp)
mov    %rbx,0x58(%rsp)
jmp    1388 <jacobi+0x218>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x38(%rsp)
cmp    $0x65,%rax
je     1a7d <jacobi+0x90d>
cmpq   $0x2,0x10(%rsp)
jl     1a43 <jacobi+0x8d3>
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
je     1414 <jacobi+0x2a4>
mov    $0x2,%ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
mov    (%rbx,%rax,8),%rsi
mov    %rax,%rdi
mov    0x10(%rsp),%rbp
nopl   0x0(%rax)
movsd  0x8(%rsi,%rdi,8),%xmm1
andpd  %xmm3,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rbp,%rdi
jl     13c0 <jacobi+0x250>
mov    0x8(%rbx,%rax,8),%rsi
add    $0x2,%rax
mov    %rcx,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x8(%rsi,%rdi,8),%xmm1
andpd  %xmm3,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rbp,%rdi
jl     13f0 <jacobi+0x280>
add    $0x2,%rdx
add    $0x2,%rcx
cmp    %r11,%rdx
jne    13b0 <jacobi+0x240>
testb  $0x1,0xe0(%rsp)
01
mov    0x10(%rsp),%rdx
je     1447 <jacobi+0x2d7>
mov    (%rbx,%rax,8),%rcx
nopw   0x0(%rax,%rax,1)
movsd  0x8(%rcx,%rax,8),%xmm1
add    $0x1,%rax
andpd  %xmm3,%xmm1
addsd  %xmm1,%xmm0
cmp    %rdx,%rax
jl     1430 <jacobi+0x2c0>
movsd  0xbd1(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     1a43 <jacobi+0x8d3>
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x90(%rsp)
cmpq   $0x3,0x38(%rsp)
ja     1488 <jacobi+0x318>
mulsd  0xbb2(%rip),%xmm0
divsd  0xb8(%rsp),%xmm0
movsd  %xmm0,0x90(%rsp)
cmpq   $0x2,0x10(%rsp)
jl     18e0 <jacobi+0x770>
mov    $0x1,%ecx
mov    $0x3,%eax
xor    %edx,%edx
jmp    14d8 <jacobi+0x368>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x30(%rsp),%rdx
add    $0xffffffffffffffff,%rdx
mov    0xe8(%rsp),%rax
add    $0x1,%rax
mov    0x88(%rsp),%rcx
cmp    0x10(%rsp),%rcx
je     18e0 <jacobi+0x770>
mov    %rdx,0x30(%rsp)
mov    %rcx,%rsi
lea    0x1(%rcx),%r15
mov    %rax,0xe8(%rsp)
mov    %rax,0xa0(%rsp)
xor    %eax,%eax
mov    %rax,0x98(%rsp)
mov    %r15,0x88(%rsp)
mov    %r15,%rax
mov    %rcx,0x20(%rsp)
jmp    1551 <jacobi+0x3e1>
movq   $0x0,(%rdx,%rax,8)
nopl   0x0(%rax,%rax,1)
lea    0x1(%rax),%rcx
addq   $0x1,0x98(%rsp)
addq   $0x1,0xa0(%rsp)
cmp    0x10(%rsp),%rax
mov    %rcx,%rax
movapd 0xaba(%rip),%xmm3
mov    0x58(%rsp),%rbx
jge    14b0 <jacobi+0x340>
mov    (%rbx,%rsi,8),%rdx
movsd  (%rdx,%rax,8),%xmm0
andpd  %xmm3,%xmm0
mulsd  0xaca(%rip),%xmm0
movsd  %xmm0,0xa8(%rsp)
cmpq   $0x5,0x38(%rsp)
jb     15c0 <jacobi+0x450>
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rsi,8),%xmm1
andpd  %xmm3,%xmm1
movapd %xmm0,%xmm2
addsd  %xmm1,%xmm2
ucomisd %xmm1,%xmm2
jne    15c0 <jacobi+0x450>
jp     15c0 <jacobi+0x450>
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
andpd  %xmm3,%xmm1
movapd %xmm0,%xmm2
addsd  %xmm1,%xmm2
ucomisd %xmm1,%xmm2
jne    15c0 <jacobi+0x450>
jnp    1510 <jacobi+0x3a0>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm1
andpd  %xmm3,%xmm1
ucomisd 0x90(%rsp),%xmm1
jbe    1520 <jacobi+0x3b0>
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm3
subsd  (%rcx,%rsi,8),%xmm3
movsd  %xmm3,0x28(%rsp)
movapd %xmm3,%xmm1
movapd 0xa07(%rip),%xmm2
andpd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
ucomisd %xmm1,%xmm0
mov    %rax,%r15
jne    1631 <jacobi+0x4c1>
jp     1631 <jacobi+0x4c1>
movsd  (%rdx,%rax,8),%xmm1
divsd  %xmm3,%xmm1
lea    0x28(%rsp),%rbp
mov    0x58(%rsp),%r13
lea    0xa8(%rsp),%r14
mov    0x30(%rsp),%r12
mov    %rax,%rbx
jmp    16af <jacobi+0x53f>
mulsd  0x9ff(%rip),%xmm3
divsd  (%rdx,%rax,8),%xmm3
movapd %xmm3,0x60(%rsp)
movapd %xmm3,%xmm0
andpd  %xmm2,%xmm0
movapd %xmm0,0x40(%rsp)
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
movsd  0x9de(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1080 <sqrt@plt>
addsd  0x40(%rsp),%xmm0
movsd  0x9c3(%rip),%xmm1
divsd  %xmm0,%xmm1
xorpd  %xmm0,%xmm0
ucomisd 0x60(%rsp),%xmm0
lea    0x28(%rsp),%rbp
mov    0x58(%rsp),%r13
lea    0xa8(%rsp),%r14
jbe    16a7 <jacobi+0x537>
xorpd  0x969(%rip),%xmm1
mov    0x30(%rsp),%r12
mov    %r15,%rbx
movapd %xmm1,0x40(%rsp)
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x97b(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1080 <sqrt@plt>
movsd  0x966(%rip),%xmm1
movapd %xmm1,%xmm4
divsd  %xmm0,%xmm4
movapd 0x40(%rsp),%xmm2
movapd %xmm2,%xmm0
mov    0x20(%rsp),%rsi
mov    0x0(%r13,%rsi,8),%rax
mulsd  (%rax,%rbx,8),%xmm2
mulsd  %xmm4,%xmm0
movsd  %xmm2,0x28(%rsp)
movapd %xmm2,%xmm3
mov    0x80(%rsp),%rcx
movsd  (%rcx,%rsi,8),%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rcx,%rsi,8)
movsd  0x28(%rsp),%xmm2
addsd  (%rcx,%rbx,8),%xmm2
addsd  %xmm1,%xmm4
movsd  %xmm2,(%rcx,%rbx,8)
movsd  0x28(%rsp),%xmm3
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rsi,8),%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rcx,%rsi,8)
movapd %xmm0,%xmm1
addsd  (%rcx,%rbx,8),%xmm3
divsd  %xmm4,%xmm1
movsd  %xmm3,(%rcx,%rbx,8)
movq   $0x0,(%rax,%rbx,8)
cmp    $0x2,%rsi
mov    %rbx,%rax
movsd  %xmm0,0x40(%rsp)
movsd  %xmm1,0x60(%rsp)
jb     17c3 <jacobi+0x653>
mov    $0x1,%ebx
mov    %rbp,(%rsp)
mov    %r13,%rdi
mov    %rbx,%rsi
mov    0x20(%rsp),%rdx
mov    %rbx,%rcx
mov    %r15,%r8
mov    %r14,%r9
call   1040 <rotate@plt>
movsd  0x60(%rsp),%xmm1
movsd  0x40(%rsp),%xmm0
mov    %r15,%rax
mov    0x20(%rsp),%rsi
lea    (%r12,%rbx,1),%rcx
add    $0x1,%rcx
add    $0x1,%rbx
cmp    $0x1,%rcx
jne    1780 <jacobi+0x610>
mov    0x98(%rsp),%rbx
mov    %r14,%r12
mov    0x88(%rsp),%rcx
mov    %rcx,%r14
cmp    %rax,%rcx
jae    1816 <jacobi+0x6a6>
xchg   %ax,%ax
mov    %rbp,(%rsp)
mov    %r13,%rdi
mov    %r14,%rdx
mov    %r14,%rcx
mov    %r15,%r8
mov    %r12,%r9
call   1040 <rotate@plt>
movsd  0x60(%rsp),%xmm1
movsd  0x40(%rsp),%xmm0
mov    %r15,%rax
mov    0x20(%rsp),%rsi
add    $0x1,%r14
add    $0xffffffffffffffff,%rbx
jne    17e0 <jacobi+0x670>
mov    0xa0(%rsp),%rbx
mov    0x10(%rsp),%r14
cmp    %r14,%rax
jge    1868 <jacobi+0x6f8>
nopl   0x0(%rax,%rax,1)
mov    %rbp,(%rsp)
mov    %r13,%rdi
mov    %rbx,%rdx
mov    %rax,%rcx
mov    %rbx,%r8
mov    %r12,%r9
call   1040 <rotate@plt>
movsd  0x60(%rsp),%xmm1
movsd  0x40(%rsp),%xmm0
mov    %r15,%rax
mov    0x20(%rsp),%rsi
lea    0x1(%rbx),%rcx
cmp    %r14,%rbx
mov    %rcx,%rbx
jl     1830 <jacobi+0x6c0>
test   %r14,%r14
mov    0x78(%rsp),%r9
mov    0xf0(%rsp),%r14
jle    1520 <jacobi+0x3b0>
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbp,(%rsp)
mov    %r9,%rdi
mov    %rbx,%rsi
mov    0x20(%rsp),%rdx
mov    %rbx,%rcx
mov    %r15,%r8
mov    %r9,%r13
mov    %r12,%r9
call   1040 <rotate@plt>
movsd  0x60(%rsp),%xmm1
movsd  0x40(%rsp),%xmm0
mov    %r15,%rax
mov    0x20(%rsp),%rsi
mov    %r13,%r9
lea    (%r14,%rbx,1),%rcx
add    $0x1,%rcx
add    $0x1,%rbx
cmp    $0x1,%rcx
jne    1890 <jacobi+0x720>
jmp    1520 <jacobi+0x3b0>
xchg   %ax,%ax
cmpq   $0x0,0x10(%rsp)
mov    0xd8(%rsp),%r12
mov    0x80(%rsp),%r13
mov    0xd0(%rsp),%r10
mov    0xc8(%rsp),%r11
mov    0xc0(%rsp),%r8
xorpd  %xmm4,%xmm4
mov    0x18(%rsp),%rdx
jle    1370 <jacobi+0x200>
cmpq   $0x4,0x10(%rsp)
setb   %al
or     0xf(%rsp),%al
mov    $0x1,%ecx
jne    19a8 <jacobi+0x838>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x8(%r13,%rax,8),%xmm0
movupd 0x18(%r13,%rax,8),%xmm1
movupd 0x8(%r12,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x18(%r12,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x8(%r12,%rax,8)
movupd %xmm0,0x18(%r12,%rax,8)
movupd %xmm2,0x8(%rdx,%rax,8)
movupd %xmm0,0x18(%rdx,%rax,8)
movupd %xmm4,0x8(%r13,%rax,8)
movupd %xmm4,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%r8
jne    1940 <jacobi+0x7d0>
mov    0xb0(%rsp),%rcx
cmp    0x10(%rsp),%r8
je     1370 <jacobi+0x200>
mov    %rcx,%rax
mov    0x10(%rsp),%rdx
test   $0x1,%dl
je     19df <jacobi+0x86f>
movsd  0x0(%r13,%rcx,8),%xmm0
addsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
mov    0x18(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,0x0(%r13,%rcx,8)
lea    0x1(%rcx),%rax
cmp    %rdx,%rcx
mov    0x18(%rsp),%rcx
je     1370 <jacobi+0x200>
nopl   (%rax)
movsd  0x0(%r13,%rax,8),%xmm0
addsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  %xmm0,(%rcx,%rax,8)
movq   $0x0,0x0(%r13,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm0
addsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
movsd  %xmm0,0x8(%rcx,%rax,8)
movq   $0x0,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    19f0 <jacobi+0x880>
jmp    1370 <jacobi+0x200>
mov    %r13,%rdi
mov    $0x1,%esi
mov    0x10(%rsp),%r15
mov    %r15,%rdx
mov    %r9,%rbx
call   1070 <free_dvector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    %r15,%rdx
call   1070 <free_dvector@plt>
mov    0x18(%rsp),%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1050 <eigsrt@plt>
jmp    1a89 <jacobi+0x919>
lea    0x5cc(%rip),%rdi
call   1030 <nrerror@plt>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [20 x i8] c"too many iterations\00"
define void @jacobi(double** %0, i64 %1, double* %2, double** %3) {
%5 = alloca double
%6 = alloca double
%7 = bitcast double* %5 to i8*
%8 = bitcast double* %6 to i8*
%9 = tail call double* @dvector(i32 1, i64 %1)
%10 = tail call double* @dvector(i32 1, i64 %1)
%11 = tail call i32 @identity_matrix(double** %3, i64 %1)
%12 = icmp slt i64 %1, 1
br i1 %12, label %29, label %13
13: ; preds = %4
%14 = and i64 %1, 1
%15 = icmp eq i64 %1, 1
br i1 %15, label %18, label %16
16: ; preds = %13
%17 = and i64 %1, -2
br label %62
18: ; preds = %62, %13
%19 = phi i64 [ 1, %13 ], [ %80, %62 ]
%20 = icmp eq i64 %14, 0
br i1 %20, label %29, label %21
21: ; preds = %18
%22 = getelementptr inbounds double*, double** %0, i64 %19
%23 = load double*, double** %22
%24 = getelementptr inbounds double, double* %23, i64 %19
%25 = load double, double* %24
%26 = getelementptr inbounds double, double* %2, i64 %19
store double %25, double* %26
%27 = getelementptr inbounds double, double* %9, i64 %19
store double %25, double* %27
%28 = getelementptr inbounds double, double* %10, i64 %19
store double 0.000000e+00, double* %28
br label %29
29: ; preds = %21, %18, %4
%30 = icmp sgt i64 %1, 1
%31 = mul nsw i64 %1, %1
%32 = sitofp i64 %31 to double
%33 = getelementptr double, double* %9, i64 1
%34 = add i64 %1, 1
%35 = getelementptr double, double* %9, i64 %34
%36 = getelementptr double, double* %2, i64 1
%37 = getelementptr double, double* %2, i64 %34
%38 = getelementptr double, double* %10, i64 1
%39 = getelementptr double, double* %10, i64 %34
%40 = add i64 %1, -1
%41 = and i64 %40, 1
%42 = icmp eq i64 %1, 2
%43 = and i64 %40, -2
%44 = icmp eq i64 %41, 0
%45 = icmp ult i64 %1, 4
%46 = icmp ult double* %33, %37
%47 = icmp ult double* %36, %35
%48 = and i1 %46, %47
%49 = icmp ult double* %33, %39
%50 = icmp ult double* %38, %35
%51 = and i1 %49, %50
%52 = or i1 %48, %51
%53 = icmp ult double* %36, %39
%54 = icmp ult double* %38, %37
%55 = and i1 %53, %54
%56 = or i1 %52, %55
%57 = and i64 %1, -4
%58 = or i64 %57, 1
%59 = icmp eq i64 %57, %1
%60 = and i64 %1, 1
%61 = icmp eq i64 %60, 0
br label %83
62: ; preds = %62, %16
%63 = phi i64 [ 1, %16 ], [ %80, %62 ]
%64 = phi i64 [ 0, %16 ], [ %81, %62 ]
%65 = getelementptr inbounds double*, double** %0, i64 %63
%66 = load double*, double** %65
%67 = getelementptr inbounds double, double* %66, i64 %63
%68 = load double, double* %67
%69 = getelementptr inbounds double, double* %2, i64 %63
store double %68, double* %69
%70 = getelementptr inbounds double, double* %9, i64 %63
store double %68, double* %70
%71 = getelementptr inbounds double, double* %10, i64 %63
store double 0.000000e+00, double* %71
%72 = add nuw i64 %63, 1
%73 = getelementptr inbounds double*, double** %0, i64 %72
%74 = load double*, double** %73
%75 = getelementptr inbounds double, double* %74, i64 %72
%76 = load double, double* %75
%77 = getelementptr inbounds double, double* %2, i64 %72
store double %76, double* %77
%78 = getelementptr inbounds double, double* %9, i64 %72
store double %76, double* %78
%79 = getelementptr inbounds double, double* %10, i64 %72
store double 0.000000e+00, double* %79
%80 = add nuw i64 %63, 2
%81 = add i64 %64, 2
%82 = icmp eq i64 %81, %17
br i1 %82, label %18, label %62
83: ; preds = %29, %319
%84 = phi i64 [ 1, %29 ], [ %320, %319 ]
br i1 %30, label %85, label %137
85: ; preds = %83
br i1 %42, label %118, label %102
86: ; preds = %109
%87 = add nuw nsw i64 %103, 2
%88 = getelementptr inbounds double*, double** %0, i64 %106
%89 = load double*, double** %88
br label %90
90: ; preds = %90, %86
%91 = phi i64 [ %87, %86 ], [ %97, %90 ]
%92 = phi double [ %115, %86 ], [ %96, %90 ]
%93 = getelementptr inbounds double, double* %89, i64 %91
%94 = load double, double* %93
%95 = call double @llvm.fabs.f64(double %94)
%96 = fadd double %92, %95
%97 = add nuw nsw i64 %91, 1
%98 = icmp slt i64 %91, %1
br i1 %98, label %90, label %99
99: ; preds = %90
%100 = add i64 %105, 2
%101 = icmp eq i64 %100, %43
br i1 %101, label %118, label %102
102: ; preds = %85, %99
%103 = phi i64 [ %87, %99 ], [ 1, %85 ]
%104 = phi double [ %96, %99 ], [ 0.000000e+00, %85 ]
%105 = phi i64 [ %100, %99 ], [ 0, %85 ]
%106 = add nuw nsw i64 %103, 1
%107 = getelementptr inbounds double*, double** %0, i64 %103
%108 = load double*, double** %107
br label %109
109: ; preds = %102, %109
%110 = phi i64 [ %106, %102 ], [ %116, %109 ]
%111 = phi double [ %104, %102 ], [ %115, %109 ]
%112 = getelementptr inbounds double, double* %108, i64 %110
%113 = load double, double* %112
%114 = call double @llvm.fabs.f64(double %113)
%115 = fadd double %111, %114
%116 = add nuw nsw i64 %110, 1
%117 = icmp slt i64 %110, %1
br i1 %117, label %109, label %86
118: ; preds = %99, %85
%119 = phi double [ undef, %85 ], [ %96, %99 ]
%120 = phi i64 [ 1, %85 ], [ %87, %99 ]
%121 = phi double [ 0.000000e+00, %85 ], [ %96, %99 ]
br i1 %44, label %134, label %122
122: ; preds = %118
%123 = getelementptr inbounds double*, double** %0, i64 %120
%124 = load double*, double** %123
br label %125
125: ; preds = %125, %122
%126 = phi i64 [ %120, %122 ], [ %128, %125 ]
%127 = phi double [ %121, %122 ], [ %132, %125 ]
%128 = add nuw nsw i64 %126, 1
%129 = getelementptr inbounds double, double* %124, i64 %128
%130 = load double, double* %129
%131 = call double @llvm.fabs.f64(double %130)
%132 = fadd double %127, %131
%133 = icmp slt i64 %128, %1
br i1 %133, label %125, label %134
134: ; preds = %125, %118
%135 = phi double [ %119, %118 ], [ %132, %125 ]
%136 = fcmp olt double %135, 0x3E7AD7F29ABCAF48
br i1 %136, label %137, label %141
137: ; preds = %83, %134
%138 = call i32 @free_dvector(double* %10, i32 1, i64 %1)
%139 = call i32 @free_dvector(double* %9, i32 1, i64 %1)
%140 = call i32 @eigsrt(double* %2, double** %3, i64 %1)
br label %324
141: ; preds = %134
%142 = icmp ult i64 %84, 4
br i1 %142, label %143, label %146
143: ; preds = %141
%144 = fmul double %135, 2.000000e-01
%145 = fdiv double %144, %32
br label %146
146: ; preds = %141, %143
%147 = phi double [ %145, %143 ], [ 0.000000e+00, %141 ]
br i1 %30, label %148, label %152
148: ; preds = %146
%149 = icmp ugt i64 %84, 4
br label %196
150: ; preds = %299
%151 = icmp eq i64 %198, %1
br i1 %151, label %152, label %196
152: ; preds = %150, %146
br i1 %12, label %319, label %153
153: ; preds = %152
%154 = select i1 %45, i1 true, i1 %56
br i1 %154, label %183, label %155
155: ; preds = %153, %155
%156 = phi i64 [ %180, %155 ], [ 0, %153 ]
%157 = or i64 %156, 1
%158 = getelementptr inbounds double, double* %10, i64 %157
%159 = bitcast double* %158 to <2 x double>*
%160 = load <2 x double>, <2 x double>* %159
%161 = getelementptr inbounds double, double* %158, i64 2
%162 = bitcast double* %161 to <2 x double>*
%163 = load <2 x double>, <2 x double>* %162
%164 = getelementptr inbounds double, double* %9, i64 %157
%165 = bitcast double* %164 to <2 x double>*
%166 = load <2 x double>, <2 x double>* %165
%167 = getelementptr inbounds double, double* %164, i64 2
%168 = bitcast double* %167 to <2 x double>*
%169 = load <2 x double>, <2 x double>* %168
%170 = fadd <2 x double> %160, %166
%171 = fadd <2 x double> %163, %169
%172 = bitcast double* %164 to <2 x double>*
store <2 x double> %170, <2 x double>* %172
%173 = bitcast double* %167 to <2 x double>*
store <2 x double> %171, <2 x double>* %173
%174 = getelementptr inbounds double, double* %2, i64 %157
%175 = bitcast double* %174 to <2 x double>*
store <2 x double> %170, <2 x double>* %175
%176 = getelementptr inbounds double, double* %174, i64 2
%177 = bitcast double* %176 to <2 x double>*
store <2 x double> %171, <2 x double>* %177
%178 = bitcast double* %158 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %178
%179 = bitcast double* %161 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %179
%180 = add nuw i64 %156, 4
%181 = icmp eq i64 %180, %57
br i1 %181, label %182, label %155
182: ; preds = %155
br i1 %59, label %319, label %183
183: ; preds = %153, %182
%184 = phi i64 [ 1, %153 ], [ %58, %182 ]
br i1 %61, label %193, label %185
185: ; preds = %183
%186 = getelementptr inbounds double, double* %10, i64 %184
%187 = load double, double* %186
%188 = getelementptr inbounds double, double* %9, i64 %184
%189 = load double, double* %188
%190 = fadd double %187, %189
store double %190, double* %188
%191 = getelementptr inbounds double, double* %2, i64 %184
store double %190, double* %191
store double 0.000000e+00, double* %186
%192 = add nuw i64 %184, 1
br label %193
193: ; preds = %185, %183
%194 = phi i64 [ %184, %183 ], [ %192, %185 ]
%195 = icmp eq i64 %184, %1
br i1 %195, label %319, label %302
196: ; preds = %150, %148
%197 = phi i64 [ 1, %148 ], [ %198, %150 ]
%198 = add nuw nsw i64 %197, 1
%199 = getelementptr inbounds double*, double** %0, i64 %197
%200 = getelementptr inbounds double, double* %2, i64 %197
%201 = getelementptr inbounds double, double* %10, i64 %197
%202 = icmp ugt i64 %197, 1
br label %203
203: ; preds = %196, %299
%204 = phi i64 [ %198, %196 ], [ %300, %299 ]
%205 = load double*, double** %199
%206 = getelementptr inbounds double, double* %205, i64 %204
%207 = load double, double* %206
%208 = call double @llvm.fabs.f64(double %207)
%209 = fmul double %208, 1.000000e+02
store double %209, double* %6
br i1 %149, label %210, label %222
210: ; preds = %203
%211 = load double, double* %200
%212 = call double @llvm.fabs.f64(double %211)
%213 = fadd double %209, %212
%214 = fcmp oeq double %213, %212
br i1 %214, label %215, label %222
215: ; preds = %210
%216 = getelementptr inbounds double, double* %2, i64 %204
%217 = load double, double* %216
%218 = call double @llvm.fabs.f64(double %217)
%219 = fadd double %209, %218
%220 = fcmp oeq double %219, %218
br i1 %220, label %221, label %222
221: ; preds = %215
store double 0.000000e+00, double* %206
br label %299
222: ; preds = %215, %210, %203
%223 = load double, double* %206
%224 = call double @llvm.fabs.f64(double %223)
%225 = fcmp ogt double %224, %147
br i1 %225, label %226, label %299
226: ; preds = %222
%227 = getelementptr inbounds double, double* %2, i64 %204
%228 = load double, double* %227
%229 = load double, double* %200
%230 = fsub double %228, %229
store double %230, double* %5
%231 = call double @llvm.fabs.f64(double %230)
%232 = fadd double %209, %231
%233 = fcmp oeq double %232, %231
br i1 %233, label %234, label %237
234: ; preds = %226
%235 = load double, double* %206
%236 = fdiv double %235, %230
br label %250
237: ; preds = %226
%238 = fmul double %230, 5.000000e-01
%239 = load double, double* %206
%240 = fdiv double %238, %239
%241 = call double @llvm.fabs.f64(double %240)
%242 = call double @llvm.fmuladd.f64(double %240, double %240, double 1.000000e+00)
%243 = fptosi double %242 to i32
%244 = call double @sqrt(i32 %243)
%245 = fadd double %244, %241
%246 = fdiv double 1.000000e+00, %245
%247 = fcmp olt double %240, 0.000000e+00
br i1 %247, label %248, label %250
248: ; preds = %237
%249 = fneg double %246
br label %250
250: ; preds = %237, %248, %234
%251 = phi double [ %236, %234 ], [ %249, %248 ], [ %246, %237 ]
%252 = call double @llvm.fmuladd.f64(double %251, double %251, double 1.000000e+00)
%253 = fptosi double %252 to i32
%254 = call double @sqrt(i32 %253)
%255 = fdiv double 1.000000e+00, %254
%256 = fmul double %251, %255
%257 = fadd double %255, 1.000000e+00
%258 = fdiv double %256, %257
%259 = load double*, double** %199
%260 = getelementptr inbounds double, double* %259, i64 %204
%261 = load double, double* %260
%262 = fmul double %251, %261
store double %262, double* %5
%263 = load double, double* %201
%264 = fsub double %263, %262
store double %264, double* %201
%265 = load double, double* %5
%266 = getelementptr inbounds double, double* %10, i64 %204
%267 = load double, double* %266
%268 = fadd double %265, %267
store double %268, double* %266
%269 = load double, double* %5
%270 = load double, double* %200
%271 = fsub double %270, %269
store double %271, double* %200
%272 = load double, double* %227
%273 = fadd double %269, %272
store double %273, double* %227
store double 0.000000e+00, double* %260
br i1 %202, label %276, label %274
274: ; preds = %276, %250
%275 = icmp ult i64 %198, %204
br i1 %275, label %283, label %281
276: ; preds = %250, %276
%277 = phi i64 [ %279, %276 ], [ 1, %250 ]
%278 = call i32 @rotate(double** %0, i64 %277, i64 %197, i64 %277, i64 %204, double* %6, double* %5, double %256, double %258)
%279 = add nuw nsw i64 %277, 1
%280 = icmp eq i64 %279, %197
br i1 %280, label %274, label %276
281: ; preds = %283, %274
%282 = icmp slt i64 %204, %1
br i1 %282, label %289, label %288
283: ; preds = %274, %283
%284 = phi i64 [ %286, %283 ], [ %198, %274 ]
%285 = call i32 @rotate(double** %0, i64 %197, i64 %284, i64 %284, i64 %204, double* %6, double* %5, double %256, double %258)
%286 = add nuw i64 %284, 1
%287 = icmp eq i64 %286, %204
br i1 %287, label %281, label %283
288: ; preds = %289, %281
br i1 %12, label %299, label %294
289: ; preds = %281, %289
%290 = phi i64 [ %291, %289 ], [ %204, %281 ]
%291 = add nuw nsw i64 %290, 1
%292 = call i32 @rotate(double** %0, i64 %197, i64 %291, i64 %204, i64 %291, double* %6, double* %5, double %256, double %258)
%293 = icmp slt i64 %291, %1
br i1 %293, label %289, label %288
294: ; preds = %288, %294
%295 = phi i64 [ %297, %294 ], [ 1, %288 ]
%296 = call i32 @rotate(double** %3, i64 %295, i64 %197, i64 %295, i64 %204, double* %6, double* %5, double %256, double %258)
%297 = add nuw i64 %295, 1
%298 = icmp eq i64 %295, %1
br i1 %298, label %299, label %294
299: ; preds = %294, %288, %221, %222
%300 = add nuw nsw i64 %204, 1
%301 = icmp slt i64 %204, %1
br i1 %301, label %203, label %150
302: ; preds = %193, %302
%303 = phi i64 [ %317, %302 ], [ %194, %193 ]
%304 = getelementptr inbounds double, double* %10, i64 %303
%305 = load double, double* %304
%306 = getelementptr inbounds double, double* %9, i64 %303
%307 = load double, double* %306
%308 = fadd double %305, %307
store double %308, double* %306
%309 = getelementptr inbounds double, double* %2, i64 %303
store double %308, double* %309
store double 0.000000e+00, double* %304
%310 = add nuw i64 %303, 1
%311 = getelementptr inbounds double, double* %10, i64 %310
%312 = load double, double* %311
%313 = getelementptr inbounds double, double* %9, i64 %310
%314 = load double, double* %313
%315 = fadd double %312, %314
store double %315, double* %313
%316 = getelementptr inbounds double, double* %2, i64 %310
store double %315, double* %316
store double 0.000000e+00, double* %311
%317 = add nuw i64 %303, 2
%318 = icmp eq i64 %310, %1
br i1 %318, label %319, label %302
319: ; preds = %193, %302, %182, %152
%320 = add nuw nsw i64 %84, 1
%321 = icmp eq i64 %320, 101
br i1 %321, label %322, label %83
322: ; preds = %319
%323 = call i32 @nrerror(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i64 0, i64 0))
br label %324
324: ; preds = %322, %137
ret void
}