#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*/ cmco_h2b(int const, double *, double const **,
                            double const **, double **, double **);
double sqrt(double);
double cmxx_en(double jcen[3], const int nbod, const int nbig, double *m,
               const double **restrict xh, const double **restrict vh,
               double **s, double *e) {
  int iflag = 0, itmp[8] = {0};
  double l[3] = {0.0};
  double temp = 0.0, dx = 0.0, dy = 0.0, dz = 0.0, r2 = 0.0, ke = 0.0, pe = 0.0;
  double r_1 = 0.0, r_2 = 0.0, r_4 = 0.0, r_6 = 0.0, u2 = 0.0, u4 = 0.0,
         u6 = 0.0;
  double tmp2[2000][4];
  double x[2000][3], v[2000][3];
  double *x_ptr[3];
  for (int i = 0; i < 3; i++) {
    x_ptr[i] = x[i];
  }
  double *v_ptr[3];
  for (int i = 0; i < 3; i++) {
    v_ptr[i] = v[i];
  }
  double _e = *e;
  ke = 0.0;
  pe = 0.0;
  cmco_h2b(nbod, m, xh, vh, x_ptr, v_ptr);
  for (int j = 0; j < nbod; j++) {
    l[0] += s[j][0];
    l[1] += s[j][1];
    l[2] += s[j][2];
  }
  for (int j = 0; j < nbod; j++) {
    l[0] += m[j] * (x[j][1] * v[j][2] - x[j][2] * v[j][1]);
    l[1] += m[j] * (x[j][2] * v[j][0] - x[j][0] * v[j][2]);
    l[2] += m[j] * (x[j][0] * v[j][1] - x[j][1] * v[j][0]);
    ke =
        ke + m[j] * (v[j][0] * v[j][0] + v[j][1] * v[j][1] + v[j][2] * v[j][2]);
  }
  for (int j = 1; j < nbod; j++) {
    double tmp = 0.0;
    for (int k = j + 1; k < nbod; k++) {
      dx = x[k][0] - x[j][0];
      dy = x[k][1] - x[j][1];
      dz = x[k][2] - x[j][2];
      r2 = dx * dx + dy * dy + dz * dz;
      if (r2) {
        tmp = tmp + m[k] / sqrt(r2);
      }
    }
    pe = pe - tmp * m[j];
  }
  for (int j = 1; j < nbod; j++) {
    dx = x[j][0] - x[0][0];
    dy = x[j][1] - x[0][1];
    dz = x[j][2] - x[0][2];
    r2 = dx * dx + dy * dy + dz * dz;
    if (r2) {
      pe -= m[0] * m[j] / sqrt(r2);
    }
  }
  if (jcen[0] != 0 || jcen[1] != 0 || jcen[2] != 0) {
    for (int j = 1; j < nbod; j++) {
      r2 = xh[j][0] * xh[j][0] + xh[j][1] * xh[j][1] + xh[j][2] * xh[j][2];
      r_1 = 1.0 / sqrt(r2);
      r_2 = r_1 * r_1;
      r_4 = r_2 * r_2;
      r_6 = r_4 * r_2;
      u2 = xh[j][2] * xh[j][2] * r_2;
      u4 = u2 * u2;
      u6 = u4 * u2;
      pe +=
          m[0] * m[j] * r_1 *
          (jcen[0] * r_2 * (1.5 * u2 - 0.5) +
           jcen[1] * r_4 * (4.375 * u4 - 3.75 * u2 + .375) +
           jcen[2] * r_6 * (14.4375 * u6 - 19.6875 * u4 + 6.5625 * u2 - .3125));
    }
  }
  _e = .50 * ke + pe;
  *e = _e;
  return sqrt(l[0] * l[0] + l[1] * l[1] + l[2] * l[2]);
}


