void dadd_mat(int row, int col, double alpha, double *A, int lda, double *B,
              int ldb) {
  int i, j;
  for (j = 0; j < col; j++) {
    i = 0;
    for (; i < row - 3; i += 4) {
      B[i + 0 + j * ldb] += alpha * A[i + 0 + j * lda];
      B[i + 1 + j * ldb] += alpha * A[i + 1 + j * lda];
      B[i + 2 + j * ldb] += alpha * A[i + 2 + j * lda];
      B[i + 3 + j * ldb] += alpha * A[i + 3 + j * lda];
    }
    for (; i < row; i++) {
      B[i + j * ldb] += alpha * A[i + j * lda];
    }
  }
}


x86 assembly (clang, -O0):
<dadd_mat>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12eb <dadd_mat+0x1eb>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1277 <dadd_mat+0x177>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
mov    -0x34(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
mov    -0x34(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
mov    -0x34(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
mov    -0x34(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    1138 <dadd_mat+0x38>
jmp    127c <dadd_mat+0x17c>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12d8 <dadd_mat+0x1d8>
movsd  -0x10(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    127c <dadd_mat+0x17c>
jmp    12dd <dadd_mat+0x1dd>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1125 <dadd_mat+0x25>
pop    %rbp
ret

x86 assembly (clang, -O2):
<dadd_mat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rdx,-0x70(%rsp)
test   %esi,%esi
jle    157c <dadd_mat+0x47c>
lea    -0x3(%rdi),%eax
movslq %eax,%r11
movslq %ecx,%rbp
movslq %r9d,%rcx
mov    %esi,%eax
mov    %rax,(%rsp)
mov    %edi,%r15d
cmp    $0x5,%r11
mov    $0x4,%ebx
cmovge %r11,%rbx
lea    -0x1(%rbx),%rax
mov    %rax,-0x20(%rsp)
shr    $0x2,%rax
add    $0x3,%rbx
and    $0xfffffffffffffffc,%rbx
lea    0x1(%rax),%rsi
mov    $0x20,%edx
mul    %rdx
mov    %rax,-0x28(%rsp)
seto   -0x79(%rsp)
mov    %rsi,-0x40(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,-0x58(%rsp)
lea    0x0(,%rsi,4),%rax
mov    %rax,-0x48(%rsp)
movapd %xmm0,%xmm8
unpcklpd %xmm0,%xmm8
mov    %r15,%rax
neg    %rax
mov    %rax,-0x30(%rsp)
mov    %rbp,0x8(%rsp)
lea    0x0(,%rbp,8),%rax
mov    %rax,-0x8(%rsp)
mov    %rcx,-0x18(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,-0x10(%rsp)
mov    -0x70(%rsp),%r10
lea    0x10(%r10),%rbp
lea    0x10(%r8),%rax
mov    %rax,-0x50(%rsp)
xor    %r9d,%r9d
mov    %r8,%r13
mov    %rbx,-0x78(%rsp)
mov    %rdi,-0x38(%rsp)
mov    %r8,-0x60(%rsp)
jmp    1216 <dadd_mat+0x116>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r9
mov    -0x8(%rsp),%rcx
add    %rcx,%r10
mov    -0x10(%rsp),%rdx
add    %rdx,%r13
add    %rcx,%rbp
add    %rdx,-0x50(%rsp)
cmp    (%rsp),%r9
je     157c <dadd_mat+0x47c>
mov    %r9,%r12
imul   -0x18(%rsp),%r12
mov    %r9,%rax
imul   0x8(%rsp),%rax
mov    $0x0,%ecx
cmp    $0x4,%edi
jl     12fc <dadd_mat+0x1fc>
lea    (%r8,%r12,8),%rcx
add    $0x18,%rcx
mov    -0x28(%rsp),%rdx
add    %rcx,%rdx
cmp    %rcx,%rdx
setb   %cl
cmpq   $0x4,-0x20(%rsp)
jb     128e <dadd_mat+0x18e>
or     -0x79(%rsp),%cl
mov    $0x0,%ecx
jne    1290 <dadd_mat+0x190>
lea    (%rbx,%rax,1),%rcx
lea    (%r8,%r12,8),%rdx
mov    -0x70(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
cmp    %rcx,%rdx
jae    147f <dadd_mat+0x37f>
lea    (%rbx,%r12,1),%rcx
lea    (%r8,%rcx,8),%rcx
lea    (%rsi,%rax,8),%rdx
cmp    %rcx,%rdx
jae    147f <dadd_mat+0x37f>
xor    %ecx,%ecx
movsd  (%r10,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%r13,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
movsd  0x8(%r10,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r13,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rcx,8)
movsd  0x10(%r10,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%r13,%rcx,8),%xmm1
movsd  %xmm1,0x10(%r13,%rcx,8)
movsd  0x18(%r10,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%r13,%rcx,8),%xmm1
movsd  %xmm1,0x18(%r13,%rcx,8)
add    $0x4,%rcx
cmp    %r11,%rcx
jl     1290 <dadd_mat+0x190>
cmp    %edi,%ecx
jge    11f0 <dadd_mat+0xf0>
mov    %rbp,-0x68(%rsp)
mov    %ecx,%ecx
mov    %r15,%rbx
sub    %rcx,%rbx
cmp    $0x4,%rbx
jae    1330 <dadd_mat+0x230>
mov    %rcx,%r14
mov    -0x78(%rsp),%rbx
mov    -0x68(%rsp),%rbp
mov    -0x60(%rsp),%r8
jmp    1400 <dadd_mat+0x300>
xchg   %ax,%ax
lea    (%rax,%r15,1),%rdx
mov    -0x70(%rsp),%r14
lea    (%r14,%rdx,8),%rdx
lea    (%r12,%rcx,1),%rsi
mov    -0x60(%rsp),%r8
lea    (%r8,%rsi,8),%rsi
cmp    %rdx,%rsi
jae    1379 <dadd_mat+0x279>
mov    %rax,%rbp
lea    (%r12,%r15,1),%rdx
lea    (%r8,%rdx,8),%rdx
lea    (%rax,%rcx,1),%rsi
lea    (%r14,%rsi,8),%rsi
cmp    %rdx,%rsi
jae    1379 <dadd_mat+0x279>
mov    %rcx,%r14
mov    -0x78(%rsp),%rbx
mov    -0x68(%rsp),%rbp
jmp    1400 <dadd_mat+0x300>
mov    %rbx,%rsi
and    $0xfffffffffffffffc,%rsi
lea    (%rsi,%rcx,1),%r14
mov    -0x68(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    -0x50(%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rbp,8),%xmm1
movupd (%rdx,%rbp,8),%xmm2
movupd -0x10(%rcx,%rbp,8),%xmm3
movupd (%rcx,%rbp,8),%xmm4
mulpd  %xmm8,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm8,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,-0x10(%rcx,%rbp,8)
movupd %xmm2,(%rcx,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rsi
jne    13a0 <dadd_mat+0x2a0>
cmp    %rsi,%rbx
mov    -0x38(%rsp),%rdi
mov    -0x78(%rsp),%rbx
mov    -0x68(%rsp),%rbp
mov    -0x60(%rsp),%r8
je     11f0 <dadd_mat+0xf0>
nopl   0x0(%rax)
mov    %r15d,%ecx
sub    %r14d,%ecx
mov    %r14,%rsi
test   $0x1,%cl
je     1432 <dadd_mat+0x332>
add    %r14,%rax
add    %r14,%r12
mov    -0x70(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r8,%r12,8),%xmm1
movsd  %xmm1,(%r8,%r12,8)
lea    0x1(%r14),%rsi
not    %r14
cmp    -0x30(%rsp),%r14
je     11f0 <dadd_mat+0xf0>
movsd  (%r10,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%r13,%rsi,8),%xmm1
movsd  %xmm1,0x0(%r13,%rsi,8)
movsd  0x8(%r10,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r13,%rsi,8),%xmm1
movsd  %xmm1,0x8(%r13,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r15
jne    1440 <dadd_mat+0x340>
jmp    11f0 <dadd_mat+0xf0>
mov    -0x58(%rsp),%rcx
xor    %r14d,%r14d
nopw   0x0(%rax,%rax,1)
movupd (%r10,%r14,1),%xmm2
movupd 0x10(%r10,%r14,1),%xmm3
movupd 0x20(%r10,%r14,1),%xmm5
movupd 0x30(%r10,%r14,1),%xmm6
movapd %xmm2,%xmm4
unpcklpd %xmm5,%xmm4
unpckhpd %xmm5,%xmm2
movapd %xmm3,%xmm5
unpcklpd %xmm6,%xmm5
unpckhpd %xmm6,%xmm3
movupd 0x0(%r13,%r14,1),%xmm6
movupd 0x10(%r13,%r14,1),%xmm10
movupd 0x20(%r13,%r14,1),%xmm1
movupd 0x30(%r13,%r14,1),%xmm9
movapd %xmm6,%xmm7
unpcklpd %xmm1,%xmm7
unpckhpd %xmm1,%xmm6
movapd %xmm10,%xmm1
unpcklpd %xmm9,%xmm1
unpckhpd %xmm9,%xmm10
mulpd  %xmm8,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm8,%xmm2
addpd  %xmm6,%xmm2
mulpd  %xmm8,%xmm5
addpd  %xmm1,%xmm5
mulpd  %xmm8,%xmm3
addpd  %xmm10,%xmm3
movapd %xmm5,%xmm1
unpcklpd %xmm3,%xmm1
movapd %xmm4,%xmm6
unpcklpd %xmm2,%xmm6
movhlps %xmm5,%xmm3
movhlps %xmm4,%xmm2
movups %xmm2,0x20(%r13,%r14,1)
movups %xmm3,0x30(%r13,%r14,1)
movupd %xmm6,0x0(%r13,%r14,1)
movupd %xmm1,0x10(%r13,%r14,1)
add    $0x40,%r14
add    $0xfffffffffffffffe,%rcx
jne    1490 <dadd_mat+0x390>
mov    -0x48(%rsp),%rcx
mov    -0x58(%rsp),%rsi
cmp    %rsi,-0x40(%rsp)
mov    -0x78(%rsp),%rbx
jne    1290 <dadd_mat+0x190>
jmp    12fc <dadd_mat+0x1fc>
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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