#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 */
typedef size_t m;
typedef int j;
typedef size_t i;

/* Variables and functions */
scalar_t__ fabs(double);
void cbal(int nm, int n, double *ar, double *ai, int *low, int *igh,
          double *scale) {
  int i, j, k, l, m, jj, iexc;
  double c, f, g, r, s, b2, radix;
  int noconv;
  radix = 16.0;
  b2 = radix * radix;
  k = 1;
  l = n;
  goto L100;
L20:
  scale[(m)-1] = j;
  if (j != m) {
    for (i = 1; i <= l; i++) {
      f = ar[(i)-1 + ((j)-1) * (nm)];
      ar[(i)-1 + ((j)-1) * (nm)] = ar[(i)-1 + ((m)-1) * (nm)];
      ar[(i)-1 + ((m)-1) * (nm)] = f;
      f = ai[(i)-1 + ((j)-1) * (nm)];
      ai[(i)-1 + ((j)-1) * (nm)] = ai[(i)-1 + ((m)-1) * (nm)];
      ai[(i)-1 + ((m)-1) * (nm)] = f;
    }
    for (i = k; i <= n; i++) {
      f = ar[(j)-1 + ((i)-1) * (nm)];
      ar[(j)-1 + ((i)-1) * (nm)] = ar[(m)-1 + ((i)-1) * (nm)];
      ar[(m)-1 + ((i)-1) * (nm)] = f;
      f = ai[(j)-1 + ((i)-1) * (nm)];
      ai[(j)-1 + ((i)-1) * (nm)] = ai[(m)-1 + ((i)-1) * (nm)];
      ai[(m)-1 + ((i)-1) * (nm)] = f;
    }
  }
  if (iexc == 2) {
    k++;
    goto L130;
  }
  if (l == 1)
    goto L280;
  l--;
L100:
  for (jj = 1; jj <= l; jj++) {
    int test = 0;
    j = l + 1 - jj;
    for (i = 1; i <= l; i++) {
      if (i == j)
        continue;
      if (ar[(j)-1 + ((i)-1) * (nm)] != 0.0 ||
          ai[(j)-1 + ((i)-1) * (nm)] != 0.0) {
        test = 1;
        break;
      }
    }
    if (!test) {
      m = l;
      iexc = 1;
      goto L20;
    }
  }
L130:
  for (j = k; j <= l; j++) {
    int test = 0;
    for (i = k; i <= l; i++) {
      if (i == j)
        continue;
      if (ar[(i)-1 + ((j)-1) * (nm)] != 0.0 ||
          ai[(i)-1 + ((j)-1) * (nm)] != 0.0) {
        test = 1;
        break;
      }
    }
    if (!test) {
      m = k;
      iexc = 2;
      goto L20;
    }
  }
  for (i = k; i <= l; i++)
    scale[(i)-1] = 1.0;
  do {
    noconv = 0;
    for (i = k; i <= l; i++) {
      c = 0.0;
      r = 0.0;
      for (j = k; j <= l; j++) {
        if (j == i)
          continue;
        c +=
            fabs(ar[(j)-1 + ((i)-1) * (nm)]) + fabs(ai[(j)-1 + ((i)-1) * (nm)]);
        r +=
            fabs(ar[(i)-1 + ((j)-1) * (nm)]) + fabs(ai[(i)-1 + ((j)-1) * (nm)]);
      }
      if (c == 0.0 || r == 0.0)
        continue;
      g = r / radix;
      f = 1.0;
      s = c + r;
      while (c < g) {
        f *= radix;
        c *= b2;
      }
      g = r * radix;
      while (c >= g) {
        f /= radix;
        c /= b2;
      }
      if ((c + r) / f >= 0.95 * s)
        continue;
      g = 1.0 / f;
      scale[(i)-1] *= f;
      noconv = 1;
      for (j = k; j <= n; j++) {
        ar[(i)-1 + ((j)-1) * (nm)] *= g;
        ai[(i)-1 + ((j)-1) * (nm)] *= g;
      }
      for (j = 1; j <= l; j++) {
        ar[(j)-1 + ((i)-1) * (nm)] *= f;
        ai[(j)-1 + ((i)-1) * (nm)] *= f;
      }
    }
  } while (noconv);
L280:
  *low = k;
  *igh = l;
}


