#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 src_int_to_float_array(const int *in, float *out, int len) {
  while (len) {
    len--;
    out[len] = (float)(in[len] / (8.0 * 0x10000000));
  };
  return;
}


x86 assembly (clang, -O0):
<src_int_to_float_array>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     1151 <src_int_to_float_array+0x51>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  0xec9(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    110f <src_int_to_float_array+0xf>
pop    %rbp
ret

x86 assembly (clang, -O2):
<src_int_to_float_array>:
push   %rbx
test   %edx,%edx
je     1252 <src_int_to_float_array+0x152>
movslq %edx,%rax
add    $0xffffffff,%edx
cmp    $0x3,%edx
jb     121a <src_int_to_float_array+0x11a>
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1254 <src_int_to_float_array+0x154>
mov    %r9,%r10
and    $0xfffffffffffffffe,%r10
lea    (%rsi,%rax,4),%r11
lea    (%rdi,%rax,4),%rbx
mov    $0xfffffffffffffffc,%rcx
movapd 0xea7(%rip),%xmm0
nopl   0x0(%rax)
movdqu (%rbx,%rcx,4),%xmm1
pshufd $0x1b,%xmm1,%xmm2
cvtdq2pd %xmm2,%xmm2
pshufd $0x11,%xmm1,%xmm1
cvtdq2pd %xmm1,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm1,%xmm1
shufps $0x11,%xmm2,%xmm1
movups %xmm1,(%r11,%rcx,4)
movdqu -0x10(%rbx,%rcx,4),%xmm1
pshufd $0x1b,%xmm1,%xmm2
cvtdq2pd %xmm2,%xmm2
pshufd $0x11,%xmm1,%xmm1
cvtdq2pd %xmm1,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm1,%xmm1
shufps $0x11,%xmm2,%xmm1
movups %xmm1,-0x10(%r11,%rcx,4)
add    $0xfffffffffffffff8,%rcx
add    $0xfffffffffffffffe,%r10
jne    1160 <src_int_to_float_array+0x60>
add    $0x3,%rcx
test   $0x1,%r9b
je     1212 <src_int_to_float_array+0x112>
add    %rax,%rcx
movdqu -0xc(%rdi,%rcx,4),%xmm0
pshufd $0x1b,%xmm0,%xmm1
cvtdq2pd %xmm1,%xmm1
pshufd $0x11,%xmm0,%xmm0
cvtdq2pd %xmm0,%xmm0
movapd 0xe07(%rip),%xmm2
mulpd  %xmm2,%xmm0
mulpd  %xmm2,%xmm1
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm0,%xmm0
shufps $0x11,%xmm1,%xmm0
movups %xmm0,-0xc(%rsi,%rcx,4)
cmp    %r8,%rdx
je     1252 <src_int_to_float_array+0x152>
sub    %r8,%rax
movsd  0xdee(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorps  %xmm1,%xmm1
cvtsi2sdl -0x4(%rdi,%rax,4),%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,-0x4(%rsi,%rax,4)
lea    -0x1(%rax),%rcx
mov    %rcx,%rax
test   %ecx,%ecx
jne    1230 <src_int_to_float_array+0x130>
pop    %rbx
ret
mov    $0xffffffffffffffff,%rcx
test   $0x1,%r9b
jne    11d6 <src_int_to_float_array+0xd6>
jmp    1212 <src_int_to_float_array+0x112>

LLVM IR (-O0):
define void @src_int_to_float_array(i32* %0, float* %1, i32 %2) {
%4 = alloca i32*
%5 = alloca float*
%6 = alloca i32
store i32* %0, i32** %4
store float* %1, float** %5
store i32 %2, i32* %6
br label %7
7: ; preds = %10, %3
%8 = load i32, i32* %6
%9 = icmp ne i32 %8, 0
br i1 %9, label %10, label %25
10: ; preds = %7
%11 = load i32, i32* %6
%12 = add nsw i32 %11, -1
store i32 %12, i32* %6
%13 = load i32*, i32** %4
%14 = load i32, i32* %6
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i32, i32* %13, i64 %15
%17 = load i32, i32* %16
%18 = sitofp i32 %17 to double
%19 = fdiv double %18, 0x41E0000000000000
%20 = fptrunc double %19 to float
%21 = load float*, float** %5
%22 = load i32, i32* %6
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds float, float* %21, i64 %23
store float %20, float* %24
br label %7
25: ; preds = %7
ret void
}

LLVM IR (-O2):
define void @src_int_to_float_array(i32* nocapture %0, float* nocapture writeonly %1, i32 %2) {
%4 = icmp eq i32 %2, 0
br i1 %4, label %89, label %5
5: ; preds = %3
%6 = sext i32 %2 to i64
%7 = add i32 %2, -1
%8 = zext i32 %7 to i64
%9 = add nuw nsw i64 %8, 1
%10 = icmp ult i32 %7, 3
br i1 %10, label %76, label %11
11: ; preds = %5
%12 = and i64 %9, 8589934588
%13 = sub nsw i64 %6, %12
%14 = add nsw i64 %12, -4
%15 = lshr exact i64 %14, 2
%16 = add nuw nsw i64 %15, 1
%17 = and i64 %16, 1
%18 = icmp eq i64 %14, 0
br i1 %18, label %57, label %19
19: ; preds = %11
%20 = and i64 %16, 9223372036854775806
%21 = getelementptr inbounds i32, i32* %0, i64 -3
%22 = getelementptr inbounds float, float* %1, i64 -3
%23 = getelementptr inbounds i32, i32* %0, i64 -3
%24 = getelementptr inbounds float, float* %1, i64 -3
br label %25
25: ; preds = %25, %19
%26 = phi i64 [ 0, %19 ], [ %52, %25 ]
%27 = phi i64 [ 0, %19 ], [ %53, %25 ]
%28 = xor i64 %26, -1
%29 = add i64 %28, %6
%30 = getelementptr inbounds i32, i32* %21, i64 %29
%31 = bitcast i32* %30 to <4 x i32>*
%32 = load <4 x i32>, <4 x i32>* %31
%33 = shufflevector <4 x i32> %32, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%34 = sitofp <4 x i32> %33 to <4 x double>
%35 = fmul <4 x double> %34, <double 0x3E00000000000000, double 0x3E00000000000000, double 0x3E00000000000000, double 0x3E00000000000000>
%36 = fptrunc <4 x double> %35 to <4 x float>
%37 = shufflevector <4 x float> %36, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%38 = getelementptr inbounds float, float* %22, i64 %29
%39 = bitcast float* %38 to <4 x float>*
store <4 x float> %37, <4 x float>* %39
%40 = sub nuw nsw i64 -5, %26
%41 = add i64 %40, %6
%42 = getelementptr inbounds i32, i32* %23, i64 %41
%43 = bitcast i32* %42 to <4 x i32>*
%44 = load <4 x i32>, <4 x i32>* %43
%45 = shufflevector <4 x i32> %44, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%46 = sitofp <4 x i32> %45 to <4 x double>
%47 = fmul <4 x double> %46, <double 0x3E00000000000000, double 0x3E00000000000000, double 0x3E00000000000000, double 0x3E00000000000000>
%48 = fptrunc <4 x double> %47 to <4 x float>
%49 = shufflevector <4 x float> %48, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%50 = getelementptr inbounds float, float* %24, i64 %41
%51 = bitcast float* %50 to <4 x float>*
store <4 x float> %49, <4 x float>* %51
%52 = add nuw i64 %26, 8
%53 = add i64 %27, 2
%54 = icmp eq i64 %53, %20
br i1 %54, label %55, label %25
55: ; preds = %25
%56 = sub i64 -9, %26
br label %57
57: ; preds = %55, %11
%58 = phi i64 [ -1, %11 ], [ %56, %55 ]
%59 = icmp eq i64 %17, 0
br i1 %59, label %74, label %60
60: ; preds = %57
%61 = add i64 %58, %6
%62 = getelementptr inbounds i32, i32* %0, i64 -3
%63 = getelementptr inbounds i32, i32* %62, i64 %61
%64 = bitcast i32* %63 to <4 x i32>*
%65 = load <4 x i32>, <4 x i32>* %64
%66 = shufflevector <4 x i32> %65, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%67 = sitofp <4 x i32> %66 to <4 x double>
%68 = fmul <4 x double> %67, <double 0x3E00000000000000, double 0x3E00000000000000, double 0x3E00000000000000, double 0x3E00000000000000>
%69 = fptrunc <4 x double> %68 to <4 x float>
%70 = getelementptr inbounds float, float* %1, i64 -3
%71 = shufflevector <4 x float> %69, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%72 = getelementptr inbounds float, float* %70, i64 %61
%73 = bitcast float* %72 to <4 x float>*
store <4 x float> %71, <4 x float>* %73
br label %74
74: ; preds = %57, %60
%75 = icmp eq i64 %9, %12
br i1 %75, label %89, label %76
76: ; preds = %5, %74
%77 = phi i64 [ %6, %5 ], [ %13, %74 ]
br label %78
78: ; preds = %76, %78
%79 = phi i64 [ %80, %78 ], [ %77, %76 ]
%80 = add nsw i64 %79, -1
%81 = getelementptr inbounds i32, i32* %0, i64 %80
%82 = load i32, i32* %81
%83 = sitofp i32 %82 to double
%84 = fmul double %83, 0x3E00000000000000
%85 = fptrunc double %84 to float
%86 = getelementptr inbounds float, float* %1, i64 %80
store float %85, float* %86
%87 = trunc i64 %80 to i32
%88 = icmp eq i32 %87, 0
br i1 %88, label %89, label %78
89: ; preds = %78, %74, %3
ret void
}