void matmult_block_notrans(double *C, const double *A, const double *B,
                           const double alpha, int M, int N, int P, int S,
                           int L, int R, int E) {
  int i, j, k;
  const double *Br, *Ac, *Bc;
  double *Cc;
  register const double *Ar;
  register double *Cr;
  register double coeff;
  Cc = &C[S * M + R];
  Bc = &B[S * P];
  Ac = &A[R];
  for (j = S; j < L; j++) {
    Ac = A + R;
    Br = Bc;
    for (k = 0; k < P; k++) {
      Cr = Cc;
      Ar = Ac;
      if (*Br != 0.0) {
        coeff = *Br * alpha;
        for (i = R; i < E; i++) {
          *Cr += (*Ar) * coeff;
          Cr++;
          Ar++;
        }
      }
      Br++;
      Ac += M;
    }
    Cc += M;
    Bc += P;
  }
}


x86 assembly (clang, -O0):
<matmult_block_notrans>:
push   %rbp
mov    %rsp,%rbp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq 0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    12bb <matmult_block_notrans+0x1bb>
mov    -0x10(%rbp),%rax
movslq 0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1283 <matmult_block_notrans+0x183>
mov    -0x58(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11e4 <matmult_block_notrans+0xe4>
jp     11e4 <matmult_block_notrans+0xe4>
jmp    1254 <matmult_block_notrans+0x154>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    124f <matmult_block_notrans+0x14f>
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x68(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11fc <matmult_block_notrans+0xfc>
jmp    1254 <matmult_block_notrans+0x154>
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11a8 <matmult_block_notrans+0xa8>
mov    -0x24(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    117a <matmult_block_notrans+0x7a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<matmult_block_notrans>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,-0x60(%rsp)
mov    %rdi,-0x68(%rsp)
mov    0x40(%rsp),%ebp
cmp    0x48(%rsp),%ebp
jge    14a9 <matmult_block_notrans+0x3a9>
mov    0x58(%rsp),%eax
mov    0x50(%rsp),%r11d
movslq %r11d,%rsi
mov    %ebp,%edi
imul   %r9d,%edi
movslq %edi,%rdi
lea    (%rdx,%rdi,8),%rdx
mov    %rdx,-0x80(%rsp)
mov    %ebp,%edx
imul   %ecx,%edx
add    %r11d,%edx
movslq %edx,%rdx
mov    -0x68(%rsp),%rdi
lea    (%rdi,%rdx,8),%r8
mov    -0x60(%rsp),%rdi
lea    (%rdi,%rsi,8),%rdi
mov    %rdi,-0x48(%rsp)
movslq %ecx,%rcx
movslq %r9d,%rdi
mov    %rdi,-0x38(%rsp)
mov    %esi,%edi
not    %edi
add    %eax,%edi
add    %rdi,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rsp)
lea    0x1(%rsi,%rdi,1),%rdx
mov    %rdx,-0x8(%rsp)
mov    %rdi,(%rsp)
lea    0x1(%rdi),%rdx
mov    %rdx,-0x18(%rsp)
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rsi
mov    %rsi,-0x20(%rsp)
mov    %rsi,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,%rsi
mov    %rdi,-0x28(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,-0x40(%rsp)
xorpd  %xmm8,%xmm8
mov    %rdx,%rsi
mov    %rdx,-0x78(%rsp)
add    %r11d,%edx
mov    %edx,-0x70(%rsp)
mov    %rcx,-0x58(%rsp)
lea    0x0(,%rcx,8),%rdi
xor    %r14d,%r14d
jmp    121b <matmult_block_notrans+0x11b>
cs nopw 0x0(%rax,%rax,1)
add    %rdi,%r8
mov    -0x80(%rsp),%rcx
mov    -0x38(%rsp),%rdx
lea    (%rcx,%rdx,8),%rcx
mov    %rcx,-0x80(%rsp)
mov    -0x6c(%rsp),%ebp
add    $0x1,%ebp
add    $0x1,%r14
cmp    0x48(%rsp),%ebp
je     14a9 <matmult_block_notrans+0x3a9>
mov    %ebp,-0x6c(%rsp)
test   %r9d,%r9d
jle    11f0 <matmult_block_notrans+0xf0>
mov    %r14,%rcx
imul   -0x58(%rsp),%rcx
add    -0x50(%rsp),%rcx
mov    -0x68(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,-0x10(%rsp)
mov    -0x78(%rsp),%rcx
lea    (%r8,%rcx,8),%rcx
mov    %rcx,-0x30(%rsp)
mov    -0x48(%rsp),%r15
xor    %ebp,%ebp
mov    -0x80(%rsp),%rdx
jmp    1270 <matmult_block_notrans+0x170>
nopl   0x0(%rax)
add    $0x8,%rdx
add    %rdi,%r15
add    $0x1,%rbp
cmp    %r9d,%ebp
je     11f0 <matmult_block_notrans+0xf0>
movsd  (%rdx),%xmm2
ucomisd %xmm8,%xmm2
jne    127d <matmult_block_notrans+0x17d>
jnp    1260 <matmult_block_notrans+0x160>
cmp    %eax,%r11d
jge    1260 <matmult_block_notrans+0x160>
mulsd  %xmm0,%xmm2
mov    %r11d,%esi
mov    %r8,%rbx
mov    %r15,%r13
cmpl   $0x3,(%rsp)
jb     13d0 <matmult_block_notrans+0x2d0>
mov    %rbp,%rcx
imul   -0x58(%rsp),%rcx
add    -0x8(%rsp),%rcx
mov    -0x60(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
cmp    %rcx,%r8
jae    12c9 <matmult_block_notrans+0x1c9>
mov    %r11d,%esi
mov    %r8,%rbx
mov    %r15,%r13
cmp    -0x10(%rsp),%r15
jb     13d0 <matmult_block_notrans+0x2d0>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x0,-0x20(%rsp)
je     1497 <matmult_block_notrans+0x397>
mov    -0x40(%rsp),%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%r15,%rbx,8),%xmm4
movupd 0x10(%r15,%rbx,8),%xmm5
mulpd  %xmm3,%xmm4
movupd (%r8,%rbx,8),%xmm6
addpd  %xmm4,%xmm6
movupd 0x10(%r8,%rbx,8),%xmm4
movupd 0x20(%r8,%rbx,8),%xmm7
movupd 0x30(%r8,%rbx,8),%xmm1
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm6,(%r8,%rbx,8)
movupd %xmm5,0x10(%r8,%rbx,8)
movupd 0x20(%r15,%rbx,8),%xmm4
movupd 0x30(%r15,%rbx,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm1,%xmm5
movupd %xmm4,0x20(%r8,%rbx,8)
movupd %xmm5,0x30(%r8,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rsi
jne    12f0 <matmult_block_notrans+0x1f0>
testb  $0x1,-0x28(%rsp)
je     13a9 <matmult_block_notrans+0x2a9>
movupd (%r15,%rbx,8),%xmm1
movupd 0x10(%r15,%rbx,8),%xmm4
movupd (%r8,%rbx,8),%xmm5
movupd 0x10(%r8,%rbx,8),%xmm6
mulpd  %xmm3,%xmm1
addpd  %xmm5,%xmm1
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm1,(%r8,%rbx,8)
movupd %xmm4,0x10(%r8,%rbx,8)
mov    -0x78(%rsp),%rcx
cmp    %rcx,-0x18(%rsp)
je     1260 <matmult_block_notrans+0x160>
mov    -0x78(%rsp),%rcx
lea    (%r15,%rcx,8),%r13
mov    -0x70(%rsp),%esi
mov    -0x30(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
sub    %esi,%ecx
mov    %esi,%r12d
not    %r12d
add    %eax,%r12d
and    $0x3,%ecx
je     1416 <matmult_block_notrans+0x316>
neg    %ecx
xor    %r10d,%r10d
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13),%xmm1
mulsd  %xmm2,%xmm1
addsd  (%rbx),%xmm1
movsd  %xmm1,(%rbx)
add    $0x8,%rbx
add    $0x8,%r13
add    $0xffffffff,%r10d
cmp    %r10d,%ecx
jne    13f0 <matmult_block_notrans+0x2f0>
sub    %r10d,%esi
cmp    $0x3,%r12d
jb     1260 <matmult_block_notrans+0x160>
mov    %eax,%ecx
sub    %esi,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%r13,%rsi,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  (%rbx,%rsi,8),%xmm1
movsd  %xmm1,(%rbx,%rsi,8)
movsd  0x8(%r13,%rsi,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  0x8(%rbx,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rsi,8)
movsd  0x10(%r13,%rsi,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  0x10(%rbx,%rsi,8),%xmm1
movsd  %xmm1,0x10(%rbx,%rsi,8)
movsd  0x18(%r13,%rsi,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  0x18(%rbx,%rsi,8),%xmm1
movsd  %xmm1,0x18(%rbx,%rsi,8)
add    $0x4,%rsi
cmp    %esi,%ecx
jne    1430 <matmult_block_notrans+0x330>
jmp    1260 <matmult_block_notrans+0x160>
xor    %ebx,%ebx
testb  $0x1,-0x28(%rsp)
jne    1372 <matmult_block_notrans+0x272>
jmp    13a9 <matmult_block_notrans+0x2a9>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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