#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 */
int /*<<< orphan*/ assert(int);
void src_int_to_float_array(int const *src, float *dest, int len) {
  assert(src && dest);
  while (len--)
    dest[len] = (float)(src[len] * (1 / (32768. * 65536.)));
}


x86 assembly (clang, -O0):
<src_int_to_float_array>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x8(%rbp)
mov    %al,-0x15(%rbp)
je     113e <src_int_to_float_array+0x2e>
cmpq   $0x0,-0x10(%rbp)
setne  %al
mov    %al,-0x15(%rbp)
mov    -0x15(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     118e <src_int_to_float_array+0x7e>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  0xe8c(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    114b <src_int_to_float_array+0x3b>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<src_int_to_float_array>:
push   %r15
push   %r14
push   %rbx
mov    %edx,%r15d
mov    %rsi,%r14
mov    %rdi,%rbx
test   %rdi,%rdi
setne  %al
test   %rsi,%rsi
setne  %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
test   %r15d,%r15d
je     1283 <src_int_to_float_array+0x173>
movslq %r15d,%rax
add    $0xffffffff,%r15d
cmp    $0x3,%r15d
jb     1249 <src_int_to_float_array+0x139>
add    $0x1,%r15
mov    %r15,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1289 <src_int_to_float_array+0x179>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%r14,%rax,4),%rcx
lea    (%rbx,%rax,4),%rsi
mov    $0xfffffffffffffffc,%rdx
movapd 0xe71(%rip),%xmm0
nop
movdqu (%rsi,%rdx,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,(%rcx,%rdx,4)
movdqu -0x10(%rsi,%rdx,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(%rcx,%rdx,4)
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1190 <src_int_to_float_array+0x80>
add    $0x3,%rdx
test   $0x1,%r9b
je     1241 <src_int_to_float_array+0x131>
add    %rax,%rdx
movdqu -0xc(%rbx,%rdx,4),%xmm0
pshufd $0x1b,%xmm0,%xmm1
cvtdq2pd %xmm1,%xmm1
pshufd $0x11,%xmm0,%xmm0
cvtdq2pd %xmm0,%xmm0
movapd 0xdd9(%rip),%xmm2
mulpd  %xmm2,%xmm0
mulpd  %xmm2,%xmm1
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm0,%xmm0
shufps $0x11,%xmm1,%xmm0
movups %xmm0,-0xc(%r14,%rdx,4)
cmp    %r8,%r15
je     1283 <src_int_to_float_array+0x173>
sub    %r8,%rax
movsd  0xdbf(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sdl -0x4(%rbx,%rax,4),%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,-0x4(%r14,%rax,4)
lea    -0x1(%rax),%rcx
mov    %rcx,%rax
test   %ecx,%ecx
jne    1260 <src_int_to_float_array+0x150>
pop    %rbx
pop    %r14
pop    %r15
ret
mov    $0xffffffffffffffff,%rdx
test   $0x1,%r9b
jne    1204 <src_int_to_float_array+0xf4>
jmp    1241 <src_int_to_float_array+0x131>

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
%7 = load i32*, i32** %4
%8 = icmp ne i32* %7, null
br i1 %8, label %9, label %12
9: ; preds = %3
%10 = load float*, float** %5
%11 = icmp ne float* %10, null
br label %12
12: ; preds = %9, %3
%13 = phi i1 [ false, %3 ], [ %11, %9 ]
%14 = zext i1 %13 to i32
%15 = call i32 @assert(i32 %14)
br label %16
16: ; preds = %20, %12
%17 = load i32, i32* %6
%18 = add nsw i32 %17, -1
store i32 %18, i32* %6
%19 = icmp ne i32 %17, 0
br i1 %19, label %20, label %33
20: ; preds = %16
%21 = load i32*, i32** %4
%22 = load i32, i32* %6
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i32, i32* %21, i64 %23
%25 = load i32, i32* %24
%26 = sitofp i32 %25 to double
%27 = fmul double %26, 0x3E00000000000000
%28 = fptrunc double %27 to float
%29 = load float*, float** %5
%30 = load i32, i32* %6
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds float, float* %29, i64 %31
store float %28, float* %32
br label %16
33: ; preds = %16
ret void
}

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