void update_center(double (*c)[11], int *ks, int k) {
  int i;
  double mx, my, xx, yy, xy, det, invxx, invyy, invxy;
  for (i = 0; i < k; i++) {
    mx = c[i][0] / ks[i];
    my = c[i][1] / ks[i];
    xx = c[i][2] / ks[i] - mx * mx;
    yy = c[i][3] / ks[i] - my * my;
    xy = c[i][4] / ks[i] - mx * my;
    det = xx * yy - xy * xy;
    invxx = yy / det;
    invyy = xx / det;
    invxy = -xy / det;
    c[i][5] = mx;
    c[i][6] = my;
    c[i][7] = det;
    c[i][8] = invxx;
    c[i][9] = invyy;
    c[i][10] = invxy;
  }
}


x86 assembly (clang, -O0):
<update_center>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    138e <update_center+0x28e>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x58,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x58,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x58,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
divsd  %xmm0,%xmm1
movsd  -0x20(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x58,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
divsd  %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x58,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
divsd  %xmm0,%xmm1
movsd  -0x20(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x30(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x58,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x58,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x58,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x38(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x58,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x40(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x58,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x48(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x58,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x50(%rax)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1116 <update_center+0x16>
pop    %rbp
ret

x86 assembly (clang, -O2):
<update_center>:
test   %edx,%edx
jle    12d8 <update_center+0x1d8>
mov    %edx,%r8d
cmp    $0x1,%edx
jne    1117 <update_center+0x17>
xor    %ecx,%ecx
jmp    121f <update_center+0x11f>
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
xor    %edx,%edx
movapd 0xed9(%rip),%xmm0
mov    %rdi,%rax
nopw   0x0(%rax,%rax,1)
movsd  (%rax),%xmm3
movhpd 0x58(%rax),%xmm3
movsd  0x8(%rax),%xmm2
cvtdq2pd (%rsi,%rdx,4),%xmm4
movsd  0x10(%rax),%xmm1
divpd  %xmm4,%xmm3
movhpd 0x60(%rax),%xmm2
divpd  %xmm4,%xmm2
movhpd 0x68(%rax),%xmm1
divpd  %xmm4,%xmm1
movapd %xmm2,%xmm5
movapd %xmm3,%xmm6
mulpd  %xmm2,%xmm6
movapd %xmm3,%xmm7
unpcklpd %xmm2,%xmm7
movhlps %xmm3,%xmm2
mulpd  %xmm3,%xmm3
subpd  %xmm3,%xmm1
movsd  0x18(%rax),%xmm3
movhpd 0x70(%rax),%xmm3
divpd  %xmm4,%xmm3
mulpd  %xmm5,%xmm5
subpd  %xmm5,%xmm3
movsd  0x20(%rax),%xmm5
movhpd 0x78(%rax),%xmm5
divpd  %xmm4,%xmm5
subpd  %xmm6,%xmm5
movapd %xmm5,%xmm4
xorpd  %xmm0,%xmm4
mulpd  %xmm5,%xmm5
movapd %xmm1,%xmm6
mulpd  %xmm3,%xmm6
subpd  %xmm5,%xmm6
divpd  %xmm6,%xmm3
divpd  %xmm6,%xmm1
divpd  %xmm6,%xmm4
movupd %xmm7,0x28(%rax)
movups %xmm2,0x80(%rax)
movapd %xmm6,%xmm2
unpcklpd %xmm3,%xmm2
movupd %xmm2,0x38(%rax)
movhlps %xmm6,%xmm3
movups %xmm3,0x90(%rax)
movapd %xmm1,%xmm2
unpcklpd %xmm4,%xmm2
movupd %xmm2,0x48(%rax)
movhlps %xmm1,%xmm4
movups %xmm4,0xa0(%rax)
add    $0x2,%rdx
add    $0xb0,%rax
cmp    %rdx,%rcx
jne    1130 <update_center+0x30>
cmp    %r8,%rcx
je     12d8 <update_center+0x1d8>
imul   $0x58,%rcx,%rax
add    %rdi,%rax
add    $0x50,%rax
movapd 0xdce(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorps  %xmm1,%xmm1
cvtsi2sdl (%rsi,%rcx,4),%xmm1
movsd  -0x30(%rax),%xmm2
divsd  %xmm1,%xmm2
unpcklpd %xmm1,%xmm1
movupd -0x50(%rax),%xmm3
movupd -0x40(%rax),%xmm4
divpd  %xmm1,%xmm3
divpd  %xmm1,%xmm4
movapd %xmm3,%xmm1
movapd %xmm3,%xmm5
movupd %xmm3,-0x28(%rax)
xorpd  %xmm0,%xmm3
mulpd  %xmm1,%xmm1
subpd  %xmm1,%xmm4
unpckhpd %xmm5,%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm2,%xmm5
movapd %xmm5,%xmm1
xorpd  %xmm0,%xmm1
mulsd  %xmm5,%xmm5
movapd %xmm4,%xmm2
unpckhpd %xmm4,%xmm2
mulsd  %xmm4,%xmm2
subsd  %xmm5,%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm2,-0x18(%rax)
unpcklpd %xmm2,%xmm2
shufpd $0x1,%xmm4,%xmm4
divpd  %xmm2,%xmm4
movupd %xmm4,-0x10(%rax)
movsd  %xmm1,(%rax)
add    $0x1,%rcx
add    $0x58,%rax
cmp    %rcx,%r8
jne    1240 <update_center+0x140>
ret

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

LLVM IR (-O2):
define void @update_center([11 x double]* nocapture %0, i32* nocapture %1, i32 %2) {
%4 = icmp sgt i32 %2, 0
br i1 %4, label %5, label %131
5: ; preds = %3
%6 = zext i32 %2 to i64
%7 = icmp eq i32 %2, 1
br i1 %7, label %88, label %8
8: ; preds = %5
%9 = and i64 %6, 4294967294
br label %10
10: ; preds = %10, %8
%11 = phi i64 [ 0, %8 ], [ %84, %10 ]
%12 = or i64 %11, 1
%13 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %11, i64 0
%14 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %12, i64 0
%15 = load double, double* %13
%16 = load double, double* %14
%17 = insertelement <2 x double> poison, double %15, i64 0
%18 = insertelement <2 x double> %17, double %16, i64 1
%19 = getelementptr inbounds i32, i32* %1, i64 %11
%20 = bitcast i32* %19 to <2 x i32>*
%21 = load <2 x i32>, <2 x i32>* %20
%22 = sitofp <2 x i32> %21 to <2 x double>
%23 = fdiv <2 x double> %18, %22
%24 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %11, i64 1
%25 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %12, i64 1
%26 = load double, double* %24
%27 = load double, double* %25
%28 = insertelement <2 x double> poison, double %26, i64 0
%29 = insertelement <2 x double> %28, double %27, i64 1
%30 = fdiv <2 x double> %29, %22
%31 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %11, i64 2
%32 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %12, i64 2
%33 = load double, double* %31
%34 = load double, double* %32
%35 = insertelement <2 x double> poison, double %33, i64 0
%36 = insertelement <2 x double> %35, double %34, i64 1
%37 = fdiv <2 x double> %36, %22
%38 = fneg <2 x double> %23
%39 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %38, <2 x double> %23, <2 x double> %37)
%40 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %11, i64 3
%41 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %12, i64 3
%42 = load double, double* %40
%43 = load double, double* %41
%44 = insertelement <2 x double> poison, double %42, i64 0
%45 = insertelement <2 x double> %44, double %43, i64 1
%46 = fdiv <2 x double> %45, %22
%47 = fneg <2 x double> %30
%48 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %47, <2 x double> %30, <2 x double> %46)
%49 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %11, i64 4
%50 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %12, i64 4
%51 = load double, double* %49
%52 = load double, double* %50
%53 = insertelement <2 x double> poison, double %51, i64 0
%54 = insertelement <2 x double> %53, double %52, i64 1
%55 = fdiv <2 x double> %54, %22
%56 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %38, <2 x double> %30, <2 x double> %55)
%57 = fneg <2 x double> %56
%58 = fmul <2 x double> %56, %57
%59 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %39, <2 x double> %48, <2 x double> %58)
%60 = fdiv <2 x double> %48, %59
%61 = fdiv <2 x double> %39, %59
%62 = fdiv <2 x double> %57, %59
%63 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %11, i64 5
%64 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %12, i64 5
%65 = extractelement <2 x double> %23, i64 0
store double %65, double* %63
%66 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %11, i64 6
%67 = extractelement <2 x double> %30, i64 0
store double %67, double* %66
%68 = shufflevector <2 x double> %23, <2 x double> %30, <2 x i32> <i32 1, i32 3>
%69 = bitcast double* %64 to <2 x double>*
store <2 x double> %68, <2 x double>* %69
%70 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %11, i64 7
%71 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %12, i64 7
%72 = extractelement <2 x double> %59, i64 0
store double %72, double* %70
%73 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %11, i64 8
%74 = extractelement <2 x double> %60, i64 0
store double %74, double* %73
%75 = shufflevector <2 x double> %59, <2 x double> %60, <2 x i32> <i32 1, i32 3>
%76 = bitcast double* %71 to <2 x double>*
store <2 x double> %75, <2 x double>* %76
%77 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %11, i64 9
%78 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %12, i64 9
%79 = extractelement <2 x double> %61, i64 0
store double %79, double* %77
%80 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %11, i64 10
%81 = extractelement <2 x double> %62, i64 0
store double %81, double* %80
%82 = shufflevector <2 x double> %61, <2 x double> %62, <2 x i32> <i32 1, i32 3>
%83 = bitcast double* %78 to <2 x double>*
store <2 x double> %82, <2 x double>* %83
%84 = add nuw i64 %11, 2
%85 = icmp eq i64 %84, %9
br i1 %85, label %86, label %10
86: ; preds = %10
%87 = icmp eq i64 %9, %6
br i1 %87, label %131, label %88
88: ; preds = %5, %86
%89 = phi i64 [ 0, %5 ], [ %9, %86 ]
br label %90
90: ; preds = %88, %90
%91 = phi i64 [ %129, %90 ], [ %89, %88 ]
%92 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %91, i64 0
%93 = getelementptr inbounds i32, i32* %1, i64 %91
%94 = load i32, i32* %93
%95 = sitofp i32 %94 to double
%96 = bitcast double* %92 to <2 x double>*
%97 = load <2 x double>, <2 x double>* %96
%98 = insertelement <2 x double> poison, double %95, i64 0
%99 = shufflevector <2 x double> %98, <2 x double> poison, <2 x i32> zeroinitializer
%100 = fdiv <2 x double> %97, %99
%101 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %91, i64 2
%102 = bitcast double* %101 to <2 x double>*
%103 = load <2 x double>, <2 x double>* %102
%104 = fdiv <2 x double> %103, %99
%105 = fneg <2 x double> %100
%106 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %105, <2 x double> %100, <2 x double> %104)
%107 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %91, i64 4
%108 = load double, double* %107
%109 = fdiv double %108, %95
%110 = extractelement <2 x double> %100, i64 1
%111 = extractelement <2 x double> %105, i64 0
%112 = tail call double @llvm.fmuladd.f64(double %111, double %110, double %109)
%113 = fneg double %112
%114 = fmul double %112, %113
%115 = extractelement <2 x double> %106, i64 0
%116 = extractelement <2 x double> %106, i64 1
%117 = tail call double @llvm.fmuladd.f64(double %115, double %116, double %114)
%118 = insertelement <2 x double> poison, double %117, i64 0
%119 = shufflevector <2 x double> %118, <2 x double> poison, <2 x i32> zeroinitializer
%120 = fdiv <2 x double> %106, %119
%121 = fdiv double %113, %117
%122 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %91, i64 5
%123 = bitcast double* %122 to <2 x double>*
store <2 x double> %100, <2 x double>* %123
%124 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %91, i64 7
store double %117, double* %124
%125 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %91, i64 8
%126 = shufflevector <2 x double> %120, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%127 = bitcast double* %125 to <2 x double>*
store <2 x double> %126, <2 x double>* %127
%128 = getelementptr inbounds [11 x double], [11 x double]* %0, i64 %91, i64 10
store double %121, double* %128
%129 = add nuw nsw i64 %91, 1
%130 = icmp eq i64 %129, %6
br i1 %130, label %131, label %90
131: ; preds = %90, %86, %3
ret void
}