void update_x_k(double *A, double *b, double *x, int neq, int m, int n,
                double *w, double *wa, double *alpha, double awa, int k,
                double *conv) {
  double alpha_old = alpha[k];
  double ax = 0, fact;
  for (int j = 0; j < n; j++) {
    ax += A[k + j * m] * x[j];
    wa[j] = w[j] * A[k + j * m];
  }
  conv[k] = (ax - b[k]) / awa;
  fact = conv[k];
  if (k >= neq) {
    alpha[k] += conv[k];
    if (alpha[k] < 0)
      alpha[k] = 0;
    fact = alpha[k] - alpha_old;
  }
  for (int j = 0; j < n; j++) {
    x[j] -= wa[j] * fact;
  }
}


x86 assembly (clang, -O0):
<update_x_k>:
push   %rbp
mov    %rsp,%rbp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    0x20(%rbp),%rax
movslq 0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11d7 <update_x_k+0xd7>
mov    -0x8(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1154 <update_x_k+0x54>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq 0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0x30(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq 0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq 0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jl     1275 <update_x_k+0x175>
mov    0x30(%rbp),%rax
movslq 0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq 0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq 0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    125e <update_x_k+0x15e>
mov    0x20(%rbp),%rax
movslq 0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq 0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12d9 <update_x_k+0x1d9>
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    127c <update_x_k+0x17c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<update_x_k>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x58(%rsp),%rbp
mov    0x50(%rsp),%eax
mov    0x48(%rsp),%rbx
mov    0x40(%rsp),%r12
movslq %eax,%r11
movsd  (%rbx,%r11,8),%xmm2
mov    %r9d,%r10d
test   %r9d,%r9d
jle    1144 <update_x_k+0x44>
mov    0x38(%rsp),%r13
movslq %r8d,%r8
cmp    $0x1,%r9d
jne    114d <update_x_k+0x4d>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
jmp    11bf <update_x_k+0xbf>
xorpd  %xmm1,%xmm1
jmp    11f6 <update_x_k+0xf6>
mov    %r10d,%ebx
and    $0xfffffffe,%ebx
lea    (%rdi,%r8,8),%rbp
lea    (%r8,%r8,1),%r14
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    %r11,%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%r15,8),%xmm3
movsd  (%rdx,%rax,8),%xmm4
mulsd  %xmm3,%xmm4
mulsd  0x0(%r13,%rax,8),%xmm3
addsd  %xmm1,%xmm4
movsd  %xmm3,(%r12,%rax,8)
movsd  0x0(%rbp,%r15,8),%xmm3
movsd  0x8(%rdx,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm4,%xmm1
mulsd  0x8(%r13,%rax,8),%xmm3
movsd  %xmm3,0x8(%r12,%rax,8)
add    $0x2,%rax
add    %r14,%r15
cmp    %rax,%rbx
jne    1170 <update_x_k+0x70>
test   $0x1,%r10b
mov    0x48(%rsp),%rbx
mov    0x58(%rsp),%rbp
je     11f6 <update_x_k+0xf6>
imul   %rax,%r8
add    %r11,%r8
movsd  (%rdi,%r8,8),%xmm3
movsd  (%rdx,%rax,8),%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
mulsd  0x0(%r13,%rax,8),%xmm3
movsd  %xmm3,(%r12,%rax,8)
subsd  (%rsi,%r11,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%r11,8)
cmp    %ecx,%r11d
jl     1228 <update_x_k+0x128>
addsd  (%rbx,%r11,8),%xmm1
xorpd  %xmm0,%xmm0
maxsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%r11,8)
subsd  %xmm2,%xmm0
movapd %xmm0,%xmm1
test   %r9d,%r9d
jle    13a5 <update_x_k+0x2a5>
cmp    $0x4,%r9d
jb     124d <update_x_k+0x14d>
lea    (%r12,%r10,8),%rax
cmp    %rdx,%rax
jbe    12c1 <update_x_k+0x1c1>
lea    (%rdx,%r10,8),%rax
cmp    %r12,%rax
jbe    12c1 <update_x_k+0x1c1>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
test   $0x1,%r10b
je     1277 <update_x_k+0x177>
movsd  (%rdx,%rcx,8),%xmm0
movsd  (%r12,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
or     $0x1,%rcx
add    %r10,%rax
je     13a5 <update_x_k+0x2a5>
movsd  (%r12,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  (%rdx,%rcx,8),%xmm2
subsd  %xmm0,%xmm2
movsd  0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm2,(%rdx,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r10
jne    1280 <update_x_k+0x180>
jmp    13a5 <update_x_k+0x2a5>
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rcx),%rax
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rax,%rax
je     13b0 <update_x_k+0x2b0>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %eax,%eax
movupd (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
movupd (%rdx,%rax,8),%xmm4
subpd  %xmm2,%xmm4
movupd 0x10(%rdx,%rax,8),%xmm2
movupd 0x20(%rdx,%rax,8),%xmm5
movupd 0x30(%rdx,%rax,8),%xmm6
mulpd  %xmm0,%xmm3
subpd  %xmm3,%xmm2
movupd %xmm4,(%rdx,%rax,8)
movupd %xmm2,0x10(%rdx,%rax,8)
movupd 0x20(%r12,%rax,8),%xmm2
movupd 0x30(%r12,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
subpd  %xmm2,%xmm5
mulpd  %xmm0,%xmm3
subpd  %xmm3,%xmm6
movupd %xmm5,0x20(%rdx,%rax,8)
movupd %xmm6,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    12f0 <update_x_k+0x1f0>
test   $0x1,%sil
je     139c <update_x_k+0x29c>
movupd (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
movupd (%rdx,%rax,8),%xmm4
movupd 0x10(%rdx,%rax,8),%xmm5
mulpd  %xmm0,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm0,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,(%rdx,%rax,8)
movupd %xmm5,0x10(%rdx,%rax,8)
cmp    %r10,%rcx
jne    124f <update_x_k+0x14f>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
test   $0x1,%sil
jne    1369 <update_x_k+0x269>
jmp    139c <update_x_k+0x29c>

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

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