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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
void arraydiff_kernel_rect_fwd_f32(size_t dim, const float *x, float *y) {
  for (size_t i = 0; i < dim; i++) {
    float x_i = x[i];
    y[i] = x_i * (x_i > 0.0f);
  }
}


x86 assembly (clang, -O0):
<arraydiff_kernel_rect_fwd_f32>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1176 <arraydiff_kernel_rect_fwd_f32+0x76>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x24(%rbp),%xmm1
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
seta   %al
and    $0x1,%al
movzbl %al,%eax
cvtsi2ss %eax,%xmm1
mulss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1118 <arraydiff_kernel_rect_fwd_f32+0x18>
pop    %rbp
ret

x86 assembly (clang, -O2):
<arraydiff_kernel_rect_fwd_f32>:
test   %rdi,%rdi
je     1296 <arraydiff_kernel_rect_fwd_f32+0x196>
cmp    $0x8,%rdi
jb     1129 <arraydiff_kernel_rect_fwd_f32+0x29>
lea    (%rsi,%rdi,4),%rax
cmp    %rdx,%rax
jbe    11b2 <arraydiff_kernel_rect_fwd_f32+0xb2>
lea    (%rdx,%rdi,4),%rax
cmp    %rsi,%rax
jbe    11b2 <arraydiff_kernel_rect_fwd_f32+0xb2>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%dil
je     115c <arraydiff_kernel_rect_fwd_f32+0x5c>
movss  (%rsi,%rax,4),%xmm0
xorps  %xmm1,%xmm1
cmpltss %xmm0,%xmm1
movss  0xec4(%rip),%xmm2
andps  %xmm1,%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rdx,%rax,4)
or     $0x1,%rax
add    %rdi,%rcx
je     1296 <arraydiff_kernel_rect_fwd_f32+0x196>
movss  0xea3(%rip),%xmm0
nopl   (%rax)
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm2,%xmm2
cmpltss %xmm1,%xmm2
andps  %xmm0,%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,(%rdx,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm1
xorps  %xmm2,%xmm2
cmpltss %xmm1,%xmm2
andps  %xmm0,%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,0x4(%rdx,%rax,4)
add    $0x2,%rax
cmp    %rax,%rdi
jne    1170 <arraydiff_kernel_rect_fwd_f32+0x70>
jmp    1296 <arraydiff_kernel_rect_fwd_f32+0x196>
mov    %rdi,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1297 <arraydiff_kernel_rect_fwd_f32+0x197>
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
xor    %ecx,%ecx
movaps 0xe1f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rcx,4),%xmm1
movups 0x10(%rsi,%rcx,4),%xmm2
xorps  %xmm3,%xmm3
cmpltps %xmm1,%xmm3
andps  %xmm0,%xmm3
xorps  %xmm4,%xmm4
cmpltps %xmm2,%xmm4
andps  %xmm0,%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm2,%xmm4
movups %xmm3,(%rdx,%rcx,4)
movups %xmm4,0x10(%rdx,%rcx,4)
movups 0x20(%rsi,%rcx,4),%xmm1
movups 0x30(%rsi,%rcx,4),%xmm2
xorps  %xmm3,%xmm3
cmpltps %xmm1,%xmm3
andps  %xmm0,%xmm3
xorps  %xmm4,%xmm4
cmpltps %xmm2,%xmm4
andps  %xmm0,%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm2,%xmm4
movups %xmm3,0x20(%rdx,%rcx,4)
movups %xmm4,0x30(%rdx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%r9
jne    11f0 <arraydiff_kernel_rect_fwd_f32+0xf0>
test   $0x1,%r8b
je     128d <arraydiff_kernel_rect_fwd_f32+0x18d>
movups (%rsi,%rcx,4),%xmm0
movups 0x10(%rsi,%rcx,4),%xmm1
xorps  %xmm2,%xmm2
xorps  %xmm3,%xmm3
cmpltps %xmm0,%xmm3
movaps 0xd8c(%rip),%xmm4
andps  %xmm4,%xmm3
cmpltps %xmm1,%xmm2
andps  %xmm4,%xmm2
mulps  %xmm0,%xmm3
mulps  %xmm1,%xmm2
movups %xmm3,(%rdx,%rcx,4)
movups %xmm2,0x10(%rdx,%rcx,4)
cmp    %rdi,%rax
jne    112b <arraydiff_kernel_rect_fwd_f32+0x2b>
ret
xor    %ecx,%ecx
test   $0x1,%r8b
jne    125a <arraydiff_kernel_rect_fwd_f32+0x15a>
jmp    128d <arraydiff_kernel_rect_fwd_f32+0x18d>

LLVM IR (-O0):
define void @arraydiff_kernel_rect_fwd_f32(i64 %0, float* %1, float* %2) {
%4 = alloca i64
%5 = alloca float*
%6 = alloca float*
%7 = alloca i64
%8 = alloca float
store i64 %0, i64* %4
store float* %1, float** %5
store float* %2, float** %6
store i64 0, i64* %7
br label %9
9: ; preds = %27, %3
%10 = load i64, i64* %7
%11 = load i64, i64* %4
%12 = icmp ult i64 %10, %11
br i1 %12, label %13, label %30
13: ; preds = %9
%14 = load float*, float** %5
%15 = load i64, i64* %7
%16 = getelementptr inbounds float, float* %14, i64 %15
%17 = load float, float* %16
store float %17, float* %8
%18 = load float, float* %8
%19 = load float, float* %8
%20 = fcmp ogt float %19, 0.000000e+00
%21 = zext i1 %20 to i32
%22 = sitofp i32 %21 to float
%23 = fmul float %18, %22
%24 = load float*, float** %6
%25 = load i64, i64* %7
%26 = getelementptr inbounds float, float* %24, i64 %25
store float %23, float* %26
br label %27
27: ; preds = %13
%28 = load i64, i64* %7
%29 = add i64 %28, 1
store i64 %29, i64* %7
br label %9
30: ; preds = %9
ret void
}

LLVM IR (-O2):
define void @arraydiff_kernel_rect_fwd_f32(i64 %0, float* nocapture %1, float* nocapture writeonly %2) {
%4 = icmp eq i64 %0, 0
br i1 %4, label %100, label %5
5: ; preds = %3
%6 = icmp ult i64 %0, 8
br i1 %6, label %83, label %7
7: ; preds = %5
%8 = getelementptr float, float* %2, i64 %0
%9 = getelementptr float, float* %1, i64 %0
%10 = icmp ugt float* %9, %2
%11 = icmp ugt float* %8, %1
%12 = and i1 %10, %11
br i1 %12, label %83, label %13
13: ; preds = %7
%14 = and i64 %0, -8
%15 = add i64 %14, -8
%16 = lshr exact i64 %15, 3
%17 = add nuw nsw i64 %16, 1
%18 = and i64 %17, 1
%19 = icmp eq i64 %15, 0
br i1 %19, label %61, label %20
20: ; preds = %13
%21 = and i64 %17, 4611686018427387902
br label %22
22: ; preds = %22, %20
%23 = phi i64 [ 0, %20 ], [ %58, %22 ]
%24 = phi i64 [ 0, %20 ], [ %59, %22 ]
%25 = getelementptr inbounds float, float* %1, i64 %23
%26 = bitcast float* %25 to <4 x float>*
%27 = load <4 x float>, <4 x float>* %26
%28 = getelementptr inbounds float, float* %25, i64 4
%29 = bitcast float* %28 to <4 x float>*
%30 = load <4 x float>, <4 x float>* %29
%31 = fcmp ogt <4 x float> %27, zeroinitializer
%32 = fcmp ogt <4 x float> %30, zeroinitializer
%33 = uitofp <4 x i1> %31 to <4 x float>
%34 = uitofp <4 x i1> %32 to <4 x float>
%35 = fmul <4 x float> %27, %33
%36 = fmul <4 x float> %30, %34
%37 = getelementptr inbounds float, float* %2, i64 %23
%38 = bitcast float* %37 to <4 x float>*
store <4 x float> %35, <4 x float>* %38
%39 = getelementptr inbounds float, float* %37, i64 4
%40 = bitcast float* %39 to <4 x float>*
store <4 x float> %36, <4 x float>* %40
%41 = or i64 %23, 8
%42 = getelementptr inbounds float, float* %1, i64 %41
%43 = bitcast float* %42 to <4 x float>*
%44 = load <4 x float>, <4 x float>* %43
%45 = getelementptr inbounds float, float* %42, i64 4
%46 = bitcast float* %45 to <4 x float>*
%47 = load <4 x float>, <4 x float>* %46
%48 = fcmp ogt <4 x float> %44, zeroinitializer
%49 = fcmp ogt <4 x float> %47, zeroinitializer
%50 = uitofp <4 x i1> %48 to <4 x float>
%51 = uitofp <4 x i1> %49 to <4 x float>
%52 = fmul <4 x float> %44, %50
%53 = fmul <4 x float> %47, %51
%54 = getelementptr inbounds float, float* %2, i64 %41
%55 = bitcast float* %54 to <4 x float>*
store <4 x float> %52, <4 x float>* %55
%56 = getelementptr inbounds float, float* %54, i64 4
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %53, <4 x float>* %57
%58 = add nuw i64 %23, 16
%59 = add i64 %24, 2
%60 = icmp eq i64 %59, %21
br i1 %60, label %61, label %22
61: ; preds = %22, %13
%62 = phi i64 [ 0, %13 ], [ %58, %22 ]
%63 = icmp eq i64 %18, 0
br i1 %63, label %81, label %64
64: ; preds = %61
%65 = getelementptr inbounds float, float* %1, i64 %62
%66 = bitcast float* %65 to <4 x float>*
%67 = load <4 x float>, <4 x float>* %66
%68 = getelementptr inbounds float, float* %65, i64 4
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = fcmp ogt <4 x float> %67, zeroinitializer
%72 = fcmp ogt <4 x float> %70, zeroinitializer
%73 = uitofp <4 x i1> %71 to <4 x float>
%74 = uitofp <4 x i1> %72 to <4 x float>
%75 = fmul <4 x float> %67, %73
%76 = fmul <4 x float> %70, %74
%77 = getelementptr inbounds float, float* %2, i64 %62
%78 = bitcast float* %77 to <4 x float>*
store <4 x float> %75, <4 x float>* %78
%79 = getelementptr inbounds float, float* %77, i64 4
%80 = bitcast float* %79 to <4 x float>*
store <4 x float> %76, <4 x float>* %80
br label %81
81: ; preds = %61, %64
%82 = icmp eq i64 %14, %0
br i1 %82, label %100, label %83
83: ; preds = %7, %5, %81
%84 = phi i64 [ 0, %7 ], [ 0, %5 ], [ %14, %81 ]
%85 = xor i64 %84, -1
%86 = and i64 %0, 1
%87 = icmp eq i64 %86, 0
br i1 %87, label %96, label %88
88: ; preds = %83
%89 = getelementptr inbounds float, float* %1, i64 %84
%90 = load float, float* %89
%91 = fcmp ogt float %90, 0.000000e+00
%92 = uitofp i1 %91 to float
%93 = fmul float %90, %92
%94 = getelementptr inbounds float, float* %2, i64 %84
store float %93, float* %94
%95 = or i64 %84, 1
br label %96
96: ; preds = %88, %83
%97 = phi i64 [ %84, %83 ], [ %95, %88 ]
%98 = sub i64 0, %0
%99 = icmp eq i64 %85, %98
br i1 %99, label %100, label %101
100: ; preds = %96, %101, %81, %3
ret void
101: ; preds = %96, %101
%102 = phi i64 [ %116, %101 ], [ %97, %96 ]
%103 = getelementptr inbounds float, float* %1, i64 %102
%104 = load float, float* %103
%105 = fcmp ogt float %104, 0.000000e+00
%106 = uitofp i1 %105 to float
%107 = fmul float %104, %106
%108 = getelementptr inbounds float, float* %2, i64 %102
store float %107, float* %108
%109 = add nuw i64 %102, 1
%110 = getelementptr inbounds float, float* %1, i64 %109
%111 = load float, float* %110
%112 = fcmp ogt float %111, 0.000000e+00
%113 = uitofp i1 %112 to float
%114 = fmul float %111, %113
%115 = getelementptr inbounds float, float* %2, i64 %109
store float %114, float* %115
%116 = add nuw i64 %102, 2
%117 = icmp eq i64 %116, %0
br i1 %117, label %100, label %101
}