void cvt_tran_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 > col)
    row0 = col;
  row1 = col - row0;
  ii = 0;
  if (row0 > 0) {
    for (j = 0; j < row; j++) {
      for (i = 0; i < row0; i++) {
        pA[i + j * bs + ii * sda] = (float)A[j + (i + ii) * lda];
      }
    }
    A += row0 * lda;
    pA += row0 + bs * (sda - 1);
  }
  ii = 0;
  for (; ii < row1 - 7; ii += bs) {
    j = 0;
    for (; j < row - 7; j += 8) {
      pA[0 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 0) * lda];
      pA[1 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 1) * lda];
      pA[2 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 2) * lda];
      pA[3 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 3) * lda];
      pA[4 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 4) * lda];
      pA[5 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 5) * lda];
      pA[6 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 6) * lda];
      pA[7 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 7) * lda];
      pA[0 + (j + 1) * bs + ii * sda] = (float)A[j + 1 + (ii + 0) * lda];
      pA[1 + (j + 1) * bs + ii * sda] = (float)A[j + 1 + (ii + 1) * lda];
      pA[2 + (j + 1) * bs + ii * sda] = (float)A[j + 1 + (ii + 2) * lda];
      pA[3 + (j + 1) * bs + ii * sda] = (float)A[j + 1 + (ii + 3) * lda];
      pA[4 + (j + 1) * bs + ii * sda] = (float)A[j + 1 + (ii + 4) * lda];
      pA[5 + (j + 1) * bs + ii * sda] = (float)A[j + 1 + (ii + 5) * lda];
      pA[6 + (j + 1) * bs + ii * sda] = (float)A[j + 1 + (ii + 6) * lda];
      pA[7 + (j + 1) * bs + ii * sda] = (float)A[j + 1 + (ii + 7) * lda];
      pA[0 + (j + 2) * bs + ii * sda] = (float)A[j + 2 + (ii + 0) * lda];
      pA[1 + (j + 2) * bs + ii * sda] = (float)A[j + 2 + (ii + 1) * lda];
      pA[2 + (j + 2) * bs + ii * sda] = (float)A[j + 2 + (ii + 2) * lda];
      pA[3 + (j + 2) * bs + ii * sda] = (float)A[j + 2 + (ii + 3) * lda];
      pA[4 + (j + 2) * bs + ii * sda] = (float)A[j + 2 + (ii + 4) * lda];
      pA[5 + (j + 2) * bs + ii * sda] = (float)A[j + 2 + (ii + 5) * lda];
      pA[6 + (j + 2) * bs + ii * sda] = (float)A[j + 2 + (ii + 6) * lda];
      pA[7 + (j + 2) * bs + ii * sda] = (float)A[j + 2 + (ii + 7) * lda];
      pA[0 + (j + 3) * bs + ii * sda] = (float)A[j + 3 + (ii + 0) * lda];
      pA[1 + (j + 3) * bs + ii * sda] = (float)A[j + 3 + (ii + 1) * lda];
      pA[2 + (j + 3) * bs + ii * sda] = (float)A[j + 3 + (ii + 2) * lda];
      pA[3 + (j + 3) * bs + ii * sda] = (float)A[j + 3 + (ii + 3) * lda];
      pA[4 + (j + 3) * bs + ii * sda] = (float)A[j + 3 + (ii + 4) * lda];
      pA[5 + (j + 3) * bs + ii * sda] = (float)A[j + 3 + (ii + 5) * lda];
      pA[6 + (j + 3) * bs + ii * sda] = (float)A[j + 3 + (ii + 6) * lda];
      pA[7 + (j + 3) * bs + ii * sda] = (float)A[j + 3 + (ii + 7) * lda];
      pA[0 + (j + 4) * bs + ii * sda] = (float)A[j + 4 + (ii + 0) * lda];
      pA[1 + (j + 4) * bs + ii * sda] = (float)A[j + 4 + (ii + 1) * lda];
      pA[2 + (j + 4) * bs + ii * sda] = (float)A[j + 4 + (ii + 2) * lda];
      pA[3 + (j + 4) * bs + ii * sda] = (float)A[j + 4 + (ii + 3) * lda];
      pA[4 + (j + 4) * bs + ii * sda] = (float)A[j + 4 + (ii + 4) * lda];
      pA[5 + (j + 4) * bs + ii * sda] = (float)A[j + 4 + (ii + 5) * lda];
      pA[6 + (j + 4) * bs + ii * sda] = (float)A[j + 4 + (ii + 6) * lda];
      pA[7 + (j + 4) * bs + ii * sda] = (float)A[j + 4 + (ii + 7) * lda];
      pA[0 + (j + 5) * bs + ii * sda] = (float)A[j + 5 + (ii + 0) * lda];
      pA[1 + (j + 5) * bs + ii * sda] = (float)A[j + 5 + (ii + 1) * lda];
      pA[2 + (j + 5) * bs + ii * sda] = (float)A[j + 5 + (ii + 2) * lda];
      pA[3 + (j + 5) * bs + ii * sda] = (float)A[j + 5 + (ii + 3) * lda];
      pA[4 + (j + 5) * bs + ii * sda] = (float)A[j + 5 + (ii + 4) * lda];
      pA[5 + (j + 5) * bs + ii * sda] = (float)A[j + 5 + (ii + 5) * lda];
      pA[6 + (j + 5) * bs + ii * sda] = (float)A[j + 5 + (ii + 6) * lda];
      pA[7 + (j + 5) * bs + ii * sda] = (float)A[j + 5 + (ii + 7) * lda];
      pA[0 + (j + 6) * bs + ii * sda] = (float)A[j + 6 + (ii + 0) * lda];
      pA[1 + (j + 6) * bs + ii * sda] = (float)A[j + 6 + (ii + 1) * lda];
      pA[2 + (j + 6) * bs + ii * sda] = (float)A[j + 6 + (ii + 2) * lda];
      pA[3 + (j + 6) * bs + ii * sda] = (float)A[j + 6 + (ii + 3) * lda];
      pA[4 + (j + 6) * bs + ii * sda] = (float)A[j + 6 + (ii + 4) * lda];
      pA[5 + (j + 6) * bs + ii * sda] = (float)A[j + 6 + (ii + 5) * lda];
      pA[6 + (j + 6) * bs + ii * sda] = (float)A[j + 6 + (ii + 6) * lda];
      pA[7 + (j + 6) * bs + ii * sda] = (float)A[j + 6 + (ii + 7) * lda];
      pA[0 + (j + 7) * bs + ii * sda] = (float)A[j + 7 + (ii + 0) * lda];
      pA[1 + (j + 7) * bs + ii * sda] = (float)A[j + 7 + (ii + 1) * lda];
      pA[2 + (j + 7) * bs + ii * sda] = (float)A[j + 7 + (ii + 2) * lda];
      pA[3 + (j + 7) * bs + ii * sda] = (float)A[j + 7 + (ii + 3) * lda];
      pA[4 + (j + 7) * bs + ii * sda] = (float)A[j + 7 + (ii + 4) * lda];
      pA[5 + (j + 7) * bs + ii * sda] = (float)A[j + 7 + (ii + 5) * lda];
      pA[6 + (j + 7) * bs + ii * sda] = (float)A[j + 7 + (ii + 6) * lda];
      pA[7 + (j + 7) * bs + ii * sda] = (float)A[j + 7 + (ii + 7) * lda];
    }
    for (; j < row; j++) {
      pA[0 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 0) * lda];
      pA[1 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 1) * lda];
      pA[2 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 2) * lda];
      pA[3 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 3) * lda];
      pA[4 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 4) * lda];
      pA[5 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 5) * lda];
      pA[6 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 6) * lda];
      pA[7 + (j + 0) * bs + ii * sda] = (float)A[j + 0 + (ii + 7) * lda];
    }
  }
  if (ii < row1) {
    row2 = row1 - ii;
    if (bs < row2)
      row2 = bs;
    for (j = 0; j < row; j++) {
      for (i = 0; i < row2; i++) {
        pA[i + j * bs + ii * sda] = (float)A[j + (i + ii) * lda];
      }
    }
  }
}


