#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 */
struct stat {
  int st_size;
};
typedef float int16_t;

/* Variables and functions */
int /*<<< orphan*/ O_RDONLY;
int /*<<< orphan*/ close(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
int open(char const *, int /*<<< orphan*/);
size_t read(int, float *, size_t);
scalar_t__ stat(char const *, struct stat *);
int /*<<< orphan*/ stderr;
float *read_raw(const char *filename, size_t *frames) {
  struct stat st;
  int16_t *buf;
  size_t f, n;
  int fd;
  float *data;
  int i;
  if (stat(filename, &st) < 0) {
    fprintf(stderr, "cannot stat file %s\n", filename);
    return NULL;
  }
  fd = open(filename, O_RDONLY);
  if (fd < 0) {
    fprintf(stderr, "cannot open file %s\n", filename);
    return NULL;
  }
  f = st.st_size / 4;
  n = f * 4;
  buf = (int16_t *)malloc(n);
  if (read(fd, buf, n) != n) {
    fprintf(stderr, "short read %zu\n", n);
    free(buf);
    return NULL;
  }
  close(fd);
  data = (float *)malloc(sizeof(float) * f * 2);
  for (i = 0; i < f; i++) {
    data[i] = buf[2 * i] / 32768.0f;
    data[i + f] = buf[2 * i + 1] / 32768.0f;
  }
  free(buf);
  *frames = f;
  return data;
}


x86 assembly (clang, -O0):
<read_raw>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
lea    -0x20(%rbp),%rsi
call   1070 <stat@plt>
cmp    $0x0,%rax
jge    11bf <read_raw+0x4f>
mov    0x2e3a(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rdx
lea    0xe59(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movq   $0x0,-0x8(%rbp)
jmp    1338 <read_raw+0x1c8>
mov    -0x10(%rbp),%rdi
mov    0x2e1e(%rip),%rax
mov    (%rax),%esi
call   1090 <open@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jge    1206 <read_raw+0x96>
mov    0x2df3(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rdx
lea    0xe27(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movq   $0x0,-0x8(%rbp)
jmp    1338 <read_raw+0x1c8>
mov    -0x20(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cltq
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x38(%rbp),%rdx
call   1050 <read@plt>
cmp    -0x38(%rbp),%rax
je     127d <read_raw+0x10d>
mov    0x2d85(%rip),%rax
mov    (%rax),%edi
mov    -0x38(%rbp),%rdx
lea    0xdce(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
movq   $0x0,-0x8(%rbp)
jmp    1338 <read_raw+0x1c8>
mov    -0x3c(%rbp),%edi
call   1040 <close@plt>
mov    -0x30(%rbp),%rax
shl    $0x2,%rax
shl    $0x1,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movslq -0x4c(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    131c <read_raw+0x1ac>
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0xd35(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0xd07(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
add    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12a3 <read_raw+0x133>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x48(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<read_raw>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%rbp
mov    %rdi,%rbx
lea    0x8(%rsp),%rsi
call   1070 <stat@plt>
test   %rax,%rax
js     12cd <read_raw+0x15d>
mov    0x2e4a(%rip),%rax
mov    (%rax),%esi
mov    %rbx,%rdi
call   1090 <open@plt>
test   %eax,%eax
js     12df <read_raw+0x16f>
mov    %eax,%r15d
mov    %rbp,0x10(%rsp)
mov    0x8(%rsp),%ebp
lea    0x3(%rbp),%r14d
test   %ebp,%ebp
cmovs  %r14d,%ebp
sar    $0x2,%ebp
movslq %ebp,%r13
lea    0x0(,%r13,4),%r12
mov    %r12d,%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
mov    %r15d,%edi
mov    %rax,%rsi
mov    %r12,%rdx
call   1050 <read@plt>
cmp    %r12,%rax
jne    1301 <read_raw+0x191>
mov    %r15d,%edi
call   1040 <close@plt>
shl    $0x3,%ebp
mov    %ebp,%edi
call   1080 <malloc@plt>
mov    %rax,%r15
cmp    $0x7,%r14d
jb     14a3 <read_raw+0x333>
cmp    $0x2,%r13
mov    $0x1,%eax
cmovae %r13,%rax
cmp    $0x4,%rax
jae    132b <read_raw+0x1bb>
xor    %ecx,%ecx
mov    %rcx,%rdx
or     $0x1,%rdx
test   $0x1,%al
je     1262 <read_raw+0xf2>
movss  0xdcf(%rip),%xmm0
movss  (%rbx,%rcx,8),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r15,%rcx,4)
mulss  0x4(%rbx,%rcx,8),%xmm0
add    %r13,%rcx
movss  %xmm0,(%r15,%rcx,4)
mov    %rdx,%rcx
cmp    %rdx,%rax
je     14a3 <read_raw+0x333>
lea    (%r15,%r13,4),%rdx
add    $0x4,%rdx
movss  0xd95(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,8),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r15,%rcx,4)
movss  0x4(%rbx,%rcx,8),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rdx,%rcx,4)
movss  0x8(%rbx,%rcx,8),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r15,%rcx,4)
movss  0xc(%rbx,%rcx,8),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1280 <read_raw+0x110>
jmp    14a3 <read_raw+0x333>
mov    0x2d04(%rip),%rax
mov    (%rax),%edi
lea    0xd37(%rip),%rsi
jmp    12ef <read_raw+0x17f>
mov    0x2cf2(%rip),%rax
mov    (%rax),%edi
lea    0xd3a(%rip),%rsi
xor    %r15d,%r15d
mov    %rbx,%rdx
xor    %eax,%eax
call   1060 <fprintf@plt>
jmp    14b3 <read_raw+0x343>
mov    0x2cd0(%rip),%rax
mov    (%rax),%edi
lea    0xd2d(%rip),%rsi
xor    %r15d,%r15d
mov    %r12,%rdx
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
jmp    14b3 <read_raw+0x343>
lea    (%r15,%rax,4),%rcx
lea    (%r15,%r13,4),%rbp
lea    (%rax,%r13,1),%rdx
lea    (%r15,%rdx,4),%rdi
lea    (%rbx,%rax,8),%rsi
add    $0xfffffffffffffffc,%rsi
lea    0x4(%rbx),%r10
lea    (%rbx,%rax,8),%rdx
cmp    %rdi,%r15
setb   0x7(%rsp)
cmp    %rcx,%rbp
setb   0x6(%rsp)
cmp    %rsi,%r15
setb   %r9b
cmp    %rcx,%rbx
setb   0x5(%rsp)
cmp    %rdx,%r15
setb   %r11b
cmp    %rcx,%r10
setb   0x4(%rsp)
cmp    %rsi,%rbp
setb   %r14b
cmp    %rdi,%rbx
setb   %sil
cmp    %rdx,%rbp
setb   %r8b
cmp    %rdi,%r10
setb   %bpl
xor    %ecx,%ecx
mov    0x6(%rsp),%dl
test   %dl,0x7(%rsp)
jne    122e <read_raw+0xbe>
and    0x5(%rsp),%r9b
jne    122e <read_raw+0xbe>
and    0x4(%rsp),%r11b
jne    122e <read_raw+0xbe>
and    %sil,%r14b
jne    122e <read_raw+0xbe>
and    %bpl,%r8b
jne    122e <read_raw+0xbe>
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1464 <read_raw+0x2f4>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    0x10(%r15),%rbp
lea    (%r15,%r12,1),%rsi
add    $0x10,%rsi
xor    %edx,%edx
movaps 0xbfc(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rbx,%rdx,8),%xmm1
movups 0x10(%rbx,%rdx,8),%xmm2
movaps %xmm1,%xmm3
shufps $0x88,%xmm2,%xmm3
shufps $0xdd,%xmm2,%xmm1
mulps  %xmm0,%xmm3
movups %xmm3,-0x10(%rbp,%rdx,4)
mulps  %xmm0,%xmm1
movups %xmm1,-0x10(%rsi,%rdx,4)
movups 0x20(%rbx,%rdx,8),%xmm1
movups 0x30(%rbx,%rdx,8),%xmm2
movaps %xmm1,%xmm3
shufps $0x88,%xmm2,%xmm3
shufps $0xdd,%xmm2,%xmm1
mulps  %xmm0,%xmm3
movups %xmm3,0x0(%rbp,%rdx,4)
mulps  %xmm0,%xmm1
movups %xmm1,(%rsi,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1410 <read_raw+0x2a0>
jmp    1466 <read_raw+0x2f6>
xor    %edx,%edx
test   $0x1,%r8b
je     149a <read_raw+0x32a>
movups (%rbx,%rdx,8),%xmm0
movups 0x10(%rbx,%rdx,8),%xmm1
movaps %xmm0,%xmm2
shufps $0x88,%xmm1,%xmm2
shufps $0xdd,%xmm1,%xmm0
movaps 0xb79(%rip),%xmm1
mulps  %xmm1,%xmm2
movups %xmm2,(%r15,%rdx,4)
mulps  %xmm1,%xmm0
add    %r13,%rdx
movups %xmm0,(%r15,%rdx,4)
cmp    %rcx,%rax
jne    122e <read_raw+0xbe>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rax
mov    %r13,(%rax)
mov    %r15,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.stat = type { i32 }
@stderr = global i32 0
@.str = [21 x i8] c"cannot stat file %s\0A\00"
@O_RDONLY = global i32 0
@.str.1 = [21 x i8] c"cannot open file %s\0A\00"
@.str.2 = [16 x i8] c"short read %zu\0A\00"
define float* @read_raw(i8* %0, i64* %1) {
%3 = alloca float*
%4 = alloca i8*
%5 = alloca i64*
%6 = alloca %struct.stat
%7 = alloca float*
%8 = alloca i64
%9 = alloca i64
%10 = alloca i32
%11 = alloca float*
%12 = alloca i32
store i8* %0, i8** %4
store i64* %1, i64** %5
%13 = load i8*, i8** %4
%14 = call i64 @stat(i8* %13, %struct.stat* %6)
%15 = icmp slt i64 %14, 0
br i1 %15, label %16, label %20
16: ; preds = %2
%17 = load i32, i32* @stderr
%18 = load i8*, i8** %4
%19 = call i32 (i32, i8*, ...) @fprintf(i32 %17, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0), i8* %18)
store float* null, float** %3
br label %102
20: ; preds = %2
%21 = load i8*, i8** %4
%22 = load i32, i32* @O_RDONLY
%23 = call i32 @open(i8* %21, i32 %22)
store i32 %23, i32* %10
%24 = load i32, i32* %10
%25 = icmp slt i32 %24, 0
br i1 %25, label %26, label %30
26: ; preds = %20
%27 = load i32, i32* @stderr
%28 = load i8*, i8** %4
%29 = call i32 (i32, i8*, ...) @fprintf(i32 %27, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), i8* %28)
store float* null, float** %3
br label %102
30: ; preds = %20
%31 = getelementptr inbounds %struct.stat, %struct.stat* %6, i32 0, i32 0
%32 = load i32, i32* %31
%33 = sdiv i32 %32, 4
%34 = sext i32 %33 to i64
store i64 %34, i64* %8
%35 = load i64, i64* %8
%36 = mul i64 %35, 4
store i64 %36, i64* %9
%37 = load i64, i64* %9
%38 = trunc i64 %37 to i32
%39 = call i64 @malloc(i32 %38)
%40 = inttoptr i64 %39 to float*
store float* %40, float** %7
%41 = load i32, i32* %10
%42 = load float*, float** %7
%43 = load i64, i64* %9
%44 = call i64 @read(i32 %41, float* %42, i64 %43)
%45 = load i64, i64* %9
%46 = icmp ne i64 %44, %45
br i1 %46, label %47, label %53
47: ; preds = %30
%48 = load i32, i32* @stderr
%49 = load i64, i64* %9
%50 = call i32 (i32, i8*, ...) @fprintf(i32 %48, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0), i64 %49)
%51 = load float*, float** %7
%52 = call i32 @free(float* %51)
store float* null, float** %3
br label %102
53: ; preds = %30
%54 = load i32, i32* %10
%55 = call i32 @close(i32 %54)
%56 = load i64, i64* %8
%57 = mul i64 4, %56
%58 = mul i64 %57, 2
%59 = trunc i64 %58 to i32
%60 = call i64 @malloc(i32 %59)
%61 = inttoptr i64 %60 to float*
store float* %61, float** %11
store i32 0, i32* %12
br label %62
62: ; preds = %93, %53
%63 = load i32, i32* %12
%64 = sext i32 %63 to i64
%65 = load i64, i64* %8
%66 = icmp ult i64 %64, %65
br i1 %66, label %67, label %96
67: ; preds = %62
%68 = load float*, float** %7
%69 = load i32, i32* %12
%70 = mul nsw i32 2, %69
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %68, i64 %71
%73 = load float, float* %72
%74 = fdiv float %73, 3.276800e+04
%75 = load float*, float** %11
%76 = load i32, i32* %12
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds float, float* %75, i64 %77
store float %74, float* %78
%79 = load float*, float** %7
%80 = load i32, i32* %12
%81 = mul nsw i32 2, %80
%82 = add nsw i32 %81, 1
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float, float* %79, i64 %83
%85 = load float, float* %84
%86 = fdiv float %85, 3.276800e+04
%87 = load float*, float** %11
%88 = load i32, i32* %12
%89 = sext i32 %88 to i64
%90 = load i64, i64* %8
%91 = add i64 %89, %90
%92 = getelementptr inbounds float, float* %87, i64 %91
store float %86, float* %92
br label %93
93: ; preds = %67
%94 = load i32, i32* %12
%95 = add nsw i32 %94, 1
store i32 %95, i32* %12
br label %62
96: ; preds = %62
%97 = load float*, float** %7
%98 = call i32 @free(float* %97)
%99 = load i64, i64* %8
%100 = load i64*, i64** %5
store i64 %99, i64* %100
%101 = load float*, float** %11
store float* %101, float** %3
br label %102
102: ; preds = %96, %47, %26, %16
%103 = load float*, float** %3
ret float* %103
}

LLVM IR (-O2):
%struct.stat = type { i32 }
@stderr = global i32 0
@.str = [21 x i8] c"cannot stat file %s\0A\00"
@O_RDONLY = global i32 0
@.str.1 = [21 x i8] c"cannot open file %s\0A\00"
@.str.2 = [16 x i8] c"short read %zu\0A\00"
define float* @read_raw(i8* %0, i64* nocapture writeonly %1) {
%3 = alloca %struct.stat
%4 = bitcast %struct.stat* %3 to i8*
%5 = call i64 @stat(i8* %0, %struct.stat* %3)
%6 = icmp slt i64 %5, 0
br i1 %6, label %7, label %10
7: ; preds = %2
%8 = load i32, i32* @stderr
%9 = call i32 (i32, i8*, ...) @fprintf(i32 %8, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0), i8* %0)
br label %188
10: ; preds = %2
%11 = load i32, i32* @O_RDONLY
%12 = call i32 @open(i8* %0, i32 %11)
%13 = icmp slt i32 %12, 0
br i1 %13, label %14, label %17
14: ; preds = %10
%15 = load i32, i32* @stderr
%16 = call i32 (i32, i8*, ...) @fprintf(i32 %15, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), i8* %0)
br label %188
17: ; preds = %10
%18 = getelementptr inbounds %struct.stat, %struct.stat* %3, i64 0, i32 0
%19 = load i32, i32* %18
%20 = sdiv i32 %19, 4
%21 = sext i32 %20 to i64
%22 = shl nsw i64 %21, 2
%23 = trunc i64 %22 to i32
%24 = call i64 @malloc(i32 %23)
%25 = inttoptr i64 %24 to float*
%26 = inttoptr i64 %24 to i8*
%27 = call i64 @read(i32 %12, float* %25, i64 %22)
%28 = icmp eq i64 %27, %22
br i1 %28, label %33, label %29
29: ; preds = %17
%30 = load i32, i32* @stderr
%31 = call i32 (i32, i8*, ...) @fprintf(i32 %30, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0), i64 %22)
%32 = call i32 @free(float* %25)
br label %188
33: ; preds = %17
%34 = call i32 @close(i32 %12)
%35 = shl i32 %20, 3
%36 = call i64 @malloc(i32 %35)
%37 = inttoptr i64 %36 to float*
%38 = inttoptr i64 %36 to i8*
%39 = add i32 %19, 3
%40 = icmp ult i32 %39, 7
br i1 %40, label %186, label %41
41: ; preds = %33
%42 = call i64 @llvm.umax.i64(i64 %21, i64 1)
%43 = icmp ult i64 %42, 4
br i1 %43, label %138, label %44
44: ; preds = %41
%45 = getelementptr float, float* %37, i64 %42
%46 = bitcast float* %45 to i8*
%47 = getelementptr float, float* %37, i64 %21
%48 = add i64 %42, %21
%49 = getelementptr float, float* %37, i64 %48
%50 = bitcast float* %49 to i8*
%51 = shl i64 %42, 1
%52 = add i64 %51, -1
%53 = getelementptr float, float* %25, i64 %52
%54 = bitcast float* %53 to i8*
%55 = getelementptr float, float* %25, i64 1
%56 = getelementptr float, float* %25, i64 %51
%57 = bitcast float* %56 to i8*
%58 = icmp ult i8* %38, %50
%59 = icmp ult float* %47, %45
%60 = and i1 %58, %59
%61 = icmp ult i8* %38, %54
%62 = icmp ult i8* %26, %46
%63 = and i1 %61, %62
%64 = or i1 %60, %63
%65 = icmp ult i8* %38, %57
%66 = icmp ult float* %55, %45
%67 = and i1 %65, %66
%68 = or i1 %64, %67
%69 = icmp ult float* %47, %53
%70 = icmp ult i8* %26, %50
%71 = and i1 %69, %70
%72 = or i1 %68, %71
%73 = icmp ult float* %47, %56
%74 = icmp ult float* %55, %49
%75 = and i1 %73, %74
%76 = or i1 %72, %75
br i1 %76, label %138, label %77
77: ; preds = %44
%78 = and i64 %42, -4
%79 = add i64 %78, -4
%80 = lshr exact i64 %79, 2
%81 = add nuw nsw i64 %80, 1
%82 = and i64 %81, 1
%83 = icmp eq i64 %79, 0
br i1 %83, label %119, label %84
84: ; preds = %77
%85 = and i64 %81, 9223372036854775806
br label %86
86: ; preds = %86, %84
%87 = phi i64 [ 0, %84 ], [ %116, %86 ]
%88 = phi i64 [ 0, %84 ], [ %117, %86 ]
%89 = shl nuw nsw i64 %87, 1
%90 = getelementptr inbounds float, float* %25, i64 %89
%91 = bitcast float* %90 to <8 x float>*
%92 = load <8 x float>, <8 x float>* %91
%93 = shufflevector <8 x float> %92, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%94 = shufflevector <8 x float> %92, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%95 = fmul <4 x float> %93, <float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000>
%96 = getelementptr inbounds float, float* %37, i64 %87
%97 = bitcast float* %96 to <4 x float>*
store <4 x float> %95, <4 x float>* %97
%98 = fmul <4 x float> %94, <float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000>
%99 = add nsw i64 %87, %21
%100 = getelementptr inbounds float, float* %37, i64 %99
%101 = bitcast float* %100 to <4 x float>*
store <4 x float> %98, <4 x float>* %101
%102 = or i64 %87, 4
%103 = shl nuw nsw i64 %102, 1
%104 = getelementptr inbounds float, float* %25, i64 %103
%105 = bitcast float* %104 to <8 x float>*
%106 = load <8 x float>, <8 x float>* %105
%107 = shufflevector <8 x float> %106, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%108 = shufflevector <8 x float> %106, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%109 = fmul <4 x float> %107, <float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000>
%110 = getelementptr inbounds float, float* %37, i64 %102
%111 = bitcast float* %110 to <4 x float>*
store <4 x float> %109, <4 x float>* %111
%112 = fmul <4 x float> %108, <float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000>
%113 = add nsw i64 %102, %21
%114 = getelementptr inbounds float, float* %37, i64 %113
%115 = bitcast float* %114 to <4 x float>*
store <4 x float> %112, <4 x float>* %115
%116 = add nuw i64 %87, 8
%117 = add i64 %88, 2
%118 = icmp eq i64 %117, %85
br i1 %118, label %119, label %86
119: ; preds = %86, %77
%120 = phi i64 [ 0, %77 ], [ %116, %86 ]
%121 = icmp eq i64 %82, 0
br i1 %121, label %136, label %122
122: ; preds = %119
%123 = shl nuw nsw i64 %120, 1
%124 = getelementptr inbounds float, float* %25, i64 %123
%125 = bitcast float* %124 to <8 x float>*
%126 = load <8 x float>, <8 x float>* %125
%127 = shufflevector <8 x float> %126, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%128 = shufflevector <8 x float> %126, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%129 = fmul <4 x float> %127, <float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000>
%130 = getelementptr inbounds float, float* %37, i64 %120
%131 = bitcast float* %130 to <4 x float>*
store <4 x float> %129, <4 x float>* %131
%132 = fmul <4 x float> %128, <float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000, float 0x3F00000000000000>
%133 = add nsw i64 %120, %21
%134 = getelementptr inbounds float, float* %37, i64 %133
%135 = bitcast float* %134 to <4 x float>*
store <4 x float> %132, <4 x float>* %135
br label %136
136: ; preds = %119, %122
%137 = icmp eq i64 %42, %78
br i1 %137, label %186, label %138
138: ; preds = %44, %41, %136
%139 = phi i64 [ 0, %44 ], [ 0, %41 ], [ %78, %136 ]
%140 = or i64 %139, 1
%141 = and i64 %42, 1
%142 = icmp eq i64 %141, 0
br i1 %142, label %156, label %143
143: ; preds = %138
%144 = shl nuw nsw i64 %139, 1
%145 = getelementptr inbounds float, float* %25, i64 %144
%146 = load float, float* %145
%147 = fmul float %146, 0x3F00000000000000
%148 = getelementptr inbounds float, float* %37, i64 %139
store float %147, float* %148
%149 = or i64 %144, 1
%150 = getelementptr inbounds float, float* %25, i64 %149
%151 = load float, float* %150
%152 = fmul float %151, 0x3F00000000000000
%153 = add nsw i64 %139, %21
%154 = getelementptr inbounds float, float* %37, i64 %153
store float %152, float* %154
%155 = or i64 %139, 1
br label %156
156: ; preds = %143, %138
%157 = phi i64 [ %139, %138 ], [ %155, %143 ]
%158 = icmp eq i64 %42, %140
br i1 %158, label %186, label %159
159: ; preds = %156, %159
%160 = phi i64 [ %184, %159 ], [ %157, %156 ]
%161 = shl nuw nsw i64 %160, 1
%162 = getelementptr inbounds float, float* %25, i64 %161
%163 = load float, float* %162
%164 = fmul float %163, 0x3F00000000000000
%165 = getelementptr inbounds float, float* %37, i64 %160
store float %164, float* %165
%166 = or i64 %161, 1
%167 = getelementptr inbounds float, float* %25, i64 %166
%168 = load float, float* %167
%169 = fmul float %168, 0x3F00000000000000
%170 = add nsw i64 %160, %21
%171 = getelementptr inbounds float, float* %37, i64 %170
store float %169, float* %171
%172 = add nuw nsw i64 %160, 1
%173 = shl nuw nsw i64 %172, 1
%174 = getelementptr inbounds float, float* %25, i64 %173
%175 = load float, float* %174
%176 = fmul float %175, 0x3F00000000000000
%177 = getelementptr inbounds float, float* %37, i64 %172
store float %176, float* %177
%178 = or i64 %173, 1
%179 = getelementptr inbounds float, float* %25, i64 %178
%180 = load float, float* %179
%181 = fmul float %180, 0x3F00000000000000
%182 = add nsw i64 %172, %21
%183 = getelementptr inbounds float, float* %37, i64 %182
store float %181, float* %183
%184 = add nuw nsw i64 %160, 2
%185 = icmp eq i64 %184, %42
br i1 %185, label %186, label %159
186: ; preds = %156, %159, %136, %33
%187 = call i32 @free(float* %25)
store i64 %21, i64* %1
br label %188
188: ; preds = %186, %29, %14, %7
%189 = phi float* [ null, %7 ], [ null, %14 ], [ null, %29 ], [ %37, %186 ]
ret float* %189
}