void cvt_d2s_mat2pmat(int row, int col, int offset, int bs_dummy, double *A,
                      int lda, float *pA, int sda) {
  const int bs = 8;
  int i, ii, j, row0, row1, row2;
  row0 = (bs - offset % bs) % bs;
  if (row0 > row)
    row0 = row;
  row1 = row - row0;
  ii = 0;
  if (row0 > 0) {
    for (j = 0; j < col; j++) {
      for (i = 0; i < row0; i++) {
        pA[i + j * bs + ii * sda] = (float)A[i + ii + j * lda];
      }
    }
    A += row0;
    pA += row0 + bs * (sda - 1);
  }
  ii = 0;
  for (; ii < row1 - 7; ii += bs) {
    j = 0;
    for (; j < col - 7; j += 8) {
      pA[0 + (j + 0) * bs + ii * sda] = (float)A[ii + 0 + (j + 0) * lda];
      pA[1 + (j + 0) * bs + ii * sda] = (float)A[ii + 1 + (j + 0) * lda];
      pA[2 + (j + 0) * bs + ii * sda] = (float)A[ii + 2 + (j + 0) * lda];
      pA[3 + (j + 0) * bs + ii * sda] = (float)A[ii + 3 + (j + 0) * lda];
      pA[4 + (j + 0) * bs + ii * sda] = (float)A[ii + 4 + (j + 0) * lda];
      pA[5 + (j + 0) * bs + ii * sda] = (float)A[ii + 5 + (j + 0) * lda];
      pA[6 + (j + 0) * bs + ii * sda] = (float)A[ii + 6 + (j + 0) * lda];
      pA[7 + (j + 0) * bs + ii * sda] = (float)A[ii + 7 + (j + 0) * lda];
      pA[0 + (j + 1) * bs + ii * sda] = (float)A[ii + 0 + (j + 1) * lda];
      pA[1 + (j + 1) * bs + ii * sda] = (float)A[ii + 1 + (j + 1) * lda];
      pA[2 + (j + 1) * bs + ii * sda] = (float)A[ii + 2 + (j + 1) * lda];
      pA[3 + (j + 1) * bs + ii * sda] = (float)A[ii + 3 + (j + 1) * lda];
      pA[4 + (j + 1) * bs + ii * sda] = (float)A[ii + 4 + (j + 1) * lda];
      pA[5 + (j + 1) * bs + ii * sda] = (float)A[ii + 5 + (j + 1) * lda];
      pA[6 + (j + 1) * bs + ii * sda] = (float)A[ii + 6 + (j + 1) * lda];
      pA[7 + (j + 1) * bs + ii * sda] = (float)A[ii + 7 + (j + 1) * lda];
      pA[0 + (j + 2) * bs + ii * sda] = (float)A[ii + 0 + (j + 2) * lda];
      pA[1 + (j + 2) * bs + ii * sda] = (float)A[ii + 1 + (j + 2) * lda];
      pA[2 + (j + 2) * bs + ii * sda] = (float)A[ii + 2 + (j + 2) * lda];
      pA[3 + (j + 2) * bs + ii * sda] = (float)A[ii + 3 + (j + 2) * lda];
      pA[4 + (j + 2) * bs + ii * sda] = (float)A[ii + 4 + (j + 2) * lda];
      pA[5 + (j + 2) * bs + ii * sda] = (float)A[ii + 5 + (j + 2) * lda];
      pA[6 + (j + 2) * bs + ii * sda] = (float)A[ii + 6 + (j + 2) * lda];
      pA[7 + (j + 2) * bs + ii * sda] = (float)A[ii + 7 + (j + 2) * lda];
      pA[0 + (j + 3) * bs + ii * sda] = (float)A[ii + 0 + (j + 3) * lda];
      pA[1 + (j + 3) * bs + ii * sda] = (float)A[ii + 1 + (j + 3) * lda];
      pA[2 + (j + 3) * bs + ii * sda] = (float)A[ii + 2 + (j + 3) * lda];
      pA[3 + (j + 3) * bs + ii * sda] = (float)A[ii + 3 + (j + 3) * lda];
      pA[4 + (j + 3) * bs + ii * sda] = (float)A[ii + 4 + (j + 3) * lda];
      pA[5 + (j + 3) * bs + ii * sda] = (float)A[ii + 5 + (j + 3) * lda];
      pA[6 + (j + 3) * bs + ii * sda] = (float)A[ii + 6 + (j + 3) * lda];
      pA[7 + (j + 3) * bs + ii * sda] = (float)A[ii + 7 + (j + 3) * lda];
      pA[0 + (j + 4) * bs + ii * sda] = (float)A[ii + 0 + (j + 4) * lda];
      pA[1 + (j + 4) * bs + ii * sda] = (float)A[ii + 1 + (j + 4) * lda];
      pA[2 + (j + 4) * bs + ii * sda] = (float)A[ii + 2 + (j + 4) * lda];
      pA[3 + (j + 4) * bs + ii * sda] = (float)A[ii + 3 + (j + 4) * lda];
      pA[4 + (j + 4) * bs + ii * sda] = (float)A[ii + 4 + (j + 4) * lda];
      pA[5 + (j + 4) * bs + ii * sda] = (float)A[ii + 5 + (j + 4) * lda];
      pA[6 + (j + 4) * bs + ii * sda] = (float)A[ii + 6 + (j + 4) * lda];
      pA[7 + (j + 4) * bs + ii * sda] = (float)A[ii + 7 + (j + 4) * lda];
      pA[0 + (j + 5) * bs + ii * sda] = (float)A[ii + 0 + (j + 5) * lda];
      pA[1 + (j + 5) * bs + ii * sda] = (float)A[ii + 1 + (j + 5) * lda];
      pA[2 + (j + 5) * bs + ii * sda] = (float)A[ii + 2 + (j + 5) * lda];
      pA[3 + (j + 5) * bs + ii * sda] = (float)A[ii + 3 + (j + 5) * lda];
      pA[4 + (j + 5) * bs + ii * sda] = (float)A[ii + 4 + (j + 5) * lda];
      pA[5 + (j + 5) * bs + ii * sda] = (float)A[ii + 5 + (j + 5) * lda];
      pA[6 + (j + 5) * bs + ii * sda] = (float)A[ii + 6 + (j + 5) * lda];
      pA[7 + (j + 5) * bs + ii * sda] = (float)A[ii + 7 + (j + 5) * lda];
      pA[0 + (j + 6) * bs + ii * sda] = (float)A[ii + 0 + (j + 6) * lda];
      pA[1 + (j + 6) * bs + ii * sda] = (float)A[ii + 1 + (j + 6) * lda];
      pA[2 + (j + 6) * bs + ii * sda] = (float)A[ii + 2 + (j + 6) * lda];
      pA[3 + (j + 6) * bs + ii * sda] = (float)A[ii + 3 + (j + 6) * lda];
      pA[4 + (j + 6) * bs + ii * sda] = (float)A[ii + 4 + (j + 6) * lda];
      pA[5 + (j + 6) * bs + ii * sda] = (float)A[ii + 5 + (j + 6) * lda];
      pA[6 + (j + 6) * bs + ii * sda] = (float)A[ii + 6 + (j + 6) * lda];
      pA[7 + (j + 6) * bs + ii * sda] = (float)A[ii + 7 + (j + 6) * lda];
      pA[0 + (j + 7) * bs + ii * sda] = (float)A[ii + 0 + (j + 7) * lda];
      pA[1 + (j + 7) * bs + ii * sda] = (float)A[ii + 1 + (j + 7) * lda];
      pA[2 + (j + 7) * bs + ii * sda] = (float)A[ii + 2 + (j + 7) * lda];
      pA[3 + (j + 7) * bs + ii * sda] = (float)A[ii + 3 + (j + 7) * lda];
      pA[4 + (j + 7) * bs + ii * sda] = (float)A[ii + 4 + (j + 7) * lda];
      pA[5 + (j + 7) * bs + ii * sda] = (float)A[ii + 5 + (j + 7) * lda];
      pA[6 + (j + 7) * bs + ii * sda] = (float)A[ii + 6 + (j + 7) * lda];
      pA[7 + (j + 7) * bs + ii * sda] = (float)A[ii + 7 + (j + 7) * lda];
    }
    for (; j < col; j++) {
      pA[0 + (j + 0) * bs + ii * sda] = (float)A[ii + 0 + (j + 0) * lda];
      pA[1 + (j + 0) * bs + ii * sda] = (float)A[ii + 1 + (j + 0) * lda];
      pA[2 + (j + 0) * bs + ii * sda] = (float)A[ii + 2 + (j + 0) * lda];
      pA[3 + (j + 0) * bs + ii * sda] = (float)A[ii + 3 + (j + 0) * lda];
      pA[4 + (j + 0) * bs + ii * sda] = (float)A[ii + 4 + (j + 0) * lda];
      pA[5 + (j + 0) * bs + ii * sda] = (float)A[ii + 5 + (j + 0) * lda];
      pA[6 + (j + 0) * bs + ii * sda] = (float)A[ii + 6 + (j + 0) * lda];
      pA[7 + (j + 0) * bs + ii * sda] = (float)A[ii + 7 + (j + 0) * lda];
    }
  }
  if (ii < row1) {
    row2 = row1 - ii;
    if (bs < row2)
      row2 = bs;
    for (j = 0; j < col; j++) {
      for (i = 0; i < row2; i++) {
        pA[i + j * bs + ii * sda] = (float)A[i + ii + j * lda];
      }
    }
  }
}


