void TrisolveREG(double *t0, double *tu, double *tl, double *coef, double *sol,
                 int sizeh0) {
  double m = 0;
  int i = 0;
  for (i = 0; i < sizeh0 - 1; i++) {
    m = tl[i] / t0[i];
    t0[i + 1] = t0[i + 1] - m * tu[i];
    coef[i + 1] = coef[i + 1] - coef[i] * m;
  }
  sol[sizeh0 - 1] = coef[sizeh0 - 1] / t0[sizeh0 - 1];
  for (i = 0; i < sizeh0 - 1; i++) {
    sol[sizeh0 - 2 - i] =
        (coef[sizeh0 - 2 - i] - (tu[sizeh0 - 2 - i] * sol[sizeh0 - 1 - i])) /
        t0[sizeh0 - 2 - i];
  }
}


x86 assembly (clang, -O0):
<TrisolveREG>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    121a <TrisolveREG+0x11a>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%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    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1132 <TrisolveREG+0x32>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12fe <TrisolveREG+0x1fe>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x3c(%rbp),%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    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1257 <TrisolveREG+0x157>
pop    %rbp
ret

x86 assembly (clang, -O2):
<TrisolveREG>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
lea    -0x1(%r9),%eax
cmp    $0x1,%r9d
jle    1186 <TrisolveREG+0x86>
mov    %eax,%r11d
lea    (%rcx,%r11,8),%rbp
add    $0x8,%rbp
cmp    %rdi,%rbp
jbe    119d <TrisolveREG+0x9d>
lea    (%rdi,%r11,8),%rbp
add    $0x8,%rbp
cmp    %rcx,%rbp
jbe    119d <TrisolveREG+0x9d>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rbp,8),%xmm0
divsd  (%rdi,%rbp,8),%xmm0
movsd  0x8(%rdi,%rbp,8),%xmm1
movsd  (%rsi,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rdi,%rbp,8)
movsd  0x8(%rcx,%rbp,8),%xmm1
mulsd  (%rcx,%rbp,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rcx,%rbp,8)
lea    0x1(%rbp),%rbx
mov    %rbx,%rbp
cmp    %rbx,%r11
jne    1140 <TrisolveREG+0x40>
jmp    11f2 <TrisolveREG+0xf2>
cltq
movsd  (%rcx,%rax,8),%xmm0
divsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r8,%rax,8)
jmp    125e <TrisolveREG+0x15e>
movsd  (%rdi),%xmm1
movsd  (%rcx),%xmm0
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rbp,8),%xmm2
divsd  %xmm1,%xmm2
mulsd  %xmm2,%xmm0
mulsd  (%rsi,%rbp,8),%xmm2
movsd  0x8(%rdi,%rbp,8),%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rdi,%rbp,8)
movsd  0x8(%rcx,%rbp,8),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rcx,%rbp,8)
lea    0x1(%rbp),%rbx
movapd %xmm2,%xmm0
mov    %rbx,%rbp
cmp    %rbx,%r11
jne    11b0 <TrisolveREG+0xb0>
movslq %eax,%r12
movsd  (%rcx,%r12,8),%xmm0
divsd  (%rdi,%r12,8),%xmm0
movsd  %xmm0,(%r8,%r12,8)
cmp    $0x2,%r9d
jl     125e <TrisolveREG+0x15e>
cmp    $0x2,%eax
jae    1269 <TrisolveREG+0x169>
xor    %edx,%edx
sub    %edx,%r9d
add    $0xfffffffe,%r9d
sub    %rdx,%r12
lea    (%r8,%r12,8),%rax
sub    %r11,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
lea    (%r9,%rbp,1),%ebx
movslq %ebx,%rbx
movsd  (%rsi,%rbx,8),%xmm0
mulsd  (%rax,%rbp,8),%xmm0
movsd  (%rcx,%rbx,8),%xmm1
subsd  %xmm0,%xmm1
divsd  (%rdi,%rbx,8),%xmm1
movsd  %xmm1,(%r8,%rbx,8)
add    $0xffffffffffffffff,%rbp
cmp    %rbp,%rdx
jne    1230 <TrisolveREG+0x130>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x2(%r9),%r14d
lea    -0x1(%r11),%r10
mov    %r14d,%ebx
sub    %r10d,%ebx
mov    $0x8,%edx
mov    %r10,%rax
mul    %rdx
seto   %r15b
xor    %edx,%edx
cmp    %r14d,%ebx
jg     1214 <TrisolveREG+0x114>
shr    $0x20,%r10
jne    1214 <TrisolveREG+0x114>
movslq %r14d,%r10
lea    (%r8,%r10,8),%rbp
mov    %rbp,%rbx
sub    %rax,%rbx
cmp    %rbp,%rbx
ja     1214 <TrisolveREG+0x114>
test   %r15b,%r15b
jne    1214 <TrisolveREG+0x114>
lea    (%rcx,%r10,8),%rbp
mov    %rbp,%rbx
sub    %rax,%rbx
cmp    %rbp,%rbx
ja     1214 <TrisolveREG+0x114>
test   %r15b,%r15b
jne    1214 <TrisolveREG+0x114>
lea    (%rsi,%r10,8),%rbp
mov    %rbp,%rbx
sub    %rax,%rbx
cmp    %rbp,%rbx
ja     1214 <TrisolveREG+0x114>
test   %r15b,%r15b
jne    1214 <TrisolveREG+0x114>
lea    (%r8,%r12,8),%rbp
mov    %rbp,%rbx
sub    %rax,%rbx
cmp    %rbp,%rbx
ja     1214 <TrisolveREG+0x114>
test   %r15b,%r15b
jne    1214 <TrisolveREG+0x114>
lea    (%rdi,%r10,8),%rbp
mov    %rbp,%rbx
sub    %rax,%rbx
cmp    %rbp,%rbx
ja     1214 <TrisolveREG+0x114>
mov    %r14d,-0x4(%rsp)
test   %r15b,%r15b
jne    1214 <TrisolveREG+0x114>
lea    0x1(%r10),%rdx
sub    %r11,%rdx
lea    (%r8,%rdx,8),%rbp
lea    (%r8,%r10,8),%r13
add    $0x8,%r13
lea    (%rcx,%rdx,8),%rax
lea    (%rcx,%r10,8),%rbx
add    $0x8,%rbx
lea    (%rsi,%rdx,8),%r15
lea    0x1(%r12),%r14
sub    %r11,%r14
cmp    %rbx,%rbp
setb   -0x5(%rsp)
cmp    %r13,%rax
lea    0x8(%rsi,%r10,8),%rax
setb   -0x6(%rsp)
cmp    %rax,%rbp
setb   %al
cmp    %r13,%r15
lea    0x8(%r8,%r12,8),%rbx
setb   %r15b
cmp    %rbx,%rbp
lea    (%r8,%r14,8),%rbx
setb   %r14b
cmp    %r13,%rbx
lea    0x8(%rdi,%r10,8),%rbx
setb   -0x7(%rsp)
cmp    %rbx,%rbp
lea    (%rdi,%rdx,8),%rdx
setb   %r10b
cmp    %r13,%rdx
setb   %bpl
xor    %edx,%edx
mov    -0x6(%rsp),%bl
test   %bl,-0x5(%rsp)
jne    1214 <TrisolveREG+0x114>
and    %r15b,%al
jne    1214 <TrisolveREG+0x114>
and    -0x7(%rsp),%r14b
jne    1214 <TrisolveREG+0x114>
and    %bpl,%r10b
jne    1214 <TrisolveREG+0x114>
mov    %r11d,%edx
and    $0xfffffffe,%edx
lea    (%r8,%r12,8),%r10
add    $0xfffffffffffffff8,%r10
mov    %rdx,%rbp
neg    %rbp
mov    -0x4(%rsp),%r14d
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
lea    (%r14,%rax,1),%ebx
movslq %ebx,%rbx
movupd -0x8(%rcx,%rbx,8),%xmm0
movupd -0x8(%rsi,%rbx,8),%xmm1
movupd (%r10,%rax,8),%xmm2
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm0
movupd -0x8(%rdi,%rbx,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,-0x8(%r8,%rbx,8)
add    $0xfffffffffffffffe,%rax
cmp    %rax,%rbp
jne    13f0 <TrisolveREG+0x2f0>
cmp    %r11,%rdx
jne    1214 <TrisolveREG+0x114>
jmp    125e <TrisolveREG+0x15e>

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

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