float amotry(p, y, psum, ndim, funk, ihi, nfunk, fac)
float **p, *y, *psum, (*funk)(), fac;
int ndim, ihi, *nfunk;
{
  int j;
  float fac1, fac2, ytry, *ptry, *vector();
  void nrerror(), free_vector();
  ptry = vector(1, ndim);
  fac1 = (1.0 - fac) / ndim;
  fac2 = fac1 - fac;
  for (j = 1; j <= ndim; j++)
    ptry[j] = psum[j] * fac1 - p[ihi][j] * fac2;
  ytry = (*funk)(ptry);
  ++(*nfunk);
  if (ytry < y[ihi]) {
    y[ihi] = ytry;
    for (j = 1; j <= ndim; j++) {
      psum[j] += ptry[j] - p[ihi][j];
      p[ihi][j] = ptry[j];
    }
  }
  free_vector(ptry, 1, ndim);
  return ytry;
}


x86 assembly (clang, -O0):
<amotry>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x10(%rbp),%rax
cvtsd2ss %xmm0,%xmm0
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movss  %xmm0,-0x30(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <vector@plt>
mov    %rax,-0x48(%rbp)
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe90(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1204 <amotry+0xe4>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x38(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    119c <amotry+0x7c>
mov    -0x28(%rbp),%rcx
mov    -0x48(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
movss  %xmm0,-0x40(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
movss  -0x40(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    12c9 <amotry+0x1a9>
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     12c4 <amotry+0x1a4>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1254 <amotry+0x134>
jmp    12c9 <amotry+0x1a9>
mov    -0x48(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <free_vector@plt>
movss  -0x40(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<amotry>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
movsd  %xmm0,0x8(%rsp)
mov    %r9d,%r15d
mov    %r8,0x10(%rsp)
mov    %ecx,%r14d
mov    %rdx,%rbx
mov    %rsi,%r12
mov    %rdi,%r13
mov    $0x1,%edi
mov    %ecx,%esi
xor    %eax,%eax
call   1040 <vector@plt>
mov    %rax,%rbp
movslq %r15d,%r15
test   %r14d,%r14d
jle    12f2 <amotry+0x1d2>
movsd  0x8(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
movsd  0xe82(%rip),%xmm1
subsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movaps %xmm0,%xmm1
subss  %xmm2,%xmm1
mov    0x0(%r13,%r15,8),%rax
mov    %r14d,%r8d
lea    0x1(%r8),%rcx
mov    $0x1,%edx
cmp    $0x8,%r14d
jae    1238 <amotry+0x118>
mov    %rdx,%rsi
not    %rsi
test   $0x1,%cl
jne    11e2 <amotry+0xc2>
movss  (%rax,%rdx,4),%xmm2
mulss  %xmm1,%xmm2
movss  (%rbx,%rdx,4),%xmm3
mulss  %xmm0,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,0x0(%rbp,%rdx,4)
add    $0x1,%rdx
add    %rcx,%rsi
je     12f2 <amotry+0x1d2>
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm2
mulss  %xmm1,%xmm2
movss  (%rbx,%rdx,4),%xmm3
mulss  %xmm0,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,0x0(%rbp,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm2
mulss  %xmm1,%xmm2
movss  0x4(%rbx,%rdx,4),%xmm3
mulss  %xmm0,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,0x4(%rbp,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    11f0 <amotry+0xd0>
jmp    12f2 <amotry+0x1d2>
mov    %r12,0x8(%rsp)
mov    %r13,%r12
lea    0x4(%rbp),%rsi
lea    0x0(,%rcx,4),%rdi
add    %rbp,%rdi
lea    0x4(%rbx),%r9
lea    (%rbx,%rcx,4),%r10
lea    0x4(%rax),%r11
lea    (%rax,%rcx,4),%r13
cmp    %r10,%rsi
setb   %r10b
cmp    %rdi,%r9
setb   %r9b
cmp    %r13,%rsi
setb   %sil
cmp    %rdi,%r11
setb   %dil
test   %r9b,%r10b
jne    1516 <amotry+0x3f6>
and    %dil,%sil
mov    %r12,%r13
mov    0x8(%rsp),%r12
jne    11b7 <amotry+0x97>
mov    %r8d,%edi
and    $0xfffffff8,%edi
lea    0x1(%rdi),%rdx
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
xor    %esi,%esi
nop
movups 0x4(%rbx,%rsi,4),%xmm4
movups 0x14(%rbx,%rsi,4),%xmm5
movups 0x4(%rax,%rsi,4),%xmm6
movups 0x14(%rax,%rsi,4),%xmm7
mulps  %xmm2,%xmm6
mulps  %xmm2,%xmm7
mulps  %xmm3,%xmm4
subps  %xmm6,%xmm4
mulps  %xmm3,%xmm5
subps  %xmm7,%xmm5
movups %xmm4,0x4(%rbp,%rsi,4)
movups %xmm5,0x14(%rbp,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rdi
jne    12b0 <amotry+0x190>
cmp    %rdi,%r8
jne    11b7 <amotry+0x97>
mov    %rbp,%rdi
xor    %eax,%eax
call   *0x10(%rsp)
mov    0x50(%rsp),%rax
addl   $0x1,(%rax)
movaps %xmm0,%xmm2
movss  (%r12,%r15,4),%xmm0
ucomiss %xmm2,%xmm0
jbe    14e9 <amotry+0x3c9>
movss  %xmm2,(%r12,%r15,4)
test   %r14d,%r14d
jle    14e9 <amotry+0x3c9>
mov    0x0(%r13,%r15,8),%rax
mov    %r14d,%r8d
lea    0x1(%r8),%rcx
mov    $0x1,%edx
cmp    $0x4,%r14d
jae    13d2 <amotry+0x2b2>
mov    %rdx,%rsi
not    %rsi
test   $0x1,%cl
jne    136e <amotry+0x24e>
movss  0x0(%rbp,%rdx,4),%xmm0
subss  (%rax,%rdx,4),%xmm0
addss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,(%rbx,%rdx,4)
movss  0x0(%rbp,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
add    $0x1,%rdx
add    %rcx,%rsi
je     14e9 <amotry+0x3c9>
nopw   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rdx,4),%xmm0
subss  (%rax,%rdx,4),%xmm0
addss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,(%rbx,%rdx,4)
movss  0x0(%rbp,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
movss  0x4(%rbp,%rdx,4),%xmm0
subss  0x4(%rax,%rdx,4),%xmm0
addss  0x4(%rbx,%rdx,4),%xmm0
movss  %xmm0,0x4(%rbx,%rdx,4)
movss  0x4(%rbp,%rdx,4),%xmm0
movss  %xmm0,0x4(%rax,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1380 <amotry+0x260>
jmp    14e9 <amotry+0x3c9>
lea    0x4(%rbx),%r15
lea    (%rbx,%rcx,4),%r9
lea    0x4(%rax),%r10
lea    (%rax,%rcx,4),%r11
lea    0x0(,%rcx,4),%rdi
add    %rbp,%rdi
mov    %rbp,%rsi
add    $0x4,%rsi
cmp    %r11,%r15
setb   %r12b
cmp    %r9,%r10
setb   %r13b
cmp    %rdi,%r15
setb   %r15b
cmp    %r9,%rsi
setb   %r9b
cmp    %rdi,%r10
setb   %dil
cmp    %r11,%rsi
setb   %r10b
test   %r13b,%r12b
jne    133f <amotry+0x21f>
and    %r9b,%r15b
jne    133f <amotry+0x21f>
and    %r10b,%dil
jne    133f <amotry+0x21f>
mov    %r8d,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     152c <amotry+0x40c>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0x1,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x0(%rbp,%rdi,4),%xmm0
movups (%rax,%rdi,4),%xmm1
subps  %xmm1,%xmm0
movups (%rbx,%rdi,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rbx,%rdi,4)
movups 0x0(%rbp,%rdi,4),%xmm0
movups %xmm0,(%rax,%rdi,4)
movups 0x10(%rbp,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
subps  %xmm1,%xmm0
movups 0x10(%rbx,%rdi,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x10(%rbx,%rdi,4)
movups 0x10(%rbp,%rdi,4),%xmm0
movups %xmm0,0x10(%rax,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1470 <amotry+0x350>
test   $0x1,%r9b
je     14e4 <amotry+0x3c4>
movups 0x0(%rbp,%rdi,4),%xmm0
movups (%rax,%rdi,4),%xmm1
subps  %xmm1,%xmm0
movups (%rbx,%rdi,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rbx,%rdi,4)
movups 0x0(%rbp,%rdi,4),%xmm0
movups %xmm0,(%rax,%rdi,4)
cmp    %rdx,%r8
jne    1523 <amotry+0x403>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %r14d,%edx
xor    %eax,%eax
movss  %xmm2,0x10(%rsp)
call   1030 <free_vector@plt>
movss  0x10(%rsp),%xmm0
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r12,%r13
mov    0x8(%rsp),%r12
jmp    11b7 <amotry+0x97>
or     $0x1,%rdx
jmp    133f <amotry+0x21f>
mov    $0x1,%edi
test   $0x1,%r9b
jne    14c4 <amotry+0x3a4>
jmp    14e4 <amotry+0x3c4>

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

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