#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*/ EXIT_FAILURE;
int /*<<< orphan*/ exit(int /*<<< orphan*/);
double fabs(float);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int, int);
int /*<<< orphan*/ rotate(float **, int, int, int, int, float *, float *, float,
                          float);
double sqrt(double);
int /*<<< orphan*/ stderr;
void jacobi(float aa[2][2], int n, float d[2], float v[2][2], int *nrot) {
  int j, iq, ip, i;
  float thresh, theta, tau, t, sm, s, h, g, c;
  float b[2], z[2], a[2][2];
  if (n != 2) {
    fprintf(stderr, "\nFatal error: n %d not N %d in jacobi\n", n, 2);
    exit(EXIT_FAILURE);
  }
  for (ip = 0; ip < n; ip++) {
    for (iq = 0; iq < n; iq++)
      v[ip][iq] = 0.0;
    for (iq = 0; iq < n; iq++)
      a[ip][iq] = aa[ip][iq];
    v[ip][ip] = 1.0;
  }
  for (ip = 0; ip < n; ip++) {
    b[ip] = d[ip] = a[ip][ip];
    z[ip] = 0.0;
  }
  *nrot = 0;
  for (i = 0; i < 100; i++) {
    sm = 0.0;
    for (ip = 0; ip < (n - 1); ip++) {
      for (iq = ip + 1; iq < n; iq++)
        sm += (float)fabs(a[ip][iq]);
    }
    if (sm == 0.0)
      return;
    if (i < 3)
      thresh = (float)(0.2 * sm / (n * n));
    else
      thresh = 0.0;
    for (ip = 0; ip < (n - 1); ip++) {
      for (iq = ip + 1; iq < n; iq++) {
        g = (float)(100.0 * fabs(a[ip][iq]));
        if (i > 3 && 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]) > thresh) {
          h = d[iq] - d[ip];
          if (fabs(h) + g == fabs(h))
            t = (a[ip][iq]) / h;
          else {
            theta = 0.5f * h / (a[ip][iq]);
            t = (float)(1.0 / (fabs(theta) + sqrt(1.0 + theta * theta)));
            if (theta < 0.0)
              t = -t;
          }
          c = (float)(1.0 / sqrt(1.0 + t * t));
          s = t * c;
          tau = s / (1.0f + 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 = 0; j < ip - 1; j++)
            rotate(a, j, ip, j, iq, &h, &g, s, tau);
          for (j = ip + 1; j < iq - 1; j++)
            rotate(a, ip, j, j, iq, &h, &g, s, tau);
          for (j = iq + 1; j < n; j++)
            rotate(a, ip, j, iq, j, &h, &g, s, tau);
          for (j = 0; j < n; j++)
            rotate(v, j, ip, j, iq, &h, &g, s, tau);
          ++(*nrot);
        }
      }
    }
    for (ip = 0; ip < n; ip++) {
      b[ip] += z[ip];
      d[ip] = b[ip];
      z[ip] = 0.0;
    }
  }
}


