#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 sqrt(double);
void scale_eigvec_time(double *restrict out, int tsID, int nts, int npack,
                       const int *restrict pack, const double *restrict weight,
                       double **covar, double **data, double missval,
                       double sum_w) {
  for (int i = 0; i < npack; ++i) {
    double sum = 0;
    for (int j = 0; j < nts; ++j)
      sum += data[j][i] * covar[tsID][j];
    out[pack[i]] = sum;
  }
  double sum = 0;
  for (int i = 0; i < npack; ++i) {
    sum += weight[pack[i]] * out[pack[i]] * out[pack[i]];
  }
  if (sum > 0) {
    sum = sqrt(sum / sum_w);
    for (int i = 0; i < npack; ++i)
      out[pack[i]] /= sum;
  } else {
    for (int i = 0; i < npack; ++i)
      out[pack[i]] = missval;
  }
}


x86 assembly (clang, -O0):
<scale_eigvec_time>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11df <scale_eigvec_time+0xcf>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11b7 <scale_eigvec_time+0xa7>
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1161 <scale_eigvec_time+0x51>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1146 <scale_eigvec_time+0x36>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1259 <scale_eigvec_time+0x149>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    11ee <scale_eigvec_time+0xde>
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    12c8 <scale_eigvec_time+0x1b8>
movsd  -0x58(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12c3 <scale_eigvec_time+0x1b3>
movsd  -0x58(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x60(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1286 <scale_eigvec_time+0x176>
jmp    1308 <scale_eigvec_time+0x1f8>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1303 <scale_eigvec_time+0x1f3>
movsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12cf <scale_eigvec_time+0x1bf>
jmp    1308 <scale_eigvec_time+0x1f8>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scale_eigvec_time>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
test   %ecx,%ecx
jle    1414 <scale_eigvec_time+0x304>
mov    %r8,%r14
mov    %rdi,%r13
mov    %r9,0x10(%rsp)
mov    0x58(%rsp),%rax
movslq %esi,%r9
mov    %ecx,0xc(%rsp)
mov    %ecx,%edi
mov    %edx,%r10d
lea    -0x1(%r10),%r11
mov    %r10d,%r12d
and    $0x3,%r12d
and    $0xfffffffc,%r10d
xor    %esi,%esi
jmp    117c <scale_eigvec_time+0x6c>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm2,%xmm2
movslq (%r14,%rsi,4),%rcx
movsd  %xmm2,0x0(%r13,%rcx,8)
add    $0x1,%rsi
cmp    %rdi,%rsi
je     1232 <scale_eigvec_time+0x122>
test   %edx,%edx
jle    1160 <scale_eigvec_time+0x50>
mov    %rdi,%r8
mov    0x50(%rsp),%rcx
mov    (%rcx,%r9,8),%rcx
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
cmp    $0x3,%r11
jb     11f8 <scale_eigvec_time+0xe8>
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rbx,8),%rbp
mov    0x8(%rax,%rbx,8),%rdi
movsd  0x0(%rbp,%rsi,8),%xmm3
mulsd  (%rcx,%rbx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  (%rdi,%rsi,8),%xmm4
mulsd  0x8(%rcx,%rbx,8),%xmm4
addsd  %xmm3,%xmm4
mov    0x10(%rax,%rbx,8),%rdi
movsd  (%rdi,%rsi,8),%xmm3
mulsd  0x10(%rcx,%rbx,8),%xmm3
mov    0x18(%rax,%rbx,8),%rdi
movsd  (%rdi,%rsi,8),%xmm2
mulsd  0x18(%rcx,%rbx,8),%xmm2
addsd  %xmm4,%xmm3
addsd  %xmm3,%xmm2
add    $0x4,%rbx
cmp    %rbx,%r10
jne    11a0 <scale_eigvec_time+0x90>
test   %r12,%r12
mov    %r8,%rdi
je     1164 <scale_eigvec_time+0x54>
lea    (%rcx,%rbx,8),%rcx
lea    (%rax,%rbx,8),%rbx
xor    %r15d,%r15d
nop
mov    (%rbx,%r15,8),%r8
movsd  (%r8,%rsi,8),%xmm3
mulsd  (%rcx,%r15,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%r15
cmp    %r15,%r12
jne    1210 <scale_eigvec_time+0x100>
jmp    1164 <scale_eigvec_time+0x54>
mov    0xc(%rsp),%ebx
test   %ebx,%ebx
mov    0x10(%rsp),%rsi
jle    1414 <scale_eigvec_time+0x304>
mov    %rdi,%rbp
add    $0xffffffffffffffff,%rbp
je     1306 <scale_eigvec_time+0x1f6>
mov    %edi,%ecx
and    $0xfffffffe,%ecx
xorpd  %xmm2,%xmm2
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movslq (%r14,%rax,4),%rdx
movsd  0x0(%r13,%rdx,8),%xmm3
movsd  (%rsi,%rdx,8),%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm2,%xmm4
movslq 0x4(%r14,%rax,4),%rdx
movsd  0x0(%r13,%rdx,8),%xmm3
movsd  (%rsi,%rdx,8),%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm4,%xmm2
add    $0x2,%rax
cmp    %rax,%rcx
jne    1260 <scale_eigvec_time+0x150>
test   $0x1,%dil
je     12c4 <scale_eigvec_time+0x1b4>
movslq (%r14,%rax,4),%rax
movsd  0x0(%r13,%rax,8),%xmm3
movsd  (%rsi,%rax,8),%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm4,%xmm2
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm2
jbe    12e8 <scale_eigvec_time+0x1d8>
divsd  %xmm1,%xmm2
ucomisd %xmm3,%xmm2
jb     1314 <scale_eigvec_time+0x204>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
test   %ebx,%ebx
jg     132b <scale_eigvec_time+0x21b>
jmp    1414 <scale_eigvec_time+0x304>
test   %ebx,%ebx
jle    1414 <scale_eigvec_time+0x304>
mov    %edi,%eax
and    $0x3,%eax
cmp    $0x3,%rbp
jae    1385 <scale_eigvec_time+0x275>
xor    %ecx,%ecx
jmp    13c8 <scale_eigvec_time+0x2b8>
xor    %eax,%eax
xorpd  %xmm2,%xmm2
test   $0x1,%dil
jne    12a8 <scale_eigvec_time+0x198>
jmp    12c4 <scale_eigvec_time+0x1b4>
movapd %xmm2,%xmm0
mov    %rdi,%r15
call   1030 <sqrt@plt>
mov    %r15,%rdi
test   %ebx,%ebx
jle    1414 <scale_eigvec_time+0x304>
test   %rbp,%rbp
je     13f6 <scale_eigvec_time+0x2e6>
mov    %edi,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movslq (%r14,%rax,4),%rdx
movsd  0x0(%r13,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
movslq 0x4(%r14,%rax,4),%rdx
movsd  0x0(%r13,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1340 <scale_eigvec_time+0x230>
test   $0x1,%dil
jne    13fe <scale_eigvec_time+0x2ee>
jmp    1414 <scale_eigvec_time+0x304>
and    $0xfffffffc,%edi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movslq (%r14,%rcx,4),%rdx
movsd  %xmm0,0x0(%r13,%rdx,8)
movslq 0x4(%r14,%rcx,4),%rdx
movsd  %xmm0,0x0(%r13,%rdx,8)
movslq 0x8(%r14,%rcx,4),%rdx
movsd  %xmm0,0x0(%r13,%rdx,8)
movslq 0xc(%r14,%rcx,4),%rdx
movsd  %xmm0,0x0(%r13,%rdx,8)
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    1390 <scale_eigvec_time+0x280>
test   %rax,%rax
je     1414 <scale_eigvec_time+0x304>
lea    (%r14,%rcx,4),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq (%rcx,%rdx,4),%rsi
movsd  %xmm0,0x0(%r13,%rsi,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    13e0 <scale_eigvec_time+0x2d0>
jmp    1414 <scale_eigvec_time+0x304>
xor    %eax,%eax
test   $0x1,%dil
je     1414 <scale_eigvec_time+0x304>
movslq (%r14,%rax,4),%rax
movsd  0x0(%r13,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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