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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
double sqrt(double);
void jac(double **a, double *e, double **v, int n) {
  int i, j, kmax = n, kaisuu;
  int p, q;
  double eps, eps2, bunbo, c, s;
  double apq, apqmax, gmax, wa, sa;
  double apj, aqj, vip, viq;
  gmax = 0.0;
  for (i = 0; i < n; ++i) {
    s = 0.0;
    for (j = 0; j < n; ++j)
      s += fabs((*((double *)a + i * n + j)));
    if (s > gmax)
      gmax = s;
  }
  eps = 0.000001 * gmax;
  eps2 = 0.001 * eps;
  for (i = 0; i < n; ++i) {
    for (j = 0; j < n; ++j)
      (*((double *)v + i * n + j)) = 0.0;
    (*((double *)v + i * n + i)) = 1.0;
  }
  for (kaisuu = 1; kaisuu <= kmax; ++kaisuu) {
    apqmax = 0.0;
    for (p = 0; p < n - 1; ++p) {
      for (q = p + 1; q < n; ++q) {
        apq = fabs((*((double *)a + p * n + q)));
        if (apq > apqmax)
          apqmax = apq;
      }
    }
    if (apqmax < eps)
      break;
    for (p = 0; p < n - 1; ++p) {
      for (q = p + 1; q < n; ++q) {
        apq = (*((double *)a + p * n + q));
        if (fabs(apq = apq) < eps)
          break;
        wa =
            ((*((double *)a + p * n + p)) + (*((double *)a + q * n + q))) * 0.5;
        sa =
            ((*((double *)a + p * n + p)) - (*((double *)a + q * n + q))) * 0.5;
        bunbo = sqrt(sa * sa + (*((double *)a + p * n + q)) *
                                   (*((double *)a + p * n + q)));
        if (sa > 0.0) {
          c = sqrt(1.0 + sa / bunbo) / 1.41421356;
          s = apq / (2.0 * c * bunbo);
          (*((double *)a + p * n + p)) = wa + bunbo;
          (*((double *)a + q * n + q)) = wa - bunbo;
        } else {
          c = sqrt(1.0 - sa / bunbo) / 1.41421356;
          s = (-apq) / (2.0 * c * bunbo);
          (*((double *)a + p * n + p)) = wa - bunbo;
          (*((double *)a + q * n + q)) = wa + bunbo;
        }
        (*((double *)a + p * n + q)) = (*((double *)a + q * n + p)) = 0.0;
        for (j = 0; j < p; ++j) {
          apj = (*((double *)a + p * n + j));
          aqj = (*((double *)a + q * n + j));
          (*((double *)a + j * n + p)) = (*((double *)a + p * n + j)) =
              apj * c + aqj * s;
          (*((double *)a + j * n + q)) = (*((double *)a + q * n + j)) =
              (-apj * s + aqj * c);
        }
        for (j = p + 1; j < q; ++j) {
          apj = (*((double *)a + p * n + j));
          aqj = (*((double *)a + q * n + j));
          (*((double *)a + j * n + p)) = (*((double *)a + p * n + j)) =
              apj * c + aqj * s;
          (*((double *)a + j * n + q)) = (*((double *)a + q * n + j)) =
              (-apj * s + aqj * c);
        }
        for (j = q + 1; j < n; ++j) {
          apj = (*((double *)a + p * n + j));
          aqj = (*((double *)a + q * n + j));
          (*((double *)a + j * n + p)) = (*((double *)a + p * n + j)) =
              apj * c + aqj * s;
          (*((double *)a + j * n + q)) = (*((double *)a + q * n + j)) =
              (-apj * s + aqj * c);
        }
        for (i = 0; i < n; ++i) {
          vip = (*((double *)v + i * n + p));
          viq = (*((double *)v + i * n + q));
          (*((double *)v + i * n + p)) = vip * c + viq * s;
          (*((double *)v + i * n + q)) = (-vip * s + viq * c);
        }
      }
    }
    eps = eps * 1.05;
  }
  for (i = 0; i < n; ++i)
    e[i] = (*((double *)a + i * n + i));
}


