#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 */
float stdlib_strided_sdsapxsumpw(const int64_t N, const float alpha,
                                 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) {
    return alpha + X[0];
  }
  if (stride < 0) {
    ix = (1 - N) * stride;
  } else {
    ix = 0;
  }
  if (N < 8) {
    sum = 0.0;
    for (i = 0; i < N; i++) {
      sum += alpha + X[ix];
      ix += stride;
    }
    return sum;
  }
  if (N <= 128) {
    s0 = alpha + X[ix];
    s1 = alpha + X[ix + stride];
    s2 = alpha + X[ix + (2 * stride)];
    s3 = alpha + X[ix + (3 * stride)];
    s4 = alpha + X[ix + (4 * stride)];
    s5 = alpha + X[ix + (5 * stride)];
    s6 = alpha + X[ix + (6 * stride)];
    s7 = alpha + X[ix + (7 * stride)];
    ix += 8 * stride;
    M = N % 8;
    for (i = 8; i < N - M; i += 8) {
      s0 += alpha + X[ix];
      s1 += alpha + X[ix + stride];
      s2 += alpha + X[ix + (2 * stride)];
      s3 += alpha + X[ix + (3 * stride)];
      s4 += alpha + X[ix + (4 * stride)];
      s5 += alpha + X[ix + (5 * stride)];
      s6 += alpha + X[ix + (6 * stride)];
      s7 += alpha + X[ix + (7 * stride)];
      ix += 8 * stride;
    }
    sum = ((s0 + s1) + (s2 + s3)) + ((s4 + s5) + (s6 + s7));
    for (; i < N; i++) {
      sum += alpha + 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_sdsapxsumpw(n, alpha, xp1, stride) +
         stdlib_strided_sdsapxsumpw(N - n, alpha, xp2, stride);
}


x86 assembly (clang, -O0):
<stdlib_strided_sdsapxsumpw>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
cmpl   $0x0,-0x8(%rbp)
jg     1141 <stdlib_strided_sdsapxsumpw+0x31>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    15fa <stdlib_strided_sdsapxsumpw+0x4ea>
cmpl   $0x1,-0x8(%rbp)
je     1155 <stdlib_strided_sdsapxsumpw+0x45>
cmpl   $0x0,-0x1c(%rbp)
jne    116c <stdlib_strided_sdsapxsumpw+0x5c>
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    15fa <stdlib_strided_sdsapxsumpw+0x4ea>
cmpl   $0x0,-0x1c(%rbp)
jge    118a <stdlib_strided_sdsapxsumpw+0x7a>
mov    $0x1,%eax
sub    -0x8(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1191 <stdlib_strided_sdsapxsumpw+0x81>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x8,-0x8(%rbp)
jge    1200 <stdlib_strided_sdsapxsumpw+0xf0>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11ed <stdlib_strided_sdsapxsumpw+0xdd>
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addss  (%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    11aa <stdlib_strided_sdsapxsumpw+0x9a>
movsd  -0x38(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    15fa <stdlib_strided_sdsapxsumpw+0x4ea>
cmpl   $0x80,-0x8(%rbp)
jg     153e <stdlib_strided_sdsapxsumpw+0x42e>
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x3,-0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x5,-0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x6,-0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x7,-0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x1c(%rbp),%eax
shl    $0x3,%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x40(%rbp)
movl   $0x8,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    -0x40(%rbp),%ecx
cmp    %ecx,%eax
jge    14ac <stdlib_strided_sdsapxsumpw+0x39c>
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x3,-0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x5,-0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x6,-0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x7,-0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x1c(%rbp),%eax
shl    $0x3,%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x48(%rbp)
jmp    1342 <stdlib_strided_sdsapxsumpw+0x232>
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    -0x8(%rbp),%eax
jge    152b <stdlib_strided_sdsapxsumpw+0x41b>
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addss  (%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    14e8 <stdlib_strided_sdsapxsumpw+0x3d8>
movsd  -0x38(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    15fa <stdlib_strided_sdsapxsumpw+0x4ea>
mov    -0x8(%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    1592 <stdlib_strided_sdsapxsumpw+0x482>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x8(%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    15b3 <stdlib_strided_sdsapxsumpw+0x4a3>
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
movss  -0xc(%rbp),%xmm0
mov    -0x28(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1030 <stdlib_strided_sdsapxsumpw@plt>
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x8(%rbp),%edi
sub    -0x44(%rbp),%edi
movss  -0xc(%rbp),%xmm0
mov    -0x30(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1030 <stdlib_strided_sdsapxsumpw@plt>
movaps %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
addss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stdlib_strided_sdsapxsumpw>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
test   %edi,%edi
jle    1236 <stdlib_strided_sdsapxsumpw+0x126>
mov    %rsi,%r13
movaps %xmm0,%xmm8
mov    %edi,%ebx
cmp    $0x1,%edi
je     123c <stdlib_strided_sdsapxsumpw+0x12c>
mov    %edx,%r15d
test   %edx,%edx
je     123c <stdlib_strided_sdsapxsumpw+0x12c>
mov    $0x1,%eax
sub    %ebx,%eax
imul   %r15d,%eax
mov    %r15d,%ecx
sar    $0x1f,%ecx
and    %eax,%ecx
cmp    $0x7,%ebx
ja     1255 <stdlib_strided_sdsapxsumpw+0x145>
movslq %ecx,%rax
movss  0x0(%r13,%rax,4),%xmm0
addss  %xmm8,%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cmp    $0x1,%ebx
je     122b <stdlib_strided_sdsapxsumpw+0x11b>
movslq %r15d,%rcx
add    %rcx,%rax
movss  0x0(%r13,%rax,4),%xmm1
addss  %xmm8,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cmp    $0x2,%ebx
je     122b <stdlib_strided_sdsapxsumpw+0x11b>
add    %rcx,%rax
movss  0x0(%r13,%rax,4),%xmm1
addss  %xmm8,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cmp    $0x3,%ebx
je     122b <stdlib_strided_sdsapxsumpw+0x11b>
add    %rcx,%rax
movss  0x0(%r13,%rax,4),%xmm1
addss  %xmm8,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cmp    $0x4,%ebx
je     122b <stdlib_strided_sdsapxsumpw+0x11b>
add    %rcx,%rax
movss  0x0(%r13,%rax,4),%xmm1
addss  %xmm8,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cmp    $0x5,%ebx
je     122b <stdlib_strided_sdsapxsumpw+0x11b>
add    %rcx,%rax
movss  0x0(%r13,%rax,4),%xmm1
addss  %xmm8,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cmp    $0x6,%ebx
je     122b <stdlib_strided_sdsapxsumpw+0x11b>
add    %rcx,%rax
addss  0x0(%r13,%rax,4),%xmm8
xorps  %xmm1,%xmm1
cvtss2sd %xmm8,%xmm1
addsd  %xmm1,%xmm0
xorps  %xmm8,%xmm8
cvtsd2ss %xmm0,%xmm8
jmp    1242 <stdlib_strided_sdsapxsumpw+0x132>
xorps  %xmm8,%xmm8
jmp    1242 <stdlib_strided_sdsapxsumpw+0x132>
addss  0x0(%r13),%xmm8
movaps %xmm8,%xmm0
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x80,%ebx
ja     13fb <stdlib_strided_sdsapxsumpw+0x2eb>
movslq %ecx,%rdi
lea    (%rcx,%r15,1),%eax
cltq
lea    (%r15,%r15,1),%r12d
lea    (%rdi,%r15,2),%edx
movslq %edx,%rsi
lea    (%r15,%r15,2),%r14d
lea    (%rcx,%r14,1),%edx
lea    (%rdi,%r15,4),%ebp
movslq %ebp,%rbp
movss  0x0(%r13,%rbp,4),%xmm0
movss  0x0(%r13,%rdi,4),%xmm1
unpcklps %xmm0,%xmm1
movaps %xmm8,%xmm2
shufps $0x0,%xmm8,%xmm2
addps  %xmm2,%xmm1
cvtps2pd %xmm1,%xmm0
lea    (%r15,%r15,4),%r8d
lea    (%rcx,%r8,1),%ebp
movslq %ebp,%rbp
movss  0x0(%r13,%rax,4),%xmm1
movss  0x0(%r13,%rbp,4),%xmm3
unpcklps %xmm3,%xmm1
addps  %xmm2,%xmm1
cvtps2pd %xmm1,%xmm1
movslq %edx,%rbp
lea    (%r12,%r12,2),%eax
lea    (%rcx,%rax,1),%edx
movslq %edx,%rdx
movss  0x0(%r13,%rsi,4),%xmm3
movss  0x0(%r13,%rdx,4),%xmm4
unpcklps %xmm4,%xmm3
addps  %xmm2,%xmm3
cvtps2pd %xmm3,%xmm3
lea    0x0(,%r15,8),%edx
mov    %edx,0xc(%rsp)
sub    %r15d,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  0x0(%r13,%rcx,4),%xmm4
movss  0x0(%r13,%rbp,4),%xmm5
unpcklps %xmm4,%xmm5
addps  %xmm2,%xmm5
cvtps2pd %xmm5,%xmm4
mov    %ebx,%r9d
and    $0xfffffff8,%r9d
lea    (%rdi,%r15,8),%ecx
cmp    $0x9,%r9d
jb     1420 <stdlib_strided_sdsapxsumpw+0x310>
lea    0x0(,%r15,4),%edi
movslq %ecx,%rsi
movslq 0xc(%rsp),%r10
movslq %r15d,%r11
movslq %r12d,%r12
mov    %r13,0x10(%rsp)
movslq %r14d,%r13
movslq %edi,%rdi
movslq %r8d,%rbp
cltq
movslq %edx,%rdx
add    %rsi,%rdx
shl    $0x2,%r10
add    %rsi,%rax
add    %rsi,%rbp
add    %rsi,%rdi
add    %rsi,%r13
add    %rsi,%r12
add    %rsi,%r11
mov    $0x8,%r14d
mov    0x10(%rsp),%r8
nopw   0x0(%rax,%rax,1)
movss  (%r8,%rdi,4),%xmm5
movss  (%r8,%rsi,4),%xmm6
unpcklps %xmm5,%xmm6
addps  %xmm2,%xmm6
cvtps2pd %xmm6,%xmm5
movss  (%r8,%rbp,4),%xmm6
movss  (%r8,%r11,4),%xmm7
unpcklps %xmm6,%xmm7
addps  %xmm2,%xmm7
cvtps2pd %xmm7,%xmm6
addpd  %xmm5,%xmm0
addpd  %xmm6,%xmm1
movss  (%r8,%rax,4),%xmm5
movss  (%r8,%r12,4),%xmm6
unpcklps %xmm5,%xmm6
addps  %xmm2,%xmm6
cvtps2pd %xmm6,%xmm5
addpd  %xmm5,%xmm3
movss  (%r8,%rdx,4),%xmm5
movss  (%r8,%r13,4),%xmm6
unpcklps %xmm5,%xmm6
addps  %xmm2,%xmm6
cvtps2pd %xmm6,%xmm5
addpd  %xmm5,%xmm4
add    $0x8,%r14d
add    %r10,%r8
add    0xc(%rsp),%ecx
cmp    %r9d,%r14d
jl     1380 <stdlib_strided_sdsapxsumpw+0x270>
mov    0x10(%rsp),%r13
jmp    1426 <stdlib_strided_sdsapxsumpw+0x316>
mov    %ebx,%ebp
shr    %ebp
and    $0xfffffff8,%ebp
mov    %ebp,%eax
test   %r15d,%r15d
js     151b <stdlib_strided_sdsapxsumpw+0x40b>
imul   %r15d,%eax
cltq
mov    %r13,%rsi
lea    0x0(%r13,%rax,4),%r13
jmp    152e <stdlib_strided_sdsapxsumpw+0x41e>
mov    $0x8,%r9d
addpd  %xmm4,%xmm3
addpd  %xmm1,%xmm0
addpd  %xmm3,%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
cmp    %ebx,%r9d
jge    1511 <stdlib_strided_sdsapxsumpw+0x401>
movslq %ecx,%rax
movslq %r15d,%rcx
mov    %r9d,%edx
not    %edx
add    %ebx,%edx
mov    %ebx,%esi
and    $0x3,%esi
je     1481 <stdlib_strided_sdsapxsumpw+0x371>
neg    %esi
xor    %edi,%edi
nop
movss  0x0(%r13,%rax,4),%xmm0
addss  %xmm8,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
add    %rcx,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    1460 <stdlib_strided_sdsapxsumpw+0x350>
sub    %edi,%r9d
cmp    $0x3,%edx
jb     1511 <stdlib_strided_sdsapxsumpw+0x401>
lea    0x0(,%rax,4),%rdx
add    %r13,%rdx
mov    %rcx,%rsi
shl    $0x4,%rsi
lea    0x0(,%rcx,4),%rdi
lea    (%rdi,%rdi,2),%rdi
add    %rcx,%rax
lea    0x0(,%rax,4),%rax
add    %r13,%rax
sub    %r9d,%ebx
nopl   0x0(%rax)
movss  (%rdx),%xmm0
addss  %xmm8,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movss  (%rax),%xmm1
addss  %xmm8,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movss  (%rdx,%rcx,8),%xmm0
addss  %xmm8,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movss  (%rdx,%rdi,1),%xmm1
addss  %xmm8,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
add    %rsi,%rdx
add    %rsi,%rax
add    $0xfffffffc,%ebx
jne    14c0 <stdlib_strided_sdsapxsumpw+0x3b0>
cvtsd2ss %xmm1,%xmm8
jmp    1242 <stdlib_strided_sdsapxsumpw+0x132>
sub    %ebx,%eax
imul   %r15d,%eax
cltq
lea    0x0(,%rax,4),%rsi
add    %r13,%rsi
mov    %ebp,%edi
movaps %xmm8,%xmm0
mov    %r15d,%edx
movaps %xmm8,0x10(%rsp)
call   1030 <stdlib_strided_sdsapxsumpw@plt>
movss  %xmm0,0xc(%rsp)
sub    %ebp,%ebx
mov    %ebx,%edi
movaps 0x10(%rsp),%xmm0
mov    %r13,%rsi
mov    %r15d,%edx
call   1030 <stdlib_strided_sdsapxsumpw@plt>
movaps %xmm0,%xmm8
addss  0xc(%rsp),%xmm8
jmp    1242 <stdlib_strided_sdsapxsumpw+0x132>

LLVM IR (-O0):
define float @stdlib_strided_sdsapxsumpw(i32 %0, float %1, float* %2, i32 %3) {
%5 = alloca float
%6 = alloca i32
%7 = alloca float
%8 = alloca float*
%9 = alloca i32
%10 = alloca float*
%11 = alloca float*
%12 = alloca double
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
store i32 %0, i32* %6
store float %1, float* %7
store float* %2, float** %8
store i32 %3, i32* %9
%25 = load i32, i32* %6
%26 = icmp sle i32 %25, 0
br i1 %26, label %27, label %28
27: ; preds = %4
store float 0.000000e+00, float* %5
br label %366
28: ; preds = %4
%29 = load i32, i32* %6
%30 = icmp eq i32 %29, 1
br i1 %30, label %34, label %31
31: ; preds = %28
%32 = load i32, i32* %9
%33 = icmp eq i32 %32, 0
br i1 %33, label %34, label %40
34: ; preds = %31, %28
%35 = load float, float* %7
%36 = load float*, float** %8
%37 = getelementptr inbounds float, float* %36, i64 0
%38 = load float, float* %37
%39 = fadd float %35, %38
store float %39, float* %5
br label %366
40: ; preds = %31
%41 = load i32, i32* %9
%42 = icmp slt i32 %41, 0
br i1 %42, label %43, label %48
43: ; preds = %40
%44 = load i32, i32* %6
%45 = sub nsw i32 1, %44
%46 = load i32, i32* %9
%47 = mul nsw i32 %45, %46
store i32 %47, i32* %13
br label %49
48: ; preds = %40
store i32 0, i32* %13
br label %49
49: ; preds = %48, %43
%50 = load i32, i32* %6
%51 = icmp slt i32 %50, 8
br i1 %51, label %52, label %77
52: ; preds = %49
store double 0.000000e+00, double* %12
store i32 0, i32* %16
br label %53
53: ; preds = %71, %52
%54 = load i32, i32* %16
%55 = load i32, i32* %6
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %74
57: ; preds = %53
%58 = load float, float* %7
%59 = load float*, float** %8
%60 = load i32, i32* %13
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
%63 = load float, float* %62
%64 = fadd float %58, %63
%65 = fpext float %64 to double
%66 = load double, double* %12
%67 = fadd double %66, %65
store double %67, double* %12
%68 = load i32, i32* %9
%69 = load i32, i32* %13
%70 = add nsw i32 %69, %68
store i32 %70, i32* %13
br label %71
71: ; preds = %57
%72 = load i32, i32* %16
%73 = add nsw i32 %72, 1
store i32 %73, i32* %16
br label %53
74: ; preds = %53
%75 = load double, double* %12
%76 = fptrunc double %75 to float
store float %76, float* %5
br label %366
77: ; preds = %49
%78 = load i32, i32* %6
%79 = icmp sle i32 %78, 128
br i1 %79, label %80, label %325
80: ; preds = %77
%81 = load float, float* %7
%82 = load float*, float** %8
%83 = load i32, i32* %13
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float, float* %82, i64 %84
%86 = load float, float* %85
%87 = fadd float %81, %86
%88 = fpext float %87 to double
store double %88, double* %17
%89 = load float, float* %7
%90 = load float*, float** %8
%91 = load i32, i32* %13
%92 = load i32, i32* %9
%93 = add nsw i32 %91, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float, float* %90, i64 %94
%96 = load float, float* %95
%97 = fadd float %89, %96
%98 = fpext float %97 to double
store double %98, double* %18
%99 = load float, float* %7
%100 = load float*, float** %8
%101 = load i32, i32* %13
%102 = load i32, i32* %9
%103 = mul nsw i32 2, %102
%104 = add nsw i32 %101, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float, float* %100, i64 %105
%107 = load float, float* %106
%108 = fadd float %99, %107
%109 = fpext float %108 to double
store double %109, double* %19
%110 = load float, float* %7
%111 = load float*, float** %8
%112 = load i32, i32* %13
%113 = load i32, i32* %9
%114 = mul nsw i32 3, %113
%115 = add nsw i32 %112, %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %111, i64 %116
%118 = load float, float* %117
%119 = fadd float %110, %118
%120 = fpext float %119 to double
store double %120, double* %20
%121 = load float, float* %7
%122 = load float*, float** %8
%123 = load i32, i32* %13
%124 = load i32, i32* %9
%125 = mul nsw i32 4, %124
%126 = add nsw i32 %123, %125
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %122, i64 %127
%129 = load float, float* %128
%130 = fadd float %121, %129
%131 = fpext float %130 to double
store double %131, double* %21
%132 = load float, float* %7
%133 = load float*, float** %8
%134 = load i32, i32* %13
%135 = load i32, i32* %9
%136 = mul nsw i32 5, %135
%137 = add nsw i32 %134, %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %133, i64 %138
%140 = load float, float* %139
%141 = fadd float %132, %140
%142 = fpext float %141 to double
store double %142, double* %22
%143 = load float, float* %7
%144 = load float*, float** %8
%145 = load i32, i32* %13
%146 = load i32, i32* %9
%147 = mul nsw i32 6, %146
%148 = add nsw i32 %145, %147
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float, float* %144, i64 %149
%151 = load float, float* %150
%152 = fadd float %143, %151
%153 = fpext float %152 to double
store double %153, double* %23
%154 = load float, float* %7
%155 = load float*, float** %8
%156 = load i32, i32* %13
%157 = load i32, i32* %9
%158 = mul nsw i32 7, %157
%159 = add nsw i32 %156, %158
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds float, float* %155, i64 %160
%162 = load float, float* %161
%163 = fadd float %154, %162
%164 = fpext float %163 to double
store double %164, double* %24
%165 = load i32, i32* %9
%166 = mul nsw i32 8, %165
%167 = load i32, i32* %13
%168 = add nsw i32 %167, %166
store i32 %168, i32* %13
%169 = load i32, i32* %6
%170 = srem i32 %169, 8
store i32 %170, i32* %14
store i32 8, i32* %16
br label %171
171: ; preds = %282, %80
%172 = load i32, i32* %16
%173 = load i32, i32* %6
%174 = load i32, i32* %14
%175 = sub nsw i32 %173, %174
%176 = icmp slt i32 %172, %175
br i1 %176, label %177, label %285
177: ; preds = %171
%178 = load float, float* %7
%179 = load float*, float** %8
%180 = load i32, i32* %13
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %179, i64 %181
%183 = load float, float* %182
%184 = fadd float %178, %183
%185 = fpext float %184 to double
%186 = load double, double* %17
%187 = fadd double %186, %185
store double %187, double* %17
%188 = load float, float* %7
%189 = load float*, float** %8
%190 = load i32, i32* %13
%191 = load i32, i32* %9
%192 = add nsw i32 %190, %191
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds float, float* %189, i64 %193
%195 = load float, float* %194
%196 = fadd float %188, %195
%197 = fpext float %196 to double
%198 = load double, double* %18
%199 = fadd double %198, %197
store double %199, double* %18
%200 = load float, float* %7
%201 = load float*, float** %8
%202 = load i32, i32* %13
%203 = load i32, i32* %9
%204 = mul nsw i32 2, %203
%205 = add nsw i32 %202, %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %201, i64 %206
%208 = load float, float* %207
%209 = fadd float %200, %208
%210 = fpext float %209 to double
%211 = load double, double* %19
%212 = fadd double %211, %210
store double %212, double* %19
%213 = load float, float* %7
%214 = load float*, float** %8
%215 = load i32, i32* %13
%216 = load i32, i32* %9
%217 = mul nsw i32 3, %216
%218 = add nsw i32 %215, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float, float* %214, i64 %219
%221 = load float, float* %220
%222 = fadd float %213, %221
%223 = fpext float %222 to double
%224 = load double, double* %20
%225 = fadd double %224, %223
store double %225, double* %20
%226 = load float, float* %7
%227 = load float*, float** %8
%228 = load i32, i32* %13
%229 = load i32, i32* %9
%230 = mul nsw i32 4, %229
%231 = add nsw i32 %228, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds float, float* %227, i64 %232
%234 = load float, float* %233
%235 = fadd float %226, %234
%236 = fpext float %235 to double
%237 = load double, double* %21
%238 = fadd double %237, %236
store double %238, double* %21
%239 = load float, float* %7
%240 = load float*, float** %8
%241 = load i32, i32* %13
%242 = load i32, i32* %9
%243 = mul nsw i32 5, %242
%244 = add nsw i32 %241, %243
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds float, float* %240, i64 %245
%247 = load float, float* %246
%248 = fadd float %239, %247
%249 = fpext float %248 to double
%250 = load double, double* %22
%251 = fadd double %250, %249
store double %251, double* %22
%252 = load float, float* %7
%253 = load float*, float** %8
%254 = load i32, i32* %13
%255 = load i32, i32* %9
%256 = mul nsw i32 6, %255
%257 = add nsw i32 %254, %256
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds float, float* %253, i64 %258
%260 = load float, float* %259
%261 = fadd float %252, %260
%262 = fpext float %261 to double
%263 = load double, double* %23
%264 = fadd double %263, %262
store double %264, double* %23
%265 = load float, float* %7
%266 = load float*, float** %8
%267 = load i32, i32* %13
%268 = load i32, i32* %9
%269 = mul nsw i32 7, %268
%270 = add nsw i32 %267, %269
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds float, float* %266, i64 %271
%273 = load float, float* %272
%274 = fadd float %265, %273
%275 = fpext float %274 to double
%276 = load double, double* %24
%277 = fadd double %276, %275
store double %277, double* %24
%278 = load i32, i32* %9
%279 = mul nsw i32 8, %278
%280 = load i32, i32* %13
%281 = add nsw i32 %280, %279
store i32 %281, i32* %13
br label %282
282: ; preds = %177
%283 = load i32, i32* %16
%284 = add nsw i32 %283, 8
store i32 %284, i32* %16
br label %171
285: ; preds = %171
%286 = load double, double* %17
%287 = load double, double* %18
%288 = fadd double %286, %287
%289 = load double, double* %19
%290 = load double, double* %20
%291 = fadd double %289, %290
%292 = fadd double %288, %291
%293 = load double, double* %21
%294 = load double, double* %22
%295 = fadd double %293, %294
%296 = load double, double* %23
%297 = load double, double* %24
%298 = fadd double %296, %297
%299 = fadd double %295, %298
%300 = fadd double %292, %299
store double %300, double* %12
br label %301
301: ; preds = %319, %285
%302 = load i32, i32* %16
%303 = load i32, i32* %6
%304 = icmp slt i32 %302, %303
br i1 %304, label %305, label %322
305: ; preds = %301
%306 = load float, float* %7
%307 = load float*, float** %8
%308 = load i32, i32* %13
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds float, float* %307, i64 %309
%311 = load float, float* %310
%312 = fadd float %306, %311
%313 = fpext float %312 to double
%314 = load double, double* %12
%315 = fadd double %314, %313
store double %315, double* %12
%316 = load i32, i32* %9
%317 = load i32, i32* %13
%318 = add nsw i32 %317, %316
store i32 %318, i32* %13
br label %319
319: ; preds = %305
%320 = load i32, i32* %16
%321 = add nsw i32 %320, 1
store i32 %321, i32* %16
br label %301
322: ; preds = %301
%323 = load double, double* %12
%324 = fptrunc double %323 to float
store float %324, float* %5
br label %366
325: ; preds = %77
%326 = load i32, i32* %6
%327 = sdiv i32 %326, 2
store i32 %327, i32* %15
%328 = load i32, i32* %15
%329 = srem i32 %328, 8
%330 = load i32, i32* %15
%331 = sub nsw i32 %330, %329
store i32 %331, i32* %15
%332 = load i32, i32* %9
%333 = icmp slt i32 %332, 0
br i1 %333, label %334, label %344
334: ; preds = %325
%335 = load float*, float** %8
%336 = load i32, i32* %15
%337 = load i32, i32* %6
%338 = sub nsw i32 %336, %337
%339 = load i32, i32* %9
%340 = mul nsw i32 %338, %339
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds float, float* %335, i64 %341
store float* %342, float** %10
%343 = load float*, float** %8
store float* %343, float** %11
br label %352
344: ; preds = %325
%345 = load float*, float** %8
store float* %345, float** %10
%346 = load float*, float** %8
%347 = load i32, i32* %15
%348 = load i32, i32* %9
%349 = mul nsw i32 %347, %348
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds float, float* %346, i64 %350
store float* %351, float** %11
br label %352
352: ; preds = %344, %334
%353 = load i32, i32* %15
%354 = load float, float* %7
%355 = load float*, float** %10
%356 = load i32, i32* %9
%357 = call float @stdlib_strided_sdsapxsumpw(i32 %353, float %354, float* %355, i32 %356)
%358 = load i32, i32* %6
%359 = load i32, i32* %15
%360 = sub nsw i32 %358, %359
%361 = load float, float* %7
%362 = load float*, float** %11
%363 = load i32, i32* %9
%364 = call float @stdlib_strided_sdsapxsumpw(i32 %360, float %361, float* %362, i32 %363)
%365 = fadd float %357, %364
store float %365, float* %5
br label %366
366: ; preds = %352, %322, %74, %34, %27
%367 = load float, float* %5
ret float %367
}

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