x86 assembly (clang, -O0):
<cvt_d2s_mat2pmat>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
movl   $0x8,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    $0x8,%eax
sub    %edx,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jle    1155 <cvt_d2s_mat2pmat+0x55>
mov    -0x4(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    122a <cvt_d2s_mat2pmat+0x12a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11f5 <cvt_d2s_mat2pmat+0xf5>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    11e2 <cvt_d2s_mat2pmat+0xe2>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x2c(%rbp),%edx
shl    $0x3,%edx
add    %edx,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1189 <cvt_d2s_mat2pmat+0x89>
jmp    11e7 <cvt_d2s_mat2pmat+0xe7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1176 <cvt_d2s_mat2pmat+0x76>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%ecx
mov    0x18(%rbp),%eax
sub    $0x1,%eax
shl    $0x3,%eax
add    %eax,%ecx
mov    0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,0x10(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    2572 <cvt_d2s_mat2pmat+0x1472>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    2328 <cvt_d2s_mat2pmat+0x1228>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x2c(%rbp)
jmp    1249 <cvt_d2s_mat2pmat+0x149>
jmp    232d <cvt_d2s_mat2pmat+0x122d>
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    255f <cvt_d2s_mat2pmat+0x145f>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    232d <cvt_d2s_mat2pmat+0x122d>
jmp    2564 <cvt_d2s_mat2pmat+0x1464>
mov    -0x28(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x28(%rbp)
jmp    1231 <cvt_d2s_mat2pmat+0x131>
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2627 <cvt_d2s_mat2pmat+0x1527>
mov    -0x34(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    $0x8,%eax
cmp    -0x38(%rbp),%eax
jge    259c <cvt_d2s_mat2pmat+0x149c>
movl   $0x8,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2622 <cvt_d2s_mat2pmat+0x1522>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    260f <cvt_d2s_mat2pmat+0x150f>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x2c(%rbp),%edx
shl    $0x3,%edx
add    %edx,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    25b6 <cvt_d2s_mat2pmat+0x14b6>
jmp    2614 <cvt_d2s_mat2pmat+0x1514>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    25a3 <cvt_d2s_mat2pmat+0x14a3>
jmp    2627 <cvt_d2s_mat2pmat+0x1527>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvt_d2s_mat2pmat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %esi,%r13d
mov    0x40(%rsp),%ebx
mov    0x38(%rsp),%rcx
neg    %edx
and    $0x7,%edx
cmp    %edi,%edx
cmovg  %edi,%edx
sub    %edx,%edi
mov    %rdx,-0x50(%rsp)
test   %edx,%edx
mov    %r13,-0x28(%rsp)
mov    %r9d,-0x5c(%rsp)
mov    %rdi,-0x20(%rsp)
jle    13ba <cvt_d2s_mat2pmat+0x2ba>
mov    %r8,-0x58(%rsp)
test   %r13d,%r13d
jle    1391 <cvt_d2s_mat2pmat+0x291>
movslq -0x5c(%rsp),%rdx
mov    %r13d,%eax
mov    %rax,-0x30(%rsp)
mov    -0x50(%rsp),%ebp
lea    -0x1(%rbp),%rax
mov    %ebp,%esi
and    $0xfffffffc,%esi
mov    %rsi,-0x40(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,-0x8(%rsp)
mov    %rsi,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,%rsi
mov    %rdi,-0x10(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,-0x18(%rsp)
mov    %rbp,-0x48(%rsp)
neg    %rbp
mov    -0x58(%rsp),%r10
lea    0x30(%r10),%rdi
lea    0x0(,%rdx,8),%r8
mov    $0x4,%r14d
xor    %r9d,%r9d
xor    %r12d,%r12d
mov    %rax,-0x38(%rsp)
jmp    11e2 <cvt_d2s_mat2pmat+0xe2>
nopl   0x0(%rax)
add    $0x1,%r12
add    %r8,%rdi
add    $0x8,%r14
add    $0x8,%r9
add    %r8,%r10
cmp    -0x30(%rsp),%r12
mov    -0x38(%rsp),%rax
je     1391 <cvt_d2s_mat2pmat+0x291>
mov    %r12,%r11
imul   %rdx,%r11
lea    0x0(,%r12,8),%r15
cmpl   $0x4,-0x50(%rsp)
jb     12f0 <cvt_d2s_mat2pmat+0x1f0>
lea    0x0(,%r12,8),%esi
add    %eax,%esi
jb     12f0 <cvt_d2s_mat2pmat+0x1f0>
mov    %rax,%rsi
shr    $0x20,%rsi
mov    $0x0,%ebx
jne    12f2 <cvt_d2s_mat2pmat+0x1f2>
cmpq   $0x0,-0x8(%rsp)
je     137f <cvt_d2s_mat2pmat+0x27f>
mov    -0x18(%rsp),%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rdi,%rbx,8),%xmm0
movupd -0x20(%rdi,%rbx,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
lea    (%r9,%rbx,1),%r13d
and    $0xfffffff8,%r13d
movupd %xmm0,(%rcx,%r13,4)
movupd -0x10(%rdi,%rbx,8),%xmm0
movupd (%rdi,%rbx,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
lea    (%r14,%rbx,1),%eax
and    $0xfffffffc,%eax
movupd %xmm0,(%rcx,%rax,4)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rsi
jne    1240 <cvt_d2s_mat2pmat+0x140>
testb  $0x1,-0x10(%rsp)
je     12cb <cvt_d2s_mat2pmat+0x1cb>
lea    (%rbx,%r11,1),%rax
mov    %rdx,%rsi
mov    -0x58(%rsp),%rdx
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
mov    %rsi,%rdx
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
add    %r15d,%ebx
and    $0xfffffffc,%ebx
movupd %xmm0,(%rcx,%rbx,4)
mov    -0x40(%rsp),%rax
mov    %rax,%rbx
cmp    -0x48(%rsp),%rax
mov    -0x28(%rsp),%r13
je     11c0 <cvt_d2s_mat2pmat+0xc0>
jmp    12f2 <cvt_d2s_mat2pmat+0x1f2>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ebx,%ebx
mov    %rbx,%rsi
testb  $0x1,-0x48(%rsp)
je     1322 <cvt_d2s_mat2pmat+0x222>
add    %rbx,%r11
mov    -0x58(%rsp),%rax
movsd  (%rax,%r11,8),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %ebx,%r15d
and    $0xfffffffc,%r15d
movss  %xmm0,(%rcx,%r15,4)
mov    %rbx,%rsi
or     $0x1,%rsi
not    %rbx
cmp    %rbp,%rbx
je     11c0 <cvt_d2s_mat2pmat+0xc0>
lea    0x1(%rsi),%rbx
add    %r9,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%r10,%rbx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    %esi,%eax
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r10,%rbx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1(%rsi),%eax
movss  %xmm0,(%rcx,%rax,4)
lea    (%rbx,%rbp,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
add    $0x2,%rsi
cmp    $0x1,%rax
jne    1340 <cvt_d2s_mat2pmat+0x240>
jmp    11c0 <cvt_d2s_mat2pmat+0xc0>
xor    %ebx,%ebx
testb  $0x1,-0x10(%rsp)
jne    129a <cvt_d2s_mat2pmat+0x19a>
jmp    12cb <cvt_d2s_mat2pmat+0x1cb>
mov    -0x50(%rsp),%rdx
movslq %edx,%rax
mov    -0x58(%rsp),%r8
lea    (%r8,%rax,8),%r8
mov    0x40(%rsp),%ebx
lea    -0x8(%rdx,%rbx,8),%eax
cltq
lea    (%rcx,%rax,4),%rcx
mov    -0x5c(%rsp),%r9d
mov    -0x20(%rsp),%rdi
xor    %r12d,%r12d
cmp    $0x8,%edi
jl     1b53 <cvt_d2s_mat2pmat+0xa53>
lea    -0x7(%rdi),%eax
mov    %rax,-0x48(%rsp)
lea    -0x7(%r13),%esi
movslq %r9d,%rax
movslq %esi,%r11
movslq %ebx,%rsi
mov    %r13d,%edi
mov    %rdi,-0x40(%rsp)
mov    %rax,%r15
shl    $0x6,%r15
lea    0x0(,%rbx,8),%edi
mov    %rdi,-0x30(%rsp)
lea    0xe0(%rcx),%rbp
mov    %rsi,-0x58(%rsp)
shl    $0x5,%rsi
mov    %rsi,-0x38(%rsp)
lea    0x0(,%rax,8),%r9
mov    $0x4,%esi
mov    %rsi,-0x50(%rsp)
xor    %r10d,%r10d
mov    %r8,%r14
xor    %r12d,%r12d
jmp    1458 <cvt_d2s_mat2pmat+0x358>
nopl   0x0(%rax,%rax,1)
add    $0x8,%r12
add    $0x40,%r14
add    -0x30(%rsp),%r10
add    -0x38(%rsp),%rbp
addq   $0x8,-0x50(%rsp)
cmp    -0x48(%rsp),%r12
mov    -0x28(%rsp),%r13
jae    1b45 <cvt_d2s_mat2pmat+0xa45>
mov    $0x0,%edi
cmp    $0x8,%r13d
jl     1a4f <cvt_d2s_mat2pmat+0x94f>
mov    %r8,%rbx
xor    %r13d,%r13d
mov    %r14,%r8
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xe0(%rbp,%r13,4)
ff ff ff
movsd  0x8(%r8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x10(%r8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x18(%r8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x3(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x20(%r8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x4(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x28(%r8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x5(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x30(%r8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x6(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x38(%r8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x7(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  (%r8,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xc0(%rbp,%r13,4)
ff ff ff
movsd  0x8(%r8,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x9(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x10(%r8,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xa(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x18(%r8,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xb(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x20(%r8,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xc(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x28(%r8,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xd(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x30(%r8,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xe(%r10,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x38(%r8,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xf(%r10,%r13,1),%edx
movslq %edx,%rsi
lea    (%r8,%r9,1),%rdx
movss  %xmm0,(%rcx,%rsi,4)
movsd  (%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa0(%rbp,%r13,4)
ff ff ff
movsd  0x8(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x11(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x10(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x12(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x18(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x13(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x20(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x14(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x28(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x15(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x30(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x16(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x38(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x17(%r10,%r13,1),%esi
movslq %esi,%rsi
lea    (%rdx,%r9,1),%rdx
movss  %xmm0,(%rcx,%rsi,4)
movsd  (%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp,%r13,4)
movsd  0x8(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x19(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x10(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1a(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x18(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1b(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x20(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1c(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x28(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1d(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x30(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1e(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x38(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1f(%r10,%r13,1),%esi
movslq %esi,%rsi
lea    (%rdx,%r9,1),%rdx
movss  %xmm0,(%rcx,%rsi,4)
movsd  (%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp,%r13,4)
movsd  0x8(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x21(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x10(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x22(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x18(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x23(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x20(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x24(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x28(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x25(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x30(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x26(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x38(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x27(%r10,%r13,1),%esi
movslq %esi,%rsi
lea    (%rdx,%r9,1),%rdx
movss  %xmm0,(%rcx,%rsi,4)
movsd  (%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp,%r13,4)
movsd  0x8(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x29(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x10(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2a(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x18(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2b(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x20(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2c(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x28(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2d(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x30(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2e(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x38(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2f(%r10,%r13,1),%esi
movslq %esi,%rsi
lea    (%rdx,%r9,1),%rdx
movss  %xmm0,(%rcx,%rsi,4)
movsd  (%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp,%r13,4)
movsd  0x8(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x31(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x10(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x32(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x18(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x33(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x20(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x34(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x28(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x35(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x30(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x36(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x38(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x37(%r10,%r13,1),%esi
movslq %esi,%rsi
lea    (%rdx,%r9,1),%rdx
movss  %xmm0,(%rcx,%rsi,4)
movsd  (%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x0(%rbp,%r13,4)
movsd  0x8(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x39(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x10(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x3a(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x18(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x3b(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x20(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x3c(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x28(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x3d(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x30(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x3e(%r10,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x38(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r10,%r13,1),%edx
add    $0x3f,%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
add    $0x8,%rdi
add    %r15,%r8
add    $0x40,%r13
cmp    %r11,%rdi
jl     1480 <cvt_d2s_mat2pmat+0x380>
mov    %rbx,%r8
mov    -0x28(%rsp),%r13
cmp    %r13d,%edi
jge    1430 <cvt_d2s_mat2pmat+0x330>
mov    %r12,%r13
imul   -0x58(%rsp),%r13
mov    %edi,%esi
shl    $0x3,%edi
mov    -0x40(%rsp),%rdx
sub    %rsi,%rdx
imul   %rax,%rsi
add    -0x50(%rsp),%rsi
lea    (%r8,%rsi,8),%rsi
nopl   0x0(%rax,%rax,1)
movsd  -0x20(%rsi),%xmm0
cvtsd2ss %xmm0,%xmm0
movslq %edi,%rdi
lea    (%rdi,%r13,1),%rbx
movss  %xmm0,(%rcx,%rbx,4)
movsd  -0x18(%rsi),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movsd  -0x10(%rsi),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movsd  -0x8(%rsi),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x3(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movsd  (%rsi),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x4(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movsd  0x8(%rsi),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x5(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movsd  0x10(%rsi),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x6(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movsd  0x18(%rsi),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r10,%rdi,1),%ebx
add    $0x7,%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
add    $0x8,%edi
add    %r9,%rsi
add    $0xffffffffffffffff,%rdx
jne    1a80 <cvt_d2s_mat2pmat+0x980>
jmp    1430 <cvt_d2s_mat2pmat+0x330>
mov    -0x5c(%rsp),%r9d
mov    -0x20(%rsp),%rdi
mov    0x40(%rsp),%ebx
sub    %r12d,%edi
jle    1cbc <cvt_d2s_mat2pmat+0xbbc>
test   %r13d,%r13d
jle    1cbc <cvt_d2s_mat2pmat+0xbbc>
cmp    $0x8,%edi
mov    $0x8,%eax
cmovl  %edi,%eax
imul   %r12d,%ebx
cmp    $0x2,%eax
mov    $0x1,%ebp
cmovge %eax,%ebp
jmp    1ba0 <cvt_d2s_mat2pmat+0xaa0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x8,%ebx
add    %r9d,%r12d
add    $0xffffffff,%r13d
je     1cbc <cvt_d2s_mat2pmat+0xbbc>
test   %edi,%edi
jle    1b90 <cvt_d2s_mat2pmat+0xa90>
movslq %r12d,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movslq %ebx,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x2,%eax
jl     1b90 <cvt_d2s_mat2pmat+0xa90>
lea    0x1(%r12),%esi
movslq %esi,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1(%rbx),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x2,%ebp
je     1b90 <cvt_d2s_mat2pmat+0xa90>
lea    0x2(%r12),%esi
movslq %esi,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2(%rbx),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x3,%ebp
je     1b90 <cvt_d2s_mat2pmat+0xa90>
lea    0x3(%r12),%esi
movslq %esi,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x3(%rbx),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x4,%ebp
je     1b90 <cvt_d2s_mat2pmat+0xa90>
lea    0x4(%r12),%esi
movslq %esi,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x4(%rbx),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x5,%ebp
je     1b90 <cvt_d2s_mat2pmat+0xa90>
lea    0x5(%r12),%esi
movslq %esi,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x5(%rbx),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x6,%ebp
je     1b90 <cvt_d2s_mat2pmat+0xa90>
lea    0x6(%r12),%esi
movslq %esi,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x6(%rbx),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x7,%ebp
je     1b90 <cvt_d2s_mat2pmat+0xa90>
lea    0x7(%r12),%esi
movslq %esi,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x7(%rbx),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
jmp    1b90 <cvt_d2s_mat2pmat+0xa90>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @cvt_d2s_mat2pmat(i32 %0, i32 %1, i32 %2, i32 %3, double* %4, i32 %5, float* %6, i32 %7) {
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca double*
%14 = alloca i32
%15 = alloca float*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
store i32 %0, i32* %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store i32 %3, i32* %12
store double* %4, double** %13
store i32 %5, i32* %14
store float* %6, float** %15
store i32 %7, i32* %16
store i32 8, i32* %17
%24 = load i32, i32* %11
%25 = srem i32 %24, 8
%26 = sub nsw i32 8, %25
%27 = srem i32 %26, 8
store i32 %27, i32* %21
%28 = load i32, i32* %21
%29 = load i32, i32* %9
%30 = icmp sgt i32 %28, %29
br i1 %30, label %31, label %33
31: ; preds = %8
%32 = load i32, i32* %9
store i32 %32, i32* %21
br label %33
33: ; preds = %31, %8
%34 = load i32, i32* %9
%35 = load i32, i32* %21
%36 = sub nsw i32 %34, %35
store i32 %36, i32* %22
store i32 0, i32* %19
%37 = load i32, i32* %21
%38 = icmp sgt i32 %37, 0
br i1 %38, label %39, label %93
39: ; preds = %33
store i32 0, i32* %20
br label %40
40: ; preds = %77, %39
%41 = load i32, i32* %20
%42 = load i32, i32* %10
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %80
44: ; preds = %40
store i32 0, i32* %18
br label %45
45: ; preds = %73, %44
%46 = load i32, i32* %18
%47 = load i32, i32* %21
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %76
49: ; preds = %45
%50 = load double*, double** %13
%51 = load i32, i32* %18
%52 = load i32, i32* %19
%53 = add nsw i32 %51, %52
%54 = load i32, i32* %20
%55 = load i32, i32* %14
%56 = mul nsw i32 %54, %55
%57 = add nsw i32 %53, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %50, i64 %58
%60 = load double, double* %59
%61 = fptrunc double %60 to float
%62 = load float*, float** %15
%63 = load i32, i32* %18
%64 = load i32, i32* %20
%65 = mul nsw i32 %64, 8
%66 = add nsw i32 %63, %65
%67 = load i32, i32* %19
%68 = load i32, i32* %16
%69 = mul nsw i32 %67, %68
%70 = add nsw i32 %66, %69
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %62, i64 %71
store float %61, float* %72
br label %73
73: ; preds = %49
%74 = load i32, i32* %18
%75 = add nsw i32 %74, 1
store i32 %75, i32* %18
br label %45
76: ; preds = %45
br label %77
77: ; preds = %76
%78 = load i32, i32* %20
%79 = add nsw i32 %78, 1
store i32 %79, i32* %20
br label %40
80: ; preds = %40
%81 = load i32, i32* %21
%82 = load double*, double** %13
%83 = sext i32 %81 to i64
%84 = getelementptr inbounds double, double* %82, i64 %83
store double* %84, double** %13
%85 = load i32, i32* %21
%86 = load i32, i32* %16
%87 = sub nsw i32 %86, 1
%88 = mul nsw i32 8, %87
%89 = add nsw i32 %85, %88
%90 = load float*, float** %15
%91 = sext i32 %89 to i64
%92 = getelementptr inbounds float, float* %90, i64 %91
store float* %92, float** %15
br label %93
93: ; preds = %80, %33
store i32 0, i32* %19
br label %94
94: ; preds = %1775, %93
%95 = load i32, i32* %19
%96 = load i32, i32* %22
%97 = sub nsw i32 %96, 7
%98 = icmp slt i32 %95, %97
br i1 %98, label %99, label %1778
99: ; preds = %94
store i32 0, i32* %20
br label %100
100: ; preds = %1578, %99
%101 = load i32, i32* %20
%102 = load i32, i32* %10
%103 = sub nsw i32 %102, 7
%104 = icmp slt i32 %101, %103
br i1 %104, label %105, label %1581
105: ; preds = %100
%106 = load double*, double** %13
%107 = load i32, i32* %19
%108 = add nsw i32 %107, 0
%109 = load i32, i32* %20
%110 = add nsw i32 %109, 0
%111 = load i32, i32* %14
%112 = mul nsw i32 %110, %111
%113 = add nsw i32 %108, %112
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %106, i64 %114
%116 = load double, double* %115
%117 = fptrunc double %116 to float
%118 = load float*, float** %15
%119 = load i32, i32* %20
%120 = add nsw i32 %119, 0
%121 = mul nsw i32 %120, 8
%122 = add nsw i32 0, %121
%123 = load i32, i32* %19
%124 = load i32, i32* %16
%125 = mul nsw i32 %123, %124
%126 = add nsw i32 %122, %125
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %118, i64 %127
store float %117, float* %128
%129 = load double*, double** %13
%130 = load i32, i32* %19
%131 = add nsw i32 %130, 1
%132 = load i32, i32* %20
%133 = add nsw i32 %132, 0
%134 = load i32, i32* %14
%135 = mul nsw i32 %133, %134
%136 = add nsw i32 %131, %135
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds double, double* %129, i64 %137
%139 = load double, double* %138
%140 = fptrunc double %139 to float
%141 = load float*, float** %15
%142 = load i32, i32* %20
%143 = add nsw i32 %142, 0
%144 = mul nsw i32 %143, 8
%145 = add nsw i32 1, %144
%146 = load i32, i32* %19
%147 = load i32, i32* %16
%148 = mul nsw i32 %146, %147
%149 = add nsw i32 %145, %148
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float, float* %141, i64 %150
store float %140, float* %151
%152 = load double*, double** %13
%153 = load i32, i32* %19
%154 = add nsw i32 %153, 2
%155 = load i32, i32* %20
%156 = add nsw i32 %155, 0
%157 = load i32, i32* %14
%158 = mul nsw i32 %156, %157
%159 = add nsw i32 %154, %158
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds double, double* %152, i64 %160
%162 = load double, double* %161
%163 = fptrunc double %162 to float
%164 = load float*, float** %15
%165 = load i32, i32* %20
%166 = add nsw i32 %165, 0
%167 = mul nsw i32 %166, 8
%168 = add nsw i32 2, %167
%169 = load i32, i32* %19
%170 = load i32, i32* %16
%171 = mul nsw i32 %169, %170
%172 = add nsw i32 %168, %171
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %164, i64 %173
store float %163, float* %174
%175 = load double*, double** %13
%176 = load i32, i32* %19
%177 = add nsw i32 %176, 3
%178 = load i32, i32* %20
%179 = add nsw i32 %178, 0
%180 = load i32, i32* %14
%181 = mul nsw i32 %179, %180
%182 = add nsw i32 %177, %181
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %175, i64 %183
%185 = load double, double* %184
%186 = fptrunc double %185 to float
%187 = load float*, float** %15
%188 = load i32, i32* %20
%189 = add nsw i32 %188, 0
%190 = mul nsw i32 %189, 8
%191 = add nsw i32 3, %190
%192 = load i32, i32* %19
%193 = load i32, i32* %16
%194 = mul nsw i32 %192, %193
%195 = add nsw i32 %191, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %187, i64 %196
store float %186, float* %197
%198 = load double*, double** %13
%199 = load i32, i32* %19
%200 = add nsw i32 %199, 4
%201 = load i32, i32* %20
%202 = add nsw i32 %201, 0
%203 = load i32, i32* %14
%204 = mul nsw i32 %202, %203
%205 = add nsw i32 %200, %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds double, double* %198, i64 %206
%208 = load double, double* %207
%209 = fptrunc double %208 to float
%210 = load float*, float** %15
%211 = load i32, i32* %20
%212 = add nsw i32 %211, 0
%213 = mul nsw i32 %212, 8
%214 = add nsw i32 4, %213
%215 = load i32, i32* %19
%216 = load i32, i32* %16
%217 = mul nsw i32 %215, %216
%218 = add nsw i32 %214, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float, float* %210, i64 %219
store float %209, float* %220
%221 = load double*, double** %13
%222 = load i32, i32* %19
%223 = add nsw i32 %222, 5
%224 = load i32, i32* %20
%225 = add nsw i32 %224, 0
%226 = load i32, i32* %14
%227 = mul nsw i32 %225, %226
%228 = add nsw i32 %223, %227
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds double, double* %221, i64 %229
%231 = load double, double* %230
%232 = fptrunc double %231 to float
%233 = load float*, float** %15
%234 = load i32, i32* %20
%235 = add nsw i32 %234, 0
%236 = mul nsw i32 %235, 8
%237 = add nsw i32 5, %236
%238 = load i32, i32* %19
%239 = load i32, i32* %16
%240 = mul nsw i32 %238, %239
%241 = add nsw i32 %237, %240
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds float, float* %233, i64 %242
store float %232, float* %243
%244 = load double*, double** %13
%245 = load i32, i32* %19
%246 = add nsw i32 %245, 6
%247 = load i32, i32* %20
%248 = add nsw i32 %247, 0
%249 = load i32, i32* %14
%250 = mul nsw i32 %248, %249
%251 = add nsw i32 %246, %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %244, i64 %252
%254 = load double, double* %253
%255 = fptrunc double %254 to float
%256 = load float*, float** %15
%257 = load i32, i32* %20
%258 = add nsw i32 %257, 0
%259 = mul nsw i32 %258, 8
%260 = add nsw i32 6, %259
%261 = load i32, i32* %19
%262 = load i32, i32* %16
%263 = mul nsw i32 %261, %262
%264 = add nsw i32 %260, %263
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds float, float* %256, i64 %265
store float %255, float* %266
%267 = load double*, double** %13
%268 = load i32, i32* %19
%269 = add nsw i32 %268, 7
%270 = load i32, i32* %20
%271 = add nsw i32 %270, 0
%272 = load i32, i32* %14
%273 = mul nsw i32 %271, %272
%274 = add nsw i32 %269, %273
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %267, i64 %275
%277 = load double, double* %276
%278 = fptrunc double %277 to float
%279 = load float*, float** %15
%280 = load i32, i32* %20
%281 = add nsw i32 %280, 0
%282 = mul nsw i32 %281, 8
%283 = add nsw i32 7, %282
%284 = load i32, i32* %19
%285 = load i32, i32* %16
%286 = mul nsw i32 %284, %285
%287 = add nsw i32 %283, %286
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds float, float* %279, i64 %288
store float %278, float* %289
%290 = load double*, double** %13
%291 = load i32, i32* %19
%292 = add nsw i32 %291, 0
%293 = load i32, i32* %20
%294 = add nsw i32 %293, 1
%295 = load i32, i32* %14
%296 = mul nsw i32 %294, %295
%297 = add nsw i32 %292, %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %290, i64 %298
%300 = load double, double* %299
%301 = fptrunc double %300 to float
%302 = load float*, float** %15
%303 = load i32, i32* %20
%304 = add nsw i32 %303, 1
%305 = mul nsw i32 %304, 8
%306 = add nsw i32 0, %305
%307 = load i32, i32* %19
%308 = load i32, i32* %16
%309 = mul nsw i32 %307, %308
%310 = add nsw i32 %306, %309
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds float, float* %302, i64 %311
store float %301, float* %312
%313 = load double*, double** %13
%314 = load i32, i32* %19
%315 = add nsw i32 %314, 1
%316 = load i32, i32* %20
%317 = add nsw i32 %316, 1
%318 = load i32, i32* %14
%319 = mul nsw i32 %317, %318
%320 = add nsw i32 %315, %319
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds double, double* %313, i64 %321
%323 = load double, double* %322
%324 = fptrunc double %323 to float
%325 = load float*, float** %15
%326 = load i32, i32* %20
%327 = add nsw i32 %326, 1
%328 = mul nsw i32 %327, 8
%329 = add nsw i32 1, %328
%330 = load i32, i32* %19
%331 = load i32, i32* %16
%332 = mul nsw i32 %330, %331
%333 = add nsw i32 %329, %332
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds float, float* %325, i64 %334
store float %324, float* %335
%336 = load double*, double** %13
%337 = load i32, i32* %19
%338 = add nsw i32 %337, 2
%339 = load i32, i32* %20
%340 = add nsw i32 %339, 1
%341 = load i32, i32* %14
%342 = mul nsw i32 %340, %341
%343 = add nsw i32 %338, %342
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds double, double* %336, i64 %344
%346 = load double, double* %345
%347 = fptrunc double %346 to float
%348 = load float*, float** %15
%349 = load i32, i32* %20
%350 = add nsw i32 %349, 1
%351 = mul nsw i32 %350, 8
%352 = add nsw i32 2, %351
%353 = load i32, i32* %19
%354 = load i32, i32* %16
%355 = mul nsw i32 %353, %354
%356 = add nsw i32 %352, %355
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds float, float* %348, i64 %357
store float %347, float* %358
%359 = load double*, double** %13
%360 = load i32, i32* %19
%361 = add nsw i32 %360, 3
%362 = load i32, i32* %20
%363 = add nsw i32 %362, 1
%364 = load i32, i32* %14
%365 = mul nsw i32 %363, %364
%366 = add nsw i32 %361, %365
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds double, double* %359, i64 %367
%369 = load double, double* %368
%370 = fptrunc double %369 to float
%371 = load float*, float** %15
%372 = load i32, i32* %20
%373 = add nsw i32 %372, 1
%374 = mul nsw i32 %373, 8
%375 = add nsw i32 3, %374
%376 = load i32, i32* %19
%377 = load i32, i32* %16
%378 = mul nsw i32 %376, %377
%379 = add nsw i32 %375, %378
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds float, float* %371, i64 %380
store float %370, float* %381
%382 = load double*, double** %13
%383 = load i32, i32* %19
%384 = add nsw i32 %383, 4
%385 = load i32, i32* %20
%386 = add nsw i32 %385, 1
%387 = load i32, i32* %14
%388 = mul nsw i32 %386, %387
%389 = add nsw i32 %384, %388
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds double, double* %382, i64 %390
%392 = load double, double* %391
%393 = fptrunc double %392 to float
%394 = load float*, float** %15
%395 = load i32, i32* %20
%396 = add nsw i32 %395, 1
%397 = mul nsw i32 %396, 8
%398 = add nsw i32 4, %397
%399 = load i32, i32* %19
%400 = load i32, i32* %16
%401 = mul nsw i32 %399, %400
%402 = add nsw i32 %398, %401
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds float, float* %394, i64 %403
store float %393, float* %404
%405 = load double*, double** %13
%406 = load i32, i32* %19
%407 = add nsw i32 %406, 5
%408 = load i32, i32* %20
%409 = add nsw i32 %408, 1
%410 = load i32, i32* %14
%411 = mul nsw i32 %409, %410
%412 = add nsw i32 %407, %411
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds double, double* %405, i64 %413
%415 = load double, double* %414
%416 = fptrunc double %415 to float
%417 = load float*, float** %15
%418 = load i32, i32* %20
%419 = add nsw i32 %418, 1
%420 = mul nsw i32 %419, 8
%421 = add nsw i32 5, %420
%422 = load i32, i32* %19
%423 = load i32, i32* %16
%424 = mul nsw i32 %422, %423
%425 = add nsw i32 %421, %424
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %417, i64 %426
store float %416, float* %427
%428 = load double*, double** %13
%429 = load i32, i32* %19
%430 = add nsw i32 %429, 6
%431 = load i32, i32* %20
%432 = add nsw i32 %431, 1
%433 = load i32, i32* %14
%434 = mul nsw i32 %432, %433
%435 = add nsw i32 %430, %434
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds double, double* %428, i64 %436
%438 = load double, double* %437
%439 = fptrunc double %438 to float
%440 = load float*, float** %15
%441 = load i32, i32* %20
%442 = add nsw i32 %441, 1
%443 = mul nsw i32 %442, 8
%444 = add nsw i32 6, %443
%445 = load i32, i32* %19
%446 = load i32, i32* %16
%447 = mul nsw i32 %445, %446
%448 = add nsw i32 %444, %447
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds float, float* %440, i64 %449
store float %439, float* %450
%451 = load double*, double** %13
%452 = load i32, i32* %19
%453 = add nsw i32 %452, 7
%454 = load i32, i32* %20
%455 = add nsw i32 %454, 1
%456 = load i32, i32* %14
%457 = mul nsw i32 %455, %456
%458 = add nsw i32 %453, %457
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds double, double* %451, i64 %459
%461 = load double, double* %460
%462 = fptrunc double %461 to float
%463 = load float*, float** %15
%464 = load i32, i32* %20
%465 = add nsw i32 %464, 1
%466 = mul nsw i32 %465, 8
%467 = add nsw i32 7, %466
%468 = load i32, i32* %19
%469 = load i32, i32* %16
%470 = mul nsw i32 %468, %469
%471 = add nsw i32 %467, %470
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds float, float* %463, i64 %472
store float %462, float* %473
%474 = load double*, double** %13
%475 = load i32, i32* %19
%476 = add nsw i32 %475, 0
%477 = load i32, i32* %20
%478 = add nsw i32 %477, 2
%479 = load i32, i32* %14
%480 = mul nsw i32 %478, %479
%481 = add nsw i32 %476, %480
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds double, double* %474, i64 %482
%484 = load double, double* %483
%485 = fptrunc double %484 to float
%486 = load float*, float** %15
%487 = load i32, i32* %20
%488 = add nsw i32 %487, 2
%489 = mul nsw i32 %488, 8
%490 = add nsw i32 0, %489
%491 = load i32, i32* %19
%492 = load i32, i32* %16
%493 = mul nsw i32 %491, %492
%494 = add nsw i32 %490, %493
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds float, float* %486, i64 %495
store float %485, float* %496
%497 = load double*, double** %13
%498 = load i32, i32* %19
%499 = add nsw i32 %498, 1
%500 = load i32, i32* %20
%501 = add nsw i32 %500, 2
%502 = load i32, i32* %14
%503 = mul nsw i32 %501, %502
%504 = add nsw i32 %499, %503
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds double, double* %497, i64 %505
%507 = load double, double* %506
%508 = fptrunc double %507 to float
%509 = load float*, float** %15
%510 = load i32, i32* %20
%511 = add nsw i32 %510, 2
%512 = mul nsw i32 %511, 8
%513 = add nsw i32 1, %512
%514 = load i32, i32* %19
%515 = load i32, i32* %16
%516 = mul nsw i32 %514, %515
%517 = add nsw i32 %513, %516
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds float, float* %509, i64 %518
store float %508, float* %519
%520 = load double*, double** %13
%521 = load i32, i32* %19
%522 = add nsw i32 %521, 2
%523 = load i32, i32* %20
%524 = add nsw i32 %523, 2
%525 = load i32, i32* %14
%526 = mul nsw i32 %524, %525
%527 = add nsw i32 %522, %526
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds double, double* %520, i64 %528
%530 = load double, double* %529
%531 = fptrunc double %530 to float
%532 = load float*, float** %15
%533 = load i32, i32* %20
%534 = add nsw i32 %533, 2
%535 = mul nsw i32 %534, 8
%536 = add nsw i32 2, %535
%537 = load i32, i32* %19
%538 = load i32, i32* %16
%539 = mul nsw i32 %537, %538
%540 = add nsw i32 %536, %539
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds float, float* %532, i64 %541
store float %531, float* %542
%543 = load double*, double** %13
%544 = load i32, i32* %19
%545 = add nsw i32 %544, 3
%546 = load i32, i32* %20
%547 = add nsw i32 %546, 2
%548 = load i32, i32* %14
%549 = mul nsw i32 %547, %548
%550 = add nsw i32 %545, %549
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds double, double* %543, i64 %551
%553 = load double, double* %552
%554 = fptrunc double %553 to float
%555 = load float*, float** %15
%556 = load i32, i32* %20
%557 = add nsw i32 %556, 2
%558 = mul nsw i32 %557, 8
%559 = add nsw i32 3, %558
%560 = load i32, i32* %19
%561 = load i32, i32* %16
%562 = mul nsw i32 %560, %561
%563 = add nsw i32 %559, %562
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds float, float* %555, i64 %564
store float %554, float* %565
%566 = load double*, double** %13
%567 = load i32, i32* %19
%568 = add nsw i32 %567, 4
%569 = load i32, i32* %20
%570 = add nsw i32 %569, 2
%571 = load i32, i32* %14
%572 = mul nsw i32 %570, %571
%573 = add nsw i32 %568, %572
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds double, double* %566, i64 %574
%576 = load double, double* %575
%577 = fptrunc double %576 to float
%578 = load float*, float** %15
%579 = load i32, i32* %20
%580 = add nsw i32 %579, 2
%581 = mul nsw i32 %580, 8
%582 = add nsw i32 4, %581
%583 = load i32, i32* %19
%584 = load i32, i32* %16
%585 = mul nsw i32 %583, %584
%586 = add nsw i32 %582, %585
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds float, float* %578, i64 %587
store float %577, float* %588
%589 = load double*, double** %13
%590 = load i32, i32* %19
%591 = add nsw i32 %590, 5
%592 = load i32, i32* %20
%593 = add nsw i32 %592, 2
%594 = load i32, i32* %14
%595 = mul nsw i32 %593, %594
%596 = add nsw i32 %591, %595
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds double, double* %589, i64 %597
%599 = load double, double* %598
%600 = fptrunc double %599 to float
%601 = load float*, float** %15
%602 = load i32, i32* %20
%603 = add nsw i32 %602, 2
%604 = mul nsw i32 %603, 8
%605 = add nsw i32 5, %604
%606 = load i32, i32* %19
%607 = load i32, i32* %16
%608 = mul nsw i32 %606, %607
%609 = add nsw i32 %605, %608
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds float, float* %601, i64 %610
store float %600, float* %611
%612 = load double*, double** %13
%613 = load i32, i32* %19
%614 = add nsw i32 %613, 6
%615 = load i32, i32* %20
%616 = add nsw i32 %615, 2
%617 = load i32, i32* %14
%618 = mul nsw i32 %616, %617
%619 = add nsw i32 %614, %618
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds double, double* %612, i64 %620
%622 = load double, double* %621
%623 = fptrunc double %622 to float
%624 = load float*, float** %15
%625 = load i32, i32* %20
%626 = add nsw i32 %625, 2
%627 = mul nsw i32 %626, 8
%628 = add nsw i32 6, %627
%629 = load i32, i32* %19
%630 = load i32, i32* %16
%631 = mul nsw i32 %629, %630
%632 = add nsw i32 %628, %631
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds float, float* %624, i64 %633
store float %623, float* %634
%635 = load double*, double** %13
%636 = load i32, i32* %19
%637 = add nsw i32 %636, 7
%638 = load i32, i32* %20
%639 = add nsw i32 %638, 2
%640 = load i32, i32* %14
%641 = mul nsw i32 %639, %640
%642 = add nsw i32 %637, %641
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds double, double* %635, i64 %643
%645 = load double, double* %644
%646 = fptrunc double %645 to float
%647 = load float*, float** %15
%648 = load i32, i32* %20
%649 = add nsw i32 %648, 2
%650 = mul nsw i32 %649, 8
%651 = add nsw i32 7, %650
%652 = load i32, i32* %19
%653 = load i32, i32* %16
%654 = mul nsw i32 %652, %653
%655 = add nsw i32 %651, %654
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds float, float* %647, i64 %656
store float %646, float* %657
%658 = load double*, double** %13
%659 = load i32, i32* %19
%660 = add nsw i32 %659, 0
%661 = load i32, i32* %20
%662 = add nsw i32 %661, 3
%663 = load i32, i32* %14
%664 = mul nsw i32 %662, %663
%665 = add nsw i32 %660, %664
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds double, double* %658, i64 %666
%668 = load double, double* %667
%669 = fptrunc double %668 to float
%670 = load float*, float** %15
%671 = load i32, i32* %20
%672 = add nsw i32 %671, 3
%673 = mul nsw i32 %672, 8
%674 = add nsw i32 0, %673
%675 = load i32, i32* %19
%676 = load i32, i32* %16
%677 = mul nsw i32 %675, %676
%678 = add nsw i32 %674, %677
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds float, float* %670, i64 %679
store float %669, float* %680
%681 = load double*, double** %13
%682 = load i32, i32* %19
%683 = add nsw i32 %682, 1
%684 = load i32, i32* %20
%685 = add nsw i32 %684, 3
%686 = load i32, i32* %14
%687 = mul nsw i32 %685, %686
%688 = add nsw i32 %683, %687
%689 = sext i32 %688 to i64
%690 = getelementptr inbounds double, double* %681, i64 %689
%691 = load double, double* %690
%692 = fptrunc double %691 to float
%693 = load float*, float** %15
%694 = load i32, i32* %20
%695 = add nsw i32 %694, 3
%696 = mul nsw i32 %695, 8
%697 = add nsw i32 1, %696
%698 = load i32, i32* %19
%699 = load i32, i32* %16
%700 = mul nsw i32 %698, %699
%701 = add nsw i32 %697, %700
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds float, float* %693, i64 %702
store float %692, float* %703
%704 = load double*, double** %13
%705 = load i32, i32* %19
%706 = add nsw i32 %705, 2
%707 = load i32, i32* %20
%708 = add nsw i32 %707, 3
%709 = load i32, i32* %14
%710 = mul nsw i32 %708, %709
%711 = add nsw i32 %706, %710
%712 = sext i32 %711 to i64
%713 = getelementptr inbounds double, double* %704, i64 %712
%714 = load double, double* %713
%715 = fptrunc double %714 to float
%716 = load float*, float** %15
%717 = load i32, i32* %20
%718 = add nsw i32 %717, 3
%719 = mul nsw i32 %718, 8
%720 = add nsw i32 2, %719
%721 = load i32, i32* %19
%722 = load i32, i32* %16
%723 = mul nsw i32 %721, %722
%724 = add nsw i32 %720, %723
%725 = sext i32 %724 to i64
%726 = getelementptr inbounds float, float* %716, i64 %725
store float %715, float* %726
%727 = load double*, double** %13
%728 = load i32, i32* %19
%729 = add nsw i32 %728, 3
%730 = load i32, i32* %20
%731 = add nsw i32 %730, 3
%732 = load i32, i32* %14
%733 = mul nsw i32 %731, %732
%734 = add nsw i32 %729, %733
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds double, double* %727, i64 %735
%737 = load double, double* %736
%738 = fptrunc double %737 to float
%739 = load float*, float** %15
%740 = load i32, i32* %20
%741 = add nsw i32 %740, 3
%742 = mul nsw i32 %741, 8
%743 = add nsw i32 3, %742
%744 = load i32, i32* %19
%745 = load i32, i32* %16
%746 = mul nsw i32 %744, %745
%747 = add nsw i32 %743, %746
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds float, float* %739, i64 %748
store float %738, float* %749
%750 = load double*, double** %13
%751 = load i32, i32* %19
%752 = add nsw i32 %751, 4
%753 = load i32, i32* %20
%754 = add nsw i32 %753, 3
%755 = load i32, i32* %14
%756 = mul nsw i32 %754, %755
%757 = add nsw i32 %752, %756
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds double, double* %750, i64 %758
%760 = load double, double* %759
%761 = fptrunc double %760 to float
%762 = load float*, float** %15
%763 = load i32, i32* %20
%764 = add nsw i32 %763, 3
%765 = mul nsw i32 %764, 8
%766 = add nsw i32 4, %765
%767 = load i32, i32* %19
%768 = load i32, i32* %16
%769 = mul nsw i32 %767, %768
%770 = add nsw i32 %766, %769
%771 = sext i32 %770 to i64
%772 = getelementptr inbounds float, float* %762, i64 %771
store float %761, float* %772
%773 = load double*, double** %13
%774 = load i32, i32* %19
%775 = add nsw i32 %774, 5
%776 = load i32, i32* %20
%777 = add nsw i32 %776, 3
%778 = load i32, i32* %14
%779 = mul nsw i32 %777, %778
%780 = add nsw i32 %775, %779
%781 = sext i32 %780 to i64
%782 = getelementptr inbounds double, double* %773, i64 %781
%783 = load double, double* %782
%784 = fptrunc double %783 to float
%785 = load float*, float** %15
%786 = load i32, i32* %20
%787 = add nsw i32 %786, 3
%788 = mul nsw i32 %787, 8
%789 = add nsw i32 5, %788
%790 = load i32, i32* %19
%791 = load i32, i32* %16
%792 = mul nsw i32 %790, %791
%793 = add nsw i32 %789, %792
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds float, float* %785, i64 %794
store float %784, float* %795
%796 = load double*, double** %13
%797 = load i32, i32* %19
%798 = add nsw i32 %797, 6
%799 = load i32, i32* %20
%800 = add nsw i32 %799, 3
%801 = load i32, i32* %14
%802 = mul nsw i32 %800, %801
%803 = add nsw i32 %798, %802
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds double, double* %796, i64 %804
%806 = load double, double* %805
%807 = fptrunc double %806 to float
%808 = load float*, float** %15
%809 = load i32, i32* %20
%810 = add nsw i32 %809, 3
%811 = mul nsw i32 %810, 8
%812 = add nsw i32 6, %811
%813 = load i32, i32* %19
%814 = load i32, i32* %16
%815 = mul nsw i32 %813, %814
%816 = add nsw i32 %812, %815
%817 = sext i32 %816 to i64
%818 = getelementptr inbounds float, float* %808, i64 %817
store float %807, float* %818
%819 = load double*, double** %13
%820 = load i32, i32* %19
%821 = add nsw i32 %820, 7
%822 = load i32, i32* %20
%823 = add nsw i32 %822, 3
%824 = load i32, i32* %14
%825 = mul nsw i32 %823, %824
%826 = add nsw i32 %821, %825
%827 = sext i32 %826 to i64
%828 = getelementptr inbounds double, double* %819, i64 %827
%829 = load double, double* %828
%830 = fptrunc double %829 to float
%831 = load float*, float** %15
%832 = load i32, i32* %20
%833 = add nsw i32 %832, 3
%834 = mul nsw i32 %833, 8
%835 = add nsw i32 7, %834
%836 = load i32, i32* %19
%837 = load i32, i32* %16
%838 = mul nsw i32 %836, %837
%839 = add nsw i32 %835, %838
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds float, float* %831, i64 %840
store float %830, float* %841
%842 = load double*, double** %13
%843 = load i32, i32* %19
%844 = add nsw i32 %843, 0
%845 = load i32, i32* %20
%846 = add nsw i32 %845, 4
%847 = load i32, i32* %14
%848 = mul nsw i32 %846, %847
%849 = add nsw i32 %844, %848
%850 = sext i32 %849 to i64
%851 = getelementptr inbounds double, double* %842, i64 %850
%852 = load double, double* %851
%853 = fptrunc double %852 to float
%854 = load float*, float** %15
%855 = load i32, i32* %20
%856 = add nsw i32 %855, 4
%857 = mul nsw i32 %856, 8
%858 = add nsw i32 0, %857
%859 = load i32, i32* %19
%860 = load i32, i32* %16
%861 = mul nsw i32 %859, %860
%862 = add nsw i32 %858, %861
%863 = sext i32 %862 to i64
%864 = getelementptr inbounds float, float* %854, i64 %863
store float %853, float* %864
%865 = load double*, double** %13
%866 = load i32, i32* %19
%867 = add nsw i32 %866, 1
%868 = load i32, i32* %20
%869 = add nsw i32 %868, 4
%870 = load i32, i32* %14
%871 = mul nsw i32 %869, %870
%872 = add nsw i32 %867, %871
%873 = sext i32 %872 to i64
%874 = getelementptr inbounds double, double* %865, i64 %873
%875 = load double, double* %874
%876 = fptrunc double %875 to float
%877 = load float*, float** %15
%878 = load i32, i32* %20
%879 = add nsw i32 %878, 4
%880 = mul nsw i32 %879, 8
%881 = add nsw i32 1, %880
%882 = load i32, i32* %19
%883 = load i32, i32* %16
%884 = mul nsw i32 %882, %883
%885 = add nsw i32 %881, %884
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds float, float* %877, i64 %886
store float %876, float* %887
%888 = load double*, double** %13
%889 = load i32, i32* %19
%890 = add nsw i32 %889, 2
%891 = load i32, i32* %20
%892 = add nsw i32 %891, 4
%893 = load i32, i32* %14
%894 = mul nsw i32 %892, %893
%895 = add nsw i32 %890, %894
%896 = sext i32 %895 to i64
%897 = getelementptr inbounds double, double* %888, i64 %896
%898 = load double, double* %897
%899 = fptrunc double %898 to float
%900 = load float*, float** %15
%901 = load i32, i32* %20
%902 = add nsw i32 %901, 4
%903 = mul nsw i32 %902, 8
%904 = add nsw i32 2, %903
%905 = load i32, i32* %19
%906 = load i32, i32* %16
%907 = mul nsw i32 %905, %906
%908 = add nsw i32 %904, %907
%909 = sext i32 %908 to i64
%910 = getelementptr inbounds float, float* %900, i64 %909
store float %899, float* %910
%911 = load double*, double** %13
%912 = load i32, i32* %19
%913 = add nsw i32 %912, 3
%914 = load i32, i32* %20
%915 = add nsw i32 %914, 4
%916 = load i32, i32* %14
%917 = mul nsw i32 %915, %916
%918 = add nsw i32 %913, %917
%919 = sext i32 %918 to i64
%920 = getelementptr inbounds double, double* %911, i64 %919
%921 = load double, double* %920
%922 = fptrunc double %921 to float
%923 = load float*, float** %15
%924 = load i32, i32* %20
%925 = add nsw i32 %924, 4
%926 = mul nsw i32 %925, 8
%927 = add nsw i32 3, %926
%928 = load i32, i32* %19
%929 = load i32, i32* %16
%930 = mul nsw i32 %928, %929
%931 = add nsw i32 %927, %930
%932 = sext i32 %931 to i64
%933 = getelementptr inbounds float, float* %923, i64 %932
store float %922, float* %933
%934 = load double*, double** %13
%935 = load i32, i32* %19
%936 = add nsw i32 %935, 4
%937 = load i32, i32* %20
%938 = add nsw i32 %937, 4
%939 = load i32, i32* %14
%940 = mul nsw i32 %938, %939
%941 = add nsw i32 %936, %940
%942 = sext i32 %941 to i64
%943 = getelementptr inbounds double, double* %934, i64 %942
%944 = load double, double* %943
%945 = fptrunc double %944 to float
%946 = load float*, float** %15
%947 = load i32, i32* %20
%948 = add nsw i32 %947, 4
%949 = mul nsw i32 %948, 8
%950 = add nsw i32 4, %949
%951 = load i32, i32* %19
%952 = load i32, i32* %16
%953 = mul nsw i32 %951, %952
%954 = add nsw i32 %950, %953
%955 = sext i32 %954 to i64
%956 = getelementptr inbounds float, float* %946, i64 %955
store float %945, float* %956
%957 = load double*, double** %13
%958 = load i32, i32* %19
%959 = add nsw i32 %958, 5
%960 = load i32, i32* %20
%961 = add nsw i32 %960, 4
%962 = load i32, i32* %14
%963 = mul nsw i32 %961, %962
%964 = add nsw i32 %959, %963
%965 = sext i32 %964 to i64
%966 = getelementptr inbounds double, double* %957, i64 %965
%967 = load double, double* %966
%968 = fptrunc double %967 to float
%969 = load float*, float** %15
%970 = load i32, i32* %20
%971 = add nsw i32 %970, 4
%972 = mul nsw i32 %971, 8
%973 = add nsw i32 5, %972
%974 = load i32, i32* %19
%975 = load i32, i32* %16
%976 = mul nsw i32 %974, %975
%977 = add nsw i32 %973, %976
%978 = sext i32 %977 to i64
%979 = getelementptr inbounds float, float* %969, i64 %978
store float %968, float* %979
%980 = load double*, double** %13
%981 = load i32, i32* %19
%982 = add nsw i32 %981, 6
%983 = load i32, i32* %20
%984 = add nsw i32 %983, 4
%985 = load i32, i32* %14
%986 = mul nsw i32 %984, %985
%987 = add nsw i32 %982, %986
%988 = sext i32 %987 to i64
%989 = getelementptr inbounds double, double* %980, i64 %988
%990 = load double, double* %989
%991 = fptrunc double %990 to float
%992 = load float*, float** %15
%993 = load i32, i32* %20
%994 = add nsw i32 %993, 4
%995 = mul nsw i32 %994, 8
%996 = add nsw i32 6, %995
%997 = load i32, i32* %19
%998 = load i32, i32* %16
%999 = mul nsw i32 %997, %998
%1000 = add nsw i32 %996, %999
%1001 = sext i32 %1000 to i64
%1002 = getelementptr inbounds float, float* %992, i64 %1001
store float %991, float* %1002
%1003 = load double*, double** %13
%1004 = load i32, i32* %19
%1005 = add nsw i32 %1004, 7
%1006 = load i32, i32* %20
%1007 = add nsw i32 %1006, 4
%1008 = load i32, i32* %14
%1009 = mul nsw i32 %1007, %1008
%1010 = add nsw i32 %1005, %1009
%1011 = sext i32 %1010 to i64
%1012 = getelementptr inbounds double, double* %1003, i64 %1011
%1013 = load double, double* %1012
%1014 = fptrunc double %1013 to float
%1015 = load float*, float** %15
%1016 = load i32, i32* %20
%1017 = add nsw i32 %1016, 4
%1018 = mul nsw i32 %1017, 8
%1019 = add nsw i32 7, %1018
%1020 = load i32, i32* %19
%1021 = load i32, i32* %16
%1022 = mul nsw i32 %1020, %1021
%1023 = add nsw i32 %1019, %1022
%1024 = sext i32 %1023 to i64
%1025 = getelementptr inbounds float, float* %1015, i64 %1024
store float %1014, float* %1025
%1026 = load double*, double** %13
%1027 = load i32, i32* %19
%1028 = add nsw i32 %1027, 0
%1029 = load i32, i32* %20
%1030 = add nsw i32 %1029, 5
%1031 = load i32, i32* %14
%1032 = mul nsw i32 %1030, %1031
%1033 = add nsw i32 %1028, %1032
%1034 = sext i32 %1033 to i64
%1035 = getelementptr inbounds double, double* %1026, i64 %1034
%1036 = load double, double* %1035
%1037 = fptrunc double %1036 to float
%1038 = load float*, float** %15
%1039 = load i32, i32* %20
%1040 = add nsw i32 %1039, 5
%1041 = mul nsw i32 %1040, 8
%1042 = add nsw i32 0, %1041
%1043 = load i32, i32* %19
%1044 = load i32, i32* %16
%1045 = mul nsw i32 %1043, %1044
%1046 = add nsw i32 %1042, %1045
%1047 = sext i32 %1046 to i64
%1048 = getelementptr inbounds float, float* %1038, i64 %1047
store float %1037, float* %1048
%1049 = load double*, double** %13
%1050 = load i32, i32* %19
%1051 = add nsw i32 %1050, 1
%1052 = load i32, i32* %20
%1053 = add nsw i32 %1052, 5
%1054 = load i32, i32* %14
%1055 = mul nsw i32 %1053, %1054
%1056 = add nsw i32 %1051, %1055
%1057 = sext i32 %1056 to i64
%1058 = getelementptr inbounds double, double* %1049, i64 %1057
%1059 = load double, double* %1058
%1060 = fptrunc double %1059 to float
%1061 = load float*, float** %15
%1062 = load i32, i32* %20
%1063 = add nsw i32 %1062, 5
%1064 = mul nsw i32 %1063, 8
%1065 = add nsw i32 1, %1064
%1066 = load i32, i32* %19
%1067 = load i32, i32* %16
%1068 = mul nsw i32 %1066, %1067
%1069 = add nsw i32 %1065, %1068
%1070 = sext i32 %1069 to i64
%1071 = getelementptr inbounds float, float* %1061, i64 %1070
store float %1060, float* %1071
%1072 = load double*, double** %13
%1073 = load i32, i32* %19
%1074 = add nsw i32 %1073, 2
%1075 = load i32, i32* %20
%1076 = add nsw i32 %1075, 5
%1077 = load i32, i32* %14
%1078 = mul nsw i32 %1076, %1077
%1079 = add nsw i32 %1074, %1078
%1080 = sext i32 %1079 to i64
%1081 = getelementptr inbounds double, double* %1072, i64 %1080
%1082 = load double, double* %1081
%1083 = fptrunc double %1082 to float
%1084 = load float*, float** %15
%1085 = load i32, i32* %20
%1086 = add nsw i32 %1085, 5
%1087 = mul nsw i32 %1086, 8
%1088 = add nsw i32 2, %1087
%1089 = load i32, i32* %19
%1090 = load i32, i32* %16
%1091 = mul nsw i32 %1089, %1090
%1092 = add nsw i32 %1088, %1091
%1093 = sext i32 %1092 to i64
%1094 = getelementptr inbounds float, float* %1084, i64 %1093
store float %1083, float* %1094
%1095 = load double*, double** %13
%1096 = load i32, i32* %19
%1097 = add nsw i32 %1096, 3
%1098 = load i32, i32* %20
%1099 = add nsw i32 %1098, 5
%1100 = load i32, i32* %14
%1101 = mul nsw i32 %1099, %1100
%1102 = add nsw i32 %1097, %1101
%1103 = sext i32 %1102 to i64
%1104 = getelementptr inbounds double, double* %1095, i64 %1103
%1105 = load double, double* %1104
%1106 = fptrunc double %1105 to float
%1107 = load float*, float** %15
%1108 = load i32, i32* %20
%1109 = add nsw i32 %1108, 5
%1110 = mul nsw i32 %1109, 8
%1111 = add nsw i32 3, %1110
%1112 = load i32, i32* %19
%1113 = load i32, i32* %16
%1114 = mul nsw i32 %1112, %1113
%1115 = add nsw i32 %1111, %1114
%1116 = sext i32 %1115 to i64
%1117 = getelementptr inbounds float, float* %1107, i64 %1116
store float %1106, float* %1117
%1118 = load double*, double** %13
%1119 = load i32, i32* %19
%1120 = add nsw i32 %1119, 4
%1121 = load i32, i32* %20
%1122 = add nsw i32 %1121, 5
%1123 = load i32, i32* %14
%1124 = mul nsw i32 %1122, %1123
%1125 = add nsw i32 %1120, %1124
%1126 = sext i32 %1125 to i64
%1127 = getelementptr inbounds double, double* %1118, i64 %1126
%1128 = load double, double* %1127
%1129 = fptrunc double %1128 to float
%1130 = load float*, float** %15
%1131 = load i32, i32* %20
%1132 = add nsw i32 %1131, 5
%1133 = mul nsw i32 %1132, 8
%1134 = add nsw i32 4, %1133
%1135 = load i32, i32* %19
%1136 = load i32, i32* %16
%1137 = mul nsw i32 %1135, %1136
%1138 = add nsw i32 %1134, %1137
%1139 = sext i32 %1138 to i64
%1140 = getelementptr inbounds float, float* %1130, i64 %1139
store float %1129, float* %1140
%1141 = load double*, double** %13
%1142 = load i32, i32* %19
%1143 = add nsw i32 %1142, 5
%1144 = load i32, i32* %20
%1145 = add nsw i32 %1144, 5
%1146 = load i32, i32* %14
%1147 = mul nsw i32 %1145, %1146
%1148 = add nsw i32 %1143, %1147
%1149 = sext i32 %1148 to i64
%1150 = getelementptr inbounds double, double* %1141, i64 %1149
%1151 = load double, double* %1150
%1152 = fptrunc double %1151 to float
%1153 = load float*, float** %15
%1154 = load i32, i32* %20
%1155 = add nsw i32 %1154, 5
%1156 = mul nsw i32 %1155, 8
%1157 = add nsw i32 5, %1156
%1158 = load i32, i32* %19
%1159 = load i32, i32* %16
%1160 = mul nsw i32 %1158, %1159
%1161 = add nsw i32 %1157, %1160
%1162 = sext i32 %1161 to i64
%1163 = getelementptr inbounds float, float* %1153, i64 %1162
store float %1152, float* %1163
%1164 = load double*, double** %13
%1165 = load i32, i32* %19
%1166 = add nsw i32 %1165, 6
%1167 = load i32, i32* %20
%1168 = add nsw i32 %1167, 5
%1169 = load i32, i32* %14
%1170 = mul nsw i32 %1168, %1169
%1171 = add nsw i32 %1166, %1170
%1172 = sext i32 %1171 to i64
%1173 = getelementptr inbounds double, double* %1164, i64 %1172
%1174 = load double, double* %1173
%1175 = fptrunc double %1174 to float
%1176 = load float*, float** %15
%1177 = load i32, i32* %20
%1178 = add nsw i32 %1177, 5
%1179 = mul nsw i32 %1178, 8
%1180 = add nsw i32 6, %1179
%1181 = load i32, i32* %19
%1182 = load i32, i32* %16
%1183 = mul nsw i32 %1181, %1182
%1184 = add nsw i32 %1180, %1183
%1185 = sext i32 %1184 to i64
%1186 = getelementptr inbounds float, float* %1176, i64 %1185
store float %1175, float* %1186
%1187 = load double*, double** %13
%1188 = load i32, i32* %19
%1189 = add nsw i32 %1188, 7
%1190 = load i32, i32* %20
%1191 = add nsw i32 %1190, 5
%1192 = load i32, i32* %14
%1193 = mul nsw i32 %1191, %1192
%1194 = add nsw i32 %1189, %1193
%1195 = sext i32 %1194 to i64
%1196 = getelementptr inbounds double, double* %1187, i64 %1195
%1197 = load double, double* %1196
%1198 = fptrunc double %1197 to float
%1199 = load float*, float** %15
%1200 = load i32, i32* %20
%1201 = add nsw i32 %1200, 5
%1202 = mul nsw i32 %1201, 8
%1203 = add nsw i32 7, %1202
%1204 = load i32, i32* %19
%1205 = load i32, i32* %16
%1206 = mul nsw i32 %1204, %1205
%1207 = add nsw i32 %1203, %1206
%1208 = sext i32 %1207 to i64
%1209 = getelementptr inbounds float, float* %1199, i64 %1208
store float %1198, float* %1209
%1210 = load double*, double** %13
%1211 = load i32, i32* %19
%1212 = add nsw i32 %1211, 0
%1213 = load i32, i32* %20
%1214 = add nsw i32 %1213, 6
%1215 = load i32, i32* %14
%1216 = mul nsw i32 %1214, %1215
%1217 = add nsw i32 %1212, %1216
%1218 = sext i32 %1217 to i64
%1219 = getelementptr inbounds double, double* %1210, i64 %1218
%1220 = load double, double* %1219
%1221 = fptrunc double %1220 to float
%1222 = load float*, float** %15
%1223 = load i32, i32* %20
%1224 = add nsw i32 %1223, 6
%1225 = mul nsw i32 %1224, 8
%1226 = add nsw i32 0, %1225
%1227 = load i32, i32* %19
%1228 = load i32, i32* %16
%1229 = mul nsw i32 %1227, %1228
%1230 = add nsw i32 %1226, %1229
%1231 = sext i32 %1230 to i64
%1232 = getelementptr inbounds float, float* %1222, i64 %1231
store float %1221, float* %1232
%1233 = load double*, double** %13
%1234 = load i32, i32* %19
%1235 = add nsw i32 %1234, 1
%1236 = load i32, i32* %20
%1237 = add nsw i32 %1236, 6
%1238 = load i32, i32* %14
%1239 = mul nsw i32 %1237, %1238
%1240 = add nsw i32 %1235, %1239
%1241 = sext i32 %1240 to i64
%1242 = getelementptr inbounds double, double* %1233, i64 %1241
%1243 = load double, double* %1242
%1244 = fptrunc double %1243 to float
%1245 = load float*, float** %15
%1246 = load i32, i32* %20
%1247 = add nsw i32 %1246, 6
%1248 = mul nsw i32 %1247, 8
%1249 = add nsw i32 1, %1248
%1250 = load i32, i32* %19
%1251 = load i32, i32* %16
%1252 = mul nsw i32 %1250, %1251
%1253 = add nsw i32 %1249, %1252
%1254 = sext i32 %1253 to i64
%1255 = getelementptr inbounds float, float* %1245, i64 %1254
store float %1244, float* %1255
%1256 = load double*, double** %13
%1257 = load i32, i32* %19
%1258 = add nsw i32 %1257, 2
%1259 = load i32, i32* %20
%1260 = add nsw i32 %1259, 6
%1261 = load i32, i32* %14
%1262 = mul nsw i32 %1260, %1261
%1263 = add nsw i32 %1258, %1262
%1264 = sext i32 %1263 to i64
%1265 = getelementptr inbounds double, double* %1256, i64 %1264
%1266 = load double, double* %1265
%1267 = fptrunc double %1266 to float
%1268 = load float*, float** %15
%1269 = load i32, i32* %20
%1270 = add nsw i32 %1269, 6
%1271 = mul nsw i32 %1270, 8
%1272 = add nsw i32 2, %1271
%1273 = load i32, i32* %19
%1274 = load i32, i32* %16
%1275 = mul nsw i32 %1273, %1274
%1276 = add nsw i32 %1272, %1275
%1277 = sext i32 %1276 to i64
%1278 = getelementptr inbounds float, float* %1268, i64 %1277
store float %1267, float* %1278
%1279 = load double*, double** %13
%1280 = load i32, i32* %19
%1281 = add nsw i32 %1280, 3
%1282 = load i32, i32* %20
%1283 = add nsw i32 %1282, 6
%1284 = load i32, i32* %14
%1285 = mul nsw i32 %1283, %1284
%1286 = add nsw i32 %1281, %1285
%1287 = sext i32 %1286 to i64
%1288 = getelementptr inbounds double, double* %1279, i64 %1287
%1289 = load double, double* %1288
%1290 = fptrunc double %1289 to float
%1291 = load float*, float** %15
%1292 = load i32, i32* %20
%1293 = add nsw i32 %1292, 6
%1294 = mul nsw i32 %1293, 8
%1295 = add nsw i32 3, %1294
%1296 = load i32, i32* %19
%1297 = load i32, i32* %16
%1298 = mul nsw i32 %1296, %1297
%1299 = add nsw i32 %1295, %1298
%1300 = sext i32 %1299 to i64
%1301 = getelementptr inbounds float, float* %1291, i64 %1300
store float %1290, float* %1301
%1302 = load double*, double** %13
%1303 = load i32, i32* %19
%1304 = add nsw i32 %1303, 4
%1305 = load i32, i32* %20
%1306 = add nsw i32 %1305, 6
%1307 = load i32, i32* %14
%1308 = mul nsw i32 %1306, %1307
%1309 = add nsw i32 %1304, %1308
%1310 = sext i32 %1309 to i64
%1311 = getelementptr inbounds double, double* %1302, i64 %1310
%1312 = load double, double* %1311
%1313 = fptrunc double %1312 to float
%1314 = load float*, float** %15
%1315 = load i32, i32* %20
%1316 = add nsw i32 %1315, 6
%1317 = mul nsw i32 %1316, 8
%1318 = add nsw i32 4, %1317
%1319 = load i32, i32* %19
%1320 = load i32, i32* %16
%1321 = mul nsw i32 %1319, %1320
%1322 = add nsw i32 %1318, %1321
%1323 = sext i32 %1322 to i64
%1324 = getelementptr inbounds float, float* %1314, i64 %1323
store float %1313, float* %1324
%1325 = load double*, double** %13
%1326 = load i32, i32* %19
%1327 = add nsw i32 %1326, 5
%1328 = load i32, i32* %20
%1329 = add nsw i32 %1328, 6
%1330 = load i32, i32* %14
%1331 = mul nsw i32 %1329, %1330
%1332 = add nsw i32 %1327, %1331
%1333 = sext i32 %1332 to i64
%1334 = getelementptr inbounds double, double* %1325, i64 %1333
%1335 = load double, double* %1334
%1336 = fptrunc double %1335 to float
%1337 = load float*, float** %15
%1338 = load i32, i32* %20
%1339 = add nsw i32 %1338, 6
%1340 = mul nsw i32 %1339, 8
%1341 = add nsw i32 5, %1340
%1342 = load i32, i32* %19
%1343 = load i32, i32* %16
%1344 = mul nsw i32 %1342, %1343
%1345 = add nsw i32 %1341, %1344
%1346 = sext i32 %1345 to i64
%1347 = getelementptr inbounds float, float* %1337, i64 %1346
store float %1336, float* %1347
%1348 = load double*, double** %13
%1349 = load i32, i32* %19
%1350 = add nsw i32 %1349, 6
%1351 = load i32, i32* %20
%1352 = add nsw i32 %1351, 6
%1353 = load i32, i32* %14
%1354 = mul nsw i32 %1352, %1353
%1355 = add nsw i32 %1350, %1354
%1356 = sext i32 %1355 to i64
%1357 = getelementptr inbounds double, double* %1348, i64 %1356
%1358 = load double, double* %1357
%1359 = fptrunc double %1358 to float
%1360 = load float*, float** %15
%1361 = load i32, i32* %20
%1362 = add nsw i32 %1361, 6
%1363 = mul nsw i32 %1362, 8
%1364 = add nsw i32 6, %1363
%1365 = load i32, i32* %19
%1366 = load i32, i32* %16
%1367 = mul nsw i32 %1365, %1366
%1368 = add nsw i32 %1364, %1367
%1369 = sext i32 %1368 to i64
%1370 = getelementptr inbounds float, float* %1360, i64 %1369
store float %1359, float* %1370
%1371 = load double*, double** %13
%1372 = load i32, i32* %19
%1373 = add nsw i32 %1372, 7
%1374 = load i32, i32* %20
%1375 = add nsw i32 %1374, 6
%1376 = load i32, i32* %14
%1377 = mul nsw i32 %1375, %1376
%1378 = add nsw i32 %1373, %1377
%1379 = sext i32 %1378 to i64
%1380 = getelementptr inbounds double, double* %1371, i64 %1379
%1381 = load double, double* %1380
%1382 = fptrunc double %1381 to float
%1383 = load float*, float** %15
%1384 = load i32, i32* %20
%1385 = add nsw i32 %1384, 6
%1386 = mul nsw i32 %1385, 8
%1387 = add nsw i32 7, %1386
%1388 = load i32, i32* %19
%1389 = load i32, i32* %16
%1390 = mul nsw i32 %1388, %1389
%1391 = add nsw i32 %1387, %1390
%1392 = sext i32 %1391 to i64
%1393 = getelementptr inbounds float, float* %1383, i64 %1392
store float %1382, float* %1393
%1394 = load double*, double** %13
%1395 = load i32, i32* %19
%1396 = add nsw i32 %1395, 0
%1397 = load i32, i32* %20
%1398 = add nsw i32 %1397, 7
%1399 = load i32, i32* %14
%1400 = mul nsw i32 %1398, %1399
%1401 = add nsw i32 %1396, %1400
%1402 = sext i32 %1401 to i64
%1403 = getelementptr inbounds double, double* %1394, i64 %1402
%1404 = load double, double* %1403
%1405 = fptrunc double %1404 to float
%1406 = load float*, float** %15
%1407 = load i32, i32* %20
%1408 = add nsw i32 %1407, 7
%1409 = mul nsw i32 %1408, 8
%1410 = add nsw i32 0, %1409
%1411 = load i32, i32* %19
%1412 = load i32, i32* %16
%1413 = mul nsw i32 %1411, %1412
%1414 = add nsw i32 %1410, %1413
%1415 = sext i32 %1414 to i64
%1416 = getelementptr inbounds float, float* %1406, i64 %1415
store float %1405, float* %1416
%1417 = load double*, double** %13
%1418 = load i32, i32* %19
%1419 = add nsw i32 %1418, 1
%1420 = load i32, i32* %20
%1421 = add nsw i32 %1420, 7
%1422 = load i32, i32* %14
%1423 = mul nsw i32 %1421, %1422
%1424 = add nsw i32 %1419, %1423
%1425 = sext i32 %1424 to i64
%1426 = getelementptr inbounds double, double* %1417, i64 %1425
%1427 = load double, double* %1426
%1428 = fptrunc double %1427 to float
%1429 = load float*, float** %15
%1430 = load i32, i32* %20
%1431 = add nsw i32 %1430, 7
%1432 = mul nsw i32 %1431, 8
%1433 = add nsw i32 1, %1432
%1434 = load i32, i32* %19
%1435 = load i32, i32* %16
%1436 = mul nsw i32 %1434, %1435
%1437 = add nsw i32 %1433, %1436
%1438 = sext i32 %1437 to i64
%1439 = getelementptr inbounds float, float* %1429, i64 %1438
store float %1428, float* %1439
%1440 = load double*, double** %13
%1441 = load i32, i32* %19
%1442 = add nsw i32 %1441, 2
%1443 = load i32, i32* %20
%1444 = add nsw i32 %1443, 7
%1445 = load i32, i32* %14
%1446 = mul nsw i32 %1444, %1445
%1447 = add nsw i32 %1442, %1446
%1448 = sext i32 %1447 to i64
%1449 = getelementptr inbounds double, double* %1440, i64 %1448
%1450 = load double, double* %1449
%1451 = fptrunc double %1450 to float
%1452 = load float*, float** %15
%1453 = load i32, i32* %20
%1454 = add nsw i32 %1453, 7
%1455 = mul nsw i32 %1454, 8
%1456 = add nsw i32 2, %1455
%1457 = load i32, i32* %19
%1458 = load i32, i32* %16
%1459 = mul nsw i32 %1457, %1458
%1460 = add nsw i32 %1456, %1459
%1461 = sext i32 %1460 to i64
%1462 = getelementptr inbounds float, float* %1452, i64 %1461
store float %1451, float* %1462
%1463 = load double*, double** %13
%1464 = load i32, i32* %19
%1465 = add nsw i32 %1464, 3
%1466 = load i32, i32* %20
%1467 = add nsw i32 %1466, 7
%1468 = load i32, i32* %14
%1469 = mul nsw i32 %1467, %1468
%1470 = add nsw i32 %1465, %1469
%1471 = sext i32 %1470 to i64
%1472 = getelementptr inbounds double, double* %1463, i64 %1471
%1473 = load double, double* %1472
%1474 = fptrunc double %1473 to float
%1475 = load float*, float** %15
%1476 = load i32, i32* %20
%1477 = add nsw i32 %1476, 7
%1478 = mul nsw i32 %1477, 8
%1479 = add nsw i32 3, %1478
%1480 = load i32, i32* %19
%1481 = load i32, i32* %16
%1482 = mul nsw i32 %1480, %1481
%1483 = add nsw i32 %1479, %1482
%1484 = sext i32 %1483 to i64
%1485 = getelementptr inbounds float, float* %1475, i64 %1484
store float %1474, float* %1485
%1486 = load double*, double** %13
%1487 = load i32, i32* %19
%1488 = add nsw i32 %1487, 4
%1489 = load i32, i32* %20
%1490 = add nsw i32 %1489, 7
%1491 = load i32, i32* %14
%1492 = mul nsw i32 %1490, %1491
%1493 = add nsw i32 %1488, %1492
%1494 = sext i32 %1493 to i64
%1495 = getelementptr inbounds double, double* %1486, i64 %1494
%1496 = load double, double* %1495
%1497 = fptrunc double %1496 to float
%1498 = load float*, float** %15
%1499 = load i32, i32* %20
%1500 = add nsw i32 %1499, 7
%1501 = mul nsw i32 %1500, 8
%1502 = add nsw i32 4, %1501
%1503 = load i32, i32* %19
%1504 = load i32, i32* %16
%1505 = mul nsw i32 %1503, %1504
%1506 = add nsw i32 %1502, %1505
%1507 = sext i32 %1506 to i64
%1508 = getelementptr inbounds float, float* %1498, i64 %1507
store float %1497, float* %1508
%1509 = load double*, double** %13
%1510 = load i32, i32* %19
%1511 = add nsw i32 %1510, 5
%1512 = load i32, i32* %20
%1513 = add nsw i32 %1512, 7
%1514 = load i32, i32* %14
%1515 = mul nsw i32 %1513, %1514
%1516 = add nsw i32 %1511, %1515
%1517 = sext i32 %1516 to i64
%1518 = getelementptr inbounds double, double* %1509, i64 %1517
%1519 = load double, double* %1518
%1520 = fptrunc double %1519 to float
%1521 = load float*, float** %15
%1522 = load i32, i32* %20
%1523 = add nsw i32 %1522, 7
%1524 = mul nsw i32 %1523, 8
%1525 = add nsw i32 5, %1524
%1526 = load i32, i32* %19
%1527 = load i32, i32* %16
%1528 = mul nsw i32 %1526, %1527
%1529 = add nsw i32 %1525, %1528
%1530 = sext i32 %1529 to i64
%1531 = getelementptr inbounds float, float* %1521, i64 %1530
store float %1520, float* %1531
%1532 = load double*, double** %13
%1533 = load i32, i32* %19
%1534 = add nsw i32 %1533, 6
%1535 = load i32, i32* %20
%1536 = add nsw i32 %1535, 7
%1537 = load i32, i32* %14
%1538 = mul nsw i32 %1536, %1537
%1539 = add nsw i32 %1534, %1538
%1540 = sext i32 %1539 to i64
%1541 = getelementptr inbounds double, double* %1532, i64 %1540
%1542 = load double, double* %1541
%1543 = fptrunc double %1542 to float
%1544 = load float*, float** %15
%1545 = load i32, i32* %20
%1546 = add nsw i32 %1545, 7
%1547 = mul nsw i32 %1546, 8
%1548 = add nsw i32 6, %1547
%1549 = load i32, i32* %19
%1550 = load i32, i32* %16
%1551 = mul nsw i32 %1549, %1550
%1552 = add nsw i32 %1548, %1551
%1553 = sext i32 %1552 to i64
%1554 = getelementptr inbounds float, float* %1544, i64 %1553
store float %1543, float* %1554
%1555 = load double*, double** %13
%1556 = load i32, i32* %19
%1557 = add nsw i32 %1556, 7
%1558 = load i32, i32* %20
%1559 = add nsw i32 %1558, 7
%1560 = load i32, i32* %14
%1561 = mul nsw i32 %1559, %1560
%1562 = add nsw i32 %1557, %1561
%1563 = sext i32 %1562 to i64
%1564 = getelementptr inbounds double, double* %1555, i64 %1563
%1565 = load double, double* %1564
%1566 = fptrunc double %1565 to float
%1567 = load float*, float** %15
%1568 = load i32, i32* %20
%1569 = add nsw i32 %1568, 7
%1570 = mul nsw i32 %1569, 8
%1571 = add nsw i32 7, %1570
%1572 = load i32, i32* %19
%1573 = load i32, i32* %16
%1574 = mul nsw i32 %1572, %1573
%1575 = add nsw i32 %1571, %1574
%1576 = sext i32 %1575 to i64
%1577 = getelementptr inbounds float, float* %1567, i64 %1576
store float %1566, float* %1577
br label %1578
1578: ; preds = %105
%1579 = load i32, i32* %20
%1580 = add nsw i32 %1579, 8
store i32 %1580, i32* %20
br label %100
1581: ; preds = %100
br label %1582
1582: ; preds = %1771, %1581
%1583 = load i32, i32* %20
%1584 = load i32, i32* %10
%1585 = icmp slt i32 %1583, %1584
br i1 %1585, label %1586, label %1774
1586: ; preds = %1582
%1587 = load double*, double** %13
%1588 = load i32, i32* %19
%1589 = add nsw i32 %1588, 0
%1590 = load i32, i32* %20
%1591 = add nsw i32 %1590, 0
%1592 = load i32, i32* %14
%1593 = mul nsw i32 %1591, %1592
%1594 = add nsw i32 %1589, %1593
%1595 = sext i32 %1594 to i64
%1596 = getelementptr inbounds double, double* %1587, i64 %1595
%1597 = load double, double* %1596
%1598 = fptrunc double %1597 to float
%1599 = load float*, float** %15
%1600 = load i32, i32* %20
%1601 = add nsw i32 %1600, 0
%1602 = mul nsw i32 %1601, 8
%1603 = add nsw i32 0, %1602
%1604 = load i32, i32* %19
%1605 = load i32, i32* %16
%1606 = mul nsw i32 %1604, %1605
%1607 = add nsw i32 %1603, %1606
%1608 = sext i32 %1607 to i64
%1609 = getelementptr inbounds float, float* %1599, i64 %1608
store float %1598, float* %1609
%1610 = load double*, double** %13
%1611 = load i32, i32* %19
%1612 = add nsw i32 %1611, 1
%1613 = load i32, i32* %20
%1614 = add nsw i32 %1613, 0
%1615 = load i32, i32* %14
%1616 = mul nsw i32 %1614, %1615
%1617 = add nsw i32 %1612, %1616
%1618 = sext i32 %1617 to i64
%1619 = getelementptr inbounds double, double* %1610, i64 %1618
%1620 = load double, double* %1619
%1621 = fptrunc double %1620 to float
%1622 = load float*, float** %15
%1623 = load i32, i32* %20
%1624 = add nsw i32 %1623, 0
%1625 = mul nsw i32 %1624, 8
%1626 = add nsw i32 1, %1625
%1627 = load i32, i32* %19
%1628 = load i32, i32* %16
%1629 = mul nsw i32 %1627, %1628
%1630 = add nsw i32 %1626, %1629
%1631 = sext i32 %1630 to i64
%1632 = getelementptr inbounds float, float* %1622, i64 %1631
store float %1621, float* %1632
%1633 = load double*, double** %13
%1634 = load i32, i32* %19
%1635 = add nsw i32 %1634, 2
%1636 = load i32, i32* %20
%1637 = add nsw i32 %1636, 0
%1638 = load i32, i32* %14
%1639 = mul nsw i32 %1637, %1638
%1640 = add nsw i32 %1635, %1639
%1641 = sext i32 %1640 to i64
%1642 = getelementptr inbounds double, double* %1633, i64 %1641
%1643 = load double, double* %1642
%1644 = fptrunc double %1643 to float
%1645 = load float*, float** %15
%1646 = load i32, i32* %20
%1647 = add nsw i32 %1646, 0
%1648 = mul nsw i32 %1647, 8
%1649 = add nsw i32 2, %1648
%1650 = load i32, i32* %19
%1651 = load i32, i32* %16
%1652 = mul nsw i32 %1650, %1651
%1653 = add nsw i32 %1649, %1652
%1654 = sext i32 %1653 to i64
%1655 = getelementptr inbounds float, float* %1645, i64 %1654
store float %1644, float* %1655
%1656 = load double*, double** %13
%1657 = load i32, i32* %19
%1658 = add nsw i32 %1657, 3
%1659 = load i32, i32* %20
%1660 = add nsw i32 %1659, 0
%1661 = load i32, i32* %14
%1662 = mul nsw i32 %1660, %1661
%1663 = add nsw i32 %1658, %1662
%1664 = sext i32 %1663 to i64
%1665 = getelementptr inbounds double, double* %1656, i64 %1664
%1666 = load double, double* %1665
%1667 = fptrunc double %1666 to float
%1668 = load float*, float** %15
%1669 = load i32, i32* %20
%1670 = add nsw i32 %1669, 0
%1671 = mul nsw i32 %1670, 8
%1672 = add nsw i32 3, %1671
%1673 = load i32, i32* %19
%1674 = load i32, i32* %16
%1675 = mul nsw i32 %1673, %1674
%1676 = add nsw i32 %1672, %1675
%1677 = sext i32 %1676 to i64
%1678 = getelementptr inbounds float, float* %1668, i64 %1677
store float %1667, float* %1678
%1679 = load double*, double** %13
%1680 = load i32, i32* %19
%1681 = add nsw i32 %1680, 4
%1682 = load i32, i32* %20
%1683 = add nsw i32 %1682, 0
%1684 = load i32, i32* %14
%1685 = mul nsw i32 %1683, %1684
%1686 = add nsw i32 %1681, %1685
%1687 = sext i32 %1686 to i64
%1688 = getelementptr inbounds double, double* %1679, i64 %1687
%1689 = load double, double* %1688
%1690 = fptrunc double %1689 to float
%1691 = load float*, float** %15
%1692 = load i32, i32* %20
%1693 = add nsw i32 %1692, 0
%1694 = mul nsw i32 %1693, 8
%1695 = add nsw i32 4, %1694
%1696 = load i32, i32* %19
%1697 = load i32, i32* %16
%1698 = mul nsw i32 %1696, %1697
%1699 = add nsw i32 %1695, %1698
%1700 = sext i32 %1699 to i64
%1701 = getelementptr inbounds float, float* %1691, i64 %1700
store float %1690, float* %1701
%1702 = load double*, double** %13
%1703 = load i32, i32* %19
%1704 = add nsw i32 %1703, 5
%1705 = load i32, i32* %20
%1706 = add nsw i32 %1705, 0
%1707 = load i32, i32* %14
%1708 = mul nsw i32 %1706, %1707
%1709 = add nsw i32 %1704, %1708
%1710 = sext i32 %1709 to i64
%1711 = getelementptr inbounds double, double* %1702, i64 %1710
%1712 = load double, double* %1711
%1713 = fptrunc double %1712 to float
%1714 = load float*, float** %15
%1715 = load i32, i32* %20
%1716 = add nsw i32 %1715, 0
%1717 = mul nsw i32 %1716, 8
%1718 = add nsw i32 5, %1717
%1719 = load i32, i32* %19
%1720 = load i32, i32* %16
%1721 = mul nsw i32 %1719, %1720
%1722 = add nsw i32 %1718, %1721
%1723 = sext i32 %1722 to i64
%1724 = getelementptr inbounds float, float* %1714, i64 %1723
store float %1713, float* %1724
%1725 = load double*, double** %13
%1726 = load i32, i32* %19
%1727 = add nsw i32 %1726, 6
%1728 = load i32, i32* %20
%1729 = add nsw i32 %1728, 0
%1730 = load i32, i32* %14
%1731 = mul nsw i32 %1729, %1730
%1732 = add nsw i32 %1727, %1731
%1733 = sext i32 %1732 to i64
%1734 = getelementptr inbounds double, double* %1725, i64 %1733
%1735 = load double, double* %1734
%1736 = fptrunc double %1735 to float
%1737 = load float*, float** %15
%1738 = load i32, i32* %20
%1739 = add nsw i32 %1738, 0
%1740 = mul nsw i32 %1739, 8
%1741 = add nsw i32 6, %1740
%1742 = load i32, i32* %19
%1743 = load i32, i32* %16
%1744 = mul nsw i32 %1742, %1743
%1745 = add nsw i32 %1741, %1744
%1746 = sext i32 %1745 to i64
%1747 = getelementptr inbounds float, float* %1737, i64 %1746
store float %1736, float* %1747
%1748 = load double*, double** %13
%1749 = load i32, i32* %19
%1750 = add nsw i32 %1749, 7
%1751 = load i32, i32* %20
%1752 = add nsw i32 %1751, 0
%1753 = load i32, i32* %14
%1754 = mul nsw i32 %1752, %1753
%1755 = add nsw i32 %1750, %1754
%1756 = sext i32 %1755 to i64
%1757 = getelementptr inbounds double, double* %1748, i64 %1756
%1758 = load double, double* %1757
%1759 = fptrunc double %1758 to float
%1760 = load float*, float** %15
%1761 = load i32, i32* %20
%1762 = add nsw i32 %1761, 0
%1763 = mul nsw i32 %1762, 8
%1764 = add nsw i32 7, %1763
%1765 = load i32, i32* %19
%1766 = load i32, i32* %16
%1767 = mul nsw i32 %1765, %1766
%1768 = add nsw i32 %1764, %1767
%1769 = sext i32 %1768 to i64
%1770 = getelementptr inbounds float, float* %1760, i64 %1769
store float %1759, float* %1770
br label %1771
1771: ; preds = %1586
%1772 = load i32, i32* %20
%1773 = add nsw i32 %1772, 1
store i32 %1773, i32* %20
br label %1582
1774: ; preds = %1582
br label %1775
1775: ; preds = %1774
%1776 = load i32, i32* %19
%1777 = add nsw i32 %1776, 8
store i32 %1777, i32* %19
br label %94
1778: ; preds = %94
%1779 = load i32, i32* %19
%1780 = load i32, i32* %22
%1781 = icmp slt i32 %1779, %1780
br i1 %1781, label %1782, label %1831
1782: ; preds = %1778
%1783 = load i32, i32* %22
%1784 = load i32, i32* %19
%1785 = sub nsw i32 %1783, %1784
store i32 %1785, i32* %23
%1786 = load i32, i32* %23
%1787 = icmp slt i32 8, %1786
br i1 %1787, label %1788, label %1789
1788: ; preds = %1782
store i32 8, i32* %23
br label %1789
1789: ; preds = %1788, %1782
store i32 0, i32* %20
br label %1790
1790: ; preds = %1827, %1789
%1791 = load i32, i32* %20
%1792 = load i32, i32* %10
%1793 = icmp slt i32 %1791, %1792
br i1 %1793, label %1794, label %1830
1794: ; preds = %1790
store i32 0, i32* %18
br label %1795
1795: ; preds = %1823, %1794
%1796 = load i32, i32* %18
%1797 = load i32, i32* %23
%1798 = icmp slt i32 %1796, %1797
br i1 %1798, label %1799, label %1826
1799: ; preds = %1795
%1800 = load double*, double** %13
%1801 = load i32, i32* %18
%1802 = load i32, i32* %19
%1803 = add nsw i32 %1801, %1802
%1804 = load i32, i32* %20
%1805 = load i32, i32* %14
%1806 = mul nsw i32 %1804, %1805
%1807 = add nsw i32 %1803, %1806
%1808 = sext i32 %1807 to i64
%1809 = getelementptr inbounds double, double* %1800, i64 %1808
%1810 = load double, double* %1809
%1811 = fptrunc double %1810 to float
%1812 = load float*, float** %15
%1813 = load i32, i32* %18
%1814 = load i32, i32* %20
%1815 = mul nsw i32 %1814, 8
%1816 = add nsw i32 %1813, %1815
%1817 = load i32, i32* %19
%1818 = load i32, i32* %16
%1819 = mul nsw i32 %1817, %1818
%1820 = add nsw i32 %1816, %1819
%1821 = sext i32 %1820 to i64
%1822 = getelementptr inbounds float, float* %1812, i64 %1821
store float %1811, float* %1822
br label %1823
1823: ; preds = %1799
%1824 = load i32, i32* %18
%1825 = add nsw i32 %1824, 1
store i32 %1825, i32* %18
br label %1795
1826: ; preds = %1795
br label %1827
1827: ; preds = %1826
%1828 = load i32, i32* %20
%1829 = add nsw i32 %1828, 1
store i32 %1829, i32* %20
br label %1790
1830: ; preds = %1790
br label %1831
1831: ; preds = %1830, %1778
ret void
}

LLVM IR (-O2):
define void @cvt_d2s_mat2pmat(i32 %0, i32 %1, i32 %2, i32 %3, double* %4, i32 %5, float* writeonly %6, i32 %7) {
%9 = sub i32 0, %2
%10 = and i32 %9, 7
%11 = icmp sgt i32 %10, %0
%12 = select i1 %11, i32 %0, i32 %10
%13 = sub nsw i32 %0, %12
%14 = icmp sgt i32 %12, 0
br i1 %14, label %15, label %150
15: ; preds = %8
%16 = icmp sgt i32 %1, 0
br i1 %16, label %17, label %142
17: ; preds = %15
%18 = sext i32 %5 to i64
%19 = zext i32 %1 to i64
%20 = zext i32 %12 to i64
%21 = add nsw i64 %20, -1
%22 = and i64 %20, 4294967292
%23 = add nsw i64 %22, -4
%24 = lshr exact i64 %23, 2
%25 = add nuw nsw i64 %24, 1
%26 = icmp ult i32 %12, 4
%27 = trunc i64 %21 to i32
%28 = icmp ugt i64 %21, 4294967295
%29 = and i64 %20, 4294967292
%30 = and i64 %25, 1
%31 = icmp eq i64 %23, 0
%32 = and i64 %25, 9223372036854775806
%33 = icmp eq i64 %30, 0
%34 = icmp eq i64 %29, %20
%35 = and i64 %20, 1
%36 = icmp eq i64 %35, 0
%37 = sub nsw i64 0, %20
br label %38
38: ; preds = %139, %17
%39 = phi i64 [ 0, %17 ], [ %140, %139 ]
%40 = mul nsw i64 %39, %18
%41 = shl i64 %39, 3
br i1 %26, label %105, label %42
42: ; preds = %38
%43 = trunc i64 %39 to i32
%44 = shl i32 %43, 3
%45 = xor i32 %44, -1
%46 = icmp ult i32 %45, %27
%47 = or i1 %46, %28
br i1 %47, label %105, label %48
48: ; preds = %42
br i1 %31, label %86, label %49
49: ; preds = %48, %49
%50 = phi i64 [ %83, %49 ], [ 0, %48 ]
%51 = phi i64 [ %84, %49 ], [ 0, %48 ]
%52 = add nsw i64 %50, %40
%53 = getelementptr inbounds double, double* %4, i64 %52
%54 = bitcast double* %53 to <2 x double>*
%55 = load <2 x double>, <2 x double>* %54
%56 = getelementptr inbounds double, double* %53, i64 2
%57 = bitcast double* %56 to <2 x double>*
%58 = load <2 x double>, <2 x double>* %57
%59 = fptrunc <2 x double> %55 to <2 x float>
%60 = fptrunc <2 x double> %58 to <2 x float>
%61 = add i64 %50, %41
%62 = and i64 %61, 4294967288
%63 = getelementptr inbounds float, float* %6, i64 %62
%64 = bitcast float* %63 to <2 x float>*
store <2 x float> %59, <2 x float>* %64
%65 = getelementptr inbounds float, float* %63, i64 2
%66 = bitcast float* %65 to <2 x float>*
store <2 x float> %60, <2 x float>* %66
%67 = or i64 %50, 4
%68 = add nsw i64 %67, %40
%69 = getelementptr inbounds double, double* %4, i64 %68
%70 = bitcast double* %69 to <2 x double>*
%71 = load <2 x double>, <2 x double>* %70
%72 = getelementptr inbounds double, double* %69, i64 2
%73 = bitcast double* %72 to <2 x double>*
%74 = load <2 x double>, <2 x double>* %73
%75 = fptrunc <2 x double> %71 to <2 x float>
%76 = fptrunc <2 x double> %74 to <2 x float>
%77 = add i64 %67, %41
%78 = and i64 %77, 4294967292
%79 = getelementptr inbounds float, float* %6, i64 %78
%80 = bitcast float* %79 to <2 x float>*
store <2 x float> %75, <2 x float>* %80
%81 = getelementptr inbounds float, float* %79, i64 2
%82 = bitcast float* %81 to <2 x float>*
store <2 x float> %76, <2 x float>* %82
%83 = add nuw i64 %50, 8
%84 = add i64 %51, 2
%85 = icmp eq i64 %84, %32
br i1 %85, label %86, label %49
86: ; preds = %49, %48
%87 = phi i64 [ 0, %48 ], [ %83, %49 ]
br i1 %33, label %104, label %88
88: ; preds = %86
%89 = add nsw i64 %87, %40
%90 = getelementptr inbounds double, double* %4, i64 %89
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = getelementptr inbounds double, double* %90, i64 2
%94 = bitcast double* %93 to <2 x double>*
%95 = load <2 x double>, <2 x double>* %94
%96 = fptrunc <2 x double> %92 to <2 x float>
%97 = fptrunc <2 x double> %95 to <2 x float>
%98 = add i64 %87, %41
%99 = and i64 %98, 4294967292
%100 = getelementptr inbounds float, float* %6, i64 %99
%101 = bitcast float* %100 to <2 x float>*
store <2 x float> %96, <2 x float>* %101
%102 = getelementptr inbounds float, float* %100, i64 2
%103 = bitcast float* %102 to <2 x float>*
store <2 x float> %97, <2 x float>* %103
br label %104
104: ; preds = %86, %88
br i1 %34, label %139, label %105
105: ; preds = %42, %38, %104
%106 = phi i64 [ 0, %42 ], [ 0, %38 ], [ %29, %104 ]
%107 = xor i64 %106, -1
br i1 %36, label %117, label %108
108: ; preds = %105
%109 = add nsw i64 %106, %40
%110 = getelementptr inbounds double, double* %4, i64 %109
%111 = load double, double* %110
%112 = fptrunc double %111 to float
%113 = add i64 %106, %41
%114 = and i64 %113, 4294967292
%115 = getelementptr inbounds float, float* %6, i64 %114
store float %112, float* %115
%116 = or i64 %106, 1
br label %117
117: ; preds = %108, %105
%118 = phi i64 [ %106, %105 ], [ %116, %108 ]
%119 = icmp eq i64 %107, %37
br i1 %119, label %139, label %120
120: ; preds = %117, %120
%121 = phi i64 [ %137, %120 ], [ %118, %117 ]
%122 = add nsw i64 %121, %40
%123 = getelementptr inbounds double, double* %4, i64 %122
%124 = load double, double* %123
%125 = fptrunc double %124 to float
%126 = add i64 %121, %41
%127 = and i64 %126, 4294967295
%128 = getelementptr inbounds float, float* %6, i64 %127
store float %125, float* %128
%129 = add nuw nsw i64 %121, 1
%130 = add nsw i64 %129, %40
%131 = getelementptr inbounds double, double* %4, i64 %130
%132 = load double, double* %131
%133 = fptrunc double %132 to float
%134 = add i64 %129, %41
%135 = and i64 %134, 4294967295
%136 = getelementptr inbounds float, float* %6, i64 %135
store float %133, float* %136
%137 = add nuw nsw i64 %121, 2
%138 = icmp eq i64 %137, %20
br i1 %138, label %139, label %120
139: ; preds = %117, %120, %104
%140 = add nuw nsw i64 %39, 1
%141 = icmp eq i64 %140, %19
br i1 %141, label %142, label %38
142: ; preds = %139, %15
%143 = sext i32 %12 to i64
%144 = getelementptr inbounds double, double* %4, i64 %143
%145 = shl i32 %7, 3
%146 = add i32 %12, -8
%147 = add i32 %146, %145
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds float, float* %6, i64 %148
br label %150
150: ; preds = %142, %8
%151 = phi float* [ %149, %142 ], [ %6, %8 ]
%152 = phi double* [ %144, %142 ], [ %4, %8 ]
%153 = icmp sgt i32 %13, 7
br i1 %153, label %154, label %748
154: ; preds = %150
%155 = add nsw i32 %13, -7
%156 = add nsw i32 %1, -7
%157 = icmp sgt i32 %1, 7
%158 = sext i32 %5 to i64
%159 = sext i32 %156 to i64
%160 = sext i32 %7 to i64
%161 = zext i32 %155 to i64
%162 = zext i32 %1 to i64
br label %163
163: ; preds = %154, %743
%164 = phi i64 [ 0, %154 ], [ %744, %743 ]
br i1 %157, label %165, label %184
165: ; preds = %163
%166 = mul nsw i64 %164, %160
%167 = or i64 %164, 1
%168 = trunc i64 %166 to i32
%169 = or i32 %168, 1
%170 = or i64 %164, 2
%171 = or i32 %168, 2
%172 = or i64 %164, 3
%173 = or i32 %168, 3
%174 = or i64 %164, 4
%175 = or i32 %168, 4
%176 = or i64 %164, 5
%177 = or i32 %168, 5
%178 = or i64 %164, 6
%179 = or i32 %168, 6
%180 = or i64 %164, 7
%181 = or i32 %168, 7
br label %205
182: ; preds = %205
%183 = trunc i64 %678 to i32
br label %184
184: ; preds = %182, %163
%185 = phi i32 [ 0, %163 ], [ %183, %182 ]
%186 = icmp slt i32 %185, %1
br i1 %186, label %187, label %743
187: ; preds = %184
%188 = mul nsw i64 %164, %160
%189 = or i64 %164, 1
%190 = trunc i64 %188 to i32
%191 = or i32 %190, 1
%192 = or i64 %164, 2
%193 = or i32 %190, 2
%194 = or i64 %164, 3
%195 = or i32 %190, 3
%196 = or i64 %164, 4
%197 = or i32 %190, 4
%198 = or i64 %164, 5
%199 = or i32 %190, 5
%200 = or i64 %164, 6
%201 = or i32 %190, 6
%202 = or i64 %164, 7
%203 = or i32 %190, 7
%204 = zext i32 %185 to i64
br label %680
205: ; preds = %165, %205
%206 = phi i64 [ 0, %165 ], [ %678, %205 ]
%207 = mul nsw i64 %206, %158
%208 = add nsw i64 %207, %164
%209 = getelementptr inbounds double, double* %152, i64 %208
%210 = load double, double* %209
%211 = fptrunc double %210 to float
%212 = shl nsw i64 %206, 3
%213 = add nsw i64 %212, %166
%214 = getelementptr inbounds float, float* %151, i64 %213
store float %211, float* %214
%215 = add nsw i64 %207, %167
%216 = getelementptr inbounds double, double* %152, i64 %215
%217 = load double, double* %216
%218 = fptrunc double %217 to float
%219 = trunc i64 %212 to i32
%220 = add i32 %169, %219
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds float, float* %151, i64 %221
store float %218, float* %222
%223 = add nsw i64 %207, %170
%224 = getelementptr inbounds double, double* %152, i64 %223
%225 = load double, double* %224
%226 = fptrunc double %225 to float
%227 = add i32 %171, %219
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float, float* %151, i64 %228
store float %226, float* %229
%230 = add nsw i64 %207, %172
%231 = getelementptr inbounds double, double* %152, i64 %230
%232 = load double, double* %231
%233 = fptrunc double %232 to float
%234 = add i32 %173, %219
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds float, float* %151, i64 %235
store float %233, float* %236
%237 = add nsw i64 %207, %174
%238 = getelementptr inbounds double, double* %152, i64 %237
%239 = load double, double* %238
%240 = fptrunc double %239 to float
%241 = add i32 %175, %219
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds float, float* %151, i64 %242
store float %240, float* %243
%244 = add nsw i64 %207, %176
%245 = getelementptr inbounds double, double* %152, i64 %244
%246 = load double, double* %245
%247 = fptrunc double %246 to float
%248 = add i32 %177, %219
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float, float* %151, i64 %249
store float %247, float* %250
%251 = add nsw i64 %207, %178
%252 = getelementptr inbounds double, double* %152, i64 %251
%253 = load double, double* %252
%254 = fptrunc double %253 to float
%255 = add i32 %179, %219
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds float, float* %151, i64 %256
store float %254, float* %257
%258 = add nsw i64 %207, %180
%259 = getelementptr inbounds double, double* %152, i64 %258
%260 = load double, double* %259
%261 = fptrunc double %260 to float
%262 = add i32 %181, %219
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds float, float* %151, i64 %263
store float %261, float* %264
%265 = or i64 %206, 1
%266 = mul nsw i64 %265, %158
%267 = add nsw i64 %266, %164
%268 = getelementptr inbounds double, double* %152, i64 %267
%269 = load double, double* %268
%270 = fptrunc double %269 to float
%271 = shl nsw i64 %265, 3
%272 = add nsw i64 %271, %166
%273 = getelementptr inbounds float, float* %151, i64 %272
store float %270, float* %273
%274 = add nsw i64 %266, %167
%275 = getelementptr inbounds double, double* %152, i64 %274
%276 = load double, double* %275
%277 = fptrunc double %276 to float
%278 = trunc i64 %271 to i32
%279 = add i32 %169, %278
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds float, float* %151, i64 %280
store float %277, float* %281
%282 = add nsw i64 %266, %170
%283 = getelementptr inbounds double, double* %152, i64 %282
%284 = load double, double* %283
%285 = fptrunc double %284 to float
%286 = add i32 %171, %278
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds float, float* %151, i64 %287
store float %285, float* %288
%289 = add nsw i64 %266, %172
%290 = getelementptr inbounds double, double* %152, i64 %289
%291 = load double, double* %290
%292 = fptrunc double %291 to float
%293 = add i32 %173, %278
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds float, float* %151, i64 %294
store float %292, float* %295
%296 = add nsw i64 %266, %174
%297 = getelementptr inbounds double, double* %152, i64 %296
%298 = load double, double* %297
%299 = fptrunc double %298 to float
%300 = add i32 %175, %278
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds float, float* %151, i64 %301
store float %299, float* %302
%303 = add nsw i64 %266, %176
%304 = getelementptr inbounds double, double* %152, i64 %303
%305 = load double, double* %304
%306 = fptrunc double %305 to float
%307 = add i32 %177, %278
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds float, float* %151, i64 %308
store float %306, float* %309
%310 = add nsw i64 %266, %178
%311 = getelementptr inbounds double, double* %152, i64 %310
%312 = load double, double* %311
%313 = fptrunc double %312 to float
%314 = add i32 %179, %278
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds float, float* %151, i64 %315
store float %313, float* %316
%317 = add nsw i64 %266, %180
%318 = getelementptr inbounds double, double* %152, i64 %317
%319 = load double, double* %318
%320 = fptrunc double %319 to float
%321 = add i32 %181, %278
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds float, float* %151, i64 %322
store float %320, float* %323
%324 = or i64 %206, 2
%325 = mul nsw i64 %324, %158
%326 = add nsw i64 %325, %164
%327 = getelementptr inbounds double, double* %152, i64 %326
%328 = load double, double* %327
%329 = fptrunc double %328 to float
%330 = shl nsw i64 %324, 3
%331 = add nsw i64 %330, %166
%332 = getelementptr inbounds float, float* %151, i64 %331
store float %329, float* %332
%333 = add nsw i64 %325, %167
%334 = getelementptr inbounds double, double* %152, i64 %333
%335 = load double, double* %334
%336 = fptrunc double %335 to float
%337 = trunc i64 %330 to i32
%338 = add i32 %169, %337
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds float, float* %151, i64 %339
store float %336, float* %340
%341 = add nsw i64 %325, %170
%342 = getelementptr inbounds double, double* %152, i64 %341
%343 = load double, double* %342
%344 = fptrunc double %343 to float
%345 = add i32 %171, %337
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds float, float* %151, i64 %346
store float %344, float* %347
%348 = add nsw i64 %325, %172
%349 = getelementptr inbounds double, double* %152, i64 %348
%350 = load double, double* %349
%351 = fptrunc double %350 to float
%352 = add i32 %173, %337
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds float, float* %151, i64 %353
store float %351, float* %354
%355 = add nsw i64 %325, %174
%356 = getelementptr inbounds double, double* %152, i64 %355
%357 = load double, double* %356
%358 = fptrunc double %357 to float
%359 = add i32 %175, %337
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds float, float* %151, i64 %360
store float %358, float* %361
%362 = add nsw i64 %325, %176
%363 = getelementptr inbounds double, double* %152, i64 %362
%364 = load double, double* %363
%365 = fptrunc double %364 to float
%366 = add i32 %177, %337
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds float, float* %151, i64 %367
store float %365, float* %368
%369 = add nsw i64 %325, %178
%370 = getelementptr inbounds double, double* %152, i64 %369
%371 = load double, double* %370
%372 = fptrunc double %371 to float
%373 = add i32 %179, %337
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds float, float* %151, i64 %374
store float %372, float* %375
%376 = add nsw i64 %325, %180
%377 = getelementptr inbounds double, double* %152, i64 %376
%378 = load double, double* %377
%379 = fptrunc double %378 to float
%380 = add i32 %181, %337
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds float, float* %151, i64 %381
store float %379, float* %382
%383 = or i64 %206, 3
%384 = mul nsw i64 %383, %158
%385 = add nsw i64 %384, %164
%386 = getelementptr inbounds double, double* %152, i64 %385
%387 = load double, double* %386
%388 = fptrunc double %387 to float
%389 = shl nsw i64 %383, 3
%390 = add nsw i64 %389, %166
%391 = getelementptr inbounds float, float* %151, i64 %390
store float %388, float* %391
%392 = add nsw i64 %384, %167
%393 = getelementptr inbounds double, double* %152, i64 %392
%394 = load double, double* %393
%395 = fptrunc double %394 to float
%396 = trunc i64 %389 to i32
%397 = add i32 %169, %396
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds float, float* %151, i64 %398
store float %395, float* %399
%400 = add nsw i64 %384, %170
%401 = getelementptr inbounds double, double* %152, i64 %400
%402 = load double, double* %401
%403 = fptrunc double %402 to float
%404 = add i32 %171, %396
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds float, float* %151, i64 %405
store float %403, float* %406
%407 = add nsw i64 %384, %172
%408 = getelementptr inbounds double, double* %152, i64 %407
%409 = load double, double* %408
%410 = fptrunc double %409 to float
%411 = add i32 %173, %396
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds float, float* %151, i64 %412
store float %410, float* %413
%414 = add nsw i64 %384, %174
%415 = getelementptr inbounds double, double* %152, i64 %414
%416 = load double, double* %415
%417 = fptrunc double %416 to float
%418 = add i32 %175, %396
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds float, float* %151, i64 %419
store float %417, float* %420
%421 = add nsw i64 %384, %176
%422 = getelementptr inbounds double, double* %152, i64 %421
%423 = load double, double* %422
%424 = fptrunc double %423 to float
%425 = add i32 %177, %396
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %151, i64 %426
store float %424, float* %427
%428 = add nsw i64 %384, %178
%429 = getelementptr inbounds double, double* %152, i64 %428
%430 = load double, double* %429
%431 = fptrunc double %430 to float
%432 = add i32 %179, %396
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds float, float* %151, i64 %433
store float %431, float* %434
%435 = add nsw i64 %384, %180
%436 = getelementptr inbounds double, double* %152, i64 %435
%437 = load double, double* %436
%438 = fptrunc double %437 to float
%439 = add i32 %181, %396
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds float, float* %151, i64 %440
store float %438, float* %441
%442 = or i64 %206, 4
%443 = mul nsw i64 %442, %158
%444 = add nsw i64 %443, %164
%445 = getelementptr inbounds double, double* %152, i64 %444
%446 = load double, double* %445
%447 = fptrunc double %446 to float
%448 = shl nsw i64 %442, 3
%449 = add nsw i64 %448, %166
%450 = getelementptr inbounds float, float* %151, i64 %449
store float %447, float* %450
%451 = add nsw i64 %443, %167
%452 = getelementptr inbounds double, double* %152, i64 %451
%453 = load double, double* %452
%454 = fptrunc double %453 to float
%455 = trunc i64 %448 to i32
%456 = add i32 %169, %455
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds float, float* %151, i64 %457
store float %454, float* %458
%459 = add nsw i64 %443, %170
%460 = getelementptr inbounds double, double* %152, i64 %459
%461 = load double, double* %460
%462 = fptrunc double %461 to float
%463 = add i32 %171, %455
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds float, float* %151, i64 %464
store float %462, float* %465
%466 = add nsw i64 %443, %172
%467 = getelementptr inbounds double, double* %152, i64 %466
%468 = load double, double* %467
%469 = fptrunc double %468 to float
%470 = add i32 %173, %455
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds float, float* %151, i64 %471
store float %469, float* %472
%473 = add nsw i64 %443, %174
%474 = getelementptr inbounds double, double* %152, i64 %473
%475 = load double, double* %474
%476 = fptrunc double %475 to float
%477 = add i32 %175, %455
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds float, float* %151, i64 %478
store float %476, float* %479
%480 = add nsw i64 %443, %176
%481 = getelementptr inbounds double, double* %152, i64 %480
%482 = load double, double* %481
%483 = fptrunc double %482 to float
%484 = add i32 %177, %455
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds float, float* %151, i64 %485
store float %483, float* %486
%487 = add nsw i64 %443, %178
%488 = getelementptr inbounds double, double* %152, i64 %487
%489 = load double, double* %488
%490 = fptrunc double %489 to float
%491 = add i32 %179, %455
%492 = sext i32 %491 to i64
%493 = getelementptr inbounds float, float* %151, i64 %492
store float %490, float* %493
%494 = add nsw i64 %443, %180
%495 = getelementptr inbounds double, double* %152, i64 %494
%496 = load double, double* %495
%497 = fptrunc double %496 to float
%498 = add i32 %181, %455
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds float, float* %151, i64 %499
store float %497, float* %500
%501 = or i64 %206, 5
%502 = mul nsw i64 %501, %158
%503 = add nsw i64 %502, %164
%504 = getelementptr inbounds double, double* %152, i64 %503
%505 = load double, double* %504
%506 = fptrunc double %505 to float
%507 = shl nsw i64 %501, 3
%508 = add nsw i64 %507, %166
%509 = getelementptr inbounds float, float* %151, i64 %508
store float %506, float* %509
%510 = add nsw i64 %502, %167
%511 = getelementptr inbounds double, double* %152, i64 %510
%512 = load double, double* %511
%513 = fptrunc double %512 to float
%514 = trunc i64 %507 to i32
%515 = add i32 %169, %514
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds float, float* %151, i64 %516
store float %513, float* %517
%518 = add nsw i64 %502, %170
%519 = getelementptr inbounds double, double* %152, i64 %518
%520 = load double, double* %519
%521 = fptrunc double %520 to float
%522 = add i32 %171, %514
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds float, float* %151, i64 %523
store float %521, float* %524
%525 = add nsw i64 %502, %172
%526 = getelementptr inbounds double, double* %152, i64 %525
%527 = load double, double* %526
%528 = fptrunc double %527 to float
%529 = add i32 %173, %514
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds float, float* %151, i64 %530
store float %528, float* %531
%532 = add nsw i64 %502, %174
%533 = getelementptr inbounds double, double* %152, i64 %532
%534 = load double, double* %533
%535 = fptrunc double %534 to float
%536 = add i32 %175, %514
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds float, float* %151, i64 %537
store float %535, float* %538
%539 = add nsw i64 %502, %176
%540 = getelementptr inbounds double, double* %152, i64 %539
%541 = load double, double* %540
%542 = fptrunc double %541 to float
%543 = add i32 %177, %514
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds float, float* %151, i64 %544
store float %542, float* %545
%546 = add nsw i64 %502, %178
%547 = getelementptr inbounds double, double* %152, i64 %546
%548 = load double, double* %547
%549 = fptrunc double %548 to float
%550 = add i32 %179, %514
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds float, float* %151, i64 %551
store float %549, float* %552
%553 = add nsw i64 %502, %180
%554 = getelementptr inbounds double, double* %152, i64 %553
%555 = load double, double* %554
%556 = fptrunc double %555 to float
%557 = add i32 %181, %514
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds float, float* %151, i64 %558
store float %556, float* %559
%560 = or i64 %206, 6
%561 = mul nsw i64 %560, %158
%562 = add nsw i64 %561, %164
%563 = getelementptr inbounds double, double* %152, i64 %562
%564 = load double, double* %563
%565 = fptrunc double %564 to float
%566 = shl nsw i64 %560, 3
%567 = add nsw i64 %566, %166
%568 = getelementptr inbounds float, float* %151, i64 %567
store float %565, float* %568
%569 = add nsw i64 %561, %167
%570 = getelementptr inbounds double, double* %152, i64 %569
%571 = load double, double* %570
%572 = fptrunc double %571 to float
%573 = trunc i64 %566 to i32
%574 = add i32 %169, %573
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds float, float* %151, i64 %575
store float %572, float* %576
%577 = add nsw i64 %561, %170
%578 = getelementptr inbounds double, double* %152, i64 %577
%579 = load double, double* %578
%580 = fptrunc double %579 to float
%581 = add i32 %171, %573
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds float, float* %151, i64 %582
store float %580, float* %583
%584 = add nsw i64 %561, %172
%585 = getelementptr inbounds double, double* %152, i64 %584
%586 = load double, double* %585
%587 = fptrunc double %586 to float
%588 = add i32 %173, %573
%589 = sext i32 %588 to i64
%590 = getelementptr inbounds float, float* %151, i64 %589
store float %587, float* %590
%591 = add nsw i64 %561, %174
%592 = getelementptr inbounds double, double* %152, i64 %591
%593 = load double, double* %592
%594 = fptrunc double %593 to float
%595 = add i32 %175, %573
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds float, float* %151, i64 %596
store float %594, float* %597
%598 = add nsw i64 %561, %176
%599 = getelementptr inbounds double, double* %152, i64 %598
%600 = load double, double* %599
%601 = fptrunc double %600 to float
%602 = add i32 %177, %573
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds float, float* %151, i64 %603
store float %601, float* %604
%605 = add nsw i64 %561, %178
%606 = getelementptr inbounds double, double* %152, i64 %605
%607 = load double, double* %606
%608 = fptrunc double %607 to float
%609 = add i32 %179, %573
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds float, float* %151, i64 %610
store float %608, float* %611
%612 = add nsw i64 %561, %180
%613 = getelementptr inbounds double, double* %152, i64 %612
%614 = load double, double* %613
%615 = fptrunc double %614 to float
%616 = add i32 %181, %573
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds float, float* %151, i64 %617
store float %615, float* %618
%619 = or i64 %206, 7
%620 = mul nsw i64 %619, %158
%621 = add nsw i64 %620, %164
%622 = getelementptr inbounds double, double* %152, i64 %621
%623 = load double, double* %622
%624 = fptrunc double %623 to float
%625 = shl nsw i64 %619, 3
%626 = add nsw i64 %625, %166
%627 = getelementptr inbounds float, float* %151, i64 %626
store float %624, float* %627
%628 = add nsw i64 %620, %167
%629 = getelementptr inbounds double, double* %152, i64 %628
%630 = load double, double* %629
%631 = fptrunc double %630 to float
%632 = trunc i64 %625 to i32
%633 = add i32 %169, %632
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds float, float* %151, i64 %634
store float %631, float* %635
%636 = add nsw i64 %620, %170
%637 = getelementptr inbounds double, double* %152, i64 %636
%638 = load double, double* %637
%639 = fptrunc double %638 to float
%640 = add i32 %171, %632
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds float, float* %151, i64 %641
store float %639, float* %642
%643 = add nsw i64 %620, %172
%644 = getelementptr inbounds double, double* %152, i64 %643
%645 = load double, double* %644
%646 = fptrunc double %645 to float
%647 = add i32 %173, %632
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds float, float* %151, i64 %648
store float %646, float* %649
%650 = add nsw i64 %620, %174
%651 = getelementptr inbounds double, double* %152, i64 %650
%652 = load double, double* %651
%653 = fptrunc double %652 to float
%654 = add i32 %175, %632
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds float, float* %151, i64 %655
store float %653, float* %656
%657 = add nsw i64 %620, %176
%658 = getelementptr inbounds double, double* %152, i64 %657
%659 = load double, double* %658
%660 = fptrunc double %659 to float
%661 = add i32 %177, %632
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds float, float* %151, i64 %662
store float %660, float* %663
%664 = add nsw i64 %620, %178
%665 = getelementptr inbounds double, double* %152, i64 %664
%666 = load double, double* %665
%667 = fptrunc double %666 to float
%668 = add i32 %179, %632
%669 = sext i32 %668 to i64
%670 = getelementptr inbounds float, float* %151, i64 %669
store float %667, float* %670
%671 = add nsw i64 %620, %180
%672 = getelementptr inbounds double, double* %152, i64 %671
%673 = load double, double* %672
%674 = fptrunc double %673 to float
%675 = add i32 %181, %632
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds float, float* %151, i64 %676
store float %674, float* %677
%678 = add nuw nsw i64 %206, 8
%679 = icmp slt i64 %678, %159
br i1 %679, label %205, label %182
680: ; preds = %187, %680
%681 = phi i64 [ %204, %187 ], [ %741, %680 ]
%682 = trunc i64 %681 to i32
%683 = mul nsw i64 %681, %158
%684 = add nsw i64 %683, %164
%685 = getelementptr inbounds double, double* %152, i64 %684
%686 = load double, double* %685
%687 = fptrunc double %686 to float
%688 = shl nsw i32 %682, 3
%689 = sext i32 %688 to i64
%690 = add nsw i64 %188, %689
%691 = getelementptr inbounds float, float* %151, i64 %690
store float %687, float* %691
%692 = add nsw i64 %189, %683
%693 = getelementptr inbounds double, double* %152, i64 %692
%694 = load double, double* %693
%695 = fptrunc double %694 to float
%696 = add i32 %191, %688
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds float, float* %151, i64 %697
store float %695, float* %698
%699 = add nsw i64 %192, %683
%700 = getelementptr inbounds double, double* %152, i64 %699
%701 = load double, double* %700
%702 = fptrunc double %701 to float
%703 = add i32 %193, %688
%704 = sext i32 %703 to i64
%705 = getelementptr inbounds float, float* %151, i64 %704
store float %702, float* %705
%706 = add nsw i64 %194, %683
%707 = getelementptr inbounds double, double* %152, i64 %706
%708 = load double, double* %707
%709 = fptrunc double %708 to float
%710 = add i32 %195, %688
%711 = sext i32 %710 to i64
%712 = getelementptr inbounds float, float* %151, i64 %711
store float %709, float* %712
%713 = add nsw i64 %196, %683
%714 = getelementptr inbounds double, double* %152, i64 %713
%715 = load double, double* %714
%716 = fptrunc double %715 to float
%717 = add i32 %197, %688
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds float, float* %151, i64 %718
store float %716, float* %719
%720 = add nsw i64 %198, %683
%721 = getelementptr inbounds double, double* %152, i64 %720
%722 = load double, double* %721
%723 = fptrunc double %722 to float
%724 = add i32 %199, %688
%725 = sext i32 %724 to i64
%726 = getelementptr inbounds float, float* %151, i64 %725
store float %723, float* %726
%727 = add nsw i64 %200, %683
%728 = getelementptr inbounds double, double* %152, i64 %727
%729 = load double, double* %728
%730 = fptrunc double %729 to float
%731 = add i32 %201, %688
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds float, float* %151, i64 %732
store float %730, float* %733
%734 = add nsw i64 %202, %683
%735 = getelementptr inbounds double, double* %152, i64 %734
%736 = load double, double* %735
%737 = fptrunc double %736 to float
%738 = add i32 %203, %688
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds float, float* %151, i64 %739
store float %737, float* %740
%741 = add nuw nsw i64 %681, 1
%742 = icmp eq i64 %741, %162
br i1 %742, label %743, label %680
743: ; preds = %680, %184
%744 = add nuw nsw i64 %164, 8
%745 = icmp ult i64 %744, %161
br i1 %745, label %163, label %746
746: ; preds = %743
%747 = trunc i64 %744 to i32
br label %748
748: ; preds = %746, %150
%749 = phi i32 [ 0, %150 ], [ %747, %746 ]
%750 = icmp sgt i32 %13, %749
br i1 %750, label %751, label %846
751: ; preds = %748
%752 = sub nsw i32 %13, %749
%753 = icmp sgt i32 %1, 0
br i1 %753, label %754, label %846
754: ; preds = %751
%755 = icmp slt i32 %752, 8
%756 = select i1 %755, i32 %752, i32 8
%757 = icmp sgt i32 %752, 0
%758 = mul nsw i32 %749, %7
%759 = call i32 @llvm.smax.i32(i32 %756, i32 1)
%760 = icmp slt i32 %756, 2
%761 = icmp eq i32 %759, 2
%762 = icmp eq i32 %759, 3
%763 = icmp eq i32 %759, 4
%764 = icmp eq i32 %759, 5
%765 = icmp eq i32 %759, 6
%766 = icmp eq i32 %759, 7
br label %767
767: ; preds = %754, %843
%768 = phi i32 [ 0, %754 ], [ %844, %843 ]
br i1 %757, label %769, label %843
769: ; preds = %767
%770 = mul nsw i32 %768, %5
%771 = add i32 %770, %749
%772 = shl nsw i32 %768, 3
%773 = add i32 %772, %758
%774 = sext i32 %771 to i64
%775 = getelementptr inbounds double, double* %152, i64 %774
%776 = load double, double* %775
%777 = fptrunc double %776 to float
%778 = sext i32 %773 to i64
%779 = getelementptr inbounds float, float* %151, i64 %778
store float %777, float* %779
br i1 %760, label %843, label %780
780: ; preds = %769
%781 = add i32 %771, 1
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds double, double* %152, i64 %782
%784 = load double, double* %783
%785 = fptrunc double %784 to float
%786 = add i32 %773, 1
%787 = sext i32 %786 to i64
%788 = getelementptr inbounds float, float* %151, i64 %787
store float %785, float* %788
br i1 %761, label %843, label %789
789: ; preds = %780
%790 = add i32 %771, 2
%791 = sext i32 %790 to i64
%792 = getelementptr inbounds double, double* %152, i64 %791
%793 = load double, double* %792
%794 = fptrunc double %793 to float
%795 = add i32 %773, 2
%796 = sext i32 %795 to i64
%797 = getelementptr inbounds float, float* %151, i64 %796
store float %794, float* %797
br i1 %762, label %843, label %798
798: ; preds = %789
%799 = add i32 %771, 3
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds double, double* %152, i64 %800
%802 = load double, double* %801
%803 = fptrunc double %802 to float
%804 = add i32 %773, 3
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds float, float* %151, i64 %805
store float %803, float* %806
br i1 %763, label %843, label %807
807: ; preds = %798
%808 = add i32 %771, 4
%809 = sext i32 %808 to i64
%810 = getelementptr inbounds double, double* %152, i64 %809
%811 = load double, double* %810
%812 = fptrunc double %811 to float
%813 = add i32 %773, 4
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds float, float* %151, i64 %814
store float %812, float* %815
br i1 %764, label %843, label %816
816: ; preds = %807
%817 = add i32 %771, 5
%818 = sext i32 %817 to i64
%819 = getelementptr inbounds double, double* %152, i64 %818
%820 = load double, double* %819
%821 = fptrunc double %820 to float
%822 = add i32 %773, 5
%823 = sext i32 %822 to i64
%824 = getelementptr inbounds float, float* %151, i64 %823
store float %821, float* %824
br i1 %765, label %843, label %825
825: ; preds = %816
%826 = add i32 %771, 6
%827 = sext i32 %826 to i64
%828 = getelementptr inbounds double, double* %152, i64 %827
%829 = load double, double* %828
%830 = fptrunc double %829 to float
%831 = add i32 %773, 6
%832 = sext i32 %831 to i64
%833 = getelementptr inbounds float, float* %151, i64 %832
store float %830, float* %833
br i1 %766, label %843, label %834
834: ; preds = %825
%835 = add i32 %771, 7
%836 = sext i32 %835 to i64
%837 = getelementptr inbounds double, double* %152, i64 %836
%838 = load double, double* %837
%839 = fptrunc double %838 to float
%840 = add i32 %773, 7
%841 = sext i32 %840 to i64
%842 = getelementptr inbounds float, float* %151, i64 %841
store float %839, float* %842
br label %843
843: ; preds = %769, %780, %789, %798, %807, %816, %825, %834, %767
%844 = add nuw nsw i32 %768, 1
%845 = icmp eq i32 %844, %1
br i1 %845, label %846, label %767
846: ; preds = %843, %751, %748
ret void
}