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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
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];
    }
  }
  free(q1);
  free(q2);
}


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  0xea6(%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
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%eax
add    $0x2,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x58(%rbp)
cmpl   $0x0,0x20(%rbp)
je     11b5 <a2b_ord2+0x95>
movl   $0x1,-0x3c(%rbp)
jmp    11bc <a2b_ord2+0x9c>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x0,0x28(%rbp)
je     11d1 <a2b_ord2+0xb1>
mov    -0x4(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    11d7 <a2b_ord2+0xb7>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,0x30(%rbp)
je     11ed <a2b_ord2+0xcd>
movl   $0x1,-0x44(%rbp)
jmp    11f4 <a2b_ord2+0xd4>
movl   $0x0,-0x44(%rbp)
cmpl   $0x0,0x38(%rbp)
je     1209 <a2b_ord2+0xe9>
mov    -0x8(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    120f <a2b_ord2+0xef>
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    12ee <a2b_ord2+0x1ce>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    12db <a2b_ord2+0x1bb>
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  0xd65(%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    1227 <a2b_ord2+0x107>
jmp    12e0 <a2b_ord2+0x1c0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1215 <a2b_ord2+0xf5>
cmpl   $0x0,0x20(%rbp)
je     134c <a2b_ord2+0x22c>
cmpl   $0x0,0x30(%rbp)
je     134c <a2b_ord2+0x22c>
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  0xcc0(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x0,0x28(%rbp)
je     13b6 <a2b_ord2+0x296>
cmpl   $0x0,0x30(%rbp)
je     13b6 <a2b_ord2+0x296>
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  0xc5b(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,0x28(%rbp)
je     143d <a2b_ord2+0x31d>
cmpl   $0x0,0x38(%rbp)
je     143d <a2b_ord2+0x31d>
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  0xbdd(%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     14be <a2b_ord2+0x39e>
cmpl   $0x0,0x38(%rbp)
je     14be <a2b_ord2+0x39e>
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  0xb59(%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     15b5 <a2b_ord2+0x495>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     1534 <a2b_ord2+0x414>
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  0xafb(%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    14ce <a2b_ord2+0x3ae>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    15b0 <a2b_ord2+0x490>
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  0xa98(%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    153a <a2b_ord2+0x41a>
jmp    15b5 <a2b_ord2+0x495>
cmpl   $0x0,0x28(%rbp)
je     16b2 <a2b_ord2+0x592>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     162e <a2b_ord2+0x50e>
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  0xa01(%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    15c5 <a2b_ord2+0x4a5>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    16ad <a2b_ord2+0x58d>
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  0x99e(%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    1634 <a2b_ord2+0x514>
jmp    16b2 <a2b_ord2+0x592>
cmpl   $0x0,0x30(%rbp)
je     1792 <a2b_ord2+0x672>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1717 <a2b_ord2+0x5f7>
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  0x918(%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    16c2 <a2b_ord2+0x5a2>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    178d <a2b_ord2+0x66d>
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  0x8b5(%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    171d <a2b_ord2+0x5fd>
jmp    1792 <a2b_ord2+0x672>
cmpl   $0x0,0x38(%rbp)
je     188f <a2b_ord2+0x76f>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     180b <a2b_ord2+0x6eb>
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  0x824(%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    17a2 <a2b_ord2+0x682>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    188a <a2b_ord2+0x76a>
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  0x7c1(%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    1811 <a2b_ord2+0x6f1>
jmp    188f <a2b_ord2+0x76f>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
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    $0xc8,%rsp
mov    %r9,0x98(%rsp)
mov    %r8,0x78(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdx,%r12
mov    %esi,%ebp
mov    %edi,%r14d
mov    0x128(%rsp),%eax
mov    %eax,0x40(%rsp)
mov    0x120(%rsp),%eax
mov    %eax,0xc(%rsp)
mov    0x118(%rsp),%eax
mov    %eax,0x44(%rsp)
mov    0x110(%rsp),%r15d
mov    0x108(%rsp),%r13
mov    0x100(%rsp),%rax
mov    %rax,0x58(%rsp)
lea    0x1(%r14),%ebx
lea    0x1(%rbp),%eax
mov    %eax,0x38(%rsp)
lea    0x2(%r14),%eax
mov    %rax,0xa0(%rsp)
cltq
mov    %rax,0x10(%rsp)
lea    0x10(,%r14,8),%edi
call   1040 <malloc@plt>
mov    %rax,(%rsp)
lea    0x10(,%rbp,8),%edi
call   1040 <malloc@plt>
mov    %r13,%r9
mov    %rax,%r13
xor    %r11d,%r11d
mov    %r15d,0x8(%rsp)
test   %r15d,%r15d
setne  %r11b
cmpl   $0x0,0x44(%rsp)
mov    %ebx,%r8d
mov    %r14,0x90(%rsp)
cmovne %r14d,%r8d
xor    %edx,%edx
cmpl   $0x0,0xc(%rsp)
setne  %dl
cmpl   $0x0,0x40(%rsp)
mov    0x38(%rsp),%eax
mov    %eax,%ecx
mov    %rbp,0x68(%rsp)
cmovne %ebp,%ecx
mov    %rbx,%rax
mov    %rbx,0x70(%rsp)
movslq %ebx,%rsi
mov    %rcx,0x30(%rsp)
mov    %edx,0x3c(%rsp)
cmp    %edx,%ecx
mov    %r9,0x18(%rsp)
mov    %r8,0x20(%rsp)
mov    %r11d,0x2c(%rsp)
mov    %rsi,%rax
mov    %rsi,0x48(%rsp)
jle    1432 <a2b_ord2+0x312>
xor    %edx,%edx
cmpl   $0x0,0xc(%rsp)
setne  %dl
xor    %edi,%edi
cmpl   $0x0,0x8(%rsp)
setne  %dil
mov    0x30(%rsp),%eax
mov    %r8d,%ecx
lea    (%r12,%rdi,8),%rbp
mov    %rbp,0xb8(%rsp)
lea    (%r12,%rcx,8),%rbp
add    $0x8,%rbp
mov    %rbp,0xb0(%rsp)
mov    %rcx,%r10
sub    %rdi,%r10
mov    %r10,0x50(%rsp)
and    $0xfffffffffffffffe,%r10
lea    (%r10,%rdi,1),%rbx
mov    %rbx,0xa8(%rsp)
lea    0x8(%r12),%rbx
mov    %rbx,0xc0(%rsp)
movsd  0x1d8b(%rip),%xmm0
movapd 0x1d53(%rip),%xmm1
mov    %r13,0x88(%rsp)
mov    %rax,0x80(%rsp)
jmp    12d3 <a2b_ord2+0x1b3>
nop
add    $0x1,%rdx
mov    %rdx,%r14
mov    %r14,%rdx
cmp    %rax,%r14
je     1432 <a2b_ord2+0x312>
cmp    %r11d,%r8d
jle    12c0 <a2b_ord2+0x1a0>
mov    %rdx,%r13
mov    0x10(%rsp),%rax
imul   %rax,%r13
lea    0x1(%rdx),%r14
mov    %r14,%r15
imul   %rax,%r15
imul   %rsi,%rdx
mov    %rdi,%rbp
cmpq   $0x2,0x50(%rsp)
jb     13d0 <a2b_ord2+0x2b0>
lea    (%rdx,%rdi,1),%rax
lea    (%r9,%rax,8),%rax
lea    (%rdx,%rcx,1),%rbx
lea    (%r9,%rbx,8),%rbx
mov    0xb8(%rsp),%r8
lea    (%r8,%r15,8),%rbp
mov    0xb0(%rsp),%rsi
lea    (%rsi,%r15,8),%r9
lea    (%r8,%r13,8),%r11
lea    (%rsi,%r13,8),%r8
cmp    %r9,%rax
setb   %r9b
cmp    %rbx,%rbp
setb   %sil
cmp    %r8,%rax
mov    0x20(%rsp),%r8
setb   %al
cmp    %rbx,%r11
mov    0x2c(%rsp),%r11d
setb   %bl
mov    %rdi,%rbp
test   %sil,%r9b
mov    0x18(%rsp),%r9
jne    13d0 <a2b_ord2+0x2b0>
mov    %rdi,%rbp
and    %bl,%al
jne    13d0 <a2b_ord2+0x2b0>
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %rbp,%rax
or     %rdi,%rax
lea    (%rax,%r13,1),%rsi
movupd (%r12,%rsi,8),%xmm2
movupd 0x8(%r12,%rsi,8),%xmm3
addpd  %xmm2,%xmm3
lea    (%rax,%r15,1),%rsi
movupd (%r12,%rsi,8),%xmm2
addpd  %xmm3,%xmm2
movupd 0x8(%r12,%rsi,8),%xmm3
addpd  %xmm2,%xmm3
mulpd  %xmm1,%xmm3
add    %rdx,%rax
movupd %xmm3,(%r9,%rax,8)
add    $0x2,%rbp
cmp    %rbp,%r10
jne    1370 <a2b_ord2+0x250>
mov    0xa8(%rsp),%rbp
cmp    %r10,0x50(%rsp)
je     1418 <a2b_ord2+0x2f8>
nopl   0x0(%rax)
lea    (%r9,%rdx,8),%rdx
mov    0xc0(%rsp),%rax
lea    (%rax,%r15,8),%rbx
lea    (%rax,%r13,8),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rax,%rbp,8),%xmm2
addsd  (%rax,%rbp,8),%xmm2
addsd  -0x8(%rbx,%rbp,8),%xmm2
addsd  (%rbx,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rdx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rcx
jne    13f0 <a2b_ord2+0x2d0>
mov    0x88(%rsp),%r13
mov    0x48(%rsp),%rsi
mov    0x80(%rsp),%rax
jmp    12c7 <a2b_ord2+0x1a7>
mov    0x90(%rsp),%rdi
movslq %edi,%rsi
cmpl   $0x0,0x8(%rsp)
mov    0xc(%rsp),%ecx
je     1472 <a2b_ord2+0x352>
test   %ecx,%ecx
je     1472 <a2b_ord2+0x352>
movsd  0x18(%r12,%rsi,8),%xmm0
mov    0x10(%rsp),%rax
addsd  (%r12,%rax,8),%xmm0
addsd  0x8(%r12),%xmm0
mulsd  0x1bcb(%rip),%xmm0
movsd  %xmm0,(%r9)
cmpl   $0x0,0x44(%rsp)
mov    0x58(%rsp),%r11
mov    (%rsp),%r10
mov    0xa0(%rsp),%r14
mov    0x98(%rsp),%r15
mov    0x78(%rsp),%r8
mov    0x60(%rsp),%rbx
je     14d0 <a2b_ord2+0x3b0>
test   %ecx,%ecx
je     14d0 <a2b_ord2+0x3b0>
lea    (%r14,%rdi,1),%eax
cltq
movsd  (%r12,%rax,8),%xmm0
addsd  (%r12,%rsi,8),%xmm0
mov    0x70(%rsp),%rax
add    %r14d,%eax
cltq
addsd  (%r12,%rax,8),%xmm0
mulsd  0x1b6e(%rip),%xmm0
movsd  %xmm0,(%r9,%rsi,8)
cmpl   $0x0,0x44(%rsp)
je     152d <a2b_ord2+0x40d>
cmpl   $0x0,0x40(%rsp)
je     152d <a2b_ord2+0x40d>
mov    %r14d,%eax
mov    0x68(%rsp),%rdx
imul   %edx,%eax
lea    (%rax,%rdi,1),%ecx
movslq %ecx,%rcx
movsd  (%r12,%rcx,8),%xmm0
mov    0x70(%rsp),%rcx
add    %ecx,%eax
cltq
addsd  (%r12,%rax,8),%xmm0
mov    0x38(%rsp),%eax
imul   %r14d,%eax
add    %edi,%eax
cltq
addsd  (%r12,%rax,8),%xmm0
mulsd  0x1b1a(%rip),%xmm0
mov    %ecx,%eax
imul   %edx,%eax
add    %edi,%eax
cltq
movsd  %xmm0,(%r9,%rax,8)
mov    %rsi,0x50(%rsp)
cmpl   $0x0,0x8(%rsp)
je     1583 <a2b_ord2+0x463>
cmpl   $0x0,0x40(%rsp)
je     1583 <a2b_ord2+0x463>
mov    %r14d,%eax
mov    0x68(%rsp),%rcx
imul   %ecx,%eax
cltq
movsd  0x8(%r12,%rax,8),%xmm0
addsd  (%r12,%rax,8),%xmm0
mov    0x38(%rsp),%eax
imul   %r14d,%eax
cltq
addsd  0x8(%r12,%rax,8),%xmm0
mulsd  0x1ac5(%rip),%xmm0
mov    0x70(%rsp),%rax
imul   %ecx,%eax
cltq
movsd  %xmm0,(%r9,%rax,8)
cmpl   $0x0,0x8(%rsp)
je     176f <a2b_ord2+0x64f>
mov    0x3c(%rsp),%eax
cmp    %eax,0x30(%rsp)
jl     1668 <a2b_ord2+0x548>
xor    %ecx,%ecx
mov    0xc(%rsp),%edi
test   %edi,%edi
setne  %cl
mov    0x30(%rsp),%rax
lea    0x1(%rax),%edx
mov    %edx,%esi
sub    %ecx,%esi
mov    %rcx,%rax
not    %rax
test   $0x1,%sil
je     15f9 <a2b_ord2+0x4d9>
xor    %esi,%esi
mov    %edi,%ebx
xor    %edi,%edi
test   %ebx,%ebx
mov    0x60(%rsp),%rbx
cmovne 0x10(%rsp),%rsi
setne  %dil
movsd  (%r12,%rsi,8),%xmm0
addsd  0x8(%r12,%rsi,8),%xmm0
mulsd  0x1a55(%rip),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
add    $0x1,%rdi
mov    %rdi,%rcx
add    %rdx,%rax
je     1668 <a2b_ord2+0x548>
mov    %rcx,%rax
mov    0x10(%rsp),%rbx
imul   %rbx,%rax
lea    0x8(%r12),%rsi
mov    %rbx,%rdi
shl    $0x4,%rdi
lea    0x1(%rcx),%rbp
imul   %rbx,%rbp
mov    0x60(%rsp),%rbx
movsd  0x1a15(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rax,8),%xmm1
addsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
movsd  -0x8(%rsi,%rbp,8),%xmm1
addsd  (%rsi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rcx,8)
add    $0x2,%rcx
add    %rdi,%rsi
cmp    %rcx,%rdx
jne    1630 <a2b_ord2+0x510>
mov    0x3c(%rsp),%eax
cmp    %eax,0x30(%rsp)
jle    176f <a2b_ord2+0x64f>
xor    %edx,%edx
mov    0xc(%rsp),%edi
test   %edi,%edi
setne  %dl
mov    0x30(%rsp),%rsi
mov    %esi,%ecx
sub    %edx,%esi
mov    %rdx,%rax
not    %rax
test   $0x1,%sil
je     16d6 <a2b_ord2+0x5b6>
movsd  (%rbx,%rdx,8),%xmm0
movsd  0x19a5(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x0(%r13,%rdx,8),%xmm0
xor    %edx,%edx
xor    %esi,%esi
test   %edi,%edi
setne  %sil
cmovne 0x48(%rsp),%rdx
mulsd  0x8(%r13,%rsi,8),%xmm1
add    $0x1,%rsi
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r9,%rdx,8)
mov    %rsi,%rdx
add    %rcx,%rax
je     176f <a2b_ord2+0x64f>
mov    %rdx,%rsi
mov    0x48(%rsp),%rbx
imul   %rbx,%rsi
mov    %rbx,%rdi
shl    $0x4,%rdi
lea    0x1(%rdx),%rax
imul   %rbx,%rax
mov    0x60(%rsp),%rbx
movsd  0x1941(%rip),%xmm0
mov    %r9,%rbp
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm1
movapd %xmm0,%xmm2
subsd  %xmm1,%xmm2
mulsd  0x8(%r13,%rdx,8),%xmm2
mulsd  0x0(%r13,%rdx,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%rbp,%rsi,8)
movsd  0x8(%rbx,%rdx,8),%xmm1
movapd %xmm0,%xmm2
subsd  %xmm1,%xmm2
mulsd  0x10(%r13,%rdx,8),%xmm2
mulsd  0x8(%r13,%rdx,8),%xmm1
lea    0x2(%rdx),%rbx
addsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    %rdi,%rbp
mov    %rbx,%rdx
cmp    %rbx,%rcx
mov    0x60(%rsp),%rbx
jne    1710 <a2b_ord2+0x5f0>
cmpl   $0x0,0x44(%rsp)
je     199a <a2b_ord2+0x87a>
mov    0x3c(%rsp),%eax
cmp    %eax,0x30(%rsp)
jl     1896 <a2b_ord2+0x776>
xor    %ecx,%ecx
mov    0xc(%rsp),%edi
test   %edi,%edi
setne  %cl
mov    0x30(%rsp),%rax
lea    0x1(%rax),%r9d
mov    %r9d,%edx
sub    %ecx,%edx
mov    %rcx,%rax
not    %rax
test   $0x1,%dl
je     17eb <a2b_ord2+0x6cb>
xor    %edx,%edx
xor    %esi,%esi
test   %edi,%edi
setne  %sil
cmovne 0x10(%rsp),%rdx
mov    0x50(%rsp),%rdi
add    %rdx,%rdi
movsd  (%r12,%rdi,8),%xmm0
add    0x48(%rsp),%rdx
addsd  (%r12,%rdx,8),%xmm0
mulsd  0x1863(%rip),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
add    $0x1,%rsi
mov    %rsi,%rcx
add    %r9,%rax
je     1896 <a2b_ord2+0x776>
mov    %rcx,%rax
mov    %r14,%r8
mov    0x10(%rsp),%r14
imul   %r14,%rax
mov    0x48(%rsp),%rdx
lea    0x0(,%rdx,8),%rbp
lea    0x0(,%rax,8),%rsi
add    %rbp,%rsi
lea    -0x2(%r14),%rdi
shl    $0x4,%rdi
add    $0x20,%rdi
lea    -0x10(,%r14,8),%rbx
ff
lea    (%rbx,%rax,8),%rax
lea    0x1(%rcx),%rdx
imul   %r14,%rdx
mov    %r8,%r14
mov    0x78(%rsp),%r8
lea    0x0(%rbp,%rdx,8),%rbp
lea    (%rbx,%rdx,8),%rdx
movsd  0x17ec(%rip),%xmm0
mov    %r12,%rbx
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,1),%xmm1
addsd  (%rbx,%rsi,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
movsd  (%rbx,%rdx,1),%xmm1
addsd  (%rbx,%rbp,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rcx,8)
add    $0x2,%rcx
add    %rdi,%rbx
cmp    %rcx,%r9
jne    1860 <a2b_ord2+0x740>
mov    0x3c(%rsp),%eax
cmp    %eax,0x30(%rsp)
mov    0x18(%rsp),%r9
mov    0x48(%rsp),%rbx
jle    199a <a2b_ord2+0x87a>
xor    %edx,%edx
mov    0xc(%rsp),%edi
test   %edi,%edi
setne  %dl
mov    0x30(%rsp),%rax
mov    %eax,%ecx
sub    %edx,%eax
mov    %rdx,%rsi
not    %rsi
test   $0x1,%al
je     190c <a2b_ord2+0x7ec>
movsd  (%r8,%rdx,8),%xmm0
movsd  0x176e(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x0(%r13,%rdx,8),%xmm0
xor    %eax,%eax
xor    %edx,%edx
test   %edi,%edi
setne  %dl
cmovne %rbx,%rax
mulsd  0x8(%r13,%rdx,8),%xmm1
add    $0x1,%rdx
addsd  %xmm1,%xmm0
add    0x50(%rsp),%rax
movsd  %xmm0,(%r9,%rax,8)
add    %rcx,%rsi
je     199a <a2b_ord2+0x87a>
mov    %rdx,%rax
imul   %rbx,%rax
lea    (%r9,%rax,8),%rax
mov    0x10(%rsp),%rsi
add    $0xfffffffffffffffe,%rsi
lea    0x1(%rdx),%rdi
imul   %rbx,%rdi
add    %rbx,%rbx
lea    (%r9,%rdi,8),%rdi
movsd  0x1708(%rip),%xmm0
movsd  (%r8,%rdx,8),%xmm1
movapd %xmm0,%xmm2
subsd  %xmm1,%xmm2
mulsd  0x8(%r13,%rdx,8),%xmm2
mulsd  0x0(%r13,%rdx,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rax,%rsi,8)
movsd  0x8(%r8,%rdx,8),%xmm1
movapd %xmm0,%xmm2
subsd  %xmm1,%xmm2
mulsd  0x10(%r13,%rdx,8),%xmm2
mulsd  0x8(%r13,%rdx,8),%xmm1
lea    0x2(%rdx),%rbp
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
add    %rbx,%rsi
mov    %rbp,%rdx
cmp    %rbp,%rcx
jne    1940 <a2b_ord2+0x820>
cmpl   $0x0,0xc(%rsp)
mov    0x20(%rsp),%rbp
je     1dd9 <a2b_ord2+0xcb9>
cmp    0x2c(%rsp),%ebp
jl     1c06 <a2b_ord2+0xae6>
xor    %edx,%edx
cmpl   $0x0,0x8(%rsp)
setne  %dl
mov    0x20(%rsp),%rax
lea    0x1(%rax),%esi
mov    %rsi,%r10
sub    %rdx,%r10
cmp    $0x4,%r10
jae    19db <a2b_ord2+0x8bb>
mov    (%rsp),%r10
jmp    1b71 <a2b_ord2+0xa51>
mov    (%rsp),%rax
lea    (%rax,%rdx,8),%rcx
lea    (%rax,%rsi,8),%rdi
mov    0x10(%rsp),%rax
lea    (%rax,%rdx,1),%rbp
lea    (%r12,%rbp,8),%rbp
lea    (%rax,%rsi,1),%rbx
lea    (%r12,%rbx,8),%rbx
lea    (%r12,%rdx,8),%r8
lea    (%r12,%rsi,8),%rax
cmp    %rbx,%rcx
setb   %r9b
cmp    %rdi,%rbp
setb   %bl
cmp    %rax,%rcx
setb   %cl
cmp    %rdi,%r8
setb   %al
test   %bl,%r9b
jne    1b68 <a2b_ord2+0xa48>
and    %al,%cl
jne    1b68 <a2b_ord2+0xa48>
mov    %r10,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
mov    %rcx,0x50(%rsp)
je     21b8 <a2b_ord2+0x1098>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %ebp,%ebp
movapd 0x15ad(%rip),%xmm0
mov    (%rsp),%rbx
mov    0x10(%rsp),%r8
nopl   0x0(%rax)
mov    %rbp,%rdi
or     %rdx,%rdi
movupd (%r12,%rdi,8),%xmm1
movupd 0x10(%r12,%rdi,8),%xmm2
lea    (%rdi,%r8,1),%rax
movupd (%r12,%rax,8),%xmm3
addpd  %xmm1,%xmm3
movupd 0x10(%r12,%rax,8),%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm1
movupd %xmm3,(%rbx,%rdi,8)
movupd %xmm1,0x10(%rbx,%rdi,8)
or     $0x4,%rdi
movupd (%r12,%rdi,8),%xmm1
movupd 0x10(%r12,%rdi,8),%xmm2
lea    (%rdi,%r8,1),%rax
movupd (%r12,%rax,8),%xmm3
addpd  %xmm1,%xmm3
movupd 0x10(%r12,%rax,8),%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm1
movupd %xmm3,(%rbx,%rdi,8)
movupd %xmm1,0x10(%rbx,%rdi,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rcx
jne    1a70 <a2b_ord2+0x950>
test   $0x1,%r9b
je     1b4c <a2b_ord2+0xa2c>
or     %rdx,%rbp
movupd (%r12,%rbp,8),%xmm0
movupd 0x10(%r12,%rbp,8),%xmm1
mov    0x10(%rsp),%rax
add    %rbp,%rax
movupd (%r12,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r12,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movapd 0x14db(%rip),%xmm1
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm0
mov    (%rsp),%rax
movupd %xmm2,(%rax,%rbp,8)
movupd %xmm0,0x10(%rax,%rbp,8)
mov    0x50(%rsp),%rax
cmp    %rax,%r10
mov    (%rsp),%r10
mov    0x18(%rsp),%r9
je     1c06 <a2b_ord2+0xae6>
or     %rax,%rdx
jmp    1b71 <a2b_ord2+0xa51>
mov    (%rsp),%r10
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%rdi
mov    %esi,%ecx
sub    %edx,%ecx
mov    %rdx,%rax
not    %rax
test   $0x1,%cl
je     1ba7 <a2b_ord2+0xa87>
movsd  (%r12,%rdx,8),%xmm0
lea    (%rdx,%rdi,1),%rcx
addsd  (%r12,%rcx,8),%xmm0
mulsd  0x14a3(%rip),%xmm0
movsd  %xmm0,(%r10,%rdx,8)
add    $0x1,%rdx
add    %rsi,%rax
je     1c06 <a2b_ord2+0xae6>
mov    0x10(%rsp),%rax
lea    (%r12,%rax,8),%rax
add    $0x8,%rax
movsd  0x147f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,8),%xmm1
addsd  -0x8(%rax,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%rdx,8)
movsd  0x8(%r12,%rdx,8),%xmm1
addsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r10,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1bd0 <a2b_ord2+0xab0>
mov    0x20(%rsp),%rbp
cmp    0x2c(%rsp),%ebp
jle    1dd9 <a2b_ord2+0xcb9>
xor    %ecx,%ecx
cmpl   $0x0,0x8(%rsp)
setne  %cl
mov    %ebp,%edx
mov    %rdx,%r8
sub    %rcx,%r8
cmp    $0x4,%r8
jae    1c35 <a2b_ord2+0xb15>
mov    %rcx,%rax
jmp    1d27 <a2b_ord2+0xc07>
lea    (%r9,%rcx,8),%rax
lea    (%r9,%rdx,8),%rsi
lea    (%r15,%rcx,8),%rdi
lea    (%r15,%rdx,8),%rbp
lea    (%r10,%rcx,8),%r9
lea    (%r10,%rdx,8),%rbx
add    $0x8,%rbx
cmp    %rbp,%rax
setb   %r10b
cmp    %rsi,%rdi
setb   %dil
cmp    %rbx,%rax
setb   %al
cmp    %rsi,%r9
setb   %bl
test   %dil,%r10b
jne    1d1b <a2b_ord2+0xbfb>
and    %bl,%al
jne    1d1b <a2b_ord2+0xbfb>
mov    %r8,%rdi
and    $0xfffffffffffffffc,%rdi
lea    (%rdi,%rcx,1),%rax
xor    %ebp,%ebp
movapd 0x138f(%rip),%xmm0
mov    (%rsp),%r10
mov    0x18(%rsp),%r9
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rsi
or     %rcx,%rsi
movupd (%r15,%rsi,8),%xmm1
movupd 0x10(%r15,%rsi,8),%xmm2
movapd %xmm0,%xmm3
subpd  %xmm1,%xmm3
movapd %xmm0,%xmm4
subpd  %xmm2,%xmm4
movupd (%r10,%rsi,8),%xmm5
movupd 0x8(%r10,%rsi,8),%xmm6
mulpd  %xmm3,%xmm6
movupd 0x10(%r10,%rsi,8),%xmm3
movupd 0x18(%r10,%rsi,8),%xmm7
mulpd  %xmm4,%xmm7
mulpd  %xmm1,%xmm5
addpd  %xmm6,%xmm5
mulpd  %xmm2,%xmm3
addpd  %xmm7,%xmm3
movupd %xmm5,(%r9,%rsi,8)
movupd %xmm3,0x10(%r9,%rsi,8)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    1ca0 <a2b_ord2+0xb80>
cmp    %rdi,%r8
mov    0x20(%rsp),%rbp
jne    1d2c <a2b_ord2+0xc0c>
jmp    1dd9 <a2b_ord2+0xcb9>
mov    %rcx,%rax
mov    (%rsp),%r10
mov    0x18(%rsp),%r9
mov    0x20(%rsp),%rbp
mov    %edx,%esi
sub    %eax,%esi
mov    %rax,%rcx
not    %rcx
test   $0x1,%sil
je     1d69 <a2b_ord2+0xc49>
movsd  (%r15,%rax,8),%xmm0
movsd  0x12fe(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x8(%r10,%rax,8),%xmm1
mulsd  (%r10,%rax,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r9,%rax,8)
add    $0x1,%rax
add    %rdx,%rcx
je     1dd9 <a2b_ord2+0xcb9>
movsd  0x12d2(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
movapd %xmm0,%xmm2
subsd  %xmm1,%xmm2
mulsd  0x8(%r10,%rax,8),%xmm2
mulsd  (%r10,%rax,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%r9,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm1
movapd %xmm0,%xmm2
subsd  %xmm1,%xmm2
mulsd  0x10(%r10,%rax,8),%xmm2
mulsd  0x8(%r10,%rax,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r9,%rax,8)
lea    0x2(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%rdx
jne    1d80 <a2b_ord2+0xc60>
cmpl   $0x0,0x40(%rsp)
je     2197 <a2b_ord2+0x1077>
cmp    0x2c(%rsp),%ebp
jl     1fa4 <a2b_ord2+0xe84>
xor    %edi,%edi
cmpl   $0x0,0x8(%rsp)
setne  %dil
mov    0x38(%rsp),%eax
imul   %r14d,%eax
imul   0x68(%rsp),%r14d
movslq %r14d,%r9
movslq %eax,%r15
lea    0x1(%rbp),%edx
mov    %rdx,%r8
sub    %rdi,%r8
cmp    $0x4,%r8
jae    1e24 <a2b_ord2+0xd04>
mov    %rdi,%rsi
jmp    1f0e <a2b_ord2+0xdee>
lea    (%r10,%rdi,8),%rax
lea    (%r10,%rdx,8),%rsi
lea    (%r15,%rdi,1),%rbp
lea    (%r12,%rbp,8),%r10
lea    (%r15,%rdx,1),%rbx
lea    (%r12,%rbx,8),%rbx
lea    (%r9,%rdi,1),%rbp
lea    (%r12,%rbp,8),%r11
lea    (%r9,%rdx,1),%rbp
lea    (%r12,%rbp,8),%rbp
cmp    %rbx,%rax
setb   %r14b
cmp    %rsi,%r10
setb   %bl
cmp    %rbp,%rax
setb   %al
cmp    %rsi,%r11
setb   %sil
test   %bl,%r14b
jne    1efd <a2b_ord2+0xddd>
and    %sil,%al
mov    0x58(%rsp),%r11
jne    1f07 <a2b_ord2+0xde7>
mov    %r8,%rax
and    $0xfffffffffffffffc,%rax
lea    (%rax,%rdi,1),%rsi
xor    %ebx,%ebx
movapd 0x117e(%rip),%xmm0
mov    (%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rbp
or     %rdi,%rbp
lea    (%r9,%rbp,1),%rcx
movupd (%r12,%rcx,8),%xmm1
movupd 0x10(%r12,%rcx,8),%xmm2
lea    (%r15,%rbp,1),%rcx
movupd (%r12,%rcx,8),%xmm3
addpd  %xmm1,%xmm3
movupd 0x10(%r12,%rcx,8),%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm1
movupd %xmm3,(%r10,%rbp,8)
movupd %xmm1,0x10(%r10,%rbp,8)
add    $0x4,%rbx
cmp    %rbx,%rax
jne    1ea0 <a2b_ord2+0xd80>
cmp    %rax,%r8
mov    0x20(%rsp),%rbp
jne    1f13 <a2b_ord2+0xdf3>
jmp    1fa4 <a2b_ord2+0xe84>
mov    %rdi,%rsi
mov    0x58(%rsp),%r11
jmp    1f0a <a2b_ord2+0xdea>
mov    %rdi,%rsi
mov    (%rsp),%r10
mov    0x20(%rsp),%rbp
mov    %edx,%ecx
sub    %esi,%ecx
mov    %rsi,%rax
not    %rax
test   $0x1,%cl
je     1f48 <a2b_ord2+0xe28>
lea    (%rsi,%r9,1),%rcx
movsd  (%r12,%rcx,8),%xmm0
lea    (%rsi,%r15,1),%rcx
addsd  (%r12,%rcx,8),%xmm0
mulsd  0x1102(%rip),%xmm0
movsd  %xmm0,(%r10,%rsi,8)
add    $0x1,%rsi
add    %rdx,%rax
je     1fa4 <a2b_ord2+0xe84>
lea    (%r12,%r15,8),%rax
add    $0x8,%rax
lea    (%r12,%r9,8),%rcx
add    $0x8,%rcx
movsd  0x10db(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rcx,%rsi,8),%xmm1
addsd  -0x8(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%rsi,8)
movsd  (%rcx,%rsi,8),%xmm1
addsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r10,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rdx
jne    1f70 <a2b_ord2+0xe50>
cmp    0x2c(%rsp),%ebp
mov    0x18(%rsp),%rcx
jle    2197 <a2b_ord2+0x1077>
xor    %esi,%esi
cmpl   $0x0,0x8(%rsp)
setne  %sil
mov    0x70(%rsp),%rax
imul   0x68(%rsp),%eax
movslq %eax,%r14
mov    %ebp,%eax
mov    %rax,%r8
sub    %rsi,%r8
cmp    $0x4,%r8
jae    1fe1 <a2b_ord2+0xec1>
mov    %rsi,%rdx
jmp    20e8 <a2b_ord2+0xfc8>
lea    (%r14,%rsi,1),%rdx
lea    (%rcx,%rdx,8),%rdx
lea    (%r14,%rax,1),%rdi
lea    (%rcx,%rdi,8),%rdi
mov    %r10,%rbp
lea    (%r11,%rsi,8),%r10
lea    (%r11,%rax,8),%rbx
lea    0x0(,%rsi,8),%r9
add    %rbp,%r9
lea    0x8(%rbp,%rax,8),%rbp
cmp    %rbx,%rdx
setb   %r11b
cmp    %rdi,%r10
setb   %bl
cmp    %rbp,%rdx
setb   %dl
cmp    %rdi,%r9
setb   %dil
test   %bl,%r11b
jne    20d7 <a2b_ord2+0xfb7>
and    %dil,%dl
jne    20d7 <a2b_ord2+0xfb7>
mov    %r8,%rdi
and    $0xfffffffffffffffc,%rdi
lea    (%rdi,%rsi,1),%rdx
xor    %ebp,%ebp
movapd 0xfd3(%rip),%xmm0
mov    0x58(%rsp),%r11
mov    (%rsp),%r10
mov    0x18(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rbx
or     %rsi,%rbx
movupd (%r11,%rbx,8),%xmm1
movupd 0x10(%r11,%rbx,8),%xmm2
movapd %xmm0,%xmm3
subpd  %xmm1,%xmm3
movapd %xmm0,%xmm4
subpd  %xmm2,%xmm4
movupd (%r10,%rbx,8),%xmm5
movupd 0x8(%r10,%rbx,8),%xmm6
mulpd  %xmm3,%xmm6
movupd 0x10(%r10,%rbx,8),%xmm3
movupd 0x18(%r10,%rbx,8),%xmm7
mulpd  %xmm4,%xmm7
mulpd  %xmm1,%xmm5
addpd  %xmm6,%xmm5
mulpd  %xmm2,%xmm3
addpd  %xmm7,%xmm3
add    %r14,%rbx
movupd %xmm5,(%rcx,%rbx,8)
movupd %xmm3,0x10(%rcx,%rbx,8)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    2060 <a2b_ord2+0xf40>
cmp    %rdi,%r8
jne    20e8 <a2b_ord2+0xfc8>
jmp    2197 <a2b_ord2+0x1077>
mov    %rsi,%rdx
mov    0x58(%rsp),%r11
mov    (%rsp),%r10
mov    0x18(%rsp),%rcx
mov    %eax,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
test   $0x1,%dil
je     212a <a2b_ord2+0x100a>
movsd  (%r11,%rdx,8),%xmm0
movsd  0xf42(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x8(%r10,%rdx,8),%xmm1
mulsd  (%r10,%rdx,8),%xmm0
lea    0x1(%rdx),%rdi
addsd  %xmm1,%xmm0
add    %r14,%rdx
movsd  %xmm0,(%rcx,%rdx,8)
mov    %rdi,%rdx
add    %rax,%rsi
je     2197 <a2b_ord2+0x1077>
lea    (%rcx,%r14,8),%rcx
add    $0x8,%rcx
movsd  0xf09(%rip),%xmm0
nop
movsd  (%r11,%rdx,8),%xmm1
movapd %xmm0,%xmm2
subsd  %xmm1,%xmm2
mulsd  0x8(%r10,%rdx,8),%xmm2
mulsd  (%r10,%rdx,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,-0x8(%rcx,%rdx,8)
movsd  0x8(%r11,%rdx,8),%xmm1
movapd %xmm0,%xmm2
subsd  %xmm1,%xmm2
mulsd  0x10(%r10,%rdx,8),%xmm2
mulsd  0x8(%r10,%rdx,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
lea    0x2(%rdx),%rsi
mov    %rsi,%rdx
cmp    %rsi,%rax
jne    2140 <a2b_ord2+0x1020>
mov    %r10,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %ebp,%ebp
test   $0x1,%r9b
jne    1b00 <a2b_ord2+0x9e0>
jmp    1b4c <a2b_ord2+0xa2c>

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