void construct_total_matrix(double *ld, double *md, double *ud, double *mat,
                            int n, int m) {
  int i, j, k;
  int size = m * m;
  i = 0;
  for (j = i * m; j < (i + 1) * m; j++) {
    for (k = i * m; k < (i + 1) * m; k++) {
      mat[k + j * n] = md[i * size + k + j * m];
    }
    for (k = (i + 1) * m; k < (i + 2) * m; k++) {
      mat[k + j * n] = ud[i * size + k + j * m];
    }
  }
  for (i = 1; i < n - 1; i++) {
    for (j = i * m; j < (i + 1) * m; j++) {
      for (k = i * m; k < (i + 1) * m; k++) {
        mat[k + j * n] = md[i * size + k + j * m];
      }
      for (k = (i + 1) * m; k < (i + 2) * m; k++) {
        mat[k + j * n] = ud[i * size + k + j * m];
      }
      for (k = (i - 1) * m; k < i * m; k++) {
        mat[k + j * n] = ld[i * size + k + j * m];
      }
    }
  }
  i = n - 1;
  for (j = i * m; j < (i + 1) * m; j++) {
    for (k = i * m; k < (i + 1) * m; k++) {
      mat[k + j * n] = md[i * size + k + j * m];
    }
    for (k = (i - 1) * m; k < i * m; k++) {
      mat[k + j * n] = ld[i * size + k + j * m];
    }
  }
}


