void ExpSubstitutionMatrix(double bmx[20][20], int dist, double smx[20][20]) {
  double xmx[11][20][20];
  double tmx[20][20];
  int r, c, i;
  int exponent;
  int chunk;
  int first;
  for (r = 0; r < 20; r++)
    for (c = 0; c < 20; c++)
      xmx[0][r][c] = bmx[r][c];
  for (exponent = 1; exponent < 11; exponent++) {
    for (r = 0; r < 20; r++)
      for (c = 0; c < 20; c++) {
        xmx[exponent][r][c] = 0.0;
        for (i = 0; i < 20; i++)
          xmx[exponent][r][c] +=
              xmx[exponent - 1][r][i] * xmx[exponent - 1][i][c];
      }
  }
  first = 1;
  for (exponent = 10, chunk = 1024; chunk >= 1; chunk /= 2, exponent--) {
    while (dist >= chunk) {
      dist -= chunk;
      if (first) {
        for (r = 0; r < 20; r++)
          for (c = 0; c < 20; c++)
            smx[r][c] = xmx[exponent][r][c];
        first = 0;
      } else {
        for (r = 0; r < 20; r++)
          for (c = 0; c < 20; c++) {
            tmx[r][c] = 0.0;
            for (i = 0; i < 20; i++)
              tmx[r][c] += smx[r][i] * xmx[exponent][i][c];
          }
        for (r = 0; r < 20; r++)
          for (c = 0; c < 20; c++)
            smx[r][c] = tmx[r][c];
      }
    }
  }
}


