void tridia(int ne, double *a, double *b, double *c, double *y, double *x) {
  double alpha[20], gamma[20];
  int nm1, i, ib;
  nm1 = ne - 1;
  alpha[0] = 1. / b[0];
  gamma[0] = c[0] * alpha[0];
  for (i = 1; i < nm1; i++) {
    alpha[i] = 1. / (b[i] - a[i] * gamma[i - 1]);
    gamma[i] = c[i] * alpha[i];
  }
  x[0] = y[0] * alpha[0];
  for (i = 1; i < nm1; i++) {
    x[i] = (y[i] - a[i] * x[i - 1]) * alpha[i];
  }
  x[nm1] = (y[nm1] - a[nm1] * x[nm1 - 1]) / (b[nm1] - a[nm1] * gamma[nm1 - 1]);
  for (i = nm1 - 1; i >= 0; i--) {
    x[i] = x[i] - gamma[i] * x[i + 1];
  }
}


x86 assembly (clang, -O0):
<tridia>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x174(%rbp)
mov    -0x18(%rbp),%rax
movsd  0xec6(%rip),%xmm0
divsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
movl   $0x1,-0x178(%rbp)
mov    -0x178(%rbp),%eax
cmp    -0x174(%rbp),%eax
jge    122d <tridia+0x12d>
mov    -0x18(%rbp),%rax
movslq -0x178(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x178(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x178(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x170(%rbp,%rax,8),%xmm2
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe2b(%rip),%xmm0
divsd  %xmm1,%xmm0
movslq -0x178(%rbp),%rax
movsd  %xmm0,-0xd0(%rbp,%rax,8)
ff ff
mov    -0x20(%rbp),%rax
movslq -0x178(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x178(%rbp),%rax
mulsd  -0xd0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x178(%rbp),%rax
movsd  %xmm0,-0x170(%rbp,%rax,8)
ff ff
mov    -0x178(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x178(%rbp)
jmp    1168 <tridia+0x68>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x178(%rbp)
mov    -0x178(%rbp),%eax
cmp    -0x174(%rbp),%eax
jge    12e9 <tridia+0x1e9>
mov    -0x28(%rbp),%rax
movslq -0x178(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x178(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x178(%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
movslq -0x178(%rbp),%rax
mulsd  -0xd0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x30(%rbp),%rax
movslq -0x178(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x178(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x178(%rbp)
jmp    124f <tridia+0x14f>
mov    -0x28(%rbp),%rax
movslq -0x174(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x174(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x174(%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
mov    -0x18(%rbp),%rax
movslq -0x174(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x174(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x174(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x170(%rbp,%rax,8),%xmm3
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x174(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x174(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x178(%rbp)
cmpl   $0x0,-0x178(%rbp)
jl     1438 <tridia+0x338>
mov    -0x30(%rbp),%rax
movslq -0x178(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x178(%rbp),%rax
movsd  -0x170(%rbp,%rax,8),%xmm0
ff ff
mov    -0x30(%rbp),%rax
mov    -0x178(%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    -0x30(%rbp),%rax
movslq -0x178(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x178(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x178(%rbp)
jmp    13b3 <tridia+0x2b3>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tridia>:
push   %rbx
sub    $0xc0,%rsp
lea    -0x1(%rdi),%r10d
movsd  0xeec(%rip),%xmm1
movapd %xmm1,%xmm0
divsd  (%rdx),%xmm0
movsd  (%rcx),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,-0x80(%rsp)
cmp    $0x2,%edi
jle    121d <tridia+0x11d>
mov    %r10d,%ebx
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm3
mulsd  (%rsi,%rax,8),%xmm2
subsd  %xmm2,%xmm3
movapd %xmm1,%xmm2
divsd  %xmm3,%xmm2
movsd  %xmm2,0x20(%rsp,%rax,8)
mulsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,-0x80(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1140 <tridia+0x40>
mulsd  (%r8),%xmm0
movsd  %xmm0,(%r9)
cmp    $0x3,%edi
jl     1227 <tridia+0x127>
add    $0xffffffffffffffff,%rbx
mov    $0x1,%ecx
cmp    $0x2,%r10d
je     11fb <tridia+0xfb>
mov    %rbx,%r11
and    $0xfffffffffffffffe,%r11
neg    %r11
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  (%rsi,%rcx,8),%xmm0
movsd  (%r8,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x20(%rsp,%rcx,8),%xmm1
movsd  %xmm1,(%r9,%rcx,8)
mulsd  0x8(%rsi,%rcx,8),%xmm1
movsd  0x8(%r8,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
mulsd  0x28(%rsp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r9,%rcx,8)
lea    (%r11,%rcx,1),%rax
add    $0x2,%rax
add    $0x2,%rcx
cmp    $0x1,%rax
jne    11b0 <tridia+0xb0>
test   $0x1,%bl
je     1227 <tridia+0x127>
movsd  (%r8,%rcx,8),%xmm1
mulsd  (%rsi,%rcx,8),%xmm0
subsd  %xmm0,%xmm1
mulsd  0x20(%rsp,%rcx,8),%xmm1
movsd  %xmm1,(%r9,%rcx,8)
jmp    1227 <tridia+0x127>
mulsd  (%r8),%xmm0
movsd  %xmm0,(%r9)
movslq %r10d,%rax
movsd  (%r8,%rax,8),%xmm0
movsd  (%rsi,%rax,8),%xmm1
movslq %edi,%rcx
movsd  -0x10(%r9,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
movsd  (%rdx,%rax,8),%xmm2
mulsd  -0x90(%rsp,%rcx,8),%xmm1
ff ff
subsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,(%r9,%rax,8)
cmp    $0x2,%edi
jl     12e2 <tridia+0x1e2>
add    $0xfffffffe,%edi
mov    %edi,%eax
test   $0x1,%dil
jne    1294 <tridia+0x194>
movsd  -0x80(%rsp,%rax,8),%xmm0
mulsd  0x8(%r9,%rax,8),%xmm0
movsd  (%r9,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rax,8)
add    $0xffffffffffffffff,%rax
test   %edi,%edi
je     12e2 <tridia+0x1e2>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r9,%rax,8),%xmm0
movsd  (%r9,%rax,8),%xmm1
movsd  -0x80(%rsp,%rax,8),%xmm2
mulsd  0x8(%r9,%rax,8),%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r9,%rax,8)
mulsd  -0x88(%rsp,%rax,8),%xmm1
ff ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%r9,%rax,8)
add    $0xfffffffffffffffe,%rax
cmp    $0xffffffffffffffff,%rax
jne    12a0 <tridia+0x1a0>
add    $0xc0,%rsp
pop    %rbx
ret

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

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