#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 /*<<< orphan*/);
void s8_to_float(const char *in, float *out, const size_t samples) {
  size_t i;
  assert(in != NULL);
  assert(out != NULL);
  for (i = 0; i < samples; i++)
    out[i] = *in++ / (float)((127) + 1);
}


x86 assembly (clang, -O0):
<s8_to_float>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
cmpq   $0x0,-0x8(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpq   $0x0,-0x10(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    119e <s8_to_float+0x8e>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movsbl (%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xe84(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1150 <s8_to_float+0x40>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<s8_to_float>:
push   %r15
push   %r14
push   %rbx
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%rbx
xor    %edi,%edi
test   %rbx,%rbx
setne  %dil
call   1030 <assert@plt>
xor    %edi,%edi
test   %r15,%r15
setne  %dil
call   1030 <assert@plt>
test   %r14,%r14
je     1345 <s8_to_float+0x235>
cmp    $0x8,%r14
jb     1163 <s8_to_float+0x53>
lea    (%rbx,%r14,1),%rax
cmp    %r15,%rax
jbe    1234 <s8_to_float+0x124>
lea    (%r15,%r14,4),%rax
cmp    %rbx,%rax
jbe    1234 <s8_to_float+0x124>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
mov    %r14,%rdx
and    $0x3,%rdx
je     11a2 <s8_to_float+0x92>
movss  0xe91(%rip),%xmm0
nop
movsbl (%rbx),%esi
add    $0x1,%rbx
xorps  %xmm1,%xmm1
cvtsi2ss %esi,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r15,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1180 <s8_to_float+0x70>
cmp    $0x3,%rcx
jb     1345 <s8_to_float+0x235>
sub    %rax,%r14
lea    (%r15,%rax,4),%rax
add    $0xc,%rax
xor    %ecx,%ecx
movss  0xe4f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsbl (%rbx,%rcx,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0xc(%rax,%rcx,4)
movsbl 0x1(%rbx,%rcx,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x8(%rax,%rcx,4)
movsbl 0x2(%rbx,%rcx,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rax,%rcx,4)
movsbl 0x3(%rbx,%rcx,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r14
jne    11d0 <s8_to_float+0xc0>
jmp    1345 <s8_to_float+0x235>
mov    %r14,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1353 <s8_to_float+0x243>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movaps 0xd9d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movd   (%rbx,%rcx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
movd   0x4(%rbx,%rcx,1),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
psrad  $0x18,%xmm1
cvtdq2ps %xmm1,%xmm1
psrad  $0x18,%xmm2
cvtdq2ps %xmm2,%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%r15,%rcx,4)
movups %xmm2,0x10(%r15,%rcx,4)
movd   0x8(%rbx,%rcx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
movd   0xc(%rbx,%rcx,1),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
psrad  $0x18,%xmm1
cvtdq2ps %xmm1,%xmm1
psrad  $0x18,%xmm2
cvtdq2ps %xmm2,%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,0x20(%r15,%rcx,4)
movups %xmm2,0x30(%r15,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1270 <s8_to_float+0x160>
test   $0x1,%dl
je     1340 <s8_to_float+0x230>
movd   (%rbx,%rcx,1),%xmm0
movd   0x4(%rbx,%rcx,1),%xmm1
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
cvtdq2ps %xmm0,%xmm0
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
cvtdq2ps %xmm1,%xmm1
movaps 0xcd1(%rip),%xmm2
mulps  %xmm2,%xmm0
mulps  %xmm2,%xmm1
movups %xmm0,(%r15,%rcx,4)
movups %xmm1,0x10(%r15,%rcx,4)
cmp    %r14,%rax
jne    134b <s8_to_float+0x23b>
pop    %rbx
pop    %r14
pop    %r15
ret
add    %rax,%rbx
jmp    1165 <s8_to_float+0x55>
xor    %ecx,%ecx
test   $0x1,%dl
jne    12fd <s8_to_float+0x1ed>
jmp    1340 <s8_to_float+0x230>

LLVM IR (-O0):
define void @s8_to_float(i8* %0, float* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca float*
%6 = alloca i64
%7 = alloca i64
store i8* %0, i8** %4
store float* %1, float** %5
store i64 %2, i64* %6
%8 = load i8*, i8** %4
%9 = icmp ne i8* %8, null
%10 = zext i1 %9 to i32
%11 = call i32 @assert(i32 %10)
%12 = load float*, float** %5
%13 = icmp ne float* %12, null
%14 = zext i1 %13 to i32
%15 = call i32 @assert(i32 %14)
store i64 0, i64* %7
br label %16
16: ; preds = %30, %3
%17 = load i64, i64* %7
%18 = load i64, i64* %6
%19 = icmp ult i64 %17, %18
br i1 %19, label %20, label %33
20: ; preds = %16
%21 = load i8*, i8** %4
%22 = getelementptr inbounds i8, i8* %21, i32 1
store i8* %22, i8** %4
%23 = load i8, i8* %21
%24 = sext i8 %23 to i32
%25 = sitofp i32 %24 to float
%26 = fdiv float %25, 1.280000e+02
%27 = load float*, float** %5
%28 = load i64, i64* %7
%29 = getelementptr inbounds float, float* %27, i64 %28
store float %26, float* %29
br label %30
30: ; preds = %20
%31 = load i64, i64* %7
%32 = add i64 %31, 1
store i64 %32, i64* %7
br label %16
33: ; preds = %16
ret void
}

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