void residual_eq(double *param, double *fixed, int *lev, int *fact, int *sumlev,
                 double *observed, int *dimdata, double *RSS) {
  int i, j, k;
  int lentot = (dimdata[0]) * (dimdata[1]);
  double resid;
  double parameters[sumlev[2]];
  double estimated[dimdata[1]];
  for (i = 0; i < sumlev[1]; i++)
    if (!isnan(fixed[i]))
      parameters[i] = fixed[i];
    else
      parameters[i] = param[i];
  j = sumlev[1];
  for (i = 0; i < *fact; i++) {
    for (k = 0; k < lev[i]; k++) {
      parameters[j] = param[sumlev[1] + i];
      j++;
    }
  }
  averaging(parameters, lev, fact, sumlev, estimated);
  j = 0;
  for (i = 0; i < lentot; i++) {
    if (!isnan(observed[i])) {
      resid = estimated[j] - observed[i];
      *RSS += resid * resid;
    }
    if (i == ((dimdata[0]) * (j + 1) - 1))
      j++;
  }
}


x86 assembly (clang, -O0):
<residual_eq>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
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    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x10(%rbp),%rcx
mov    (%rcx),%eax
mov    0x4(%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%eax
mov    %rsp,%rcx
mov    %rcx,-0x50(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x70(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
mov    0x10(%rbp),%rax
mov    0x4(%rax),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    1226 <residual_eq+0x106>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0x1,%al
call   1030 <isnan@plt>
cmp    $0x0,%eax
jne    11f9 <residual_eq+0xd9>
mov    -0x70(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1213 <residual_eq+0xf3>
mov    -0x70(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1218 <residual_eq+0xf8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ad <residual_eq+0x8d>
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    12ae <residual_eq+0x18e>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    129b <residual_eq+0x17b>
mov    -0x70(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    0x4(%rdx),%edx
add    -0x34(%rbp),%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    124d <residual_eq+0x12d>
jmp    12a0 <residual_eq+0x180>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1237 <residual_eq+0x117>
mov    -0x68(%rbp),%r8
mov    -0x70(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    $0x0,%al
call   1040 <averaging@plt>
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1376 <residual_eq+0x256>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0x1,%al
call   1030 <isnan@plt>
cmp    $0x0,%eax
jne    133d <residual_eq+0x21d>
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x38(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1363 <residual_eq+0x243>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1368 <residual_eq+0x248>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12d7 <residual_eq+0x1b7>
mov    -0x50(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<residual_eq>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,-0x58(%rbp)
mov    %r8,%r13
mov    %rcx,-0x38(%rbp)
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%eax
mov    (%rcx),%ecx
imul   %eax,%ecx
mov    %ecx,-0x2c(%rbp)
mov    0x8(%r8),%ecx
mov    %rsp,%r14
lea    0xf(,%rcx,8),%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%r14
mov    %r14,%rsp
mov    %rsp,%rcx
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rcx,%rsp
mov    0x4(%r8),%eax
test   %eax,%eax
mov    %rdx,-0x48(%rbp)
mov    %rdi,-0x40(%rbp)
jle    11e0 <residual_eq+0xc0>
mov    %rsi,%r12
xor    %ebx,%ebx
mov    %rdi,%r15
jmp    11bf <residual_eq+0x9f>
nopw   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
movsd  %xmm0,(%r14,%rbx,8)
add    $0x1,%rbx
movslq 0x4(%r13),%rax
add    $0x8,%r15
add    $0x8,%r12
cmp    %rax,%rbx
jge    11d8 <residual_eq+0xb8>
movsd  (%r12),%xmm0
mov    $0x1,%al
call   1030 <isnan@plt>
mov    %r12,%rcx
test   %eax,%eax
je     11a0 <residual_eq+0x80>
mov    %r15,%rcx
jmp    11a0 <residual_eq+0x80>
mov    -0x48(%rbp),%rdx
mov    -0x40(%rbp),%rdi
mov    -0x38(%rbp),%rcx
mov    (%rcx),%r11d
test   %r11d,%r11d
jle    1335 <residual_eq+0x215>
movslq %eax,%r10
lea    0x70(%r14),%rcx
mov    %rcx,-0x60(%rbp)
lea    0x10(%r14),%rcx
mov    %rcx,-0x68(%rbp)
xor    %esi,%esi
jmp    121d <residual_eq+0xfd>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %r11,%rsi
je     1335 <residual_eq+0x215>
mov    (%rdx,%rsi,4),%r9d
test   %r9d,%r9d
jle    1210 <residual_eq+0xf0>
lea    (%rsi,%r10,1),%rcx
movsd  (%rdi,%rcx,8),%xmm0
cltq
lea    -0x1(%r9),%r15d
xor    %r12d,%r12d
cmp    $0x3,%r15d
jb     1318 <residual_eq+0x1f8>
add    $0x1,%r15
mov    %r15,%r12
and    $0xfffffffffffffffc,%r12
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r12),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ecx,%ebx
and    $0x3,%ebx
cmp    $0xc,%rdx
jae    1274 <residual_eq+0x154>
xor    %edx,%edx
jmp    12d1 <residual_eq+0x1b1>
and    $0xfffffffffffffffc,%rcx
mov    -0x60(%rbp),%rdx
lea    (%rdx,%rax,8),%r8
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm1,-0x70(%r8,%rdx,8)
movupd %xmm1,-0x60(%r8,%rdx,8)
movupd %xmm1,-0x50(%r8,%rdx,8)
movupd %xmm1,-0x40(%r8,%rdx,8)
movupd %xmm1,-0x30(%r8,%rdx,8)
movupd %xmm1,-0x20(%r8,%rdx,8)
movupd %xmm1,-0x10(%r8,%rdx,8)
movupd %xmm1,(%r8,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1290 <residual_eq+0x170>
test   %rbx,%rbx
je     1304 <residual_eq+0x1e4>
add    %rax,%rdx
mov    -0x68(%rbp),%rcx
lea    (%rcx,%rdx,8),%rcx
shl    $0x5,%rbx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd %xmm1,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbx
jne    12f0 <residual_eq+0x1d0>
add    %r12,%rax
cmp    %r12,%r15
mov    -0x48(%rbp),%rdx
mov    -0x40(%rbp),%rdi
je     1210 <residual_eq+0xf0>
sub    %r12d,%r9d
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%r9d
jne    1320 <residual_eq+0x200>
jmp    1210 <residual_eq+0xf0>
xor    %r15d,%r15d
mov    %r14,%rdi
mov    %rdx,%rsi
mov    -0x38(%rbp),%rdx
mov    %r13,%rcx
mov    -0x50(%rbp),%r8
xor    %eax,%eax
call   1040 <averaging@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
mov    -0x58(%rbp),%r13
jle    13c9 <residual_eq+0x2a9>
mov    0x18(%rbp),%r14
mov    %eax,%r12d
xor    %ebx,%ebx
jmp    137c <residual_eq+0x25c>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbx
mov    %eax,%r15d
cmp    %rbx,%r12
je     13c9 <residual_eq+0x2a9>
movsd  0x0(%r13,%rbx,8),%xmm0
mov    $0x1,%al
call   1030 <isnan@plt>
test   %eax,%eax
jne    13af <residual_eq+0x28f>
movslq %r15d,%rax
mov    -0x50(%rbp),%rcx
movsd  (%rcx,%rax,8),%xmm0
subsd  0x0(%r13,%rbx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  (%r14),%xmm0
movsd  %xmm0,(%r14)
lea    0x1(%r15),%eax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
imul   %eax,%ecx
add    $0xffffffff,%ecx
cmp    %rcx,%rbx
je     1370 <residual_eq+0x250>
mov    %r15d,%eax
jmp    1370 <residual_eq+0x250>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @residual_eq(double* %0, double* %1, i32* %2, i32* %3, i32* %4, double* %5, i32* %6, double* %7) {
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32*
%14 = alloca double*
%15 = alloca i32*
%16 = alloca double*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca double
%22 = alloca i8*
%23 = alloca i64
%24 = alloca i64
store double* %0, double** %9
store double* %1, double** %10
store i32* %2, i32** %11
store i32* %3, i32** %12
store i32* %4, i32** %13
store double* %5, double** %14
store i32* %6, i32** %15
store double* %7, double** %16
%25 = load i32*, i32** %15
%26 = getelementptr inbounds i32, i32* %25, i64 0
%27 = load i32, i32* %26
%28 = load i32*, i32** %15
%29 = getelementptr inbounds i32, i32* %28, i64 1
%30 = load i32, i32* %29
%31 = mul nsw i32 %27, %30
store i32 %31, i32* %20
%32 = load i32*, i32** %13
%33 = getelementptr inbounds i32, i32* %32, i64 2
%34 = load i32, i32* %33
%35 = zext i32 %34 to i64
%36 = call i8* @llvm.stacksave()
store i8* %36, i8** %22
%37 = alloca double, i64 %35
store i64 %35, i64* %23
%38 = load i32*, i32** %15
%39 = getelementptr inbounds i32, i32* %38, i64 1
%40 = load i32, i32* %39
%41 = zext i32 %40 to i64
%42 = alloca double, i64 %41
store i64 %41, i64* %24
store i32 0, i32* %17
br label %43
43: ; preds = %76, %8
%44 = load i32, i32* %17
%45 = load i32*, i32** %13
%46 = getelementptr inbounds i32, i32* %45, i64 1
%47 = load i32, i32* %46
%48 = icmp slt i32 %44, %47
br i1 %48, label %49, label %79
49: ; preds = %43
%50 = load double*, double** %10
%51 = load i32, i32* %17
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %50, i64 %52
%54 = load double, double* %53
%55 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %54)
%56 = icmp ne i32 %55, 0
br i1 %56, label %66, label %57
57: ; preds = %49
%58 = load double*, double** %10
%59 = load i32, i32* %17
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds double, double* %58, i64 %60
%62 = load double, double* %61
%63 = load i32, i32* %17
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %37, i64 %64
store double %62, double* %65
br label %75
66: ; preds = %49
%67 = load double*, double** %9
%68 = load i32, i32* %17
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %67, i64 %69
%71 = load double, double* %70
%72 = load i32, i32* %17
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double, double* %37, i64 %73
store double %71, double* %74
br label %75
75: ; preds = %66, %57
br label %76
76: ; preds = %75
%77 = load i32, i32* %17
%78 = add nsw i32 %77, 1
store i32 %78, i32* %17
br label %43
79: ; preds = %43
%80 = load i32*, i32** %13
%81 = getelementptr inbounds i32, i32* %80, i64 1
%82 = load i32, i32* %81
store i32 %82, i32* %18
store i32 0, i32* %17
br label %83
83: ; preds = %116, %79
%84 = load i32, i32* %17
%85 = load i32*, i32** %12
%86 = load i32, i32* %85
%87 = icmp slt i32 %84, %86
br i1 %87, label %88, label %119
88: ; preds = %83
store i32 0, i32* %19
br label %89
89: ; preds = %112, %88
%90 = load i32, i32* %19
%91 = load i32*, i32** %11
%92 = load i32, i32* %17
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i32, i32* %91, i64 %93
%95 = load i32, i32* %94
%96 = icmp slt i32 %90, %95
br i1 %96, label %97, label %115
97: ; preds = %89
%98 = load double*, double** %9
%99 = load i32*, i32** %13
%100 = getelementptr inbounds i32, i32* %99, i64 1
%101 = load i32, i32* %100
%102 = load i32, i32* %17
%103 = add nsw i32 %101, %102
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double, double* %98, i64 %104
%106 = load double, double* %105
%107 = load i32, i32* %18
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double, double* %37, i64 %108
store double %106, double* %109
%110 = load i32, i32* %18
%111 = add nsw i32 %110, 1
store i32 %111, i32* %18
br label %112
112: ; preds = %97
%113 = load i32, i32* %19
%114 = add nsw i32 %113, 1
store i32 %114, i32* %19
br label %89
115: ; preds = %89
br label %116
116: ; preds = %115
%117 = load i32, i32* %17
%118 = add nsw i32 %117, 1
store i32 %118, i32* %17
br label %83
119: ; preds = %83
%120 = load i32*, i32** %11
%121 = load i32*, i32** %12
%122 = load i32*, i32** %13
%123 = call i32 (double*, i32*, i32*, i32*, double*, ...) bitcast (i32 (...)* @averaging to i32 (double*, i32*, i32*, i32*, double*, ...)*)(double* %37, i32* %120, i32* %121, i32* %122, double* %42)
store i32 0, i32* %18
store i32 0, i32* %17
br label %124
124: ; preds = %166, %119
%125 = load i32, i32* %17
%126 = load i32, i32* %20
%127 = icmp slt i32 %125, %126
br i1 %127, label %128, label %169
128: ; preds = %124
%129 = load double*, double** %14
%130 = load i32, i32* %17
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds double, double* %129, i64 %131
%133 = load double, double* %132
%134 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %133)
%135 = icmp ne i32 %134, 0
br i1 %135, label %152, label %136
136: ; preds = %128
%137 = load i32, i32* %18
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %42, i64 %138
%140 = load double, double* %139
%141 = load double*, double** %14
%142 = load i32, i32* %17
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %141, i64 %143
%145 = load double, double* %144
%146 = fsub double %140, %145
store double %146, double* %21
%147 = load double, double* %21
%148 = load double, double* %21
%149 = load double*, double** %16
%150 = load double, double* %149
%151 = call double @llvm.fmuladd.f64(double %147, double %148, double %150)
store double %151, double* %149
br label %152
152: ; preds = %136, %128
%153 = load i32, i32* %17
%154 = load i32*, i32** %15
%155 = getelementptr inbounds i32, i32* %154, i64 0
%156 = load i32, i32* %155
%157 = load i32, i32* %18
%158 = add nsw i32 %157, 1
%159 = mul nsw i32 %156, %158
%160 = sub nsw i32 %159, 1
%161 = icmp eq i32 %153, %160
br i1 %161, label %162, label %165
162: ; preds = %152
%163 = load i32, i32* %18
%164 = add nsw i32 %163, 1
store i32 %164, i32* %18
br label %165
165: ; preds = %162, %152
br label %166
166: ; preds = %165
%167 = load i32, i32* %17
%168 = add nsw i32 %167, 1
store i32 %168, i32* %17
br label %124
169: ; preds = %124
%170 = load i8*, i8** %22
ret void
}

LLVM IR (-O2):
define void @residual_eq(double* nocapture %0, double* nocapture %1, i32* %2, i32* %3, i32* %4, double* nocapture %5, i32* nocapture %6, double* nocapture %7) {
%9 = load i32, i32* %6
%10 = getelementptr inbounds i32, i32* %6, i64 1
%11 = load i32, i32* %10
%12 = mul i32 %11, %9
%13 = getelementptr inbounds i32, i32* %4, i64 2
%14 = load i32, i32* %13
%15 = zext i32 %14 to i64
%16 = alloca double, i64 %15
%17 = zext i32 %11 to i64
%18 = alloca double, i64 %17
%19 = getelementptr inbounds i32, i32* %4, i64 1
%20 = load i32, i32* %19
%21 = icmp sgt i32 %20, 0
br i1 %21, label %29, label %22
22: ; preds = %29, %8
%23 = phi i32 [ %20, %8 ], [ %40, %29 ]
%24 = load i32, i32* %3
%25 = icmp sgt i32 %24, 0
br i1 %25, label %26, label %135
26: ; preds = %22
%27 = sext i32 %23 to i64
%28 = zext i32 %24 to i64
br label %43
29: ; preds = %8, %29
%30 = phi i64 [ %39, %29 ], [ 0, %8 ]
%31 = getelementptr inbounds double, double* %1, i64 %30
%32 = load double, double* %31
%33 = tail call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %32)
%34 = icmp eq i32 %33, 0
%35 = getelementptr inbounds double, double* %0, i64 %30
%36 = select i1 %34, double* %31, double* %35
%37 = load double, double* %36
%38 = getelementptr inbounds double, double* %16, i64 %30
store double %37, double* %38
%39 = add nuw nsw i64 %30, 1
%40 = load i32, i32* %19
%41 = sext i32 %40 to i64
%42 = icmp slt i64 %39, %41
br i1 %42, label %29, label %22
43: ; preds = %26, %131
%44 = phi i64 [ 0, %26 ], [ %133, %131 ]
%45 = phi i32 [ %23, %26 ], [ %132, %131 ]
%46 = getelementptr inbounds i32, i32* %2, i64 %44
%47 = load i32, i32* %46
%48 = icmp sgt i32 %47, 0
br i1 %48, label %49, label %131
49: ; preds = %43
%50 = add nsw i64 %44, %27
%51 = getelementptr inbounds double, double* %0, i64 %50
%52 = load double, double* %51
%53 = sext i32 %45 to i64
%54 = add i32 %47, -1
%55 = zext i32 %54 to i64
%56 = add nuw nsw i64 %55, 1
%57 = icmp ult i32 %54, 3
br i1 %57, label %118, label %58
58: ; preds = %49
%59 = and i64 %56, 8589934588
%60 = add nsw i64 %59, %53
%61 = trunc i64 %59 to i32
%62 = insertelement <2 x double> poison, double %52, i64 0
%63 = shufflevector <2 x double> %62, <2 x double> poison, <2 x i32> zeroinitializer
%64 = insertelement <2 x double> poison, double %52, i64 0
%65 = shufflevector <2 x double> %64, <2 x double> poison, <2 x i32> zeroinitializer
%66 = add nsw i64 %59, -4
%67 = lshr exact i64 %66, 2
%68 = add nuw nsw i64 %67, 1
%69 = and i64 %68, 3
%70 = icmp ult i64 %66, 12
br i1 %70, label %102, label %71
71: ; preds = %58
%72 = and i64 %68, 9223372036854775804
br label %73
73: ; preds = %73, %71
%74 = phi i64 [ 0, %71 ], [ %99, %73 ]
%75 = phi i64 [ 0, %71 ], [ %100, %73 ]
%76 = add i64 %74, %53
%77 = getelementptr inbounds double, double* %16, i64 %76
%78 = bitcast double* %77 to <2 x double>*
store <2 x double> %63, <2 x double>* %78
%79 = getelementptr inbounds double, double* %77, i64 2
%80 = bitcast double* %79 to <2 x double>*
store <2 x double> %65, <2 x double>* %80
%81 = or i64 %74, 4
%82 = add i64 %81, %53
%83 = getelementptr inbounds double, double* %16, i64 %82
%84 = bitcast double* %83 to <2 x double>*
store <2 x double> %63, <2 x double>* %84
%85 = getelementptr inbounds double, double* %83, i64 2
%86 = bitcast double* %85 to <2 x double>*
store <2 x double> %65, <2 x double>* %86
%87 = or i64 %74, 8
%88 = add i64 %87, %53
%89 = getelementptr inbounds double, double* %16, i64 %88
%90 = bitcast double* %89 to <2 x double>*
store <2 x double> %63, <2 x double>* %90
%91 = getelementptr inbounds double, double* %89, i64 2
%92 = bitcast double* %91 to <2 x double>*
store <2 x double> %65, <2 x double>* %92
%93 = or i64 %74, 12
%94 = add i64 %93, %53
%95 = getelementptr inbounds double, double* %16, i64 %94
%96 = bitcast double* %95 to <2 x double>*
store <2 x double> %63, <2 x double>* %96
%97 = getelementptr inbounds double, double* %95, i64 2
%98 = bitcast double* %97 to <2 x double>*
store <2 x double> %65, <2 x double>* %98
%99 = add nuw i64 %74, 16
%100 = add nuw i64 %75, 4
%101 = icmp eq i64 %100, %72
br i1 %101, label %102, label %73
102: ; preds = %73, %58
%103 = phi i64 [ 0, %58 ], [ %99, %73 ]
%104 = icmp eq i64 %69, 0
br i1 %104, label %116, label %105
105: ; preds = %102, %105
%106 = phi i64 [ %113, %105 ], [ %103, %102 ]
%107 = phi i64 [ %114, %105 ], [ 0, %102 ]
%108 = add i64 %106, %53
%109 = getelementptr inbounds double, double* %16, i64 %108
%110 = bitcast double* %109 to <2 x double>*
store <2 x double> %63, <2 x double>* %110
%111 = getelementptr inbounds double, double* %109, i64 2
%112 = bitcast double* %111 to <2 x double>*
store <2 x double> %65, <2 x double>* %112
%113 = add nuw i64 %106, 4
%114 = add i64 %107, 1
%115 = icmp eq i64 %114, %69
br i1 %115, label %116, label %105
116: ; preds = %105, %102
%117 = icmp eq i64 %56, %59
br i1 %117, label %128, label %118
118: ; preds = %49, %116
%119 = phi i64 [ %53, %49 ], [ %60, %116 ]
%120 = phi i32 [ 0, %49 ], [ %61, %116 ]
br label %121
121: ; preds = %118, %121
%122 = phi i64 [ %125, %121 ], [ %119, %118 ]
%123 = phi i32 [ %126, %121 ], [ %120, %118 ]
%124 = getelementptr inbounds double, double* %16, i64 %122
store double %52, double* %124
%125 = add nsw i64 %122, 1
%126 = add nuw nsw i32 %123, 1
%127 = icmp eq i32 %126, %47
br i1 %127, label %128, label %121
128: ; preds = %121, %116
%129 = phi i64 [ %60, %116 ], [ %125, %121 ]
%130 = trunc i64 %129 to i32
br label %131
131: ; preds = %128, %43
%132 = phi i32 [ %45, %43 ], [ %130, %128 ]
%133 = add nuw nsw i64 %44, 1
%134 = icmp eq i64 %133, %28
br i1 %134, label %135, label %43
135: ; preds = %131, %22
%136 = call i32 (double*, i32*, i32*, i32*, double*, ...) bitcast (i32 (...)* @averaging to i32 (double*, i32*, i32*, i32*, double*, ...)*)(double* %16, i32* %2, i32* %3, i32* %4, double* %18)
%137 = icmp sgt i32 %12, 0
br i1 %137, label %138, label %165
138: ; preds = %135
%139 = zext i32 %12 to i64
br label %140
140: ; preds = %138, %155
%141 = phi i64 [ 0, %138 ], [ %163, %155 ]
%142 = phi i32 [ 0, %138 ], [ %162, %155 ]
%143 = getelementptr inbounds double, double* %5, i64 %141
%144 = load double, double* %143
%145 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %144)
%146 = icmp eq i32 %145, 0
br i1 %146, label %147, label %155
147: ; preds = %140
%148 = sext i32 %142 to i64
%149 = getelementptr inbounds double, double* %18, i64 %148
%150 = load double, double* %149
%151 = load double, double* %143
%152 = fsub double %150, %151
%153 = load double, double* %7
%154 = call double @llvm.fmuladd.f64(double %152, double %152, double %153)
store double %154, double* %7
br label %155
155: ; preds = %147, %140
%156 = load i32, i32* %6
%157 = add nsw i32 %142, 1
%158 = mul nsw i32 %156, %157
%159 = add nsw i32 %158, -1
%160 = zext i32 %159 to i64
%161 = icmp eq i64 %141, %160
%162 = select i1 %161, i32 %157, i32 %142
%163 = add nuw nsw i64 %141, 1
%164 = icmp eq i64 %163, %139
br i1 %164, label %165, label %140
165: ; preds = %155, %135
ret void
}