x86 assembly (clang, -O0):
<ExpSubstitutionMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x95c0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x9624(%rbp)
cmpl   $0x14,-0x9624(%rbp)
jge    11b6 <ExpSubstitutionMatrix+0xb6>
movl   $0x0,-0x9628(%rbp)
cmpl   $0x14,-0x9628(%rbp)
jge    119d <ExpSubstitutionMatrix+0x9d>
mov    -0x8(%rbp),%rax
movslq -0x9624(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    -0x89a0(%rbp),%rax
movslq -0x9624(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9628(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9628(%rbp)
jmp    1137 <ExpSubstitutionMatrix+0x37>
jmp    11a2 <ExpSubstitutionMatrix+0xa2>
mov    -0x9624(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9624(%rbp)
jmp    1120 <ExpSubstitutionMatrix+0x20>
movl   $0x1,-0x9630(%rbp)
cmpl   $0xb,-0x9630(%rbp)
jge    135f <ExpSubstitutionMatrix+0x25f>
movl   $0x0,-0x9624(%rbp)
cmpl   $0x14,-0x9624(%rbp)
jge    1346 <ExpSubstitutionMatrix+0x246>
movl   $0x0,-0x9628(%rbp)
cmpl   $0x14,-0x9628(%rbp)
jge    132d <ExpSubstitutionMatrix+0x22d>
movslq -0x9630(%rbp),%rcx
lea    -0x89a0(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x9624(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x962c(%rbp)
cmpl   $0x14,-0x962c(%rbp)
jge    1314 <ExpSubstitutionMatrix+0x214>
mov    -0x9630(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x89a0(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x9624(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x962c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9630(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x89a0(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x962c(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x9630(%rbp),%rcx
lea    -0x89a0(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x9624(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x962c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x962c(%rbp)
jmp    123d <ExpSubstitutionMatrix+0x13d>
jmp    1319 <ExpSubstitutionMatrix+0x219>
mov    -0x9628(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9628(%rbp)
jmp    11ee <ExpSubstitutionMatrix+0xee>
jmp    1332 <ExpSubstitutionMatrix+0x232>
mov    -0x9624(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9624(%rbp)
jmp    11d7 <ExpSubstitutionMatrix+0xd7>
jmp    134b <ExpSubstitutionMatrix+0x24b>
mov    -0x9630(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9630(%rbp)
jmp    11c0 <ExpSubstitutionMatrix+0xc0>
movl   $0x1,-0x9638(%rbp)
movl   $0xa,-0x9630(%rbp)
movl   $0x400,-0x9634(%rbp)
cmpl   $0x1,-0x9634(%rbp)
jl     1689 <ExpSubstitutionMatrix+0x589>
jmp    138f <ExpSubstitutionMatrix+0x28f>
mov    -0xc(%rbp),%eax
cmp    -0x9634(%rbp),%eax
jl     165c <ExpSubstitutionMatrix+0x55c>
mov    -0x9634(%rbp),%ecx
mov    -0xc(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0x9638(%rbp)
je     1479 <ExpSubstitutionMatrix+0x379>
movl   $0x0,-0x9624(%rbp)
cmpl   $0x14,-0x9624(%rbp)
jge    146a <ExpSubstitutionMatrix+0x36a>
movl   $0x0,-0x9628(%rbp)
cmpl   $0x14,-0x9628(%rbp)
jge    1451 <ExpSubstitutionMatrix+0x351>
movslq -0x9630(%rbp),%rcx
lea    -0x89a0(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x9624(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x9624(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9628(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9628(%rbp)
jmp    13da <ExpSubstitutionMatrix+0x2da>
jmp    1456 <ExpSubstitutionMatrix+0x356>
mov    -0x9624(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9624(%rbp)
jmp    13c3 <ExpSubstitutionMatrix+0x2c3>
movl   $0x0,-0x9638(%rbp)
jmp    1657 <ExpSubstitutionMatrix+0x557>
movl   $0x0,-0x9624(%rbp)
cmpl   $0x14,-0x9624(%rbp)
jge    15b2 <ExpSubstitutionMatrix+0x4b2>
movl   $0x0,-0x9628(%rbp)
cmpl   $0x14,-0x9628(%rbp)
jge    1599 <ExpSubstitutionMatrix+0x499>
movslq -0x9624(%rbp),%rcx
lea    -0x9620(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x962c(%rbp)
cmpl   $0x14,-0x962c(%rbp)
jge    1580 <ExpSubstitutionMatrix+0x480>
mov    -0x18(%rbp),%rax
movslq -0x9624(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x962c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x9630(%rbp),%rcx
lea    -0x89a0(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x962c(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x9624(%rbp),%rcx
lea    -0x9620(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x962c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x962c(%rbp)
jmp    14d8 <ExpSubstitutionMatrix+0x3d8>
jmp    1585 <ExpSubstitutionMatrix+0x485>
mov    -0x9628(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9628(%rbp)
jmp    149a <ExpSubstitutionMatrix+0x39a>
jmp    159e <ExpSubstitutionMatrix+0x49e>
mov    -0x9624(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9624(%rbp)
jmp    1483 <ExpSubstitutionMatrix+0x383>
movl   $0x0,-0x9624(%rbp)
cmpl   $0x14,-0x9624(%rbp)
jge    1652 <ExpSubstitutionMatrix+0x552>
movl   $0x0,-0x9628(%rbp)
cmpl   $0x14,-0x9628(%rbp)
jge    1639 <ExpSubstitutionMatrix+0x539>
movslq -0x9624(%rbp),%rcx
lea    -0x9620(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x9624(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x9628(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9628(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9628(%rbp)
jmp    15d3 <ExpSubstitutionMatrix+0x4d3>
jmp    163e <ExpSubstitutionMatrix+0x53e>
mov    -0x9624(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9624(%rbp)
jmp    15bc <ExpSubstitutionMatrix+0x4bc>
jmp    1657 <ExpSubstitutionMatrix+0x557>
jmp    138f <ExpSubstitutionMatrix+0x28f>
jmp    1661 <ExpSubstitutionMatrix+0x561>
mov    -0x9634(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x9634(%rbp)
mov    -0x9630(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x9630(%rbp)
jmp    137d <ExpSubstitutionMatrix+0x27d>
add    $0x95c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ExpSubstitutionMatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x9698,%rsp
mov    %rdx,%rbx
mov    %esi,%r14d
mov    %rdi,%rsi
lea    0xd10(%rsp),%r15
mov    $0xc80,%edx
mov    %r15,%rdi
call   1030 <memcpy@plt>
mov    $0x1,%r8d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rcx
xor    %r9d,%r9d
cs nopw 0x0(%rax,%rax,1)
mov    %r15,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r9,%r9,4),%rax
shl    $0x5,%rax
imul   $0xc80,%r8,%rsi
add    %rsp,%rsi
add    $0xd10,%rsi
add    %rsi,%rax
lea    (%rax,%rdi,8),%rbp
movq   $0x0,(%rax,%rdi,8)
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
mov    %rdx,%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rcx,%rax,8),%xmm1
mulsd  (%rsi),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp)
movsd  (%rcx,%rax,8),%xmm0
mulsd  0xa0(%rsi),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp)
add    $0x2,%rax
add    $0x140,%rsi
cmp    $0x15,%rax
jne    11b0 <ExpSubstitutionMatrix+0xa0>
add    $0x1,%rdi
add    $0x8,%rdx
cmp    $0x14,%rdi
jne    1170 <ExpSubstitutionMatrix+0x60>
add    $0x1,%r9
add    $0xa0,%rcx
cmp    $0x14,%r9
jne    1160 <ExpSubstitutionMatrix+0x50>
add    $0x1,%r8
add    $0xc80,%r15
cmp    $0xb,%r8
jne    1150 <ExpSubstitutionMatrix+0x40>
lea    0x95f0(%rsp),%rbp
mov    $0x400,%r13d
mov    $0x1,%eax
xor    %edx,%edx
lea    0x90(%rsp),%r12
jmp    1278 <ExpSubstitutionMatrix+0x168>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13d,%ecx
shr    $0x1f,%ecx
add    %r13d,%ecx
sar    %ecx
mov    0x8(%rsp),%rdx
add    $0x1,%rdx
add    $0xfffffffffffff380,%rbp
mov    %ecx,%r13d
cmp    $0xb,%rdx
je     1594 <ExpSubstitutionMatrix+0x484>
cmp    %r13d,%r14d
mov    %rdx,0x8(%rsp)
jl     1250 <ExpSubstitutionMatrix+0x140>
mov    $0xa,%ecx
sub    %rdx,%rcx
imul   $0xc80,%rcx,%rcx
lea    (%rsp,%rcx,1),%r15
add    $0xd10,%r15
jmp    12b4 <ExpSubstitutionMatrix+0x1a4>
xchg   %ax,%ax
mov    $0xc80,%edx
mov    %rbx,%rdi
call   1030 <memcpy@plt>
xor    %eax,%eax
cmp    %r13d,%r14d
jl     1250 <ExpSubstitutionMatrix+0x140>
sub    %r13d,%r14d
mov    %r15,%rsi
test   %eax,%eax
jne    12a0 <ExpSubstitutionMatrix+0x190>
mov    %r12,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rcx,%rcx,4),%rdx
shl    $0x5,%rdx
movsd  (%rbx,%rdx,1),%xmm0
movsd  0x8(%rbx,%rdx,1),%xmm1
movsd  0x10(%rbx,%rdx,1),%xmm2
movsd  0x18(%rbx,%rdx,1),%xmm3
movlhps %xmm0,%xmm0
movaps %xmm0,0x80(%rsp)
movlhps %xmm1,%xmm1
movaps %xmm1,0x70(%rsp)
movlhps %xmm2,%xmm2
movaps %xmm2,0x60(%rsp)
movlhps %xmm3,%xmm3
movaps %xmm3,0x50(%rsp)
movsd  0x20(%rbx,%rdx,1),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x40(%rsp)
movsd  0x28(%rbx,%rdx,1),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x30(%rsp)
movsd  0x30(%rbx,%rdx,1),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
movsd  0x38(%rbx,%rdx,1),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x10(%rsp)
movsd  0x40(%rbx,%rdx,1),%xmm14
unpcklpd %xmm14,%xmm14
movsd  0x48(%rbx,%rdx,1),%xmm15
unpcklpd %xmm15,%xmm15
movsd  0x50(%rbx,%rdx,1),%xmm2
unpcklpd %xmm2,%xmm2
movsd  0x58(%rbx,%rdx,1),%xmm3
unpcklpd %xmm3,%xmm3
movsd  0x60(%rbx,%rdx,1),%xmm4
unpcklpd %xmm4,%xmm4
movsd  0x68(%rbx,%rdx,1),%xmm5
unpcklpd %xmm5,%xmm5
movsd  0x70(%rbx,%rdx,1),%xmm6
unpcklpd %xmm6,%xmm6
movsd  0x78(%rbx,%rdx,1),%xmm7
unpcklpd %xmm7,%xmm7
movsd  0x80(%rbx,%rdx,1),%xmm8
unpcklpd %xmm8,%xmm8
movsd  0x88(%rbx,%rdx,1),%xmm9
unpcklpd %xmm9,%xmm9
movsd  0x90(%rbx,%rdx,1),%xmm10
unpcklpd %xmm10,%xmm10
movsd  0x98(%rbx,%rdx,1),%xmm11
unpcklpd %xmm11,%xmm11
mov    $0xffffffffffffffec,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd -0xb40(%rbp,%rdx,8),%xmm12
f4 ff ff
mulpd  0x80(%rsp),%xmm12
addpd  0xbf3(%rip),%xmm12
movapd -0xaa0(%rbp,%rdx,8),%xmm13
f5 ff ff
mulpd  0x70(%rsp),%xmm13
addpd  %xmm12,%xmm13
movapd -0xa00(%rbp,%rdx,8),%xmm0
ff ff
mulpd  0x60(%rsp),%xmm0
addpd  %xmm13,%xmm0
movapd -0x960(%rbp,%rdx,8),%xmm1
ff ff
mulpd  0x50(%rsp),%xmm1
addpd  %xmm0,%xmm1
movapd -0x8c0(%rbp,%rdx,8),%xmm0
ff ff
mulpd  0x40(%rsp),%xmm0
addpd  %xmm1,%xmm0
movapd -0x820(%rbp,%rdx,8),%xmm1
ff ff
mulpd  0x30(%rsp),%xmm1
addpd  %xmm0,%xmm1
movapd -0x780(%rbp,%rdx,8),%xmm0
ff ff
mulpd  0x20(%rsp),%xmm0
addpd  %xmm1,%xmm0
movapd -0x6e0(%rbp,%rdx,8),%xmm1
ff ff
mulpd  0x10(%rsp),%xmm1
addpd  %xmm0,%xmm1
movapd -0x640(%rbp,%rdx,8),%xmm0
ff ff
mulpd  %xmm14,%xmm0
addpd  %xmm1,%xmm0
movapd -0x5a0(%rbp,%rdx,8),%xmm1
ff ff
mulpd  %xmm15,%xmm1
addpd  %xmm0,%xmm1
movapd -0x500(%rbp,%rdx,8),%xmm0
ff ff
mulpd  %xmm2,%xmm0
addpd  %xmm1,%xmm0
movapd -0x460(%rbp,%rdx,8),%xmm1
ff ff
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movapd -0x3c0(%rbp,%rdx,8),%xmm0
ff ff
mulpd  %xmm4,%xmm0
addpd  %xmm1,%xmm0
movapd -0x320(%rbp,%rdx,8),%xmm1
ff ff
mulpd  %xmm5,%xmm1
addpd  %xmm0,%xmm1
movapd -0x280(%rbp,%rdx,8),%xmm0
ff ff
mulpd  %xmm6,%xmm0
addpd  %xmm1,%xmm0
movapd -0x1e0(%rbp,%rdx,8),%xmm1
ff ff
mulpd  %xmm7,%xmm1
addpd  %xmm0,%xmm1
movapd -0x140(%rbp,%rdx,8),%xmm0
ff ff
mulpd  %xmm8,%xmm0
addpd  %xmm1,%xmm0
movapd -0xa0(%rbp,%rdx,8),%xmm1
ff ff
mulpd  %xmm9,%xmm1
addpd  %xmm0,%xmm1
movapd 0x0(%rbp,%rdx,8),%xmm0
mulpd  %xmm10,%xmm0
addpd  %xmm1,%xmm0
movapd 0xa0(%rbp,%rdx,8),%xmm1
mulpd  %xmm11,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0xa0(%rax,%rdx,8)
add    $0x2,%rdx
jne    13f0 <ExpSubstitutionMatrix+0x2e0>
add    $0x1,%rcx
add    $0xa0,%rax
cmp    $0x14,%rcx
jne    12d0 <ExpSubstitutionMatrix+0x1c0>
mov    %r12,%rsi
jmp    12a0 <ExpSubstitutionMatrix+0x190>
add    $0x9698,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @ExpSubstitutionMatrix([20 x double]* %0, i32 %1, [20 x double]* %2) {
%4 = alloca [20 x double]*
%5 = alloca i32
%6 = alloca [20 x double]*
%7 = alloca [11 x [20 x [20 x double]]]
%8 = alloca [20 x [20 x double]]
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
store [20 x double]* %0, [20 x double]** %4
store i32 %1, i32* %5
store [20 x double]* %2, [20 x double]** %6
store i32 0, i32* %9
br label %15
15: ; preds = %42, %3
%16 = load i32, i32* %9
%17 = icmp slt i32 %16, 20
br i1 %17, label %18, label %45
18: ; preds = %15
store i32 0, i32* %10
br label %19
19: ; preds = %38, %18
%20 = load i32, i32* %10
%21 = icmp slt i32 %20, 20
br i1 %21, label %22, label %41
22: ; preds = %19
%23 = load [20 x double]*, [20 x double]** %4
%24 = load i32, i32* %9
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [20 x double], [20 x double]* %23, i64 %25
%27 = load i32, i32* %10
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [20 x double], [20 x double]* %26, i64 0, i64 %28
%30 = load double, double* %29
%31 = getelementptr inbounds [11 x [20 x [20 x double]]], [11 x [20 x [20 x double]]]* %7, i64 0, i64 0
%32 = load i32, i32* %9
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [20 x [20 x double]], [20 x [20 x double]]* %31, i64 0, i64 %33
%35 = load i32, i32* %10
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [20 x double], [20 x double]* %34, i64 0, i64 %36
store double %30, double* %37
br label %38
38: ; preds = %22
%39 = load i32, i32* %10
%40 = add nsw i32 %39, 1
store i32 %40, i32* %10
br label %19
41: ; preds = %19
br label %42
42: ; preds = %41
%43 = load i32, i32* %9
%44 = add nsw i32 %43, 1
store i32 %44, i32* %9
br label %15
45: ; preds = %15
store i32 1, i32* %12
br label %46
46: ; preds = %116, %45
%47 = load i32, i32* %12
%48 = icmp slt i32 %47, 11
br i1 %48, label %49, label %119
49: ; preds = %46
store i32 0, i32* %9
br label %50
50: ; preds = %112, %49
%51 = load i32, i32* %9
%52 = icmp slt i32 %51, 20
br i1 %52, label %53, label %115
53: ; preds = %50
store i32 0, i32* %10
br label %54
54: ; preds = %108, %53
%55 = load i32, i32* %10
%56 = icmp slt i32 %55, 20
br i1 %56, label %57, label %111
57: ; preds = %54
%58 = load i32, i32* %12
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [11 x [20 x [20 x double]]], [11 x [20 x [20 x double]]]* %7, i64 0, i64 %59
%61 = load i32, i32* %9
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [20 x [20 x double]], [20 x [20 x double]]* %60, i64 0, i64 %62
%64 = load i32, i32* %10
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [20 x double], [20 x double]* %63, i64 0, i64 %65
store double 0.000000e+00, double* %66
store i32 0, i32* %11
br label %67
67: ; preds = %104, %57
%68 = load i32, i32* %11
%69 = icmp slt i32 %68, 20
br i1 %69, label %70, label %107
70: ; preds = %67
%71 = load i32, i32* %12
%72 = sub nsw i32 %71, 1
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [11 x [20 x [20 x double]]], [11 x [20 x [20 x double]]]* %7, i64 0, i64 %73
%75 = load i32, i32* %9
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [20 x [20 x double]], [20 x [20 x double]]* %74, i64 0, i64 %76
%78 = load i32, i32* %11
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [20 x double], [20 x double]* %77, i64 0, i64 %79
%81 = load double, double* %80
%82 = load i32, i32* %12
%83 = sub nsw i32 %82, 1
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [11 x [20 x [20 x double]]], [11 x [20 x [20 x double]]]* %7, i64 0, i64 %84
%86 = load i32, i32* %11
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [20 x [20 x double]], [20 x [20 x double]]* %85, i64 0, i64 %87
%89 = load i32, i32* %10
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [20 x double], [20 x double]* %88, i64 0, i64 %90
%92 = load double, double* %91
%93 = load i32, i32* %12
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [11 x [20 x [20 x double]]], [11 x [20 x [20 x double]]]* %7, i64 0, i64 %94
%96 = load i32, i32* %9
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [20 x [20 x double]], [20 x [20 x double]]* %95, i64 0, i64 %97
%99 = load i32, i32* %10
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [20 x double], [20 x double]* %98, i64 0, i64 %100
%102 = load double, double* %101
%103 = call double @llvm.fmuladd.f64(double %81, double %92, double %102)
store double %103, double* %101
br label %104
104: ; preds = %70
%105 = load i32, i32* %11
%106 = add nsw i32 %105, 1
store i32 %106, i32* %11
br label %67
107: ; preds = %67
br label %108
108: ; preds = %107
%109 = load i32, i32* %10
%110 = add nsw i32 %109, 1
store i32 %110, i32* %10
br label %54
111: ; preds = %54
br label %112
112: ; preds = %111
%113 = load i32, i32* %9
%114 = add nsw i32 %113, 1
store i32 %114, i32* %9
br label %50
115: ; preds = %50
br label %116
116: ; preds = %115
%117 = load i32, i32* %12
%118 = add nsw i32 %117, 1
store i32 %118, i32* %12
br label %46
119: ; preds = %46
store i32 1, i32* %14
store i32 10, i32* %12
store i32 1024, i32* %13
br label %120
120: ; preds = %257, %119
%121 = load i32, i32* %13
%122 = icmp sge i32 %121, 1
br i1 %122, label %123, label %262
123: ; preds = %120
br label %124
124: ; preds = %255, %123
%125 = load i32, i32* %5
%126 = load i32, i32* %13
%127 = icmp sge i32 %125, %126
br i1 %127, label %128, label %256
128: ; preds = %124
%129 = load i32, i32* %13
%130 = load i32, i32* %5
%131 = sub nsw i32 %130, %129
store i32 %131, i32* %5
%132 = load i32, i32* %14
%133 = icmp ne i32 %132, 0
br i1 %133, label %134, label %168
134: ; preds = %128
store i32 0, i32* %9
br label %135
135: ; preds = %164, %134
%136 = load i32, i32* %9
%137 = icmp slt i32 %136, 20
br i1 %137, label %138, label %167
138: ; preds = %135
store i32 0, i32* %10
br label %139
139: ; preds = %160, %138
%140 = load i32, i32* %10
%141 = icmp slt i32 %140, 20
br i1 %141, label %142, label %163
142: ; preds = %139
%143 = load i32, i32* %12
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [11 x [20 x [20 x double]]], [11 x [20 x [20 x double]]]* %7, i64 0, i64 %144
%146 = load i32, i32* %9
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [20 x [20 x double]], [20 x [20 x double]]* %145, i64 0, i64 %147
%149 = load i32, i32* %10
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds [20 x double], [20 x double]* %148, i64 0, i64 %150
%152 = load double, double* %151
%153 = load [20 x double]*, [20 x double]** %6
%154 = load i32, i32* %9
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [20 x double], [20 x double]* %153, i64 %155
%157 = load i32, i32* %10
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds [20 x double], [20 x double]* %156, i64 0, i64 %158
store double %152, double* %159
br label %160
160: ; preds = %142
%161 = load i32, i32* %10
%162 = add nsw i32 %161, 1
store i32 %162, i32* %10
br label %139
163: ; preds = %139
br label %164
164: ; preds = %163
%165 = load i32, i32* %9
%166 = add nsw i32 %165, 1
store i32 %166, i32* %9
br label %135
167: ; preds = %135
store i32 0, i32* %14
br label %255
168: ; preds = %128
store i32 0, i32* %9
br label %169
169: ; preds = %221, %168
%170 = load i32, i32* %9
%171 = icmp slt i32 %170, 20
br i1 %171, label %172, label %224
172: ; preds = %169
store i32 0, i32* %10
br label %173
173: ; preds = %217, %172
%174 = load i32, i32* %10
%175 = icmp slt i32 %174, 20
br i1 %175, label %176, label %220
176: ; preds = %173
%177 = load i32, i32* %9
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds [20 x [20 x double]], [20 x [20 x double]]* %8, i64 0, i64 %178
%180 = load i32, i32* %10
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [20 x double], [20 x double]* %179, i64 0, i64 %181
store double 0.000000e+00, double* %182
store i32 0, i32* %11
br label %183
183: ; preds = %213, %176
%184 = load i32, i32* %11
%185 = icmp slt i32 %184, 20
br i1 %185, label %186, label %216
186: ; preds = %183
%187 = load [20 x double]*, [20 x double]** %6
%188 = load i32, i32* %9
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [20 x double], [20 x double]* %187, i64 %189
%191 = load i32, i32* %11
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds [20 x double], [20 x double]* %190, i64 0, i64 %192
%194 = load double, double* %193
%195 = load i32, i32* %12
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds [11 x [20 x [20 x double]]], [11 x [20 x [20 x double]]]* %7, i64 0, i64 %196
%198 = load i32, i32* %11
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [20 x [20 x double]], [20 x [20 x double]]* %197, i64 0, i64 %199
%201 = load i32, i32* %10
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [20 x double], [20 x double]* %200, i64 0, i64 %202
%204 = load double, double* %203
%205 = load i32, i32* %9
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds [20 x [20 x double]], [20 x [20 x double]]* %8, i64 0, i64 %206
%208 = load i32, i32* %10
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [20 x double], [20 x double]* %207, i64 0, i64 %209
%211 = load double, double* %210
%212 = call double @llvm.fmuladd.f64(double %194, double %204, double %211)
store double %212, double* %210
br label %213
213: ; preds = %186
%214 = load i32, i32* %11
%215 = add nsw i32 %214, 1
store i32 %215, i32* %11
br label %183
216: ; preds = %183
br label %217
217: ; preds = %216
%218 = load i32, i32* %10
%219 = add nsw i32 %218, 1
store i32 %219, i32* %10
br label %173
220: ; preds = %173
br label %221
221: ; preds = %220
%222 = load i32, i32* %9
%223 = add nsw i32 %222, 1
store i32 %223, i32* %9
br label %169
224: ; preds = %169
store i32 0, i32* %9
br label %225
225: ; preds = %251, %224
%226 = load i32, i32* %9
%227 = icmp slt i32 %226, 20
br i1 %227, label %228, label %254
228: ; preds = %225
store i32 0, i32* %10
br label %229
229: ; preds = %247, %228
%230 = load i32, i32* %10
%231 = icmp slt i32 %230, 20
br i1 %231, label %232, label %250
232: ; preds = %229
%233 = load i32, i32* %9
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [20 x [20 x double]], [20 x [20 x double]]* %8, i64 0, i64 %234
%236 = load i32, i32* %10
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds [20 x double], [20 x double]* %235, i64 0, i64 %237
%239 = load double, double* %238
%240 = load [20 x double]*, [20 x double]** %6
%241 = load i32, i32* %9
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds [20 x double], [20 x double]* %240, i64 %242
%244 = load i32, i32* %10
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds [20 x double], [20 x double]* %243, i64 0, i64 %245
store double %239, double* %246
br label %247
247: ; preds = %232
%248 = load i32, i32* %10
%249 = add nsw i32 %248, 1
store i32 %249, i32* %10
br label %229
250: ; preds = %229
br label %251
251: ; preds = %250
%252 = load i32, i32* %9
%253 = add nsw i32 %252, 1
store i32 %253, i32* %9
br label %225
254: ; preds = %225
br label %255
255: ; preds = %254, %167
br label %124
256: ; preds = %124
br label %257
257: ; preds = %256
%258 = load i32, i32* %13
%259 = sdiv i32 %258, 2
store i32 %259, i32* %13
%260 = load i32, i32* %12
%261 = add nsw i32 %260, -1
store i32 %261, i32* %12
br label %120
262: ; preds = %120
ret void
}

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