#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 densearray_kernel_elem_postreduce_var_f32(size_t dim, size_t count,
                                               float *uvar) {
  float n = (float)(count);
  float scale = 1.0 / (n - 1.0f);
  for (size_t idx = 0; idx < dim; idx++) {
    uvar[idx] *= scale;
  }
}


x86 assembly (clang, -O0):
<densearray_kernel_elem_postreduce_var_f32>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x30(%rbp)
test   %rax,%rax
movss  %xmm0,-0x2c(%rbp)
js     114d <densearray_kernel_elem_postreduce_var_f32+0x4d>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  0xea4(%rip),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe8c(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    11bf <densearray_kernel_elem_postreduce_var_f32+0xbf>
movss  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1189 <densearray_kernel_elem_postreduce_var_f32+0x89>
pop    %rbp
ret

x86 assembly (clang, -O2):
<densearray_kernel_elem_postreduce_var_f32>:
test   %rsi,%rsi
js     1114 <densearray_kernel_elem_postreduce_var_f32+0x14>
cvtsi2ss %rsi,%xmm1
test   %rdi,%rdi
jne    1132 <densearray_kernel_elem_postreduce_var_f32+0x32>
jmp    1207 <densearray_kernel_elem_postreduce_var_f32+0x107>
mov    %rsi,%rax
shr    %rax
and    $0x1,%esi
or     %rax,%rsi
cvtsi2ss %rsi,%xmm1
addss  %xmm1,%xmm1
test   %rdi,%rdi
je     1207 <densearray_kernel_elem_postreduce_var_f32+0x107>
addss  0xec6(%rip),%xmm1
movss  0xec2(%rip),%xmm0
divss  %xmm1,%xmm0
cmp    $0x8,%rdi
jae    1153 <densearray_kernel_elem_postreduce_var_f32+0x53>
xor    %eax,%eax
jmp    11f0 <densearray_kernel_elem_postreduce_var_f32+0xf0>
mov    %rdi,%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rax),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1208 <densearray_kernel_elem_postreduce_var_f32+0x108>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdx,%rcx,4),%xmm2
movups 0x10(%rdx,%rcx,4),%xmm3
movups 0x20(%rdx,%rcx,4),%xmm4
movups 0x30(%rdx,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdx,%rcx,4)
movups %xmm3,0x10(%rdx,%rcx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,0x20(%rdx,%rcx,4)
movups %xmm5,0x30(%rdx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1190 <densearray_kernel_elem_postreduce_var_f32+0x90>
test   $0x1,%r8b
je     11ea <densearray_kernel_elem_postreduce_var_f32+0xea>
movups (%rdx,%rcx,4),%xmm2
movups 0x10(%rdx,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdx,%rcx,4)
movups %xmm3,0x10(%rdx,%rcx,4)
cmp    %rdi,%rax
je     1207 <densearray_kernel_elem_postreduce_var_f32+0x107>
nop
movss  (%rdx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdi
jne    11f0 <densearray_kernel_elem_postreduce_var_f32+0xf0>
ret
xor    %ecx,%ecx
test   $0x1,%r8b
jne    11d2 <densearray_kernel_elem_postreduce_var_f32+0xd2>
jmp    11ea <densearray_kernel_elem_postreduce_var_f32+0xea>

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

LLVM IR (-O2):
define void @densearray_kernel_elem_postreduce_var_f32(i64 %0, i64 %1, float* nocapture %2) {
%4 = uitofp i64 %1 to float
%5 = fadd float %4, -1.000000e+00
%6 = fdiv float 1.000000e+00, %5
%7 = icmp eq i64 %0, 0
br i1 %7, label %68, label %8
8: ; preds = %3
%9 = icmp ult i64 %0, 8
br i1 %9, label %66, label %10
10: ; preds = %8
%11 = and i64 %0, -8
%12 = insertelement <4 x float> poison, float %6, i64 0
%13 = shufflevector <4 x float> %12, <4 x float> poison, <4 x i32> zeroinitializer
%14 = insertelement <4 x float> poison, float %6, i64 0
%15 = shufflevector <4 x float> %14, <4 x float> poison, <4 x i32> zeroinitializer
%16 = add i64 %11, -8
%17 = lshr exact i64 %16, 3
%18 = add nuw nsw i64 %17, 1
%19 = and i64 %18, 1
%20 = icmp eq i64 %16, 0
br i1 %20, label %50, label %21
21: ; preds = %10
%22 = and i64 %18, 4611686018427387902
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %47, %23 ]
%25 = phi i64 [ 0, %21 ], [ %48, %23 ]
%26 = getelementptr inbounds float, float* %2, i64 %24
%27 = bitcast float* %26 to <4 x float>*
%28 = load <4 x float>, <4 x float>* %27
%29 = getelementptr inbounds float, float* %26, i64 4
%30 = bitcast float* %29 to <4 x float>*
%31 = load <4 x float>, <4 x float>* %30
%32 = fmul <4 x float> %13, %28
%33 = fmul <4 x float> %15, %31
%34 = bitcast float* %26 to <4 x float>*
store <4 x float> %32, <4 x float>* %34
%35 = bitcast float* %29 to <4 x float>*
store <4 x float> %33, <4 x float>* %35
%36 = or i64 %24, 8
%37 = getelementptr inbounds float, float* %2, i64 %36
%38 = bitcast float* %37 to <4 x float>*
%39 = load <4 x float>, <4 x float>* %38
%40 = getelementptr inbounds float, float* %37, i64 4
%41 = bitcast float* %40 to <4 x float>*
%42 = load <4 x float>, <4 x float>* %41
%43 = fmul <4 x float> %13, %39
%44 = fmul <4 x float> %15, %42
%45 = bitcast float* %37 to <4 x float>*
store <4 x float> %43, <4 x float>* %45
%46 = bitcast float* %40 to <4 x float>*
store <4 x float> %44, <4 x float>* %46
%47 = add nuw i64 %24, 16
%48 = add i64 %25, 2
%49 = icmp eq i64 %48, %22
br i1 %49, label %50, label %23
50: ; preds = %23, %10
%51 = phi i64 [ 0, %10 ], [ %47, %23 ]
%52 = icmp eq i64 %19, 0
br i1 %52, label %64, label %53
53: ; preds = %50
%54 = getelementptr inbounds float, float* %2, i64 %51
%55 = bitcast float* %54 to <4 x float>*
%56 = load <4 x float>, <4 x float>* %55
%57 = getelementptr inbounds float, float* %54, i64 4
%58 = bitcast float* %57 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = fmul <4 x float> %13, %56
%61 = fmul <4 x float> %15, %59
%62 = bitcast float* %54 to <4 x float>*
store <4 x float> %60, <4 x float>* %62
%63 = bitcast float* %57 to <4 x float>*
store <4 x float> %61, <4 x float>* %63
br label %64
64: ; preds = %50, %53
%65 = icmp eq i64 %11, %0
br i1 %65, label %68, label %66
66: ; preds = %8, %64
%67 = phi i64 [ 0, %8 ], [ %11, %64 ]
br label %69
68: ; preds = %69, %64, %3
ret void
69: ; preds = %66, %69
%70 = phi i64 [ %74, %69 ], [ %67, %66 ]
%71 = getelementptr inbounds float, float* %2, i64 %70
%72 = load float, float* %71
%73 = fmul float %6, %72
store float %73, float* %71
%74 = add nuw i64 %70, 1
%75 = icmp eq i64 %74, %0
br i1 %75, label %68, label %69
}