#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*/ exit(int);
float exp(int);
int floor(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(float *, float *, int);
int /*<<< orphan*/ stderr;
float *gaussian_filter(const float sigma, int *filter_order) {
  if (sigma == 0.0f) {
    fprintf(stderr, "gaussian_filter() error: sigma is zeros\n");
    exit(1);
  }
  if (!filter_order) {
    fprintf(stderr, "gaussian_filter() error: filter_order is null\n");
    exit(1);
  }
  *filter_order = floor(3 * sigma);
  if (*filter_order == 0)
    *filter_order = 1;
  float *data = (float *)malloc(sizeof(float) * (2 * (*filter_order) + 1));
  if (data == NULL) {
    fprintf(stderr, "gaussian_filter() error: not enough memory\n");
    exit(1);
  }
  const float alpha = 1.0f / (2.0f * sigma * sigma);
  float sum = 0.0f;
  int i;
  for (i = -(*filter_order); i <= *filter_order; i++) {
    data[i + (*filter_order)] = exp(-i * i * alpha);
    sum += data[i + (*filter_order)];
  }
  for (i = -(*filter_order); i <= *filter_order; i++) {
    data[i + (*filter_order)] /= sum;
  }
  float *data2 = (float *)malloc(sizeof(float) * (*filter_order + 1));
  if (data2 == NULL) {
    fprintf(stderr, "gaussian_filter() error: not enough memory\n");
    exit(1);
  }
  memcpy(data2, &data[*filter_order],
         sizeof(float) * (*filter_order) + sizeof(float));
  free(data);
  return data2;
}


x86 assembly (clang, -O0):
<gaussian_filter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movss  %xmm0,-0x4(%rbp)
mov    %rdi,-0x10(%rbp)
movss  -0x4(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11b7 <gaussian_filter+0x47>
jp     11b7 <gaussian_filter+0x47>
mov    0x2e41(%rip),%rax
mov    (%rax),%edi
lea    0xe64(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>
cmpq   $0x0,-0x10(%rbp)
jne    11e1 <gaussian_filter+0x71>
mov    0x2e17(%rip),%rax
mov    (%rax),%edi
lea    0xe63(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>
movss  0xe17(%rip),%xmm0
mulss  -0x4(%rbp),%xmm0
cvttss2si %xmm0,%edi
call   1090 <floor@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1216 <gaussian_filter+0xa6>
mov    -0x10(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    125d <gaussian_filter+0xed>
mov    0x2d9b(%rip),%rax
mov    (%rax),%edi
lea    0xe16(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>
movss  0xda3(%rip),%xmm1
mulss  -0x4(%rbp),%xmm1
mulss  -0x4(%rbp),%xmm1
movss  0xd8d(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rcx
xor    %eax,%eax
sub    (%rcx),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jg     12ff <gaussian_filter+0x18f>
xor    %eax,%eax
sub    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
cvtsi2ss %eax,%xmm0
mulss  -0x1c(%rbp),%xmm0
cvttss2si %xmm0,%edi
call   1070 <exp@plt>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%rdx
add    (%rdx),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%rdx
add    (%rdx),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1293 <gaussian_filter+0x123>
mov    -0x10(%rbp),%rcx
xor    %eax,%eax
sub    (%rcx),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jg     134a <gaussian_filter+0x1da>
movss  -0x20(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%rdx
add    (%rdx),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    130a <gaussian_filter+0x19a>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    138e <gaussian_filter+0x21e>
mov    0x2c6a(%rip),%rax
mov    (%rax),%edi
lea    0xce5(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>
mov    -0x30(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x10(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x10(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
add    $0x4,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gaussian_filter>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x28,%rsp
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1189 <gaussian_filter+0x19>
jnp    1369 <gaussian_filter+0x1f9>
mov    %rdi,%r14
test   %rdi,%rdi
je     137b <gaussian_filter+0x20b>
movss  0xe63(%rip),%xmm1
movss  %xmm0,0x10(%rsp)
mulss  %xmm0,%xmm1
cvttss2si %xmm1,%edi
call   1090 <floor@plt>
test   %eax,%eax
mov    $0x1,%ecx
cmovne %eax,%ecx
mov    %ecx,(%r14)
lea    0x4(,%rcx,8),%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     1357 <gaussian_filter+0x1e7>
mov    %rax,%r12
mov    (%r14),%eax
test   %eax,%eax
js     1316 <gaussian_filter+0x1a6>
movss  0x10(%rsp),%xmm1
movaps %xmm1,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm1,%xmm0
movss  0xe0b(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xc(%rsp)
neg    %eax
movslq %eax,%rbx
xorps  %xmm3,%xmm3
nopl   0x0(%rax,%rax,1)
movaps %xmm3,0x10(%rsp)
mov    %ebx,%eax
imul   %ebx,%eax
neg    %eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  0xc(%rsp),%xmm0
cvttss2si %xmm0,%edi
call   1070 <exp@plt>
movaps 0x10(%rsp),%xmm3
movslq (%r14),%rax
mov    %rax,%rcx
add    %rbx,%rcx
movss  %xmm0,(%r12,%rcx,4)
addss  %xmm0,%xmm3
add    $0x1,%rbx
lea    -0x1(%rbx),%ecx
cmp    %eax,%ecx
jl     1210 <gaussian_filter+0xa0>
mov    %eax,%eax
test   %eax,%eax
js     1316 <gaussian_filter+0x1a6>
mov    %eax,%ecx
neg    %ecx
movslq %ecx,%r8
lea    (%rax,%rax,1),%ecx
cmp    $0x4,%ecx
jae    1276 <gaussian_filter+0x106>
mov    %r8,%rcx
jmp    12f1 <gaussian_filter+0x181>
and    $0xfffffffc,%ecx
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
lea    -0x4(%rcx),%rdx
mov    %rdx,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rdx,%rdx
je     12d4 <gaussian_filter+0x164>
mov    %rbx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r8,%rax,1),%rdx
lea    (%r12,%rdx,4),%rdx
add    $0x10,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movups -0x10(%rdx,%rdi,4),%xmm1
movups (%rdx,%rdi,4),%xmm2
divps  %xmm0,%xmm1
movups %xmm1,-0x10(%rdx,%rdi,4)
divps  %xmm0,%xmm2
movups %xmm2,(%rdx,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    12b0 <gaussian_filter+0x140>
jmp    12d6 <gaussian_filter+0x166>
xor    %edi,%edi
add    %r8,%rcx
test   $0x1,%bl
je     12f1 <gaussian_filter+0x181>
add    %r8,%rdi
add    %rax,%rdi
movups (%r12,%rdi,4),%xmm1
divps  %xmm0,%xmm1
movups %xmm1,(%r12,%rdi,4)
lea    (%r12,%rax,4),%rdx
lea    0x1(%rax),%rsi
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm0
divss  %xmm3,%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%esi
jne    1300 <gaussian_filter+0x190>
lea    0x4(,%rax,4),%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     1357 <gaussian_filter+0x1e7>
mov    %rax,%r15
movslq (%r14),%rax
lea    (%r12,%rax,4),%rsi
lea    0x4(,%rax,4),%edx
mov    %r15,%rdi
call   1050 <memcpy@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    0x2c82(%rip),%rax
mov    (%rax),%edi
lea    0xcf9(%rip),%rsi
jmp    138b <gaussian_filter+0x21b>
mov    0x2c70(%rip),%rax
mov    (%rax),%edi
lea    0xc8f(%rip),%rsi
jmp    138b <gaussian_filter+0x21b>
mov    0x2c5e(%rip),%rax
mov    (%rax),%edi
lea    0xca6(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [41 x i8] c"gaussian_filter() error: sigma is zeros\0A\00"
@.str.1 = [47 x i8] c"gaussian_filter() error: filter_order is null\0A\00"
@.str.2 = [44 x i8] c"gaussian_filter() error: not enough memory\0A\00"
define float* @gaussian_filter(float %0, i32* %1) {
%3 = alloca float
%4 = alloca i32*
%5 = alloca float*
%6 = alloca float
%7 = alloca float
%8 = alloca i32
%9 = alloca float*
store float %0, float* %3
store i32* %1, i32** %4
%10 = load float, float* %3
%11 = fcmp oeq float %10, 0.000000e+00
br i1 %11, label %12, label %16
12: ; preds = %2
%13 = load i32, i32* @stderr
%14 = call i32 @fprintf(i32 %13, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0))
%15 = call i32 @exit(i32 1)
unreachable
16: ; preds = %2
%17 = load i32*, i32** %4
%18 = icmp ne i32* %17, null
br i1 %18, label %23, label %19
19: ; preds = %16
%20 = load i32, i32* @stderr
%21 = call i32 @fprintf(i32 %20, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0))
%22 = call i32 @exit(i32 1)
unreachable
23: ; preds = %16
%24 = load float, float* %3
%25 = fmul float 3.000000e+00, %24
%26 = fptosi float %25 to i32
%27 = call i32 @floor(i32 %26)
%28 = load i32*, i32** %4
store i32 %27, i32* %28
%29 = load i32*, i32** %4
%30 = load i32, i32* %29
%31 = icmp eq i32 %30, 0
br i1 %31, label %32, label %34
32: ; preds = %23
%33 = load i32*, i32** %4
store i32 1, i32* %33
br label %34
34: ; preds = %32, %23
%35 = load i32*, i32** %4
%36 = load i32, i32* %35
%37 = mul nsw i32 2, %36
%38 = add nsw i32 %37, 1
%39 = sext i32 %38 to i64
%40 = mul i64 4, %39
%41 = trunc i64 %40 to i32
%42 = call i64 @malloc(i32 %41)
%43 = inttoptr i64 %42 to float*
store float* %43, float** %5
%44 = load float*, float** %5
%45 = icmp eq float* %44, null
br i1 %45, label %46, label %50
46: ; preds = %34
%47 = load i32, i32* @stderr
%48 = call i32 @fprintf(i32 %47, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.2, i64 0, i64 0))
%49 = call i32 @exit(i32 1)
unreachable
50: ; preds = %34
%51 = load float, float* %3
%52 = fmul float 2.000000e+00, %51
%53 = load float, float* %3
%54 = fmul float %52, %53
%55 = fdiv float 1.000000e+00, %54
store float %55, float* %6
store float 0.000000e+00, float* %7
%56 = load i32*, i32** %4
%57 = load i32, i32* %56
%58 = sub nsw i32 0, %57
store i32 %58, i32* %8
br label %59
59: ; preds = %91, %50
%60 = load i32, i32* %8
%61 = load i32*, i32** %4
%62 = load i32, i32* %61
%63 = icmp sle i32 %60, %62
br i1 %63, label %64, label %94
64: ; preds = %59
%65 = load i32, i32* %8
%66 = sub nsw i32 0, %65
%67 = load i32, i32* %8
%68 = mul nsw i32 %66, %67
%69 = sitofp i32 %68 to float
%70 = load float, float* %6
%71 = fmul float %69, %70
%72 = fptosi float %71 to i32
%73 = call float @exp(i32 %72)
%74 = load float*, float** %5
%75 = load i32, i32* %8
%76 = load i32*, i32** %4
%77 = load i32, i32* %76
%78 = add nsw i32 %75, %77
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float, float* %74, i64 %79
store float %73, float* %80
%81 = load float*, float** %5
%82 = load i32, i32* %8
%83 = load i32*, i32** %4
%84 = load i32, i32* %83
%85 = add nsw i32 %82, %84
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds float, float* %81, i64 %86
%88 = load float, float* %87
%89 = load float, float* %7
%90 = fadd float %89, %88
store float %90, float* %7
br label %91
91: ; preds = %64
%92 = load i32, i32* %8
%93 = add nsw i32 %92, 1
store i32 %93, i32* %8
br label %59
94: ; preds = %59
%95 = load i32*, i32** %4
%96 = load i32, i32* %95
%97 = sub nsw i32 0, %96
store i32 %97, i32* %8
br label %98
98: ; preds = %114, %94
%99 = load i32, i32* %8
%100 = load i32*, i32** %4
%101 = load i32, i32* %100
%102 = icmp sle i32 %99, %101
br i1 %102, label %103, label %117
103: ; preds = %98
%104 = load float, float* %7
%105 = load float*, float** %5
%106 = load i32, i32* %8
%107 = load i32*, i32** %4
%108 = load i32, i32* %107
%109 = add nsw i32 %106, %108
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds float, float* %105, i64 %110
%112 = load float, float* %111
%113 = fdiv float %112, %104
store float %113, float* %111
br label %114
114: ; preds = %103
%115 = load i32, i32* %8
%116 = add nsw i32 %115, 1
store i32 %116, i32* %8
br label %98
117: ; preds = %98
%118 = load i32*, i32** %4
%119 = load i32, i32* %118
%120 = add nsw i32 %119, 1
%121 = sext i32 %120 to i64
%122 = mul i64 4, %121
%123 = trunc i64 %122 to i32
%124 = call i64 @malloc(i32 %123)
%125 = inttoptr i64 %124 to float*
store float* %125, float** %9
%126 = load float*, float** %9
%127 = icmp eq float* %126, null
br i1 %127, label %128, label %132
128: ; preds = %117
%129 = load i32, i32* @stderr
%130 = call i32 @fprintf(i32 %129, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.2, i64 0, i64 0))
%131 = call i32 @exit(i32 1)
unreachable
132: ; preds = %117
%133 = load float*, float** %9
%134 = load float*, float** %5
%135 = load i32*, i32** %4
%136 = load i32, i32* %135
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %134, i64 %137
%139 = load i32*, i32** %4
%140 = load i32, i32* %139
%141 = sext i32 %140 to i64
%142 = mul i64 4, %141
%143 = add i64 %142, 4
%144 = trunc i64 %143 to i32
%145 = call i32 @memcpy(float* %133, float* %138, i32 %144)
%146 = load float*, float** %5
%147 = call i32 @free(float* %146)
%148 = load float*, float** %9
ret float* %148
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [41 x i8] c"gaussian_filter() error: sigma is zeros\0A\00"
@.str.1 = [47 x i8] c"gaussian_filter() error: filter_order is null\0A\00"
@.str.2 = [44 x i8] c"gaussian_filter() error: not enough memory\0A\00"
define float* @gaussian_filter(float %0, i32* %1) {
%3 = fcmp oeq float %0, 0.000000e+00
br i1 %3, label %4, label %8
4: ; preds = %2
%5 = load i32, i32* @stderr
%6 = tail call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0))
%7 = tail call i32 @exit(i32 1)
unreachable
8: ; preds = %2
%9 = icmp eq i32* %1, null
br i1 %9, label %10, label %14
10: ; preds = %8
%11 = load i32, i32* @stderr
%12 = tail call i32 @fprintf(i32 %11, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0))
%13 = tail call i32 @exit(i32 1)
unreachable
14: ; preds = %8
%15 = fmul float %0, 3.000000e+00
%16 = fptosi float %15 to i32
%17 = tail call i32 @floor(i32 %16)
%18 = icmp eq i32 %17, 0
%19 = select i1 %18, i32 1, i32 %17
store i32 %19, i32* %1
%20 = shl i32 %19, 3
%21 = or i32 %20, 4
%22 = tail call i64 @malloc(i32 %21)
%23 = inttoptr i64 %22 to float*
%24 = icmp eq i64 %22, 0
br i1 %24, label %25, label %29
25: ; preds = %14
%26 = load i32, i32* @stderr
%27 = tail call i32 @fprintf(i32 %26, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.2, i64 0, i64 0))
%28 = tail call i32 @exit(i32 1)
unreachable
29: ; preds = %14
%30 = fmul float %0, 2.000000e+00
%31 = fmul float %30, %0
%32 = fdiv float 1.000000e+00, %31
%33 = load i32, i32* %1
%34 = icmp slt i32 %33, 0
br i1 %34, label %118, label %35
35: ; preds = %29
%36 = sub i32 0, %33
br label %37
37: ; preds = %35, %37
%38 = phi float [ %50, %37 ], [ 0.000000e+00, %35 ]
%39 = phi i32 [ %51, %37 ], [ %36, %35 ]
%40 = mul i32 %39, %39
%41 = sub i32 0, %40
%42 = sitofp i32 %41 to float
%43 = fmul float %32, %42
%44 = fptosi float %43 to i32
%45 = tail call float @exp(i32 %44)
%46 = load i32, i32* %1
%47 = add nsw i32 %46, %39
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds float, float* %23, i64 %48
store float %45, float* %49
%50 = fadd float %38, %45
%51 = add nsw i32 %39, 1
%52 = icmp slt i32 %39, %46
br i1 %52, label %37, label %53
53: ; preds = %37
%54 = icmp slt i32 %46, 0
br i1 %54, label %118, label %55
55: ; preds = %53
%56 = sub i32 0, %46
%57 = sext i32 %56 to i64
%58 = zext i32 %46 to i64
%59 = add nuw i32 %46, 1
%60 = shl i32 %46, 1
%61 = icmp ult i32 %60, 4
br i1 %61, label %107, label %62
62: ; preds = %55
%63 = and i32 %60, -4
%64 = zext i32 %63 to i64
%65 = add nsw i64 %64, %57
%66 = insertelement <4 x float> poison, float %50, i64 0
%67 = shufflevector <4 x float> %66, <4 x float> poison, <4 x i32> zeroinitializer
%68 = add nsw i64 %64, -4
%69 = lshr exact i64 %68, 2
%70 = add nuw nsw i64 %69, 1
%71 = and i64 %70, 1
%72 = icmp eq i64 %68, 0
br i1 %72, label %96, label %73
73: ; preds = %62
%74 = and i64 %70, 9223372036854775806
br label %75
75: ; preds = %75, %73
%76 = phi i64 [ 0, %73 ], [ %93, %75 ]
%77 = phi i64 [ 0, %73 ], [ %94, %75 ]
%78 = add i64 %76, %57
%79 = add nsw i64 %78, %58
%80 = getelementptr inbounds float, float* %23, i64 %79
%81 = bitcast float* %80 to <4 x float>*
%82 = load <4 x float>, <4 x float>* %81
%83 = fdiv <4 x float> %82, %67
%84 = bitcast float* %80 to <4 x float>*
store <4 x float> %83, <4 x float>* %84
%85 = or i64 %76, 4
%86 = add i64 %85, %57
%87 = add nsw i64 %86, %58
%88 = getelementptr inbounds float, float* %23, i64 %87
%89 = bitcast float* %88 to <4 x float>*
%90 = load <4 x float>, <4 x float>* %89
%91 = fdiv <4 x float> %90, %67
%92 = bitcast float* %88 to <4 x float>*
store <4 x float> %91, <4 x float>* %92
%93 = add nuw i64 %76, 8
%94 = add i64 %77, 2
%95 = icmp eq i64 %94, %74
br i1 %95, label %96, label %75
96: ; preds = %75, %62
%97 = phi i64 [ 0, %62 ], [ %93, %75 ]
%98 = icmp eq i64 %71, 0
br i1 %98, label %107, label %99
99: ; preds = %96
%100 = add i64 %97, %57
%101 = add nsw i64 %100, %58
%102 = getelementptr inbounds float, float* %23, i64 %101
%103 = bitcast float* %102 to <4 x float>*
%104 = load <4 x float>, <4 x float>* %103
%105 = fdiv <4 x float> %104, %67
%106 = bitcast float* %102 to <4 x float>*
store <4 x float> %105, <4 x float>* %106
br label %107
107: ; preds = %99, %96, %55
%108 = phi i64 [ %57, %55 ], [ %65, %96 ], [ %65, %99 ]
br label %109
109: ; preds = %107, %109
%110 = phi i64 [ %115, %109 ], [ %108, %107 ]
%111 = add nsw i64 %110, %58
%112 = getelementptr inbounds float, float* %23, i64 %111
%113 = load float, float* %112
%114 = fdiv float %113, %50
store float %114, float* %112
%115 = add nsw i64 %110, 1
%116 = trunc i64 %115 to i32
%117 = icmp eq i32 %59, %116
br i1 %117, label %118, label %109
118: ; preds = %109, %29, %53
%119 = phi i32 [ %46, %53 ], [ %33, %29 ], [ %46, %109 ]
%120 = shl i32 %119, 2
%121 = add i32 %120, 4
%122 = tail call i64 @malloc(i32 %121)
%123 = inttoptr i64 %122 to float*
%124 = icmp eq i64 %122, 0
br i1 %124, label %125, label %129
125: ; preds = %118
%126 = load i32, i32* @stderr
%127 = tail call i32 @fprintf(i32 %126, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.2, i64 0, i64 0))
%128 = tail call i32 @exit(i32 1)
unreachable
129: ; preds = %118
%130 = load i32, i32* %1
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds float, float* %23, i64 %131
%133 = shl i32 %130, 2
%134 = add i32 %133, 4
%135 = tail call i32 @memcpy(float* %123, float* %132, i32 %134)
%136 = tail call i32 @free(float* %23)
ret float* %123
}