x86 assembly (clang, -O0):
<cbal>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  0xec3(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1404 <cbal+0x2f4>
cvtsi2sdl -0x30(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     13d4 <cbal+0x2c4>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     12ab <cbal+0x19b>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    118d <cbal+0x7d>
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     13cf <cbal+0x2bf>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12b1 <cbal+0x1a1>
jmp    13d4 <cbal+0x2c4>
cmpl   $0x2,-0x44(%rbp)
jne    13ec <cbal+0x2dc>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1511 <cbal+0x401>
cmpl   $0x1,-0x38(%rbp)
jne    13fb <cbal+0x2eb>
jmp    19cd <cbal+0x8bd>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     150c <cbal+0x3fc>
movl   $0x0,-0x88(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     14da <cbal+0x3ca>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    1451 <cbal+0x341>
jmp    14cc <cbal+0x3bc>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14b8 <cbal+0x3a8>
jp     14b8 <cbal+0x3a8>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14b8 <cbal+0x3a8>
jp     14b8 <cbal+0x3a8>
jmp    14c7 <cbal+0x3b7>
movl   $0x1,-0x88(%rbp)
jmp    14da <cbal+0x3ca>
jmp    14cc <cbal+0x3bc>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1434 <cbal+0x324>
cmpl   $0x0,-0x88(%rbp)
jne    14f9 <cbal+0x3e9>
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x44(%rbp)
jmp    1163 <cbal+0x53>
jmp    14fe <cbal+0x3ee>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    140b <cbal+0x2fb>
jmp    1511 <cbal+0x401>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     160b <cbal+0x4fb>
movl   $0x0,-0x8c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     15d9 <cbal+0x4c9>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    1550 <cbal+0x440>
jmp    15cb <cbal+0x4bb>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15b7 <cbal+0x4a7>
jp     15b7 <cbal+0x4a7>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15b7 <cbal+0x4a7>
jp     15b7 <cbal+0x4a7>
jmp    15c6 <cbal+0x4b6>
movl   $0x1,-0x8c(%rbp)
jmp    15d9 <cbal+0x4c9>
jmp    15cb <cbal+0x4bb>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1533 <cbal+0x423>
cmpl   $0x0,-0x8c(%rbp)
jne    15f8 <cbal+0x4e8>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x2,-0x44(%rbp)
jmp    1163 <cbal+0x53>
jmp    15fd <cbal+0x4ed>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1517 <cbal+0x407>
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1645 <cbal+0x535>
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x9d6(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1611 <cbal+0x501>
jmp    164a <cbal+0x53a>
movl   $0x0,-0x84(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     19b6 <cbal+0x8a6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1779 <cbal+0x669>
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    1699 <cbal+0x589>
jmp    176b <cbal+0x65b>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0xa0(%rbp),%rax
add    %rcx,%rax
cvtsi2sd %rax,%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,-0x98(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0x98(%rbp),%rax
add    %rcx,%rax
cvtsi2sd %rax,%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    167c <cbal+0x56c>
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1796 <cbal+0x686>
jp     1796 <cbal+0x686>
jmp    17ae <cbal+0x69e>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17b3 <cbal+0x6a3>
jp     17b3 <cbal+0x6a3>
jmp    19a8 <cbal+0x898>
movsd  -0x68(%rbp),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x83e(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1815 <cbal+0x705>
movsd  -0x80(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    17de <cbal+0x6ce>
movsd  -0x68(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
ucomisd -0x60(%rbp),%xmm0
jb     185f <cbal+0x74f>
movsd  -0x80(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1824 <cbal+0x714>
movsd  -0x50(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  0x79a(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jb     188a <cbal+0x77a>
jmp    19a8 <cbal+0x898>
movsd  0x776(%rip),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x84(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1932 <cbal+0x822>
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    18c8 <cbal+0x7b8>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     19a3 <cbal+0x893>
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1939 <cbal+0x829>
jmp    19a8 <cbal+0x898>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    165a <cbal+0x54a>
jmp    19bb <cbal+0x8ab>
cmpl   $0x0,-0x84(%rbp)
jne    164a <cbal+0x53a>
jmp    19cd <cbal+0x8bd>
mov    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x38(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cbal>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
mov    %r9,0x160(%rsp)
mov    %r8,0x158(%rsp)
mov    %rcx,%r12
mov    %rdx,%r13
mov    %edi,0x8(%rsp)
movslq %edi,%rax
mov    %rax,0xe0(%rsp)
lea    0x1(%rsi),%ecx
mov    %rsi,0x78(%rsp)
movslq %esi,%r14
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x68(%rsp)
lea    -0x10(%r13),%rdx
mov    %rdx,0xc0(%rsp)
lea    -0x8(%r12),%rdx
mov    %rdx,0x28(%rsp)
mov    %rax,%rdx
shl    $0x4,%rdx
mov    %rdx,0xa0(%rsp)
xorpd  %xmm0,%xmm0
lea    -0x10(%r12),%rdx
mov    %rdx,0xb8(%rsp)
lea    -0x1(%r14),%ebx
lea    0x0(,%rax,8),%r15
lea    0x10(%r12),%rax
mov    %rax,0xb0(%rsp)
lea    0x10(%r13),%rax
mov    %rax,0xa8(%rsp)
mov    $0x1,%r11d
mov    %ecx,0x74(%rsp)
mov    %ecx,%eax
mov    %r12,0x40(%rsp)
mov    %r13,0x10(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %eax,%eax
lea    -0x3(%rax),%rdx
mov    %rdx,0x88(%rsp)
shr    %rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0x98(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x38(%rsp)
mov    %rax,0x60(%rsp)
add    $0xffffffffffffffff,%rax
mov    %rax,0x90(%rsp)
test   %r14,%r14
mov    %r14,0x18(%rsp)
mov    %ebx,0xc8(%rsp)
jle    15ed <cbal+0x4dd>
lea    0x1(%r14),%r8d
mov    $0x1,%edx
mov    %r14d,%esi
mov    %esi,%esi
movslq %ebx,%rcx
shl    $0x3,%rcx
mov    %r8d,%r9d
sub    %edx,%r9d
mov    $0x1,%eax
jmp    1260 <cbal+0x150>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    %r15,%rcx
xor    %edi,%edi
cmp    %rax,0x60(%rsp)
je     12a0 <cbal+0x190>
cmp    %rax,%rsi
je     1250 <cbal+0x140>
movsd  0x0(%r13,%rcx,1),%xmm1
ucomisd %xmm0,%xmm1
jne    1282 <cbal+0x172>
jp     1282 <cbal+0x172>
movsd  (%r12,%rcx,1),%xmm1
ucomisd %xmm0,%xmm1
jne    1282 <cbal+0x172>
jnp    1250 <cbal+0x140>
add    $0x1,%rdx
add    $0xffffffff,%esi
add    $0xffffffff,%ebx
cmp    0x60(%rsp),%rdx
jne    122b <cbal+0x11b>
jmp    15ed <cbal+0x4dd>
nopl   0x0(%rax,%rax,1)
mov    %r14d,%eax
jmp    12b6 <cbal+0x1a6>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x1,%dil
mov    %eax,%r11d
xorps  %xmm1,%xmm1
cvtsi2sd %r9d,%xmm1
cltq
lea    -0x1(%rax),%r8
mov    0x1f0(%rsp),%rcx
movsd  %xmm1,-0x8(%rcx,%rax,8)
cmp    %eax,%r9d
je     15e0 <cbal+0x4d0>
mov    %r11d,0x58(%rsp)
test   %r14,%r14
jle    1371 <cbal+0x261>
lea    -0x1(%r9),%eax
mov    0x8(%rsp),%edx
imul   %edx,%eax
mov    %r8d,%ecx
imul   %edx,%ecx
movslq %ecx,%rbp
movslq %eax,%rbx
mov    $0x1,%r11d
cmpq   $0x2,0x90(%rsp)
jae    16b0 <cbal+0x5a0>
add    %r11,%rbx
mov    0x68(%rsp),%rdx
lea    (%rdx,%rbx,8),%rax
mov    0x28(%rsp),%rsi
lea    (%rsi,%rbx,8),%rcx
add    %r11,%rbp
lea    (%rdx,%rbp,8),%rdx
lea    (%rsi,%rbp,8),%rsi
mov    0x60(%rsp),%rbp
sub    %r11,%rbp
xor    %ebx,%ebx
nop
movsd  (%rax,%rbx,8),%xmm1
movsd  (%rdx,%rbx,8),%xmm2
movsd  %xmm2,(%rax,%rbx,8)
movsd  %xmm1,(%rdx,%rbx,8)
movsd  (%rcx,%rbx,8),%xmm1
movsd  (%rsi,%rbx,8),%xmm2
movsd  %xmm2,(%rcx,%rbx,8)
movsd  %xmm1,(%rsi,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1340 <cbal+0x230>
mov    0x58(%rsp),%r11d
cmp    0x78(%rsp),%r11d
jg     15e0 <cbal+0x4d0>
add    $0xffffffff,%r9d
movslq %r11d,%rdx
movslq %r9d,%r9
mov    0x78(%rsp),%rax
sub    %r11d,%eax
lea    0x1(%rax),%rcx
test   %eax,%eax
je     1570 <cbal+0x460>
cmpl   $0x1,0x8(%rsp)
jne    1570 <cbal+0x460>
mov    %rcx,0x30(%rsp)
mov    %r9,(%rsp)
lea    (%rdx,%r9,1),%rcx
mov    0x68(%rsp),%r10
mov    %r8,%rsi
lea    (%r10,%rcx,8),%r8
lea    (%rcx,%rax,1),%rbp
lea    0x0(%r13,%rbp,8),%r11
mov    %rsi,0x20(%rsp)
lea    (%rsi,%rdx,1),%rbx
mov    0xc0(%rsp),%rsi
lea    0x8(%rsi,%rbx,8),%r9
lea    0x1(%rax,%rbx,1),%r13
lea    (%r10,%r13,8),%r14
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%r10
lea    (%r12,%rbp,8),%r12
cmp    %r14,%r8
setb   0x80(%rsp)
cmp    %r11,%r9
setb   0x4c(%rsp)
cmp    %r12,%r8
setb   %cl
cmp    %r11,%r10
setb   %sil
and    %cl,%sil
lea    (%rax,%r13,8),%rax
cmp    %rax,%r8
mov    0xb8(%rsp),%rcx
lea    0x8(%rcx,%rbx,8),%rbp
setb   %cl
cmp    %r11,%rbp
setb   %r13b
and    %cl,%r13b
cmp    %r12,%r9
setb   %bl
mov    %r10,%rcx
cmp    %r14,%r10
setb   %r10b
and    %bl,%r10b
cmp    %rax,%r9
setb   %r8b
cmp    %r14,%rbp
setb   %bl
and    %r8b,%bl
cmp    %rax,%rcx
setb   %r8b
cmp    %r12,%rbp
setb   %al
and    %r8b,%al
mov    0x4c(%rsp),%cl
test   %cl,0x80(%rsp)
jne    1929 <cbal+0x819>
test   %sil,%sil
mov    0x40(%rsp),%r12
mov    0x58(%rsp),%r11d
mov    0x20(%rsp),%r8
mov    (%rsp),%r9
jne    18d3 <cbal+0x7c3>
test   %r13b,%r13b
jne    18d3 <cbal+0x7c3>
test   %r10b,%r10b
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%r13
jne    1570 <cbal+0x460>
test   %bl,%bl
jne    1570 <cbal+0x460>
test   %al,%al
jne    1570 <cbal+0x460>
mov    0x30(%rsp),%r11
movabs $0x1fffffffe,%rax
and    %rax,%r11
lea    (%r11,%rdx,1),%r10
mov    0x28(%rsp),%rax
lea    (%rax,%r8,8),%rsi
add    $0x8,%rsi
add    $0xffffffffffffffff,%rdx
imul   %r15,%rdx
mov    0x68(%rsp),%rax
lea    (%rax,%r8,8),%rax
add    $0x8,%rax
lea    (%r12,%r9,8),%rbp
lea    0x0(,%r9,8),%rbx
add    %r13,%rbx
mov    %r11,%rcx
mov    0xa0(%rsp),%r8
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rdx,1),%xmm1
movups (%rax,%rdx,1),%xmm2
movups %xmm2,(%rbx,%rdx,1)
movups %xmm1,(%rax,%rdx,1)
movupd 0x0(%rbp,%rdx,1),%xmm1
movupd (%rsi,%rdx,1),%xmm2
movupd %xmm2,0x0(%rbp,%rdx,1)
movupd %xmm1,(%rsi,%rdx,1)
add    %r8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1520 <cbal+0x410>
cmp    %r11,0x30(%rsp)
mov    0x58(%rsp),%r11d
mov    0x20(%rsp),%r8
jne    1573 <cbal+0x463>
jmp    15e0 <cbal+0x4d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdx,%r10
mov    0x68(%rsp),%rax
lea    (%rax,%r8,8),%rcx
add    $0x8,%rcx
lea    -0x1(%r10),%rdx
imul   %r15,%rdx
mov    0x28(%rsp),%rax
lea    (%rax,%r8,8),%rsi
add    $0x8,%rsi
lea    0x0(,%r9,8),%rax
add    %r13,%rax
lea    (%r12,%r9,8),%rbx
mov    0x74(%rsp),%ebp
sub    %r10d,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,1),%xmm1
movsd  (%rcx,%rdx,1),%xmm2
movsd  %xmm2,(%rax,%rdx,1)
movsd  %xmm1,(%rcx,%rdx,1)
movsd  (%rbx,%rdx,1),%xmm1
movsd  (%rsi,%rdx,1),%xmm2
movsd  %xmm2,(%rbx,%rdx,1)
movsd  %xmm1,(%rsi,%rdx,1)
add    %r15,%rdx
add    $0xffffffff,%ebp
jne    15b0 <cbal+0x4a0>
test   %dil,%dil
je     1680 <cbal+0x570>
add    $0x1,%r11d
mov    %r11d,%eax
movslq %r11d,%rdx
mov    %rdx,%rcx
mov    %rdx,(%rsp)
cmp    %rdx,%r14
jl     194e <cbal+0x83e>
mov    (%rsp),%r9
lea    -0x1(%r9),%r8
lea    -0x1(%r9),%ecx
imul   0x8(%rsp),%ecx
add    %r9d,%ecx
add    $0xffffffff,%ecx
xor    %ebx,%ebx
mov    %ecx,%esi
mov    %r8,%rdi
mov    %rbx,%rdx
jmp    1640 <cbal+0x530>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x1,%esi
cmp    %r14,%rdi
jge    12b0 <cbal+0x1a0>
sub    $0x1,%rdx
jb     1630 <cbal+0x520>
movslq %esi,%rbp
movsd  0x0(%r13,%rbp,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1666 <cbal+0x556>
jp     1666 <cbal+0x556>
movsd  (%r12,%rbp,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1666 <cbal+0x556>
jnp    1630 <cbal+0x520>
lea    0x1(%r9),%rdx
add    $0x1,%rbx
add    0x8(%rsp),%ecx
cmp    %r14,%r9
mov    %rdx,%r9
jl     161c <cbal+0x50c>
jmp    194e <cbal+0x83e>
nop
cmp    $0x1,%r14
je     2442 <cbal+0x1332>
add    $0xffffffffffffffff,%r14
mov    0x60(%rsp),%rax
add    $0xffffffff,%eax
mov    0xc8(%rsp),%ebx
add    $0xffffffff,%ebx
jmp    11d0 <cbal+0xc0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r8,0x20(%rsp)
lea    0x0(,%rbx,8),%rax
add    %r13,%rax
mov    0x60(%rsp),%rsi
lea    (%rbx,%rsi,1),%r10
mov    0x68(%rsp),%rcx
lea    (%rcx,%r10,8),%rdx
lea    0x0(%r13,%rbp,8),%r8
lea    0x0(%rbp,%rsi,1),%r13
lea    (%rcx,%r13,8),%r14
mov    %rbx,(%rsp)
lea    (%r12,%rbx,8),%r11
mov    0x28(%rsp),%rcx
lea    (%rcx,%r10,8),%rsi
lea    (%rcx,%r13,8),%rcx
cmp    %r14,%rax
setb   0x80(%rsp)
cmp    %rdx,%r8
mov    %r12,%r10
setb   %r12b
cmp    %rsi,%rax
setb   %bl
cmp    %rdx,%r11
setb   %r13b
and    %bl,%r13b
cmp    %rcx,%rax
mov    %rbp,0x30(%rsp)
lea    (%r10,%rbp,8),%r10
setb   %al
cmp    %rdx,%r10
setb   %bl
and    %al,%bl
cmp    %rsi,%r8
setb   %dl
cmp    %r14,%r11
setb   %al
and    %dl,%al
cmp    %rcx,%r8
setb   %r8b
cmp    %r14,%r10
setb   %dl
and    %r8b,%dl
cmp    %rcx,%r11
setb   %r8b
cmp    %rsi,%r10
setb   %cl
and    %r8b,%cl
test   %r12b,0x80(%rsp)
jne    18ee <cbal+0x7de>
test   %r13b,%r13b
mov    0x40(%rsp),%r12
mov    0x20(%rsp),%r8
mov    0x30(%rsp),%rbp
mov    $0x1,%r11d
jne    1916 <cbal+0x806>
test   %bl,%bl
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%r13
jne    18e5 <cbal+0x7d5>
test   %al,%al
mov    (%rsp),%rbx
jne    1315 <cbal+0x205>
test   %dl,%dl
jne    1315 <cbal+0x205>
test   %cl,%cl
jne    1315 <cbal+0x205>
mov    0x90(%rsp),%rcx
mov    %rcx,%r10
and    $0xfffffffffffffffe,%r10
mov    %rcx,%r11
or     $0x1,%r11
mov    $0x0,%edx
cmpq   $0x2,0x88(%rsp)
jb     186c <cbal+0x75c>
mov    0xb0(%rsp),%rdx
mov    (%rsp),%rsi
lea    (%rdx,%rsi,8),%rcx
mov    0xa8(%rsp),%rax
lea    (%rax,%rsi,8),%rsi
lea    (%rdx,%rbp,8),%rbx
lea    (%rax,%rbp,8),%r13
mov    0x38(%rsp),%r12
xor    %edx,%edx
xchg   %ax,%ax
movups -0x10(%rsi,%rdx,8),%xmm1
movups -0x10(%r13,%rdx,8),%xmm2
movups %xmm2,-0x10(%rsi,%rdx,8)
movups %xmm1,-0x10(%r13,%rdx,8)
movups -0x10(%rcx,%rdx,8),%xmm1
movups -0x10(%rbx,%rdx,8),%xmm2
movups %xmm2,-0x10(%rcx,%rdx,8)
movups %xmm1,-0x10(%rbx,%rdx,8)
movups (%rsi,%rdx,8),%xmm1
movups 0x0(%r13,%rdx,8),%xmm2
movups %xmm2,(%rsi,%rdx,8)
movups %xmm1,0x0(%r13,%rdx,8)
movupd (%rcx,%rdx,8),%xmm1
movupd (%rbx,%rdx,8),%xmm2
movupd %xmm2,(%rcx,%rdx,8)
movupd %xmm1,(%rbx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%r12
jne    1810 <cbal+0x700>
testb  $0x1,0x98(%rsp)
01
mov    0x40(%rsp),%r12
mov    0x10(%rsp),%r13
mov    (%rsp),%rbx
je     18bb <cbal+0x7ab>
lea    (%rdx,%rbx,1),%rcx
movups 0x0(%r13,%rcx,8),%xmm1
add    %rbp,%rdx
movups 0x0(%r13,%rdx,8),%xmm2
movups %xmm2,0x0(%r13,%rcx,8)
movups %xmm1,0x0(%r13,%rdx,8)
movupd (%r12,%rcx,8),%xmm1
movupd (%r12,%rdx,8),%xmm2
movupd %xmm2,(%r12,%rcx,8)
movupd %xmm1,(%r12,%rdx,8)
cmp    %r10,0x90(%rsp)
mov    0x18(%rsp),%r14
jne    1315 <cbal+0x205>
jmp    1371 <cbal+0x261>
mov    %rdx,%r10
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%r13
jmp    1573 <cbal+0x463>
mov    (%rsp),%rbx
jmp    1315 <cbal+0x205>
mov    0x18(%rsp),%r14
mov    0x40(%rsp),%r12
mov    0x10(%rsp),%r13
mov    0x20(%rsp),%r8
mov    0x30(%rsp),%rbp
mov    $0x1,%r11d
mov    (%rsp),%rbx
jmp    1315 <cbal+0x205>
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%r13
mov    (%rsp),%rbx
jmp    1315 <cbal+0x205>
mov    %rdx,%r10
mov    0x18(%rsp),%r14
mov    0x40(%rsp),%r12
mov    0x10(%rsp),%r13
mov    0x58(%rsp),%r11d
mov    0x20(%rsp),%r8
mov    (%rsp),%r9
jmp    1573 <cbal+0x463>
lea    0x1(%r14),%ecx
mov    %ecx,0x4c(%rsp)
mov    %rax,0x50(%rsp)
cmp    %r14d,%eax
mov    0xe0(%rsp),%r8
jg     1adc <cbal+0x9cc>
mov    %r14d,%edx
sub    0x50(%rsp),%edx
lea    0x1(%rdx),%r9
mov    (%rsp),%rax
cmp    $0x3,%edx
jb     1aa9 <cbal+0x999>
movabs $0x1fffffffe,%rax
lea    -0x2(%rax),%rdx
and    %r9,%rdx
mov    (%rsp),%rax
add    %rdx,%rax
lea    -0x4(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
xor    %ebp,%ebp
cmp    $0xc,%rdi
jb     1a39 <cbal+0x929>
mov    0x50(%rsp),%rcx
movslq %ecx,%rdi
mov    0x1f0(%rsp),%rbp
lea    0x68(,%rdi,8),%rdi
add    %rbp,%rdi
mov    %r14d,%ebx
sub    %ecx,%ebx
add    $0x1,%rbx
and    $0xfffffffffffffffc,%rbx
add    $0xfffffffffffffffc,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffc,%rbx
xor    %ebp,%ebp
movapd 0x1607(%rip),%xmm0
nopl   0x0(%rax)
movupd %xmm0,-0x70(%rdi,%rbp,8)
movupd %xmm0,-0x60(%rdi,%rbp,8)
movupd %xmm0,-0x50(%rdi,%rbp,8)
movupd %xmm0,-0x40(%rdi,%rbp,8)
movupd %xmm0,-0x30(%rdi,%rbp,8)
movupd %xmm0,-0x20(%rdi,%rbp,8)
movupd %xmm0,-0x10(%rdi,%rbp,8)
movupd %xmm0,(%rdi,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rbx
jne    1a00 <cbal+0x8f0>
test   $0x3,%sil
je     1aa4 <cbal+0x994>
mov    0x50(%rsp),%rcx
movslq %ecx,%rsi
add    %rsi,%rbp
mov    0x1f0(%rsp),%rsi
lea    (%rsi,%rbp,8),%rsi
add    $0x8,%rsi
mov    %r14d,%edi
sub    %ecx,%edi
add    $0x1,%dil
and    $0xc,%dil
add    $0xfc,%dil
shr    $0x2,%dil
add    $0x1,%dil
movzbl %dil,%edi
and    $0x3,%edi
shl    $0x5,%rdi
xor    %ebp,%ebp
movapd 0x1578(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm0,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdi
jne    1a90 <cbal+0x980>
cmp    %rdx,%r9
je     1adc <cbal+0x9cc>
mov    0x1f0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %r14d,%edx
sub    %eax,%edx
mov    $0xffffffffffffffff,%rax
movabs $0x3ff0000000000000,%rsi
nopl   0x0(%rax,%rax,1)
mov    %rsi,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %eax,%edx
jne    1ad0 <cbal+0x9c0>
mov    0x4c(%rsp),%ebx
mov    0x50(%rsp),%rdi
cmp    %r14d,%edi
jg     244b <cbal+0x133b>
lea    -0x1(%rbx),%r11
lea    -0x8(,%rbx,8),%r9
ff
add    %r13,%r9
lea    (%r12,%rbx,8),%r10
add    $0xfffffffffffffff8,%r10
mov    0x78(%rsp),%rdx
sub    %edi,%edx
mov    (%rsp),%rbp
lea    (%rdx,%rbp,2),%rsi
add    $0xffffffffffffffff,%rsi
mov    %rsi,0x1b0(%rsp)
lea    0x1(%rdx),%rcx
movabs $0x1fffffffe,%rsi
mov    %rcx,0x128(%rsp)
and    %rcx,%rsi
lea    -0x2(%rsi),%rcx
mov    %rcx,0x120(%rsp)
mov    %rcx,%rax
shr    %rax
add    $0x1,%rax
lea    -0x3(%rbx),%rcx
mov    %rcx,0x150(%rsp)
shr    %rcx
add    $0x1,%rcx
mov    %rcx,0x148(%rsp)
test   %edx,%edx
setne  %dl
cmpl   $0x1,0x8(%rsp)
sete   %cl
and    %dl,%cl
mov    %cl,0xf(%rsp)
mov    %rax,%rcx
mov    %rax,0x118(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rax,0x108(%rsp)
cmp    %r13,%r10
seta   %cl
cmp    %r12,%r9
seta   %al
and    %cl,%al
mov    %al,0xe(%rsp)
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x140(%rsp)
mov    %r11,0xd8(%rsp)
or     $0x1,%r11
mov    %r11,0x138(%rsp)
mov    %rbx,%rax
neg    %rax
mov    %rax,0x170(%rsp)
mov    %rbp,%rax
neg    %rax
mov    %rax,0x1a8(%rsp)
lea    -0x1(%rbp),%rax
imul   %r8,%rax
mov    0x60(%rsp),%rcx
mov    %ecx,%r9d
sub    %edi,%r9d
lea    0x1(%rbp),%rcx
imul   %r8,%rcx
mov    %r8,%r10
shl    $0x5,%r10
lea    (%r12,%rcx,8),%rdx
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x100(%rsp)
lea    -0x8(%r13,%rcx,8),%rcx
mov    %rcx,0xf8(%rsp)
lea    -0x1(%rax),%rcx
mov    %rcx,0x1a0(%rsp)
lea    -0x8(%r12,%rax,8),%rcx
mov    %rcx,0xf0(%rsp)
lea    -0x8(,%rax,8),%rax
ff
add    %r13,%rax
mov    %rax,0xe8(%rsp)
andq   $0xfffffffffffffffe,0x98(%rsp)
xorpd  %xmm8,%xmm8
movsd  0x13aa(%rip),%xmm5
movsd  0x13b2(%rip),%xmm6
movsd  0x13b2(%rip),%xmm7
movsd  0x13b2(%rip),%xmm4
mov    %rbx,0xd0(%rsp)
lea    -0x2(%rbx),%rax
mov    %rax,0x168(%rsp)
lea    -0x1(%rdi),%eax
mov    %rax,0x198(%rsp)
lea    -0x2(%rbp,%rbp,1),%rax
mov    %rax,0x190(%rsp)
mov    %rsi,0x130(%rsp)
lea    (%rsi,%rbp,1),%rax
mov    %rax,0x110(%rsp)
lea    -0x8(%r13,%rbp,8),%rax
mov    %rax,0x188(%rsp)
lea    (%r12,%rbp,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x180(%rsp)
xor    %r11d,%r11d
xor    %r15d,%r15d
movl   $0x0,0x30(%rsp)
mov    %r10,0x178(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x190(%rsp),%rax
add    %r11,%rax
lea    0x0(%r13,%rax,8),%rcx
mov    %rcx,0xc0(%rsp)
mov    0x1b0(%rsp),%rcx
mov    %r11,0x88(%rsp)
lea    (%rcx,%r11,1),%rcx
lea    0x0(%r13,%rcx,8),%rdx
mov    %rdx,0xb0(%rsp)
lea    (%r12,%rax,8),%rax
mov    %rax,0xa8(%rsp)
lea    (%r12,%rcx,8),%rax
mov    %rax,0xb8(%rsp)
mov    0x198(%rsp),%rax
mov    %r15,0x20(%rsp)
add    %r15d,%eax
imul   0x8(%rsp),%eax
mov    %rax,0x80(%rsp)
lea    -0x1(%rbp),%rax
mov    %rax,0x38(%rsp)
imul   %r8,%rax
mov    0x1a8(%rsp),%rcx
lea    (%rcx,%rbp,1),%r12
mov    0x188(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x90(%rsp)
mov    0x180(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x68(%rsp)
mov    0x1a0(%rsp),%rax
mov    %rbp,0x28(%rsp)
lea    (%rax,%rbp,1),%r15
xor    %ebx,%ebx
xorpd  %xmm3,%xmm3
xorpd  %xmm1,%xmm1
jmp    1de0 <cbal+0xcd0>
nopl   0x0(%rax)
add    $0x1,%rbx
add    %r8,%r15
cmp    %ebx,%r9d
je     1eb0 <cbal+0xda0>
cmp    %rbx,%r12
je     1dd0 <cbal+0xcc0>
mov    0x90(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r9,%r13
movsd  %xmm3,0xc8(%rsp)
movsd  %xmm1,0x58(%rsp)
call   1030 <fabs@plt>
mov    %rax,%r14
mov    0x68(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
call   1030 <fabs@plt>
add    %r14,%rax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  0x58(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x58(%rsp)
mov    0x10(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rbp
mov    0x40(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
call   1030 <fabs@plt>
movsd  0x58(%rsp),%xmm1
movsd  0xc8(%rsp),%xmm3
movsd  0x11c0(%rip),%xmm4
movsd  0x11b0(%rip),%xmm7
movsd  0x11a0(%rip),%xmm6
movsd  0x1188(%rip),%xmm5
xorpd  %xmm8,%xmm8
mov    %r13,%r9
mov    0xe0(%rsp),%r8
add    %rbp,%rax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm3
jmp    1dd0 <cbal+0xcc0>
nopl   0x0(%rax)
ucomisd %xmm8,%xmm1
jne    1ebd <cbal+0xdad>
jnp    2110 <cbal+0x1000>
ucomisd %xmm8,%xmm3
jne    1eca <cbal+0xdba>
jnp    2110 <cbal+0x1000>
movapd %xmm3,%xmm2
mulsd  %xmm5,%xmm2
movapd %xmm1,%xmm9
addsd  %xmm3,%xmm9
ucomisd %xmm1,%xmm2
mov    0x18(%rsp),%r14
mov    0x40(%rsp),%r12
mov    0x10(%rsp),%r13
mov    0xa0(%rsp),%rbx
mov    0x178(%rsp),%r10
mov    0x88(%rsp),%r11
mov    0x20(%rsp),%r15
movsd  0x1104(%rip),%xmm0
jbe    1f2e <cbal+0xe1e>
cs nopw 0x0(%rax,%rax,1)
mulsd  %xmm6,%xmm0
mulsd  %xmm7,%xmm1
ucomisd %xmm1,%xmm2
ja     1f20 <cbal+0xe10>
movapd %xmm3,%xmm2
mulsd  %xmm6,%xmm2
ucomisd %xmm2,%xmm1
jb     1f4e <cbal+0xe3e>
nopl   0x0(%rax)
mulsd  %xmm5,%xmm0
mulsd  %xmm4,%xmm1
ucomisd %xmm2,%xmm1
jae    1f40 <cbal+0xe30>
addsd  %xmm1,%xmm3
divsd  %xmm0,%xmm3
mulsd  0x10d9(%rip),%xmm9
ucomisd %xmm9,%xmm3
jae    212c <cbal+0x101c>
movsd  0x10a6(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    0x1f0(%rsp),%rax
mov    0x28(%rsp),%rcx
movsd  -0x8(%rax,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,-0x8(%rax,%rcx,8)
mov    0x50(%rsp),%rax
cmp    0x78(%rsp),%eax
jg     2242 <cbal+0x1132>
mov    (%rsp),%rax
cmpb   $0x0,0xf(%rsp)
je     20e6 <cbal+0xfd6>
mov    0xb8(%rsp),%rax
cmp    %rax,0xc0(%rsp)
jae    1fdd <cbal+0xecd>
mov    (%rsp),%rax
mov    0xa8(%rsp),%rcx
cmp    0xb0(%rsp),%rcx
jb     20e6 <cbal+0xfd6>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
mov    $0x0,%eax
cmpq   $0x0,0x120(%rsp)
mov    0x28(%rsp),%rbx
je     2080 <cbal+0xf70>
mov    0x108(%rsp),%rcx
mov    0xe8(%rsp),%rdx
mov    0xf0(%rsp),%rsi
mov    0xf8(%rsp),%rdi
mov    0x100(%rsp),%rbp
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd (%rdx,%rbx,8),%xmm3
mulpd  %xmm2,%xmm3
movupd %xmm3,(%rdx,%rbx,8)
movupd (%rsi,%rbx,8),%xmm3
mulpd  %xmm2,%xmm3
movupd %xmm3,(%rsi,%rbx,8)
movupd (%rdi,%rbx,8),%xmm3
mulpd  %xmm2,%xmm3
movupd %xmm3,(%rdi,%rbx,8)
movupd 0x0(%rbp,%rbx,8),%xmm3
mulpd  %xmm2,%xmm3
movupd %xmm3,0x0(%rbp,%rbx,8)
add    $0x4,%rax
add    %r10,%rbp
add    %r10,%rdi
add    %r10,%rsi
add    %r10,%rdx
add    $0xfffffffffffffffe,%rcx
jne    2030 <cbal+0xf20>
testb  $0x1,0x118(%rsp)
01
je     20c0 <cbal+0xfb0>
mov    (%rsp),%rcx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
imul   %r8,%rax
add    0x38(%rsp),%rax
movupd 0x0(%r13,%rax,8),%xmm3
mulpd  %xmm2,%xmm3
movupd %xmm3,0x0(%r13,%rax,8)
movupd (%r12,%rax,8),%xmm3
mulpd  %xmm2,%xmm3
movupd %xmm3,(%r12,%rax,8)
mov    0x110(%rsp),%rax
mov    0x128(%rsp),%rcx
cmp    0x130(%rsp),%rcx
mov    0xa0(%rsp),%rbx
je     2242 <cbal+0x1132>
mov    0x74(%rsp),%ecx
sub    %eax,%ecx
test   $0x1,%cl
jne    2177 <cbal+0x1067>
mov    %rax,%rbp
cmp    0x78(%rsp),%eax
jne    21b7 <cbal+0x10a7>
jmp    2242 <cbal+0x1132>
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%r14
mov    0x40(%rsp),%r12
mov    0x10(%rsp),%r13
mov    0x88(%rsp),%r11
mov    0x20(%rsp),%r15
mov    0x28(%rsp),%rbp
add    $0x1,%rbp
add    $0x1,%r15d
add    $0x1,%r11
cmp    %ebp,0x4c(%rsp)
jne    1d00 <cbal+0xbf0>
xor    %r11d,%r11d
cmpl   $0x0,0x30(%rsp)
je     243b <cbal+0x132b>
mov    $0x0,%r15d
mov    (%rsp),%rbp
movl   $0x0,0x30(%rsp)
cmp    %r14d,0x50(%rsp)
jle    1d00 <cbal+0xbf0>
jmp    243b <cbal+0x132b>
lea    -0x1(%rax),%rcx
imul   %r8,%rcx
add    0x38(%rsp),%rcx
movsd  0x0(%r13,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%r13,%rcx,8)
movsd  (%r12,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r12,%rcx,8)
mov    %rax,%rbp
add    $0x1,%rbp
cmp    0x78(%rsp),%eax
je     2242 <cbal+0x1132>
mov    0x74(%rsp),%eax
sub    %ebp,%eax
mov    %r8,%rsi
imul   %rbp,%rsi
lea    (%r12,%rsi,8),%rcx
mov    0x28(%rsp),%rdx
lea    -0x8(,%rdx,8),%rdx
ff
lea    0x0(,%rsi,8),%rsi
add    %r13,%rsi
add    $0xffffffffffffffff,%rbp
imul   %r8,%rbp
lea    0x0(,%rbp,8),%rdi
add    %r13,%rdi
lea    (%r12,%rbp,8),%rbp
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rdx,1),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rdx,1)
movsd  0x0(%rbp,%rdx,1),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,1)
movsd  (%rsi,%rdx,1),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rdx,1)
movsd  (%rcx,%rdx,1),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx,%rdx,1)
add    %rbx,%rdx
add    $0xfffffffe,%eax
jne    2200 <cbal+0x10f0>
movl   $0x1,0x30(%rsp)
test   %r14d,%r14d
jle    212c <cbal+0x101c>
mov    0x38(%rsp),%rax
imul   0x8(%rsp),%eax
mov    %rax,0x38(%rsp)
add    $0xffffffff,%eax
mov    $0x1,%ecx
cmpq   $0x2,0xd8(%rsp)
jae    2282 <cbal+0x1172>
mov    0xd0(%rsp),%rbp
jmp    238c <cbal+0x127c>
mov    0x168(%rsp),%rsi
mov    %rsi,%rdx
shr    $0x20,%rdx
setne  %dl
mov    0x80(%rsp),%rdi
add    %edi,%esi
cmp    %edi,%esi
setl   %bl
or     %dl,%bl
or     0xe(%rsp),%bl
mov    0xd0(%rsp),%rbp
jne    238c <cbal+0x127c>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    $0x0,%ecx
cmpq   $0x2,0x150(%rsp)
jb     233a <cbal+0x122a>
mov    0x98(%rsp),%rdx
mov    0x38(%rsp),%rsi
xor    %ecx,%ecx
xchg   %ax,%ax
movslq %esi,%rsi
movupd 0x0(%r13,%rsi,8),%xmm2
mulpd  %xmm1,%xmm2
movupd %xmm2,0x0(%r13,%rsi,8)
movupd (%r12,%rsi,8),%xmm2
mulpd  %xmm1,%xmm2
movupd %xmm2,(%r12,%rsi,8)
lea    0x2(%rsi),%edi
movslq %edi,%rdi
movupd 0x0(%r13,%rdi,8),%xmm2
mulpd  %xmm1,%xmm2
movupd %xmm2,0x0(%r13,%rdi,8)
movupd (%r12,%rdi,8),%xmm2
mulpd  %xmm1,%xmm2
movupd %xmm2,(%r12,%rdi,8)
add    $0x4,%rcx
add    $0x4,%esi
add    $0xfffffffffffffffe,%rdx
jne    22e0 <cbal+0x11d0>
testb  $0x1,0x148(%rsp)
01
je     236e <cbal+0x125e>
or     $0x1,%ecx
add    %eax,%ecx
movslq %ecx,%rcx
movupd 0x0(%r13,%rcx,8),%xmm2
mulpd  %xmm1,%xmm2
movupd %xmm2,0x0(%r13,%rcx,8)
movupd (%r12,%rcx,8),%xmm2
mulpd  %xmm1,%xmm2
movupd %xmm2,(%r12,%rcx,8)
mov    0x138(%rsp),%rcx
mov    0x140(%rsp),%rdx
cmp    %rdx,0xd8(%rsp)
je     212c <cbal+0x101c>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%bpl
jne    23c2 <cbal+0x12b2>
add    %ecx,%eax
cltq
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rax,8)
add    $0x1,%rcx
mov    0x38(%rsp),%rsi
cmp    0x170(%rsp),%rdx
je     212c <cbal+0x101c>
add    %ecx,%esi
mov    0x60(%rsp),%rax
sub    %rcx,%rax
nop
lea    -0x1(%rsi),%ecx
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
movsd  (%r12,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rcx,8)
movslq %esi,%rsi
movsd  0x0(%r13,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rsi,8)
movsd  (%r12,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rsi,8)
add    $0x2,%esi
add    $0xfffffffffffffffe,%rax
jne    23e0 <cbal+0x12d0>
jmp    212c <cbal+0x101c>
mov    0x50(%rsp),%rdi
jmp    244b <cbal+0x133b>
mov    $0x1,%r14d
mov    %r11d,%edi
mov    0x158(%rsp),%rax
mov    %edi,(%rax)
mov    0x160(%rsp),%rax
mov    %r14d,(%rax)
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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