x86 assembly (clang, -O0):
<jac>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11d4 <jac+0xc4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11a7 <jac+0x97>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xeb5(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    115a <jac+0x4a>
movsd  -0x60(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    11c1 <jac+0xb1>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    11c6 <jac+0xb6>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    113f <jac+0x2f>
movsd  0xe2c(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xe12(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1281 <jac+0x171>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    124d <jac+0x13d>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1212 <jac+0x102>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  0xdc2(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11ff <jac+0xef>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1b83 <jac+0xa73>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1337 <jac+0x227>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1324 <jac+0x214>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd52(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1311 <jac+0x201>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1316 <jac+0x206>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12bd <jac+0x1ad>
jmp    1329 <jac+0x219>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12a3 <jac+0x193>
movsd  -0x70(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1350 <jac+0x240>
jmp    1b83 <jac+0xa73>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1b63 <jac+0xa53>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1b50 <jac+0xa40>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  %xmm1,-0x68(%rbp)
movaps 0xc8f(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    13c9 <jac+0x2b9>
jmp    1b50 <jac+0xa40>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xc0b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0xbbe(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    157d <jac+0x46d>
movsd  -0x88(%rbp),%xmm1
ff
divsd  -0x50(%rbp),%xmm1
movsd  0xb42(%rip),%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  0xb29(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  0xb0b(%rip),%xmm1
mulsd  -0x58(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x80(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1633 <jac+0x523>
movsd  -0x88(%rbp),%xmm1
ff
divsd  -0x50(%rbp),%xmm1
movsd  0xa9e(%rip),%xmm0
subsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  0xa85(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xa50(%rip),%xmm1
mulsd  -0x58(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x80(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    17b5 <jac+0x6a5>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    167c <jac+0x56c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    18f7 <jac+0x7e7>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    17be <jac+0x6ae>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a39 <jac+0x929>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1900 <jac+0x7f0>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1b3d <jac+0xa2d>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1a40 <jac+0x930>
jmp    1b42 <jac+0xa32>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1371 <jac+0x261>
jmp    1b55 <jac+0xa45>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1357 <jac+0x247>
movsd  0x4a5(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1288 <jac+0x178>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1bcf <jac+0xabf>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1b8a <jac+0xa7a>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jac>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
test   %ecx,%ecx
jle    1e15 <jac+0xcf5>
mov    %ecx,%r12d
mov    %ecx,%r10d
lea    -0x1(%r10),%rax
mov    %rax,0x80(%rsp)
mov    %r10d,%r14d
and    $0x3,%r14d
mov    %r10d,%r11d
and    $0xfffffffc,%r11d
lea    0x18(%rdi),%rax
lea    0x0(,%r10,8),%rbp
mov    %rbp,0x10(%rsp)
xorpd  %xmm1,%xmm1
xor    %r9d,%r9d
movapd 0xe87(%rip),%xmm0
mov    %rdi,%r8
jmp    11a0 <jac+0x80>
xchg   %ax,%ax
maxsd  %xmm1,%xmm6
add    $0x1,%r9
mov    0x10(%rsp),%rbp
add    %rbp,%rax
add    %rbp,%r8
movapd %xmm6,%xmm1
cmp    %r10,%r9
je     1250 <jac+0x130>
cmpq   $0x3,0x80(%rsp)
jae    11c0 <jac+0xa0>
xor    %ebp,%ebp
xorpd  %xmm6,%xmm6
jmp    1214 <jac+0xf4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm2,%xmm2
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x18(%rax,%rbp,8),%xmm3
movsd  -0x10(%rax,%rbp,8),%xmm4
movsd  -0x8(%rax,%rbp,8),%xmm5
movsd  (%rax,%rbp,8),%xmm6
andpd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
andpd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
andpd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
andpd  %xmm0,%xmm6
addsd  %xmm5,%xmm6
add    $0x4,%rbp
movapd %xmm6,%xmm2
cmp    %rbp,%r11
jne    11d0 <jac+0xb0>
test   %r14,%r14
je     1180 <jac+0x60>
lea    (%r8,%rbp,8),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rbx,8),%xmm2
andpd  0xdc2(%rip),%xmm2
addsd  %xmm2,%xmm6
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1230 <jac+0x110>
jmp    1180 <jac+0x60>
test   %r12d,%r12d
jle    1e15 <jac+0xcf5>
lea    0x0(,%r10,8),%r13
mov    %r10d,%r14d
and    $0x3,%r14d
xor    %ebp,%ebp
movabs $0x3ff0000000000000,%r15
cmpq   $0x3,0x80(%rsp)
mov    %rdi,0x48(%rsp)
mov    %r10,0x28(%rsp)
mov    %rdx,0x40(%rsp)
mov    %rsi,0x130(%rsp)
mov    %r12,0x20(%rsp)
movapd %xmm6,0xc0(%rsp)
jb     13ee <jac+0x2ce>
mov    %r14,0x30(%rsp)
lea    (%r12,%r12,1),%esi
mov    %rsi,0x38(%rsp)
lea    0x0(,%r12,4),%esi
mov    %esi,0x70(%rsp)
mov    %r10,%rsi
shl    $0x4,%rsi
mov    %rsi,0x18(%rsp)
mov    %r10,%rsi
shl    $0x5,%rsi
add    $0x20,%rsi
mov    %rsi,0x98(%rsp)
lea    (%r12,%r12,2),%eax
mov    %rax,0x8(%rsp)
mov    0x10(%rsp),%rax
lea    (%rax,%rax,2),%rax
mov    %rax,0x90(%rsp)
mov    %r10d,%eax
and    $0xfffffffc,%eax
neg    %rax
mov    %rax,0x88(%rsp)
mov    $0x1,%r12d
mov    %rdx,%r15
mov    0x40(%rsp),%r14
nopw   0x0(%rax,%rax,1)
movslq %ebp,%rbp
lea    (%r14,%rbp,8),%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1030 <memset@plt>
mov    %r13,%rbx
movabs $0x3ff0000000000000,%r13
mov    %r13,(%r15)
mov    0x20(%rsp),%rax
add    %ebp,%eax
cltq
lea    (%r14,%rax,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1030 <memset@plt>
mov    0x28(%rsp),%rax
mov    %r13,0x8(%r15,%rax,8)
mov    0x38(%rsp),%rax
add    %ebp,%eax
cltq
lea    (%r14,%rax,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1030 <memset@plt>
mov    0x18(%rsp),%rax
mov    %r13,0x10(%r15,%rax,1)
mov    0x8(%rsp),%rax
add    %ebp,%eax
cltq
lea    (%r14,%rax,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1030 <memset@plt>
mov    0x90(%rsp),%rax
mov    %r13,0x18(%r15,%rax,1)
mov    %rbx,%r13
add    0x70(%rsp),%ebp
add    0x98(%rsp),%r15
mov    0x88(%rsp),%rax
add    %r12,%rax
add    $0x4,%rax
add    $0x4,%r12
cmp    $0x1,%rax
jne    1320 <jac+0x200>
movabs $0x3ff0000000000000,%r15
add    $0xffffffffffffffff,%r12
mov    %r12,%rbp
mov    0x20(%rsp),%r12
mov    0x30(%rsp),%r14
test   %r14,%r14
je     1447 <jac+0x327>
mov    0x28(%rsp),%rax
lea    0x8(,%rax,8),%rax
mov    %rbp,%rbx
mov    %rax,0x38(%rsp)
imul   %rax,%rbx
add    0x40(%rsp),%rbx
imul   %r12d,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movslq %ebp,%rbp
mov    0x40(%rsp),%rax
lea    (%rax,%rbp,8),%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1030 <memset@plt>
mov    %r15,(%rbx)
add    0x38(%rsp),%rbx
add    %r12d,%ebp
add    $0xffffffffffffffff,%r14
jne    1420 <jac+0x300>
test   %r12d,%r12d
mov    0x28(%rsp),%r9
mov    0x10(%rsp),%r8
movapd 0xba4(%rip),%xmm5
movapd 0xc0(%rsp),%xmm8
jle    1d24 <jac+0xc04>
mulsd  0xbab(%rip),%xmm8
mov    0x20(%rsp),%rax
lea    -0x1(%rax),%ebp
mov    %r9d,%r14d
and    $0xfffffffe,%r14d
lea    0x8(,%r9,8),%rax
mov    %rax,0xb8(%rsp)
mov    0x48(%rsp),%rcx
lea    0x8(%rcx),%rax
mov    %rax,0x160(%rsp)
lea    (%rcx,%r9,8),%rax
mov    %rax,0x158(%rsp)
lea    0x8(%rcx,%r9,8),%rax
mov    %rax,0x150(%rsp)
mov    0x40(%rsp),%rax
lea    (%rax,%r9,8),%rcx
add    $0x8,%rcx
mov    %rcx,0x148(%rsp)
mov    %r9,%r10
shl    $0x4,%r10
lea    (%rax,%r9,8),%rcx
mov    %rcx,0x140(%rsp)
add    $0x8,%rax
mov    %rax,0x138(%rsp)
mov    $0x1,%eax
mov    %rax,0xd0(%rsp)
xorpd  %xmm7,%xmm7
movsd  0xb1c(%rip),%xmm9
mov    %rbp,0x168(%rsp)
mov    %r14,0x178(%rsp)
mov    %r10,0x170(%rsp)
jmp    1561 <jac+0x441>
cs nopw 0x0(%rax,%rax,1)
ucomisd %xmm7,%xmm8
ja     1d24 <jac+0xc04>
mulsd  0xafc(%rip),%xmm8
mov    0xd0(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0x20(%rsp),%ecx
mov    %rax,0xd0(%rsp)
je     1d24 <jac+0xc04>
cmpl   $0x1,0x20(%rsp)
je     1530 <jac+0x410>
xorpd  %xmm0,%xmm0
mov    %r9,%rax
mov    0x48(%rsp),%rcx
xor    %edx,%edx
jmp    1591 <jac+0x471>
nopl   0x0(%rax,%rax,1)
add    0xb8(%rsp),%rcx
add    $0xffffffffffffffff,%rax
cmp    %rbp,%rdx
je     15d0 <jac+0x4b0>
add    $0x1,%rdx
cmp    %r9,%rdx
jae    1580 <jac+0x460>
mov    $0x1,%esi
movapd %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rsi,8),%xmm0
andpd  %xmm5,%xmm0
maxsd  %xmm1,%xmm0
add    $0x1,%rsi
movapd %xmm0,%xmm1
cmp    %rsi,%rax
jne    15b0 <jac+0x490>
jmp    1580 <jac+0x460>
nopl   0x0(%rax)
ucomisd %xmm0,%xmm8
ja     1d24 <jac+0xc04>
cmpl   $0x1,0x20(%rsp)
je     153b <jac+0x41b>
mov    $0x1,%eax
mov    %rax,0x108(%rsp)
movl   $0x2,0x7c(%rsp)
mov    0x40(%rsp),%rsi
mov    0x138(%rsp),%rax
mov    %rax,0x100(%rsp)
mov    0x140(%rsp),%rdi
mov    0x148(%rsp),%rax
mov    %rax,0xf8(%rsp)
mov    0x150(%rsp),%rax
mov    %rax,0xf0(%rsp)
mov    0x48(%rsp),%rdx
mov    %rdx,%r15
mov    0x160(%rsp),%rax
mov    %rax,0xe8(%rsp)
mov    0x158(%rsp),%rcx
mov    %rcx,0xe0(%rsp)
mov    %rdx,0x60(%rsp)
mov    %rdx,0x50(%rsp)
mov    %rax,0xd8(%rsp)
xor    %eax,%eax
movapd %xmm8,0xc0(%rsp)
jmp    16f8 <jac+0x5d8>
addq   $0x1,0x108(%rsp)
addl   $0x1,0x7c(%rsp)
addq   $0x8,0xd8(%rsp)
addq   $0x8,0x50(%rsp)
add    %r8,0x60(%rsp)
add    %r8,0xe0(%rsp)
mov    0xb8(%rsp),%rax
add    %rax,0xe8(%rsp)
add    %rax,%r15
add    %rax,0xf0(%rsp)
addq   $0x8,0xf8(%rsp)
add    $0x8,%rdi
addq   $0x8,0x100(%rsp)
add    $0x8,%rsi
mov    0x168(%rsp),%rbp
mov    0x120(%rsp),%rax
cmp    %rbp,%rax
je     153b <jac+0x41b>
mov    %rax,0x8(%rsp)
add    $0x1,%rax
mov    %rax,0x120(%rsp)
cmp    %r9,%rax
jae    1680 <jac+0x560>
movslq 0x7c(%rsp),%rcx
mov    %r9,%rax
mov    %rcx,0x128(%rsp)
imul   %rcx,%rax
mov    0xd8(%rsp),%rdx
lea    (%rdx,%rax,8),%rcx
mov    %rcx,0x70(%rsp)
mov    0x50(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x30(%rsp)
mov    0x8(%rsp),%rax
imul   %r9,%rax
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x100(%rsp),%rbp
mov    0xf8(%rsp),%rbx
xor    %eax,%eax
mov    %rax,0x90(%rsp)
mov    0xf0(%rsp),%r12
mov    0xe8(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    0xe0(%rsp),%r13
mov    0x108(%rsp),%r11
mov    %rsi,0x118(%rsp)
mov    %rcx,0x18(%rsp)
mov    %rdi,0x110(%rsp)
jmp    180a <jac+0x6ea>
addq   $0x1,0x128(%rsp)
mov    0x98(%rsp),%rdx
add    $0x8,%rdx
add    %r8,%r13
addq   $0x8,0x88(%rsp)
add    %r8,%r12
addq   $0x1,0x90(%rsp)
mov    0x70(%rsp),%rcx
add    0xb8(%rsp),%rcx
mov    %rcx,0x70(%rsp)
add    %r8,0x30(%rsp)
add    $0x8,%rbx
add    $0x8,%rbp
cmp    %r9,%r11
mov    0x18(%rsp),%rcx
je     1680 <jac+0x560>
movsd  (%rcx,%r11,8),%xmm2
movapd %xmm2,%xmm0
andpd  %xmm5,%xmm0
ucomisd %xmm0,%xmm8
ja     1680 <jac+0x560>
mov    0x8(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm3
mov    %r11,%rax
imul   %r9,%rax
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,8),%r14
movsd  (%r14,%r11,8),%xmm5
movapd %xmm3,%xmm4
subsd  %xmm5,%xmm4
mulsd  %xmm9,%xmm4
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm7,%xmm0
mov    %rdx,0x98(%rsp)
mov    %r11,0x38(%rsp)
movapd %xmm2,0xa0(%rsp)
jb     1890 <jac+0x770>
xorps  %xmm2,%xmm2
sqrtsd %xmm0,%xmm2
jmp    18d0 <jac+0x7b0>
nopl   0x0(%rax)
movsd  %xmm3,0x68(%rsp)
movsd  %xmm4,0x58(%rsp)
movsd  %xmm5,0x180(%rsp)
call   1040 <sqrt@plt>
movsd  0x180(%rsp),%xmm5
movsd  0x58(%rsp),%xmm4
movsd  0x68(%rsp),%xmm3
movsd  0x760(%rip),%xmm9
xorpd  %xmm7,%xmm7
movapd %xmm0,%xmm2
addsd  %xmm5,%xmm3
mulsd  %xmm9,%xmm3
ucomisd %xmm7,%xmm4
divsd  %xmm2,%xmm4
jbe    1900 <jac+0x7e0>
addsd  0x745(%rip),%xmm4
ucomisd %xmm7,%xmm4
jb     1920 <jac+0x800>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
jmp    194e <jac+0x82e>
nopw   0x0(%rax,%rax,1)
movsd  0x728(%rip),%xmm0
subsd  %xmm4,%xmm0
ucomisd %xmm7,%xmm0
jb     19c0 <jac+0x8a0>
sqrtsd %xmm0,%xmm0
jmp    19ea <jac+0x8ca>
nop
movapd %xmm4,%xmm0
movsd  %xmm3,0x68(%rsp)
movsd  %xmm2,0x58(%rsp)
call   1040 <sqrt@plt>
movsd  0x58(%rsp),%xmm2
movsd  0x68(%rsp),%xmm3
movsd  0x6de(%rip),%xmm9
xorpd  %xmm7,%xmm7
mov    0x28(%rsp),%r9
mov    0x10(%rsp),%r8
movapd 0x6a0(%rip),%xmm5
movapd 0xc0(%rsp),%xmm8
mov    0x60(%rsp),%rdx
mov    0x50(%rsp),%rsi
mov    0x8(%rsp),%rdi
mov    0x30(%rsp),%r10
mov    0x18(%rsp),%rax
movapd 0xa0(%rsp),%xmm6
divsd  0x6a4(%rip),%xmm0
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm6
movapd %xmm2,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rax,%rdi,8)
subsd  %xmm2,%xmm3
jmp    1a59 <jac+0x939>
nopw   0x0(%rax,%rax,1)
movsd  %xmm3,0x68(%rsp)
movsd  %xmm2,0x58(%rsp)
call   1040 <sqrt@plt>
movsd  0x58(%rsp),%xmm2
movsd  0x68(%rsp),%xmm3
movsd  0x642(%rip),%xmm9
xorpd  %xmm7,%xmm7
mov    0x28(%rsp),%r9
mov    0x10(%rsp),%r8
movapd 0x604(%rip),%xmm5
movapd 0xc0(%rsp),%xmm8
mov    0x60(%rsp),%rdx
mov    0x50(%rsp),%rsi
mov    0x8(%rsp),%rdi
mov    0x30(%rsp),%r10
mov    0x18(%rsp),%rax
movapd 0xa0(%rsp),%xmm6
divsd  0x608(%rip),%xmm0
xorpd  0x5d8(%rip),%xmm6
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm6
movapd %xmm3,%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rax,%rdi,8)
addsd  %xmm2,%xmm3
mov    0x38(%rsp),%rcx
movsd  %xmm3,(%r14,%rcx,8)
movq   $0x0,(%r14,%rdi,8)
movq   $0x0,(%rax,%rcx,8)
test   %rdi,%rdi
mov    0x98(%rsp),%r11
je     1adf <jac+0x9bf>
xor    %eax,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rcx,8),%xmm1
movsd  0x0(%r13,%rcx,8),%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rdx,%rcx,8)
movsd  %xmm4,(%rsi,%rax,8)
mulsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%r13,%rcx,8)
movsd  %xmm2,(%r11,%rax,8)
add    $0x1,%rcx
add    %r9,%rax
cmp    %rcx,%rdi
jne    1a90 <jac+0x970>
mov    0x38(%rsp),%rdi
cmp    %rdi,0x120(%rsp)
mov    0x90(%rsp),%rdx
mov    0x88(%rsp),%rsi
jae    1b61 <jac+0xa41>
xor    %eax,%eax
mov    %r9,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x8(%r15,%rax,8),%xmm1
movsd  (%r12,%rax,8),%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,0x8(%r15,%rax,8)
movsd  %xmm4,(%r15,%rcx,8)
mulsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,(%r12,%rax,8)
movsd  %xmm2,(%rsi,%rcx,8)
add    %r9,%rcx
add    $0x1,%rax
cmp    %rax,%rdx
jne    1b10 <jac+0x9f0>
lea    0x1(%rdi),%rax
mov    %rax,0xa0(%rsp)
cmp    %r9,%rax
mov    0x70(%rsp),%rdi
mov    0x18(%rsp),%r11
jae    1be5 <jac+0xac5>
xor    %ecx,%ecx
mov    0x128(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
mov    %edx,%esi
shl    $0x3,%rsi
movsd  (%r11,%rsi,1),%xmm1
movsd  (%r14,%rsi,1),%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%r11,%rsi,1)
movsd  %xmm4,(%r10,%rcx,1)
mulsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,(%r14,%rsi,1)
movsd  %xmm2,(%rdi,%rcx,1)
add    $0x1,%rdx
add    %r8,%rcx
cmp    %r9,%rdx
jl     1b90 <jac+0xa70>
cmpq   $0x0,0x80(%rsp)
je     1cb0 <jac+0xb90>
xor    %edx,%edx
xor    %ecx,%ecx
mov    0x178(%rsp),%r14
mov    0x170(%rsp),%r10
mov    0x118(%rsp),%rsi
mov    0x110(%rsp),%rdi
mov    0xa0(%rsp),%r11
movsd  (%rsi,%rdx,1),%xmm1
movsd  0x0(%rbp,%rdx,1),%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rsi,%rdx,1)
mulsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,1)
movsd  (%rdi,%rdx,1),%xmm1
movsd  (%rbx,%rdx,1),%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rdi,%rdx,1)
mulsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rdx,1)
add    $0x2,%rcx
add    %r10,%rdx
cmp    %rcx,%r14
jne    1c20 <jac+0xb00>
test   $0x1,%r9b
je     17b0 <jac+0x690>
jmp    1cd4 <jac+0xbb4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ecx,%ecx
mov    0x118(%rsp),%rsi
mov    0x110(%rsp),%rdi
mov    0xa0(%rsp),%r11
test   $0x1,%r9b
je     17b0 <jac+0x690>
imul   %r9,%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    0x8(%rsp),%rdx
movsd  (%rcx,%rdx,8),%xmm1
mov    0x38(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rcx,%rdx,8)
mulsd  %xmm2,%xmm0
mulsd  %xmm6,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
jmp    17b0 <jac+0x690>
cmpl   $0x0,0x20(%rsp)
mov    0x130(%rsp),%rdx
mov    0x48(%rsp),%rdi
jle    1e15 <jac+0xcf5>
mov    %r9d,%r8d
and    $0x3,%r8d
cmpq   $0x3,0x80(%rsp)
jae    1d5e <jac+0xc3e>
xor    %ecx,%ecx
test   %r8,%r8
jne    1dde <jac+0xcbe>
jmp    1e15 <jac+0xcf5>
mov    %r9,%r11
shl    $0x4,%r11
mov    %r9,%rsi
shl    $0x5,%rsi
add    $0x20,%rsi
mov    0x10(%rsp),%rax
lea    (%rax,%rax,2),%r10
mov    %r9d,%ebp
and    $0xfffffffc,%ebp
neg    %rbp
mov    $0x1,%ecx
mov    %rdi,%rbx
nopw   0x0(%rax,%rax,1)
movsd  (%rbx),%xmm0
movsd  %xmm0,-0x8(%rdx,%rcx,8)
movsd  0x8(%rbx,%r9,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  0x10(%rbx,%r11,1),%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,8)
movsd  0x18(%rbx,%r10,1),%xmm0
movsd  %xmm0,0x10(%rdx,%rcx,8)
add    %rsi,%rbx
lea    (%rcx,%rbp,1),%rax
add    $0x4,%rax
add    $0x4,%rcx
cmp    $0x1,%rax
jne    1d90 <jac+0xc70>
add    $0xffffffffffffffff,%rcx
test   %r8,%r8
je     1e15 <jac+0xcf5>
lea    (%rdx,%rcx,8),%rdx
lea    0x8(,%r9,8),%rsi
imul   %rsi,%rcx
add    %rcx,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x1,%rcx
add    %rsi,%rdi
cmp    %rcx,%r8
jne    1e00 <jac+0xce0>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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