#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 */
typedef float *prev_beta;

/* Variables and functions */
scalar_t__ fabs(float);
void spectrum_adaptive_time_smoothing(int fft_size_2, float *spectrum_prev,
                                      float *spectrum, float *noise_thresholds,
                                      float *prev_beta, float coeff) {
  int k;
  float discrepancy, numerator = 0.f, denominator = 0.f;
  float beta_ts;
  float beta_smooth;
  float gamma_ts;
  for (k = 0; k <= fft_size_2; k++) {
    numerator += fabs(spectrum[k] - noise_thresholds[k]);
    denominator += noise_thresholds[k];
  }
  discrepancy = numerator / denominator;
  beta_ts = (((discrepancy) < (1.f)) ? (discrepancy) : (1.f));
  if (*prev_beta < beta_ts) {
    gamma_ts = 0.f;
  } else {
    gamma_ts = coeff;
  }
  beta_smooth = gamma_ts * *(prev_beta) + (1.f - gamma_ts) * beta_ts;
  *prev_beta = beta_smooth;
  for (k = 0; k <= fft_size_2; k++) {
    spectrum[k] =
        (1.f - beta_smooth) * spectrum_prev[k] + beta_smooth * spectrum[k];
  }
}


x86 assembly (clang, -O0):
<spectrum_adaptive_time_smoothing>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     11a6 <spectrum_adaptive_time_smoothing+0x96>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
cvtsi2ss %rax,%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1147 <spectrum_adaptive_time_smoothing+0x37>
movss  -0x38(%rbp),%xmm0
divss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  0xe43(%rip),%xmm0
ucomiss -0x34(%rbp),%xmm0
jbe    11d6 <spectrum_adaptive_time_smoothing+0xc6>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    11e8 <spectrum_adaptive_time_smoothing+0xd8>
movss  0xe22(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    11e8 <spectrum_adaptive_time_smoothing+0xd8>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x40(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1215 <spectrum_adaptive_time_smoothing+0x105>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    121f <spectrum_adaptive_time_smoothing+0x10f>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movss  0xdcc(%rip),%xmm1
subss  -0x48(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     12ba <spectrum_adaptive_time_smoothing+0x1aa>
movss  0xd8d(%rip),%xmm0
subss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x44(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    125f <spectrum_adaptive_time_smoothing+0x14f>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<spectrum_adaptive_time_smoothing>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rdx,%r13
mov    %rsi,%r14
mov    %edi,%r15d
test   %edi,%edi
js     1228 <spectrum_adaptive_time_smoothing+0x118>
mov    %rcx,%rbx
lea    0x1(%r15),%r12d
test   %r15d,%r15d
mov    %r8,0x18(%rsp)
movaps %xmm0,0x20(%rsp)
mov    %r12,0x10(%rsp)
je     1331 <spectrum_adaptive_time_smoothing+0x221>
and    $0xfffffffe,%r12d
xorps  %xmm4,%xmm4
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movss  %xmm4,0x8(%rsp)
movss  %xmm0,0xc(%rsp)
movss  0x0(%r13,%rbp,4),%xmm0
subss  (%rbx,%rbp,4),%xmm0
call   1030 <fabs@plt>
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
movss  0xc(%rsp),%xmm0
addss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,0xc(%rsp)
addss  0x8(%rsp),%xmm1
movss  %xmm1,0x8(%rsp)
movss  0x4(%r13,%rbp,4),%xmm0
subss  0x4(%rbx,%rbp,4),%xmm0
call   1030 <fabs@plt>
movss  0xc(%rsp),%xmm0
xorps  %xmm4,%xmm4
cvtsi2ss %rax,%xmm4
addss  0x8(%rsp),%xmm4
addss  0x4(%rbx,%rbp,4),%xmm0
add    $0x2,%rbp
cmp    %rbp,%r12
jne    1160 <spectrum_adaptive_time_smoothing+0x50>
testb  $0x1,0x10(%rsp)
je     1218 <spectrum_adaptive_time_smoothing+0x108>
movss  %xmm0,0xc(%rsp)
movss  0x0(%r13,%rbp,4),%xmm0
subss  (%rbx,%rbp,4),%xmm0
movss  %xmm4,0x8(%rsp)
call   1030 <fabs@plt>
movss  0x8(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  %xmm0,%xmm4
movss  0xc(%rsp),%xmm0
addss  (%rbx,%rbp,4),%xmm0
divss  %xmm0,%xmm4
mov    0x18(%rsp),%r8
movaps 0x20(%rsp),%xmm0
jmp    1230 <spectrum_adaptive_time_smoothing+0x120>
movss  0xdd0(%rip),%xmm4
movss  0xdcb(%rip),%xmm8
minss  %xmm8,%xmm4
movss  (%r8),%xmm2
movaps %xmm2,%xmm1
cmpltss %xmm4,%xmm1
andnps %xmm0,%xmm1
movaps %xmm8,%xmm3
subss  %xmm1,%xmm3
mulss  %xmm4,%xmm3
mulss  %xmm2,%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,(%r8)
test   %r15d,%r15d
js     143f <spectrum_adaptive_time_smoothing+0x32f>
subss  %xmm1,%xmm8
lea    0x1(%r15),%eax
cmp    $0x7,%r15d
jb     12a0 <spectrum_adaptive_time_smoothing+0x190>
lea    (%r14,%rax,4),%rcx
cmp    %r13,%rcx
jbe    1349 <spectrum_adaptive_time_smoothing+0x239>
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
cmp    %r14,%rcx
jbe    1349 <spectrum_adaptive_time_smoothing+0x239>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     12d1 <spectrum_adaptive_time_smoothing+0x1c1>
movss  0x0(%r13,%rcx,4),%xmm0
mulss  %xmm1,%xmm0
movss  (%r14,%rcx,4),%xmm2
mulss  %xmm8,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x0(%r13,%rcx,4)
or     $0x1,%rcx
add    %rax,%rdx
je     143f <spectrum_adaptive_time_smoothing+0x32f>
nopw   0x0(%rax,%rax,1)
movss  0x0(%r13,%rcx,4),%xmm0
mulss  %xmm1,%xmm0
movss  (%r14,%rcx,4),%xmm2
mulss  %xmm8,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x0(%r13,%rcx,4)
movss  0x4(%r13,%rcx,4),%xmm0
mulss  %xmm1,%xmm0
movss  0x4(%r14,%rcx,4),%xmm2
mulss  %xmm8,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x4(%r13,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    12e0 <spectrum_adaptive_time_smoothing+0x1d0>
jmp    143f <spectrum_adaptive_time_smoothing+0x32f>
xorps  %xmm4,%xmm4
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
testb  $0x1,0x10(%rsp)
jne    11de <spectrum_adaptive_time_smoothing+0xce>
jmp    1218 <spectrum_adaptive_time_smoothing+0x108>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
movaps %xmm8,%xmm9
shufps $0x0,%xmm8,%xmm9
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     144e <spectrum_adaptive_time_smoothing+0x33e>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nop
movups (%r14,%rdx,4),%xmm4
movups 0x10(%r14,%rdx,4),%xmm5
movups 0x0(%r13,%rdx,4),%xmm6
movups 0x10(%r13,%rdx,4),%xmm7
movups 0x20(%r13,%rdx,4),%xmm0
movups 0x30(%r13,%rdx,4),%xmm2
mulps  %xmm3,%xmm6
mulps  %xmm3,%xmm7
mulps  %xmm9,%xmm4
addps  %xmm6,%xmm4
mulps  %xmm9,%xmm5
addps  %xmm7,%xmm5
movups %xmm4,0x0(%r13,%rdx,4)
movups %xmm5,0x10(%r13,%rdx,4)
movups 0x20(%r14,%rdx,4),%xmm4
movups 0x30(%r14,%rdx,4),%xmm5
mulps  %xmm3,%xmm0
mulps  %xmm3,%xmm2
mulps  %xmm9,%xmm4
addps  %xmm0,%xmm4
mulps  %xmm9,%xmm5
addps  %xmm2,%xmm5
movups %xmm4,0x20(%r13,%rdx,4)
movups %xmm5,0x30(%r13,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1380 <spectrum_adaptive_time_smoothing+0x270>
test   $0x1,%sil
je     1436 <spectrum_adaptive_time_smoothing+0x326>
movups (%r14,%rdx,4),%xmm0
movups 0x10(%r14,%rdx,4),%xmm2
movups 0x0(%r13,%rdx,4),%xmm4
movups 0x10(%r13,%rdx,4),%xmm5
mulps  %xmm3,%xmm4
mulps  %xmm3,%xmm5
mulps  %xmm9,%xmm0
addps  %xmm4,%xmm0
mulps  %xmm9,%xmm2
addps  %xmm5,%xmm2
movups %xmm0,0x0(%r13,%rdx,4)
movups %xmm2,0x10(%r13,%rdx,4)
cmp    %rax,%rcx
jne    12a2 <spectrum_adaptive_time_smoothing+0x192>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    13ff <spectrum_adaptive_time_smoothing+0x2ef>
jmp    1436 <spectrum_adaptive_time_smoothing+0x326>

LLVM IR (-O0):
define void @spectrum_adaptive_time_smoothing(i32 %0, float* %1, float* %2, float* %3, float* %4, float %5) {
%7 = alloca i32
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca float*
%12 = alloca float
%13 = alloca i32
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
store i32 %0, i32* %7
store float* %1, float** %8
store float* %2, float** %9
store float* %3, float** %10
store float* %4, float** %11
store float %5, float* %12
store float 0.000000e+00, float* %15
store float 0.000000e+00, float* %16
store i32 0, i32* %13
br label %20
20: ; preds = %47, %6
%21 = load i32, i32* %13
%22 = load i32, i32* %7
%23 = icmp sle i32 %21, %22
br i1 %23, label %24, label %50
24: ; preds = %20
%25 = load float*, float** %9
%26 = load i32, i32* %13
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds float, float* %25, i64 %27
%29 = load float, float* %28
%30 = load float*, float** %10
%31 = load i32, i32* %13
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds float, float* %30, i64 %32
%34 = load float, float* %33
%35 = fsub float %29, %34
%36 = call i64 @fabs(float %35)
%37 = sitofp i64 %36 to float
%38 = load float, float* %15
%39 = fadd float %38, %37
store float %39, float* %15
%40 = load float*, float** %10
%41 = load i32, i32* %13
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %40, i64 %42
%44 = load float, float* %43
%45 = load float, float* %16
%46 = fadd float %45, %44
store float %46, float* %16
br label %47
47: ; preds = %24
%48 = load i32, i32* %13
%49 = add nsw i32 %48, 1
store i32 %49, i32* %13
br label %20
50: ; preds = %20
%51 = load float, float* %15
%52 = load float, float* %16
%53 = fdiv float %51, %52
store float %53, float* %14
%54 = load float, float* %14
%55 = fcmp olt float %54, 1.000000e+00
br i1 %55, label %56, label %58
56: ; preds = %50
%57 = load float, float* %14
br label %59
58: ; preds = %50
br label %59
59: ; preds = %58, %56
%60 = phi float [ %57, %56 ], [ 1.000000e+00, %58 ]
store float %60, float* %17
%61 = load float*, float** %11
%62 = load float, float* %61
%63 = load float, float* %17
%64 = fcmp olt float %62, %63
br i1 %64, label %65, label %66
65: ; preds = %59
store float 0.000000e+00, float* %19
br label %68
66: ; preds = %59
%67 = load float, float* %12
store float %67, float* %19
br label %68
68: ; preds = %66, %65
%69 = load float, float* %19
%70 = load float*, float** %11
%71 = load float, float* %70
%72 = load float, float* %19
%73 = fsub float 1.000000e+00, %72
%74 = load float, float* %17
%75 = fmul float %73, %74
%76 = call float @llvm.fmuladd.f32(float %69, float %71, float %75)
store float %76, float* %18
%77 = load float, float* %18
%78 = load float*, float** %11
store float %77, float* %78
store i32 0, i32* %13
br label %79
79: ; preds = %103, %68
%80 = load i32, i32* %13
%81 = load i32, i32* %7
%82 = icmp sle i32 %80, %81
br i1 %82, label %83, label %106
83: ; preds = %79
%84 = load float, float* %18
%85 = fsub float 1.000000e+00, %84
%86 = load float*, float** %8
%87 = load i32, i32* %13
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %86, i64 %88
%90 = load float, float* %89
%91 = load float, float* %18
%92 = load float*, float** %9
%93 = load i32, i32* %13
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float, float* %92, i64 %94
%96 = load float, float* %95
%97 = fmul float %91, %96
%98 = call float @llvm.fmuladd.f32(float %85, float %90, float %97)
%99 = load float*, float** %9
%100 = load i32, i32* %13
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds float, float* %99, i64 %101
store float %98, float* %102
br label %103
103: ; preds = %83
%104 = load i32, i32* %13
%105 = add nsw i32 %104, 1
store i32 %105, i32* %13
br label %79
106: ; preds = %79
ret void
}

LLVM IR (-O2):
define void @spectrum_adaptive_time_smoothing(i32 %0, float* nocapture %1, float* nocapture %2, float* nocapture %3, float* nocapture %4, float %5) {
%7 = icmp slt i32 %0, 0
br i1 %7, label %66, label %8
8: ; preds = %6
%9 = add nuw i32 %0, 1
%10 = zext i32 %9 to i64
%11 = and i64 %10, 1
%12 = icmp eq i32 %0, 0
br i1 %12, label %44, label %13
13: ; preds = %8
%14 = and i64 %10, 4294967294
br label %15
15: ; preds = %15, %13
%16 = phi i64 [ 0, %13 ], [ %41, %15 ]
%17 = phi float [ 0.000000e+00, %13 ], [ %38, %15 ]
%18 = phi float [ 0.000000e+00, %13 ], [ %40, %15 ]
%19 = phi i64 [ 0, %13 ], [ %42, %15 ]
%20 = getelementptr inbounds float, float* %2, i64 %16
%21 = load float, float* %20
%22 = getelementptr inbounds float, float* %3, i64 %16
%23 = load float, float* %22
%24 = fsub float %21, %23
%25 = tail call i64 @fabs(float %24)
%26 = sitofp i64 %25 to float
%27 = fadd float %17, %26
%28 = load float, float* %22
%29 = fadd float %18, %28
%30 = or i64 %16, 1
%31 = getelementptr inbounds float, float* %2, i64 %30
%32 = load float, float* %31
%33 = getelementptr inbounds float, float* %3, i64 %30
%34 = load float, float* %33
%35 = fsub float %32, %34
%36 = tail call i64 @fabs(float %35)
%37 = sitofp i64 %36 to float
%38 = fadd float %27, %37
%39 = load float, float* %33
%40 = fadd float %29, %39
%41 = add nuw nsw i64 %16, 2
%42 = add i64 %19, 2
%43 = icmp eq i64 %42, %14
br i1 %43, label %44, label %15
44: ; preds = %15, %8
%45 = phi float [ undef, %8 ], [ %38, %15 ]
%46 = phi float [ undef, %8 ], [ %40, %15 ]
%47 = phi i64 [ 0, %8 ], [ %41, %15 ]
%48 = phi float [ 0.000000e+00, %8 ], [ %38, %15 ]
%49 = phi float [ 0.000000e+00, %8 ], [ %40, %15 ]
%50 = icmp eq i64 %11, 0
br i1 %50, label %62, label %51
51: ; preds = %44
%52 = getelementptr inbounds float, float* %2, i64 %47
%53 = load float, float* %52
%54 = getelementptr inbounds float, float* %3, i64 %47
%55 = load float, float* %54
%56 = fsub float %53, %55
%57 = tail call i64 @fabs(float %56)
%58 = sitofp i64 %57 to float
%59 = fadd float %48, %58
%60 = load float, float* %54
%61 = fadd float %49, %60
br label %62
62: ; preds = %44, %51
%63 = phi float [ %45, %44 ], [ %59, %51 ]
%64 = phi float [ %46, %44 ], [ %61, %51 ]
%65 = fdiv float %63, %64
br label %66
66: ; preds = %62, %6
%67 = phi float [ %65, %62 ], [ 0x7FF8000000000000, %6 ]
%68 = fcmp olt float %67, 1.000000e+00
%69 = select i1 %68, float %67, float 1.000000e+00
%70 = load float, float* %4
%71 = fcmp olt float %70, %69
%72 = select i1 %71, float 0.000000e+00, float %5
%73 = fsub float 1.000000e+00, %72
%74 = fmul float %69, %73
%75 = tail call float @llvm.fmuladd.f32(float %72, float %70, float %74)
store float %75, float* %4
br i1 %7, label %205, label %76
76: ; preds = %66
%77 = fsub float 1.000000e+00, %75
%78 = add nuw i32 %0, 1
%79 = zext i32 %78 to i64
%80 = icmp ult i32 %0, 7
br i1 %80, label %171, label %81
81: ; preds = %76
%82 = getelementptr float, float* %2, i64 %79
%83 = getelementptr float, float* %1, i64 %79
%84 = icmp ugt float* %83, %2
%85 = icmp ugt float* %82, %1
%86 = and i1 %84, %85
br i1 %86, label %171, label %87
87: ; preds = %81
%88 = and i64 %79, 4294967288
%89 = insertelement <4 x float> poison, float %75, i64 0
%90 = shufflevector <4 x float> %89, <4 x float> poison, <4 x i32> zeroinitializer
%91 = insertelement <4 x float> poison, float %75, i64 0
%92 = shufflevector <4 x float> %91, <4 x float> poison, <4 x i32> zeroinitializer
%93 = insertelement <4 x float> poison, float %77, i64 0
%94 = shufflevector <4 x float> %93, <4 x float> poison, <4 x i32> zeroinitializer
%95 = insertelement <4 x float> poison, float %77, i64 0
%96 = shufflevector <4 x float> %95, <4 x float> poison, <4 x i32> zeroinitializer
%97 = add nsw i64 %88, -8
%98 = lshr exact i64 %97, 3
%99 = add nuw nsw i64 %98, 1
%100 = and i64 %99, 1
%101 = icmp eq i64 %97, 0
br i1 %101, label %147, label %102
102: ; preds = %87
%103 = and i64 %99, 4611686018427387902
br label %104
104: ; preds = %104, %102
%105 = phi i64 [ 0, %102 ], [ %144, %104 ]
%106 = phi i64 [ 0, %102 ], [ %145, %104 ]
%107 = getelementptr inbounds float, float* %1, i64 %105
%108 = bitcast float* %107 to <4 x float>*
%109 = load <4 x float>, <4 x float>* %108
%110 = getelementptr inbounds float, float* %107, i64 4
%111 = bitcast float* %110 to <4 x float>*
%112 = load <4 x float>, <4 x float>* %111
%113 = getelementptr inbounds float, float* %2, i64 %105
%114 = bitcast float* %113 to <4 x float>*
%115 = load <4 x float>, <4 x float>* %114
%116 = getelementptr inbounds float, float* %113, i64 4
%117 = bitcast float* %116 to <4 x float>*
%118 = load <4 x float>, <4 x float>* %117
%119 = fmul <4 x float> %90, %115
%120 = fmul <4 x float> %92, %118
%121 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %94, <4 x float> %109, <4 x float> %119)
%122 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %96, <4 x float> %112, <4 x float> %120)
%123 = bitcast float* %113 to <4 x float>*
store <4 x float> %121, <4 x float>* %123
%124 = bitcast float* %116 to <4 x float>*
store <4 x float> %122, <4 x float>* %124
%125 = or i64 %105, 8
%126 = getelementptr inbounds float, float* %1, i64 %125
%127 = bitcast float* %126 to <4 x float>*
%128 = load <4 x float>, <4 x float>* %127
%129 = getelementptr inbounds float, float* %126, i64 4
%130 = bitcast float* %129 to <4 x float>*
%131 = load <4 x float>, <4 x float>* %130
%132 = getelementptr inbounds float, float* %2, i64 %125
%133 = bitcast float* %132 to <4 x float>*
%134 = load <4 x float>, <4 x float>* %133
%135 = getelementptr inbounds float, float* %132, i64 4
%136 = bitcast float* %135 to <4 x float>*
%137 = load <4 x float>, <4 x float>* %136
%138 = fmul <4 x float> %90, %134
%139 = fmul <4 x float> %92, %137
%140 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %94, <4 x float> %128, <4 x float> %138)
%141 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %96, <4 x float> %131, <4 x float> %139)
%142 = bitcast float* %132 to <4 x float>*
store <4 x float> %140, <4 x float>* %142
%143 = bitcast float* %135 to <4 x float>*
store <4 x float> %141, <4 x float>* %143
%144 = add nuw i64 %105, 16
%145 = add i64 %106, 2
%146 = icmp eq i64 %145, %103
br i1 %146, label %147, label %104
147: ; preds = %104, %87
%148 = phi i64 [ 0, %87 ], [ %144, %104 ]
%149 = icmp eq i64 %100, 0
br i1 %149, label %169, label %150
150: ; preds = %147
%151 = getelementptr inbounds float, float* %1, i64 %148
%152 = bitcast float* %151 to <4 x float>*
%153 = load <4 x float>, <4 x float>* %152
%154 = getelementptr inbounds float, float* %151, i64 4
%155 = bitcast float* %154 to <4 x float>*
%156 = load <4 x float>, <4 x float>* %155
%157 = getelementptr inbounds float, float* %2, i64 %148
%158 = bitcast float* %157 to <4 x float>*
%159 = load <4 x float>, <4 x float>* %158
%160 = getelementptr inbounds float, float* %157, i64 4
%161 = bitcast float* %160 to <4 x float>*
%162 = load <4 x float>, <4 x float>* %161
%163 = fmul <4 x float> %90, %159
%164 = fmul <4 x float> %92, %162
%165 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %94, <4 x float> %153, <4 x float> %163)
%166 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %96, <4 x float> %156, <4 x float> %164)
%167 = bitcast float* %157 to <4 x float>*
store <4 x float> %165, <4 x float>* %167
%168 = bitcast float* %160 to <4 x float>*
store <4 x float> %166, <4 x float>* %168
br label %169
169: ; preds = %147, %150
%170 = icmp eq i64 %88, %79
br i1 %170, label %205, label %171
171: ; preds = %81, %76, %169
%172 = phi i64 [ 0, %81 ], [ 0, %76 ], [ %88, %169 ]
%173 = xor i64 %172, -1
%174 = and i64 %79, 1
%175 = icmp eq i64 %174, 0
br i1 %175, label %184, label %176
176: ; preds = %171
%177 = getelementptr inbounds float, float* %1, i64 %172
%178 = load float, float* %177
%179 = getelementptr inbounds float, float* %2, i64 %172
%180 = load float, float* %179
%181 = fmul float %75, %180
%182 = tail call float @llvm.fmuladd.f32(float %77, float %178, float %181)
store float %182, float* %179
%183 = or i64 %172, 1
br label %184
184: ; preds = %176, %171
%185 = phi i64 [ %172, %171 ], [ %183, %176 ]
%186 = sub nsw i64 0, %79
%187 = icmp eq i64 %173, %186
br i1 %187, label %205, label %188
188: ; preds = %184, %188
%189 = phi i64 [ %203, %188 ], [ %185, %184 ]
%190 = getelementptr inbounds float, float* %1, i64 %189
%191 = load float, float* %190
%192 = getelementptr inbounds float, float* %2, i64 %189
%193 = load float, float* %192
%194 = fmul float %75, %193
%195 = tail call float @llvm.fmuladd.f32(float %77, float %191, float %194)
store float %195, float* %192
%196 = add nuw nsw i64 %189, 1
%197 = getelementptr inbounds float, float* %1, i64 %196
%198 = load float, float* %197
%199 = getelementptr inbounds float, float* %2, i64 %196
%200 = load float, float* %199
%201 = fmul float %75, %200
%202 = tail call float @llvm.fmuladd.f32(float %77, float %198, float %201)
store float %202, float* %199
%203 = add nuw nsw i64 %189, 2
%204 = icmp eq i64 %203, %79
br i1 %204, label %205, label %188
205: ; preds = %184, %188, %169, %66
ret void
}