#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_nanf(float const);
double stdlib_strided_dsnansumpw(const int64_t N, const float *X,
                                 const int64_t stride) {
  float *xp1;
  float *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_nanf(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_nanf(X[ix])) {
        sum += (double)X[ix];
      }
      ix += stride;
    }
    return sum;
  }
  if (N <= 128) {
    s0 = (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
    ix += stride;
    s1 = (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
    ix += stride;
    s2 = (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
    ix += stride;
    s3 = (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
    ix += stride;
    s4 = (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
    ix += stride;
    s5 = (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
    ix += stride;
    s6 = (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
    ix += stride;
    s7 = (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
    ix += stride;
    M = N % 8;
    for (i = 8; i < N - M; i += 8) {
      s0 += (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
      ix += stride;
      s1 += (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
      ix += stride;
      s2 += (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
      ix += stride;
      s3 += (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
      ix += stride;
      s4 += (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
      ix += stride;
      s5 += (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
      ix += stride;
      s6 += (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
      ix += stride;
      s7 += (stdlib_base_is_nanf(X[ix])) ? 0.0 : (double)X[ix];
      ix += stride;
    }
    sum = ((s0 + s1) + (s2 + s3)) + ((s4 + s5) + (s6 + s7));
    for (; i < N; i++) {
      if (!stdlib_base_is_nanf(X[ix])) {
        sum += (double)X[ix];
      }
      ix += stride;
    }
    return sum;
  }
  n = N / 2;
  n -= n % 8;
  if (stride < 0) {
    xp1 = (float *)X + ((n - N) * stride);
    xp2 = (float *)X;
  } else {
    xp1 = (float *)X;
    xp2 = (float *)X + (n * stride);
  }
  return stdlib_strided_dsnansumpw(n, xp1, stride) +
         stdlib_strided_dsnansumpw(N - n, xp2, stride);
}


x86 assembly (clang, -O0):
<stdlib_strided_dsnansumpw>:
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_dsnansumpw+0x2c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    19ba <stdlib_strided_dsnansumpw+0x89a>
cmpl   $0x1,-0xc(%rbp)
je     1160 <stdlib_strided_dsnansumpw+0x40>
cmpl   $0x0,-0x1c(%rbp)
jne    119a <stdlib_strided_dsnansumpw+0x7a>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     1184 <stdlib_strided_dsnansumpw+0x64>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    19ba <stdlib_strided_dsnansumpw+0x89a>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    19ba <stdlib_strided_dsnansumpw+0x89a>
cmpl   $0x0,-0x1c(%rbp)
jge    11b8 <stdlib_strided_dsnansumpw+0x98>
mov    $0x1,%eax
sub    -0xc(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    11bf <stdlib_strided_dsnansumpw+0x9f>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x8,-0xc(%rbp)
jge    1241 <stdlib_strided_dsnansumpw+0x121>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1232 <stdlib_strided_dsnansumpw+0x112>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
jne    121b <stdlib_strided_dsnansumpw+0xfb>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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    11d8 <stdlib_strided_dsnansumpw+0xb8>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    19ba <stdlib_strided_dsnansumpw+0x89a>
cmpl   $0x80,-0xc(%rbp)
jg     1908 <stdlib_strided_dsnansumpw+0x7e8>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     127a <stdlib_strided_dsnansumpw+0x15a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1293 <stdlib_strided_dsnansumpw+0x173>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     12d5 <stdlib_strided_dsnansumpw+0x1b5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    12ee <stdlib_strided_dsnansumpw+0x1ce>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     1330 <stdlib_strided_dsnansumpw+0x210>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1349 <stdlib_strided_dsnansumpw+0x229>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     138b <stdlib_strided_dsnansumpw+0x26b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    13a4 <stdlib_strided_dsnansumpw+0x284>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     13e6 <stdlib_strided_dsnansumpw+0x2c6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    13ff <stdlib_strided_dsnansumpw+0x2df>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     1441 <stdlib_strided_dsnansumpw+0x321>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    145a <stdlib_strided_dsnansumpw+0x33a>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     149c <stdlib_strided_dsnansumpw+0x37c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    14b5 <stdlib_strided_dsnansumpw+0x395>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     14f7 <stdlib_strided_dsnansumpw+0x3d7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1510 <stdlib_strided_dsnansumpw+0x3f0>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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    1863 <stdlib_strided_dsnansumpw+0x743>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     157b <stdlib_strided_dsnansumpw+0x45b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    1594 <stdlib_strided_dsnansumpw+0x474>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     15db <stdlib_strided_dsnansumpw+0x4bb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    15f4 <stdlib_strided_dsnansumpw+0x4d4>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     163b <stdlib_strided_dsnansumpw+0x51b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1654 <stdlib_strided_dsnansumpw+0x534>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     169b <stdlib_strided_dsnansumpw+0x57b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    16b4 <stdlib_strided_dsnansumpw+0x594>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     16fb <stdlib_strided_dsnansumpw+0x5db>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    1714 <stdlib_strided_dsnansumpw+0x5f4>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     175b <stdlib_strided_dsnansumpw+0x63b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    1774 <stdlib_strided_dsnansumpw+0x654>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     17bb <stdlib_strided_dsnansumpw+0x69b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    17d4 <stdlib_strided_dsnansumpw+0x6b4>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     181b <stdlib_strided_dsnansumpw+0x6fb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    1834 <stdlib_strided_dsnansumpw+0x714>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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    153e <stdlib_strided_dsnansumpw+0x41e>
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    18f9 <stdlib_strided_dsnansumpw+0x7d9>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
jne    18e2 <stdlib_strided_dsnansumpw+0x7c2>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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    189f <stdlib_strided_dsnansumpw+0x77f>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    19ba <stdlib_strided_dsnansumpw+0x89a>
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    195c <stdlib_strided_dsnansumpw+0x83c>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    197d <stdlib_strided_dsnansumpw+0x85d>
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1030 <stdlib_strided_dsnansumpw@plt>
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0xc(%rbp),%edi
sub    -0x44(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1030 <stdlib_strided_dsnansumpw@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_dsnansumpw>:
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    1725 <stdlib_strided_dsnansumpw+0x605>
mov    %rsi,%r14
mov    %edi,%r13d
cmp    $0x1,%edi
je     11c3 <stdlib_strided_dsnansumpw+0xa3>
mov    %edx,%ebx
test   %edx,%edx
je     11c3 <stdlib_strided_dsnansumpw+0xa3>
mov    $0x1,%eax
sub    %r13d,%eax
imul   %ebx,%eax
mov    %ebx,%ebp
sar    $0x1f,%ebp
and    %eax,%ebp
cmp    $0x7,%r13d
ja     11e4 <stdlib_strided_dsnansumpw+0xc4>
movslq %ebp,%rax
movslq %ebx,%rbp
lea    (%r14,%rax,4),%rbx
shl    $0x2,%rbp
xorpd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
jmp    119d <stdlib_strided_dsnansumpw+0x7d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %rbp,%rbx
add    $0xffffffff,%r13d
je     1725 <stdlib_strided_dsnansumpw+0x605>
movss  (%rbx),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
test   %rax,%rax
jne    1190 <stdlib_strided_dsnansumpw+0x70>
movss  (%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  (%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
jmp    1190 <stdlib_strided_dsnansumpw+0x70>
movss  (%r14),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
test   %rax,%rax
jne    1725 <stdlib_strided_dsnansumpw+0x605>
movss  (%r14),%xmm0
cvtss2sd %xmm0,%xmm0
jmp    1720 <stdlib_strided_dsnansumpw+0x600>
cmp    $0x80,%r13d
ja     1630 <stdlib_strided_dsnansumpw+0x510>
movslq %ebp,%r15
movss  (%r14,%r15,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x28(%rsp)
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
test   %rax,%rax
jne    1224 <stdlib_strided_dsnansumpw+0x104>
movss  (%r14,%r15,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rsp)
lea    (%rbx,%rbp,1),%r12d
movslq %r12d,%r15
movss  (%r14,%r15,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
test   %rax,%rax
jne    124b <stdlib_strided_dsnansumpw+0x12b>
movss  (%r14,%r15,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x28(%rsp)
add    %ebx,%r12d
movslq %r12d,%r15
movss  (%r14,%r15,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    1277 <stdlib_strided_dsnansumpw+0x157>
movss  (%r14,%r15,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x38(%rsp)
add    %ebx,%r12d
movslq %r12d,%r15
movss  (%r14,%r15,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
test   %rax,%rax
jne    12a3 <stdlib_strided_dsnansumpw+0x183>
movss  (%r14,%r15,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
add    %ebx,%r12d
movslq %r12d,%r15
movss  (%r14,%r15,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    12cf <stdlib_strided_dsnansumpw+0x1af>
movss  (%r14,%r15,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x30(%rsp)
add    %ebx,%r12d
movslq %r12d,%r15
movss  (%r14,%r15,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
test   %rax,%rax
jne    12fb <stdlib_strided_dsnansumpw+0x1db>
movss  (%r14,%r15,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
add    %ebx,%r12d
movslq %r12d,%r15
movss  (%r14,%r15,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    131e <stdlib_strided_dsnansumpw+0x1fe>
movss  (%r14,%r15,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %rbx,0x10(%rsp)
add    %ebx,%r12d
movslq %r12d,%rbx
movss  (%r14,%rbx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
test   %rax,%rax
xorps  %xmm2,%xmm2
jne    134f <stdlib_strided_dsnansumpw+0x22f>
movss  (%r14,%rbx,4),%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
mov    %r13d,%esi
and    $0xfffffff8,%esi
cmp    $0x9,%esi
movsd  0x38(%rsp),%xmm1
jb     1653 <stdlib_strided_dsnansumpw+0x533>
mov    0x10(%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    148a <stdlib_strided_dsnansumpw+0x36a>
nopw   0x0(%rax,%rax,1)
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  0x8(%rsp),%xmm0
addsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x30(%rsp),%xmm0
addsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x20(%rsp),%xmm0
addsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x18(%rsp),%xmm0
addsd  0x98(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
add    $0x8,%r12d
mov    0xb8(%rsp),%rcx
mov    %ecx,%ebp
mov    0x44(%rsp),%esi
cmp    %esi,%r12d
jge    165f <stdlib_strided_dsnansumpw+0x53f>
movsd  %xmm2,0xc0(%rsp)
movsd  %xmm1,0x38(%rsp)
mov    0x90(%rsp),%rax
add    %ebp,%eax
mov    %rax,0xb8(%rsp)
movslq %eax,%r15
movss  (%r14,%r15,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x58(%rsp)
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    14d4 <stdlib_strided_dsnansumpw+0x3b4>
movss  (%r14,%r15,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0xb0(%rsp)
mov    0x60(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movss  (%r14,%rbx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
test   %rax,%rax
jne    1507 <stdlib_strided_dsnansumpw+0x3e7>
movss  (%r14,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x58(%rsp)
mov    0x68(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movss  (%r14,%rbx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x50(%rsp)
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    1537 <stdlib_strided_dsnansumpw+0x417>
movss  (%r14,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0xa8(%rsp)
mov    0x70(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movss  (%r14,%rbx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
test   %rax,%rax
jne    156a <stdlib_strided_dsnansumpw+0x44a>
movss  (%r14,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x50(%rsp)
mov    0x78(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movss  (%r14,%rbx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x48(%rsp)
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    159a <stdlib_strided_dsnansumpw+0x47a>
movss  (%r14,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    0x80(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movss  (%r14,%rbx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
test   %rax,%rax
jne    15d0 <stdlib_strided_dsnansumpw+0x4b0>
movss  (%r14,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x48(%rsp)
mov    0x88(%rsp),%rax
add    %ebp,%eax
movslq %eax,%rbx
movss  (%r14,%rbx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
xorps  %xmm0,%xmm0
test   %rax,%rax
jne    15fa <stdlib_strided_dsnansumpw+0x4da>
movss  (%r14,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x98(%rsp)
add    0x40(%rsp),%ebp
movslq %ebp,%rbx
movss  (%r14,%rbx,4),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
test   %rax,%rax
xorps  %xmm0,%xmm0
jne    13e0 <stdlib_strided_dsnansumpw+0x2c0>
movss  (%r14,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
jmp    13e0 <stdlib_strided_dsnansumpw+0x2c0>
mov    %r13d,%ebp
shr    %ebp
and    $0xfffffff8,%ebp
mov    %ebp,%eax
test   %ebx,%ebx
js     16f1 <stdlib_strided_dsnansumpw+0x5d1>
imul   %ebx,%eax
cltq
mov    %r14,%rsi
lea    (%r14,%rax,4),%r14
jmp    16fd <stdlib_strided_dsnansumpw+0x5dd>
add    0x10(%rsp),%r12d
mov    $0x8,%esi
jmp    1668 <stdlib_strided_dsnansumpw+0x548>
mov    0x10(%rsp),%rax
lea    (%rcx,%rax,8),%r12d
movsd  0x8(%rsp),%xmm0
movsd  0x18(%rsp),%xmm3
addsd  %xmm2,%xmm3
movsd  0x30(%rsp),%xmm2
addsd  0x20(%rsp),%xmm2
addsd  %xmm3,%xmm2
addsd  %xmm0,%xmm1
movsd  (%rsp),%xmm0
addsd  0x28(%rsp),%xmm0
addsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rsp)
cmp    %r13d,%esi
jge    1725 <stdlib_strided_dsnansumpw+0x605>
movslq %r12d,%rax
movslq 0x10(%rsp),%r15
lea    (%r14,%rax,4),%rbp
shl    $0x2,%r15
sub    %esi,%r13d
jmp    16c9 <stdlib_strided_dsnansumpw+0x5a9>
xchg   %ax,%ax
add    %r15,%rbp
add    $0xffffffff,%r13d
je     1725 <stdlib_strided_dsnansumpw+0x605>
movss  0x0(%rbp),%xmm0
call   1040 <stdlib_base_is_nanf@plt>
test   %rax,%rax
jne    16c0 <stdlib_strided_dsnansumpw+0x5a0>
movss  0x0(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  (%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
jmp    16c0 <stdlib_strided_dsnansumpw+0x5a0>
sub    %r13d,%eax
imul   %ebx,%eax
cltq
lea    (%r14,%rax,4),%rsi
mov    %ebp,%edi
mov    %ebx,%edx
call   1030 <stdlib_strided_dsnansumpw@plt>
movsd  %xmm0,(%rsp)
sub    %ebp,%r13d
mov    %r13d,%edi
mov    %r14,%rsi
mov    %ebx,%edx
call   1030 <stdlib_strided_dsnansumpw@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_dsnansumpw(i32 %0, float* %1, i32 %2) {
%4 = alloca double
%5 = alloca i32
%6 = alloca float*
%7 = alloca i32
%8 = alloca float*
%9 = alloca float*
%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 float* %1, float** %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 %524
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 %44
32: ; preds = %29, %26
%33 = load float*, float** %6
%34 = getelementptr inbounds float, float* %33, i64 0
%35 = load float, float* %34
%36 = call i64 @stdlib_base_is_nanf(float %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 %524
39: ; preds = %32
%40 = load float*, float** %6
%41 = getelementptr inbounds float, float* %40, i64 0
%42 = load float, float* %41
%43 = fpext float %42 to double
store double %43, double* %4
br label %524
44: ; preds = %29
%45 = load i32, i32* %7
%46 = icmp slt i32 %45, 0
br i1 %46, label %47, label %52
47: ; preds = %44
%48 = load i32, i32* %5
%49 = sub nsw i32 1, %48
%50 = load i32, i32* %7
%51 = mul nsw i32 %49, %50
store i32 %51, i32* %11
br label %53
52: ; preds = %44
store i32 0, i32* %11
br label %53
53: ; preds = %52, %47
%54 = load i32, i32* %5
%55 = icmp slt i32 %54, 8
br i1 %55, label %56, label %87
56: ; preds = %53
store double 0.000000e+00, double* %10
store i32 0, i32* %14
br label %57
57: ; preds = %82, %56
%58 = load i32, i32* %14
%59 = load i32, i32* %5
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %85
61: ; preds = %57
%62 = load float*, float** %6
%63 = load i32, i32* %11
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds float, float* %62, i64 %64
%66 = load float, float* %65
%67 = call i64 @stdlib_base_is_nanf(float %66)
%68 = icmp ne i64 %67, 0
br i1 %68, label %78, label %69
69: ; preds = %61
%70 = load float*, float** %6
%71 = load i32, i32* %11
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
%74 = load float, float* %73
%75 = fpext float %74 to double
%76 = load double, double* %10
%77 = fadd double %76, %75
store double %77, double* %10
br label %78
78: ; preds = %69, %61
%79 = load i32, i32* %7
%80 = load i32, i32* %11
%81 = add nsw i32 %80, %79
store i32 %81, i32* %11
br label %82
82: ; preds = %78
%83 = load i32, i32* %14
%84 = add nsw i32 %83, 1
store i32 %84, i32* %14
br label %57
85: ; preds = %57
%86 = load double, double* %10
store double %86, double* %4
br label %524
87: ; preds = %53
%88 = load i32, i32* %5
%89 = icmp sle i32 %88, 128
br i1 %89, label %90, label %485
90: ; preds = %87
%91 = load float*, float** %6
%92 = load i32, i32* %11
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %91, i64 %93
%95 = load float, float* %94
%96 = call i64 @stdlib_base_is_nanf(float %95)
%97 = icmp ne i64 %96, 0
br i1 %97, label %98, label %99
98: ; preds = %90
br label %106
99: ; preds = %90
%100 = load float*, float** %6
%101 = load i32, i32* %11
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %100, i64 %102
%104 = load float, float* %103
%105 = fpext float %104 to double
br label %106
106: ; preds = %99, %98
%107 = phi double [ 0.000000e+00, %98 ], [ %105, %99 ]
store double %107, double* %15
%108 = load i32, i32* %7
%109 = load i32, i32* %11
%110 = add nsw i32 %109, %108
store i32 %110, i32* %11
%111 = load float*, float** %6
%112 = load i32, i32* %11
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %111, i64 %113
%115 = load float, float* %114
%116 = call i64 @stdlib_base_is_nanf(float %115)
%117 = icmp ne i64 %116, 0
br i1 %117, label %118, label %119
118: ; preds = %106
br label %126
119: ; preds = %106
%120 = load float*, float** %6
%121 = load i32, i32* %11
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float, float* %120, i64 %122
%124 = load float, float* %123
%125 = fpext float %124 to double
br label %126
126: ; preds = %119, %118
%127 = phi double [ 0.000000e+00, %118 ], [ %125, %119 ]
store double %127, double* %16
%128 = load i32, i32* %7
%129 = load i32, i32* %11
%130 = add nsw i32 %129, %128
store i32 %130, i32* %11
%131 = load float*, float** %6
%132 = load i32, i32* %11
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds float, float* %131, i64 %133
%135 = load float, float* %134
%136 = call i64 @stdlib_base_is_nanf(float %135)
%137 = icmp ne i64 %136, 0
br i1 %137, label %138, label %139
138: ; preds = %126
br label %146
139: ; preds = %126
%140 = load float*, float** %6
%141 = load i32, i32* %11
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds float, float* %140, i64 %142
%144 = load float, float* %143
%145 = fpext float %144 to double
br label %146
146: ; preds = %139, %138
%147 = phi double [ 0.000000e+00, %138 ], [ %145, %139 ]
store double %147, double* %17
%148 = load i32, i32* %7
%149 = load i32, i32* %11
%150 = add nsw i32 %149, %148
store i32 %150, i32* %11
%151 = load float*, float** %6
%152 = load i32, i32* %11
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds float, float* %151, i64 %153
%155 = load float, float* %154
%156 = call i64 @stdlib_base_is_nanf(float %155)
%157 = icmp ne i64 %156, 0
br i1 %157, label %158, label %159
158: ; preds = %146
br label %166
159: ; preds = %146
%160 = load float*, float** %6
%161 = load i32, i32* %11
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float, float* %160, i64 %162
%164 = load float, float* %163
%165 = fpext float %164 to double
br label %166
166: ; preds = %159, %158
%167 = phi double [ 0.000000e+00, %158 ], [ %165, %159 ]
store double %167, double* %18
%168 = load i32, i32* %7
%169 = load i32, i32* %11
%170 = add nsw i32 %169, %168
store i32 %170, i32* %11
%171 = load float*, float** %6
%172 = load i32, i32* %11
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %171, i64 %173
%175 = load float, float* %174
%176 = call i64 @stdlib_base_is_nanf(float %175)
%177 = icmp ne i64 %176, 0
br i1 %177, label %178, label %179
178: ; preds = %166
br label %186
179: ; preds = %166
%180 = load float*, float** %6
%181 = load i32, i32* %11
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %180, i64 %182
%184 = load float, float* %183
%185 = fpext float %184 to double
br label %186
186: ; preds = %179, %178
%187 = phi double [ 0.000000e+00, %178 ], [ %185, %179 ]
store double %187, double* %19
%188 = load i32, i32* %7
%189 = load i32, i32* %11
%190 = add nsw i32 %189, %188
store i32 %190, i32* %11
%191 = load float*, float** %6
%192 = load i32, i32* %11
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds float, float* %191, i64 %193
%195 = load float, float* %194
%196 = call i64 @stdlib_base_is_nanf(float %195)
%197 = icmp ne i64 %196, 0
br i1 %197, label %198, label %199
198: ; preds = %186
br label %206
199: ; preds = %186
%200 = load float*, float** %6
%201 = load i32, i32* %11
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float, float* %200, i64 %202
%204 = load float, float* %203
%205 = fpext float %204 to double
br label %206
206: ; preds = %199, %198
%207 = phi double [ 0.000000e+00, %198 ], [ %205, %199 ]
store double %207, double* %20
%208 = load i32, i32* %7
%209 = load i32, i32* %11
%210 = add nsw i32 %209, %208
store i32 %210, i32* %11
%211 = load float*, float** %6
%212 = load i32, i32* %11
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds float, float* %211, i64 %213
%215 = load float, float* %214
%216 = call i64 @stdlib_base_is_nanf(float %215)
%217 = icmp ne i64 %216, 0
br i1 %217, label %218, label %219
218: ; preds = %206
br label %226
219: ; preds = %206
%220 = load float*, float** %6
%221 = load i32, i32* %11
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds float, float* %220, i64 %222
%224 = load float, float* %223
%225 = fpext float %224 to double
br label %226
226: ; preds = %219, %218
%227 = phi double [ 0.000000e+00, %218 ], [ %225, %219 ]
store double %227, double* %21
%228 = load i32, i32* %7
%229 = load i32, i32* %11
%230 = add nsw i32 %229, %228
store i32 %230, i32* %11
%231 = load float*, float** %6
%232 = load i32, i32* %11
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds float, float* %231, i64 %233
%235 = load float, float* %234
%236 = call i64 @stdlib_base_is_nanf(float %235)
%237 = icmp ne i64 %236, 0
br i1 %237, label %238, label %239
238: ; preds = %226
br label %246
239: ; preds = %226
%240 = load float*, float** %6
%241 = load i32, i32* %11
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds float, float* %240, i64 %242
%244 = load float, float* %243
%245 = fpext float %244 to double
br label %246
246: ; preds = %239, %238
%247 = phi double [ 0.000000e+00, %238 ], [ %245, %239 ]
store double %247, double* %22
%248 = load i32, i32* %7
%249 = load i32, i32* %11
%250 = add nsw i32 %249, %248
store i32 %250, i32* %11
%251 = load i32, i32* %5
%252 = srem i32 %251, 8
store i32 %252, i32* %12
store i32 8, i32* %14
br label %253
253: ; preds = %436, %246
%254 = load i32, i32* %14
%255 = load i32, i32* %5
%256 = load i32, i32* %12
%257 = sub nsw i32 %255, %256
%258 = icmp slt i32 %254, %257
br i1 %258, label %259, label %439
259: ; preds = %253
%260 = load float*, float** %6
%261 = load i32, i32* %11
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds float, float* %260, i64 %262
%264 = load float, float* %263
%265 = call i64 @stdlib_base_is_nanf(float %264)
%266 = icmp ne i64 %265, 0
br i1 %266, label %267, label %268
267: ; preds = %259
br label %275
268: ; preds = %259
%269 = load float*, float** %6
%270 = load i32, i32* %11
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds float, float* %269, i64 %271
%273 = load float, float* %272
%274 = fpext float %273 to double
br label %275
275: ; preds = %268, %267
%276 = phi double [ 0.000000e+00, %267 ], [ %274, %268 ]
%277 = load double, double* %15
%278 = fadd double %277, %276
store double %278, double* %15
%279 = load i32, i32* %7
%280 = load i32, i32* %11
%281 = add nsw i32 %280, %279
store i32 %281, i32* %11
%282 = load float*, float** %6
%283 = load i32, i32* %11
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds float, float* %282, i64 %284
%286 = load float, float* %285
%287 = call i64 @stdlib_base_is_nanf(float %286)
%288 = icmp ne i64 %287, 0
br i1 %288, label %289, label %290
289: ; preds = %275
br label %297
290: ; preds = %275
%291 = load float*, float** %6
%292 = load i32, i32* %11
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds float, float* %291, i64 %293
%295 = load float, float* %294
%296 = fpext float %295 to double
br label %297
297: ; preds = %290, %289
%298 = phi double [ 0.000000e+00, %289 ], [ %296, %290 ]
%299 = load double, double* %16
%300 = fadd double %299, %298
store double %300, double* %16
%301 = load i32, i32* %7
%302 = load i32, i32* %11
%303 = add nsw i32 %302, %301
store i32 %303, i32* %11
%304 = load float*, float** %6
%305 = load i32, i32* %11
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds float, float* %304, i64 %306
%308 = load float, float* %307
%309 = call i64 @stdlib_base_is_nanf(float %308)
%310 = icmp ne i64 %309, 0
br i1 %310, label %311, label %312
311: ; preds = %297
br label %319
312: ; preds = %297
%313 = load float*, float** %6
%314 = load i32, i32* %11
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds float, float* %313, i64 %315
%317 = load float, float* %316
%318 = fpext float %317 to double
br label %319
319: ; preds = %312, %311
%320 = phi double [ 0.000000e+00, %311 ], [ %318, %312 ]
%321 = load double, double* %17
%322 = fadd double %321, %320
store double %322, double* %17
%323 = load i32, i32* %7
%324 = load i32, i32* %11
%325 = add nsw i32 %324, %323
store i32 %325, i32* %11
%326 = load float*, float** %6
%327 = load i32, i32* %11
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds float, float* %326, i64 %328
%330 = load float, float* %329
%331 = call i64 @stdlib_base_is_nanf(float %330)
%332 = icmp ne i64 %331, 0
br i1 %332, label %333, label %334
333: ; preds = %319
br label %341
334: ; preds = %319
%335 = load float*, float** %6
%336 = load i32, i32* %11
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds float, float* %335, i64 %337
%339 = load float, float* %338
%340 = fpext float %339 to double
br label %341
341: ; preds = %334, %333
%342 = phi double [ 0.000000e+00, %333 ], [ %340, %334 ]
%343 = load double, double* %18
%344 = fadd double %343, %342
store double %344, double* %18
%345 = load i32, i32* %7
%346 = load i32, i32* %11
%347 = add nsw i32 %346, %345
store i32 %347, i32* %11
%348 = load float*, float** %6
%349 = load i32, i32* %11
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds float, float* %348, i64 %350
%352 = load float, float* %351
%353 = call i64 @stdlib_base_is_nanf(float %352)
%354 = icmp ne i64 %353, 0
br i1 %354, label %355, label %356
355: ; preds = %341
br label %363
356: ; preds = %341
%357 = load float*, float** %6
%358 = load i32, i32* %11
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds float, float* %357, i64 %359
%361 = load float, float* %360
%362 = fpext float %361 to double
br label %363
363: ; preds = %356, %355
%364 = phi double [ 0.000000e+00, %355 ], [ %362, %356 ]
%365 = load double, double* %19
%366 = fadd double %365, %364
store double %366, double* %19
%367 = load i32, i32* %7
%368 = load i32, i32* %11
%369 = add nsw i32 %368, %367
store i32 %369, i32* %11
%370 = load float*, float** %6
%371 = load i32, i32* %11
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds float, float* %370, i64 %372
%374 = load float, float* %373
%375 = call i64 @stdlib_base_is_nanf(float %374)
%376 = icmp ne i64 %375, 0
br i1 %376, label %377, label %378
377: ; preds = %363
br label %385
378: ; preds = %363
%379 = load float*, float** %6
%380 = load i32, i32* %11
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds float, float* %379, i64 %381
%383 = load float, float* %382
%384 = fpext float %383 to double
br label %385
385: ; preds = %378, %377
%386 = phi double [ 0.000000e+00, %377 ], [ %384, %378 ]
%387 = load double, double* %20
%388 = fadd double %387, %386
store double %388, double* %20
%389 = load i32, i32* %7
%390 = load i32, i32* %11
%391 = add nsw i32 %390, %389
store i32 %391, i32* %11
%392 = load float*, float** %6
%393 = load i32, i32* %11
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds float, float* %392, i64 %394
%396 = load float, float* %395
%397 = call i64 @stdlib_base_is_nanf(float %396)
%398 = icmp ne i64 %397, 0
br i1 %398, label %399, label %400
399: ; preds = %385
br label %407
400: ; preds = %385
%401 = load float*, float** %6
%402 = load i32, i32* %11
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds float, float* %401, i64 %403
%405 = load float, float* %404
%406 = fpext float %405 to double
br label %407
407: ; preds = %400, %399
%408 = phi double [ 0.000000e+00, %399 ], [ %406, %400 ]
%409 = load double, double* %21
%410 = fadd double %409, %408
store double %410, double* %21
%411 = load i32, i32* %7
%412 = load i32, i32* %11
%413 = add nsw i32 %412, %411
store i32 %413, i32* %11
%414 = load float*, float** %6
%415 = load i32, i32* %11
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds float, float* %414, i64 %416
%418 = load float, float* %417
%419 = call i64 @stdlib_base_is_nanf(float %418)
%420 = icmp ne i64 %419, 0
br i1 %420, label %421, label %422
421: ; preds = %407
br label %429
422: ; preds = %407
%423 = load float*, float** %6
%424 = load i32, i32* %11
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds float, float* %423, i64 %425
%427 = load float, float* %426
%428 = fpext float %427 to double
br label %429
429: ; preds = %422, %421
%430 = phi double [ 0.000000e+00, %421 ], [ %428, %422 ]
%431 = load double, double* %22
%432 = fadd double %431, %430
store double %432, double* %22
%433 = load i32, i32* %7
%434 = load i32, i32* %11
%435 = add nsw i32 %434, %433
store i32 %435, i32* %11
br label %436
436: ; preds = %429
%437 = load i32, i32* %14
%438 = add nsw i32 %437, 8
store i32 %438, i32* %14
br label %253
439: ; preds = %253
%440 = load double, double* %15
%441 = load double, double* %16
%442 = fadd double %440, %441
%443 = load double, double* %17
%444 = load double, double* %18
%445 = fadd double %443, %444
%446 = fadd double %442, %445
%447 = load double, double* %19
%448 = load double, double* %20
%449 = fadd double %447, %448
%450 = load double, double* %21
%451 = load double, double* %22
%452 = fadd double %450, %451
%453 = fadd double %449, %452
%454 = fadd double %446, %453
store double %454, double* %10
br label %455
455: ; preds = %480, %439
%456 = load i32, i32* %14
%457 = load i32, i32* %5
%458 = icmp slt i32 %456, %457
br i1 %458, label %459, label %483
459: ; preds = %455
%460 = load float*, float** %6
%461 = load i32, i32* %11
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds float, float* %460, i64 %462
%464 = load float, float* %463
%465 = call i64 @stdlib_base_is_nanf(float %464)
%466 = icmp ne i64 %465, 0
br i1 %466, label %476, label %467
467: ; preds = %459
%468 = load float*, float** %6
%469 = load i32, i32* %11
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds float, float* %468, i64 %470
%472 = load float, float* %471
%473 = fpext float %472 to double
%474 = load double, double* %10
%475 = fadd double %474, %473
store double %475, double* %10
br label %476
476: ; preds = %467, %459
%477 = load i32, i32* %7
%478 = load i32, i32* %11
%479 = add nsw i32 %478, %477
store i32 %479, i32* %11
br label %480
480: ; preds = %476
%481 = load i32, i32* %14
%482 = add nsw i32 %481, 1
store i32 %482, i32* %14
br label %455
483: ; preds = %455
%484 = load double, double* %10
store double %484, double* %4
br label %524
485: ; preds = %87
%486 = load i32, i32* %5
%487 = sdiv i32 %486, 2
store i32 %487, i32* %13
%488 = load i32, i32* %13
%489 = srem i32 %488, 8
%490 = load i32, i32* %13
%491 = sub nsw i32 %490, %489
store i32 %491, i32* %13
%492 = load i32, i32* %7
%493 = icmp slt i32 %492, 0
br i1 %493, label %494, label %504
494: ; preds = %485
%495 = load float*, float** %6
%496 = load i32, i32* %13
%497 = load i32, i32* %5
%498 = sub nsw i32 %496, %497
%499 = load i32, i32* %7
%500 = mul nsw i32 %498, %499
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds float, float* %495, i64 %501
store float* %502, float** %8
%503 = load float*, float** %6
store float* %503, float** %9
br label %512
504: ; preds = %485
%505 = load float*, float** %6
store float* %505, float** %8
%506 = load float*, float** %6
%507 = load i32, i32* %13
%508 = load i32, i32* %7
%509 = mul nsw i32 %507, %508
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds float, float* %506, i64 %510
store float* %511, float** %9
br label %512
512: ; preds = %504, %494
%513 = load i32, i32* %13
%514 = load float*, float** %8
%515 = load i32, i32* %7
%516 = call double @stdlib_strided_dsnansumpw(i32 %513, float* %514, i32 %515)
%517 = load i32, i32* %5
%518 = load i32, i32* %13
%519 = sub nsw i32 %517, %518
%520 = load float*, float** %9
%521 = load i32, i32* %7
%522 = call double @stdlib_strided_dsnansumpw(i32 %519, float* %520, i32 %521)
%523 = fadd double %516, %522
store double %523, double* %4
br label %524
524: ; preds = %512, %483, %85, %39, %38, %25
%525 = load double, double* %4
ret double %525
}

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