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

/* Forward declarations */

/* Type definitions */
typedef int int64_t;

/* Variables and functions */
scalar_t__ stdlib_base_is_nan(double const);
double stdlib_strided_dnansumpw(const int64_t N, const double *X,
                                const int64_t stride) {
  double *xp1;
  double *xp2;
  double sum;
  int64_t ix;
  int64_t M;
  int64_t n;
  int64_t i;
  double s0;
  double s1;
  double s2;
  double s3;
  double s4;
  double s5;
  double s6;
  double s7;
  if (N <= 0) {
    return 0.0;
  }
  if (N == 1 || stride == 0) {
    if (stdlib_base_is_nan(X[0])) {
      return 0.0;
    }
    return X[0];
  }
  if (stride < 0) {
    ix = (1 - N) * stride;
  } else {
    ix = 0;
  }
  if (N < 8) {
    sum = 0.0;
    for (i = 0; i < N; i++) {
      if (!stdlib_base_is_nan(X[ix])) {
        sum += X[ix];
      }
      ix += stride;
    }
    return sum;
  }
  if (N <= 128) {
    s0 = (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
    ix += stride;
    s1 = (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
    ix += stride;
    s2 = (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
    ix += stride;
    s3 = (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
    ix += stride;
    s4 = (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
    ix += stride;
    s5 = (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
    ix += stride;
    s6 = (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
    ix += stride;
    s7 = (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
    ix += stride;
    M = N % 8;
    for (i = 8; i < N - M; i += 8) {
      s0 += (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
      ix += stride;
      s1 += (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
      ix += stride;
      s2 += (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
      ix += stride;
      s3 += (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
      ix += stride;
      s4 += (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
      ix += stride;
      s5 += (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
      ix += stride;
      s6 += (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
      ix += stride;
      s7 += (stdlib_base_is_nan(X[ix])) ? 0.0 : X[ix];
      ix += stride;
    }
    sum = ((s0 + s1) + (s2 + s3)) + ((s4 + s5) + (s6 + s7));
    for (; i < N; i++) {
      if (!stdlib_base_is_nan(X[ix])) {
        sum += X[ix];
      }
      ix += stride;
    }
    return sum;
  }
  n = N / 2;
  n -= n % 8;
  if (stride < 0) {
    xp1 = (double *)X + ((n - N) * stride);
    xp2 = (double *)X;
  } else {
    xp1 = (double *)X;
    xp2 = (double *)X + (n * stride);
  }
  return stdlib_strided_dnansumpw(n, xp1, stride) +
         stdlib_strided_dnansumpw(N - n, xp2, stride);
}


x86 assembly (clang, -O0):
<stdlib_strided_dnansumpw>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %edi,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
cmpl   $0x0,-0xc(%rbp)
jg     114c <stdlib_strided_dnansumpw+0x2c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    196e <stdlib_strided_dnansumpw+0x84e>
cmpl   $0x1,-0xc(%rbp)
je     1160 <stdlib_strided_dnansumpw+0x40>
cmpl   $0x0,-0x1c(%rbp)
jne    1196 <stdlib_strided_dnansumpw+0x76>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     1184 <stdlib_strided_dnansumpw+0x64>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    196e <stdlib_strided_dnansumpw+0x84e>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    196e <stdlib_strided_dnansumpw+0x84e>
cmpl   $0x0,-0x1c(%rbp)
jge    11b4 <stdlib_strided_dnansumpw+0x94>
mov    $0x1,%eax
sub    -0xc(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    11bb <stdlib_strided_dnansumpw+0x9b>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x8,-0xc(%rbp)
jge    1239 <stdlib_strided_dnansumpw+0x119>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    122a <stdlib_strided_dnansumpw+0x10a>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
jne    1213 <stdlib_strided_dnansumpw+0xf3>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11d4 <stdlib_strided_dnansumpw+0xb4>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    196e <stdlib_strided_dnansumpw+0x84e>
cmpl   $0x80,-0xc(%rbp)
jg     18bc <stdlib_strided_dnansumpw+0x79c>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     1272 <stdlib_strided_dnansumpw+0x152>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1287 <stdlib_strided_dnansumpw+0x167>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     12c9 <stdlib_strided_dnansumpw+0x1a9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    12de <stdlib_strided_dnansumpw+0x1be>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     1320 <stdlib_strided_dnansumpw+0x200>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1335 <stdlib_strided_dnansumpw+0x215>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     1377 <stdlib_strided_dnansumpw+0x257>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    138c <stdlib_strided_dnansumpw+0x26c>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     13ce <stdlib_strided_dnansumpw+0x2ae>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    13e3 <stdlib_strided_dnansumpw+0x2c3>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     1425 <stdlib_strided_dnansumpw+0x305>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    143a <stdlib_strided_dnansumpw+0x31a>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     147c <stdlib_strided_dnansumpw+0x35c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1491 <stdlib_strided_dnansumpw+0x371>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     14d3 <stdlib_strided_dnansumpw+0x3b3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    14e8 <stdlib_strided_dnansumpw+0x3c8>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x40(%rbp)
movl   $0x8,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x40(%rbp),%ecx
cmp    %ecx,%eax
jge    181b <stdlib_strided_dnansumpw+0x6fb>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     1553 <stdlib_strided_dnansumpw+0x433>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    1568 <stdlib_strided_dnansumpw+0x448>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     15af <stdlib_strided_dnansumpw+0x48f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    15c4 <stdlib_strided_dnansumpw+0x4a4>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     160b <stdlib_strided_dnansumpw+0x4eb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1620 <stdlib_strided_dnansumpw+0x500>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     1667 <stdlib_strided_dnansumpw+0x547>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    167c <stdlib_strided_dnansumpw+0x55c>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     16c3 <stdlib_strided_dnansumpw+0x5a3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    16d8 <stdlib_strided_dnansumpw+0x5b8>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     171f <stdlib_strided_dnansumpw+0x5ff>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    1734 <stdlib_strided_dnansumpw+0x614>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     177b <stdlib_strided_dnansumpw+0x65b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    1790 <stdlib_strided_dnansumpw+0x670>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
je     17d7 <stdlib_strided_dnansumpw+0x6b7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    17ec <stdlib_strided_dnansumpw+0x6cc>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x48(%rbp)
jmp    1516 <stdlib_strided_dnansumpw+0x3f6>
movsd  -0x50(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
addsd  -0x78(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
addsd  -0x88(%rbp),%xmm2
ff
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18ad <stdlib_strided_dnansumpw+0x78d>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
cmp    $0x0,%rax
jne    1896 <stdlib_strided_dnansumpw+0x776>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1857 <stdlib_strided_dnansumpw+0x737>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    196e <stdlib_strided_dnansumpw+0x84e>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x44(%rbp),%eax
sub    %edx,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    1910 <stdlib_strided_dnansumpw+0x7f0>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    1931 <stdlib_strided_dnansumpw+0x811>
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1040 <stdlib_strided_dnansumpw@plt>
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0xc(%rbp),%edi
sub    -0x44(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1040 <stdlib_strided_dnansumpw@plt>
movaps %xmm0,%xmm1
movsd  -0x110(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stdlib_strided_dnansumpw>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
xorpd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
test   %edi,%edi
jle    16cd <stdlib_strided_dnansumpw+0x5ad>
mov    %rsi,%r14
mov    %edi,%r13d
cmp    $0x1,%edi
je     11bb <stdlib_strided_dnansumpw+0x9b>
mov    %edx,%ebx
test   %edx,%edx
je     11bb <stdlib_strided_dnansumpw+0x9b>
mov    $0x1,%eax
sub    %r13d,%eax
imul   %ebx,%eax
mov    %ebx,%ebp
sar    $0x1f,%ebp
and    %eax,%ebp
cmp    $0x7,%r13d
ja     11d8 <stdlib_strided_dnansumpw+0xb8>
movslq %ebp,%rax
movslq %ebx,%rbp
lea    (%r14,%rax,8),%rbx
shl    $0x3,%rbp
xorpd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
jmp    119d <stdlib_strided_dnansumpw+0x7d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %rbp,%rbx
add    $0xffffffff,%r13d
je     16cd <stdlib_strided_dnansumpw+0x5ad>
movsd  (%rbx),%xmm0
call   1030 <stdlib_base_is_nan@plt>
test   %rax,%rax
jne    1190 <stdlib_strided_dnansumpw+0x70>
movsd  (%rsp),%xmm0
addsd  (%rbx),%xmm0
movsd  %xmm0,(%rsp)
jmp    1190 <stdlib_strided_dnansumpw+0x70>
movsd  (%r14),%xmm0
call   1030 <stdlib_base_is_nan@plt>
test   %rax,%rax
jne    16cd <stdlib_strided_dnansumpw+0x5ad>
movsd  (%r14),%xmm0
jmp    16c8 <stdlib_strided_dnansumpw+0x5a8>
cmp    $0x80,%r13d
ja     15e1 <stdlib_strided_dnansumpw+0x4c1>
movslq %ebp,%r15
movsd  (%r14,%r15,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x28(%rsp)
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
test   %rax,%rax
jne    1214 <stdlib_strided_dnansumpw+0xf4>
movsd  (%r14,%r15,8),%xmm0
movsd  %xmm0,(%rsp)
lea    (%rbx,%rbp,1),%r12d
movslq %r12d,%r15
movsd  (%r14,%r15,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
test   %rax,%rax
jne    1237 <stdlib_strided_dnansumpw+0x117>
movsd  (%r14,%r15,8),%xmm0
movsd  %xmm0,0x28(%rsp)
add    %ebx,%r12d
movslq %r12d,%r15
movsd  (%r14,%r15,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    125f <stdlib_strided_dnansumpw+0x13f>
movsd  (%r14,%r15,8),%xmm0
movsd  %xmm0,0x38(%rsp)
add    %ebx,%r12d
movslq %r12d,%r15
movsd  (%r14,%r15,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
test   %rax,%rax
jne    1287 <stdlib_strided_dnansumpw+0x167>
movsd  (%r14,%r15,8),%xmm0
movsd  %xmm0,0x20(%rsp)
add    %ebx,%r12d
movslq %r12d,%r15
movsd  (%r14,%r15,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x18(%rsp)
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    12af <stdlib_strided_dnansumpw+0x18f>
movsd  (%r14,%r15,8),%xmm0
movsd  %xmm0,0x30(%rsp)
add    %ebx,%r12d
movslq %r12d,%r15
movsd  (%r14,%r15,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
test   %rax,%rax
jne    12d7 <stdlib_strided_dnansumpw+0x1b7>
movsd  (%r14,%r15,8),%xmm0
movsd  %xmm0,0x18(%rsp)
add    %ebx,%r12d
movslq %r12d,%r15
movsd  (%r14,%r15,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    12f6 <stdlib_strided_dnansumpw+0x1d6>
movsd  (%r14,%r15,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rbx,0x8(%rsp)
add    %ebx,%r12d
movslq %r12d,%rbx
movsd  (%r14,%rbx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
test   %rax,%rax
xorpd  %xmm2,%xmm2
jne    1321 <stdlib_strided_dnansumpw+0x201>
movsd  (%r14,%rbx,8),%xmm2
mov    %r13d,%esi
and    $0xfffffff8,%esi
cmp    $0x9,%esi
movsd  0x38(%rsp),%xmm1
jb     1604 <stdlib_strided_dnansumpw+0x4e4>
mov    0x8(%rsp),%rdx
lea    0x0(,%rdx,8),%eax
mov    %rax,0x90(%rsp)
lea    (%rdx,%rdx,4),%eax
lea    (%rax,%rax,2),%ecx
mov    %ecx,0x40(%rsp)
mov    %edx,%ecx
shl    $0x4,%ecx
sub    %edx,%ecx
sub    %edx,%ecx
mov    %rcx,0x88(%rsp)
lea    (%rdx,%rdx,2),%ecx
lea    (%rdx,%rcx,4),%ecx
mov    %rcx,0x80(%rsp)
lea    0x0(,%rdx,4),%ecx
lea    (%rcx,%rcx,2),%ecx
mov    %rcx,0x78(%rsp)
lea    (%rdx,%rax,2),%eax
mov    %rax,0x70(%rsp)
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%eax
mov    %rax,0x68(%rsp)
lea    (%rdx,%rdx,8),%eax
mov    %rax,0x60(%rsp)
mov    $0x8,%r12d
mov    %esi,0x44(%rsp)
jmp    145a <stdlib_strided_dnansumpw+0x33a>
nopl   0x0(%rax)
movsd  0xc0(%rsp),%xmm2
addsd  %xmm0,%xmm2
movsd  (%rsp),%xmm0
addsd  0xb0(%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x28(%rsp),%xmm0
addsd  0x58(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
movsd  0x38(%rsp),%xmm1
addsd  0xa8(%rsp),%xmm1
movsd  0x20(%rsp),%xmm0
addsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x30(%rsp),%xmm0
addsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x18(%rsp),%xmm0
addsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x10(%rsp),%xmm0
addsd  0x98(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
add    $0x8,%r12d
mov    0xb8(%rsp),%rcx
mov    %ecx,%ebp
mov    0x44(%rsp),%esi
cmp    %esi,%r12d
jge    1610 <stdlib_strided_dnansumpw+0x4f0>
movsd  %xmm2,0xc0(%rsp)
movsd  %xmm1,0x38(%rsp)
mov    0x90(%rsp),%rax
add    %ebp,%eax
mov    %rax,0xb8(%rsp)
movslq %eax,%r15
movsd  (%r14,%r15,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x58(%rsp)
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    14a0 <stdlib_strided_dnansumpw+0x380>
movsd  (%r14,%r15,8),%xmm0
movsd  %xmm0,0xb0(%rsp)
mov    0x60(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movsd  (%r14,%rbx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
test   %rax,%rax
jne    14cf <stdlib_strided_dnansumpw+0x3af>
movsd  (%r14,%rbx,8),%xmm0
movsd  %xmm0,0x58(%rsp)
mov    0x68(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movsd  (%r14,%rbx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x50(%rsp)
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    14fb <stdlib_strided_dnansumpw+0x3db>
movsd  (%r14,%rbx,8),%xmm0
movsd  %xmm0,0xa8(%rsp)
mov    0x70(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movsd  (%r14,%rbx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
test   %rax,%rax
jne    152a <stdlib_strided_dnansumpw+0x40a>
movsd  (%r14,%rbx,8),%xmm0
movsd  %xmm0,0x50(%rsp)
mov    0x78(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movsd  (%r14,%rbx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x48(%rsp)
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    1556 <stdlib_strided_dnansumpw+0x436>
movsd  (%r14,%rbx,8),%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    0x80(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movsd  (%r14,%rbx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
test   %rax,%rax
jne    1588 <stdlib_strided_dnansumpw+0x468>
movsd  (%r14,%rbx,8),%xmm0
movsd  %xmm0,0x48(%rsp)
mov    0x88(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movsd  (%r14,%rbx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    15ae <stdlib_strided_dnansumpw+0x48e>
movsd  (%r14,%rbx,8),%xmm0
movsd  %xmm0,0x98(%rsp)
add    0x40(%rsp),%ebp
movslq %ebp,%rbx
movsd  (%r14,%rbx,8),%xmm0
call   1030 <stdlib_base_is_nan@plt>
test   %rax,%rax
xorpd  %xmm0,%xmm0
jne    13b0 <stdlib_strided_dnansumpw+0x290>
movsd  (%r14,%rbx,8),%xmm0
jmp    13b0 <stdlib_strided_dnansumpw+0x290>
mov    %r13d,%ebp
shr    %ebp
and    $0xfffffff8,%ebp
mov    %ebp,%eax
test   %ebx,%ebx
js     1699 <stdlib_strided_dnansumpw+0x579>
imul   %ebx,%eax
cltq
mov    %r14,%rsi
lea    (%r14,%rax,8),%r14
jmp    16a5 <stdlib_strided_dnansumpw+0x585>
add    0x8(%rsp),%r12d
mov    $0x8,%esi
jmp    1619 <stdlib_strided_dnansumpw+0x4f9>
mov    0x8(%rsp),%rax
lea    (%rcx,%rax,8),%r12d
movsd  0x10(%rsp),%xmm0
addsd  %xmm2,%xmm0
movsd  0x30(%rsp),%xmm2
addsd  0x18(%rsp),%xmm2
addsd  %xmm0,%xmm2
addsd  0x20(%rsp),%xmm1
movsd  (%rsp),%xmm0
addsd  0x28(%rsp),%xmm0
addsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rsp)
cmp    %r13d,%esi
jge    16cd <stdlib_strided_dnansumpw+0x5ad>
movslq %r12d,%rax
movslq 0x8(%rsp),%r15
lea    (%r14,%rax,8),%rbp
shl    $0x3,%r15
sub    %esi,%r13d
jmp    1679 <stdlib_strided_dnansumpw+0x559>
nopl   0x0(%rax,%rax,1)
add    %r15,%rbp
add    $0xffffffff,%r13d
je     16cd <stdlib_strided_dnansumpw+0x5ad>
movsd  0x0(%rbp),%xmm0
call   1030 <stdlib_base_is_nan@plt>
test   %rax,%rax
jne    1670 <stdlib_strided_dnansumpw+0x550>
movsd  (%rsp),%xmm0
addsd  0x0(%rbp),%xmm0
movsd  %xmm0,(%rsp)
jmp    1670 <stdlib_strided_dnansumpw+0x550>
sub    %r13d,%eax
imul   %ebx,%eax
cltq
lea    (%r14,%rax,8),%rsi
mov    %ebp,%edi
mov    %ebx,%edx
call   1040 <stdlib_strided_dnansumpw@plt>
movsd  %xmm0,(%rsp)
sub    %ebp,%r13d
mov    %r13d,%edi
mov    %r14,%rsi
mov    %ebx,%edx
call   1040 <stdlib_strided_dnansumpw@plt>
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  (%rsp),%xmm0
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define double @stdlib_strided_dnansumpw(i32 %0, double* %1, i32 %2) {
%4 = icmp slt i32 %0, 1
br i1 %4, label %278, label %5
5: ; preds = %3
%6 = icmp eq i32 %0, 1
%7 = icmp eq i32 %2, 0
%8 = or i1 %6, %7
br i1 %8, label %9, label %15
9: ; preds = %5
%10 = load double, double* %1
%11 = tail call i64 @stdlib_base_is_nan(double %10)
%12 = icmp eq i64 %11, 0
br i1 %12, label %13, label %278
13: ; preds = %9
%14 = load double, double* %1
br label %278
15: ; preds = %5
%16 = icmp slt i32 %2, 0
%17 = sub nsw i32 1, %0
%18 = mul nsw i32 %17, %2
%19 = select i1 %16, i32 %18, i32 0
%20 = icmp ult i32 %0, 8
br i1 %20, label %21, label %40
21: ; preds = %15
%22 = sext i32 %19 to i64
%23 = sext i32 %2 to i64
br label %24
24: ; preds = %21, %35
%25 = phi i64 [ %22, %21 ], [ %37, %35 ]
%26 = phi i32 [ 0, %21 ], [ %38, %35 ]
%27 = phi double [ 0.000000e+00, %21 ], [ %36, %35 ]
%28 = getelementptr inbounds double, double* %1, i64 %25
%29 = load double, double* %28
%30 = tail call i64 @stdlib_base_is_nan(double %29)
%31 = icmp eq i64 %30, 0
br i1 %31, label %32, label %35
32: ; preds = %24
%33 = load double, double* %28
%34 = fadd double %27, %33
br label %35
35: ; preds = %32, %24
%36 = phi double [ %27, %24 ], [ %34, %32 ]
%37 = add i64 %25, %23
%38 = add nuw nsw i32 %26, 1
%39 = icmp eq i32 %38, %0
br i1 %39, label %278, label %24
40: ; preds = %15
%41 = icmp ult i32 %0, 129
br i1 %41, label %42, label %266
42: ; preds = %40
%43 = sext i32 %19 to i64
%44 = getelementptr inbounds double, double* %1, i64 %43
%45 = load double, double* %44
%46 = tail call i64 @stdlib_base_is_nan(double %45)
%47 = icmp eq i64 %46, 0
br i1 %47, label %48, label %50
48: ; preds = %42
%49 = load double, double* %44
br label %50
50: ; preds = %42, %48
%51 = phi double [ %49, %48 ], [ 0.000000e+00, %42 ]
%52 = add nsw i32 %19, %2
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds double, double* %1, i64 %53
%55 = load double, double* %54
%56 = tail call i64 @stdlib_base_is_nan(double %55)
%57 = icmp eq i64 %56, 0
br i1 %57, label %58, label %60
58: ; preds = %50
%59 = load double, double* %54
br label %60
60: ; preds = %50, %58
%61 = phi double [ %59, %58 ], [ 0.000000e+00, %50 ]
%62 = add nsw i32 %52, %2
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds double, double* %1, i64 %63
%65 = load double, double* %64
%66 = tail call i64 @stdlib_base_is_nan(double %65)
%67 = icmp eq i64 %66, 0
br i1 %67, label %68, label %70
68: ; preds = %60
%69 = load double, double* %64
br label %70
70: ; preds = %60, %68
%71 = phi double [ %69, %68 ], [ 0.000000e+00, %60 ]
%72 = add nsw i32 %62, %2
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double, double* %1, i64 %73
%75 = load double, double* %74
%76 = tail call i64 @stdlib_base_is_nan(double %75)
%77 = icmp eq i64 %76, 0
br i1 %77, label %78, label %80
78: ; preds = %70
%79 = load double, double* %74
br label %80
80: ; preds = %70, %78
%81 = phi double [ %79, %78 ], [ 0.000000e+00, %70 ]
%82 = add nsw i32 %72, %2
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %1, i64 %83
%85 = load double, double* %84
%86 = tail call i64 @stdlib_base_is_nan(double %85)
%87 = icmp eq i64 %86, 0
br i1 %87, label %88, label %90
88: ; preds = %80
%89 = load double, double* %84
br label %90
90: ; preds = %80, %88
%91 = phi double [ %89, %88 ], [ 0.000000e+00, %80 ]
%92 = add nsw i32 %82, %2
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds double, double* %1, i64 %93
%95 = load double, double* %94
%96 = tail call i64 @stdlib_base_is_nan(double %95)
%97 = icmp eq i64 %96, 0
br i1 %97, label %98, label %100
98: ; preds = %90
%99 = load double, double* %94
br label %100
100: ; preds = %90, %98
%101 = phi double [ %99, %98 ], [ 0.000000e+00, %90 ]
%102 = add nsw i32 %92, %2
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds double, double* %1, i64 %103
%105 = load double, double* %104
%106 = tail call i64 @stdlib_base_is_nan(double %105)
%107 = icmp eq i64 %106, 0
br i1 %107, label %108, label %110
108: ; preds = %100
%109 = load double, double* %104
br label %110
110: ; preds = %100, %108
%111 = phi double [ %109, %108 ], [ 0.000000e+00, %100 ]
%112 = add nsw i32 %102, %2
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds double, double* %1, i64 %113
%115 = load double, double* %114
%116 = tail call i64 @stdlib_base_is_nan(double %115)
%117 = icmp eq i64 %116, 0
br i1 %117, label %118, label %120
118: ; preds = %110
%119 = load double, double* %114
br label %120
120: ; preds = %110, %118
%121 = phi double [ %119, %118 ], [ 0.000000e+00, %110 ]
%122 = and i32 %0, -8
%123 = add nsw i32 %112, %2
%124 = icmp ugt i32 %122, 8
br i1 %124, label %125, label %228
125: ; preds = %120, %220
%126 = phi i32 [ %224, %220 ], [ %123, %120 ]
%127 = phi double [ %222, %220 ], [ %121, %120 ]
%128 = phi double [ %211, %220 ], [ %111, %120 ]
%129 = phi double [ %200, %220 ], [ %101, %120 ]
%130 = phi double [ %189, %220 ], [ %91, %120 ]
%131 = phi double [ %178, %220 ], [ %81, %120 ]
%132 = phi double [ %167, %220 ], [ %71, %120 ]
%133 = phi double [ %156, %220 ], [ %61, %120 ]
%134 = phi double [ %145, %220 ], [ %51, %120 ]
%135 = phi i32 [ %223, %220 ], [ 8, %120 ]
%136 = sext i32 %126 to i64
%137 = getelementptr inbounds double, double* %1, i64 %136
%138 = load double, double* %137
%139 = tail call i64 @stdlib_base_is_nan(double %138)
%140 = icmp eq i64 %139, 0
br i1 %140, label %141, label %143
141: ; preds = %125
%142 = load double, double* %137
br label %143
143: ; preds = %125, %141
%144 = phi double [ %142, %141 ], [ 0.000000e+00, %125 ]
%145 = fadd double %134, %144
%146 = add nsw i32 %126, %2
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds double, double* %1, i64 %147
%149 = load double, double* %148
%150 = tail call i64 @stdlib_base_is_nan(double %149)
%151 = icmp eq i64 %150, 0
br i1 %151, label %152, label %154
152: ; preds = %143
%153 = load double, double* %148
br label %154
154: ; preds = %143, %152
%155 = phi double [ %153, %152 ], [ 0.000000e+00, %143 ]
%156 = fadd double %133, %155
%157 = add nsw i32 %146, %2
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %1, i64 %158
%160 = load double, double* %159
%161 = tail call i64 @stdlib_base_is_nan(double %160)
%162 = icmp eq i64 %161, 0
br i1 %162, label %163, label %165
163: ; preds = %154
%164 = load double, double* %159
br label %165
165: ; preds = %154, %163
%166 = phi double [ %164, %163 ], [ 0.000000e+00, %154 ]
%167 = fadd double %132, %166
%168 = add nsw i32 %157, %2
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds double, double* %1, i64 %169
%171 = load double, double* %170
%172 = tail call i64 @stdlib_base_is_nan(double %171)
%173 = icmp eq i64 %172, 0
br i1 %173, label %174, label %176
174: ; preds = %165
%175 = load double, double* %170
br label %176
176: ; preds = %165, %174
%177 = phi double [ %175, %174 ], [ 0.000000e+00, %165 ]
%178 = fadd double %131, %177
%179 = add nsw i32 %168, %2
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %1, i64 %180
%182 = load double, double* %181
%183 = tail call i64 @stdlib_base_is_nan(double %182)
%184 = icmp eq i64 %183, 0
br i1 %184, label %185, label %187
185: ; preds = %176
%186 = load double, double* %181
br label %187
187: ; preds = %176, %185
%188 = phi double [ %186, %185 ], [ 0.000000e+00, %176 ]
%189 = fadd double %130, %188
%190 = add nsw i32 %179, %2
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds double, double* %1, i64 %191
%193 = load double, double* %192
%194 = tail call i64 @stdlib_base_is_nan(double %193)
%195 = icmp eq i64 %194, 0
br i1 %195, label %196, label %198
196: ; preds = %187
%197 = load double, double* %192
br label %198
198: ; preds = %187, %196
%199 = phi double [ %197, %196 ], [ 0.000000e+00, %187 ]
%200 = fadd double %129, %199
%201 = add nsw i32 %190, %2
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %1, i64 %202
%204 = load double, double* %203
%205 = tail call i64 @stdlib_base_is_nan(double %204)
%206 = icmp eq i64 %205, 0
br i1 %206, label %207, label %209
207: ; preds = %198
%208 = load double, double* %203
br label %209
209: ; preds = %198, %207
%210 = phi double [ %208, %207 ], [ 0.000000e+00, %198 ]
%211 = fadd double %128, %210
%212 = add nsw i32 %201, %2
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %1, i64 %213
%215 = load double, double* %214
%216 = tail call i64 @stdlib_base_is_nan(double %215)
%217 = icmp eq i64 %216, 0
br i1 %217, label %218, label %220
218: ; preds = %209
%219 = load double, double* %214
br label %220
220: ; preds = %209, %218
%221 = phi double [ %219, %218 ], [ 0.000000e+00, %209 ]
%222 = fadd double %127, %221
%223 = add nuw nsw i32 %135, 8
%224 = add nsw i32 %212, %2
%225 = icmp slt i32 %223, %122
br i1 %225, label %125, label %226
226: ; preds = %220
%227 = and i32 %0, -8
br label %228
228: ; preds = %226, %120
%229 = phi i32 [ 8, %120 ], [ %227, %226 ]
%230 = phi double [ %51, %120 ], [ %145, %226 ]
%231 = phi double [ %61, %120 ], [ %156, %226 ]
%232 = phi double [ %71, %120 ], [ %167, %226 ]
%233 = phi double [ %81, %120 ], [ %178, %226 ]
%234 = phi double [ %91, %120 ], [ %189, %226 ]
%235 = phi double [ %101, %120 ], [ %200, %226 ]
%236 = phi double [ %111, %120 ], [ %211, %226 ]
%237 = phi double [ %121, %120 ], [ %222, %226 ]
%238 = phi i32 [ %123, %120 ], [ %224, %226 ]
%239 = fadd double %230, %231
%240 = fadd double %232, %233
%241 = fadd double %239, %240
%242 = fadd double %234, %235
%243 = fadd double %236, %237
%244 = fadd double %242, %243
%245 = fadd double %241, %244
%246 = icmp slt i32 %229, %0
br i1 %246, label %247, label %278
247: ; preds = %228
%248 = sext i32 %238 to i64
%249 = sext i32 %2 to i64
br label %250
250: ; preds = %247, %261
%251 = phi i64 [ %248, %247 ], [ %263, %261 ]
%252 = phi i32 [ %229, %247 ], [ %264, %261 ]
%253 = phi double [ %245, %247 ], [ %262, %261 ]
%254 = getelementptr inbounds double, double* %1, i64 %251
%255 = load double, double* %254
%256 = tail call i64 @stdlib_base_is_nan(double %255)
%257 = icmp eq i64 %256, 0
br i1 %257, label %258, label %261
258: ; preds = %250
%259 = load double, double* %254
%260 = fadd double %253, %259
br label %261
261: ; preds = %258, %250
%262 = phi double [ %253, %250 ], [ %260, %258 ]
%263 = add i64 %251, %249
%264 = add i32 %252, 1
%265 = icmp eq i32 %264, %0
br i1 %265, label %278, label %250
266: ; preds = %40
%267 = lshr i32 %0, 1
%268 = and i32 %267, 2147483640
br i1 %16, label %269, label %274
269: ; preds = %266
%270 = sub nsw i32 %268, %0
%271 = mul nsw i32 %270, %2
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %1, i64 %272
br label %280
274: ; preds = %266
%275 = mul nsw i32 %268, %2
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %1, i64 %276
br label %280
278: ; preds = %261, %35, %228, %13, %3, %9, %280
%279 = phi double [ %286, %280 ], [ %14, %13 ], [ 0.000000e+00, %3 ], [ 0.000000e+00, %9 ], [ %245, %228 ], [ %36, %35 ], [ %262, %261 ]
ret double %279
280: ; preds = %274, %269
%281 = phi double* [ %273, %269 ], [ %1, %274 ]
%282 = phi double* [ %1, %269 ], [ %277, %274 ]
%283 = tail call double @stdlib_strided_dnansumpw(i32 %268, double* %281, i32 %2)
%284 = sub nsw i32 %0, %268
%285 = tail call double @stdlib_strided_dnansumpw(i32 %284, double* %282, i32 %2)
%286 = fadd double %283, %285
br label %278
}