void kernel_doitgen(int nr, int nq, int np, double A[150 + 0][140 + 0][160 + 0],
                    double C4[160 + 0][160 + 0], double sum[160 + 0]) {
  int r, q, p, s;
#pragma scop
  for (r = 0; r < nr; r++)
    for (q = 0; q < nq; q++) {
      for (p = 0; p < np; p++) {
        sum[p] = 0.0;
        for (s = 0; s < np; s++)
          sum[p] += A[r][q][s] * C4[s][p];
      }
      for (p = 0; p < np; p++)
        A[r][q][p] = sum[p];
    }
#pragma endscop
}


x86 assembly (clang, -O0):
<kernel_doitgen>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1271 <kernel_doitgen+0x171>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    125e <kernel_doitgen+0x15e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11f4 <kernel_doitgen+0xf4>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11e1 <kernel_doitgen+0xe1>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x2bc00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x500,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   $0x500,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1169 <kernel_doitgen+0x69>
jmp    11e6 <kernel_doitgen+0xe6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1146 <kernel_doitgen+0x46>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    124b <kernel_doitgen+0x14b>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x2bc00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x500,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11fb <kernel_doitgen+0xfb>
jmp    1250 <kernel_doitgen+0x150>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1133 <kernel_doitgen+0x33>
jmp    1263 <kernel_doitgen+0x163>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1120 <kernel_doitgen+0x20>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_doitgen>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,-0x50(%rsp)
mov    %esi,-0x7c(%rsp)
test   %edi,%edi
jle    1485 <kernel_doitgen+0x385>
mov    %r8,%r13
mov    %edi,%eax
mov    %rax,-0x40(%rsp)
mov    -0x7c(%rsp),%eax
mov    %rax,-0x8(%rsp)
mov    %edx,%ebx
lea    (%r9,%rbx,8),%rax
mov    %rax,-0x18(%rsp)
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x20(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x28(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ebx,%eax
and    $0xfffffffe,%eax
mov    %ecx,%esi
and    $0x3,%esi
and    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x48(%rsp)
mov    %ebx,%ecx
and    $0x3,%ecx
mov    %rcx,-0x10(%rsp)
mov    -0x50(%rsp),%rcx
lea    0x8(%rcx),%rdi
mov    %rdi,-0x60(%rsp)
lea    0x70(%rcx),%rdi
mov    %rdi,-0x68(%rsp)
lea    0x10(%r9),%rdi
mov    %rdi,-0x38(%rsp)
mov    %rsi,-0x30(%rsp)
shl    $0x5,%rsi
mov    %rsi,-0x58(%rsp)
xor    %esi,%esi
mov    %rsi,-0x78(%rsp)
mov    %rcx,-0x70(%rsp)
jmp    11e7 <kernel_doitgen+0xe7>
mov    -0x78(%rsp),%rsi
add    $0x1,%rsi
addq   $0x2bc00,-0x60(%rsp)
addq   $0x2bc00,-0x68(%rsp)
addq   $0x2bc00,-0x70(%rsp)
mov    %rsi,%rcx
mov    %rsi,-0x78(%rsp)
cmp    -0x40(%rsp),%rsi
je     1485 <kernel_doitgen+0x385>
cmpl   $0x0,-0x7c(%rsp)
jle    11b0 <kernel_doitgen+0xb0>
mov    -0x70(%rsp),%rsi
mov    -0x68(%rsp),%r15
mov    -0x60(%rsp),%r10
xor    %r12d,%r12d
jmp    1230 <kernel_doitgen+0x130>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r12
add    $0x500,%r10
add    $0x500,%r15
add    $0x500,%rsi
cmp    -0x8(%rsp),%r12
je     11b0 <kernel_doitgen+0xb0>
test   %edx,%edx
jle    1210 <kernel_doitgen+0x110>
imul   $0x2bc00,-0x78(%rsp),%rcx
add    -0x50(%rsp),%rcx
lea    (%r12,%r12,4),%r11
shl    $0x8,%r11
add    %rcx,%r11
lea    (%r11,%rbx,8),%rbp
mov    %r13,%r14
xor    %ecx,%ecx
jmp    1271 <kernel_doitgen+0x171>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x8,%r14
cmp    %rbx,%rcx
je     1310 <kernel_doitgen+0x210>
movq   $0x0,(%r9,%rcx,8)
xorpd  %xmm0,%xmm0
cmp    $0x1,%edx
jne    1290 <kernel_doitgen+0x190>
xor    %edi,%edi
jmp    12df <kernel_doitgen+0x1df>
cs nopw 0x0(%rax,%rax,1)
mov    %r14,%r8
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%r10,%rdi,8),%xmm1
mulsd  (%r8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rcx,8)
movsd  (%r10,%rdi,8),%xmm0
mulsd  0x500(%r8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r9,%rcx,8)
add    $0x2,%rdi
add    $0xa00,%r8
cmp    %rdi,%rax
jne    12a0 <kernel_doitgen+0x1a0>
test   $0x1,%bl
je     1260 <kernel_doitgen+0x160>
movsd  (%r11,%rdi,8),%xmm1
lea    (%rdi,%rdi,4),%rdi
shl    $0x8,%rdi
add    %r13,%rdi
mulsd  (%rdi,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rcx,8)
jmp    1260 <kernel_doitgen+0x160>
nopl   (%rax)
test   %edx,%edx
jle    1210 <kernel_doitgen+0x110>
cmp    $0x4,%edx
jb     1329 <kernel_doitgen+0x229>
cmp    -0x18(%rsp),%r11
jae    13a0 <kernel_doitgen+0x2a0>
cmp    %r9,%rbp
jbe    13a0 <kernel_doitgen+0x2a0>
xor    %ecx,%ecx
mov    %rcx,%rdi
not    %rdi
add    %rbx,%rdi
mov    -0x10(%rsp),%rbp
test   %rbp,%rbp
je     1355 <kernel_doitgen+0x255>
xchg   %ax,%ax
movsd  (%r9,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rbp
jne    1340 <kernel_doitgen+0x240>
cmp    $0x3,%rdi
jb     1210 <kernel_doitgen+0x110>
nop
movsd  (%r9,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
movsd  0x8(%r9,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rcx,8)
movsd  0x10(%r9,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rsi,%rcx,8)
movsd  0x18(%r9,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rsi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    1360 <kernel_doitgen+0x260>
jmp    1210 <kernel_doitgen+0x110>
cmpq   $0xc,-0x28(%rsp)
jae    13b1 <kernel_doitgen+0x2b1>
xor    %ecx,%ecx
mov    -0x58(%rsp),%r8
jmp    142c <kernel_doitgen+0x32c>
mov    -0x48(%rsp),%rdi
xor    %ecx,%ecx
mov    -0x58(%rsp),%r8
nopl   (%rax)
movups (%r9,%rcx,8),%xmm0
movups 0x10(%r9,%rcx,8),%xmm1
movups %xmm0,-0x70(%r15,%rcx,8)
movups %xmm1,-0x60(%r15,%rcx,8)
movups 0x20(%r9,%rcx,8),%xmm0
movups 0x30(%r9,%rcx,8),%xmm1
movups %xmm0,-0x50(%r15,%rcx,8)
movups %xmm1,-0x40(%r15,%rcx,8)
movups 0x40(%r9,%rcx,8),%xmm0
movups 0x50(%r9,%rcx,8),%xmm1
movups %xmm0,-0x30(%r15,%rcx,8)
movups %xmm1,-0x20(%r15,%rcx,8)
movupd 0x60(%r9,%rcx,8),%xmm0
movupd 0x70(%r9,%rcx,8),%xmm1
movupd %xmm0,-0x10(%r15,%rcx,8)
movupd %xmm1,(%r15,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdi
jne    13c0 <kernel_doitgen+0x2c0>
cmpq   $0x0,-0x30(%rsp)
je     146f <kernel_doitgen+0x36f>
lea    (%rsi,%rcx,8),%rdi
mov    -0x38(%rsp),%rbp
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rbp,1),%xmm0
movupd (%rcx,%rbp,1),%xmm1
movupd %xmm0,(%rdi,%rbp,1)
movupd %xmm1,0x10(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    1450 <kernel_doitgen+0x350>
mov    -0x20(%rsp),%rdi
mov    %rdi,%rcx
cmp    %rbx,%rdi
je     1210 <kernel_doitgen+0x110>
jmp    132b <kernel_doitgen+0x22b>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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