double evalfunc(double **param, double *vals, double *psum, double *ptry,
                int nparam,
                double (*minfunc)(double *tryparam, double *consts,
                                  struct stat_str *data, int ndata, int start,
                                  int stop),
                double *consts, void *data, int ndata, int start, int stop,
                int ihi, double factor) {
  int j;
  double fac1, fac2, ytry;
  fac1 = (1.0 - factor) / nparam;
  fac2 = fac1 - factor;
  for (j = 0; j < nparam; j++) {
    ptry[j] = psum[j] * fac1 - param[ihi][j] * fac2;
  }
  ytry = minfunc(ptry, consts, data, ndata, start, stop);
  if (ytry < vals[ihi]) {
    vals[ihi] = ytry;
    for (j = 0; j < nparam; j++) {
      psum[j] += ptry[j] - param[ihi][j];
      param[ihi][j] = ptry[j];
    }
  }
  return ytry;
}


x86 assembly (clang, -O0):
<evalfunc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  0xebf(%rip),%xmm0
subsd  -0x38(%rbp),%xmm0
cvtsi2sdl -0x24(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11dc <evalfunc+0xdc>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq 0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    116a <evalfunc+0x6a>
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rdi
mov    0x10(%rbp),%rsi
mov    0x18(%rbp),%rdx
mov    0x20(%rbp),%ecx
mov    0x28(%rbp),%r8d
mov    0x30(%rbp),%r9d
call   *%rax
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq 0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    12a8 <evalfunc+0x1a8>
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq 0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12a3 <evalfunc+0x1a3>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq 0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq 0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1233 <evalfunc+0x133>
jmp    12a8 <evalfunc+0x1a8>
movsd  -0x58(%rbp),%xmm0
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<evalfunc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r9,%r10
mov    %r8d,%r15d
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %rsi,(%rsp)
mov    %rdi,%r12
mov    0x60(%rsp),%r9d
mov    0x58(%rsp),%r8d
mov    0x48(%rsp),%rdx
mov    0x40(%rsp),%rsi
movslq 0x68(%rsp),%r13
test   %r15d,%r15d
jle    12d4 <evalfunc+0x1d4>
movsd  0xeb8(%rip),%xmm1
subsd  %xmm0,%xmm1
cvtsi2sd %r15d,%xmm2
divsd  %xmm2,%xmm1
movapd %xmm1,%xmm2
subsd  %xmm0,%xmm2
mov    (%r12,%r13,8),%rdi
mov    %r15d,%r11d
cmp    $0x4,%r15d
jae    11f9 <evalfunc+0xf9>
xor    %eax,%eax
mov    %rax,%rbp
not    %rbp
test   $0x1,%r11b
je     119c <evalfunc+0x9c>
movsd  (%rdi,%rax,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  (%r14,%rax,8),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm0,%xmm3
movsd  %xmm3,(%rbx,%rax,8)
or     $0x1,%rax
add    %r11,%rbp
je     12d4 <evalfunc+0x1d4>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rax,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  (%r14,%rax,8),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm0,%xmm3
movsd  %xmm3,(%rbx,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  0x8(%r14,%rax,8),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm0,%xmm3
movsd  %xmm3,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r11
jne    11b0 <evalfunc+0xb0>
jmp    12d4 <evalfunc+0x1d4>
mov    %rdx,%rsi
mov    %r9d,%edx
mov    %r10,%rcx
mov    %r12,%r8
lea    (%r14,%r11,8),%rax
cmp    %rbx,%rax
seta   %r12b
lea    (%rbx,%r11,8),%rax
cmp    %r14,%rax
seta   %r9b
lea    (%rdi,%r11,8),%rbp
cmp    %rbx,%rbp
seta   %r10b
cmp    %rax,%rdi
setb   %bpl
xor    %eax,%eax
test   %r9b,%r12b
jne    14c4 <evalfunc+0x3c4>
and    %bpl,%r10b
mov    %r8,%r12
mov    %rcx,%r10
mov    %edx,%r9d
mov    0x58(%rsp),%r8d
mov    %rsi,%rdx
mov    0x40(%rsp),%rsi
jne    1170 <evalfunc+0x70>
mov    %r11d,%eax
and    $0xfffffffc,%eax
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
lea    0x0(,%r11,8),%rbp
and    $0xffffffffffffffe0,%rbp
xor    %r10d,%r10d
nopl   0x0(%rax)
movupd (%r14,%r10,1),%xmm4
movupd 0x10(%r14,%r10,1),%xmm5
movupd (%rdi,%r10,1),%xmm6
movupd 0x10(%rdi,%r10,1),%xmm7
mulpd  %xmm0,%xmm6
mulpd  %xmm0,%xmm7
mulpd  %xmm3,%xmm4
subpd  %xmm6,%xmm4
mulpd  %xmm3,%xmm5
subpd  %xmm7,%xmm5
movupd %xmm4,(%rbx,%r10,1)
movupd %xmm5,0x10(%rbx,%r10,1)
add    $0x20,%r10
cmp    %r10,%rbp
jne    1280 <evalfunc+0x180>
cmp    %r11,%rax
mov    %rcx,%r10
jne    1170 <evalfunc+0x70>
mov    %rbx,%rdi
mov    0x50(%rsp),%ecx
call   *%r10
mov    (%rsp),%rax
movsd  (%rax,%r13,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    14b5 <evalfunc+0x3b5>
movsd  %xmm0,(%rax,%r13,8)
test   %r15d,%r15d
jle    14b5 <evalfunc+0x3b5>
mov    (%r12,%r13,8),%rax
mov    %r15d,%ecx
cmp    $0x1,%r15d
jne    13a4 <evalfunc+0x2a4>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%cl
je     1343 <evalfunc+0x243>
movsd  (%rbx,%rdx,8),%xmm1
subsd  (%rax,%rdx,8),%xmm1
addsd  (%r14,%rdx,8),%xmm1
movsd  %xmm1,(%r14,%rdx,8)
movsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rax,%rdx,8)
or     $0x1,%rdx
add    %rcx,%rsi
je     14b5 <evalfunc+0x3b5>
nopl   0x0(%rax)
movsd  (%rbx,%rdx,8),%xmm1
subsd  (%rax,%rdx,8),%xmm1
addsd  (%r14,%rdx,8),%xmm1
movsd  %xmm1,(%r14,%rdx,8)
movsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rax,%rdx,8)
movsd  0x8(%rbx,%rdx,8),%xmm1
subsd  0x8(%rax,%rdx,8),%xmm1
addsd  0x8(%r14,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r14,%rdx,8)
movsd  0x8(%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x8(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1350 <evalfunc+0x250>
jmp    14b5 <evalfunc+0x3b5>
lea    (%r14,%rcx,8),%rdx
lea    (%rax,%rcx,8),%rbp
lea    (%rbx,%rcx,8),%rdi
cmp    %r14,%rbp
seta   %r10b
cmp    %rdx,%rax
setb   %r11b
cmp    %r14,%rdi
seta   %sil
cmp    %rbx,%rdx
seta   %r8b
cmp    %rdi,%rax
setb   %dil
cmp    %rbx,%rbp
seta   %r9b
xor    %edx,%edx
test   %r11b,%r10b
jne    1314 <evalfunc+0x214>
and    %r8b,%sil
jne    1314 <evalfunc+0x214>
and    %r9b,%dil
jne    1314 <evalfunc+0x214>
mov    %ecx,%edx
and    $0xfffffffe,%edx
lea    -0x2(%rdx),%rsi
mov    %rsi,%rbp
shr    %rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     14df <evalfunc+0x3df>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movupd (%rbx,%rsi,8),%xmm1
movupd (%rax,%rsi,8),%xmm2
subpd  %xmm2,%xmm1
movupd (%r14,%rsi,8),%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%r14,%rsi,8)
movups (%rbx,%rsi,8),%xmm1
movups %xmm1,(%rax,%rsi,8)
movupd 0x10(%rbx,%rsi,8),%xmm1
movupd 0x10(%rax,%rsi,8),%xmm2
subpd  %xmm2,%xmm1
movupd 0x10(%r14,%rsi,8),%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,0x10(%r14,%rsi,8)
movupd 0x10(%rbx,%rsi,8),%xmm1
movupd %xmm1,0x10(%rax,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1420 <evalfunc+0x320>
test   $0x1,%bpl
je     14ac <evalfunc+0x3ac>
movupd (%rbx,%rsi,8),%xmm1
movupd (%rax,%rsi,8),%xmm2
subpd  %xmm2,%xmm1
movupd (%r14,%rsi,8),%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%r14,%rsi,8)
movupd (%rbx,%rsi,8),%xmm1
movupd %xmm1,(%rax,%rsi,8)
cmp    %rcx,%rdx
jne    1314 <evalfunc+0x214>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8,%r12
mov    %rcx,%r10
mov    %edx,%r9d
mov    0x58(%rsp),%r8d
mov    %rsi,%rdx
mov    0x40(%rsp),%rsi
jmp    1170 <evalfunc+0x70>
xor    %esi,%esi
test   $0x1,%bpl
jne    1484 <evalfunc+0x384>
jmp    14ac <evalfunc+0x3ac>

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

LLVM IR (-O2):
%struct.stat_str = type opaque
define double @evalfunc(double** nocapture %0, double* nocapture %1, double* nocapture %2, double* %3, i32 %4, double (double*, double*, %struct.stat_str*, i32, i32, i32)* nocapture %5, double* %6, i8* %7, i32 %8, i32 %9, i32 %10, i32 %11, double %12) {
%14 = fsub double 1.000000e+00, %12
%15 = sitofp i32 %4 to double
%16 = fdiv double %14, %15
%17 = fsub double %16, %12
%18 = icmp sgt i32 %4, 0
%19 = sext i32 %11 to i64
br i1 %18, label %20, label %114
20: ; preds = %13
%21 = getelementptr inbounds double*, double** %0, i64 %19
%22 = load double*, double** %21
%23 = zext i32 %4 to i64
%24 = icmp ult i32 %4, 4
br i1 %24, label %74, label %25
25: ; preds = %20
%26 = getelementptr double, double* %3, i64 %23
%27 = getelementptr double, double* %2, i64 %23
%28 = getelementptr double, double* %22, i64 %23
%29 = icmp ugt double* %27, %3
%30 = icmp ugt double* %26, %2
%31 = and i1 %29, %30
%32 = icmp ugt double* %28, %3
%33 = icmp ult double* %22, %26
%34 = and i1 %32, %33
%35 = or i1 %31, %34
br i1 %35, label %74, label %36
36: ; preds = %25
%37 = and i64 %23, 4294967292
%38 = insertelement <2 x double> poison, double %17, i64 0
%39 = shufflevector <2 x double> %38, <2 x double> poison, <2 x i32> zeroinitializer
%40 = insertelement <2 x double> poison, double %17, i64 0
%41 = shufflevector <2 x double> %40, <2 x double> poison, <2 x i32> zeroinitializer
%42 = insertelement <2 x double> poison, double %16, i64 0
%43 = shufflevector <2 x double> %42, <2 x double> poison, <2 x i32> zeroinitializer
%44 = insertelement <2 x double> poison, double %16, i64 0
%45 = shufflevector <2 x double> %44, <2 x double> poison, <2 x i32> zeroinitializer
br label %46
46: ; preds = %46, %36
%47 = phi i64 [ 0, %36 ], [ %70, %46 ]
%48 = getelementptr inbounds double, double* %2, i64 %47
%49 = bitcast double* %48 to <2 x double>*
%50 = load <2 x double>, <2 x double>* %49
%51 = getelementptr inbounds double, double* %48, i64 2
%52 = bitcast double* %51 to <2 x double>*
%53 = load <2 x double>, <2 x double>* %52
%54 = getelementptr inbounds double, double* %22, i64 %47
%55 = bitcast double* %54 to <2 x double>*
%56 = load <2 x double>, <2 x double>* %55
%57 = getelementptr inbounds double, double* %54, i64 2
%58 = bitcast double* %57 to <2 x double>*
%59 = load <2 x double>, <2 x double>* %58
%60 = fneg <2 x double> %56
%61 = fneg <2 x double> %59
%62 = fmul <2 x double> %39, %60
%63 = fmul <2 x double> %41, %61
%64 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %50, <2 x double> %43, <2 x double> %62)
%65 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %53, <2 x double> %45, <2 x double> %63)
%66 = getelementptr inbounds double, double* %3, i64 %47
%67 = bitcast double* %66 to <2 x double>*
store <2 x double> %64, <2 x double>* %67
%68 = getelementptr inbounds double, double* %66, i64 2
%69 = bitcast double* %68 to <2 x double>*
store <2 x double> %65, <2 x double>* %69
%70 = add nuw i64 %47, 4
%71 = icmp eq i64 %70, %37
br i1 %71, label %72, label %46
72: ; preds = %46
%73 = icmp eq i64 %37, %23
br i1 %73, label %114, label %74
74: ; preds = %25, %20, %72
%75 = phi i64 [ 0, %25 ], [ 0, %20 ], [ %37, %72 ]
%76 = xor i64 %75, -1
%77 = and i64 %23, 1
%78 = icmp eq i64 %77, 0
br i1 %78, label %89, label %79
79: ; preds = %74
%80 = getelementptr inbounds double, double* %2, i64 %75
%81 = load double, double* %80
%82 = getelementptr inbounds double, double* %22, i64 %75
%83 = load double, double* %82
%84 = fneg double %83
%85 = fmul double %17, %84
%86 = tail call double @llvm.fmuladd.f64(double %81, double %16, double %85)
%87 = getelementptr inbounds double, double* %3, i64 %75
store double %86, double* %87
%88 = or i64 %75, 1
br label %89
89: ; preds = %79, %74
%90 = phi i64 [ %75, %74 ], [ %88, %79 ]
%91 = sub nsw i64 0, %23
%92 = icmp eq i64 %76, %91
br i1 %92, label %114, label %93
93: ; preds = %89, %93
%94 = phi i64 [ %112, %93 ], [ %90, %89 ]
%95 = getelementptr inbounds double, double* %2, i64 %94
%96 = load double, double* %95
%97 = getelementptr inbounds double, double* %22, i64 %94
%98 = load double, double* %97
%99 = fneg double %98
%100 = fmul double %17, %99
%101 = tail call double @llvm.fmuladd.f64(double %96, double %16, double %100)
%102 = getelementptr inbounds double, double* %3, i64 %94
store double %101, double* %102
%103 = add nuw nsw i64 %94, 1
%104 = getelementptr inbounds double, double* %2, i64 %103
%105 = load double, double* %104
%106 = getelementptr inbounds double, double* %22, i64 %103
%107 = load double, double* %106
%108 = fneg double %107
%109 = fmul double %17, %108
%110 = tail call double @llvm.fmuladd.f64(double %105, double %16, double %109)
%111 = getelementptr inbounds double, double* %3, i64 %103
store double %110, double* %111
%112 = add nuw nsw i64 %94, 2
%113 = icmp eq i64 %112, %23
br i1 %113, label %114, label %93
114: ; preds = %89, %93, %72, %13
%115 = bitcast i8* %7 to %struct.stat_str*
%116 = tail call double %5(double* %3, double* %6, %struct.stat_str* %115, i32 %8, i32 %9, i32 %10)
%117 = getelementptr inbounds double, double* %1, i64 %19
%118 = load double, double* %117
%119 = fcmp olt double %116, %118
br i1 %119, label %120, label %251
120: ; preds = %114
store double %116, double* %117
br i1 %18, label %121, label %251
121: ; preds = %120
%122 = getelementptr inbounds double*, double** %0, i64 %19
%123 = load double*, double** %122
%124 = zext i32 %4 to i64
%125 = icmp eq i32 %4, 1
br i1 %125, label %208, label %126
126: ; preds = %121
%127 = getelementptr double, double* %2, i64 %124
%128 = getelementptr double, double* %123, i64 %124
%129 = getelementptr double, double* %3, i64 %124
%130 = icmp ugt double* %128, %2
%131 = icmp ult double* %123, %127
%132 = and i1 %130, %131
%133 = icmp ugt double* %129, %2
%134 = icmp ugt double* %127, %3
%135 = and i1 %133, %134
%136 = or i1 %132, %135
%137 = icmp ult double* %123, %129
%138 = icmp ugt double* %128, %3
%139 = and i1 %137, %138
%140 = or i1 %136, %139
br i1 %140, label %208, label %141
141: ; preds = %126
%142 = and i64 %124, 4294967294
%143 = add nsw i64 %142, -2
%144 = lshr exact i64 %143, 1
%145 = add nuw i64 %144, 1
%146 = and i64 %145, 1
%147 = icmp eq i64 %143, 0
br i1 %147, label %187, label %148
148: ; preds = %141
%149 = and i64 %145, -2
br label %150
150: ; preds = %150, %148
%151 = phi i64 [ 0, %148 ], [ %184, %150 ]
%152 = phi i64 [ 0, %148 ], [ %185, %150 ]
%153 = getelementptr inbounds double, double* %3, i64 %151
%154 = bitcast double* %153 to <2 x double>*
%155 = load <2 x double>, <2 x double>* %154
%156 = getelementptr inbounds double, double* %123, i64 %151
%157 = bitcast double* %156 to <2 x double>*
%158 = load <2 x double>, <2 x double>* %157
%159 = fsub <2 x double> %155, %158
%160 = getelementptr inbounds double, double* %2, i64 %151
%161 = bitcast double* %160 to <2 x double>*
%162 = load <2 x double>, <2 x double>* %161
%163 = fadd <2 x double> %162, %159
%164 = bitcast double* %160 to <2 x double>*
store <2 x double> %163, <2 x double>* %164
%165 = bitcast double* %153 to <2 x double>*
%166 = load <2 x double>, <2 x double>* %165
%167 = bitcast double* %156 to <2 x double>*
store <2 x double> %166, <2 x double>* %167
%168 = or i64 %151, 2
%169 = getelementptr inbounds double, double* %3, i64 %168
%170 = bitcast double* %169 to <2 x double>*
%171 = load <2 x double>, <2 x double>* %170
%172 = getelementptr inbounds double, double* %123, i64 %168
%173 = bitcast double* %172 to <2 x double>*
%174 = load <2 x double>, <2 x double>* %173
%175 = fsub <2 x double> %171, %174
%176 = getelementptr inbounds double, double* %2, i64 %168
%177 = bitcast double* %176 to <2 x double>*
%178 = load <2 x double>, <2 x double>* %177
%179 = fadd <2 x double> %178, %175
%180 = bitcast double* %176 to <2 x double>*
store <2 x double> %179, <2 x double>* %180
%181 = bitcast double* %169 to <2 x double>*
%182 = load <2 x double>, <2 x double>* %181
%183 = bitcast double* %172 to <2 x double>*
store <2 x double> %182, <2 x double>* %183
%184 = add nuw i64 %151, 4
%185 = add nuw i64 %152, 2
%186 = icmp eq i64 %185, %149
br i1 %186, label %187, label %150
187: ; preds = %150, %141
%188 = phi i64 [ 0, %141 ], [ %184, %150 ]
%189 = icmp eq i64 %146, 0
br i1 %189, label %206, label %190
190: ; preds = %187
%191 = getelementptr inbounds double, double* %3, i64 %188
%192 = bitcast double* %191 to <2 x double>*
%193 = load <2 x double>, <2 x double>* %192
%194 = getelementptr inbounds double, double* %123, i64 %188
%195 = bitcast double* %194 to <2 x double>*
%196 = load <2 x double>, <2 x double>* %195
%197 = fsub <2 x double> %193, %196
%198 = getelementptr inbounds double, double* %2, i64 %188
%199 = bitcast double* %198 to <2 x double>*
%200 = load <2 x double>, <2 x double>* %199
%201 = fadd <2 x double> %200, %197
%202 = bitcast double* %198 to <2 x double>*
store <2 x double> %201, <2 x double>* %202
%203 = bitcast double* %191 to <2 x double>*
%204 = load <2 x double>, <2 x double>* %203
%205 = bitcast double* %194 to <2 x double>*
store <2 x double> %204, <2 x double>* %205
br label %206
206: ; preds = %187, %190
%207 = icmp eq i64 %142, %124
br i1 %207, label %251, label %208
208: ; preds = %126, %121, %206
%209 = phi i64 [ 0, %126 ], [ 0, %121 ], [ %142, %206 ]
%210 = xor i64 %209, -1
%211 = and i64 %124, 1
%212 = icmp eq i64 %211, 0
br i1 %212, label %224, label %213
213: ; preds = %208
%214 = getelementptr inbounds double, double* %3, i64 %209
%215 = load double, double* %214
%216 = getelementptr inbounds double, double* %123, i64 %209
%217 = load double, double* %216
%218 = fsub double %215, %217
%219 = getelementptr inbounds double, double* %2, i64 %209
%220 = load double, double* %219
%221 = fadd double %220, %218
store double %221, double* %219
%222 = load double, double* %214
store double %222, double* %216
%223 = or i64 %209, 1
br label %224
224: ; preds = %213, %208
%225 = phi i64 [ %209, %208 ], [ %223, %213 ]
%226 = sub nsw i64 0, %124
%227 = icmp eq i64 %210, %226
br i1 %227, label %251, label %228
228: ; preds = %224, %228
%229 = phi i64 [ %249, %228 ], [ %225, %224 ]
%230 = getelementptr inbounds double, double* %3, i64 %229
%231 = load double, double* %230
%232 = getelementptr inbounds double, double* %123, i64 %229
%233 = load double, double* %232
%234 = fsub double %231, %233
%235 = getelementptr inbounds double, double* %2, i64 %229
%236 = load double, double* %235
%237 = fadd double %236, %234
store double %237, double* %235
%238 = load double, double* %230
store double %238, double* %232
%239 = add nuw nsw i64 %229, 1
%240 = getelementptr inbounds double, double* %3, i64 %239
%241 = load double, double* %240
%242 = getelementptr inbounds double, double* %123, i64 %239
%243 = load double, double* %242
%244 = fsub double %241, %243
%245 = getelementptr inbounds double, double* %2, i64 %239
%246 = load double, double* %245
%247 = fadd double %246, %244
store double %247, double* %245
%248 = load double, double* %240
store double %248, double* %242
%249 = add nuw nsw i64 %229, 2
%250 = icmp eq i64 %249, %124
br i1 %250, label %251, label %228
251: ; preds = %224, %228, %206, %120, %114
ret double %116
}