void solve_tridiagonal_matrix(const double *a, const double *b, double *c,
                              double *x, const int n_x) {
  int i;
  c[0] = c[0] / b[0];
  x[0] = x[0] / b[0];
  for (i = 1; i < n_x; ++i) {
    const double m = 1.0f / (b[i] - a[i] * c[i - 1]);
    c[i] = c[i] * m;
    x[i] = (x[i] - a[i] * x[i - 1]) * m;
  }
  for (i = n_x - 1; i-- > 0;)
    x[i] = x[i] - c[i] * x[i + 1];
}


x86 assembly (clang, -O0):
<solve_tridiagonal_matrix>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1241 <solve_tridiagonal_matrix+0x141>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe52(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    114f <solve_tridiagonal_matrix+0x4f>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x28(%rbp)
cmp    $0x0,%eax
jle    12bb <solve_tridiagonal_matrix+0x1bb>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    124a <solve_tridiagonal_matrix+0x14a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<solve_tridiagonal_matrix>:
push   %r15
push   %r14
push   %rbx
movsd  (%rdx),%xmm0
divsd  (%rsi),%xmm0
movsd  %xmm0,(%rdx)
movsd  (%rcx),%xmm0
divsd  (%rsi),%xmm0
movsd  %xmm0,(%rcx)
cmp    $0x2,%r8d
jl     13b9 <solve_tridiagonal_matrix+0x2b9>
mov    %r8d,%r9d
lea    (%rcx,%r9,8),%rax
cmp    %rdx,%rax
jbe    11a2 <solve_tridiagonal_matrix+0xa2>
lea    (%rdx,%r9,8),%rax
cmp    %rcx,%rax
jbe    11a2 <solve_tridiagonal_matrix+0xa2>
mov    $0x1,%eax
movsd  0xeb7(%rip),%xmm0
nopl   0x0(%rax)
movsd  (%rsi,%rax,8),%xmm1
movsd  (%rdi,%rax,8),%xmm2
mulsd  -0x8(%rdx,%rax,8),%xmm2
subsd  %xmm2,%xmm1
movapd %xmm0,%xmm2
divsd  %xmm1,%xmm2
movsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  (%rcx,%rax,8),%xmm1
movsd  (%rdi,%rax,8),%xmm3
mulsd  -0x8(%rcx,%rax,8),%xmm3
subsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    1150 <solve_tridiagonal_matrix+0x50>
jmp    1208 <solve_tridiagonal_matrix+0x108>
movsd  (%rdx),%xmm1
movsd  (%rcx),%xmm2
mov    $0x1,%eax
movsd  0xe49(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm3
mulsd  (%rdi,%rax,8),%xmm1
subsd  %xmm1,%xmm3
movapd %xmm0,%xmm4
divsd  %xmm3,%xmm4
movsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  (%rcx,%rax,8),%xmm3
mulsd  (%rdi,%rax,8),%xmm2
subsd  %xmm2,%xmm3
mulsd  %xmm4,%xmm3
movsd  %xmm3,(%rcx,%rax,8)
add    $0x1,%rax
movapd %xmm3,%xmm2
cmp    %rax,%r9
jne    11c0 <solve_tridiagonal_matrix+0xc0>
cmp    $0x2,%r8d
jl     13b9 <solve_tridiagonal_matrix+0x2b9>
lea    -0x2(%r8),%edi
add    $0xffffffff,%r8d
cmp    $0x3,%edi
jae    125f <solve_tridiagonal_matrix+0x15f>
mov    %rdi,%r11
test   $0x1,%r11b
jne    1365 <solve_tridiagonal_matrix+0x265>
movsd  (%rdx,%r11,8),%xmm0
mov    %r8d,%eax
mulsd  (%rcx,%rax,8),%xmm0
movsd  (%rcx,%r11,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%r11,8)
lea    -0x1(%r11),%rsi
mov    %r11d,%r8d
test   %r11,%r11
jne    136d <solve_tridiagonal_matrix+0x26d>
jmp    13b9 <solve_tridiagonal_matrix+0x2b9>
test   %r8d,%r8d
je     121f <solve_tridiagonal_matrix+0x11f>
lea    (%rcx,%rdi,8),%rax
cmp    %rcx,%rax
jb     121f <solve_tridiagonal_matrix+0x11f>
lea    (%rdx,%rdi,8),%rax
cmp    %rdx,%rax
jb     121f <solve_tridiagonal_matrix+0x11f>
lea    0x0(,%rdi,8),%rax
mov    %r8d,%r14d
lea    (%rcx,%r14,8),%rbx
mov    %rbx,%rsi
sub    %rax,%rsi
cmp    %rbx,%rsi
ja     121f <solve_tridiagonal_matrix+0x11f>
lea    (%rdx,%rdi,8),%rax
add    $0x8,%rax
mov    %r14,%rsi
sub    %rdi,%rsi
cmp    %rcx,%rax
seta   %r9b
lea    (%rcx,%rdi,8),%rbx
add    $0x8,%rbx
cmp    %rdx,%rbx
seta   %r10b
lea    (%rcx,%r14,8),%rax
add    $0x8,%rax
cmp    %rcx,%rax
seta   %al
lea    (%rcx,%rsi,8),%rsi
cmp    %rbx,%rsi
setb   %sil
test   %r10b,%r9b
jne    121f <solve_tridiagonal_matrix+0x11f>
and    %sil,%al
jne    121f <solve_tridiagonal_matrix+0x11f>
lea    0x1(%rdi),%r9
mov    %r9,%r10
and    $0xfffffffffffffffc,%r10
mov    %rdi,%r11
sub    %r10,%r11
sub    %r10d,%r8d
mov    %r10,%r15
neg    %r15
lea    (%rcx,%rdi,8),%rbx
add    $0xfffffffffffffff8,%rbx
lea    (%rdx,%rdi,8),%rdi
add    $0xfffffffffffffff8,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
lea    (%r14,%rsi,1),%eax
movupd -0x10(%rbx,%rsi,8),%xmm0
movupd (%rbx,%rsi,8),%xmm1
movupd -0x10(%rdi,%rsi,8),%xmm2
movupd (%rdi,%rsi,8),%xmm3
movupd -0x18(%rcx,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
subpd  %xmm4,%xmm0
movupd -0x8(%rcx,%rax,8),%xmm2
mulpd  %xmm3,%xmm2
subpd  %xmm2,%xmm1
movupd %xmm1,(%rbx,%rsi,8)
movupd %xmm0,-0x10(%rbx,%rsi,8)
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%r15
jne    1310 <solve_tridiagonal_matrix+0x210>
cmp    %r10,%r9
jne    1222 <solve_tridiagonal_matrix+0x122>
jmp    13b9 <solve_tridiagonal_matrix+0x2b9>
mov    %r11,%rsi
test   %r11,%r11
je     13b9 <solve_tridiagonal_matrix+0x2b9>
mov    %rsi,%rax
movsd  -0x8(%rcx,%rsi,8),%xmm0
movsd  (%rdx,%rsi,8),%xmm1
mov    %r8d,%edi
mulsd  (%rcx,%rdi,8),%xmm1
movsd  (%rcx,%rsi,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx,%rsi,8)
movsd  -0x8(%rdx,%rsi,8),%xmm1
mov    %esi,%edi
mulsd  (%rcx,%rdi,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rcx,%rsi,8)
add    $0xfffffffffffffffe,%rax
lea    -0x1(%rsi),%r8d
mov    %rax,%rsi
cmp    $0xffffffffffffffff,%rax
jne    1370 <solve_tridiagonal_matrix+0x270>
pop    %rbx
pop    %r14
pop    %r15
ret

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

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