#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 */
scalar_t__ fabs(int /*<<< orphan*/);
int /*<<< orphan*/ log(float);
float sqrt(float);
float spectralChange(float Energies[16][27], float EnergyTotal, int nSfb,
                     int start, int border, int stop) {
  int i, j;
  int len1 = border - start;
  int len2 = stop - border;
  float lenRatio = (float)len1 / (float)len2;
  float delta;
  float delta_sum = 0.0f;
  float nrg1[27];
  float nrg2[27];
  float pos_weight = (0.5f - (float)len1 / (float)(len1 + len2));
  ;
  ;
  ;
  ;
  ;
  ;
  pos_weight = 1.0f - 4.0f * pos_weight * pos_weight;
  ;
  ;
  for (j = 0; j < nSfb; j++) {
    ;
    ;
    nrg1[j] = 1.0e6f * len1;
    nrg2[j] = 1.0e6f * len2;
    ;
    ;
    for (i = start; i < border; i++) {
      ;
      ;
      nrg1[j] += Energies[i][j];
    };
    ;
    for (i = border; i < stop; i++) {
      ;
      ;
      nrg2[j] += Energies[i][j];
    }
  };
  ;
  for (j = 0; j < nSfb; j++) {
    ;
    ;
    ;
    ;
    delta = (float)fabs(log(nrg2[j] / nrg1[j] * lenRatio));
    ;
    ;
    ;
    ;
    delta_sum += (float)(sqrt((nrg1[j] + nrg2[j]) / EnergyTotal) * delta);
  };
  ;
  return delta_sum * pos_weight;
}