x86 assembly (clang, -O0):
<cvt_tran_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    -0x8(%rbp),%eax
jle    1155 <cvt_tran_d2s_mat2pmat+0x55>
mov    -0x8(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    122e <cvt_tran_d2s_mat2pmat+0x12e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11f5 <cvt_tran_d2s_mat2pmat+0xf5>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    11e2 <cvt_tran_d2s_mat2pmat+0xe2>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x24(%rbp),%edx
add    -0x28(%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_tran_d2s_mat2pmat+0x89>
jmp    11e7 <cvt_tran_d2s_mat2pmat+0xe7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1176 <cvt_tran_d2s_mat2pmat+0x76>
mov    -0x30(%rbp),%ecx
imul   -0x1c(%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    2576 <cvt_tran_d2s_mat2pmat+0x1476>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    232c <cvt_tran_d2s_mat2pmat+0x122c>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    124d <cvt_tran_d2s_mat2pmat+0x14d>
jmp    2331 <cvt_tran_d2s_mat2pmat+0x1231>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2563 <cvt_tran_d2s_mat2pmat+0x1463>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    2331 <cvt_tran_d2s_mat2pmat+0x1231>
jmp    2568 <cvt_tran_d2s_mat2pmat+0x1468>
mov    -0x28(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x28(%rbp)
jmp    1235 <cvt_tran_d2s_mat2pmat+0x135>
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    262b <cvt_tran_d2s_mat2pmat+0x152b>
mov    -0x34(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    $0x8,%eax
cmp    -0x38(%rbp),%eax
jge    25a0 <cvt_tran_d2s_mat2pmat+0x14a0>
movl   $0x8,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2626 <cvt_tran_d2s_mat2pmat+0x1526>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    2613 <cvt_tran_d2s_mat2pmat+0x1513>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x24(%rbp),%edx
add    -0x28(%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    25ba <cvt_tran_d2s_mat2pmat+0x14ba>
jmp    2618 <cvt_tran_d2s_mat2pmat+0x1518>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    25a7 <cvt_tran_d2s_mat2pmat+0x14a7>
jmp    262b <cvt_tran_d2s_mat2pmat+0x152b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvt_tran_d2s_mat2pmat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x30,%rsp
mov    %r9d,-0x74(%rsp)
mov    0x70(%rsp),%eax
mov    %rax,-0x80(%rsp)
mov    0x68(%rsp),%rcx
neg    %edx
and    $0x7,%edx
cmp    %esi,%edx
cmovg  %esi,%edx
sub    %edx,%esi
test   %edx,%edx
mov    %rdi,-0x68(%rsp)
jle    123e <cvt_tran_d2s_mat2pmat+0x13e>
mov    %r8,-0x70(%rsp)
test   %edi,%edi
jle    1217 <cvt_tran_d2s_mat2pmat+0x117>
movslq -0x74(%rsp),%r15
mov    -0x68(%rsp),%r9d
mov    %edx,%r10d
mov    %r10d,%r12d
and    $0xfffffffe,%r12d
mov    %r15,%r13
shl    $0x4,%r13
mov    $0x1,%r8d
xor    %r14d,%r14d
mov    -0x70(%rsp),%r11
jmp    1195 <cvt_tran_d2s_mat2pmat+0x95>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r14
add    $0x8,%r11
add    $0x8,%r8
cmp    %r9,%r14
je     1217 <cvt_tran_d2s_mat2pmat+0x117>
cmp    $0x1,%edx
jne    11a0 <cvt_tran_d2s_mat2pmat+0xa0>
xor    %eax,%eax
jmp    11e4 <cvt_tran_d2s_mat2pmat+0xe4>
xchg   %ax,%ax
mov    %r8,%rbp
mov    %r11,%rbx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rbx),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    -0x1(%rbp),%edi
and    $0xfffffffe,%edi
movss  %xmm0,(%rcx,%rdi,4)
movsd  (%rbx,%r15,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    %ebp,%edi
movss  %xmm0,(%rcx,%rdi,4)
add    $0x2,%rax
add    %r13,%rbx
add    $0x2,%rbp
cmp    %rax,%r12
jne    11b0 <cvt_tran_d2s_mat2pmat+0xb0>
test   $0x1,%r10b
je     1180 <cvt_tran_d2s_mat2pmat+0x80>
lea    0x0(,%r14,8),%rdi
mov    %rax,%rbx
imul   %r15,%rbx
add    %r14,%rbx
mov    -0x70(%rsp),%rbp
movsd  0x0(%rbp,%rbx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %edi,%eax
movss  %xmm0,(%rcx,%rax,4)
jmp    1180 <cvt_tran_d2s_mat2pmat+0x80>
mov    %edx,%eax
imul   -0x74(%rsp),%eax
cltq
mov    -0x70(%rsp),%r8
lea    (%r8,%rax,8),%r8
mov    0x70(%rsp),%eax
lea    (%rdx,%rax,8),%eax
add    $0xfffffff8,%eax
cltq
lea    (%rcx,%rax,4),%rcx
mov    -0x68(%rsp),%rdi
xor    %ebx,%ebx
cmp    $0x8,%esi
jl     1b7d <cvt_tran_d2s_mat2pmat+0xa7d>
mov    %rsi,-0x48(%rsp)
lea    -0x7(%rsi),%eax
mov    %rax,-0x8(%rsp)
lea    -0x7(%rdi),%eax
cltq
mov    %rax,-0x28(%rsp)
movslq -0x74(%rsp),%rsi
mov    0x70(%rsp),%eax
movslq %eax,%rbp
mov    %edi,%edx
mov    %rdx,-0x40(%rsp)
lea    0x38(%r8),%rdx
mov    %rsi,%rbx
shl    $0x6,%rbx
mov    %rbx,-0x10(%rsp)
lea    0x0(,%rax,8),%eax
mov    %rax,-0x18(%rsp)
lea    0xe0(%rcx),%r15
mov    %rbp,-0x38(%rsp)
shl    $0x5,%rbp
mov    %rbp,-0x20(%rsp)
lea    0x0(,%rsi,8),%r9
mov    %rsi,-0x30(%rsp)
mov    %rsi,%rax
shl    $0x4,%rax
lea    (%rax,%rax,2),%rax
mov    $0x8,%r10d
sub    %rax,%r10
xor    %r11d,%r11d
mov    %r8,-0x70(%rsp)
mov    %r8,-0x58(%rsp)
xor    %ebx,%ebx
jmp    1310 <cvt_tran_d2s_mat2pmat+0x210>
cs nopw 0x0(%rax,%rax,1)
mov    -0x50(%rsp),%rbx
add    $0x8,%rbx
mov    -0x10(%rsp),%rax
add    %rax,%rdx
add    -0x18(%rsp),%r11
add    -0x20(%rsp),%r15
add    %rax,-0x58(%rsp)
cmp    -0x8(%rsp),%rbx
mov    -0x68(%rsp),%rdi
jae    1b73 <cvt_tran_d2s_mat2pmat+0xa73>
mov    %rbx,-0x50(%rsp)
mov    $0x0,%ebp
cmp    $0x8,%edi
jl     19c3 <cvt_tran_d2s_mat2pmat+0x8c3>
xor    %r14d,%r14d
xor    %ebp,%ebp
mov    -0x28(%rsp),%rbx
nopl   (%rax)
movsd  -0x38(%rdx,%r14,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%rdx,%r14,1),%rax
movss  %xmm0,-0xe0(%r15,%r14,4)
ff ff ff
movsd  -0x38(%r9,%rax,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1(%r11,%r14,1),%esi
movslq %esi,%rsi
lea    -0x38(%r9,%rax,1),%r13
movss  %xmm0,(%rcx,%rsi,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x2,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x3,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x4,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x5,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x6,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x7,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movsd  -0x30(%rdx,%r14,1),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %r9,%r13
movss  %xmm0,-0xc0(%r15,%r14,4)
ff ff ff
movsd  (%r10,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x9,%eax
cltq
add    %r10,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0xa,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0xb,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0xc,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0xd,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0xe,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0xf,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movsd  -0x28(%rdx,%r14,1),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %r9,%r13
movss  %xmm0,-0xa0(%r15,%r14,4)
ff ff ff
movsd  (%r10,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x11,%eax
cltq
add    %r10,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x12,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x13,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x14,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x15,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x16,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x17,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movsd  -0x20(%rdx,%r14,1),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %r9,%r13
movss  %xmm0,-0x80(%r15,%r14,4)
movsd  (%r10,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x19,%eax
cltq
add    %r10,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x1a,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x1b,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x1c,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x1d,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x1e,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x1f,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movsd  -0x18(%rdx,%r14,1),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %r9,%r13
movss  %xmm0,-0x60(%r15,%r14,4)
movsd  (%r10,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x21,%eax
cltq
add    %r10,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x22,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x23,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x24,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x25,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x26,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x27,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movsd  -0x10(%rdx,%r14,1),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %r9,%r13
movss  %xmm0,-0x40(%r15,%r14,4)
movsd  (%r10,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x29,%eax
cltq
add    %r10,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x2a,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x2b,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x2c,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x2d,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x2e,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x2f,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movsd  -0x8(%rdx,%r14,1),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %r9,%r13
movss  %xmm0,-0x20(%r15,%r14,4)
movsd  (%r10,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x31,%eax
cltq
add    %r10,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x32,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x33,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x34,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x35,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x36,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x37,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movsd  (%rdx,%r14,1),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %r9,%r13
movss  %xmm0,(%r15,%r14,4)
movsd  (%r10,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x39,%eax
cltq
add    %r10,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x3a,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x3b,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x3c,%eax
cltq
add    %r9,%r13
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %r9,%r13
lea    (%r11,%r14,1),%eax
add    $0x3d,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %r9,%r13
lea    (%r11,%r14,1),%eax
add    $0x3e,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movsd  (%r9,%r13,1),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r11,%r14,1),%eax
add    $0x3f,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
add    $0x8,%rbp
add    $0x40,%r14
cmp    %rbx,%rbp
jl     1330 <cvt_tran_d2s_mat2pmat+0x230>
cmp    %edi,%ebp
mov    -0x70(%rsp),%rsi
jge    12e0 <cvt_tran_d2s_mat2pmat+0x1e0>
mov    -0x50(%rsp),%r14
mov    %r14,%rax
imul   -0x38(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    %r14,%rdi
or     $0x1,%rdi
mov    -0x30(%rsp),%rax
imul   %rax,%rdi
mov    %rdi,0x28(%rsp)
mov    %r14,%rdi
or     $0x2,%rdi
imul   %rax,%rdi
mov    %rdi,0x20(%rsp)
mov    %r14,%rdi
or     $0x3,%rdi
imul   %rax,%rdi
mov    %rdi,0x18(%rsp)
mov    %r14,%rdi
or     $0x4,%rdi
imul   %rax,%rdi
mov    %rdi,0x10(%rsp)
mov    %r14,%rdi
or     $0x5,%rdi
imul   %rax,%rdi
mov    %rdi,0x8(%rsp)
mov    %r14,%r12
or     $0x6,%r12
imul   %rax,%r12
or     $0x7,%r14
imul   %rax,%r14
mov    %ebp,%r13d
lea    0x0(,%rbp,8),%eax
mov    %rax,(%rsp)
lea    (%r11,%rbp,8),%ebp
mov    -0x58(%rsp),%rax
lea    (%rax,%r13,8),%r8
mov    -0x40(%rsp),%rax
sub    %r13,%rax
xor    %ebx,%ebx
movsd  (%r8,%rbx,1),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    (%rsp),%rdi
add    %ebx,%edi
movslq %edi,%rdi
add    -0x60(%rsp),%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    0x28(%rsp),%rdi
add    %r13,%rdi
movsd  (%rsi,%rdi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1(%rbp,%rbx,1),%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    0x20(%rsp),%rdi
lea    0x0(%r13,%rdi,1),%rdi
movsd  (%rsi,%rdi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2(%rbp,%rbx,1),%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    0x18(%rsp),%rdi
lea    0x0(%r13,%rdi,1),%rdi
movsd  (%rsi,%rdi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x3(%rbp,%rbx,1),%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    0x10(%rsp),%rdi
lea    0x0(%r13,%rdi,1),%rdi
movsd  (%rsi,%rdi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x4(%rbp,%rbx,1),%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    0x8(%rsp),%rdi
lea    0x0(%r13,%rdi,1),%rdi
movsd  (%rsi,%rdi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x5(%rbp,%rbx,1),%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
lea    0x0(%r13,%r12,1),%rdi
movsd  (%rsi,%rdi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x6(%rbp,%rbx,1),%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
lea    0x0(%r13,%r14,1),%rdi
movsd  (%rsi,%rdi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%rbx,%rbp,1),%edi
add    $0x7,%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
add    $0x1,%r13
add    $0x8,%rbx
add    $0xffffffffffffffff,%rax
jne    1a70 <cvt_tran_d2s_mat2pmat+0x970>
jmp    12e0 <cvt_tran_d2s_mat2pmat+0x1e0>
mov    -0x48(%rsp),%rsi
mov    -0x70(%rsp),%r8
sub    %ebx,%esi
jle    1d5c <cvt_tran_d2s_mat2pmat+0xc5c>
test   %edi,%edi
jle    1d5c <cvt_tran_d2s_mat2pmat+0xc5c>
mov    %rsi,%r9
mov    %rsi,%rdx
cmp    $0x8,%edx
mov    $0x8,%eax
cmovl  %edx,%eax
mov    -0x80(%rsp),%rdx
imul   %ebx,%edx
mov    %rdx,-0x80(%rsp)
movslq %ebx,%r10
movslq -0x74(%rsp),%rbx
cmp    $0x2,%eax
mov    $0x1,%edx
cmovge %eax,%edx
mov    %edi,%esi
mov    %r10,%rdi
imul   %rbx,%rdi
lea    0x1(%r10),%r13
imul   %rbx,%r13
lea    0x2(%r10),%r12
imul   %rbx,%r12
lea    0x3(%r10),%r15
imul   %rbx,%r15
lea    0x4(%r10),%r14
imul   %rbx,%r14
lea    0x5(%r10),%r11
imul   %rbx,%r11
lea    0x6(%r10),%rbp
imul   %rbx,%rbp
add    $0x7,%r10
imul   %rbx,%r10
lea    (%r8,%r10,8),%r10
lea    (%r8,%rbp,8),%rbx
mov    %rbx,-0x60(%rsp)
lea    (%r8,%r11,8),%r11
lea    (%r8,%r14,8),%r14
lea    (%r8,%r15,8),%r15
lea    (%r8,%r12,8),%r12
lea    (%r8,%r13,8),%r13
lea    (%r8,%rdi,8),%rbp
shl    $0x3,%rsi
xor    %ebx,%ebx
jmp    1c3d <cvt_tran_d2s_mat2pmat+0xb3d>
nopl   0x0(%rax)
add    $0x8,%rbx
cmp    %rbx,%rsi
je     1d5c <cvt_tran_d2s_mat2pmat+0xc5c>
test   %r9d,%r9d
jle    1c30 <cvt_tran_d2s_mat2pmat+0xb30>
movsd  0x0(%rbp,%rbx,1),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x80(%rsp),%rdi
add    %ebx,%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
cmp    $0x2,%eax
jl     1c30 <cvt_tran_d2s_mat2pmat+0xb30>
movsd  0x0(%r13,%rbx,1),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x80(%rsp),%rdi
add    %ebx,%edi
add    $0x1,%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
cmp    $0x2,%edx
je     1c30 <cvt_tran_d2s_mat2pmat+0xb30>
movsd  (%r12,%rbx,1),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x80(%rsp),%rdi
add    %ebx,%edi
add    $0x2,%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
cmp    $0x3,%edx
je     1c30 <cvt_tran_d2s_mat2pmat+0xb30>
movsd  (%r15,%rbx,1),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x80(%rsp),%rdi
add    %ebx,%edi
add    $0x3,%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
cmp    $0x4,%edx
je     1c30 <cvt_tran_d2s_mat2pmat+0xb30>
movsd  (%r14,%rbx,1),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x80(%rsp),%rdi
add    %ebx,%edi
add    $0x4,%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
cmp    $0x5,%edx
je     1c30 <cvt_tran_d2s_mat2pmat+0xb30>
movsd  (%r11,%rbx,1),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x80(%rsp),%rdi
add    %ebx,%edi
add    $0x5,%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
cmp    $0x6,%edx
je     1c30 <cvt_tran_d2s_mat2pmat+0xb30>
mov    -0x60(%rsp),%rdi
movsd  (%rdi,%rbx,1),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x80(%rsp),%rdi
add    %ebx,%edi
add    $0x6,%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
cmp    $0x7,%edx
je     1c30 <cvt_tran_d2s_mat2pmat+0xb30>
movsd  (%r10,%rbx,1),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x80(%rsp),%rdi
add    %ebx,%edi
add    $0x7,%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
jmp    1c30 <cvt_tran_d2s_mat2pmat+0xb30>
add    $0x30,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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