x86 assembly (clang, -O0):
<jacobi>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
cmpl   $0x2,-0xc(%rbp)
je     11a3 <jacobi+0x53>
mov    0x2e61(%rip),%rax
mov    (%rax),%edi
mov    -0xc(%rbp),%edx
lea    0xe95(%rip),%rsi
mov    $0x2,%ecx
call   1040 <fprintf@plt>
mov    0x2e3c(%rip),%rax
mov    (%rax),%edi
call   1070 <exit@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1271 <jacobi+0x121>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11f2 <jacobi+0xa2>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11bd <jacobi+0x6d>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1243 <jacobi+0xf3>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11f9 <jacobi+0xa9>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movss  0xdbe(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11aa <jacobi+0x5a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ce <jacobi+0x17e>
movslq -0x34(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
movss  %xmm0,-0x64(%rbp,%rax,4)
movslq -0x34(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp,%rax,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1278 <jacobi+0x128>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x38(%rbp)
cmpl   $0x64,-0x38(%rbp)
jge    1953 <jacobi+0x803>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    136a <jacobi+0x21a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1357 <jacobi+0x207>
movslq -0x34(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1312 <jacobi+0x1c2>
jmp    135c <jacobi+0x20c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12f8 <jacobi+0x1a8>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    138b <jacobi+0x23b>
jp     138b <jacobi+0x23b>
jmp    1953 <jacobi+0x803>
cmpl   $0x3,-0x38(%rbp)
jge    13c7 <jacobi+0x277>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc5a(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    13cf <jacobi+0x27f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    18e1 <jacobi+0x791>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18ce <jacobi+0x77e>
movslq -0x34(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0xbe4(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x3,-0x38(%rbp)
jle    1503 <jacobi+0x3b3>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jne    1503 <jacobi+0x3b3>
jp     1503 <jacobi+0x3b3>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jne    1503 <jacobi+0x3b3>
jp     1503 <jacobi+0x3b3>
movslq -0x34(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    18bb <jacobi+0x76b>
movslq -0x34(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    18b6 <jacobi+0x766>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
call   1030 <fabs@plt>
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movss  -0x54(%rbp),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jne    15bd <jacobi+0x46d>
jp     15bd <jacobi+0x46d>
movslq -0x34(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    166b <jacobi+0x51b>
movss  0xa53(%rip),%xmm0
mulss  -0x54(%rbp),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
call   1030 <fabs@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa01(%rip),%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  -0xa0(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  0x9e4(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1666 <jacobi+0x516>
movss  -0x48(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    166b <jacobi+0x51b>
movss  -0x48(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x98f(%rip),%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x97b(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
movss  0x95e(%rip),%xmm1
addss  -0x5c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x48(%rbp),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm1
movslq -0x34(%rbp),%rax
movss  -0x6c(%rbp,%rax,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp,%rax,4)
movss  -0x54(%rbp),%xmm0
movslq -0x30(%rbp),%rax
addss  -0x6c(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x6c(%rbp,%rax,4)
movss  -0x54(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    17bb <jacobi+0x66b>
lea    -0x80(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edx
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%r8d
movss  -0x50(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
lea    -0x54(%rbp),%r9
lea    -0x58(%rbp),%rax
mov    %rax,(%rsp)
call   1050 <rotate@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1770 <jacobi+0x620>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    180f <jacobi+0x6bf>
lea    -0x80(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x2c(%rbp),%edx
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%r8d
movss  -0x50(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
lea    -0x54(%rbp),%r9
lea    -0x58(%rbp),%rax
mov    %rax,(%rsp)
call   1050 <rotate@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17c4 <jacobi+0x674>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    185e <jacobi+0x70e>
lea    -0x80(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x2c(%rbp),%edx
mov    -0x30(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
movss  -0x50(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
lea    -0x54(%rbp),%r9
lea    -0x58(%rbp),%rax
mov    %rax,(%rsp)
call   1050 <rotate@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1818 <jacobi+0x6c8>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18ab <jacobi+0x75b>
mov    -0x20(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edx
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%r8d
movss  -0x50(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
lea    -0x54(%rbp),%r9
lea    -0x58(%rbp),%rax
mov    %rax,(%rsp)
call   1050 <rotate@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1865 <jacobi+0x715>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    18bb <jacobi+0x76b>
jmp    18c0 <jacobi+0x770>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13f0 <jacobi+0x2a0>
jmp    18d3 <jacobi+0x783>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13d6 <jacobi+0x286>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1940 <jacobi+0x7f0>
movslq -0x34(%rbp),%rax
movss  -0x6c(%rbp,%rax,4),%xmm0
movslq -0x34(%rbp),%rax
addss  -0x64(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x64(%rbp,%rax,4)
movslq -0x34(%rbp),%rax
movss  -0x64(%rbp,%rax,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp,%rax,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18e8 <jacobi+0x798>
jmp    1945 <jacobi+0x7f5>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12df <jacobi+0x18f>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jacobi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
cmp    $0x2,%esi
jne    152b <jacobi+0x3db>
mov    %r8,%r14
mov    %rcx,%r15
mov    %rdx,%rbx
movq   $0x0,(%rcx)
movss  (%rdi),%xmm2
movss  0x4(%rdi),%xmm0
movl   $0x3f800000,(%rcx)
movq   $0x0,0x8(%rcx)
movss  0xc(%rdi),%xmm1
movl   $0x3f800000,0xc(%rcx)
movss  %xmm2,0x2c(%rsp)
movss  %xmm2,(%rdx)
movss  %xmm1,0x28(%rsp)
movss  %xmm1,0x4(%rdx)
movl   $0x0,(%r8)
xor    %ebp,%ebp
lea    0x18(%rsp),%r13
lea    0x1c(%rsp),%r12
jmp    1212 <jacobi+0xc2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm4,%xmm4
movss  0x14(%rsp),%xmm2
movss  0x28(%rsp),%xmm1
addss  %xmm3,%xmm1
movss  0x2c(%rsp),%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,0x2c(%rsp)
movss  %xmm0,(%rbx)
movss  %xmm1,0x28(%rsp)
movss  %xmm1,0x4(%rbx)
add    $0x1,%ebp
movapd %xmm2,%xmm0
cmp    $0x64,%ebp
je     151c <jacobi+0x3cc>
movss  %xmm0,0x14(%rsp)
call   1030 <fabs@plt>
movss  0x14(%rsp),%xmm2
cvtsd2ss %xmm0,%xmm0
xorps  %xmm1,%xmm1
addss  %xmm1,%xmm0
ucomiss %xmm1,%xmm0
jne    1239 <jacobi+0xe9>
jnp    151c <jacobi+0x3cc>
cvtss2sd %xmm0,%xmm0
mulsd  0xdbb(%rip),%xmm0
mulsd  0xdbb(%rip),%xmm0
movsd  %xmm0,0x30(%rsp)
movapd %xmm2,%xmm0
call   1030 <fabs@plt>
mulsd  0xdac(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x18(%rsp)
cmp    $0x4,%ebp
jb     12f0 <jacobi+0x1a0>
movss  (%rbx),%xmm0
call   1030 <fabs@plt>
movss  0x18(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
movss  (%rbx),%xmm0
call   1030 <fabs@plt>
movsd  0x20(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jne    12f0 <jacobi+0x1a0>
jp     12f0 <jacobi+0x1a0>
movss  0x4(%rbx),%xmm0
call   1030 <fabs@plt>
movss  0x18(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
movss  0x4(%rbx),%xmm0
call   1030 <fabs@plt>
xorps  %xmm3,%xmm3
movsd  0x20(%rsp),%xmm1
ucomisd %xmm0,%xmm1
xorps  %xmm4,%xmm4
xorpd  %xmm2,%xmm2
jne    12f0 <jacobi+0x1a0>
jnp    11d9 <jacobi+0x89>
nopl   0x0(%rax,%rax,1)
movss  0x14(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    $0x3,%ebp
jb     1310 <jacobi+0x1c0>
xorps  %xmm1,%xmm1
jmp    131e <jacobi+0x1ce>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x30(%rsp),%xmm1
cvtsd2ss %xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
xorps  %xmm3,%xmm3
ucomisd %xmm1,%xmm0
jbe    11d0 <jacobi+0x80>
movss  0x4(%rbx),%xmm0
subss  (%rbx),%xmm0
movss  %xmm0,0x1c(%rsp)
call   1030 <fabs@plt>
movss  0x18(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rsp)
movss  0x1c(%rsp),%xmm0
call   1030 <fabs@plt>
movsd  0x30(%rsp),%xmm1
ucomisd %xmm0,%xmm1
movss  0x1c(%rsp),%xmm0
jne    1384 <jacobi+0x234>
jp     1384 <jacobi+0x234>
movss  0x14(%rsp),%xmm2
movaps %xmm2,%xmm1
divss  %xmm0,%xmm1
jmp    1410 <jacobi+0x2c0>
mulss  0xc9c(%rip),%xmm0
divss  0x14(%rsp),%xmm0
movss  %xmm0,0x30(%rsp)
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movss  0x30(%rsp),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0xc62(%rip),%xmm0
ucomisd 0xc62(%rip),%xmm0
jb     13c6 <jacobi+0x276>
sqrtsd %xmm0,%xmm0
jmp    13d7 <jacobi+0x287>
movsd  %xmm1,0x20(%rsp)
call   1060 <sqrt@plt>
movsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  0xc35(%rip),%xmm0
divsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomiss 0x30(%rsp),%xmm0
movss  0x14(%rsp),%xmm2
jbe    1410 <jacobi+0x2c0>
xorps  0xc3b(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm1,0x30(%rsp)
movaps %xmm1,%xmm0
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0xbf0(%rip),%xmm0
ucomisd 0xbf0(%rip),%xmm0
jb     1438 <jacobi+0x2e8>
sqrtsd %xmm0,%xmm0
jmp    1443 <jacobi+0x2f3>
call   1060 <sqrt@plt>
movss  0x14(%rsp),%xmm2
movsd  0xbcd(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movaps 0x30(%rsp),%xmm1
mulss  %xmm1,%xmm2
mulss  %xmm0,%xmm1
addss  0xbc1(%rip),%xmm0
movaps %xmm1,%xmm3
movaps %xmm1,0x30(%rsp)
divss  %xmm0,%xmm3
movss  %xmm3,0x44(%rsp)
movss  %xmm2,0x1c(%rsp)
xorps  %xmm0,%xmm0
xorps  %xmm4,%xmm4
subss  %xmm2,%xmm4
movss  %xmm4,0x14(%rsp)
movaps %xmm2,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,0x20(%rsp)
movss  (%rbx),%xmm0
subss  %xmm2,%xmm0
movss  %xmm0,(%rbx)
addss  0x4(%rbx),%xmm2
movss  %xmm2,0x4(%rbx)
mov    %r13,(%rsp)
mov    %r15,%rdi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x1,%r8d
mov    %r12,%r9
movaps %xmm1,%xmm0
movaps %xmm3,%xmm1
call   1050 <rotate@plt>
mov    %r13,(%rsp)
mov    %r15,%rdi
mov    $0x1,%esi
xor    %edx,%edx
mov    $0x1,%ecx
mov    $0x1,%r8d
mov    %r12,%r9
movapd 0x30(%rsp),%xmm0
movss  0x44(%rsp),%xmm1
call   1050 <rotate@plt>
movss  0x14(%rsp),%xmm4
movss  0x20(%rsp),%xmm3
xorps  %xmm2,%xmm2
addl   $0x1,(%r14)
jmp    11d9 <jacobi+0x89>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %esi,%edx
mov    0x2aac(%rip),%rax
mov    (%rax),%edi
lea    0xb13(%rip),%rsi
mov    $0x2,%ecx
call   1040 <fprintf@plt>
mov    0x2a8a(%rip),%rax
mov    (%rax),%edi
call   1070 <exit@plt>

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

LLVM IR (-O2):
@stderr = global i32 0
@.str = [39 x i8] c"\0AFatal error: n %d not N %d in jacobi\0A\00"
@EXIT_FAILURE = global i32 0
define void @jacobi([2 x float]* nocapture %0, i32 %1, float* nocapture %2, [2 x float]* %3, i32* nocapture %4) {
%6 = alloca float
%7 = alloca float
%8 = bitcast float* %6 to i8*
%9 = bitcast float* %7 to i8*
%10 = icmp eq i32 %1, 2
br i1 %10, label %11, label %25
11: ; preds = %5
%12 = getelementptr [2 x float], [2 x float]* %3, i64 0, i64 0
%13 = bitcast [2 x float]* %3 to i64*
store i64 0, i64* %13
%14 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 0, i64 0
%15 = load float, float* %14
%16 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 0, i64 1
%17 = load float, float* %16
store float 1.000000e+00, float* %12
%18 = getelementptr [2 x float], [2 x float]* %3, i64 1, i64 0
%19 = bitcast float* %18 to i64*
store i64 0, i64* %19
%20 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 1, i64 1
%21 = load float, float* %20
%22 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 1, i64 1
store float 1.000000e+00, float* %22
store float %15, float* %2
%23 = getelementptr inbounds float, float* %2, i64 1
store float %21, float* %23
store i32 0, i32* %4
%24 = bitcast [2 x float]* %3 to float**
br label %30
25: ; preds = %5
%26 = load i32, i32* @stderr
%27 = tail call i32 @fprintf(i32 %26, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), i32 %1, i32 2)
%28 = load i32, i32* @EXIT_FAILURE
%29 = tail call i32 @exit(i32 %28)
unreachable
30: ; preds = %11, %122
%31 = phi float [ %15, %11 ], [ %126, %122 ]
%32 = phi float [ %21, %11 ], [ %127, %122 ]
%33 = phi float [ %17, %11 ], [ %125, %122 ]
%34 = phi i32 [ 0, %11 ], [ %128, %122 ]
%35 = call double @fabs(float %33)
%36 = fptrunc double %35 to float
%37 = fadd float %36, 0.000000e+00
%38 = fcmp oeq float %37, 0.000000e+00
br i1 %38, label %130, label %39
39: ; preds = %30
%40 = fpext float %37 to double
%41 = icmp ult i32 %34, 3
%42 = fmul double %40, 2.000000e-01
%43 = fmul double %42, 2.500000e-01
%44 = fptrunc double %43 to float
%45 = call double @fabs(float %33)
%46 = fmul double %45, 1.000000e+02
%47 = fptrunc double %46 to float
store float %47, float* %7
%48 = icmp ugt i32 %34, 3
br i1 %48, label %49, label %67
49: ; preds = %39
%50 = load float, float* %2
%51 = call double @fabs(float %50)
%52 = load float, float* %7
%53 = fpext float %52 to double
%54 = fadd double %51, %53
%55 = load float, float* %2
%56 = call double @fabs(float %55)
%57 = fcmp oeq double %54, %56
br i1 %57, label %58, label %67
58: ; preds = %49
%59 = load float, float* %23
%60 = call double @fabs(float %59)
%61 = load float, float* %7
%62 = fpext float %61 to double
%63 = fadd double %60, %62
%64 = load float, float* %23
%65 = call double @fabs(float %64)
%66 = fcmp oeq double %63, %65
br i1 %66, label %122, label %67
67: ; preds = %58, %49, %39
%68 = call double @fabs(float %33)
%69 = fpext float %44 to double
%70 = select i1 %41, double %69, double 0.000000e+00
%71 = fcmp ogt double %68, %70
br i1 %71, label %72, label %122
72: ; preds = %67
%73 = load float, float* %23
%74 = load float, float* %2
%75 = fsub float %73, %74
store float %75, float* %6
%76 = call double @fabs(float %75)
%77 = load float, float* %7
%78 = fpext float %77 to double
%79 = fadd double %76, %78
%80 = load float, float* %6
%81 = call double @fabs(float %80)
%82 = fcmp oeq double %79, %81
%83 = load float, float* %6
br i1 %82, label %84, label %86
84: ; preds = %72
%85 = fdiv float %33, %83
br label %100
86: ; preds = %72
%87 = fmul float %83, 5.000000e-01
%88 = fdiv float %87, %33
%89 = call double @fabs(float %88)
%90 = fmul float %88, %88
%91 = fpext float %90 to double
%92 = fadd double %91, 1.000000e+00
%93 = call double @sqrt(double %92)
%94 = fadd double %89, %93
%95 = fdiv double 1.000000e+00, %94
%96 = fptrunc double %95 to float
%97 = fcmp olt float %88, 0.000000e+00
br i1 %97, label %98, label %100
98: ; preds = %86
%99 = fneg float %96
br label %100
100: ; preds = %86, %98, %84
%101 = phi float [ %85, %84 ], [ %99, %98 ], [ %96, %86 ]
%102 = fmul float %101, %101
%103 = fpext float %102 to double
%104 = fadd double %103, 1.000000e+00
%105 = call double @sqrt(double %104)
%106 = fdiv double 1.000000e+00, %105
%107 = fptrunc double %106 to float
%108 = fmul float %101, %107
%109 = fadd float %107, 1.000000e+00
%110 = fdiv float %108, %109
%111 = fmul float %33, %101
store float %111, float* %6
%112 = fsub float 0.000000e+00, %111
%113 = fadd float %111, 0.000000e+00
%114 = load float, float* %2
%115 = fsub float %114, %111
store float %115, float* %2
%116 = load float, float* %23
%117 = fadd float %111, %116
store float %117, float* %23
%118 = call i32 @rotate(float** %24, i32 0, i32 0, i32 0, i32 1, float* %6, float* %7, float %108, float %110)
%119 = call i32 @rotate(float** %24, i32 1, i32 0, i32 1, i32 1, float* %6, float* %7, float %108, float %110)
%120 = load i32, i32* %4
%121 = add nsw i32 %120, 1
store i32 %121, i32* %4
br label %122
122: ; preds = %58, %100, %67
%123 = phi float [ 0.000000e+00, %58 ], [ %113, %100 ], [ 0.000000e+00, %67 ]
%124 = phi float [ 0.000000e+00, %58 ], [ %112, %100 ], [ 0.000000e+00, %67 ]
%125 = phi float [ 0.000000e+00, %58 ], [ 0.000000e+00, %100 ], [ %33, %67 ]
%126 = fadd float %124, %31
store float %126, float* %2
%127 = fadd float %123, %32
store float %127, float* %23
%128 = add nuw nsw i32 %34, 1
%129 = icmp eq i32 %128, 100
br i1 %129, label %130, label %30
130: ; preds = %122, %30
ret void
}