x86 assembly (clang, -O0):
<construct_total_matrix>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    122a <construct_total_matrix+0x12a>
mov    -0x2c(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    11b0 <construct_total_matrix+0xb0>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1156 <construct_total_matrix+0x56>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1217 <construct_total_matrix+0x117>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11bd <construct_total_matrix+0xbd>
jmp    121c <construct_total_matrix+0x11c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1137 <construct_total_matrix+0x37>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13b6 <construct_total_matrix+0x2b6>
mov    -0x2c(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    13a3 <construct_total_matrix+0x2a3>
mov    -0x2c(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    12c5 <construct_total_matrix+0x1c5>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    126b <construct_total_matrix+0x16b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    132c <construct_total_matrix+0x22c>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12d2 <construct_total_matrix+0x1d2>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1390 <construct_total_matrix+0x290>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1339 <construct_total_matrix+0x239>
jmp    1395 <construct_total_matrix+0x295>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    124c <construct_total_matrix+0x14c>
jmp    13a8 <construct_total_matrix+0x2a8>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1231 <construct_total_matrix+0x131>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    14b9 <construct_total_matrix+0x3b9>
mov    -0x2c(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1442 <construct_total_matrix+0x342>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13e8 <construct_total_matrix+0x2e8>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    14a6 <construct_total_matrix+0x3a6>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    144f <construct_total_matrix+0x34f>
jmp    14ab <construct_total_matrix+0x3ab>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13c9 <construct_total_matrix+0x2c9>
pop    %rbp
ret

x86 assembly (clang, -O2):
<construct_total_matrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1d0,%rsp
mov    %rcx,-0x80(%rsp)
mov    %rdi,-0x78(%rsp)
mov    %r9d,%edi
mov    %r8,0xa8(%rsp)
movslq %r8d,%rax
mov    %rax,0x70(%rsp)
mov    %r9,%rax
mov    %r9,-0x58(%rsp)
test   %r9d,%r9d
mov    %rdi,-0x70(%rsp)
mov    %rdx,-0x28(%rsp)
jle    1594 <construct_total_matrix+0x494>
mov    -0x58(%rsp),%rax
add    %eax,%eax
mov    %eax,-0x48(%rsp)
cltq
mov    %rax,-0x60(%rsp)
mov    %rax,%rcx
sub    %rdi,%rcx
mov    %edi,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x18(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rsp)
mov    %rax,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
lea    -0x4(%rcx),%rax
mov    %rax,-0x20(%rsp)
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rbp,%rax
mov    %rbp,0x38(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rbp
mov    %rbp,0x8(%rsp)
mov    %edi,%ebp
and    $0x3,%ebp
mov    %rbp,0x40(%rsp)
mov    %rcx,-0x50(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x30(%rsp)
add    %rdi,%rcx
mov    %rcx,-0x8(%rsp)
mov    %rbx,%rcx
mov    %rbx,(%rsp)
and    %rax,%rbx
mov    %rbx,0x28(%rsp)
lea    0x30(%rsi),%r13
lea    0x0(,%rdi,8),%rax
mov    %rax,-0x10(%rsp)
mov    -0x80(%rsp),%rax
lea    0x30(%rax),%r14
mov    0x70(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
mov    %rcx,-0x40(%rsp)
lea    (%rax,%rdi,8),%r8
add    $0x30,%r8
lea    (%rdx,%rdi,8),%r11
add    $0x30,%r11
xor    %r9d,%r9d
mov    %rdx,%r15
mov    %rsi,%rbp
jmp    1266 <construct_total_matrix+0x166>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9
mov    -0x10(%rsp),%rcx
add    %rcx,%r13
mov    -0x40(%rsp),%rdx
add    %rdx,%r14
add    %rdx,%rax
add    %rcx,%rbp
add    %rdx,%r8
add    %rcx,%r11
add    %rcx,%r15
mov    -0x70(%rsp),%rdi
cmp    %rdi,%r9
mov    -0x28(%rsp),%rdx
je     1594 <construct_total_matrix+0x494>
mov    %r9,%rdx
imul   0x70(%rsp),%rdx
mov    %r9,%r12
imul   %rdi,%r12
lea    (%rdx,%rdi,1),%rcx
lea    (%r12,%rdi,1),%rbx
mov    -0x80(%rsp),%rdi
lea    (%rdi,%rcx,8),%r10
cmpl   $0x4,-0x58(%rsp)
mov    %rdx,-0x68(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r10,-0x38(%rsp)
jb     12bb <construct_total_matrix+0x1bb>
lea    (%rsi,%rbx,8),%rcx
lea    (%rdi,%rdx,8),%rdi
cmp    %rcx,%rdi
jae    1350 <construct_total_matrix+0x250>
lea    (%rsi,%r12,8),%rcx
cmp    %r10,%rcx
jae    1350 <construct_total_matrix+0x250>
xor    %ecx,%ecx
mov    -0x70(%rsp),%rbx
mov    %rcx,%rdi
not    %rdi
add    %rbx,%rdi
mov    0x40(%rsp),%rbx
test   %rbx,%rbx
je     12f5 <construct_total_matrix+0x1f5>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rbx
jne    12e0 <construct_total_matrix+0x1e0>
cmp    $0x3,%rdi
mov    -0x70(%rsp),%rdi
jb     13f0 <construct_total_matrix+0x2f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    1310 <construct_total_matrix+0x210>
jmp    13f0 <construct_total_matrix+0x2f0>
nopl   (%rax)
cmpq   $0x0,-0x30(%rsp)
je     1466 <construct_total_matrix+0x366>
mov    0x8(%rsp),%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%r13,%rcx,8),%xmm0
movups -0x20(%r13,%rcx,8),%xmm1
movups %xmm0,-0x30(%r14,%rcx,8)
movups %xmm1,-0x20(%r14,%rcx,8)
movups -0x10(%r13,%rcx,8),%xmm0
movups 0x0(%r13,%rcx,8),%xmm1
movups %xmm0,-0x10(%r14,%rcx,8)
movups %xmm1,(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1370 <construct_total_matrix+0x270>
testb  $0x1,0x38(%rsp)
je     13ce <construct_total_matrix+0x2ce>
lea    (%rcx,%r12,1),%rdi
movups (%rsi,%rdi,8),%xmm0
movups 0x10(%rsi,%rdi,8),%xmm1
add    %rdx,%rcx
mov    -0x80(%rsp),%rdi
movups %xmm0,(%rdi,%rcx,8)
movups %xmm1,0x10(%rdi,%rcx,8)
mov    -0x18(%rsp),%rdx
mov    %rdx,%rcx
mov    -0x70(%rsp),%rbx
cmp    %rbx,%rdx
jne    12c2 <construct_total_matrix+0x1c2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x48(%rsp),%ecx
cmp    -0x58(%rsp),%ecx
mov    -0x60(%rsp),%rbx
jle    1230 <construct_total_matrix+0x130>
mov    -0x70(%rsp),%r10
cmpq   $0x4,-0x50(%rsp)
jb     1510 <construct_total_matrix+0x410>
lea    (%r12,%rbx,1),%rcx
mov    -0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
cmp    %rcx,-0x38(%rsp)
jae    1455 <construct_total_matrix+0x355>
mov    -0x68(%rsp),%rcx
add    %rbx,%rcx
mov    -0x80(%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
mov    -0x28(%rsp),%rdx
mov    0x10(%rsp),%rdi
lea    (%rdx,%rdi,8),%rdi
mov    -0x70(%rsp),%r10
cmp    %rcx,%rdi
jb     1510 <construct_total_matrix+0x410>
cmpq   $0x4,-0x20(%rsp)
jae    1478 <construct_total_matrix+0x378>
xor    %ecx,%ecx
mov    -0x28(%rsp),%rdx
jmp    14c8 <construct_total_matrix+0x3c8>
xor    %ecx,%ecx
testb  $0x1,0x38(%rsp)
jne    13b0 <construct_total_matrix+0x2b0>
jmp    13ce <construct_total_matrix+0x2ce>
mov    0x28(%rsp),%rdi
xor    %ecx,%ecx
mov    -0x28(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%r11,%rcx,8),%xmm0
movups -0x20(%r11,%rcx,8),%xmm1
movups %xmm0,-0x30(%r8,%rcx,8)
movups %xmm1,-0x20(%r8,%rcx,8)
movups -0x10(%r11,%rcx,8),%xmm0
movups (%r11,%rcx,8),%xmm1
movups %xmm0,-0x10(%r8,%rcx,8)
movups %xmm1,(%r8,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1490 <construct_total_matrix+0x390>
testb  $0x1,(%rsp)
je     14f4 <construct_total_matrix+0x3f4>
add    -0x70(%rsp),%rcx
add    %rcx,%r12
movups (%rdx,%r12,8),%xmm0
movups 0x10(%rdx,%r12,8),%xmm1
add    -0x68(%rsp),%rcx
mov    -0x80(%rsp),%rdi
movups %xmm0,(%rdi,%rcx,8)
movups %xmm1,0x10(%rdi,%rcx,8)
mov    -0x8(%rsp),%r10
mov    0x30(%rsp),%rcx
cmp    %rcx,-0x50(%rsp)
je     1230 <construct_total_matrix+0x130>
nopl   0x0(%rax)
mov    -0x48(%rsp),%ecx
mov    %ecx,%edi
sub    %r10d,%edi
mov    %r10,%rcx
not    %rcx
add    %rbx,%rcx
and    $0x3,%rdi
je     1546 <construct_total_matrix+0x446>
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%r10,8),%xmm0
movsd  %xmm0,(%rax,%r10,8)
add    $0x1,%r10
add    $0xffffffffffffffff,%rdi
jne    1530 <construct_total_matrix+0x430>
cmp    $0x3,%rcx
jb     1230 <construct_total_matrix+0x130>
movsd  (%r15,%r10,8),%xmm0
movsd  %xmm0,(%rax,%r10,8)
movsd  0x8(%r15,%r10,8),%xmm0
movsd  %xmm0,0x8(%rax,%r10,8)
movsd  0x10(%r15,%r10,8),%xmm0
movsd  %xmm0,0x10(%rax,%r10,8)
movsd  0x18(%r15,%r10,8),%xmm0
movsd  %xmm0,0x18(%rax,%r10,8)
add    $0x4,%r10
cmp    %r10,%rbx
jne    1550 <construct_total_matrix+0x450>
jmp    1230 <construct_total_matrix+0x130>
mov    -0x58(%rsp),%rdi
mov    %edi,%eax
imul   %eax,%eax
mov    %rax,0x18(%rsp)
mov    0xa8(%rsp),%rax
lea    -0x1(%rax),%r11d
cmp    $0x3,%eax
mov    -0x80(%rsp),%r15
mov    -0x78(%rsp),%rbp
jl     2121 <construct_total_matrix+0x1021>
lea    (%rdi,%rdi,1),%r10d
lea    (%rdi,%rdi,2),%ebx
mov    0xa8(%rsp),%r13d
lea    -0x1(%rdi),%eax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rcx,1),%r14d
lea    (%rdi,%rdi,1),%r8d
add    $0x1,%r8d
imul   %edi,%r8d
lea    0x1(%rax),%r12
lea    0x8(,%rax,8),%rcx
add    %rbp,%rcx
mov    %rcx,0x1a8(%rsp)
lea    (%rdi,%rdi,1),%r9d
add    $0x2,%r9d
imul   %edi,%r9d
lea    (%rdx,%rax,8),%rcx
add    $0x8,%rcx
mov    %rcx,0x1a0(%rsp)
mov    %r12,0x20(%rsp)
and    $0xfffffffffffffffc,%r12
mov    %r12,0x50(%rsp)
lea    -0x4(%r12),%rcx
mov    %rcx,0x60(%rsp)
mov    %rcx,%r12
shr    $0x2,%r12
add    $0x1,%r12
mov    %r12,%rcx
mov    %r12,0x58(%rsp)
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%r12
mov    %r12,0xb8(%rsp)
mov    %r9d,%ecx
add    $0x4,%ecx
mov    %rcx,0x138(%rsp)
lea    0x1(%r13),%rcx
mov    %rcx,0x170(%rsp)
mov    %rax,-0x68(%rsp)
lea    0x8(%rsi,%rax,8),%rax
mov    %rax,0xc8(%rsp)
lea    -0x1(%rdi,%rdi,1),%eax
mov    %eax,0xf4(%rsp)
lea    -0x1(%rdi,%rdi,2),%eax
mov    %rax,0x168(%rsp)
lea    0x30(%r15),%rax
mov    %rax,0x160(%rsp)
mov    %r13,0x88(%rsp)
lea    0x0(,%r13,8),%rax
mov    %rax,0xe0(%rsp)
lea    0x4(%r8),%eax
mov    %rax,0x130(%rsp)
lea    0x8(%r15),%rax
mov    %rax,0x158(%rsp)
mov    0x18(%rsp),%rax
add    %eax,%eax
add    $0x4,%eax
mov    %rax,0x128(%rsp)
mov    $0x1,%ecx
xor    %eax,%eax
mov    %rax,0x120(%rsp)
mov    -0x70(%rsp),%rax
mov    %rax,-0x30(%rsp)
mov    %r14,0x118(%rsp)
mov    %r9,%rax
mov    %r9,0x178(%rsp)
mov    %r9,0x110(%rsp)
mov    %r14,0x148(%rsp)
mov    %r14,0xb0(%rsp)
mov    %r8,0x140(%rsp)
mov    %r8,0x108(%rsp)
movl   $0x0,0x4c(%rsp)
mov    %r11d,0xf8(%rsp)
jmp    17ea <construct_total_matrix+0x6ea>
cs nopw 0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rax
add    %rax,-0x30(%rsp)
add    %rax,%r10
mov    0x30(%rsp),%rbx
add    %rax,%rbx
add    %edi,0x4c(%rsp)
addq   $0x1,0x120(%rsp)
mov    0x140(%rsp),%rax
add    %rax,0x130(%rsp)
add    %rax,0x108(%rsp)
mov    0xb0(%rsp),%rcx
add    0x148(%rsp),%rcx
mov    %rcx,0xb0(%rsp)
add    %rax,0x138(%rsp)
add    %rax,0x110(%rsp)
add    %rax,0x128(%rsp)
add    %rax,0x118(%rsp)
mov    0xf8(%rsp),%r11d
mov    0xfc(%rsp),%ecx
cmp    %r11d,%ecx
je     2121 <construct_total_matrix+0x1021>
mov    %rbx,0x30(%rsp)
mov    %ecx,%eax
imul   %edi,%ecx
mov    %rax,-0x8(%rsp)
add    $0x1,%eax
mov    %eax,0xfc(%rsp)
imul   %edi,%eax
mov    %ecx,0x98(%rsp)
mov    %eax,0x90(%rsp)
cmp    %eax,%ecx
jge    1760 <construct_total_matrix+0x660>
movslq -0x30(%rsp),%rcx
mov    %rcx,-0x60(%rsp)
mov    0x88(%rsp),%rbx
imul   %rcx,%rbx
movslq 0x4c(%rsp),%r15
lea    (%rbx,%r15,1),%rax
mov    %rax,0x150(%rsp)
movslq %r10d,%rax
lea    (%rbx,%rax,1),%r12
mov    %rax,%r11
mov    %rax,-0x20(%rsp)
mov    0x158(%rsp),%rax
lea    (%rax,%rbx,8),%r9
mov    %rdi,%r14
mov    0x170(%rsp),%rdi
imul   %rcx,%rdi
mov    0x120(%rsp),%r13
mov    %r13d,%ecx
imul   %r14d,%ecx
mov    -0x68(%rsp),%rax
add    %ecx,%eax
mov    %eax,0xc0(%rsp)
mov    0x168(%rsp),%rax
add    %ecx,%eax
mov    %eax,0x104(%rsp)
add    0xf4(%rsp),%ecx
mov    %rcx,0xd8(%rsp)
mov    %r13,%r8
mov    0x140(%rsp),%rcx
imul   %rcx,%r8
lea    (%r8,%rcx,1),%rax
mov    %rax,0x38(%rsp)
add    0x20(%rsp),%rbx
lea    (%rbx,%r11,1),%rax
mov    %rax,0x190(%rsp)
mov    0x178(%rsp),%rax
add    %r8,%rax
mov    %rax,0x78(%rsp)
add    %r15,%rbx
mov    %rbx,0x198(%rsp)
mov    0x148(%rsp),%rax
add    %rax,%r8
mov    %r8,0x1b8(%rsp)
imul   %r13d,%ecx
add    %eax,%ecx
mov    %ecx,0x100(%rsp)
mov    -0x8(%rsp),%r8
mov    %r8d,%eax
imul   0x18(%rsp),%eax
mov    %eax,-0x50(%rsp)
lea    0x2(%r8),%eax
imul   %r14d,%eax
mov    %eax,0xe8(%rsp)
add    $0xffffffff,%r8d
imul   %r14d,%r8d
mov    %r8,-0x8(%rsp)
mov    0x160(%rsp),%rax
mov    0x150(%rsp),%rcx
lea    (%rax,%rcx,8),%r8
mov    %r12,0x1c0(%rsp)
lea    (%rax,%r12,8),%r12
lea    (%rax,%rdi,8),%r11
mov    %rdi,0xd0(%rsp)
mov    0x20(%rsp),%rax
add    %rdi,%rax
mov    %rax,0x1c8(%rsp)
mov    %r14,%rdi
mov    0x50(%rsp),%rax
mov    -0x60(%rsp),%rcx
lea    (%rax,%rcx,1),%rbx
mov    %rbx,0x1b0(%rsp)
mov    -0x20(%rsp),%rcx
lea    (%rax,%rcx,1),%rbx
mov    %rbx,0x188(%rsp)
mov    %r15,(%rsp)
lea    (%rax,%r15,1),%rax
mov    %rax,0x180(%rsp)
mov    0x118(%rsp),%rax
mov    0x128(%rsp),%rcx
mov    %rcx,0x8(%rsp)
mov    0x110(%rsp),%rbx
mov    %rbx,0x28(%rsp)
mov    0x138(%rsp),%rcx
mov    %rcx,0xa0(%rsp)
mov    0xb0(%rsp),%r14
mov    0x108(%rsp),%r15
mov    0x130(%rsp),%rbx
xor    %r13d,%r13d
mov    -0x60(%rsp),%rcx
mov    %r10,0x68(%rsp)
jmp    1a6c <construct_total_matrix+0x96c>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x1,%r13
mov    0xe0(%rsp),%rax
add    %rax,%r11
mov    -0x70(%rsp),%rdi
mov    -0x10(%rsp),%rbx
add    %rdi,%rbx
mov    -0x18(%rsp),%r15
add    %rdi,%r15
add    %rdi,%r14
add    %rax,%r9
add    %rax,%r12
add    %rdi,0xa0(%rsp)
add    %rdi,0x28(%rsp)
add    %rax,%r8
add    %rdi,0x8(%rsp)
mov    0x40(%rsp),%rax
add    %rdi,%rax
cmp    %ecx,%r10d
mov    -0x58(%rsp),%rdi
je     1760 <construct_total_matrix+0x660>
mov    %rbx,-0x10(%rsp)
mov    %rax,0x40(%rsp)
mov    %r13,-0x48(%rsp)
mov    0x88(%rsp),%rax
imul   %rax,%r13
mov    %r13,-0x38(%rsp)
mov    %ecx,%r13d
imul   %edi,%r13d
add    -0x50(%rsp),%r13d
mov    %rcx,0x10(%rsp)
imul   %rax,%rcx
mov    %rcx,-0x40(%rsp)
mov    -0x60(%rsp),%rax
cmpl   $0x3,-0x68(%rsp)
mov    -0x70(%rsp),%rcx
jb     1c10 <construct_total_matrix+0xb10>
mov    -0x48(%rsp),%rdi
imul   %ecx,%edi
add    0x38(%rsp),%edi
mov    -0x68(%rsp),%rax
lea    (%rax,%rdi,1),%ebx
mov    -0x60(%rsp),%rax
cmp    %edi,%ebx
jl     1c10 <construct_total_matrix+0xb10>
mov    -0x48(%rsp),%rax
imul   %ecx,%eax
add    0x38(%rsp),%eax
cltq
mov    0xc8(%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
mov    0xd0(%rsp),%rbx
mov    -0x38(%rsp),%rbp
add    %rbp,%rbx
mov    -0x80(%rsp),%rbp
lea    0x0(,%rbx,8),%rbx
add    %rbp,%rbx
mov    -0x78(%rsp),%rbp
cmp    %rdi,%rbx
jae    1b4b <construct_total_matrix+0xa4b>
lea    (%rsi,%rax,8),%rdi
mov    0x1c8(%rsp),%rax
mov    -0x38(%rsp),%rbx
add    %rbx,%rax
mov    -0x80(%rsp),%rbx
lea    (%rbx,%rax,8),%rbx
mov    -0x60(%rsp),%rax
cmp    %rbx,%rdi
jb     1c10 <construct_total_matrix+0xb10>
cmpq   $0x0,0x60(%rsp)
je     1bb3 <construct_total_matrix+0xab3>
mov    0xb8(%rsp),%rax
xor    %ebx,%ebx
mov    -0x10(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r15,%rbx,1),%edi
movslq %edi,%rdi
movups (%rsi,%rdi,8),%xmm0
movups 0x10(%rsi,%rdi,8),%xmm1
movups %xmm0,-0x30(%r11,%rbx,8)
movups %xmm1,-0x20(%r11,%rbx,8)
lea    (%r10,%rbx,1),%edi
movslq %edi,%rdi
movups (%rsi,%rdi,8),%xmm0
movups 0x10(%rsi,%rdi,8),%xmm1
movups %xmm0,-0x10(%r11,%rbx,8)
movups %xmm1,(%r11,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    1b70 <construct_total_matrix+0xa70>
jmp    1bb5 <construct_total_matrix+0xab5>
xor    %ebx,%ebx
testb  $0x1,0x58(%rsp)
mov    -0x28(%rsp),%rdx
mov    0x68(%rsp),%r10
je     1bf3 <construct_total_matrix+0xaf3>
mov    -0x60(%rsp),%rdi
lea    (%rbx,%rdi,1),%rax
add    %edi,%ebx
add    %r13d,%ebx
movslq %ebx,%rdi
movups (%rsi,%rdi,8),%xmm0
movups 0x10(%rsi,%rdi,8),%xmm1
add    -0x40(%rsp),%rax
mov    -0x80(%rsp),%rdi
movups %xmm0,(%rdi,%rax,8)
movups %xmm1,0x10(%rdi,%rax,8)
mov    0x1b0(%rsp),%rax
mov    0x50(%rsp),%rdi
cmp    %rdi,0x20(%rsp)
je     1c8b <construct_total_matrix+0xb8b>
nopl   0x0(%rax,%rax,1)
mov    %r10d,%edi
sub    %eax,%edi
test   $0x1,%dil
jne    1c30 <construct_total_matrix+0xb30>
mov    %rax,%rdi
cmp    %eax,0xd8(%rsp)
jne    1c60 <construct_total_matrix+0xb60>
jmp    1c8b <construct_total_matrix+0xb8b>
nopl   0x0(%rax)
add    %eax,%r13d
movslq %r13d,%rdi
movsd  (%rsi,%rdi,8),%xmm0
mov    -0x40(%rsp),%rdi
add    %rax,%rdi
mov    -0x80(%rsp),%rbx
movsd  %xmm0,(%rbx,%rdi,8)
mov    %rax,%rdi
add    $0x1,%rdi
cmp    %eax,0xd8(%rsp)
je     1c8b <construct_total_matrix+0xb8b>
nopl   (%rax)
lea    (%r14,%rdi,1),%rax
cltq
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r9,%rdi,8)
add    $0x1,%eax
cltq
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rdi,8)
add    $0x2,%rdi
cmp    %edi,%r10d
jne    1c60 <construct_total_matrix+0xb60>
mov    %r15,-0x18(%rsp)
mov    0xe8(%rsp),%eax
cmp    %eax,0x90(%rsp)
mov    0x30(%rsp),%r15
jge    1e8b <construct_total_matrix+0xd8b>
mov    0x10(%rsp),%rax
mov    %eax,%r13d
imul   -0x58(%rsp),%r13d
add    -0x50(%rsp),%r13d
mov    -0x20(%rsp),%rax
cmpl   $0x3,-0x68(%rsp)
jb     1e10 <construct_total_matrix+0xd10>
mov    -0x48(%rsp),%rdi
imul   %ecx,%edi
add    0x78(%rsp),%edi
mov    -0x68(%rsp),%rax
lea    (%rax,%rdi,1),%ebp
mov    -0x20(%rsp),%rax
cmp    %edi,%ebp
mov    -0x78(%rsp),%rbp
jl     1e10 <construct_total_matrix+0xd10>
mov    -0x48(%rsp),%rax
imul   %ecx,%eax
mov    0x1c0(%rsp),%rdi
mov    -0x38(%rsp),%rcx
add    %rcx,%rdi
add    0x78(%rsp),%eax
mov    -0x80(%rsp),%rcx
lea    (%rcx,%rdi,8),%rdi
cltq
mov    0x1a0(%rsp),%rbp
lea    0x0(%rbp,%rax,8),%rbp
cmp    %rbp,%rdi
jae    1d5b <construct_total_matrix+0xc5b>
mov    0x190(%rsp),%rdi
mov    -0x38(%rsp),%rcx
add    %rcx,%rdi
mov    -0x80(%rsp),%rcx
lea    (%rcx,%rdi,8),%rdi
lea    (%rdx,%rax,8),%rbp
mov    -0x20(%rsp),%rax
cmp    %rdi,%rbp
mov    -0x78(%rsp),%rbp
jb     1e10 <construct_total_matrix+0xd10>
cmpq   $0x0,0x60(%rsp)
je     1ffe <construct_total_matrix+0xefe>
mov    0xb8(%rsp),%rdi
xor    %eax,%eax
mov    0x28(%rsp),%rbx
mov    0xa0(%rsp),%rcx
xchg   %ax,%ax
lea    (%rbx,%rax,1),%ebp
movslq %ebp,%rbp
movups (%rdx,%rbp,8),%xmm0
movups 0x10(%rdx,%rbp,8),%xmm1
movups %xmm0,-0x30(%r12,%rax,8)
movups %xmm1,-0x20(%r12,%rax,8)
lea    (%rcx,%rax,1),%ebp
movslq %ebp,%rbp
movups (%rdx,%rbp,8),%xmm0
movups 0x10(%rdx,%rbp,8),%xmm1
movups %xmm0,-0x10(%r12,%rax,8)
movups %xmm1,(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    1d80 <construct_total_matrix+0xc80>
testb  $0x1,0x58(%rsp)
je     1df2 <construct_total_matrix+0xcf2>
mov    -0x20(%rsp),%rdi
add    %rax,%rdi
add    %r10d,%eax
add    %r13d,%eax
cltq
movups (%rdx,%rax,8),%xmm0
movups 0x10(%rdx,%rax,8),%xmm1
add    -0x40(%rsp),%rdi
mov    -0x80(%rsp),%rax
movups %xmm0,(%rax,%rdi,8)
movups %xmm1,0x10(%rax,%rdi,8)
mov    0x188(%rsp),%rax
mov    0x50(%rsp),%rdi
cmp    %rdi,0x20(%rsp)
mov    -0x78(%rsp),%rbp
je     1e8b <construct_total_matrix+0xd8b>
nop
mov    %r15d,%edi
sub    %eax,%edi
test   $0x1,%dil
jne    1e30 <construct_total_matrix+0xd30>
mov    %rax,%rdi
cmp    %eax,0x104(%rsp)
jne    1e60 <construct_total_matrix+0xd60>
jmp    1e8b <construct_total_matrix+0xd8b>
nopl   0x0(%rax)
add    %eax,%r13d
movslq %r13d,%rdi
movsd  (%rdx,%rdi,8),%xmm0
mov    -0x40(%rsp),%rcx
lea    (%rax,%rcx,1),%rdi
mov    -0x80(%rsp),%rcx
movsd  %xmm0,(%rcx,%rdi,8)
mov    %rax,%rdi
add    $0x1,%rdi
cmp    %eax,0x104(%rsp)
je     1e8b <construct_total_matrix+0xd8b>
xchg   %ax,%ax
lea    (%r14,%rdi,1),%rax
cltq
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r9,%rdi,8)
add    $0x1,%eax
cltq
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rdi,8)
add    $0x2,%rdi
cmp    %edi,%r15d
jne    1e60 <construct_total_matrix+0xd60>
mov    0x98(%rsp),%eax
cmp    %eax,-0x8(%rsp)
mov    -0x30(%rsp),%rbx
mov    -0x48(%rsp),%r13
mov    0x10(%rsp),%rcx
jge    1a10 <construct_total_matrix+0x910>
mov    %ecx,%eax
imul   -0x58(%rsp),%eax
add    -0x50(%rsp),%eax
mov    %eax,0x80(%rsp)
mov    (%rsp),%rax
cmpl   $0x3,-0x68(%rsp)
jb     2090 <construct_total_matrix+0xf90>
mov    %r13d,%edi
imul   -0x58(%rsp),%edi
add    0x100(%rsp),%edi
mov    -0x68(%rsp),%rax
lea    (%rdi,%rax,1),%ebp
mov    (%rsp),%rax
cmp    %edi,%ebp
mov    -0x78(%rsp),%rbp
jl     2090 <construct_total_matrix+0xf90>
mov    %r13d,%eax
imul   -0x70(%rsp),%eax
mov    0x150(%rsp),%rdi
mov    -0x38(%rsp),%rbx
add    %rbx,%rdi
add    0x1b8(%rsp),%eax
mov    -0x80(%rsp),%rbx
lea    (%rbx,%rdi,8),%rdi
cltq
mov    0x1a8(%rsp),%rbx
lea    (%rbx,%rax,8),%rbp
mov    -0x30(%rsp),%rbx
cmp    %rbp,%rdi
mov    -0x78(%rsp),%rbp
jae    1f72 <construct_total_matrix+0xe72>
mov    -0x38(%rsp),%rdi
add    0x198(%rsp),%rdi
mov    -0x80(%rsp),%rbp
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
mov    -0x78(%rsp),%rbp
lea    0x0(%rbp,%rax,8),%rbp
mov    (%rsp),%rax
cmp    %rdi,%rbp
mov    -0x78(%rsp),%rbp
jb     2090 <construct_total_matrix+0xf90>
cmpq   $0x0,0x60(%rsp)
je     2010 <construct_total_matrix+0xf10>
mov    0xb8(%rsp),%rdi
xor    %eax,%eax
mov    0x8(%rsp),%r15
mov    0x40(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r10,%rax,1),%ebp
movslq %ebp,%rbp
mov    -0x78(%rsp),%r13
movups 0x0(%r13,%rbp,8),%xmm0
mov    -0x78(%rsp),%rbx
movups 0x10(%rbx,%rbp,8),%xmm1
movups %xmm0,-0x30(%r8,%rax,8)
movups %xmm1,-0x20(%r8,%rax,8)
lea    (%r15,%rax,1),%ebp
movslq %ebp,%rbp
mov    -0x78(%rsp),%rbx
movups (%rbx,%rbp,8),%xmm0
mov    -0x78(%rsp),%rbx
movups 0x10(%rbx,%rbp,8),%xmm1
mov    -0x78(%rsp),%rbp
movups %xmm0,-0x10(%r8,%rax,8)
movups %xmm1,(%r8,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    1fa0 <construct_total_matrix+0xea0>
jmp    2017 <construct_total_matrix+0xf17>
xor    %eax,%eax
testb  $0x1,0x58(%rsp)
jne    1dc6 <construct_total_matrix+0xcc6>
jmp    1df2 <construct_total_matrix+0xcf2>
xor    %eax,%eax
mov    0x8(%rsp),%r15
mov    %r15,%r13
testb  $0x1,0x58(%rsp)
mov    0x68(%rsp),%r10
mov    -0x28(%rsp),%rdx
je     205c <construct_total_matrix+0xf5c>
mov    (%rsp),%rdi
add    %rax,%rdi
add    0x4c(%rsp),%eax
add    0x80(%rsp),%eax
cltq
movups 0x0(%rbp,%rax,8),%xmm0
movups 0x10(%rbp,%rax,8),%xmm1
add    -0x40(%rsp),%rdi
mov    -0x80(%rsp),%rax
movups %xmm0,(%rax,%rdi,8)
movups %xmm1,0x10(%rax,%rdi,8)
mov    0x180(%rsp),%rax
mov    0x50(%rsp),%rdi
cmp    %rdi,0x20(%rsp)
mov    -0x30(%rsp),%rbx
mov    %r13,0x8(%rsp)
mov    -0x48(%rsp),%r13
mov    0x10(%rsp),%rcx
je     1a10 <construct_total_matrix+0x910>
nopl   0x0(%rax,%rax,1)
mov    %ebx,%edi
sub    %eax,%edi
test   $0x1,%dil
jne    20b0 <construct_total_matrix+0xfb0>
mov    %rax,%rdi
cmp    %eax,0xc0(%rsp)
jne    20f0 <construct_total_matrix+0xff0>
jmp    1a10 <construct_total_matrix+0x910>
nopl   0x0(%rax,%rax,1)
mov    0x80(%rsp),%edi
add    %eax,%edi
movslq %edi,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm0
mov    -0x40(%rsp),%rdi
add    %rax,%rdi
mov    -0x80(%rsp),%r10
movsd  %xmm0,(%r10,%rdi,8)
mov    0x68(%rsp),%r10
mov    %rax,%rdi
add    $0x1,%rdi
cmp    %eax,0xc0(%rsp)
je     1a10 <construct_total_matrix+0x910>
xchg   %ax,%ax
lea    (%r14,%rdi,1),%rax
cltq
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r9,%rdi,8)
add    $0x1,%eax
cltq
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rdi,8)
add    $0x2,%rdi
cmp    %edi,%ebx
jne    20f0 <construct_total_matrix+0xff0>
jmp    1a10 <construct_total_matrix+0x910>
mov    %r11d,%ecx
imul   %edi,%ecx
mov    %edi,%edx
mov    0xa8(%rsp),%rax
imul   %eax,%edx
mov    %rcx,-0x10(%rsp)
mov    %edx,0x38(%rsp)
cmp    %edx,%ecx
jge    2783 <construct_total_matrix+0x1683>
mov    0x18(%rsp),%r9
imul   %r11d,%r9d
lea    -0x2(%rax),%ecx
mov    -0x58(%rsp),%r13
imul   %r13d,%ecx
mov    -0x10(%rsp),%rbx
movslq %ebx,%r10
mov    %ecx,-0x30(%rsp)
movslq %ecx,%rbp
movslq 0x38(%rsp),%rdx
mov    %rbp,%rcx
not    %rcx
add    %r10,%rcx
mov    %rcx,0x98(%rsp)
lea    (%rax,%rbx,2),%eax
add    $0xfffffffe,%eax
mov    %rax,0x90(%rsp)
mov    0x70(%rsp),%r11
mov    %r11,%r14
imul   %r10,%r14
lea    0x1(%r11),%r12
imul   %r10,%r12
lea    0x0(,%rbp,8),%rcx
mov    -0x78(%rsp),%rdi
sub    %rcx,%rdi
mov    %rdi,0x20(%rsp)
mov    %r10,%rdi
sub    %rbp,%rdi
mov    %r10,%rcx
not    %rcx
add    %rdx,%rcx
mov    %rcx,0x30(%rsp)
lea    0x1(%r13,%r13,1),%r15d
imul   %ebx,%r15d
mov    %r10,%rcx
neg    %rcx
mov    %rcx,0xa0(%rsp)
lea    0x0(,%r10,8),%rcx
mov    %rsi,%rbx
sub    %rcx,%rbx
mov    %rbx,0x88(%rsp)
mov    %rdx,%r8
sub    %r10,%r8
lea    -0x4(%r8),%rbx
mov    %rbx,0xe0(%rsp)
shr    $0x2,%rbx
add    $0x1,%rbx
lea    -0x4(%rdi),%rax
mov    %rax,0xd0(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %r8,0x40(%rsp)
and    $0xfffffffffffffffc,%r8
mov    %rbx,%rcx
mov    %rbx,0xd8(%rsp)
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rbx
mov    %rbx,0x60(%rsp)
mov    %rdx,%rbx
neg    %rbx
mov    %rbx,(%rsp)
mov    %rdi,0x28(%rsp)
mov    %rdi,%rbx
and    $0xfffffffffffffffc,%rbx
mov    %rax,%rdi
mov    %rax,0xc8(%rsp)
and    %rax,%rcx
mov    %rcx,0xc0(%rsp)
lea    (%r14,%rbp,1),%rax
lea    (%r14,%rdx,1),%rcx
mov    %rcx,0xe8(%rsp)
mov    -0x80(%rsp),%rcx
lea    (%rcx,%r14,8),%r14
add    $0x8,%r14
imul   0x90(%rsp),%r13d
mov    %r8,0x80(%rsp)
lea    (%r8,%r10,1),%rdi
mov    %rdi,0x78(%rsp)
mov    %r13,%r8
mov    %rbp,-0x18(%rsp)
mov    %rbx,0x58(%rsp)
lea    (%rbx,%rbp,1),%rdi
mov    %rdi,-0x28(%rsp)
mov    %r12,0x8(%rsp)
lea    0x30(%rcx,%r12,8),%r13
lea    0x0(,%r11,8),%rdi
mov    %rdi,-0x20(%rsp)
lea    0x4(%r15),%ebx
mov    %r9,0x18(%rsp)
lea    (%r9,%r9,1),%r11d
lea    0x1(%r11),%r9
mov    %rax,0x50(%rsp)
lea    0x30(%rcx,%rax,8),%rcx
lea    0x4(%r8),%edi
mov    %r15,%rax
mov    %r15,-0x8(%rsp)
xor    %ebp,%ebp
mov    %r10,%r12
mov    %r10,0x68(%rsp)
jmp    235a <construct_total_matrix+0x125a>
xchg   %ax,%ax
add    $0x1,%r12
mov    -0x68(%rsp),%rbp
add    $0x1,%rbp
mov    -0x20(%rsp),%rdi
add    %rdi,%r13
mov    -0x70(%rsp),%rax
mov    -0x38(%rsp),%rbx
add    %rax,%rbx
mov    0x10(%rsp),%r15
add    %rax,%r15
add    %rax,%r9
add    %rax,%r11
add    %rdi,%r14
add    %rdi,%rcx
mov    -0x48(%rsp),%rdi
add    %rax,%rdi
add    %rax,%r8
cmp    %rdx,%r12
je     2783 <construct_total_matrix+0x1683>
mov    %r15,0x10(%rsp)
mov    %rdi,-0x48(%rsp)
mov    %rbx,-0x38(%rsp)
mov    %rbp,%rax
mov    %rbp,-0x68(%rsp)
mov    0x70(%rsp),%rdi
imul   %rdi,%rbp
mov    0x8(%rsp),%rax
add    %rbp,%rax
mov    %r12d,%r15d
imul   -0x58(%rsp),%r15d
add    0x18(%rsp),%r15d
mov    %r12,%rbx
imul   %rdi,%rbx
mov    %rbx,-0x60(%rsp)
mov    -0x80(%rsp),%rdi
lea    (%rdi,%rax,8),%rax
mov    %rax,-0x40(%rsp)
mov    %r10,%rdi
cmpq   $0x4,0x40(%rsp)
jb     2510 <construct_total_matrix+0x1410>
mov    -0x68(%rsp),%rax
imul   -0x58(%rsp),%eax
mov    -0x8(%rsp),%rdi
lea    (%rax,%rdi,1),%ebx
mov    0x30(%rsp),%rdi
mov    %rbp,-0x50(%rsp)
mov    %r8,%rbp
lea    (%rbx,%rdi,1),%r8d
mov    %r10,%rdi
cmp    %ebx,%r8d
mov    %rbp,%r8
mov    -0x50(%rsp),%rbp
jl     2510 <construct_total_matrix+0x1410>
mov    0x30(%rsp),%rdi
shr    $0x20,%rdi
mov    %r10,%rdi
jne    2510 <construct_total_matrix+0x1410>
add    -0x8(%rsp),%eax
cltq
lea    (%rdx,%rax,1),%rdi
mov    0x88(%rsp),%rbx
lea    (%rbx,%rdi,8),%rdi
cmp    %rdi,-0x40(%rsp)
jae    2443 <construct_total_matrix+0x1343>
mov    0xe8(%rsp),%rdi
add    %rbp,%rdi
mov    -0x80(%rsp),%rbx
lea    (%rbx,%rdi,8),%rbx
lea    (%rsi,%rax,8),%rax
mov    %r10,%rdi
cmp    %rbx,%rax
jb     2510 <construct_total_matrix+0x1410>
cmpq   $0x4,0xe0(%rsp)
mov    -0x38(%rsp),%rbp
jae    2457 <construct_total_matrix+0x1357>
xor    %edi,%edi
jmp    24b2 <construct_total_matrix+0x13b2>
mov    0x60(%rsp),%rax
xor    %edi,%edi
mov    0x10(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movups (%rsi,%rbx,8),%xmm0
movups 0x10(%rsi,%rbx,8),%xmm1
movups %xmm0,-0x30(%r13,%rdi,8)
movups %xmm1,-0x20(%r13,%rdi,8)
lea    0x0(%rbp,%rdi,1),%ebx
movslq %ebx,%rbx
movups (%rsi,%rbx,8),%xmm0
movups 0x10(%rsi,%rbx,8),%xmm1
movups %xmm0,-0x10(%r13,%rdi,8)
movups %xmm1,0x0(%r13,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rax
jne    2470 <construct_total_matrix+0x1370>
testb  $0x1,0xd8(%rsp)
01
mov    0x68(%rsp),%r10
je     24eb <construct_total_matrix+0x13eb>
lea    (%rdi,%r10,1),%rax
add    -0x10(%rsp),%edi
add    %r15d,%edi
movslq %edi,%rdi
movups (%rsi,%rdi,8),%xmm0
movups 0x10(%rsi,%rdi,8),%xmm1
add    -0x60(%rsp),%rax
mov    -0x80(%rsp),%rdi
movups %xmm0,(%rdi,%rax,8)
movups %xmm1,0x10(%rdi,%rax,8)
mov    0x78(%rsp),%rdi
mov    0x80(%rsp),%rax
cmp    %rax,0x40(%rsp)
mov    -0x50(%rsp),%rbp
je     257c <construct_total_matrix+0x147c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x38(%rsp),%eax
sub    %edi,%eax
mov    %rdi,%rbx
test   $0x1,%al
je     253e <construct_total_matrix+0x143e>
add    %edi,%r15d
movslq %r15d,%rax
movsd  (%rsi,%rax,8),%xmm0
mov    -0x60(%rsp),%rax
add    %rdi,%rax
mov    -0x80(%rsp),%rbx
movsd  %xmm0,(%rbx,%rax,8)
lea    0x1(%rdi),%rbx
not    %rdi
cmp    (%rsp),%rdi
je     257c <construct_total_matrix+0x147c>
nopw   0x0(%rax,%rax,1)
lea    (%r11,%rbx,1),%eax
cltq
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r14,%rbx,8)
lea    (%r9,%rbx,1),%eax
cltq
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rdx
jne    2550 <construct_total_matrix+0x1450>
mov    -0x30(%rsp),%eax
cmp    -0x10(%rsp),%eax
mov    -0x78(%rsp),%rbx
jge    2310 <construct_total_matrix+0x1210>
mov    %r12d,%r15d
imul   -0x58(%rsp),%r15d
add    0x18(%rsp),%r15d
mov    -0x18(%rsp),%rax
cmpq   $0x4,0x28(%rsp)
jb     2700 <construct_total_matrix+0x1600>
mov    0x90(%rsp),%rax
mov    -0x68(%rsp),%rdi
add    %eax,%edi
imul   -0x58(%rsp),%edi
mov    0x98(%rsp),%rax
mov    %r8,-0x50(%rsp)
lea    (%rdi,%rax,1),%r8d
mov    -0x18(%rsp),%rax
cmp    %edi,%r8d
mov    -0x50(%rsp),%r8
jl     2700 <construct_total_matrix+0x1600>
mov    0x98(%rsp),%rax
shr    $0x20,%rax
mov    -0x18(%rsp),%rax
jne    2700 <construct_total_matrix+0x1600>
add    0x50(%rsp),%rbp
movslq %edi,%rax
lea    (%r10,%rax,1),%rdi
mov    %rbx,%r8
mov    -0x80(%rsp),%rbx
lea    (%rbx,%rbp,8),%rbp
mov    0x20(%rsp),%rbx
lea    (%rbx,%rdi,8),%rdi
mov    %r8,%rbx
cmp    %rdi,%rbp
mov    -0x50(%rsp),%r8
jae    263f <construct_total_matrix+0x153f>
lea    (%rbx,%rax,8),%rdi
mov    -0x18(%rsp),%rax
cmp    -0x40(%rsp),%rdi
jb     2700 <construct_total_matrix+0x1600>
cmpq   $0x4,0xd0(%rsp)
jae    264e <construct_total_matrix+0x154e>
xor    %edi,%edi
jmp    26a2 <construct_total_matrix+0x15a2>
mov    0xc0(%rsp),%rax
xor    %edi,%edi
mov    -0x78(%rsp),%rbp
nopl   (%rax)
lea    (%r8,%rdi,1),%ebx
movslq %ebx,%rbx
movups 0x0(%rbp,%rbx,8),%xmm0
movups 0x10(%rbp,%rbx,8),%xmm1
movups %xmm0,-0x30(%rcx,%rdi,8)
movups %xmm1,-0x20(%rcx,%rdi,8)
mov    -0x48(%rsp),%rbx
add    %edi,%ebx
movslq %ebx,%rbx
movups 0x0(%rbp,%rbx,8),%xmm0
movups 0x10(%rbp,%rbx,8),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,8)
movups %xmm1,(%rcx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rax
jne    2660 <construct_total_matrix+0x1560>
testb  $0x1,0xc8(%rsp)
01
je     26e0 <construct_total_matrix+0x15e0>
mov    -0x18(%rsp),%rax
add    %rdi,%rax
add    -0x30(%rsp),%edi
add    %r15d,%edi
movslq %edi,%rdi
mov    -0x78(%rsp),%rbp
movups 0x0(%rbp,%rdi,8),%xmm0
movups 0x10(%rbp,%rdi,8),%xmm1
add    -0x60(%rsp),%rax
mov    -0x80(%rsp),%rdi
movups %xmm0,(%rdi,%rax,8)
movups %xmm1,0x10(%rdi,%rax,8)
mov    -0x28(%rsp),%rax
mov    0x58(%rsp),%rdi
cmp    %rdi,0x28(%rsp)
je     2310 <construct_total_matrix+0x1210>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x10(%rsp),%rbx
sub    %eax,%ebx
mov    %rax,%rdi
test   $0x1,%bl
je     2736 <construct_total_matrix+0x1636>
add    %eax,%r15d
movslq %r15d,%rdi
mov    -0x78(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mov    -0x60(%rsp),%rbx
add    %rax,%rbx
mov    -0x80(%rsp),%rdi
movsd  %xmm0,(%rdi,%rbx,8)
lea    0x1(%rax),%rdi
not    %rax
cmp    0xa0(%rsp),%rax
mov    -0x78(%rsp),%rbp
je     2310 <construct_total_matrix+0x1210>
nopl   0x0(%rax)
lea    (%r11,%rdi,1),%eax
cltq
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r14,%rdi,8)
lea    (%r9,%rdi,1),%eax
cltq
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r10
jne    2750 <construct_total_matrix+0x1650>
jmp    2310 <construct_total_matrix+0x1210>
add    $0x1d0,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @construct_total_matrix(double* %0, double* %1, double* %2, double* %3, i32 %4, i32 %5) {
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store double* %0, double** %7
store double* %1, double** %8
store double* %2, double** %9
store double* %3, double** %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%17 = load i32, i32* %12
%18 = load i32, i32* %12
%19 = mul nsw i32 %17, %18
store i32 %19, i32* %16
store i32 0, i32* %13
%20 = load i32, i32* %13
%21 = load i32, i32* %12
%22 = mul nsw i32 %20, %21
store i32 %22, i32* %14
br label %23
23: ; preds = %104, %6
%24 = load i32, i32* %14
%25 = load i32, i32* %13
%26 = add nsw i32 %25, 1
%27 = load i32, i32* %12
%28 = mul nsw i32 %26, %27
%29 = icmp slt i32 %24, %28
br i1 %29, label %30, label %107
30: ; preds = %23
%31 = load i32, i32* %13
%32 = load i32, i32* %12
%33 = mul nsw i32 %31, %32
store i32 %33, i32* %15
br label %34
34: ; preds = %63, %30
%35 = load i32, i32* %15
%36 = load i32, i32* %13
%37 = add nsw i32 %36, 1
%38 = load i32, i32* %12
%39 = mul nsw i32 %37, %38
%40 = icmp slt i32 %35, %39
br i1 %40, label %41, label %66
41: ; preds = %34
%42 = load double*, double** %8
%43 = load i32, i32* %13
%44 = load i32, i32* %16
%45 = mul nsw i32 %43, %44
%46 = load i32, i32* %15
%47 = add nsw i32 %45, %46
%48 = load i32, i32* %14
%49 = load i32, i32* %12
%50 = mul nsw i32 %48, %49
%51 = add nsw i32 %47, %50
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %42, i64 %52
%54 = load double, double* %53
%55 = load double*, double** %10
%56 = load i32, i32* %15
%57 = load i32, i32* %14
%58 = load i32, i32* %11
%59 = mul nsw i32 %57, %58
%60 = add nsw i32 %56, %59
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %55, i64 %61
store double %54, double* %62
br label %63
63: ; preds = %41
%64 = load i32, i32* %15
%65 = add nsw i32 %64, 1
store i32 %65, i32* %15
br label %34
66: ; preds = %34
%67 = load i32, i32* %13
%68 = add nsw i32 %67, 1
%69 = load i32, i32* %12
%70 = mul nsw i32 %68, %69
store i32 %70, i32* %15
br label %71
71: ; preds = %100, %66
%72 = load i32, i32* %15
%73 = load i32, i32* %13
%74 = add nsw i32 %73, 2
%75 = load i32, i32* %12
%76 = mul nsw i32 %74, %75
%77 = icmp slt i32 %72, %76
br i1 %77, label %78, label %103
78: ; preds = %71
%79 = load double*, double** %9
%80 = load i32, i32* %13
%81 = load i32, i32* %16
%82 = mul nsw i32 %80, %81
%83 = load i32, i32* %15
%84 = add nsw i32 %82, %83
%85 = load i32, i32* %14
%86 = load i32, i32* %12
%87 = mul nsw i32 %85, %86
%88 = add nsw i32 %84, %87
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %79, i64 %89
%91 = load double, double* %90
%92 = load double*, double** %10
%93 = load i32, i32* %15
%94 = load i32, i32* %14
%95 = load i32, i32* %11
%96 = mul nsw i32 %94, %95
%97 = add nsw i32 %93, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %92, i64 %98
store double %91, double* %99
br label %100
100: ; preds = %78
%101 = load i32, i32* %15
%102 = add nsw i32 %101, 1
store i32 %102, i32* %15
br label %71
103: ; preds = %71
br label %104
104: ; preds = %103
%105 = load i32, i32* %14
%106 = add nsw i32 %105, 1
store i32 %106, i32* %14
br label %23
107: ; preds = %23
store i32 1, i32* %13
br label %108
108: ; preds = %238, %107
%109 = load i32, i32* %13
%110 = load i32, i32* %11
%111 = sub nsw i32 %110, 1
%112 = icmp slt i32 %109, %111
br i1 %112, label %113, label %241
113: ; preds = %108
%114 = load i32, i32* %13
%115 = load i32, i32* %12
%116 = mul nsw i32 %114, %115
store i32 %116, i32* %14
br label %117
117: ; preds = %234, %113
%118 = load i32, i32* %14
%119 = load i32, i32* %13
%120 = add nsw i32 %119, 1
%121 = load i32, i32* %12
%122 = mul nsw i32 %120, %121
%123 = icmp slt i32 %118, %122
br i1 %123, label %124, label %237
124: ; preds = %117
%125 = load i32, i32* %13
%126 = load i32, i32* %12
%127 = mul nsw i32 %125, %126
store i32 %127, i32* %15
br label %128
128: ; preds = %157, %124
%129 = load i32, i32* %15
%130 = load i32, i32* %13
%131 = add nsw i32 %130, 1
%132 = load i32, i32* %12
%133 = mul nsw i32 %131, %132
%134 = icmp slt i32 %129, %133
br i1 %134, label %135, label %160
135: ; preds = %128
%136 = load double*, double** %8
%137 = load i32, i32* %13
%138 = load i32, i32* %16
%139 = mul nsw i32 %137, %138
%140 = load i32, i32* %15
%141 = add nsw i32 %139, %140
%142 = load i32, i32* %14
%143 = load i32, i32* %12
%144 = mul nsw i32 %142, %143
%145 = add nsw i32 %141, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds double, double* %136, i64 %146
%148 = load double, double* %147
%149 = load double*, double** %10
%150 = load i32, i32* %15
%151 = load i32, i32* %14
%152 = load i32, i32* %11
%153 = mul nsw i32 %151, %152
%154 = add nsw i32 %150, %153
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %149, i64 %155
store double %148, double* %156
br label %157
157: ; preds = %135
%158 = load i32, i32* %15
%159 = add nsw i32 %158, 1
store i32 %159, i32* %15
br label %128
160: ; preds = %128
%161 = load i32, i32* %13
%162 = add nsw i32 %161, 1
%163 = load i32, i32* %12
%164 = mul nsw i32 %162, %163
store i32 %164, i32* %15
br label %165
165: ; preds = %194, %160
%166 = load i32, i32* %15
%167 = load i32, i32* %13
%168 = add nsw i32 %167, 2
%169 = load i32, i32* %12
%170 = mul nsw i32 %168, %169
%171 = icmp slt i32 %166, %170
br i1 %171, label %172, label %197
172: ; preds = %165
%173 = load double*, double** %9
%174 = load i32, i32* %13
%175 = load i32, i32* %16
%176 = mul nsw i32 %174, %175
%177 = load i32, i32* %15
%178 = add nsw i32 %176, %177
%179 = load i32, i32* %14
%180 = load i32, i32* %12
%181 = mul nsw i32 %179, %180
%182 = add nsw i32 %178, %181
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %173, i64 %183
%185 = load double, double* %184
%186 = load double*, double** %10
%187 = load i32, i32* %15
%188 = load i32, i32* %14
%189 = load i32, i32* %11
%190 = mul nsw i32 %188, %189
%191 = add nsw i32 %187, %190
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double, double* %186, i64 %192
store double %185, double* %193
br label %194
194: ; preds = %172
%195 = load i32, i32* %15
%196 = add nsw i32 %195, 1
store i32 %196, i32* %15
br label %165
197: ; preds = %165
%198 = load i32, i32* %13
%199 = sub nsw i32 %198, 1
%200 = load i32, i32* %12
%201 = mul nsw i32 %199, %200
store i32 %201, i32* %15
br label %202
202: ; preds = %230, %197
%203 = load i32, i32* %15
%204 = load i32, i32* %13
%205 = load i32, i32* %12
%206 = mul nsw i32 %204, %205
%207 = icmp slt i32 %203, %206
br i1 %207, label %208, label %233
208: ; preds = %202
%209 = load double*, double** %7
%210 = load i32, i32* %13
%211 = load i32, i32* %16
%212 = mul nsw i32 %210, %211
%213 = load i32, i32* %15
%214 = add nsw i32 %212, %213
%215 = load i32, i32* %14
%216 = load i32, i32* %12
%217 = mul nsw i32 %215, %216
%218 = add nsw i32 %214, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %209, i64 %219
%221 = load double, double* %220
%222 = load double*, double** %10
%223 = load i32, i32* %15
%224 = load i32, i32* %14
%225 = load i32, i32* %11
%226 = mul nsw i32 %224, %225
%227 = add nsw i32 %223, %226
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds double, double* %222, i64 %228
store double %221, double* %229
br label %230
230: ; preds = %208
%231 = load i32, i32* %15
%232 = add nsw i32 %231, 1
store i32 %232, i32* %15
br label %202
233: ; preds = %202
br label %234
234: ; preds = %233
%235 = load i32, i32* %14
%236 = add nsw i32 %235, 1
store i32 %236, i32* %14
br label %117
237: ; preds = %117
br label %238
238: ; preds = %237
%239 = load i32, i32* %13
%240 = add nsw i32 %239, 1
store i32 %240, i32* %13
br label %108
241: ; preds = %108
%242 = load i32, i32* %11
%243 = sub nsw i32 %242, 1
store i32 %243, i32* %13
%244 = load i32, i32* %13
%245 = load i32, i32* %12
%246 = mul nsw i32 %244, %245
store i32 %246, i32* %14
br label %247
247: ; preds = %327, %241
%248 = load i32, i32* %14
%249 = load i32, i32* %13
%250 = add nsw i32 %249, 1
%251 = load i32, i32* %12
%252 = mul nsw i32 %250, %251
%253 = icmp slt i32 %248, %252
br i1 %253, label %254, label %330
254: ; preds = %247
%255 = load i32, i32* %13
%256 = load i32, i32* %12
%257 = mul nsw i32 %255, %256
store i32 %257, i32* %15
br label %258
258: ; preds = %287, %254
%259 = load i32, i32* %15
%260 = load i32, i32* %13
%261 = add nsw i32 %260, 1
%262 = load i32, i32* %12
%263 = mul nsw i32 %261, %262
%264 = icmp slt i32 %259, %263
br i1 %264, label %265, label %290
265: ; preds = %258
%266 = load double*, double** %8
%267 = load i32, i32* %13
%268 = load i32, i32* %16
%269 = mul nsw i32 %267, %268
%270 = load i32, i32* %15
%271 = add nsw i32 %269, %270
%272 = load i32, i32* %14
%273 = load i32, i32* %12
%274 = mul nsw i32 %272, %273
%275 = add nsw i32 %271, %274
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %266, i64 %276
%278 = load double, double* %277
%279 = load double*, double** %10
%280 = load i32, i32* %15
%281 = load i32, i32* %14
%282 = load i32, i32* %11
%283 = mul nsw i32 %281, %282
%284 = add nsw i32 %280, %283
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %279, i64 %285
store double %278, double* %286
br label %287
287: ; preds = %265
%288 = load i32, i32* %15
%289 = add nsw i32 %288, 1
store i32 %289, i32* %15
br label %258
290: ; preds = %258
%291 = load i32, i32* %13
%292 = sub nsw i32 %291, 1
%293 = load i32, i32* %12
%294 = mul nsw i32 %292, %293
store i32 %294, i32* %15
br label %295
295: ; preds = %323, %290
%296 = load i32, i32* %15
%297 = load i32, i32* %13
%298 = load i32, i32* %12
%299 = mul nsw i32 %297, %298
%300 = icmp slt i32 %296, %299
br i1 %300, label %301, label %326
301: ; preds = %295
%302 = load double*, double** %7
%303 = load i32, i32* %13
%304 = load i32, i32* %16
%305 = mul nsw i32 %303, %304
%306 = load i32, i32* %15
%307 = add nsw i32 %305, %306
%308 = load i32, i32* %14
%309 = load i32, i32* %12
%310 = mul nsw i32 %308, %309
%311 = add nsw i32 %307, %310
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds double, double* %302, i64 %312
%314 = load double, double* %313
%315 = load double*, double** %10
%316 = load i32, i32* %15
%317 = load i32, i32* %14
%318 = load i32, i32* %11
%319 = mul nsw i32 %317, %318
%320 = add nsw i32 %316, %319
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds double, double* %315, i64 %321
store double %314, double* %322
br label %323
323: ; preds = %301
%324 = load i32, i32* %15
%325 = add nsw i32 %324, 1
store i32 %325, i32* %15
br label %295
326: ; preds = %295
br label %327
327: ; preds = %326
%328 = load i32, i32* %14
%329 = add nsw i32 %328, 1
store i32 %329, i32* %14
br label %247
330: ; preds = %247
ret void
}

LLVM IR (-O2):
define void @construct_total_matrix(double* nocapture %0, double* nocapture %1, double* nocapture %2, double* nocapture writeonly %3, i32 %4, i32 %5) {
%7 = mul nsw i32 %5, %5
%8 = icmp sgt i32 %5, 0
br i1 %8, label %9, label %133
9: ; preds = %6
%10 = shl nuw i32 %5, 1
%11 = icmp sgt i32 %10, %5
%12 = zext i32 %5 to i64
%13 = sext i32 %4 to i64
%14 = zext i32 %5 to i64
%15 = sext i32 %10 to i64
%16 = sub nsw i64 %15, %14
%17 = and i64 %14, 4294967292
%18 = add nsw i64 %17, -4
%19 = lshr exact i64 %18, 2
%20 = add nuw nsw i64 %19, 1
%21 = add nsw i64 %16, -4
%22 = lshr i64 %21, 2
%23 = add nuw nsw i64 %22, 1
%24 = icmp ult i32 %5, 4
%25 = and i64 %14, 4294967292
%26 = and i64 %20, 1
%27 = icmp eq i64 %18, 0
%28 = and i64 %20, 9223372036854775806
%29 = icmp eq i64 %26, 0
%30 = icmp eq i64 %25, %14
%31 = and i64 %14, 3
%32 = icmp eq i64 %31, 0
%33 = icmp ult i64 %16, 4
%34 = and i64 %16, -4
%35 = add nsw i64 %34, %12
%36 = and i64 %23, 1
%37 = icmp ult i64 %21, 4
%38 = and i64 %23, 9223372036854775806
%39 = icmp eq i64 %36, 0
%40 = icmp eq i64 %16, %34
br label %41
41: ; preds = %358, %9
%42 = phi i64 [ 0, %9 ], [ %359, %358 ]
%43 = mul i64 %42, %13
%44 = mul i64 %42, %14
%45 = mul i64 %42, %13
%46 = add i64 %45, %14
%47 = getelementptr double, double* %3, i64 %46
%48 = add i64 %45, %15
%49 = getelementptr double, double* %3, i64 %48
%50 = mul i64 %42, %14
%51 = add i64 %50, %14
%52 = getelementptr double, double* %2, i64 %51
%53 = add i64 %50, %15
%54 = getelementptr double, double* %2, i64 %53
%55 = mul nsw i64 %42, %12
%56 = mul nsw i64 %42, %13
br i1 %24, label %115, label %57
57: ; preds = %41
%58 = add i64 %44, %14
%59 = getelementptr double, double* %1, i64 %58
%60 = getelementptr double, double* %1, i64 %44
%61 = add i64 %43, %14
%62 = getelementptr double, double* %3, i64 %61
%63 = getelementptr double, double* %3, i64 %43
%64 = icmp ult double* %63, %59
%65 = icmp ult double* %60, %62
%66 = and i1 %64, %65
br i1 %66, label %115, label %67
67: ; preds = %57
br i1 %27, label %99, label %68
68: ; preds = %67, %68
%69 = phi i64 [ %96, %68 ], [ 0, %67 ]
%70 = phi i64 [ %97, %68 ], [ 0, %67 ]
%71 = add nuw nsw i64 %69, %55
%72 = getelementptr inbounds double, double* %1, i64 %71
%73 = bitcast double* %72 to <2 x double>*
%74 = load <2 x double>, <2 x double>* %73
%75 = getelementptr inbounds double, double* %72, i64 2
%76 = bitcast double* %75 to <2 x double>*
%77 = load <2 x double>, <2 x double>* %76
%78 = add nsw i64 %69, %56
%79 = getelementptr inbounds double, double* %3, i64 %78
%80 = bitcast double* %79 to <2 x double>*
store <2 x double> %74, <2 x double>* %80
%81 = getelementptr inbounds double, double* %79, i64 2
%82 = bitcast double* %81 to <2 x double>*
store <2 x double> %77, <2 x double>* %82
%83 = or i64 %69, 4
%84 = add nuw nsw i64 %83, %55
%85 = getelementptr inbounds double, double* %1, i64 %84
%86 = bitcast double* %85 to <2 x double>*
%87 = load <2 x double>, <2 x double>* %86
%88 = getelementptr inbounds double, double* %85, i64 2
%89 = bitcast double* %88 to <2 x double>*
%90 = load <2 x double>, <2 x double>* %89
%91 = add nsw i64 %83, %56
%92 = getelementptr inbounds double, double* %3, i64 %91
%93 = bitcast double* %92 to <2 x double>*
store <2 x double> %87, <2 x double>* %93
%94 = getelementptr inbounds double, double* %92, i64 2
%95 = bitcast double* %94 to <2 x double>*
store <2 x double> %90, <2 x double>* %95
%96 = add nuw i64 %69, 8
%97 = add i64 %70, 2
%98 = icmp eq i64 %97, %28
br i1 %98, label %99, label %68
99: ; preds = %68, %67
%100 = phi i64 [ 0, %67 ], [ %96, %68 ]
br i1 %29, label %114, label %101
101: ; preds = %99
%102 = add nuw nsw i64 %100, %55
%103 = getelementptr inbounds double, double* %1, i64 %102
%104 = bitcast double* %103 to <2 x double>*
%105 = load <2 x double>, <2 x double>* %104
%106 = getelementptr inbounds double, double* %103, i64 2
%107 = bitcast double* %106 to <2 x double>*
%108 = load <2 x double>, <2 x double>* %107
%109 = add nsw i64 %100, %56
%110 = getelementptr inbounds double, double* %3, i64 %109
%111 = bitcast double* %110 to <2 x double>*
store <2 x double> %105, <2 x double>* %111
%112 = getelementptr inbounds double, double* %110, i64 2
%113 = bitcast double* %112 to <2 x double>*
store <2 x double> %108, <2 x double>* %113
br label %114
114: ; preds = %99, %101
br i1 %30, label %224, label %115
115: ; preds = %57, %41, %114
%116 = phi i64 [ 0, %57 ], [ 0, %41 ], [ %25, %114 ]
%117 = xor i64 %116, -1
%118 = add nsw i64 %117, %14
br i1 %32, label %130, label %119
119: ; preds = %115, %119
%120 = phi i64 [ %127, %119 ], [ %116, %115 ]
%121 = phi i64 [ %128, %119 ], [ 0, %115 ]
%122 = add nuw nsw i64 %120, %55
%123 = getelementptr inbounds double, double* %1, i64 %122
%124 = load double, double* %123
%125 = add nsw i64 %120, %56
%126 = getelementptr inbounds double, double* %3, i64 %125
store double %124, double* %126
%127 = add nuw nsw i64 %120, 1
%128 = add i64 %121, 1
%129 = icmp eq i64 %128, %31
br i1 %129, label %130, label %119
130: ; preds = %119, %115
%131 = phi i64 [ %116, %115 ], [ %127, %119 ]
%132 = icmp ult i64 %118, 3
br i1 %132, label %224, label %304
133: ; preds = %358, %6
%134 = add i32 %4, -1
%135 = icmp sgt i32 %4, 2
br i1 %135, label %136, label %813
136: ; preds = %133
%137 = shl i32 %5, 1
%138 = mul i32 %5, 3
%139 = zext i32 %4 to i64
%140 = add i32 %5, -1
%141 = mul i32 %5, %5
%142 = shl i32 %141, 1
%143 = or i32 %137, 1
%144 = mul i32 %143, %5
%145 = zext i32 %140 to i64
%146 = add nuw nsw i64 %145, 1
%147 = zext i32 %142 to i64
%148 = or i32 %137, 1
%149 = mul i32 %148, %5
%150 = zext i32 %149 to i64
%151 = zext i32 %5 to i64
%152 = add nuw nsw i64 %145, 1
%153 = getelementptr double, double* %0, i64 %152
%154 = add i32 %5, -1
%155 = zext i32 %154 to i64
%156 = add nuw nsw i64 %155, 1
%157 = add i32 %137, 2
%158 = mul i32 %157, %5
%159 = zext i32 %158 to i64
%160 = or i32 %137, 1
%161 = mul i32 %160, %5
%162 = zext i32 %161 to i64
%163 = zext i32 %5 to i64
%164 = add i32 %5, -1
%165 = zext i32 %164 to i64
%166 = add nuw nsw i64 %165, 1
%167 = add i32 %137, 2
%168 = mul i32 %167, %5
%169 = zext i32 %168 to i64
%170 = or i32 %137, 1
%171 = mul i32 %170, %5
%172 = zext i32 %171 to i64
%173 = zext i32 %5 to i64
%174 = add nuw nsw i64 %165, 1
%175 = getelementptr double, double* %2, i64 %174
%176 = add i32 %5, -1
%177 = zext i32 %176 to i64
%178 = add nuw nsw i64 %177, 1
%179 = or i32 %137, 1
%180 = mul i32 %179, %5
%181 = zext i32 %180 to i64
%182 = zext i32 %5 to i64
%183 = add nuw nsw i64 %139, 1
%184 = add i32 %5, -1
%185 = zext i32 %184 to i64
%186 = add nuw nsw i64 %185, 1
%187 = or i32 %137, 1
%188 = mul i32 %187, %5
%189 = zext i32 %188 to i64
%190 = zext i32 %5 to i64
%191 = add nuw nsw i64 %185, 1
%192 = getelementptr double, double* %1, i64 %191
%193 = add i32 %5, -1
%194 = zext i32 %193 to i64
%195 = add nuw nsw i64 %194, 1
%196 = and i64 %195, 8589934588
%197 = add nsw i64 %196, -4
%198 = lshr exact i64 %197, 2
%199 = add nuw nsw i64 %198, 1
%200 = add i32 %137, -2
%201 = or i32 %200, 1
%202 = add i32 %138, -1
%203 = icmp ult i32 %193, 3
%204 = and i64 %195, 8589934588
%205 = and i64 %199, 1
%206 = icmp eq i64 %197, 0
%207 = and i64 %199, 9223372036854775806
%208 = icmp eq i64 %205, 0
%209 = icmp eq i64 %195, %204
%210 = icmp ult i32 %176, 3
%211 = and i64 %178, 8589934588
%212 = and i64 %199, 1
%213 = icmp eq i64 %197, 0
%214 = and i64 %199, 9223372036854775806
%215 = icmp eq i64 %212, 0
%216 = icmp eq i64 %178, %211
%217 = icmp ult i32 %154, 3
%218 = and i64 %156, 8589934588
%219 = and i64 %199, 1
%220 = icmp eq i64 %197, 0
%221 = and i64 %199, 9223372036854775806
%222 = icmp eq i64 %219, 0
%223 = icmp eq i64 %156, %218
br label %369
224: ; preds = %130, %304, %114
br i1 %11, label %225, label %358
225: ; preds = %224
%226 = mul nsw i64 %42, %12
%227 = mul nsw i64 %42, %13
br i1 %33, label %283, label %228
228: ; preds = %225
%229 = icmp ult double* %47, %54
%230 = icmp ult double* %52, %49
%231 = and i1 %229, %230
br i1 %231, label %283, label %232
232: ; preds = %228
br i1 %37, label %266, label %233
233: ; preds = %232, %233
%234 = phi i64 [ %263, %233 ], [ 0, %232 ]
%235 = phi i64 [ %264, %233 ], [ 0, %232 ]
%236 = add i64 %234, %12
%237 = add nuw nsw i64 %236, %226
%238 = getelementptr inbounds double, double* %2, i64 %237
%239 = bitcast double* %238 to <2 x double>*
%240 = load <2 x double>, <2 x double>* %239
%241 = getelementptr inbounds double, double* %238, i64 2
%242 = bitcast double* %241 to <2 x double>*
%243 = load <2 x double>, <2 x double>* %242
%244 = add nsw i64 %236, %227
%245 = getelementptr inbounds double, double* %3, i64 %244
%246 = bitcast double* %245 to <2 x double>*
store <2 x double> %240, <2 x double>* %246
%247 = getelementptr inbounds double, double* %245, i64 2
%248 = bitcast double* %247 to <2 x double>*
store <2 x double> %243, <2 x double>* %248
%249 = or i64 %234, 4
%250 = add i64 %249, %12
%251 = add nuw nsw i64 %250, %226
%252 = getelementptr inbounds double, double* %2, i64 %251
%253 = bitcast double* %252 to <2 x double>*
%254 = load <2 x double>, <2 x double>* %253
%255 = getelementptr inbounds double, double* %252, i64 2
%256 = bitcast double* %255 to <2 x double>*
%257 = load <2 x double>, <2 x double>* %256
%258 = add nsw i64 %250, %227
%259 = getelementptr inbounds double, double* %3, i64 %258
%260 = bitcast double* %259 to <2 x double>*
store <2 x double> %254, <2 x double>* %260
%261 = getelementptr inbounds double, double* %259, i64 2
%262 = bitcast double* %261 to <2 x double>*
store <2 x double> %257, <2 x double>* %262
%263 = add nuw i64 %234, 8
%264 = add i64 %235, 2
%265 = icmp eq i64 %264, %38
br i1 %265, label %266, label %233
266: ; preds = %233, %232
%267 = phi i64 [ 0, %232 ], [ %263, %233 ]
br i1 %39, label %282, label %268
268: ; preds = %266
%269 = add i64 %267, %12
%270 = add nuw nsw i64 %269, %226
%271 = getelementptr inbounds double, double* %2, i64 %270
%272 = bitcast double* %271 to <2 x double>*
%273 = load <2 x double>, <2 x double>* %272
%274 = getelementptr inbounds double, double* %271, i64 2
%275 = bitcast double* %274 to <2 x double>*
%276 = load <2 x double>, <2 x double>* %275
%277 = add nsw i64 %269, %227
%278 = getelementptr inbounds double, double* %3, i64 %277
%279 = bitcast double* %278 to <2 x double>*
store <2 x double> %273, <2 x double>* %279
%280 = getelementptr inbounds double, double* %278, i64 2
%281 = bitcast double* %280 to <2 x double>*
store <2 x double> %276, <2 x double>* %281
br label %282
282: ; preds = %266, %268
br i1 %40, label %358, label %283
283: ; preds = %228, %225, %282
%284 = phi i64 [ %12, %228 ], [ %12, %225 ], [ %35, %282 ]
%285 = sub nsw i64 %15, %284
%286 = xor i64 %284, -1
%287 = add nsw i64 %286, %15
%288 = and i64 %285, 3
%289 = icmp eq i64 %288, 0
br i1 %289, label %301, label %290
290: ; preds = %283, %290
%291 = phi i64 [ %298, %290 ], [ %284, %283 ]
%292 = phi i64 [ %299, %290 ], [ 0, %283 ]
%293 = add nuw nsw i64 %291, %226
%294 = getelementptr inbounds double, double* %2, i64 %293
%295 = load double, double* %294
%296 = add nsw i64 %291, %227
%297 = getelementptr inbounds double, double* %3, i64 %296
store double %295, double* %297
%298 = add nuw nsw i64 %291, 1
%299 = add i64 %292, 1
%300 = icmp eq i64 %299, %288
br i1 %300, label %301, label %290
301: ; preds = %290, %283
%302 = phi i64 [ %284, %283 ], [ %298, %290 ]
%303 = icmp ult i64 %287, 3
br i1 %303, label %358, label %331
304: ; preds = %130, %304
%305 = phi i64 [ %329, %304 ], [ %131, %130 ]
%306 = add nuw nsw i64 %305, %55
%307 = getelementptr inbounds double, double* %1, i64 %306
%308 = load double, double* %307
%309 = add nsw i64 %305, %56
%310 = getelementptr inbounds double, double* %3, i64 %309
store double %308, double* %310
%311 = add nuw nsw i64 %305, 1
%312 = add nuw nsw i64 %311, %55
%313 = getelementptr inbounds double, double* %1, i64 %312
%314 = load double, double* %313
%315 = add nsw i64 %311, %56
%316 = getelementptr inbounds double, double* %3, i64 %315
store double %314, double* %316
%317 = add nuw nsw i64 %305, 2
%318 = add nuw nsw i64 %317, %55
%319 = getelementptr inbounds double, double* %1, i64 %318
%320 = load double, double* %319
%321 = add nsw i64 %317, %56
%322 = getelementptr inbounds double, double* %3, i64 %321
store double %320, double* %322
%323 = add nuw nsw i64 %305, 3
%324 = add nuw nsw i64 %323, %55
%325 = getelementptr inbounds double, double* %1, i64 %324
%326 = load double, double* %325
%327 = add nsw i64 %323, %56
%328 = getelementptr inbounds double, double* %3, i64 %327
store double %326, double* %328
%329 = add nuw nsw i64 %305, 4
%330 = icmp eq i64 %329, %14
br i1 %330, label %224, label %304
331: ; preds = %301, %331
%332 = phi i64 [ %356, %331 ], [ %302, %301 ]
%333 = add nuw nsw i64 %332, %226
%334 = getelementptr inbounds double, double* %2, i64 %333
%335 = load double, double* %334
%336 = add nsw i64 %332, %227
%337 = getelementptr inbounds double, double* %3, i64 %336
store double %335, double* %337
%338 = add nuw nsw i64 %332, 1
%339 = add nuw nsw i64 %338, %226
%340 = getelementptr inbounds double, double* %2, i64 %339
%341 = load double, double* %340
%342 = add nsw i64 %338, %227
%343 = getelementptr inbounds double, double* %3, i64 %342
store double %341, double* %343
%344 = add nuw nsw i64 %332, 2
%345 = add nuw nsw i64 %344, %226
%346 = getelementptr inbounds double, double* %2, i64 %345
%347 = load double, double* %346
%348 = add nsw i64 %344, %227
%349 = getelementptr inbounds double, double* %3, i64 %348
store double %347, double* %349
%350 = add nuw nsw i64 %332, 3
%351 = add nuw nsw i64 %350, %226
%352 = getelementptr inbounds double, double* %2, i64 %351
%353 = load double, double* %352
%354 = add nsw i64 %350, %227
%355 = getelementptr inbounds double, double* %3, i64 %354
store double %353, double* %355
%356 = add nuw nsw i64 %332, 4
%357 = icmp eq i64 %356, %15
br i1 %357, label %358, label %331
358: ; preds = %301, %331, %282, %224
%359 = add nuw nsw i64 %42, 1
%360 = icmp eq i64 %359, %14
br i1 %360, label %133, label %41
361: ; preds = %807, %369
%362 = add i32 %375, %5
%363 = add i32 %374, %5
%364 = add i32 %373, %5
%365 = add i32 %372, %5
%366 = icmp eq i32 %417, %134
%367 = add i32 %371, 1
%368 = add i64 %370, 1
br i1 %366, label %813, label %369
369: ; preds = %136, %361
%370 = phi i64 [ 0, %136 ], [ %368, %361 ]
%371 = phi i32 [ 0, %136 ], [ %367, %361 ]
%372 = phi i32 [ 0, %136 ], [ %365, %361 ]
%373 = phi i32 [ %138, %136 ], [ %364, %361 ]
%374 = phi i32 [ %137, %136 ], [ %363, %361 ]
%375 = phi i32 [ %5, %136 ], [ %362, %361 ]
%376 = phi i32 [ 1, %136 ], [ %417, %361 ]
%377 = trunc i64 %370 to i32
%378 = mul i32 %377, %5
%379 = add i32 %378, %193
%380 = trunc i64 %370 to i32
%381 = mul i32 %380, %5
%382 = add i32 %381, %202
%383 = trunc i64 %370 to i32
%384 = mul i32 %383, %5
%385 = add i32 %384, %201
%386 = sext i32 %375 to i64
%387 = mul i64 %183, %386
%388 = add i64 %186, %387
%389 = mul i64 %370, %189
%390 = add i64 %389, %189
%391 = mul i64 %370, %181
%392 = add i64 %391, %181
%393 = sext i32 %375 to i64
%394 = mul nsw i64 %139, %393
%395 = sext i32 %374 to i64
%396 = add i64 %394, %395
%397 = add i64 %166, %394
%398 = add i64 %397, %395
%399 = mul i64 %370, %172
%400 = add i64 %399, %169
%401 = mul i64 %370, %162
%402 = add i64 %401, %159
%403 = sext i32 %375 to i64
%404 = mul nsw i64 %139, %403
%405 = sext i32 %372 to i64
%406 = add i64 %404, %405
%407 = add i64 %146, %404
%408 = add i64 %407, %405
%409 = mul i64 %370, %150
%410 = add i64 %409, %147
%411 = mul i32 %144, %371
%412 = add i32 %142, %411
%413 = sext i32 %375 to i64
%414 = sext i32 %372 to i64
%415 = sext i32 %374 to i64
%416 = mul nsw i32 %376, %5
%417 = add nuw nsw i32 %376, 1
%418 = mul nsw i32 %417, %5
%419 = icmp slt i32 %416, %418
br i1 %419, label %420, label %361
420: ; preds = %369
%421 = mul nsw i32 %376, %7
%422 = add nuw nsw i32 %376, 2
%423 = mul nsw i32 %422, %5
%424 = icmp slt i32 %418, %423
%425 = add nsw i32 %376, -1
%426 = mul nsw i32 %425, %5
%427 = icmp slt i32 %426, %416
%428 = add nsw i64 %204, %413
%429 = add nsw i64 %211, %415
%430 = add nsw i64 %218, %414
br label %431
431: ; preds = %807, %420
%432 = phi i64 [ %812, %807 ], [ 0, %420 ]
%433 = phi i32 [ %811, %807 ], [ 0, %420 ]
%434 = phi i64 [ %808, %807 ], [ %413, %420 ]
%435 = mul i64 %432, %139
%436 = mul i64 %432, %190
%437 = add i64 %390, %436
%438 = shl i64 %437, 32
%439 = ashr exact i64 %438, 32
%440 = mul i64 %432, %182
%441 = add i64 %392, %440
%442 = trunc i64 %441 to i32
%443 = mul i64 %432, %139
%444 = add i64 %396, %443
%445 = getelementptr double, double* %3, i64 %444
%446 = add i64 %398, %443
%447 = getelementptr double, double* %3, i64 %446
%448 = mul i64 %432, %173
%449 = add i64 %400, %448
%450 = shl i64 %449, 32
%451 = ashr exact i64 %450, 32
%452 = getelementptr double, double* %2, i64 %451
%453 = getelementptr double, double* %175, i64 %451
%454 = mul i64 %432, %163
%455 = add i64 %402, %454
%456 = trunc i64 %455 to i32
%457 = mul i64 %432, %139
%458 = add i64 %406, %457
%459 = getelementptr double, double* %3, i64 %458
%460 = add i64 %408, %457
%461 = getelementptr double, double* %3, i64 %460
%462 = mul i64 %432, %151
%463 = add i64 %410, %462
%464 = shl i64 %463, 32
%465 = ashr exact i64 %464, 32
%466 = getelementptr double, double* %0, i64 %465
%467 = getelementptr double, double* %153, i64 %465
%468 = mul i32 %433, %5
%469 = add i32 %412, %468
%470 = trunc i64 %434 to i32
%471 = mul i32 %470, %5
%472 = add i32 %471, %421
%473 = mul nsw i64 %434, %139
%474 = add i32 %176, %442
%475 = icmp slt i32 %474, %442
%476 = select i1 %203, i1 true, i1 %475
br i1 %476, label %547, label %477
477: ; preds = %431
%478 = getelementptr double, double* %192, i64 %439
%479 = getelementptr double, double* %1, i64 %439
%480 = add i64 %388, %435
%481 = getelementptr double, double* %3, i64 %480
%482 = add i64 %387, %435
%483 = getelementptr double, double* %3, i64 %482
%484 = icmp ult double* %483, %478
%485 = icmp ult double* %479, %481
%486 = and i1 %484, %485
br i1 %486, label %547, label %487
487: ; preds = %477
br i1 %206, label %527, label %488
488: ; preds = %487, %488
%489 = phi i64 [ %524, %488 ], [ 0, %487 ]
%490 = phi i64 [ %525, %488 ], [ 0, %487 ]
%491 = add i64 %489, %413
%492 = trunc i64 %489 to i32
%493 = add i32 %375, %492
%494 = add i32 %472, %493
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds double, double* %1, i64 %495
%497 = bitcast double* %496 to <2 x double>*
%498 = load <2 x double>, <2 x double>* %497
%499 = getelementptr inbounds double, double* %496, i64 2
%500 = bitcast double* %499 to <2 x double>*
%501 = load <2 x double>, <2 x double>* %500
%502 = add nsw i64 %491, %473
%503 = getelementptr inbounds double, double* %3, i64 %502
%504 = bitcast double* %503 to <2 x double>*
store <2 x double> %498, <2 x double>* %504
%505 = getelementptr inbounds double, double* %503, i64 2
%506 = bitcast double* %505 to <2 x double>*
store <2 x double> %501, <2 x double>* %506
%507 = or i64 %489, 4
%508 = add i64 %507, %413
%509 = trunc i64 %507 to i32
%510 = add i32 %375, %509
%511 = add i32 %472, %510
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds double, double* %1, i64 %512
%514 = bitcast double* %513 to <2 x double>*
%515 = load <2 x double>, <2 x double>* %514
%516 = getelementptr inbounds double, double* %513, i64 2
%517 = bitcast double* %516 to <2 x double>*
%518 = load <2 x double>, <2 x double>* %517
%519 = add nsw i64 %508, %473
%520 = getelementptr inbounds double, double* %3, i64 %519
%521 = bitcast double* %520 to <2 x double>*
store <2 x double> %515, <2 x double>* %521
%522 = getelementptr inbounds double, double* %520, i64 2
%523 = bitcast double* %522 to <2 x double>*
store <2 x double> %518, <2 x double>* %523
%524 = add nuw i64 %489, 8
%525 = add i64 %490, 2
%526 = icmp eq i64 %525, %207
br i1 %526, label %527, label %488
527: ; preds = %488, %487
%528 = phi i64 [ 0, %487 ], [ %524, %488 ]
br i1 %208, label %546, label %529
529: ; preds = %527
%530 = add i64 %528, %413
%531 = trunc i64 %528 to i32
%532 = add i32 %375, %531
%533 = add i32 %472, %532
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds double, double* %1, i64 %534
%536 = bitcast double* %535 to <2 x double>*
%537 = load <2 x double>, <2 x double>* %536
%538 = getelementptr inbounds double, double* %535, i64 2
%539 = bitcast double* %538 to <2 x double>*
%540 = load <2 x double>, <2 x double>* %539
%541 = add nsw i64 %530, %473
%542 = getelementptr inbounds double, double* %3, i64 %541
%543 = bitcast double* %542 to <2 x double>*
store <2 x double> %537, <2 x double>* %543
%544 = getelementptr inbounds double, double* %542, i64 2
%545 = bitcast double* %544 to <2 x double>*
store <2 x double> %540, <2 x double>* %545
br label %546
546: ; preds = %527, %529
br i1 %209, label %565, label %547
547: ; preds = %477, %431, %546
%548 = phi i64 [ %413, %477 ], [ %413, %431 ], [ %428, %546 ]
%549 = trunc i64 %548 to i32
%550 = sub i32 %374, %549
%551 = and i32 %550, 1
%552 = icmp eq i32 %551, 0
br i1 %552, label %562, label %553
553: ; preds = %547
%554 = trunc i64 %548 to i32
%555 = add i32 %472, %554
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds double, double* %1, i64 %556
%558 = load double, double* %557
%559 = add nsw i64 %548, %473
%560 = getelementptr inbounds double, double* %3, i64 %559
store double %558, double* %560
%561 = add nsw i64 %548, 1
br label %562
562: ; preds = %553, %547
%563 = phi i64 [ %548, %547 ], [ %561, %553 ]
%564 = icmp eq i32 %385, %549
br i1 %564, label %565, label %656
565: ; preds = %562, %656, %546
br i1 %424, label %566, label %696
566: ; preds = %565
%567 = trunc i64 %434 to i32
%568 = mul i32 %567, %5
%569 = add i32 %568, %421
%570 = mul nsw i64 %434, %139
%571 = add i32 %154, %456
%572 = icmp slt i32 %571, %456
%573 = select i1 %210, i1 true, i1 %572
br i1 %573, label %638, label %574
574: ; preds = %566
%575 = icmp ult double* %445, %453
%576 = icmp ult double* %452, %447
%577 = and i1 %575, %576
br i1 %577, label %638, label %578
578: ; preds = %574
br i1 %213, label %618, label %579
579: ; preds = %578, %579
%580 = phi i64 [ %615, %579 ], [ 0, %578 ]
%581 = phi i64 [ %616, %579 ], [ 0, %578 ]
%582 = add i64 %580, %415
%583 = trunc i64 %580 to i32
%584 = add i32 %374, %583
%585 = add i32 %569, %584
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds double, double* %2, i64 %586
%588 = bitcast double* %587 to <2 x double>*
%589 = load <2 x double>, <2 x double>* %588
%590 = getelementptr inbounds double, double* %587, i64 2
%591 = bitcast double* %590 to <2 x double>*
%592 = load <2 x double>, <2 x double>* %591
%593 = add nsw i64 %582, %570
%594 = getelementptr inbounds double, double* %3, i64 %593
%595 = bitcast double* %594 to <2 x double>*
store <2 x double> %589, <2 x double>* %595
%596 = getelementptr inbounds double, double* %594, i64 2
%597 = bitcast double* %596 to <2 x double>*
store <2 x double> %592, <2 x double>* %597
%598 = or i64 %580, 4
%599 = add i64 %598, %415
%600 = trunc i64 %598 to i32
%601 = add i32 %374, %600
%602 = add i32 %569, %601
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds double, double* %2, i64 %603
%605 = bitcast double* %604 to <2 x double>*
%606 = load <2 x double>, <2 x double>* %605
%607 = getelementptr inbounds double, double* %604, i64 2
%608 = bitcast double* %607 to <2 x double>*
%609 = load <2 x double>, <2 x double>* %608
%610 = add nsw i64 %599, %570
%611 = getelementptr inbounds double, double* %3, i64 %610
%612 = bitcast double* %611 to <2 x double>*
store <2 x double> %606, <2 x double>* %612
%613 = getelementptr inbounds double, double* %611, i64 2
%614 = bitcast double* %613 to <2 x double>*
store <2 x double> %609, <2 x double>* %614
%615 = add nuw i64 %580, 8
%616 = add i64 %581, 2
%617 = icmp eq i64 %616, %214
br i1 %617, label %618, label %579
618: ; preds = %579, %578
%619 = phi i64 [ 0, %578 ], [ %615, %579 ]
br i1 %215, label %637, label %620
620: ; preds = %618
%621 = add i64 %619, %415
%622 = trunc i64 %619 to i32
%623 = add i32 %374, %622
%624 = add i32 %569, %623
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds double, double* %2, i64 %625
%627 = bitcast double* %626 to <2 x double>*
%628 = load <2 x double>, <2 x double>* %627
%629 = getelementptr inbounds double, double* %626, i64 2
%630 = bitcast double* %629 to <2 x double>*
%631 = load <2 x double>, <2 x double>* %630
%632 = add nsw i64 %621, %570
%633 = getelementptr inbounds double, double* %3, i64 %632
%634 = bitcast double* %633 to <2 x double>*
store <2 x double> %628, <2 x double>* %634
%635 = getelementptr inbounds double, double* %633, i64 2
%636 = bitcast double* %635 to <2 x double>*
store <2 x double> %631, <2 x double>* %636
br label %637
637: ; preds = %618, %620
br i1 %216, label %696, label %638
638: ; preds = %574, %566, %637
%639 = phi i64 [ %415, %574 ], [ %415, %566 ], [ %429, %637 ]
%640 = trunc i64 %639 to i32
%641 = sub i32 %373, %640
%642 = and i32 %641, 1
%643 = icmp eq i32 %642, 0
br i1 %643, label %653, label %644
644: ; preds = %638
%645 = trunc i64 %639 to i32
%646 = add i32 %569, %645
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds double, double* %2, i64 %647
%649 = load double, double* %648
%650 = add nsw i64 %639, %570
%651 = getelementptr inbounds double, double* %3, i64 %650
store double %649, double* %651
%652 = add nsw i64 %639, 1
br label %653
653: ; preds = %644, %638
%654 = phi i64 [ %639, %638 ], [ %652, %644 ]
%655 = icmp eq i32 %382, %640
br i1 %655, label %696, label %676
656: ; preds = %562, %656
%657 = phi i64 [ %673, %656 ], [ %563, %562 ]
%658 = trunc i64 %657 to i32
%659 = add i32 %472, %658
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds double, double* %1, i64 %660
%662 = load double, double* %661
%663 = add nsw i64 %657, %473
%664 = getelementptr inbounds double, double* %3, i64 %663
store double %662, double* %664
%665 = add nsw i64 %657, 1
%666 = trunc i64 %665 to i32
%667 = add i32 %472, %666
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds double, double* %1, i64 %668
%670 = load double, double* %669
%671 = add nsw i64 %665, %473
%672 = getelementptr inbounds double, double* %3, i64 %671
store double %670, double* %672
%673 = add nsw i64 %657, 2
%674 = trunc i64 %673 to i32
%675 = icmp eq i32 %374, %674
br i1 %675, label %565, label %656
676: ; preds = %653, %676
%677 = phi i64 [ %693, %676 ], [ %654, %653 ]
%678 = trunc i64 %677 to i32
%679 = add i32 %569, %678
%680 = sext i32 %679 to i64
%681 = getelementptr inbounds double, double* %2, i64 %680
%682 = load double, double* %681
%683 = add nsw i64 %677, %570
%684 = getelementptr inbounds double, double* %3, i64 %683
store double %682, double* %684
%685 = add nsw i64 %677, 1
%686 = trunc i64 %685 to i32
%687 = add i32 %569, %686
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds double, double* %2, i64 %688
%690 = load double, double* %689
%691 = add nsw i64 %685, %570
%692 = getelementptr inbounds double, double* %3, i64 %691
store double %690, double* %692
%693 = add nsw i64 %677, 2
%694 = trunc i64 %693 to i32
%695 = icmp eq i32 %373, %694
br i1 %695, label %696, label %676
696: ; preds = %653, %676, %637, %565
br i1 %427, label %697, label %807
697: ; preds = %696
%698 = trunc i64 %434 to i32
%699 = mul i32 %698, %5
%700 = add i32 %699, %421
%701 = mul nsw i64 %434, %139
%702 = add i32 %469, %140
%703 = icmp slt i32 %702, %469
%704 = select i1 %217, i1 true, i1 %703
br i1 %704, label %769, label %705
705: ; preds = %697
%706 = icmp ult double* %459, %467
%707 = icmp ult double* %466, %461
%708 = and i1 %706, %707
br i1 %708, label %769, label %709
709: ; preds = %705
br i1 %220, label %749, label %710
710: ; preds = %709, %710
%711 = phi i64 [ %746, %710 ], [ 0, %709 ]
%712 = phi i64 [ %747, %710 ], [ 0, %709 ]
%713 = add i64 %711, %414
%714 = trunc i64 %711 to i32
%715 = add i32 %372, %714
%716 = add i32 %700, %715
%717 = sext i32 %716 to i64
%718 = getelementptr inbounds double, double* %0, i64 %717
%719 = bitcast double* %718 to <2 x double>*
%720 = load <2 x double>, <2 x double>* %719
%721 = getelementptr inbounds double, double* %718, i64 2
%722 = bitcast double* %721 to <2 x double>*
%723 = load <2 x double>, <2 x double>* %722
%724 = add nsw i64 %713, %701
%725 = getelementptr inbounds double, double* %3, i64 %724
%726 = bitcast double* %725 to <2 x double>*
store <2 x double> %720, <2 x double>* %726
%727 = getelementptr inbounds double, double* %725, i64 2
%728 = bitcast double* %727 to <2 x double>*
store <2 x double> %723, <2 x double>* %728
%729 = or i64 %711, 4
%730 = add i64 %729, %414
%731 = trunc i64 %729 to i32
%732 = add i32 %372, %731
%733 = add i32 %700, %732
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds double, double* %0, i64 %734
%736 = bitcast double* %735 to <2 x double>*
%737 = load <2 x double>, <2 x double>* %736
%738 = getelementptr inbounds double, double* %735, i64 2
%739 = bitcast double* %738 to <2 x double>*
%740 = load <2 x double>, <2 x double>* %739
%741 = add nsw i64 %730, %701
%742 = getelementptr inbounds double, double* %3, i64 %741
%743 = bitcast double* %742 to <2 x double>*
store <2 x double> %737, <2 x double>* %743
%744 = getelementptr inbounds double, double* %742, i64 2
%745 = bitcast double* %744 to <2 x double>*
store <2 x double> %740, <2 x double>* %745
%746 = add nuw i64 %711, 8
%747 = add i64 %712, 2
%748 = icmp eq i64 %747, %221
br i1 %748, label %749, label %710
749: ; preds = %710, %709
%750 = phi i64 [ 0, %709 ], [ %746, %710 ]
br i1 %222, label %768, label %751
751: ; preds = %749
%752 = add i64 %750, %414
%753 = trunc i64 %750 to i32
%754 = add i32 %372, %753
%755 = add i32 %700, %754
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds double, double* %0, i64 %756
%758 = bitcast double* %757 to <2 x double>*
%759 = load <2 x double>, <2 x double>* %758
%760 = getelementptr inbounds double, double* %757, i64 2
%761 = bitcast double* %760 to <2 x double>*
%762 = load <2 x double>, <2 x double>* %761
%763 = add nsw i64 %752, %701
%764 = getelementptr inbounds double, double* %3, i64 %763
%765 = bitcast double* %764 to <2 x double>*
store <2 x double> %759, <2 x double>* %765
%766 = getelementptr inbounds double, double* %764, i64 2
%767 = bitcast double* %766 to <2 x double>*
store <2 x double> %762, <2 x double>* %767
br label %768
768: ; preds = %749, %751
br i1 %223, label %807, label %769
769: ; preds = %705, %697, %768
%770 = phi i64 [ %414, %705 ], [ %414, %697 ], [ %430, %768 ]
%771 = trunc i64 %770 to i32
%772 = sub i32 %375, %771
%773 = and i32 %772, 1
%774 = icmp eq i32 %773, 0
br i1 %774, label %784, label %775
775: ; preds = %769
%776 = trunc i64 %770 to i32
%777 = add i32 %700, %776
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds double, double* %0, i64 %778
%780 = load double, double* %779
%781 = add nsw i64 %770, %701
%782 = getelementptr inbounds double, double* %3, i64 %781
store double %780, double* %782
%783 = add nsw i64 %770, 1
br label %784
784: ; preds = %775, %769
%785 = phi i64 [ %770, %769 ], [ %783, %775 ]
%786 = icmp eq i32 %379, %771
br i1 %786, label %807, label %787
787: ; preds = %784, %787
%788 = phi i64 [ %804, %787 ], [ %785, %784 ]
%789 = trunc i64 %788 to i32
%790 = add i32 %700, %789
%791 = sext i32 %790 to i64
%792 = getelementptr inbounds double, double* %0, i64 %791
%793 = load double, double* %792
%794 = add nsw i64 %788, %701
%795 = getelementptr inbounds double, double* %3, i64 %794
store double %793, double* %795
%796 = add nsw i64 %788, 1
%797 = trunc i64 %796 to i32
%798 = add i32 %700, %797
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds double, double* %0, i64 %799
%801 = load double, double* %800
%802 = add nsw i64 %796, %701
%803 = getelementptr inbounds double, double* %3, i64 %802
store double %801, double* %803
%804 = add nsw i64 %788, 2
%805 = trunc i64 %804 to i32
%806 = icmp eq i32 %375, %805
br i1 %806, label %807, label %787
807: ; preds = %784, %787, %768, %696
%808 = add nsw i64 %434, 1
%809 = trunc i64 %808 to i32
%810 = icmp eq i32 %374, %809
%811 = add i32 %433, 1
%812 = add i64 %432, 1
br i1 %810, label %361, label %431
813: ; preds = %361, %133
%814 = mul i32 %134, %5
%815 = mul i32 %5, %4
%816 = icmp slt i32 %814, %815
br i1 %816, label %817, label %1146
817: ; preds = %813
%818 = mul nsw i32 %7, %134
%819 = add nsw i32 %4, -2
%820 = mul i32 %819, %5
%821 = icmp slt i32 %820, %814
%822 = sext i32 %814 to i64
%823 = sext i32 %820 to i64
%824 = sext i32 %4 to i64
%825 = sext i32 %815 to i64
%826 = xor i64 %823, -1
%827 = add nsw i64 %826, %822
%828 = mul i32 %134, %5
%829 = shl i32 %828, 1
%830 = add i32 %829, %4
%831 = add i32 %830, -2
%832 = mul nsw i64 %824, %822
%833 = add i64 %832, %823
%834 = add nsw i64 %824, 1
%835 = mul i64 %834, %822
%836 = mul i32 %134, %5
%837 = shl i32 %836, 1
%838 = add i32 %837, %4
%839 = add i32 %838, -2
%840 = sub nsw i64 0, %823
%841 = getelementptr double, double* %0, i64 %840
%842 = sub nsw i64 %822, %823
%843 = xor i64 %822, -1
%844 = add nsw i64 %843, %825
%845 = mul i32 %134, %5
%846 = shl i32 %5, 1
%847 = or i32 %846, 1
%848 = mul i32 %845, %847
%849 = add nsw i64 %824, 1
%850 = mul i64 %849, %822
%851 = mul nsw i64 %824, %822
%852 = add i64 %851, %825
%853 = mul i32 %134, %5
%854 = shl i32 %5, 1
%855 = or i32 %854, 1
%856 = mul i32 %853, %855
%857 = sub nsw i64 0, %822
%858 = getelementptr double, double* %1, i64 %857
%859 = sub nsw i64 %825, %822
%860 = add nsw i64 %859, -4
%861 = lshr i64 %860, 2
%862 = add nuw nsw i64 %861, 1
%863 = add nsw i64 %842, -4
%864 = lshr i64 %863, 2
%865 = add nuw nsw i64 %864, 1
%866 = icmp ult i64 %859, 4
%867 = trunc i64 %844 to i32
%868 = icmp ugt i64 %844, 4294967295
%869 = and i64 %859, -4
%870 = add nsw i64 %869, %822
%871 = and i64 %862, 1
%872 = icmp ult i64 %860, 4
%873 = and i64 %862, 9223372036854775806
%874 = icmp eq i64 %871, 0
%875 = icmp eq i64 %859, %869
%876 = sub nsw i64 0, %825
%877 = icmp ult i64 %842, 4
%878 = trunc i64 %827 to i32
%879 = icmp ugt i64 %827, 4294967295
%880 = and i64 %842, -4
%881 = add nsw i64 %880, %823
%882 = and i64 %865, 1
%883 = icmp ult i64 %863, 4
%884 = and i64 %865, 9223372036854775806
%885 = icmp eq i64 %882, 0
%886 = icmp eq i64 %842, %880
%887 = sub nsw i64 0, %822
br label %888
888: ; preds = %1141, %817
%889 = phi i64 [ %1145, %1141 ], [ 0, %817 ]
%890 = phi i32 [ %1144, %1141 ], [ 0, %817 ]
%891 = phi i64 [ %1142, %1141 ], [ %822, %817 ]
%892 = mul i64 %889, %824
%893 = add i64 %850, %892
%894 = getelementptr double, double* %3, i64 %893
%895 = add i64 %852, %892
%896 = getelementptr double, double* %3, i64 %895
%897 = trunc i64 %889 to i32
%898 = mul i32 %897, %5
%899 = add i32 %898, %856
%900 = sext i32 %899 to i64
%901 = getelementptr double, double* %1, i64 %900
%902 = add nsw i64 %825, %900
%903 = getelementptr double, double* %858, i64 %902
%904 = trunc i64 %889 to i32
%905 = mul i32 %904, %5
%906 = add i32 %905, %848
%907 = mul i64 %889, %824
%908 = add i64 %833, %907
%909 = getelementptr double, double* %3, i64 %908
%910 = add i64 %835, %907
%911 = getelementptr double, double* %3, i64 %910
%912 = trunc i64 %889 to i32
%913 = add i32 %839, %912
%914 = mul i32 %913, %5
%915 = sext i32 %914 to i64
%916 = getelementptr double, double* %0, i64 %915
%917 = add nsw i64 %822, %915
%918 = getelementptr double, double* %841, i64 %917
%919 = add i32 %831, %890
%920 = mul i32 %919, %5
%921 = trunc i64 %891 to i32
%922 = mul i32 %921, %5
%923 = add i32 %922, %818
%924 = mul nsw i64 %891, %824
br i1 %866, label %993, label %925
925: ; preds = %888
%926 = add i32 %906, %867
%927 = icmp slt i32 %926, %906
%928 = or i1 %927, %868
br i1 %928, label %993, label %929
929: ; preds = %925
%930 = icmp ult double* %894, %903
%931 = icmp ult double* %901, %896
%932 = and i1 %930, %931
br i1 %932, label %993, label %933
933: ; preds = %929
br i1 %872, label %973, label %934
934: ; preds = %933, %934
%935 = phi i64 [ %970, %934 ], [ 0, %933 ]
%936 = phi i64 [ %971, %934 ], [ 0, %933 ]
%937 = add i64 %935, %822
%938 = trunc i64 %935 to i32
%939 = add i32 %814, %938
%940 = add i32 %923, %939
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds double, double* %1, i64 %941
%943 = bitcast double* %942 to <2 x double>*
%944 = load <2 x double>, <2 x double>* %943
%945 = getelementptr inbounds double, double* %942, i64 2
%946 = bitcast double* %945 to <2 x double>*
%947 = load <2 x double>, <2 x double>* %946
%948 = add nsw i64 %937, %924
%949 = getelementptr inbounds double, double* %3, i64 %948
%950 = bitcast double* %949 to <2 x double>*
store <2 x double> %944, <2 x double>* %950
%951 = getelementptr inbounds double, double* %949, i64 2
%952 = bitcast double* %951 to <2 x double>*
store <2 x double> %947, <2 x double>* %952
%953 = or i64 %935, 4
%954 = add i64 %953, %822
%955 = trunc i64 %953 to i32
%956 = add i32 %814, %955
%957 = add i32 %923, %956
%958 = sext i32 %957 to i64
%959 = getelementptr inbounds double, double* %1, i64 %958
%960 = bitcast double* %959 to <2 x double>*
%961 = load <2 x double>, <2 x double>* %960
%962 = getelementptr inbounds double, double* %959, i64 2
%963 = bitcast double* %962 to <2 x double>*
%964 = load <2 x double>, <2 x double>* %963
%965 = add nsw i64 %954, %924
%966 = getelementptr inbounds double, double* %3, i64 %965
%967 = bitcast double* %966 to <2 x double>*
store <2 x double> %961, <2 x double>* %967
%968 = getelementptr inbounds double, double* %966, i64 2
%969 = bitcast double* %968 to <2 x double>*
store <2 x double> %964, <2 x double>* %969
%970 = add nuw i64 %935, 8
%971 = add i64 %936, 2
%972 = icmp eq i64 %971, %873
br i1 %972, label %973, label %934
973: ; preds = %934, %933
%974 = phi i64 [ 0, %933 ], [ %970, %934 ]
br i1 %874, label %992, label %975
975: ; preds = %973
%976 = add i64 %974, %822
%977 = trunc i64 %974 to i32
%978 = add i32 %814, %977
%979 = add i32 %923, %978
%980 = sext i32 %979 to i64
%981 = getelementptr inbounds double, double* %1, i64 %980
%982 = bitcast double* %981 to <2 x double>*
%983 = load <2 x double>, <2 x double>* %982
%984 = getelementptr inbounds double, double* %981, i64 2
%985 = bitcast double* %984 to <2 x double>*
%986 = load <2 x double>, <2 x double>* %985
%987 = add nsw i64 %976, %924
%988 = getelementptr inbounds double, double* %3, i64 %987
%989 = bitcast double* %988 to <2 x double>*
store <2 x double> %983, <2 x double>* %989
%990 = getelementptr inbounds double, double* %988, i64 2
%991 = bitcast double* %990 to <2 x double>*
store <2 x double> %986, <2 x double>* %991
br label %992
992: ; preds = %973, %975
br i1 %875, label %1030, label %993
993: ; preds = %929, %925, %888, %992
%994 = phi i64 [ %822, %929 ], [ %822, %925 ], [ %822, %888 ], [ %870, %992 ]
%995 = sub nsw i64 %825, %994
%996 = xor i64 %994, -1
%997 = and i64 %995, 1
%998 = icmp eq i64 %997, 0
br i1 %998, label %1008, label %999
999: ; preds = %993
%1000 = trunc i64 %994 to i32
%1001 = add i32 %923, %1000
%1002 = sext i32 %1001 to i64
%1003 = getelementptr inbounds double, double* %1, i64 %1002
%1004 = load double, double* %1003
%1005 = add nsw i64 %994, %924
%1006 = getelementptr inbounds double, double* %3, i64 %1005
store double %1004, double* %1006
%1007 = add nsw i64 %994, 1
br label %1008
1008: ; preds = %999, %993
%1009 = phi i64 [ %994, %993 ], [ %1007, %999 ]
%1010 = icmp eq i64 %996, %876
br i1 %1010, label %1030, label %1011
1011: ; preds = %1008, %1011
%1012 = phi i64 [ %1028, %1011 ], [ %1009, %1008 ]
%1013 = trunc i64 %1012 to i32
%1014 = add i32 %923, %1013
%1015 = sext i32 %1014 to i64
%1016 = getelementptr inbounds double, double* %1, i64 %1015
%1017 = load double, double* %1016
%1018 = add nsw i64 %1012, %924
%1019 = getelementptr inbounds double, double* %3, i64 %1018
store double %1017, double* %1019
%1020 = add nsw i64 %1012, 1
%1021 = trunc i64 %1020 to i32
%1022 = add i32 %923, %1021
%1023 = sext i32 %1022 to i64
%1024 = getelementptr inbounds double, double* %1, i64 %1023
%1025 = load double, double* %1024
%1026 = add nsw i64 %1020, %924
%1027 = getelementptr inbounds double, double* %3, i64 %1026
store double %1025, double* %1027
%1028 = add nsw i64 %1012, 2
%1029 = icmp eq i64 %1028, %825
br i1 %1029, label %1030, label %1011
1030: ; preds = %1008, %1011, %992
br i1 %821, label %1031, label %1141
1031: ; preds = %1030
%1032 = trunc i64 %891 to i32
%1033 = mul i32 %1032, %5
%1034 = add i32 %1033, %818
%1035 = mul nsw i64 %891, %824
br i1 %877, label %1104, label %1036
1036: ; preds = %1031
%1037 = add i32 %920, %878
%1038 = icmp slt i32 %1037, %920
%1039 = or i1 %1038, %879
br i1 %1039, label %1104, label %1040
1040: ; preds = %1036
%1041 = icmp ult double* %909, %918
%1042 = icmp ult double* %916, %911
%1043 = and i1 %1041, %1042
br i1 %1043, label %1104, label %1044
1044: ; preds = %1040
br i1 %883, label %1084, label %1045
1045: ; preds = %1044, %1045
%1046 = phi i64 [ %1081, %1045 ], [ 0, %1044 ]
%1047 = phi i64 [ %1082, %1045 ], [ 0, %1044 ]
%1048 = add i64 %1046, %823
%1049 = trunc i64 %1046 to i32
%1050 = add i32 %820, %1049
%1051 = add i32 %1034, %1050
%1052 = sext i32 %1051 to i64
%1053 = getelementptr inbounds double, double* %0, i64 %1052
%1054 = bitcast double* %1053 to <2 x double>*
%1055 = load <2 x double>, <2 x double>* %1054
%1056 = getelementptr inbounds double, double* %1053, i64 2
%1057 = bitcast double* %1056 to <2 x double>*
%1058 = load <2 x double>, <2 x double>* %1057
%1059 = add nsw i64 %1048, %1035
%1060 = getelementptr inbounds double, double* %3, i64 %1059
%1061 = bitcast double* %1060 to <2 x double>*
store <2 x double> %1055, <2 x double>* %1061
%1062 = getelementptr inbounds double, double* %1060, i64 2
%1063 = bitcast double* %1062 to <2 x double>*
store <2 x double> %1058, <2 x double>* %1063
%1064 = or i64 %1046, 4
%1065 = add i64 %1064, %823
%1066 = trunc i64 %1064 to i32
%1067 = add i32 %820, %1066
%1068 = add i32 %1034, %1067
%1069 = sext i32 %1068 to i64
%1070 = getelementptr inbounds double, double* %0, i64 %1069
%1071 = bitcast double* %1070 to <2 x double>*
%1072 = load <2 x double>, <2 x double>* %1071
%1073 = getelementptr inbounds double, double* %1070, i64 2
%1074 = bitcast double* %1073 to <2 x double>*
%1075 = load <2 x double>, <2 x double>* %1074
%1076 = add nsw i64 %1065, %1035
%1077 = getelementptr inbounds double, double* %3, i64 %1076
%1078 = bitcast double* %1077 to <2 x double>*
store <2 x double> %1072, <2 x double>* %1078
%1079 = getelementptr inbounds double, double* %1077, i64 2
%1080 = bitcast double* %1079 to <2 x double>*
store <2 x double> %1075, <2 x double>* %1080
%1081 = add nuw i64 %1046, 8
%1082 = add i64 %1047, 2
%1083 = icmp eq i64 %1082, %884
br i1 %1083, label %1084, label %1045
1084: ; preds = %1045, %1044
%1085 = phi i64 [ 0, %1044 ], [ %1081, %1045 ]
br i1 %885, label %1103, label %1086
1086: ; preds = %1084
%1087 = add i64 %1085, %823
%1088 = trunc i64 %1085 to i32
%1089 = add i32 %820, %1088
%1090 = add i32 %1034, %1089
%1091 = sext i32 %1090 to i64
%1092 = getelementptr inbounds double, double* %0, i64 %1091
%1093 = bitcast double* %1092 to <2 x double>*
%1094 = load <2 x double>, <2 x double>* %1093
%1095 = getelementptr inbounds double, double* %1092, i64 2
%1096 = bitcast double* %1095 to <2 x double>*
%1097 = load <2 x double>, <2 x double>* %1096
%1098 = add nsw i64 %1087, %1035
%1099 = getelementptr inbounds double, double* %3, i64 %1098
%1100 = bitcast double* %1099 to <2 x double>*
store <2 x double> %1094, <2 x double>* %1100
%1101 = getelementptr inbounds double, double* %1099, i64 2
%1102 = bitcast double* %1101 to <2 x double>*
store <2 x double> %1097, <2 x double>* %1102
br label %1103
1103: ; preds = %1084, %1086
br i1 %886, label %1141, label %1104
1104: ; preds = %1040, %1036, %1031, %1103
%1105 = phi i64 [ %823, %1040 ], [ %823, %1036 ], [ %823, %1031 ], [ %881, %1103 ]
%1106 = sub nsw i64 %822, %1105
%1107 = xor i64 %1105, -1
%1108 = and i64 %1106, 1
%1109 = icmp eq i64 %1108, 0
br i1 %1109, label %1119, label %1110
1110: ; preds = %1104
%1111 = trunc i64 %1105 to i32
%1112 = add i32 %1034, %1111
%1113 = sext i32 %1112 to i64
%1114 = getelementptr inbounds double, double* %0, i64 %1113
%1115 = load double, double* %1114
%1116 = add nsw i64 %1105, %1035
%1117 = getelementptr inbounds double, double* %3, i64 %1116
store double %1115, double* %1117
%1118 = add nsw i64 %1105, 1
br label %1119
1119: ; preds = %1110, %1104
%1120 = phi i64 [ %1105, %1104 ], [ %1118, %1110 ]
%1121 = icmp eq i64 %1107, %887
br i1 %1121, label %1141, label %1122
1122: ; preds = %1119, %1122
%1123 = phi i64 [ %1139, %1122 ], [ %1120, %1119 ]
%1124 = trunc i64 %1123 to i32
%1125 = add i32 %1034, %1124
%1126 = sext i32 %1125 to i64
%1127 = getelementptr inbounds double, double* %0, i64 %1126
%1128 = load double, double* %1127
%1129 = add nsw i64 %1123, %1035
%1130 = getelementptr inbounds double, double* %3, i64 %1129
store double %1128, double* %1130
%1131 = add nsw i64 %1123, 1
%1132 = trunc i64 %1131 to i32
%1133 = add i32 %1034, %1132
%1134 = sext i32 %1133 to i64
%1135 = getelementptr inbounds double, double* %0, i64 %1134
%1136 = load double, double* %1135
%1137 = add nsw i64 %1131, %1035
%1138 = getelementptr inbounds double, double* %3, i64 %1137
store double %1136, double* %1138
%1139 = add nsw i64 %1123, 2
%1140 = icmp eq i64 %1139, %822
br i1 %1140, label %1141, label %1122
1141: ; preds = %1119, %1122, %1103, %1030
%1142 = add nsw i64 %891, 1
%1143 = icmp eq i64 %1142, %825
%1144 = add i32 %890, 1
%1145 = add i64 %889, 1
br i1 %1143, label %1146, label %888
1146: ; preds = %1141, %813
ret void
}