#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 fabsf(float const);
scalar_t__ stdlib_base_is_nanf(float);
void stdlib_strided_scuminabs(const int64_t N, const float *X,
                              const int64_t strideX, float *Y,
                              const int64_t strideY) {
  int64_t ix;
  int64_t iy;
  int64_t i;
  float min;
  float v;
  if (N <= 0) {
    return;
  }
  if (strideX < 0) {
    ix = (1 - N) * strideX;
  } else {
    ix = 0;
  }
  if (strideY < 0) {
    iy = (1 - N) * strideY;
  } else {
    iy = 0;
  }
  min = fabsf(X[ix]);
  Y[iy] = min;
  iy += strideY;
  i = 1;
  if (!stdlib_base_is_nanf(min)) {
    for (; i < N; i++) {
      ix += strideX;
      v = fabsf(X[ix]);
      if (stdlib_base_is_nanf(v)) {
        min = v;
        break;
      }
      if (v < min) {
        min = v;
      }
      Y[iy] = min;
      iy += strideY;
    }
  }
  if (stdlib_base_is_nanf(min)) {
    for (; i < N; i++) {
      Y[iy] = min;
      iy += strideY;
    }
  }
  return;
}


x86 assembly (clang, -O0):
<stdlib_strided_scuminabs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     1139 <stdlib_strided_scuminabs+0x29>
jmp    12d3 <stdlib_strided_scuminabs+0x1c3>
cmpl   $0x0,-0x14(%rbp)
jge    1157 <stdlib_strided_scuminabs+0x47>
mov    $0x1,%eax
sub    -0x4(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    115e <stdlib_strided_scuminabs+0x4e>
movl   $0x0,-0x28(%rbp)
cmpl   $0x0,-0x24(%rbp)
jge    117c <stdlib_strided_scuminabs+0x6c>
mov    $0x1,%eax
sub    -0x4(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1183 <stdlib_strided_scuminabs+0x73>
movl   $0x0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movaps 0xe69(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,-0x30(%rbp)
movss  -0x34(%rbp),%xmm0
call   1030 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
jne    127b <stdlib_strided_scuminabs+0x16b>
jmp    11db <stdlib_strided_scuminabs+0xcb>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1276 <stdlib_strided_scuminabs+0x166>
mov    -0x14(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movaps 0xdfc(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
call   1030 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     1230 <stdlib_strided_scuminabs+0x120>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    1276 <stdlib_strided_scuminabs+0x166>
movss  -0x38(%rbp),%xmm1
movss  -0x34(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    124d <stdlib_strided_scuminabs+0x13d>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11db <stdlib_strided_scuminabs+0xcb>
jmp    127b <stdlib_strided_scuminabs+0x16b>
movss  -0x34(%rbp),%xmm0
call   1030 <stdlib_base_is_nanf@plt>
cmp    $0x0,%rax
je     12ce <stdlib_strided_scuminabs+0x1be>
jmp    1294 <stdlib_strided_scuminabs+0x184>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12c9 <stdlib_strided_scuminabs+0x1b9>
movss  -0x34(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1294 <stdlib_strided_scuminabs+0x184>
jmp    12ce <stdlib_strided_scuminabs+0x1be>
jmp    12d3 <stdlib_strided_scuminabs+0x1c3>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stdlib_strided_scuminabs>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r8d,0xc(%rsp)
test   %edi,%edi
jle    12fd <stdlib_strided_scuminabs+0x1ed>
mov    %rcx,%r13
mov    %edi,%ebp
mov    $0x1,%ebx
mov    $0x1,%eax
sub    %edi,%eax
mov    %eax,%ecx
imul   %edx,%ecx
mov    %edx,0x28(%rsp)
sar    $0x1f,%edx
and    %ecx,%edx
mov    0xc(%rsp),%ecx
imul   %ecx,%eax
mov    %ecx,%r14d
sar    $0x1f,%r14d
movslq %edx,%r12
mov    %rsi,0x40(%rsp)
movss  (%rsi,%r12,4),%xmm0
andps  0xe93(%rip),%xmm0
and    %eax,%r14d
movslq %r14d,%r15
movss  %xmm0,0x0(%r13,%r15,4)
add    %ecx,%r15d
movaps %xmm0,0x10(%rsp)
call   1030 <stdlib_base_is_nanf@plt>
test   %rax,%rax
jne    1231 <stdlib_strided_scuminabs+0x121>
cmp    $0x1,%ebp
je     1231 <stdlib_strided_scuminabs+0x121>
mov    %r14d,%edx
movslq 0x28(%rsp),%r14
movslq %r15d,%rax
mov    0xc(%rsp),%ecx
movslq %ecx,%rsi
imul   %ebp,%ecx
add    %ecx,%edx
mov    %edx,0x34(%rsp)
mov    %r13,0x38(%rsp)
lea    0x0(%r13,%rax,4),%r13
shl    $0x2,%rsi
mov    %rsi,0x28(%rsp)
add    %r14,%r12
mov    0x40(%rsp),%rax
lea    (%rax,%r12,4),%r12
shl    $0x2,%r14
mov    $0x1,%ebx
nopl   0x0(%rax)
movss  (%r12),%xmm0
andps  0xe13(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
call   1030 <stdlib_base_is_nanf@plt>
test   %rax,%rax
jne    1238 <stdlib_strided_scuminabs+0x128>
movaps 0x40(%rsp),%xmm0
minss  0x10(%rsp),%xmm0
movss  %xmm0,0x0(%r13)
add    $0x1,%ebx
add    0xc(%rsp),%r15d
add    0x28(%rsp),%r13
add    %r14,%r12
movaps %xmm0,0x10(%rsp)
cmp    %ebx,%ebp
jne    11e0 <stdlib_strided_scuminabs+0xd0>
mov    0x34(%rsp),%eax
mov    %eax,%r15d
mov    %ebp,%ebx
jmp    123d <stdlib_strided_scuminabs+0x12d>
movaps 0x10(%rsp),%xmm0
jmp    1242 <stdlib_strided_scuminabs+0x132>
movaps 0x40(%rsp),%xmm0
mov    0x38(%rsp),%r13
movaps %xmm0,0x10(%rsp)
movaps 0x10(%rsp),%xmm0
call   1030 <stdlib_base_is_nanf@plt>
movaps 0x10(%rsp),%xmm0
test   %rax,%rax
je     12fd <stdlib_strided_scuminabs+0x1ed>
cmp    %ebp,%ebx
jge    12fd <stdlib_strided_scuminabs+0x1ed>
movslq %r15d,%rcx
movslq 0xc(%rsp),%rax
mov    %ebp,%esi
sub    %ebx,%esi
mov    %ebx,%edx
not    %edx
add    %ebp,%edx
and    $0x3,%esi
je     12a3 <stdlib_strided_scuminabs+0x193>
neg    %esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  %xmm0,0x0(%r13,%rcx,4)
add    %rax,%rcx
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    1290 <stdlib_strided_scuminabs+0x180>
sub    %edi,%ebx
cmp    $0x3,%edx
jb     12fd <stdlib_strided_scuminabs+0x1ed>
lea    0x0(,%rcx,4),%rdx
add    %r13,%rdx
mov    %rax,%rsi
shl    $0x4,%rsi
lea    0x0(,%rax,4),%rdi
lea    (%rdi,%rdi,2),%rdi
add    %rax,%rcx
lea    0x0(,%rcx,4),%rcx
add    %r13,%rcx
sub    %ebx,%ebp
cs nopw 0x0(%rax,%rax,1)
movss  %xmm0,(%rdx)
movss  %xmm0,(%rcx)
movss  %xmm0,(%rdx,%rax,8)
movss  %xmm0,(%rdx,%rdi,1)
add    %rsi,%rdx
add    %rsi,%rcx
add    $0xfffffffc,%ebp
jne    12e0 <stdlib_strided_scuminabs+0x1d0>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @stdlib_strided_scuminabs(i32 %0, float* %1, i32 %2, float* %3, i32 %4) {
%6 = alloca i32
%7 = alloca float*
%8 = alloca i32
%9 = alloca float*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca float
%15 = alloca float
store i32 %0, i32* %6
store float* %1, float** %7
store i32 %2, i32* %8
store float* %3, float** %9
store i32 %4, i32* %10
%16 = load i32, i32* %6
%17 = icmp sle i32 %16, 0
br i1 %17, label %18, label %19
18: ; preds = %5
br label %117
19: ; preds = %5
%20 = load i32, i32* %8
%21 = icmp slt i32 %20, 0
br i1 %21, label %22, label %27
22: ; preds = %19
%23 = load i32, i32* %6
%24 = sub nsw i32 1, %23
%25 = load i32, i32* %8
%26 = mul nsw i32 %24, %25
store i32 %26, i32* %11
br label %28
27: ; preds = %19
store i32 0, i32* %11
br label %28
28: ; preds = %27, %22
%29 = load i32, i32* %10
%30 = icmp slt i32 %29, 0
br i1 %30, label %31, label %36
31: ; preds = %28
%32 = load i32, i32* %6
%33 = sub nsw i32 1, %32
%34 = load i32, i32* %10
%35 = mul nsw i32 %33, %34
store i32 %35, i32* %12
br label %37
36: ; preds = %28
store i32 0, i32* %12
br label %37
37: ; preds = %36, %31
%38 = load float*, float** %7
%39 = load i32, i32* %11
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds float, float* %38, i64 %40
%42 = load float, float* %41
%43 = call float @llvm.fabs.f32(float %42)
store float %43, float* %14
%44 = load float, float* %14
%45 = load float*, float** %9
%46 = load i32, i32* %12
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %45, i64 %47
store float %44, float* %48
%49 = load i32, i32* %10
%50 = load i32, i32* %12
%51 = add nsw i32 %50, %49
store i32 %51, i32* %12
store i32 1, i32* %13
%52 = load float, float* %14
%53 = call i64 @stdlib_base_is_nanf(float %52)
%54 = icmp ne i64 %53, 0
br i1 %54, label %94, label %55
55: ; preds = %37
br label %56
56: ; preds = %90, %55
%57 = load i32, i32* %13
%58 = load i32, i32* %6
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %93
60: ; preds = %56
%61 = load i32, i32* %8
%62 = load i32, i32* %11
%63 = add nsw i32 %62, %61
store i32 %63, i32* %11
%64 = load float*, float** %7
%65 = load i32, i32* %11
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %64, i64 %66
%68 = load float, float* %67
%69 = call float @llvm.fabs.f32(float %68)
store float %69, float* %15
%70 = load float, float* %15
%71 = call i64 @stdlib_base_is_nanf(float %70)
%72 = icmp ne i64 %71, 0
br i1 %72, label %73, label %75
73: ; preds = %60
%74 = load float, float* %15
store float %74, float* %14
br label %93
75: ; preds = %60
%76 = load float, float* %15
%77 = load float, float* %14
%78 = fcmp olt float %76, %77
br i1 %78, label %79, label %81
79: ; preds = %75
%80 = load float, float* %15
store float %80, float* %14
br label %81
81: ; preds = %79, %75
%82 = load float, float* %14
%83 = load float*, float** %9
%84 = load i32, i32* %12
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %83, i64 %85
store float %82, float* %86
%87 = load i32, i32* %10
%88 = load i32, i32* %12
%89 = add nsw i32 %88, %87
store i32 %89, i32* %12
br label %90
90: ; preds = %81
%91 = load i32, i32* %13
%92 = add nsw i32 %91, 1
store i32 %92, i32* %13
br label %56
93: ; preds = %73, %56
br label %94
94: ; preds = %93, %37
%95 = load float, float* %14
%96 = call i64 @stdlib_base_is_nanf(float %95)
%97 = icmp ne i64 %96, 0
br i1 %97, label %98, label %116
98: ; preds = %94
br label %99
99: ; preds = %112, %98
%100 = load i32, i32* %13
%101 = load i32, i32* %6
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %115
103: ; preds = %99
%104 = load float, float* %14
%105 = load float*, float** %9
%106 = load i32, i32* %12
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float, float* %105, i64 %107
store float %104, float* %108
%109 = load i32, i32* %10
%110 = load i32, i32* %12
%111 = add nsw i32 %110, %109
store i32 %111, i32* %12
br label %112
112: ; preds = %103
%113 = load i32, i32* %13
%114 = add nsw i32 %113, 1
store i32 %114, i32* %13
br label %99
115: ; preds = %99
br label %116
116: ; preds = %115, %94
br label %117
117: ; preds = %116, %18
ret void
}

LLVM IR (-O2):
define void @stdlib_strided_scuminabs(i32 %0, float* nocapture %1, i32 %2, float* nocapture writeonly %3, i32 %4) {
%6 = icmp slt i32 %0, 1
br i1 %6, label %94, label %7
7: ; preds = %5
%8 = icmp slt i32 %2, 0
%9 = sub nsw i32 1, %0
%10 = mul nsw i32 %9, %2
%11 = select i1 %8, i32 %10, i32 0
%12 = icmp slt i32 %4, 0
%13 = mul nsw i32 %9, %4
%14 = select i1 %12, i32 %13, i32 0
%15 = sext i32 %11 to i64
%16 = getelementptr inbounds float, float* %1, i64 %15
%17 = load float, float* %16
%18 = tail call float @llvm.fabs.f32(float %17)
%19 = sext i32 %14 to i64
%20 = getelementptr inbounds float, float* %3, i64 %19
store float %18, float* %20
%21 = add i32 %14, %4
%22 = tail call i64 @stdlib_base_is_nanf(float %18)
%23 = icmp eq i64 %22, 0
%24 = icmp ne i32 %0, 1
%25 = and i1 %23, %24
br i1 %25, label %26, label %52
26: ; preds = %7
%27 = sext i32 %2 to i64
%28 = sext i32 %21 to i64
%29 = sext i32 %4 to i64
%30 = mul i32 %4, %0
%31 = add i32 %14, %30
br label %32
32: ; preds = %26, %43
%33 = phi i64 [ %28, %26 ], [ %47, %43 ]
%34 = phi i64 [ %15, %26 ], [ %37, %43 ]
%35 = phi float [ %18, %26 ], [ %45, %43 ]
%36 = phi i32 [ 1, %26 ], [ %48, %43 ]
%37 = add i64 %34, %27
%38 = getelementptr inbounds float, float* %1, i64 %37
%39 = load float, float* %38
%40 = tail call float @llvm.fabs.f32(float %39)
%41 = tail call i64 @stdlib_base_is_nanf(float %40)
%42 = icmp eq i64 %41, 0
br i1 %42, label %43, label %50
43: ; preds = %32
%44 = fcmp olt float %40, %35
%45 = select i1 %44, float %40, float %35
%46 = getelementptr inbounds float, float* %3, i64 %33
store float %45, float* %46
%47 = add i64 %33, %29
%48 = add nuw nsw i32 %36, 1
%49 = icmp eq i32 %48, %0
br i1 %49, label %52, label %32
50: ; preds = %32
%51 = trunc i64 %33 to i32
br label %52
52: ; preds = %43, %50, %7
%53 = phi i32 [ %21, %7 ], [ %51, %50 ], [ %31, %43 ]
%54 = phi i32 [ 1, %7 ], [ %36, %50 ], [ %0, %43 ]
%55 = phi float [ %18, %7 ], [ %40, %50 ], [ %45, %43 ]
%56 = tail call i64 @stdlib_base_is_nanf(float %55)
%57 = icmp ne i64 %56, 0
%58 = icmp slt i32 %54, %0
%59 = select i1 %57, i1 %58, i1 false
br i1 %59, label %60, label %94
60: ; preds = %52
%61 = sext i32 %53 to i64
%62 = sext i32 %4 to i64
%63 = sub i32 %0, %54
%64 = xor i32 %54, -1
%65 = add i32 %64, %0
%66 = and i32 %63, 3
%67 = icmp eq i32 %66, 0
br i1 %67, label %77, label %68
68: ; preds = %60, %68
%69 = phi i64 [ %73, %68 ], [ %61, %60 ]
%70 = phi i32 [ %74, %68 ], [ %54, %60 ]
%71 = phi i32 [ %75, %68 ], [ 0, %60 ]
%72 = getelementptr inbounds float, float* %3, i64 %69
store float %55, float* %72
%73 = add i64 %69, %62
%74 = add nuw nsw i32 %70, 1
%75 = add i32 %71, 1
%76 = icmp eq i32 %75, %66
br i1 %76, label %77, label %68
77: ; preds = %68, %60
%78 = phi i64 [ %61, %60 ], [ %73, %68 ]
%79 = phi i32 [ %54, %60 ], [ %74, %68 ]
%80 = icmp ult i32 %65, 3
br i1 %80, label %94, label %81
81: ; preds = %77, %81
%82 = phi i64 [ %91, %81 ], [ %78, %77 ]
%83 = phi i32 [ %92, %81 ], [ %79, %77 ]
%84 = getelementptr inbounds float, float* %3, i64 %82
store float %55, float* %84
%85 = add i64 %82, %62
%86 = getelementptr inbounds float, float* %3, i64 %85
store float %55, float* %86
%87 = add i64 %85, %62
%88 = getelementptr inbounds float, float* %3, i64 %87
store float %55, float* %88
%89 = add i64 %87, %62
%90 = getelementptr inbounds float, float* %3, i64 %89
store float %55, float* %90
%91 = add i64 %89, %62
%92 = add nuw nsw i32 %83, 4
%93 = icmp eq i32 %92, %0
br i1 %93, label %94, label %81
94: ; preds = %77, %81, %52, %5
ret void
}