#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 */
double exp(double);
double fabs(double);
double log10(double);
void WebRtcIsac_GetVarsUB(const double *input, double *oldEnergy,
                          double *varscale) {
  double nrg[4], chng;
  int k;
  nrg[0] = 0.0001;
  for (k = 0; k < (120) / 2; k++) {
    nrg[0] += input[k] * input[k];
  }
  nrg[1] = 0.0001;
  for (; k < (240) / 2; k++) {
    nrg[1] += input[k] * input[k];
  }
  nrg[2] = 0.0001;
  for (; k < (480 * 3 / 4) / 2; k++) {
    nrg[2] += input[k] * input[k];
  }
  nrg[3] = 0.0001;
  for (; k < (480) / 2; k++) {
    nrg[3] += input[k] * input[k];
  }
  chng = 0.25 * (fabs(10.0 * log10(nrg[3] / nrg[2])) +
                 fabs(10.0 * log10(nrg[2] / nrg[1])) +
                 fabs(10.0 * log10(nrg[1] / nrg[0])) +
                 fabs(10.0 * log10(nrg[0] / *oldEnergy)));
  *varscale = exp(-1.4 / (1.0 + 0.4 * chng));
  *oldEnergy = nrg[3];
}


x86 assembly (clang, -O0):
<WebRtcIsac_GetVarsUB>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  0xec4(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x4c(%rbp)
cmpl   $0x3c,-0x4c(%rbp)
jge    118c <WebRtcIsac_GetVarsUB+0x6c>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1148 <WebRtcIsac_GetVarsUB+0x28>
movsd  0xe6c(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
cmpl   $0x78,-0x4c(%rbp)
jge    11dd <WebRtcIsac_GetVarsUB+0xbd>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1199 <WebRtcIsac_GetVarsUB+0x79>
movsd  0xe1b(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
cmpl   $0xb4,-0x4c(%rbp)
jge    1231 <WebRtcIsac_GetVarsUB+0x111>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11ea <WebRtcIsac_GetVarsUB+0xca>
movsd  0xdc7(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
cmpl   $0xf0,-0x4c(%rbp)
jge    1285 <WebRtcIsac_GetVarsUB+0x165>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    123e <WebRtcIsac_GetVarsUB+0x11e>
movsd  -0x28(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
call   1040 <log10@plt>
movaps %xmm0,%xmm1
movsd  0xd89(%rip),%xmm0
mulsd  %xmm1,%xmm0
movaps 0xd86(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x30(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
call   1040 <log10@plt>
movaps %xmm0,%xmm2
movsd  -0x68(%rbp),%xmm0
movsd  0xd56(%rip),%xmm1
mulsd  %xmm2,%xmm1
movaps 0xd53(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x38(%rbp),%xmm0
divsd  -0x40(%rbp),%xmm0
call   1040 <log10@plt>
movaps %xmm0,%xmm2
movsd  -0x60(%rbp),%xmm0
movsd  0xd1f(%rip),%xmm1
mulsd  %xmm2,%xmm1
movaps 0xd1c(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
divsd  (%rax),%xmm0
call   1040 <log10@plt>
movsd  -0x58(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  0xce5(%rip),%xmm0
mulsd  %xmm2,%xmm0
movaps 0xce2(%rip),%xmm2
pand   %xmm2,%xmm0
addsd  %xmm0,%xmm1
movsd  0xcc2(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  0xc9c(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  0xc98(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0xc7c(%rip),%xmm0
divsd  %xmm1,%xmm0
call   1030 <exp@plt>
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<WebRtcIsac_GetVarsUB>:
push   %r14
push   %rbx
sub    $0x48,%rsp
mov    %rdx,%r14
mov    %rsi,%rbx
movsd  0xecb(%rip),%xmm2
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
movsd  0x8(%rdi,%rax,8),%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%rdi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x18(%rdi,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x20(%rdi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x28(%rdi,%rax,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
add    $0x6,%rax
cmp    $0x3c,%rax
jne    1140 <WebRtcIsac_GetVarsUB+0x20>
movsd  0xe5b(%rip),%xmm3
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  0x1e0(%rdi,%rax,8),%xmm0
movsd  0x1e8(%rdi,%rax,8),%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1f0(%rdi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1f8(%rdi,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x200(%rdi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x208(%rdi,%rax,8),%xmm3
mulsd  %xmm3,%xmm3
addsd  %xmm0,%xmm3
add    $0x6,%rax
cmp    $0x3c,%rax
jne    11b0 <WebRtcIsac_GetVarsUB+0x90>
movsd  0xdd8(%rip),%xmm4
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  0x3c0(%rdi,%rax,8),%xmm0
movsd  0x3c8(%rdi,%rax,8),%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm4,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x3d0(%rdi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x3d8(%rdi,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x3e0(%rdi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x3e8(%rdi,%rax,8),%xmm4
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
add    $0x6,%rax
cmp    $0x3c,%rax
jne    1230 <WebRtcIsac_GetVarsUB+0x110>
movsd  %xmm3,0x10(%rsp)
movsd  %xmm2,0x8(%rsp)
movsd  0xd4c(%rip),%xmm2
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  0x5a0(%rdi,%rax,8),%xmm0
movsd  0x5a8(%rdi,%rax,8),%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x5b0(%rdi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x5b8(%rdi,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x5c0(%rdi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x5c8(%rdi,%rax,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
add    $0x6,%rax
cmp    $0x3c,%rax
jne    12c0 <WebRtcIsac_GetVarsUB+0x1a0>
movapd %xmm2,%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm2,0x40(%rsp)
movsd  %xmm4,0x38(%rsp)
call   1040 <log10@plt>
mulsd  0xcb7(%rip),%xmm0
andpd  0xcd7(%rip),%xmm0
movapd %xmm0,0x20(%rsp)
movsd  0x38(%rsp),%xmm0
divsd  0x10(%rsp),%xmm0
call   1040 <log10@plt>
mulsd  0xc90(%rip),%xmm0
andpd  0xcb0(%rip),%xmm0
addsd  0x20(%rsp),%xmm0
movapd %xmm0,0x20(%rsp)
movsd  0x10(%rsp),%xmm0
divsd  0x8(%rsp),%xmm0
call   1040 <log10@plt>
mulsd  0xc63(%rip),%xmm0
andpd  0xc83(%rip),%xmm0
addsd  0x20(%rsp),%xmm0
movapd %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
divsd  (%rbx),%xmm0
call   1040 <log10@plt>
mulsd  0xc38(%rip),%xmm0
andpd  0xc58(%rip),%xmm0
addsd  0x10(%rsp),%xmm0
mulsd  0xc2a(%rip),%xmm0
mulsd  0xc2a(%rip),%xmm0
addsd  0xc2a(%rip),%xmm0
movsd  0xc2a(%rip),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,(%r14)
movsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%rbx)
add    $0x48,%rsp
pop    %rbx
pop    %r14
ret

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

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