void a2b_ord2(int nx, int ny, const double *qin, const double *edge_w,
              const double *edge_e, const double *edge_s, const double *edge_n,
              double *qout, int on_west_edge, int on_east_edge,
              int on_south_edge, int on_north_edge) {
  int nxp, nyp, i, j;
  int istart, iend, jstart, jend;
  double *q1, *q2;
  const double r3 = 1. / 3.;
  nxp = nx + 1;
  nyp = ny + 1;
  q1 = (double *)malloc((nx + 2) * sizeof(double));
  q2 = (double *)malloc((ny + 2) * sizeof(double));
  if (on_west_edge)
    istart = 1;
  else
    istart = 0;
  if (on_east_edge)
    iend = nx;
  else
    iend = nxp;
  if (on_south_edge)
    jstart = 1;
  else
    jstart = 0;
  if (on_north_edge)
    jend = ny;
  else
    jend = nyp;
  for (j = jstart; j < jend; j++)
    for (i = istart; i < iend; i++) {
      qout[j * nxp + i] =
          0.25 *
          (qin[j * (nx + 2) + i] + qin[j * (nx + 2) + i + 1] +
           qin[(j + 1) * (nx + 2) + i] + qin[(j + 1) * (nx + 2) + i + 1]);
    }
  if (on_west_edge && on_south_edge)
    qout[0] = r3 * (qin[1 * (nx + 2) + 1] + qin[1 * (nx + 2)] + qin[1]);
  if (on_east_edge && on_south_edge)
    qout[nx] =
        r3 * (qin[1 * (nx + 2) + nx] + qin[nx] + qin[1 * (nx + 2) + nxp]);
  if (on_east_edge && on_north_edge)
    qout[ny * nxp + nx] =
        r3 * (qin[ny * (nx + 2) + nx] + qin[ny * (nx + 2) + nxp] +
              qin[nyp * (nx + 2) + nx]);
  if (on_west_edge && on_north_edge)
    qout[ny * nxp] = r3 * (qin[ny * (nx + 2) + 1] + qin[ny * (nx + 2)] +
                           qin[nyp * (nx + 2) + 1]);
  if (on_west_edge) {
    for (j = jstart; j <= jend; j++)
      q2[j] = 0.5 * (qin[j * (nx + 2)] + qin[j * (nx + 2) + 1]);
    for (j = jstart; j < jend; j++)
      qout[j * nxp] = edge_w[j] * q2[j] + (1 - edge_w[j]) * q2[j + 1];
  }
  if (on_east_edge) {
    for (j = jstart; j <= jend; j++)
      q2[j] = 0.5 * (qin[j * (nx + 2) + nx] + qin[j * (nx + 2) + nxp]);
    for (j = jstart; j < jend; j++)
      qout[j * nxp + nx] = edge_e[j] * q2[j] + (1 - edge_e[j]) * q2[j + 1];
  }
  if (on_south_edge) {
    for (i = istart; i <= iend; i++)
      q1[i] = 0.5 * (qin[i] + qin[(nx + 2) + i]);
    for (i = istart; i < iend; i++)
      qout[i] = edge_s[i] * q1[i] + (1 - edge_s[i]) * q1[i + 1];
  }
  if (on_north_edge) {
    for (i = istart; i <= iend; i++)
      q1[i] = 0.5 * (qin[ny * (nx + 2) + i] + qin[nyp * (nx + 2) + i]);
    for (i = istart; i < iend; i++)
      qout[ny * nxp + i] = edge_n[i] * q1[i] + (1 - edge_n[i]) * q1[i + 1];
  }
}