x86 assembly (clang, -O0):
<cmxx_en>:
push   %rbp
mov    %rsp,%rbp
sub    $0x27270,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
lea    -0x50(%rbp),%rdi
xor    %esi,%esi
mov    $0x20,%edx
call   1030 <memset@plt>
lea    -0x70(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movl   $0x0,-0x27204(%rbp)
cmpl   $0x3,-0x27204(%rbp)
jge    1263 <cmxx_en+0x133>
movslq -0x27204(%rbp),%rax
lea    -0x1b660(%rbp),%rcx
imul   $0x18,%rax,%rax
add    %rax,%rcx
movslq -0x27204(%rbp),%rax
mov    %rcx,-0x27200(%rbp,%rax,8)
ff
mov    -0x27204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x27204(%rbp)
jmp    121e <cmxx_en+0xee>
movl   $0x0,-0x27224(%rbp)
cmpl   $0x3,-0x27224(%rbp)
jge    12b2 <cmxx_en+0x182>
movslq -0x27224(%rbp),%rax
lea    -0x271e0(%rbp),%rcx
imul   $0x18,%rax,%rax
add    %rax,%rcx
movslq -0x27224(%rbp),%rax
mov    %rcx,-0x27220(%rbp,%rax,8)
ff
mov    -0x27224(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x27224(%rbp)
jmp    126d <cmxx_en+0x13d>
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x27230(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0xc(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
lea    -0x27200(%rbp),%r8
lea    -0x27220(%rbp),%r9
call   1040 <cmco_h2b@plt>
movl   $0x0,-0x27234(%rbp)
mov    -0x27234(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1380 <cmxx_en+0x250>
mov    0x10(%rbp),%rax
movslq -0x27234(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x10(%rbp),%rax
movslq -0x27234(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x10(%rbp),%rax
movslq -0x27234(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x10(%rax),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x27234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x27234(%rbp)
jmp    1304 <cmxx_en+0x1d4>
movl   $0x0,-0x27238(%rbp)
mov    -0x27238(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1676 <cmxx_en+0x546>
mov    -0x18(%rbp),%rax
movslq -0x27238(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x27238(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm2
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm3
movslq -0x27238(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm1
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x27238(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x27238(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm2
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm3
movslq -0x27238(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm1
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mulsd  0x10(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x27238(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x27238(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm2
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm3
movslq -0x27238(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm1
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mulsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x27238(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm3
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm4
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm2
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mulsd  0x8(%rax),%xmm2
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm2
movslq -0x27238(%rbp),%rcx
lea    -0x271e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x27238(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x27238(%rbp)
jmp    138a <cmxx_en+0x25a>
movl   $0x1,-0x2723c(%rbp)
mov    -0x2723c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1895 <cmxx_en+0x765>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x27248(%rbp)
ff
mov    -0x2723c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2724c(%rbp)
mov    -0x2724c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    183a <cmxx_en+0x70a>
movslq -0x2724c(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movslq -0x2723c(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
movslq -0x2724c(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movslq -0x2723c(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movslq -0x2724c(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movslq -0x2723c(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17c9 <cmxx_en+0x699>
jp     17c9 <cmxx_en+0x699>
jmp    1821 <cmxx_en+0x6f1>
movsd  -0x27248(%rbp),%xmm0
ff
movsd  %xmm0,-0x27260(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2724c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x27268(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1050 <sqrt@plt>
movsd  -0x27268(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x27260(%rbp),%xmm0
ff
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x27248(%rbp)
ff
jmp    1826 <cmxx_en+0x6f6>
mov    -0x2724c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2724c(%rbp)
jmp    16a9 <cmxx_en+0x579>
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x27248(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2723c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x2723c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2723c(%rbp)
jmp    1680 <cmxx_en+0x550>
movl   $0x1,-0x27250(%rbp)
mov    -0x27250(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19f0 <cmxx_en+0x8c0>
movslq -0x27250(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
subsd  -0x1b660(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movslq -0x27250(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
subsd  -0x1b658(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movslq -0x27250(%rbp),%rcx
lea    -0x1b660(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
subsd  -0x1b650(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    198a <cmxx_en+0x85a>
jp     198a <cmxx_en+0x85a>
jmp    19d7 <cmxx_en+0x8a7>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x27250(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x27270(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1050 <sqrt@plt>
movsd  -0x27270(%rbp),%xmm1
ff
divsd  %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    19dc <cmxx_en+0x8ac>
mov    -0x27250(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x27250(%rbp)
jmp    189f <cmxx_en+0x76f>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1a48 <cmxx_en+0x918>
jp     1a48 <cmxx_en+0x918>
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1a48 <cmxx_en+0x918>
jp     1a48 <cmxx_en+0x918>
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1a48 <cmxx_en+0x918>
jp     1a48 <cmxx_en+0x918>
jmp    1d28 <cmxx_en+0xbf8>
movl   $0x1,-0x27254(%rbp)
mov    -0x27254(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1d23 <cmxx_en+0xbf3>
mov    -0x20(%rbp),%rax
movslq -0x27254(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x27254(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x27254(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x27254(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x27254(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x27254(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x549(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x27254(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x27254(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mulsd  0x10(%rax),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x27254(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm3
ff
movsd  0x43d(%rip),%xmm2
mulsd  %xmm2,%xmm3
movsd  0x439(%rip),%xmm2
addsd  %xmm2,%xmm3
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm4
ff
movsd  0x404(%rip),%xmm5
mulsd  -0xd0(%rbp),%xmm5
ff
movq   %xmm5,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm5
movsd  0x3d5(%rip),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
movsd  0x3bd(%rip),%xmm5
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm4
ff
movsd  0x384(%rip),%xmm3
mulsd  -0xd8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
movsd  0x355(%rip),%xmm5
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
movsd  -0xd0(%rbp),%xmm3
ff
movsd  0x335(%rip),%xmm5
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
movsd  0x31d(%rip),%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x27254(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x27254(%rbp)
jmp    1a52 <cmxx_en+0x922>
jmp    1d28 <cmxx_en+0xbf8>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  0x2c0(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x27230(%rbp)
ff
movsd  -0x27230(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
add    $0x27270,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cmxx_en>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x177d8,%rsp
mov    %r9,%rax
mov    %r8,%r14
mov    %rcx,%r12
mov    %esi,%r13d
mov    %rdi,%r15
lea    0xd0(%rsp),%rcx
mov    %rcx,0xb0(%rsp)
lea    0xe8(%rsp),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x100(%rsp),%rcx
mov    %rcx,0xc0(%rsp)
lea    0xbc50(%rsp),%rcx
mov    %rcx,0x90(%rsp)
lea    0xbc68(%rsp),%rcx
mov    %rcx,0x98(%rsp)
lea    0xbc80(%rsp),%rcx
mov    %rcx,0xa0(%rsp)
lea    0xb0(%rsp),%r8
lea    0x90(%rsp),%r9
mov    %esi,%edi
mov    %r12,%rsi
mov    %r14,%rdx
mov    %rax,%rcx
call   1030 <cmco_h2b@plt>
test   %r13d,%r13d
jle    11ef <cmxx_en+0xcf>
mov    0x17810(%rsp),%rcx
mov    %r13d,%ebx
lea    -0x1(%rbx),%rdx
mov    %ebx,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    1213 <cmxx_en+0xf3>
xorpd  %xmm9,%xmm9
xorpd  %xmm0,%xmm0
xor    %edx,%edx
jmp    128c <cmxx_en+0x16c>
xorpd  %xmm9,%xmm9
xor    %eax,%eax
xorpd  %xmm8,%xmm8
xorpd  %xmm0,%xmm0
movapd %xmm0,0x50(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
jmp    1654 <cmxx_en+0x534>
mov    %ebx,%esi
and    $0xfffffffc,%esi
xorpd  %xmm9,%xmm9
xorpd  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rcx,%rdx,8),%rdi
mov    0x8(%rcx,%rdx,8),%rbp
addsd  (%rdi),%xmm0
movapd %xmm0,%xmm2
movupd 0x8(%rdi),%xmm0
addpd  %xmm9,%xmm0
addsd  0x0(%rbp),%xmm2
movupd 0x8(%rbp),%xmm1
addpd  %xmm0,%xmm1
mov    0x10(%rcx,%rdx,8),%rdi
addsd  (%rdi),%xmm2
movupd 0x8(%rdi),%xmm0
addpd  %xmm1,%xmm0
mov    0x18(%rcx,%rdx,8),%rdi
addsd  (%rdi),%xmm2
movupd 0x8(%rdi),%xmm9
addpd  %xmm0,%xmm9
movapd %xmm2,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1230 <cmxx_en+0x110>
test   %rax,%rax
je     12c3 <cmxx_en+0x1a3>
lea    (%rcx,%rdx,8),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rcx,%rdx,8),%rsi
addsd  (%rsi),%xmm0
movapd %xmm0,%xmm1
movupd 0x8(%rsi),%xmm0
addpd  %xmm0,%xmm9
movapd %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    12a0 <cmxx_en+0x180>
xorpd  %xmm1,%xmm1
test   %r13d,%r13d
jle    153c <cmxx_en+0x41c>
movsd  %xmm1,(%rsp)
xorpd  %xmm8,%xmm8
unpcklpd %xmm0,%xmm8
lea    0x0(,%rbx,8),%rax
lea    (%rax,%rax,2),%rax
xor    %ecx,%ecx
movapd 0xd0a(%rip),%xmm10
mov    %r12,%rdx
nopl   0x0(%rax)
movapd %xmm9,%xmm1
movsd  0xe0(%rsp,%rcx,1),%xmm4
movapd %xmm4,%xmm0
xorpd  %xmm10,%xmm0
movupd 0xbc50(%rsp,%rcx,1),%xmm2
movapd %xmm2,%xmm5
unpckhpd %xmm2,%xmm5
mulsd  %xmm5,%xmm0
movupd 0xd0(%rsp,%rcx,1),%xmm6
movsd  0xbc60(%rsp,%rcx,1),%xmm3
movapd %xmm3,%xmm7
unpcklpd %xmm2,%xmm7
mulpd  %xmm6,%xmm7
unpcklpd %xmm6,%xmm4
mulpd  %xmm2,%xmm4
subpd  %xmm7,%xmm4
movsd  (%rdx),%xmm7
unpcklpd %xmm7,%xmm7
mulpd  %xmm7,%xmm4
movapd %xmm4,%xmm9
addpd  %xmm1,%xmm9
mulsd  %xmm5,%xmm5
mulsd  %xmm2,%xmm2
addsd  %xmm5,%xmm2
unpcklpd %xmm0,%xmm2
movsd  %xmm3,%xmm6
unpcklpd %xmm3,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm2,%xmm3
mulpd  %xmm7,%xmm3
addpd  %xmm3,%xmm8
add    $0x8,%rdx
add    $0x18,%rcx
cmp    %rcx,%rax
jne    1300 <cmxx_en+0x1e0>
addpd  %xmm1,%xmm4
movapd %xmm8,%xmm0
unpckhpd %xmm8,%xmm0
movapd %xmm0,0x50(%rsp)
cmp    $0x2,%r13d
jl     1553 <cmxx_en+0x433>
mov    %r13d,0xc(%rsp)
mov    %r15,0x30(%rsp)
mov    %r14,0x38(%rsp)
lea    0x110(%rsp),%r14
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
mov    %rbx,%rbp
mov    %r12,%r15
xorpd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
movapd %xmm4,0x80(%rsp)
mov    %r12,0x68(%rsp)
mov    %rbx,0x40(%rsp)
jmp    1450 <cmxx_en+0x330>
nopl   0x0(%rax,%rax,1)
mov    0x68(%rsp),%r12
mov    0x48(%rsp),%rax
mulsd  (%r12,%rax,8),%xmm5
movsd  (%rsp),%xmm0
subsd  %xmm5,%xmm0
movsd  %xmm0,(%rsp)
add    $0x8,%r15
add    $0x18,%r14
add    $0xffffffffffffffff,%rbp
mov    0x70(%rsp),%rcx
mov    %rcx,%rax
mov    0x40(%rsp),%rbx
cmp    %rbx,%rcx
je     155a <cmxx_en+0x43a>
mov    %rax,%rcx
mov    %rax,0x48(%rsp)
add    $0x1,%rax
xorpd  %xmm5,%xmm5
mov    %rax,0x70(%rsp)
cmp    %rbx,%rax
jae    1410 <cmxx_en+0x2f0>
mov    0x48(%rsp),%rax
lea    (%rax,%rax,2),%rax
lea    (%rsp,%rax,8),%r13
add    $0xd0,%r13
xorpd  %xmm5,%xmm5
mov    $0x2,%r12d
mov    %r14,%rbx
movapd %xmm8,0x10(%rsp)
jmp    14ea <cmxx_en+0x3ca>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm5,0x20(%rsp)
movsd  %xmm1,0x78(%rsp)
call   1040 <sqrt@plt>
movsd  0x78(%rsp),%xmm1
movsd  0x20(%rsp),%xmm5
xorpd  %xmm3,%xmm3
movapd 0x80(%rsp),%xmm4
movapd 0x10(%rsp),%xmm8
divsd  %xmm0,%xmm1
addsd  %xmm1,%xmm5
add    $0x1,%r12
add    $0x18,%rbx
cmp    %r12,%rbp
je     1410 <cmxx_en+0x2f0>
movsd  -0x10(%rbx),%xmm1
movsd  -0x8(%rbx),%xmm2
subsd  0x0(%r13),%xmm1
subsd  0x8(%r13),%xmm2
movsd  (%rbx),%xmm0
subsd  0x10(%r13),%xmm0
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm3,%xmm0
jne    1526 <cmxx_en+0x406>
jnp    14d9 <cmxx_en+0x3b9>
movsd  (%r15,%r12,8),%xmm1
ucomisd %xmm3,%xmm0
jb     14a0 <cmxx_en+0x380>
sqrtsd %xmm0,%xmm0
jmp    14d1 <cmxx_en+0x3b1>
movsd  %xmm1,(%rsp)
movapd %xmm0,0x50(%rsp)
xor    %eax,%eax
xorpd  %xmm8,%xmm8
jmp    1654 <cmxx_en+0x534>
xor    %eax,%eax
jmp    164f <cmxx_en+0x52f>
mov    0xc(%rsp),%r13d
cmp    $0x2,%r13d
jl     163a <cmxx_en+0x51a>
lea    0xf8(%rsp),%rbx
mov    $0x1,%ebp
xorpd  %xmm3,%xmm3
mov    0x38(%rsp),%r14
mov    0x30(%rsp),%r15
movapd %xmm8,0x10(%rsp)
jmp    15d6 <cmxx_en+0x4b6>
nopl   (%rax)
movsd  %xmm1,0x20(%rsp)
call   1040 <sqrt@plt>
movsd  0x20(%rsp),%xmm1
xorpd  %xmm3,%xmm3
movapd 0x80(%rsp),%xmm4
movapd 0x10(%rsp),%xmm8
divsd  %xmm0,%xmm1
movsd  (%rsp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
add    $0x1,%rbp
add    $0x18,%rbx
cmp    %rbp,0x40(%rsp)
je     164d <cmxx_en+0x52d>
movsd  -0x10(%rbx),%xmm1
movsd  -0x8(%rbx),%xmm2
subsd  0xd0(%rsp),%xmm1
subsd  0xd8(%rsp),%xmm2
movsd  (%rbx),%xmm0
subsd  0xe0(%rsp),%xmm0
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm3,%xmm0
jne    161b <cmxx_en+0x4fb>
jnp    15c7 <cmxx_en+0x4a7>
movsd  (%r12),%xmm1
mulsd  (%r12,%rbp,8),%xmm1
ucomisd %xmm3,%xmm0
jb     1590 <cmxx_en+0x470>
sqrtsd %xmm0,%xmm0
jmp    15b5 <cmxx_en+0x495>
xor    %eax,%eax
movapd %xmm4,%xmm9
mov    0x38(%rsp),%r14
mov    0x30(%rsp),%r15
jmp    1654 <cmxx_en+0x534>
mov    $0x1,%al
movapd %xmm4,%xmm9
movsd  (%r15),%xmm0
ucomisd 0xa07(%rip),%xmm0
jne    167b <cmxx_en+0x55b>
jp     167b <cmxx_en+0x55b>
movsd  0x8(%r15),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jne    167b <cmxx_en+0x55b>
jnp    1845 <cmxx_en+0x725>
test   %al,%al
je     185b <cmxx_en+0x73b>
cmp    $0x3,%r13d
mov    $0x2,%ebp
cmovge %r13d,%ebp
mov    $0x1,%ebx
xorpd  %xmm10,%xmm10
movsd  0x96d(%rip),%xmm11
movsd  0x96c(%rip),%xmm12
movsd  0x96b(%rip),%xmm13
movsd  0x96a(%rip),%xmm14
movsd  0x969(%rip),%xmm15
movapd %xmm8,0x10(%rsp)
movapd %xmm9,0x20(%rsp)
jmp    180b <cmxx_en+0x6eb>
nopw   0x0(%rax,%rax,1)
call   1040 <sqrt@plt>
movsd  0x942(%rip),%xmm15
movsd  0x931(%rip),%xmm14
movsd  0x920(%rip),%xmm13
movsd  0x90f(%rip),%xmm12
movsd  0x8fe(%rip),%xmm11
xorpd  %xmm10,%xmm10
movapd 0x20(%rsp),%xmm9
movapd 0x10(%rsp),%xmm8
movapd %xmm11,%xmm1
divsd  %xmm0,%xmm1
movsd  (%r12),%xmm0
mulsd  (%r12,%rbx,8),%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm1,%xmm3
mulsd  %xmm1,%xmm3
movapd %xmm3,%xmm4
movapd %xmm3,%xmm2
mov    (%r14,%rbx,8),%rax
movsd  0x10(%rax),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm1,%xmm5
mulsd  %xmm1,%xmm5
mulsd  (%r15),%xmm3
movapd %xmm1,%xmm6
mulsd  %xmm12,%xmm6
addsd  %xmm13,%xmm6
mulsd  %xmm3,%xmm6
movapd %xmm1,%xmm3
mulsd  %xmm14,%xmm3
movapd %xmm5,%xmm7
mulsd  %xmm15,%xmm7
addsd  %xmm3,%xmm7
mulsd  %xmm4,%xmm4
mulsd  %xmm4,%xmm2
mulsd  0x8(%r15),%xmm4
addsd  0x88e(%rip),%xmm7
mulsd  %xmm4,%xmm7
addsd  %xmm6,%xmm7
movapd %xmm1,%xmm3
mulsd  %xmm5,%xmm3
mulsd  0x87e(%rip),%xmm5
mulsd  0x87e(%rip),%xmm3
addsd  %xmm5,%xmm3
mulsd  0x10(%r15),%xmm2
mulsd  0x874(%rip),%xmm1
addsd  %xmm3,%xmm1
addsd  0x870(%rip),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm7,%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
add    $0x1,%rbx
cmp    %rbx,%rbp
je     185b <cmxx_en+0x73b>
mov    (%r14,%rbx,8),%rax
movsd  (%rax),%xmm1
movsd  0x8(%rax),%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%rax),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm10,%xmm0
jb     16e0 <cmxx_en+0x5c0>
sqrtsd %xmm0,%xmm0
jmp    1725 <cmxx_en+0x605>
ucomisd 0x10(%r15),%xmm0
setp   %cl
setne  %dl
or     %cl,%dl
test   %al,%dl
jne    1683 <cmxx_en+0x563>
mulsd  0x7fc(%rip),%xmm8
addsd  (%rsp),%xmm8
mov    0x17818(%rsp),%rax
movsd  %xmm8,(%rax)
movapd %xmm9,%xmm0
mulsd  %xmm9,%xmm0
movapd 0x50(%rsp),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
unpckhpd %xmm9,%xmm9
mulsd  %xmm9,%xmm9
addsd  %xmm1,%xmm9
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm9
jb     18b3 <cmxx_en+0x793>
xorps  %xmm0,%xmm0
sqrtsd %xmm9,%xmm0
jmp    18bd <cmxx_en+0x79d>
movapd %xmm9,%xmm0
call   1040 <sqrt@plt>
add    $0x177d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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