x86 assembly (clang, -O0):
<spectralChange>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cvtsi2ssl -0x28(%rbp),%xmm0
cvtsi2ssl -0x2c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
cvtsi2ssl -0x28(%rbp),%xmm1
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
cvtsi2ss %eax,%xmm0
divss  %xmm0,%xmm1
movss  0xe6f(%rip),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x124(%rbp)
ff
movss  0xe57(%rip),%xmm0
mulss  -0x124(%rbp),%xmm0
ff
movss  -0x124(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xe2a(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x124(%rbp)
ff
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12e0 <spectralChange+0x1b0>
cvtsi2ssl -0x28(%rbp),%xmm1
movss  0xe0a(%rip),%xmm0
mulss  %xmm1,%xmm0
movslq -0x24(%rbp),%rax
movss  %xmm0,-0xb0(%rbp,%rax,4)
ff ff
cvtsi2ssl -0x2c(%rbp),%xmm1
movss  0xdec(%rip),%xmm0
mulss  %xmm1,%xmm0
movslq -0x24(%rbp),%rax
movss  %xmm0,-0x120(%rbp,%rax,4)
ff ff
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    127f <spectralChange+0x14f>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x6c,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x24(%rbp),%rax
addss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0xb0(%rbp,%rax,4)
ff ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1237 <spectralChange+0x107>
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12cd <spectralChange+0x19d>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x6c,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x24(%rbp),%rax
addss  -0x120(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x120(%rbp,%rax,4)
ff ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1285 <spectralChange+0x155>
jmp    12d2 <spectralChange+0x1a2>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11e9 <spectralChange+0xb9>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1371 <spectralChange+0x241>
movslq -0x24(%rbp),%rax
movss  -0x120(%rbp,%rax,4),%xmm0
ff ff
movslq -0x24(%rbp),%rax
divss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
mulss  -0x30(%rbp),%xmm0
call   1040 <log@plt>
mov    %eax,%edi
call   1030 <fabs@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x34(%rbp)
movslq -0x24(%rbp),%rax
movss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x24(%rbp),%rax
addss  -0x120(%rbp,%rax,4),%xmm0
ff ff
divss  -0xc(%rbp),%xmm0
call   1050 <sqrt@plt>
movss  -0x34(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12e7 <spectralChange+0x1b7>
movss  -0x38(%rbp),%xmm0
mulss  -0x124(%rbp),%xmm0
ff
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<spectralChange>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
movss  %xmm0,0x2c(%rsp)
mov    %ecx,%ebx
sub    %edx,%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mov    %r8d,%eax
sub    %edx,%eax
cvtsi2ss %eax,%xmm1
movaps %xmm0,%xmm2
divss  %xmm1,%xmm2
movss  0xe96(%rip),%xmm1
subss  %xmm2,%xmm1
movss  %xmm1,0x24(%rsp)
xorps  %xmm3,%xmm3
test   %esi,%esi
jle    13ff <spectralChange+0x2cf>
mov    %r8d,%eax
sub    %ecx,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movaps %xmm0,%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0x28(%rsp)
movss  0xe64(%rip),%xmm2
mulss  %xmm2,%xmm0
mulss  %xmm2,%xmm1
movslq %edx,%rbp
movslq %ecx,%r12
mov    %esi,0x20(%rsp)
mov    %esi,%r14d
movslq %r8d,%r9
mov    %rbp,%rsi
not    %rsi
add    %r12,%rsi
mov    %rsi,0x10(%rsp)
mov    %r12,%rsi
not    %rsi
mov    %r9,0x30(%rsp)
add    %r9,%rsi
mov    %rsi,0x38(%rsp)
and    $0x3,%ebx
and    $0x3,%eax
mov    %rbp,0x8(%rsp)
imul   $0x6c,%rbp,%r10
add    %rdi,%r10
mov    %rbx,%rbp
neg    %rbp
lea    0xd8(%rdi),%r11
imul   $0x6c,%r12,%r13
add    %rdi,%r13
mov    %rax,0x18(%rsp)
mov    %rax,%rdi
neg    %rdi
xor    %r15d,%r15d
mov    %rbx,%rsi
jmp    1240 <spectralChange+0x110>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  %xmm2,0x40(%rsp,%r15,4)
add    $0x1,%r15
add    $0x4,%r10
add    $0x4,%r11
add    $0x4,%r13
cmp    %r14,%r15
je     1368 <spectralChange+0x238>
movss  %xmm0,0xb0(%rsp,%r15,4)
movss  %xmm1,0x40(%rsp,%r15,4)
cmp    %edx,%ecx
jle    12d1 <spectralChange+0x1a1>
mov    0x8(%rsp),%rbx
movaps %xmm0,%xmm2
test   %rsi,%rsi
je     1289 <spectralChange+0x159>
mov    %r10,%rbx
xor    %eax,%eax
movaps %xmm0,%xmm2
xchg   %ax,%ax
addss  (%rbx),%xmm2
add    $0xffffffffffffffff,%rax
add    $0x6c,%rbx
cmp    %rax,%rbp
jne    1270 <spectralChange+0x140>
mov    0x8(%rsp),%rbx
sub    %rax,%rbx
cmpq   $0x3,0x10(%rsp)
jb     12c7 <spectralChange+0x197>
mov    %r12,%rax
sub    %rbx,%rax
imul   $0x6c,%rbx,%r9
add    %r11,%r9
xchg   %ax,%ax
addss  -0xd8(%r9),%xmm2
ff ff
addss  -0x6c(%r9),%xmm2
addss  (%r9),%xmm2
addss  0x6c(%r9),%xmm2
add    $0x1b0,%r9
add    $0xfffffffffffffffc,%rax
jne    12a0 <spectralChange+0x170>
movss  %xmm2,0xb0(%rsp,%r15,4)
cmp    %ecx,%r8d
jle    1227 <spectralChange+0xf7>
mov    %r12,%rbx
movaps %xmm1,%xmm2
cmpq   $0x0,0x18(%rsp)
je     131a <spectralChange+0x1ea>
mov    %rsi,%r9
mov    %r13,%rsi
xor    %eax,%eax
movaps %xmm1,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  (%rsi),%xmm2
add    $0xffffffffffffffff,%rax
add    $0x6c,%rsi
cmp    %rax,%rdi
jne    1300 <spectralChange+0x1d0>
mov    %r12,%rbx
sub    %rax,%rbx
mov    %r9,%rsi
cmpq   $0x3,0x38(%rsp)
jb     1220 <spectralChange+0xf0>
mov    0x30(%rsp),%rax
sub    %rbx,%rax
imul   $0x6c,%rbx,%rbx
add    %r11,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
addss  -0xd8(%rbx),%xmm2
ff
addss  -0x6c(%rbx),%xmm2
addss  (%rbx),%xmm2
addss  0x6c(%rbx),%xmm2
add    $0x1b0,%rbx
add    $0xfffffffffffffffc,%rax
jne    1340 <spectralChange+0x210>
jmp    1220 <spectralChange+0xf0>
cmpl   $0x0,0x20(%rsp)
jle    13ff <spectralChange+0x2cf>
xor    %ebp,%ebp
xorps  %xmm3,%xmm3
jmp    13a4 <spectralChange+0x274>
nopw   0x0(%rax,%rax,1)
call   1050 <sqrt@plt>
xorps  %xmm1,%xmm1
cvtsi2ss %rbx,%xmm1
mulss  %xmm0,%xmm1
movss  0x8(%rsp),%xmm3
addss  %xmm1,%xmm3
add    $0x1,%rbp
cmp    %rbp,%r14
je     13ff <spectralChange+0x2cf>
movss  %xmm3,0x8(%rsp)
movss  0x40(%rsp,%rbp,4),%xmm0
movss  %xmm0,0x10(%rsp)
movss  0xb0(%rsp,%rbp,4),%xmm1
movss  %xmm1,0x18(%rsp)
divss  %xmm1,%xmm0
mulss  0x28(%rsp),%xmm0
call   1040 <log@plt>
mov    %eax,%edi
call   1030 <fabs@plt>
movss  0x10(%rsp),%xmm0
mov    %rax,%rbx
addss  0x18(%rsp),%xmm0
divss  0x2c(%rsp),%xmm0
ucomiss 0xc19(%rip),%xmm0
jb     1380 <spectralChange+0x250>
sqrtss %xmm0,%xmm0
jmp    1385 <spectralChange+0x255>
movss  0xc01(%rip),%xmm0
movss  0x24(%rsp),%xmm1
mulss  %xmm1,%xmm0
mulss  %xmm1,%xmm0
addss  0xbef(%rip),%xmm0
mulss  %xmm3,%xmm0
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define float @spectralChange([27 x float]* %0, float %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca [27 x float]*
%8 = alloca float
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca [27 x float]
%21 = alloca [27 x float]
%22 = alloca float
store [27 x float]* %0, [27 x float]** %7
store float %1, float* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%23 = load i32, i32* %11
%24 = load i32, i32* %10
%25 = sub nsw i32 %23, %24
store i32 %25, i32* %15
%26 = load i32, i32* %12
%27 = load i32, i32* %11
%28 = sub nsw i32 %26, %27
store i32 %28, i32* %16
%29 = load i32, i32* %15
%30 = sitofp i32 %29 to float
%31 = load i32, i32* %16
%32 = sitofp i32 %31 to float
%33 = fdiv float %30, %32
store float %33, float* %17
store float 0.000000e+00, float* %19
%34 = load i32, i32* %15
%35 = sitofp i32 %34 to float
%36 = load i32, i32* %15
%37 = load i32, i32* %16
%38 = add nsw i32 %36, %37
%39 = sitofp i32 %38 to float
%40 = fdiv float %35, %39
%41 = fsub float 5.000000e-01, %40
store float %41, float* %22
%42 = load float, float* %22
%43 = fmul float 4.000000e+00, %42
%44 = load float, float* %22
%45 = fneg float %43
%46 = call float @llvm.fmuladd.f32(float %45, float %44, float 1.000000e+00)
store float %46, float* %22
store i32 0, i32* %14
br label %47
47: ; preds = %110, %6
%48 = load i32, i32* %14
%49 = load i32, i32* %9
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %113
51: ; preds = %47
%52 = load i32, i32* %15
%53 = sitofp i32 %52 to float
%54 = fmul float 1.000000e+06, %53
%55 = load i32, i32* %14
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [27 x float], [27 x float]* %20, i64 0, i64 %56
store float %54, float* %57
%58 = load i32, i32* %16
%59 = sitofp i32 %58 to float
%60 = fmul float 1.000000e+06, %59
%61 = load i32, i32* %14
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [27 x float], [27 x float]* %21, i64 0, i64 %62
store float %60, float* %63
%64 = load i32, i32* %10
store i32 %64, i32* %13
br label %65
65: ; preds = %83, %51
%66 = load i32, i32* %13
%67 = load i32, i32* %11
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %86
69: ; preds = %65
%70 = load [27 x float]*, [27 x float]** %7
%71 = load i32, i32* %13
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [27 x float], [27 x float]* %70, i64 %72
%74 = load i32, i32* %14
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [27 x float], [27 x float]* %73, i64 0, i64 %75
%77 = load float, float* %76
%78 = load i32, i32* %14
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [27 x float], [27 x float]* %20, i64 0, i64 %79
%81 = load float, float* %80
%82 = fadd float %81, %77
store float %82, float* %80
br label %83
83: ; preds = %69
%84 = load i32, i32* %13
%85 = add nsw i32 %84, 1
store i32 %85, i32* %13
br label %65
86: ; preds = %65
%87 = load i32, i32* %11
store i32 %87, i32* %13
br label %88
88: ; preds = %106, %86
%89 = load i32, i32* %13
%90 = load i32, i32* %12
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %109
92: ; preds = %88
%93 = load [27 x float]*, [27 x float]** %7
%94 = load i32, i32* %13
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [27 x float], [27 x float]* %93, i64 %95
%97 = load i32, i32* %14
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [27 x float], [27 x float]* %96, i64 0, i64 %98
%100 = load float, float* %99
%101 = load i32, i32* %14
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [27 x float], [27 x float]* %21, i64 0, i64 %102
%104 = load float, float* %103
%105 = fadd float %104, %100
store float %105, float* %103
br label %106
106: ; preds = %92
%107 = load i32, i32* %13
%108 = add nsw i32 %107, 1
store i32 %108, i32* %13
br label %88
109: ; preds = %88
br label %110
110: ; preds = %109
%111 = load i32, i32* %14
%112 = add nsw i32 %111, 1
store i32 %112, i32* %14
br label %47
113: ; preds = %47
store i32 0, i32* %14
br label %114
114: ; preds = %148, %113
%115 = load i32, i32* %14
%116 = load i32, i32* %9
%117 = icmp slt i32 %115, %116
br i1 %117, label %118, label %151
118: ; preds = %114
%119 = load i32, i32* %14
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [27 x float], [27 x float]* %21, i64 0, i64 %120
%122 = load float, float* %121
%123 = load i32, i32* %14
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [27 x float], [27 x float]* %20, i64 0, i64 %124
%126 = load float, float* %125
%127 = fdiv float %122, %126
%128 = load float, float* %17
%129 = fmul float %127, %128
%130 = call i32 @log(float %129)
%131 = call i64 @fabs(i32 %130)
%132 = sitofp i64 %131 to float
store float %132, float* %18
%133 = load i32, i32* %14
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [27 x float], [27 x float]* %20, i64 0, i64 %134
%136 = load float, float* %135
%137 = load i32, i32* %14
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [27 x float], [27 x float]* %21, i64 0, i64 %138
%140 = load float, float* %139
%141 = fadd float %136, %140
%142 = load float, float* %8
%143 = fdiv float %141, %142
%144 = call float @sqrt(float %143)
%145 = load float, float* %18
%146 = load float, float* %19
%147 = call float @llvm.fmuladd.f32(float %144, float %145, float %146)
store float %147, float* %19
br label %148
148: ; preds = %118
%149 = load i32, i32* %14
%150 = add nsw i32 %149, 1
store i32 %150, i32* %14
br label %114
151: ; preds = %114
%152 = load float, float* %19
%153 = load float, float* %22
%154 = fmul float %152, %153
ret float %154
}

LLVM IR (-O2):
define float @spectralChange([27 x float]* nocapture %0, float %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca [27 x float]
%8 = alloca [27 x float]
%9 = sub nsw i32 %4, %3
%10 = sub nsw i32 %5, %4
%11 = sitofp i32 %9 to float
%12 = sitofp i32 %10 to float
%13 = fdiv float %11, %12
%14 = bitcast [27 x float]* %7 to i8*
%15 = bitcast [27 x float]* %8 to i8*
%16 = add nsw i32 %10, %9
%17 = sitofp i32 %16 to float
%18 = fdiv float %11, %17
%19 = fsub float 5.000000e-01, %18
%20 = icmp sgt i32 %2, 0
br i1 %20, label %21, label %145
21: ; preds = %6
%22 = fmul float %11, 1.000000e+06
%23 = fmul float %12, 1.000000e+06
%24 = icmp sgt i32 %4, %3
%25 = icmp sgt i32 %5, %4
%26 = sext i32 %3 to i64
%27 = sext i32 %4 to i64
%28 = zext i32 %2 to i64
%29 = sext i32 %5 to i64
%30 = sub nsw i64 %27, %26
%31 = xor i64 %26, -1
%32 = add nsw i64 %31, %27
%33 = sub nsw i64 %29, %27
%34 = xor i64 %27, -1
%35 = add nsw i64 %34, %29
%36 = and i64 %30, 3
%37 = icmp eq i64 %36, 0
%38 = icmp ult i64 %32, 3
%39 = and i64 %33, 3
%40 = icmp eq i64 %39, 0
%41 = icmp ult i64 %35, 3
br label %45
42: ; preds = %124
br i1 %20, label %43, label %145
43: ; preds = %42
%44 = zext i32 %2 to i64
br label %127
45: ; preds = %21, %124
%46 = phi i64 [ 0, %21 ], [ %125, %124 ]
%47 = getelementptr inbounds [27 x float], [27 x float]* %7, i64 0, i64 %46
store float %22, float* %47
%48 = getelementptr inbounds [27 x float], [27 x float]* %8, i64 0, i64 %46
store float %23, float* %48
br i1 %24, label %49, label %66
49: ; preds = %45
br i1 %37, label %60, label %50
50: ; preds = %49, %50
%51 = phi i64 [ %57, %50 ], [ %26, %49 ]
%52 = phi float [ %56, %50 ], [ %22, %49 ]
%53 = phi i64 [ %58, %50 ], [ 0, %49 ]
%54 = getelementptr inbounds [27 x float], [27 x float]* %0, i64 %51, i64 %46
%55 = load float, float* %54
%56 = fadd float %55, %52
%57 = add nsw i64 %51, 1
%58 = add i64 %53, 1
%59 = icmp eq i64 %58, %36
br i1 %59, label %60, label %50
60: ; preds = %50, %49
%61 = phi float [ undef, %49 ], [ %56, %50 ]
%62 = phi i64 [ %26, %49 ], [ %57, %50 ]
%63 = phi float [ %22, %49 ], [ %56, %50 ]
br i1 %38, label %64, label %82
64: ; preds = %82, %60
%65 = phi float [ %61, %60 ], [ %99, %82 ]
store float %65, float* %47
br label %66
66: ; preds = %64, %45
br i1 %25, label %67, label %124
67: ; preds = %66
br i1 %40, label %78, label %68
68: ; preds = %67, %68
%69 = phi i64 [ %75, %68 ], [ %27, %67 ]
%70 = phi float [ %74, %68 ], [ %23, %67 ]
%71 = phi i64 [ %76, %68 ], [ 0, %67 ]
%72 = getelementptr inbounds [27 x float], [27 x float]* %0, i64 %69, i64 %46
%73 = load float, float* %72
%74 = fadd float %73, %70
%75 = add nsw i64 %69, 1
%76 = add i64 %71, 1
%77 = icmp eq i64 %76, %39
br i1 %77, label %78, label %68
78: ; preds = %68, %67
%79 = phi float [ undef, %67 ], [ %74, %68 ]
%80 = phi i64 [ %27, %67 ], [ %75, %68 ]
%81 = phi float [ %23, %67 ], [ %74, %68 ]
br i1 %41, label %122, label %102
82: ; preds = %60, %82
%83 = phi i64 [ %100, %82 ], [ %62, %60 ]
%84 = phi float [ %99, %82 ], [ %63, %60 ]
%85 = getelementptr inbounds [27 x float], [27 x float]* %0, i64 %83, i64 %46
%86 = load float, float* %85
%87 = fadd float %86, %84
%88 = add nsw i64 %83, 1
%89 = getelementptr inbounds [27 x float], [27 x float]* %0, i64 %88, i64 %46
%90 = load float, float* %89
%91 = fadd float %90, %87
%92 = add nsw i64 %83, 2
%93 = getelementptr inbounds [27 x float], [27 x float]* %0, i64 %92, i64 %46
%94 = load float, float* %93
%95 = fadd float %94, %91
%96 = add nsw i64 %83, 3
%97 = getelementptr inbounds [27 x float], [27 x float]* %0, i64 %96, i64 %46
%98 = load float, float* %97
%99 = fadd float %98, %95
%100 = add nsw i64 %83, 4
%101 = icmp eq i64 %100, %27
br i1 %101, label %64, label %82
102: ; preds = %78, %102
%103 = phi i64 [ %120, %102 ], [ %80, %78 ]
%104 = phi float [ %119, %102 ], [ %81, %78 ]
%105 = getelementptr inbounds [27 x float], [27 x float]* %0, i64 %103, i64 %46
%106 = load float, float* %105
%107 = fadd float %106, %104
%108 = add nsw i64 %103, 1
%109 = getelementptr inbounds [27 x float], [27 x float]* %0, i64 %108, i64 %46
%110 = load float, float* %109
%111 = fadd float %110, %107
%112 = add nsw i64 %103, 2
%113 = getelementptr inbounds [27 x float], [27 x float]* %0, i64 %112, i64 %46
%114 = load float, float* %113
%115 = fadd float %114, %111
%116 = add nsw i64 %103, 3
%117 = getelementptr inbounds [27 x float], [27 x float]* %0, i64 %116, i64 %46
%118 = load float, float* %117
%119 = fadd float %118, %115
%120 = add nsw i64 %103, 4
%121 = icmp eq i64 %120, %29
br i1 %121, label %122, label %102
122: ; preds = %102, %78
%123 = phi float [ %79, %78 ], [ %119, %102 ]
store float %123, float* %48
br label %124
124: ; preds = %122, %66
%125 = add nuw nsw i64 %46, 1
%126 = icmp eq i64 %125, %28
br i1 %126, label %42, label %45
127: ; preds = %43, %127
%128 = phi i64 [ 0, %43 ], [ %143, %127 ]
%129 = phi float [ 0.000000e+00, %43 ], [ %142, %127 ]
%130 = getelementptr inbounds [27 x float], [27 x float]* %8, i64 0, i64 %128
%131 = load float, float* %130
%132 = getelementptr inbounds [27 x float], [27 x float]* %7, i64 0, i64 %128
%133 = load float, float* %132
%134 = fdiv float %131, %133
%135 = fmul float %13, %134
%136 = tail call i32 @log(float %135)
%137 = tail call i64 @fabs(i32 %136)
%138 = sitofp i64 %137 to float
%139 = fadd float %131, %133
%140 = fdiv float %139, %1
%141 = tail call float @sqrt(float %140)
%142 = tail call float @llvm.fmuladd.f32(float %141, float %138, float %129)
%143 = add nuw nsw i64 %128, 1
%144 = icmp eq i64 %143, %44
br i1 %144, label %145, label %127
145: ; preds = %127, %6, %42
%146 = phi float [ 0.000000e+00, %42 ], [ 0.000000e+00, %6 ], [ %142, %127 ]
%147 = fmul float %19, -4.000000e+00
%148 = tail call float @llvm.fmuladd.f32(float %147, float %19, float 1.000000e+00)
%149 = fmul float %148, %146
ret float %149
}