x86 assembly (clang, -O0):
<a2b_ord2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
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  0xeb6(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x58(%rbp)
cmpl   $0x0,0x20(%rbp)
je     11a3 <a2b_ord2+0x93>
movl   $0x1,-0x3c(%rbp)
jmp    11aa <a2b_ord2+0x9a>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x0,0x28(%rbp)
je     11bf <a2b_ord2+0xaf>
mov    -0x4(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    11c5 <a2b_ord2+0xb5>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,0x30(%rbp)
je     11db <a2b_ord2+0xcb>
movl   $0x1,-0x44(%rbp)
jmp    11e2 <a2b_ord2+0xd2>
movl   $0x0,-0x44(%rbp)
cmpl   $0x0,0x38(%rbp)
je     11f7 <a2b_ord2+0xe7>
mov    -0x8(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    11fd <a2b_ord2+0xed>
mov    -0x30(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    12dc <a2b_ord2+0x1cc>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    12c9 <a2b_ord2+0x1b9>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xd77(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1215 <a2b_ord2+0x105>
jmp    12ce <a2b_ord2+0x1be>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1203 <a2b_ord2+0xf3>
cmpl   $0x0,0x20(%rbp)
je     133a <a2b_ord2+0x22a>
cmpl   $0x0,0x30(%rbp)
je     133a <a2b_ord2+0x22a>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
shl    $0x0,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
shl    $0x0,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
addsd  0x8(%rax),%xmm1
movsd  0xcd2(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x0,0x28(%rbp)
je     13a4 <a2b_ord2+0x294>
cmpl   $0x0,0x30(%rbp)
je     13a4 <a2b_ord2+0x294>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
shl    $0x0,%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
shl    $0x0,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xc6d(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,0x28(%rbp)
je     142b <a2b_ord2+0x31b>
cmpl   $0x0,0x38(%rbp)
je     142b <a2b_ord2+0x31b>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xbef(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,0x20(%rbp)
je     14ac <a2b_ord2+0x39c>
cmpl   $0x0,0x38(%rbp)
je     14ac <a2b_ord2+0x39c>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xb6b(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,0x20(%rbp)
je     15a3 <a2b_ord2+0x493>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     1522 <a2b_ord2+0x412>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xb0d(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14bc <a2b_ord2+0x3ac>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    159e <a2b_ord2+0x48e>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  0xaaa(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
mov    -0x58(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1528 <a2b_ord2+0x418>
jmp    15a3 <a2b_ord2+0x493>
cmpl   $0x0,0x28(%rbp)
je     16a0 <a2b_ord2+0x590>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     161c <a2b_ord2+0x50c>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xa13(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15b3 <a2b_ord2+0x4a3>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    169b <a2b_ord2+0x58b>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  0x9b0(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
mov    -0x58(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1622 <a2b_ord2+0x512>
jmp    16a0 <a2b_ord2+0x590>
cmpl   $0x0,0x30(%rbp)
je     1780 <a2b_ord2+0x670>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1705 <a2b_ord2+0x5f5>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x92a(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16b0 <a2b_ord2+0x5a0>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    177b <a2b_ord2+0x66b>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  0x8c7(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
mov    -0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    170b <a2b_ord2+0x5fb>
jmp    1780 <a2b_ord2+0x670>
cmpl   $0x0,0x38(%rbp)
je     187d <a2b_ord2+0x76d>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     17f9 <a2b_ord2+0x6e9>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x836(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1790 <a2b_ord2+0x680>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1878 <a2b_ord2+0x768>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  0x7d3(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
mov    -0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17ff <a2b_ord2+0x6ef>
jmp    187d <a2b_ord2+0x76d>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<a2b_ord2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0x58(%rsp)
mov    %r8,0x78(%rsp)
mov    %rcx,0x80(%rsp)
mov    %rdx,%r15
mov    %esi,%ebp
mov    0xf8(%rsp),%r14
lea    0x1(%rdi),%ebx
lea    0x1(%rbp),%r12d
mov    %rdi,0x50(%rsp)
movslq %edi,%r13
lea    0x2(%r13),%rax
mov    %rax,0x28(%rsp)
lea    0x10(,%r13,8),%rdi
call   1030 <malloc@plt>
mov    %rax,0x90(%rsp)
mov    %rbp,0x88(%rsp)
movslq %ebp,%rbp
lea    0x10(,%rbp,8),%rdi
call   1030 <malloc@plt>
mov    %r15,%r9
mov    %r14,%r10
mov    %rax,0x18(%rsp)
xor    %eax,%eax
cmpl   $0x0,0x100(%rsp)
setne  %al
cmpl   $0x0,0x108(%rsp)
mov    %r13,0x40(%rsp)
cmove  %ebx,%r13d
xor    %edx,%edx
cmpl   $0x0,0x110(%rsp)
setne  %dl
cmpl   $0x0,0x118(%rsp)
mov    %r12d,0x34(%rsp)
cmove  %r12d,%ebp
mov    %rbx,0x60(%rsp)
movslq %ebx,%rcx
mov    %rcx,0x38(%rsp)
mov    %rbp,0x8(%rsp)
mov    %edx,0x14(%rsp)
cmp    %edx,%ebp
mov    %r15,0x20(%rsp)
mov    %r13,0x48(%rsp)
mov    %eax,0x4(%rsp)
jle    13e8 <a2b_ord2+0x2d8>
xor    %r14d,%r14d
cmpl   $0x0,0x110(%rsp)
setne  %r14b
xor    %r15d,%r15d
cmpl   $0x0,0x100(%rsp)
setne  %r15b
mov    0x8(%rsp),%edx
mov    %r13d,%ecx
lea    (%r9,%r15,8),%rsi
mov    %rsi,0xa8(%rsp)
lea    (%r9,%rcx,8),%rsi
add    $0x8,%rsi
mov    %rsi,0xa0(%rsp)
mov    %rcx,%r8
sub    %r15,%r8
mov    %r8,0x70(%rsp)
and    $0xfffffffffffffffe,%r8
lea    (%r8,%r15,1),%rsi
mov    %rsi,0x98(%rsp)
lea    0x8(%r9),%rsi
mov    %rsi,0xb0(%rsp)
movsd  0xdc8(%rip),%xmm0
movapd 0xd90(%rip),%xmm1
mov    %rdx,0x68(%rsp)
jmp    1293 <a2b_ord2+0x183>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
mov    %r14,%r12
mov    %r12,%r14
cmp    %rdx,%r12
je     13e8 <a2b_ord2+0x2d8>
cmp    %eax,%r13d
jle    1280 <a2b_ord2+0x170>
mov    %r14,%r13
mov    0x28(%rsp),%rdx
imul   %rdx,%r13
lea    0x1(%r14),%r12
mov    %r12,%r11
imul   %rdx,%r11
imul   0x38(%rsp),%r14
mov    %r15,%rdi
cmpq   $0x2,0x70(%rsp)
jb     1390 <a2b_ord2+0x280>
lea    (%r14,%r15,1),%rdx
lea    (%r10,%rdx,8),%rdx
lea    (%r14,%rcx,1),%rsi
lea    (%r10,%rsi,8),%rsi
mov    0xa8(%rsp),%rax
lea    (%rax,%r11,8),%r9
mov    0xa0(%rsp),%rdi
lea    (%rdi,%r11,8),%rbx
lea    (%rax,%r13,8),%rbp
lea    (%rdi,%r13,8),%rax
cmp    %rbx,%rdx
setb   %r10b
cmp    %rsi,%r9
setb   %r9b
cmp    %rax,%rdx
mov    0x4(%rsp),%eax
setb   %bl
cmp    %rsi,%rbp
setb   %dl
mov    %r15,%rdi
test   %r9b,%r10b
mov    0x20(%rsp),%r9
mov    0xf8(%rsp),%r10
jne    1390 <a2b_ord2+0x280>
mov    %r15,%rdi
and    %dl,%bl
jne    1390 <a2b_ord2+0x280>
xor    %edi,%edi
mov    %rdi,%rax
or     %r15,%rax
lea    (%rax,%r13,1),%rdx
movupd (%r9,%rdx,8),%xmm2
movupd 0x8(%r9,%rdx,8),%xmm3
addpd  %xmm2,%xmm3
lea    (%rax,%r11,1),%rdx
movupd (%r9,%rdx,8),%xmm2
addpd  %xmm3,%xmm2
movupd 0x8(%r9,%rdx,8),%xmm3
addpd  %xmm2,%xmm3
mulpd  %xmm1,%xmm3
add    %r14,%rax
movupd %xmm3,(%r10,%rax,8)
add    $0x2,%rdi
cmp    %rdi,%r8
jne    1330 <a2b_ord2+0x220>
mov    0x98(%rsp),%rdi
cmp    %r8,0x70(%rsp)
mov    0x4(%rsp),%eax
je     13d9 <a2b_ord2+0x2c9>
nopl   (%rax)
lea    (%r10,%r14,8),%rbx
mov    0xb0(%rsp),%rdx
lea    (%rdx,%r11,8),%rbp
lea    (%rdx,%r13,8),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rsi,%rdi,8),%xmm2
addsd  (%rsi,%rdi,8),%xmm2
addsd  -0x8(%rbp,%rdi,8),%xmm2
addsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rbx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    13b0 <a2b_ord2+0x2a0>
mov    0x48(%rsp),%r13
mov    0x68(%rsp),%rdx
jmp    1287 <a2b_ord2+0x177>
cmpl   $0x0,0x100(%rsp)
mov    0x28(%rsp),%r14
mov    0x110(%rsp),%eax
je     1427 <a2b_ord2+0x317>
test   %eax,%eax
je     1427 <a2b_ord2+0x317>
mov    0x40(%rsp),%rcx
movsd  0x18(%r9,%rcx,8),%xmm0
addsd  (%r9,%r14,8),%xmm0
addsd  0x8(%r9),%xmm0
mulsd  0xc16(%rip),%xmm0
movsd  %xmm0,(%r10)
cmpl   $0x0,0x108(%rsp)
mov    0x90(%rsp),%r11
mov    0x60(%rsp),%rsi
mov    0x58(%rsp),%r15
mov    0x80(%rsp),%rbx
je     1484 <a2b_ord2+0x374>
test   %eax,%eax
je     1484 <a2b_ord2+0x374>
mov    0x50(%rsp),%rax
add    %r14d,%eax
cltq
movsd  (%r9,%rax,8),%xmm0
mov    0x40(%rsp),%rcx
addsd  (%r9,%rcx,8),%xmm0
lea    (%r14,%rsi,1),%eax
cltq
addsd  (%r9,%rax,8),%xmm0
mulsd  0xbba(%rip),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
cmpl   $0x0,0x108(%rsp)
mov    0x88(%rsp),%r12
je     14ed <a2b_ord2+0x3dd>
cmpl   $0x0,0x118(%rsp)
je     14ed <a2b_ord2+0x3dd>
mov    0x34(%rsp),%eax
imul   %r14d,%eax
mov    %r14d,%ecx
imul   %r12d,%ecx
mov    0x50(%rsp),%rdi
lea    (%rcx,%rdi,1),%edx
movslq %edx,%rdx
movsd  (%r9,%rdx,8),%xmm0
add    %esi,%ecx
movslq %ecx,%rcx
addsd  (%r9,%rcx,8),%xmm0
add    %edi,%eax
cltq
addsd  (%r9,%rax,8),%xmm0
mulsd  0xb5b(%rip),%xmm0
mov    %esi,%eax
imul   %r12d,%eax
add    %edi,%eax
cltq
movsd  %xmm0,(%r10,%rax,8)
cmpl   $0x0,0x100(%rsp)
je     153f <a2b_ord2+0x42f>
cmpl   $0x0,0x118(%rsp)
je     153f <a2b_ord2+0x42f>
mov    0x34(%rsp),%eax
imul   %r14d,%eax
mov    %r14d,%ecx
imul   %r12d,%ecx
movslq %ecx,%rcx
movsd  0x8(%r9,%rcx,8),%xmm0
addsd  (%r9,%rcx,8),%xmm0
cltq
addsd  0x8(%r9,%rax,8),%xmm0
mulsd  0xb07(%rip),%xmm0
mov    %esi,%eax
imul   %r12d,%eax
cltq
movsd  %xmm0,(%r10,%rax,8)
cmpl   $0x0,0x100(%rsp)
mov    0x18(%rsp),%rax
je     1735 <a2b_ord2+0x625>
mov    0x14(%rsp),%ecx
cmp    %ecx,0x8(%rsp)
jl     1625 <a2b_ord2+0x515>
xor    %ecx,%ecx
mov    0x110(%rsp),%edi
test   %edi,%edi
setne  %cl
mov    0x8(%rsp),%rax
lea    0x1(%rax),%r8d
mov    %r8d,%eax
sub    %ecx,%eax
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
jne    1595 <a2b_ord2+0x485>
mov    0x18(%rsp),%rax
add    %r8,%rsi
jne    15cd <a2b_ord2+0x4bd>
jmp    1625 <a2b_ord2+0x515>
xor    %eax,%eax
xor    %edx,%edx
test   %edi,%edi
cmovne %r14,%rax
setne  %dl
movsd  (%r9,%rax,8),%xmm0
addsd  0x8(%r9,%rax,8),%xmm0
mulsd  0xa89(%rip),%xmm0
mov    0x18(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rdx
mov    %rdx,%rcx
add    %r8,%rsi
je     1625 <a2b_ord2+0x515>
mov    %rcx,%rsi
imul   %r14,%rsi
lea    0x8(%r9),%rdi
mov    %r14,%rbp
shl    $0x4,%rbp
lea    0x1(%rcx),%rdx
imul   %r14,%rdx
movsd  0xa51(%rip),%xmm0
nop
movsd  -0x8(%rdi,%rsi,8),%xmm1
addsd  (%rdi,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
movsd  -0x8(%rdi,%rdx,8),%xmm1
addsd  (%rdi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rax,%rcx,8)
add    $0x2,%rcx
add    %rbp,%rdi
cmp    %rcx,%r8
jne    15f0 <a2b_ord2+0x4e0>
mov    0x14(%rsp),%ecx
cmp    %ecx,0x8(%rsp)
jle    1735 <a2b_ord2+0x625>
xor    %edx,%edx
mov    0x110(%rsp),%ecx
test   %ecx,%ecx
setne  %dl
mov    0x8(%rsp),%rsi
mov    %esi,%r8d
movsd  (%rax,%rdx,8),%xmm0
mov    %rax,%rdi
mov    %esi,%eax
sub    %edx,%eax
mov    %rdx,%rsi
not    %rsi
test   $0x1,%al
je     169f <a2b_ord2+0x58f>
xor    %eax,%eax
movsd  (%rbx,%rdx,8),%xmm1
xor    %edx,%edx
test   %ecx,%ecx
setne  %dl
movsd  0x9d3(%rip),%xmm2
subsd  %xmm1,%xmm2
cmovne 0x38(%rsp),%rax
movsd  0x8(%rdi,%rdx,8),%xmm3
add    $0x1,%rdx
mulsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%r10,%rax,8)
movapd %xmm3,%xmm0
mov    %rdi,%rax
add    %r8,%rsi
je     1735 <a2b_ord2+0x625>
mov    %rdx,%rsi
mov    0x38(%rsp),%rcx
imul   %rcx,%rsi
mov    %rcx,%rdi
shl    $0x4,%rdi
lea    0x1(%rdx),%rbp
imul   %rcx,%rbp
movsd  0x97a(%rip),%xmm1
mov    %r10,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm2
movapd %xmm1,%xmm3
subsd  %xmm2,%xmm3
movsd  0x8(%rax,%rdx,8),%xmm4
mulsd  %xmm4,%xmm3
mulsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movsd  0x8(%rbx,%rdx,8),%xmm2
movapd %xmm1,%xmm3
subsd  %xmm2,%xmm3
movsd  0x10(%rax,%rdx,8),%xmm0
add    $0x2,%rdx
mulsd  %xmm0,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%rcx,%rbp,8)
add    %rdi,%rcx
cmp    %rdx,%r8
jne    16e0 <a2b_ord2+0x5d0>
cmpl   $0x0,0x108(%rsp)
je     1986 <a2b_ord2+0x876>
mov    0x14(%rsp),%ecx
cmp    %ecx,0x8(%rsp)
jl     1864 <a2b_ord2+0x754>
xor    %ecx,%ecx
mov    0x110(%rsp),%edi
test   %edi,%edi
setne  %cl
mov    0x8(%rsp),%rax
lea    0x1(%rax),%r8d
mov    %r8d,%eax
sub    %ecx,%eax
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
jne    1786 <a2b_ord2+0x676>
mov    0x18(%rsp),%rax
add    %r8,%rsi
jne    17d3 <a2b_ord2+0x6c3>
jmp    1864 <a2b_ord2+0x754>
xor    %eax,%eax
xor    %edx,%edx
test   %edi,%edi
setne  %dl
cmovne %r14,%rax
mov    0x40(%rsp),%rdi
add    %rax,%rdi
mov    0x20(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
add    0x38(%rsp),%rax
addsd  0x0(%rbp,%rax,8),%xmm0
mulsd  0x887(%rip),%xmm0
mov    0x18(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rdx
mov    %rdx,%rcx
add    %r8,%rsi
je     1864 <a2b_ord2+0x754>
mov    %rcx,%rax
imul   %r14,%rax
mov    0x38(%rsp),%rdx
lea    0x0(,%rdx,8),%rdx
lea    (%rdx,%rax,8),%r9
lea    -0x2(%r14),%rdi
shl    $0x4,%rdi
add    $0x20,%rdi
lea    -0x10(,%r14,8),%rsi
ff
lea    (%rsi,%rax,8),%rbp
lea    0x1(%rcx),%rax
imul   %r14,%rax
lea    (%rdx,%rax,8),%rdx
lea    (%rsi,%rax,8),%rsi
mov    0x18(%rsp),%rax
movsd  0x820(%rip),%xmm0
mov    0x20(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rbp,1),%xmm1
addsd  (%rbx,%r9,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
movsd  (%rbx,%rsi,1),%xmm1
addsd  (%rbx,%rdx,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rax,%rcx,8)
add    $0x2,%rcx
add    %rdi,%rbx
cmp    %rcx,%r8
jne    1830 <a2b_ord2+0x720>
mov    0x14(%rsp),%ecx
cmp    %ecx,0x8(%rsp)
mov    0x20(%rsp),%r9
mov    0x78(%rsp),%rbx
mov    0x38(%rsp),%rcx
jle    1986 <a2b_ord2+0x876>
xor    %edx,%edx
mov    0x110(%rsp),%edi
test   %edi,%edi
setne  %dl
mov    0x8(%rsp),%rbp
mov    %ebp,%r8d
movsd  (%rax,%rdx,8),%xmm0
sub    %edx,%ebp
mov    %rdx,%rsi
not    %rsi
test   $0x1,%bpl
je     18f2 <a2b_ord2+0x7e2>
xor    %eax,%eax
movsd  (%rbx,%rdx,8),%xmm1
xor    %edx,%edx
test   %edi,%edi
setne  %dl
movsd  0x788(%rip),%xmm2
cmovne %rcx,%rax
subsd  %xmm1,%xmm2
mov    0x18(%rsp),%rdi
movsd  0x8(%rdi,%rdx,8),%xmm3
add    $0x1,%rdx
mulsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
add    0x40(%rsp),%rax
movsd  %xmm0,(%r10,%rax,8)
movapd %xmm3,%xmm0
add    %r8,%rsi
je     1986 <a2b_ord2+0x876>
mov    %rdx,%rax
imul   %rcx,%rax
lea    (%r10,%rax,8),%rsi
lea    -0x2(%r14),%rdi
lea    0x1(%rdx),%rax
imul   %rcx,%rax
add    %rcx,%rcx
lea    (%r10,%rax,8),%rbp
mov    0x18(%rsp),%rax
movsd  0x722(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm2
movapd %xmm1,%xmm3
subsd  %xmm2,%xmm3
movsd  0x8(%rax,%rdx,8),%xmm4
mulsd  %xmm4,%xmm3
mulsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
movsd  0x8(%rbx,%rdx,8),%xmm2
movapd %xmm1,%xmm3
subsd  %xmm2,%xmm3
movsd  0x10(%rax,%rdx,8),%xmm0
add    $0x2,%rdx
mulsd  %xmm0,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp,%rdi,8)
add    %rcx,%rdi
cmp    %rdx,%r8
jne    1930 <a2b_ord2+0x820>
cmpl   $0x0,0x110(%rsp)
je     1cd6 <a2b_ord2+0xbc6>
cmp    0x4(%rsp),%r13d
jl     1b2e <a2b_ord2+0xa1e>
xor    %eax,%eax
cmpl   $0x0,0x100(%rsp)
setne  %al
lea    0x1(%r13),%ecx
mov    %rcx,%r14
sub    %rax,%r14
cmp    $0x4,%r14
jae    19c6 <a2b_ord2+0x8b6>
mov    0x28(%rsp),%rdx
jmp    1af5 <a2b_ord2+0x9e5>
mov    %r14,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1a88 <a2b_ord2+0x978>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %esi,%esi
movapd 0x61a(%rip),%xmm0
mov    0x20(%rsp),%rdx
mov    0x28(%rsp),%r15
mov    %rsi,%rdi
or     %rax,%rdi
movupd (%rdx,%rdi,8),%xmm1
movupd 0x10(%rdx,%rdi,8),%xmm2
lea    (%rdi,%r15,1),%rbx
movupd (%rdx,%rbx,8),%xmm3
addpd  %xmm1,%xmm3
movupd 0x10(%rdx,%rbx,8),%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm1
movupd %xmm3,(%r11,%rdi,8)
movupd %xmm1,0x10(%r11,%rdi,8)
or     $0x4,%rdi
movupd (%rdx,%rdi,8),%xmm1
movupd 0x10(%rdx,%rdi,8),%xmm2
lea    (%rdi,%r15,1),%rbx
movupd (%rdx,%rbx,8),%xmm3
addpd  %xmm1,%xmm3
movupd 0x10(%rdx,%rbx,8),%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm1
movupd %xmm3,(%r11,%rdi,8)
movupd %xmm1,0x10(%r11,%rdi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rbp
jne    1a00 <a2b_ord2+0x8f0>
jmp    1a8f <a2b_ord2+0x97f>
xor    %esi,%esi
mov    0x20(%rsp),%rdx
test   $0x1,%r9b
mov    %rdx,%r9
je     1ae3 <a2b_ord2+0x9d3>
or     %rax,%rsi
movupd (%r9,%rsi,8),%xmm0
movupd 0x10(%r9,%rsi,8),%xmm1
mov    0x28(%rsp),%rdx
lea    (%rsi,%rdx,1),%rdi
movupd (%r9,%rdi,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r9,%rdi,8),%xmm0
addpd  %xmm1,%xmm0
movapd 0x542(%rip),%xmm1
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r11,%rsi,8)
movupd %xmm0,0x10(%r11,%rsi,8)
cmp    %r8,%r14
mov    0x28(%rsp),%rdx
mov    0x58(%rsp),%r15
je     1b2e <a2b_ord2+0xa1e>
or     %r8,%rax
lea    (%r9,%rdx,8),%rdx
movsd  0x53f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r9,%rax,8),%xmm1
addsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r11,%rax,8)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1b10 <a2b_ord2+0xa00>
cmp    0x4(%rsp),%r13d
jle    1cd6 <a2b_ord2+0xbc6>
xor    %edx,%edx
cmpl   $0x0,0x100(%rsp)
setne  %dl
mov    %r13d,%eax
movsd  (%r11,%rdx,8),%xmm0
mov    %rax,%rsi
sub    %rdx,%rsi
cmp    $0x4,%rsi
jb     1b7d <a2b_ord2+0xa6d>
lea    (%r10,%rdx,8),%rcx
lea    (%r15,%rax,8),%rdi
cmp    %rdi,%rcx
jae    1c41 <a2b_ord2+0xb31>
lea    (%r10,%rax,8),%rcx
lea    (%r15,%rdx,8),%rdi
cmp    %rcx,%rdi
jae    1c41 <a2b_ord2+0xb31>
mov    %rdx,%rcx
mov    %eax,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
test   $0x1,%sil
je     1bc3 <a2b_ord2+0xab3>
movsd  (%r15,%rcx,8),%xmm1
movsd  0x4aa(%rip),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%r11,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%r10,%rcx,8)
add    $0x1,%rcx
movapd %xmm3,%xmm0
add    %rax,%rdx
je     1cd6 <a2b_ord2+0xbc6>
movsd  0x474(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rcx,8),%xmm2
movapd %xmm1,%xmm3
subsd  %xmm2,%xmm3
movsd  0x8(%r11,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
mulsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%r10,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm2
movapd %xmm1,%xmm3
subsd  %xmm2,%xmm3
movsd  0x10(%r11,%rcx,8),%xmm0
mulsd  %xmm0,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%r10,%rcx,8)
lea    0x2(%rcx),%rdx
mov    %rdx,%rcx
cmp    %rdx,%rax
jne    1be0 <a2b_ord2+0xad0>
jmp    1cd6 <a2b_ord2+0xbc6>
mov    %rsi,%rdi
and    $0xfffffffffffffffc,%rdi
lea    (%rdi,%rdx,1),%rcx
unpcklpd %xmm0,%xmm0
xor    %ebx,%ebx
movapd 0x3c6(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm2
mov    %rbx,%rbp
or     %rdx,%rbp
movupd (%r15,%rbp,8),%xmm3
movupd 0x10(%r15,%rbp,8),%xmm4
movapd %xmm1,%xmm5
subpd  %xmm3,%xmm5
movapd %xmm1,%xmm6
subpd  %xmm4,%xmm6
movupd 0x8(%r11,%rbp,8),%xmm7
movupd 0x18(%r11,%rbp,8),%xmm0
shufpd $0x1,%xmm7,%xmm2
mulpd  %xmm7,%xmm5
shufpd $0x1,%xmm0,%xmm7
mulpd  %xmm0,%xmm6
mulpd  %xmm3,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm4,%xmm7
addpd  %xmm6,%xmm7
movupd %xmm2,(%r10,%rbp,8)
movupd %xmm7,0x10(%r10,%rbp,8)
add    $0x4,%rbx
cmp    %rbx,%rdi
jne    1c60 <a2b_ord2+0xb50>
cmp    %rdi,%rsi
jne    1fb3 <a2b_ord2+0xea3>
cmpl   $0x0,0x118(%rsp)
je     1fa1 <a2b_ord2+0xe91>
mov    %r10,%r14
cmp    0x4(%rsp),%r13d
jl     1ddd <a2b_ord2+0xccd>
mov    %r13,%rax
xor    %r13d,%r13d
cmpl   $0x0,0x100(%rsp)
setne  %r13b
mov    0x34(%rsp),%ecx
mov    0x28(%rsp),%rdx
imul   %edx,%ecx
imul   %r12d,%edx
movslq %edx,%r9
movslq %ecx,%r10
add    $0x1,%eax
mov    %rax,%r8
sub    %r13,%r8
cmp    $0x4,%r8
jae    1d33 <a2b_ord2+0xc23>
mov    %r13,%rcx
mov    0x48(%rsp),%r13
jmp    1da4 <a2b_ord2+0xc94>
mov    %r8,%rbp
and    $0xfffffffffffffffc,%rbp
mov    %rbp,%rcx
add    %r13,%rcx
xor    %ebx,%ebx
movapd 0x2c6(%rip),%xmm0
mov    0x20(%rsp),%rdx
nop
mov    %rbx,%rsi
or     %r13,%rsi
lea    (%rsi,%r9,1),%rdi
movupd (%rdx,%rdi,8),%xmm1
movupd 0x10(%rdx,%rdi,8),%xmm2
lea    (%rsi,%r10,1),%rdi
movupd (%rdx,%rdi,8),%xmm3
addpd  %xmm1,%xmm3
movupd 0x10(%rdx,%rdi,8),%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm1
movupd %xmm3,(%r11,%rsi,8)
movupd %xmm1,0x10(%r11,%rsi,8)
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    1d50 <a2b_ord2+0xc40>
cmp    %rbp,%r8
mov    0x48(%rsp),%r13
je     1ddd <a2b_ord2+0xccd>
mov    0x20(%rsp),%rsi
lea    (%rsi,%r10,8),%rdx
lea    (%rsi,%r9,8),%rsi
movsd  0x287(%rip),%xmm0
nopl   0x0(%rax)
movsd  (%rsi,%rcx,8),%xmm1
addsd  (%rdx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r11,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1dc0 <a2b_ord2+0xcb0>
cmp    0x4(%rsp),%r13d
jle    1fa1 <a2b_ord2+0xe91>
mov    %r14,%rcx
mov    0xf0(%rsp),%rax
xor    %edi,%edi
cmpl   $0x0,0x100(%rsp)
setne  %dil
mov    0x60(%rsp),%rdx
imul   %r12d,%edx
movslq %edx,%r9
mov    %r13d,%r10d
movsd  (%r11,%rdi,8),%xmm0
mov    %r10,%r8
sub    %rdi,%r8
cmp    $0x4,%r8
jb     1e4c <a2b_ord2+0xd3c>
lea    (%r9,%rdi,1),%rdx
lea    (%rcx,%rdx,8),%rdx
lea    (%rax,%r10,8),%rbp
cmp    %rbp,%rdx
jae    1f0d <a2b_ord2+0xdfd>
lea    (%r9,%r10,1),%rdx
lea    (%rcx,%rdx,8),%rdx
lea    (%rax,%rdi,8),%rbp
cmp    %rdx,%rbp
jae    1f0d <a2b_ord2+0xdfd>
mov    %rdi,%rdx
mov    %r10d,%esi
sub    %edx,%esi
mov    %rdx,%rdi
not    %rdi
test   $0x1,%sil
je     1e97 <a2b_ord2+0xd87>
movsd  (%rax,%rdx,8),%xmm1
movsd  0x1db(%rip),%xmm2
subsd  %xmm1,%xmm2
lea    0x1(%rdx),%rsi
movsd  0x8(%r11,%rdx,8),%xmm3
mulsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
add    %r9,%rdx
movsd  %xmm0,(%rcx,%rdx,8)
movapd %xmm3,%xmm0
mov    %rsi,%rdx
add    %r10,%rdi
je     1fa1 <a2b_ord2+0xe91>
lea    (%rcx,%r9,8),%rsi
add    $0x8,%rsi
movsd  0x198(%rip),%xmm1
movsd  (%rax,%rdx,8),%xmm2
movapd %xmm1,%xmm3
subsd  %xmm2,%xmm3
movsd  0x8(%r11,%rdx,8),%xmm4
mulsd  %xmm4,%xmm3
mulsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,-0x8(%rsi,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm2
movapd %xmm1,%xmm3
subsd  %xmm2,%xmm3
movsd  0x10(%r11,%rdx,8),%xmm0
mulsd  %xmm0,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%rsi,%rdx,8)
lea    0x2(%rdx),%rdi
mov    %rdi,%rdx
cmp    %rdi,%r10
jne    1eb0 <a2b_ord2+0xda0>
jmp    1fa1 <a2b_ord2+0xe91>
mov    %r8,%rbp
and    $0xfffffffffffffffc,%rbp
lea    (%rdi,%rbp,1),%rdx
unpcklpd %xmm0,%xmm0
xor    %esi,%esi
movapd 0xfa(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
movapd %xmm0,%xmm2
mov    %rsi,%rbx
or     %rdi,%rbx
movupd (%rax,%rbx,8),%xmm3
movupd 0x10(%rax,%rbx,8),%xmm4
movapd %xmm1,%xmm5
subpd  %xmm3,%xmm5
movapd %xmm1,%xmm6
subpd  %xmm4,%xmm6
movupd 0x8(%r11,%rbx,8),%xmm7
movupd 0x18(%r11,%rbx,8),%xmm0
shufpd $0x1,%xmm7,%xmm2
mulpd  %xmm7,%xmm5
shufpd $0x1,%xmm0,%xmm7
mulpd  %xmm0,%xmm6
mulpd  %xmm3,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm4,%xmm7
addpd  %xmm6,%xmm7
add    %r9,%rbx
movupd %xmm2,(%rcx,%rbx,8)
movupd %xmm7,0x10(%rcx,%rbx,8)
add    $0x4,%rsi
cmp    %rsi,%rbp
jne    1f30 <a2b_ord2+0xe20>
cmp    %rbp,%r8
jne    1fbc <a2b_ord2+0xeac>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
unpckhpd %xmm0,%xmm0
jmp    1b80 <a2b_ord2+0xa70>
unpckhpd %xmm0,%xmm0
jmp    1e4f <a2b_ord2+0xd3f>

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

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