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


x86 assembly (clang, -O0):
<cvt_d2s_mat2pmat>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
movl   $0x4,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    $0x4,%eax
sub    %edx,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jle    1155 <cvt_d2s_mat2pmat+0x55>
mov    -0x4(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    122a <cvt_d2s_mat2pmat+0x12a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11f5 <cvt_d2s_mat2pmat+0xf5>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    11e2 <cvt_d2s_mat2pmat+0xe2>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x2c(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1189 <cvt_d2s_mat2pmat+0x89>
jmp    11e7 <cvt_d2s_mat2pmat+0xe7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1176 <cvt_d2s_mat2pmat+0x76>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%ecx
mov    0x18(%rbp),%eax
sub    $0x1,%eax
shl    $0x2,%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    $0x3,%ecx
cmp    %ecx,%eax
jge    17d6 <cvt_d2s_mat2pmat+0x6d6>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1698 <cvt_d2s_mat2pmat+0x598>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x2,%ecx
add    $0x3,%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    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    1249 <cvt_d2s_mat2pmat+0x149>
jmp    169d <cvt_d2s_mat2pmat+0x59d>
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17c3 <cvt_d2s_mat2pmat+0x6c3>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%ecx
add    $0x3,%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    169d <cvt_d2s_mat2pmat+0x59d>
jmp    17c8 <cvt_d2s_mat2pmat+0x6c8>
mov    -0x28(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x28(%rbp)
jmp    1231 <cvt_d2s_mat2pmat+0x131>
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    188b <cvt_d2s_mat2pmat+0x78b>
mov    -0x34(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    $0x4,%eax
cmp    -0x38(%rbp),%eax
jge    1800 <cvt_d2s_mat2pmat+0x700>
movl   $0x4,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1886 <cvt_d2s_mat2pmat+0x786>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1873 <cvt_d2s_mat2pmat+0x773>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x2c(%rbp),%edx
shl    $0x2,%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    181a <cvt_d2s_mat2pmat+0x71a>
jmp    1878 <cvt_d2s_mat2pmat+0x778>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1807 <cvt_d2s_mat2pmat+0x707>
jmp    188b <cvt_d2s_mat2pmat+0x78b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvt_d2s_mat2pmat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %esi,%r14d
mov    0x40(%rsp),%ebp
mov    0x38(%rsp),%rcx
neg    %edx
and    $0x3,%edx
cmp    %edi,%edx
cmovg  %edi,%edx
sub    %edx,%edi
test   %edx,%edx
mov    %r14,-0x30(%rsp)
mov    %r9d,-0x5c(%rsp)
mov    %rdi,-0x8(%rsp)
jle    1387 <cvt_d2s_mat2pmat+0x287>
test   %r14d,%r14d
jle    1361 <cvt_d2s_mat2pmat+0x261>
movslq -0x5c(%rsp),%r10
mov    -0x30(%rsp),%eax
mov    %rax,-0x10(%rsp)
mov    %edx,%ebx
lea    -0x1(%rbx),%rsi
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x20(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x28(%rsp)
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,%rax
mov    %rdi,-0x38(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,-0x40(%rsp)
mov    %rbx,-0x48(%rsp)
neg    %rbx
lea    0x30(%r8),%rdi
lea    0x0(,%r10,8),%r13
mov    $0x4,%r11d
xor    %r9d,%r9d
mov    %r8,%r12
xor    %r15d,%r15d
mov    %r8,-0x58(%rsp)
mov    %r10,-0x18(%rsp)
mov    %rsi,-0x50(%rsp)
jmp    11e2 <cvt_d2s_mat2pmat+0xe2>
nopl   0x0(%rax)
add    $0x1,%r15
add    %r13,%rdi
add    $0x4,%r11
add    $0x4,%r9
add    %r13,%r12
cmp    -0x10(%rsp),%r15
mov    -0x50(%rsp),%rsi
je     1361 <cvt_d2s_mat2pmat+0x261>
mov    %r15,%r14
imul   %r10,%r14
lea    0x0(,%r15,4),%rbp
cmp    $0x4,%edx
jb     1290 <cvt_d2s_mat2pmat+0x190>
lea    0x0(,%r15,4),%eax
add    %esi,%eax
jb     1290 <cvt_d2s_mat2pmat+0x190>
mov    %rsi,%rax
shr    $0x20,%rax
mov    $0x0,%eax
jne    1292 <cvt_d2s_mat2pmat+0x192>
cmpq   $0x0,-0x28(%rsp)
je     130f <cvt_d2s_mat2pmat+0x20f>
mov    -0x40(%rsp),%r10
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rdi,%rsi,8),%xmm0
movupd -0x20(%rdi,%rsi,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
lea    (%r9,%rsi,1),%eax
and    $0xfffffffc,%eax
movupd %xmm0,(%rcx,%rax,4)
movupd -0x10(%rdi,%rsi,8),%xmm0
movupd (%rdi,%rsi,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
lea    (%r11,%rsi,1),%eax
and    $0xfffffffc,%eax
movupd %xmm0,(%rcx,%rax,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%r10
jne    1230 <cvt_d2s_mat2pmat+0x130>
jmp    1311 <cvt_d2s_mat2pmat+0x211>
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
mov    %rax,%rsi
testb  $0x1,-0x48(%rsp)
je     12ba <cvt_d2s_mat2pmat+0x1ba>
add    %rax,%r14
movsd  (%r8,%r14,8),%xmm0
cvtsd2ss %xmm0,%xmm0
add    %eax,%ebp
and    $0xfffffffc,%ebp
movss  %xmm0,(%rcx,%rbp,4)
mov    %rax,%rsi
or     $0x1,%rsi
not    %rax
cmp    %rbx,%rax
je     11c0 <cvt_d2s_mat2pmat+0xc0>
lea    0x1(%rsi),%rax
add    %r9,%rsi
nopl   (%rax)
movsd  -0x8(%r12,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    %esi,%ebp
movss  %xmm0,(%rcx,%rbp,4)
movsd  (%r12,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1(%rsi),%ebp
movss  %xmm0,(%rcx,%rbp,4)
lea    (%rbx,%rax,1),%rbp
add    $0x2,%rbp
add    $0x2,%rax
add    $0x2,%rsi
cmp    $0x1,%rbp
jne    12d0 <cvt_d2s_mat2pmat+0x1d0>
jmp    11c0 <cvt_d2s_mat2pmat+0xc0>
xor    %esi,%esi
testb  $0x1,-0x38(%rsp)
mov    -0x58(%rsp),%r8
mov    -0x18(%rsp),%r10
je     1349 <cvt_d2s_mat2pmat+0x249>
lea    (%rsi,%r14,1),%rax
movupd (%r8,%rax,8),%xmm0
movupd 0x10(%r8,%rax,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
add    %ebp,%esi
and    $0xfffffffc,%esi
movupd %xmm0,(%rcx,%rsi,4)
mov    -0x20(%rsp),%rsi
mov    %rsi,%rax
cmp    -0x48(%rsp),%rsi
je     11c0 <cvt_d2s_mat2pmat+0xc0>
jmp    1292 <cvt_d2s_mat2pmat+0x192>
movslq %edx,%rax
lea    (%r8,%rax,8),%r8
mov    0x40(%rsp),%ebp
lea    (%rdx,%rbp,4),%eax
add    $0xfffffffc,%eax
cltq
lea    (%rcx,%rax,4),%rcx
mov    -0x5c(%rsp),%r9d
mov    -0x30(%rsp),%r14
mov    -0x8(%rsp),%rdi
xor    %r13d,%r13d
cmp    $0x4,%edi
jl     1698 <cvt_d2s_mat2pmat+0x598>
lea    -0x3(%rdi),%eax
mov    %rax,-0x18(%rsp)
lea    -0x3(%r14),%edx
movslq %r9d,%rax
movslq %edx,%rdx
mov    %rdx,-0x48(%rsp)
movslq %ebp,%rdx
mov    %r14d,%esi
mov    %rsi,-0x40(%rsp)
mov    %rax,%rsi
shl    $0x5,%rsi
mov    %rsi,-0x10(%rsp)
lea    0x0(,%rbp,4),%esi
mov    %rsi,-0x20(%rsp)
lea    0x30(%rcx),%rbp
mov    %rdx,-0x38(%rsp)
shl    $0x4,%rdx
mov    %rdx,-0x28(%rsp)
lea    0x0(,%rax,8),%r9
mov    $0x3,%r12d
mov    $0x2,%r15d
mov    %r8,%rdx
mov    $0x1,%r10d
xor    %r8d,%r8d
mov    %rdx,-0x58(%rsp)
mov    %rdx,-0x50(%rsp)
xor    %r13d,%r13d
jmp    143b <cvt_d2s_mat2pmat+0x33b>
xchg   %ax,%ax
add    $0x4,%r13
addq   $0x20,-0x50(%rsp)
mov    -0x20(%rsp),%rdx
add    %rdx,%r8
add    -0x28(%rsp),%rbp
add    %edx,%r12d
add    %edx,%r15d
add    %edx,%r10d
cmp    -0x18(%rsp),%r13
jae    1685 <cvt_d2s_mat2pmat+0x585>
mov    $0x0,%r11d
cmp    $0x4,%r14d
jl     15e2 <cvt_d2s_mat2pmat+0x4e2>
mov    %r13,%rdi
xor    %r13d,%r13d
mov    -0x50(%rsp),%r14
xor    %r11d,%r11d
nopl   0x0(%rax)
movsd  (%r14),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp,%r13,4)
movsd  0x8(%r14),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1(%r8,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x10(%r14),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2(%r8,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x18(%r14),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x3(%r8,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  (%r14,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp,%r13,4)
movsd  0x8(%r14,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x5(%r8,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x10(%r14,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r14,%r9,1),%rsi
lea    0x6(%r8,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movsd  0x18(%r14,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x7(%r8,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
lea    (%rsi,%r9,1),%rdx
movsd  (%rsi,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x10(%rbp,%r13,4)
movsd  0x8(%rsi,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x9(%r8,%r13,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movsd  0x10(%rsi,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xa(%r8,%r13,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movsd  0x18(%rsi,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xb(%r8,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  (%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x0(%rbp,%r13,4)
movsd  0x8(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xd(%r8,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x10(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0xe(%r8,%r13,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x18(%rdx,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r8,%r13,1),%edx
add    $0xf,%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
add    $0x4,%r11
add    -0x10(%rsp),%r14
add    $0x10,%r13
cmp    -0x48(%rsp),%r11
jl     1460 <cvt_d2s_mat2pmat+0x360>
mov    -0x30(%rsp),%r14
mov    %rdi,%r13
cmp    %r14d,%r11d
jge    1410 <cvt_d2s_mat2pmat+0x310>
mov    %r13,%rsi
imul   -0x38(%rsp),%rsi
mov    %r11d,%edx
shl    $0x2,%r11d
mov    -0x40(%rsp),%rbx
sub    %rdx,%rbx
imul   %rax,%rdx
add    %r13,%rdx
mov    -0x58(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx),%xmm0
cvtsd2ss %xmm0,%xmm0
movslq %r11d,%r11
lea    (%rsi,%r11,1),%rdi
movss  %xmm0,(%rcx,%rdi,4)
movsd  0x8(%rdx),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r10,%r11,1),%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
movsd  0x10(%rdx),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r15,%r11,1),%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
movsd  0x18(%rdx),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    (%r12,%r11,1),%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
add    $0x4,%r11d
add    %r9,%rdx
add    $0xffffffffffffffff,%rbx
jne    1620 <cvt_d2s_mat2pmat+0x520>
jmp    1410 <cvt_d2s_mat2pmat+0x310>
mov    -0x5c(%rsp),%r9d
mov    -0x58(%rsp),%r8
mov    -0x8(%rsp),%rdi
mov    0x40(%rsp),%ebp
sub    %r13d,%edi
jle    1761 <cvt_d2s_mat2pmat+0x661>
test   %r14d,%r14d
jle    1761 <cvt_d2s_mat2pmat+0x661>
cmp    $0x4,%edi
mov    $0x4,%eax
cmovl  %edi,%eax
imul   %r13d,%ebp
cmp    $0x2,%eax
mov    $0x1,%edx
cmovge %eax,%edx
jmp    16e0 <cvt_d2s_mat2pmat+0x5e0>
cs nopw 0x0(%rax,%rax,1)
add    $0x4,%ebp
add    %r9d,%r13d
add    $0xffffffff,%r14d
je     1761 <cvt_d2s_mat2pmat+0x661>
test   %edi,%edi
jle    16d0 <cvt_d2s_mat2pmat+0x5d0>
movslq %r13d,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movslq %ebp,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x2,%eax
jl     16d0 <cvt_d2s_mat2pmat+0x5d0>
lea    0x1(%r13),%esi
movslq %esi,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1(%rbp),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x2,%edx
je     16d0 <cvt_d2s_mat2pmat+0x5d0>
lea    0x2(%r13),%esi
movslq %esi,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x2(%rbp),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x3,%edx
je     16d0 <cvt_d2s_mat2pmat+0x5d0>
lea    0x3(%r13),%esi
movslq %esi,%rsi
movsd  (%r8,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x3(%rbp),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
jmp    16d0 <cvt_d2s_mat2pmat+0x5d0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @cvt_d2s_mat2pmat(i32 %0, i32 %1, i32 %2, i32 %3, double* %4, i32 %5, float* %6, i32 %7) {
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca double*
%14 = alloca i32
%15 = alloca float*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
store i32 %0, i32* %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store i32 %3, i32* %12
store double* %4, double** %13
store i32 %5, i32* %14
store float* %6, float** %15
store i32 %7, i32* %16
store i32 4, i32* %17
%24 = load i32, i32* %11
%25 = srem i32 %24, 4
%26 = sub nsw i32 4, %25
%27 = srem i32 %26, 4
store i32 %27, i32* %21
%28 = load i32, i32* %21
%29 = load i32, i32* %9
%30 = icmp sgt i32 %28, %29
br i1 %30, label %31, label %33
31: ; preds = %8
%32 = load i32, i32* %9
store i32 %32, i32* %21
br label %33
33: ; preds = %31, %8
%34 = load i32, i32* %9
%35 = load i32, i32* %21
%36 = sub nsw i32 %34, %35
store i32 %36, i32* %22
store i32 0, i32* %19
%37 = load i32, i32* %21
%38 = icmp sgt i32 %37, 0
br i1 %38, label %39, label %93
39: ; preds = %33
store i32 0, i32* %20
br label %40
40: ; preds = %77, %39
%41 = load i32, i32* %20
%42 = load i32, i32* %10
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %80
44: ; preds = %40
store i32 0, i32* %18
br label %45
45: ; preds = %73, %44
%46 = load i32, i32* %18
%47 = load i32, i32* %21
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %76
49: ; preds = %45
%50 = load double*, double** %13
%51 = load i32, i32* %18
%52 = load i32, i32* %19
%53 = add nsw i32 %51, %52
%54 = load i32, i32* %20
%55 = load i32, i32* %14
%56 = mul nsw i32 %54, %55
%57 = add nsw i32 %53, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %50, i64 %58
%60 = load double, double* %59
%61 = fptrunc double %60 to float
%62 = load float*, float** %15
%63 = load i32, i32* %18
%64 = load i32, i32* %20
%65 = mul nsw i32 %64, 4
%66 = add nsw i32 %63, %65
%67 = load i32, i32* %19
%68 = load i32, i32* %16
%69 = mul nsw i32 %67, %68
%70 = add nsw i32 %66, %69
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %62, i64 %71
store float %61, float* %72
br label %73
73: ; preds = %49
%74 = load i32, i32* %18
%75 = add nsw i32 %74, 1
store i32 %75, i32* %18
br label %45
76: ; preds = %45
br label %77
77: ; preds = %76
%78 = load i32, i32* %20
%79 = add nsw i32 %78, 1
store i32 %79, i32* %20
br label %40
80: ; preds = %40
%81 = load i32, i32* %21
%82 = load double*, double** %13
%83 = sext i32 %81 to i64
%84 = getelementptr inbounds double, double* %82, i64 %83
store double* %84, double** %13
%85 = load i32, i32* %21
%86 = load i32, i32* %16
%87 = sub nsw i32 %86, 1
%88 = mul nsw i32 4, %87
%89 = add nsw i32 %85, %88
%90 = load float*, float** %15
%91 = sext i32 %89 to i64
%92 = getelementptr inbounds float, float* %90, i64 %91
store float* %92, float** %15
br label %93
93: ; preds = %80, %33
store i32 0, i32* %19
br label %94
94: ; preds = %579, %93
%95 = load i32, i32* %19
%96 = load i32, i32* %22
%97 = sub nsw i32 %96, 3
%98 = icmp slt i32 %95, %97
br i1 %98, label %99, label %582
99: ; preds = %94
store i32 0, i32* %20
br label %100
100: ; preds = %474, %99
%101 = load i32, i32* %20
%102 = load i32, i32* %10
%103 = sub nsw i32 %102, 3
%104 = icmp slt i32 %101, %103
br i1 %104, label %105, label %477
105: ; preds = %100
%106 = load double*, double** %13
%107 = load i32, i32* %19
%108 = add nsw i32 %107, 0
%109 = load i32, i32* %20
%110 = add nsw i32 %109, 0
%111 = load i32, i32* %14
%112 = mul nsw i32 %110, %111
%113 = add nsw i32 %108, %112
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %106, i64 %114
%116 = load double, double* %115
%117 = fptrunc double %116 to float
%118 = load float*, float** %15
%119 = load i32, i32* %20
%120 = add nsw i32 %119, 0
%121 = mul nsw i32 %120, 4
%122 = add nsw i32 0, %121
%123 = load i32, i32* %19
%124 = load i32, i32* %16
%125 = mul nsw i32 %123, %124
%126 = add nsw i32 %122, %125
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %118, i64 %127
store float %117, float* %128
%129 = load double*, double** %13
%130 = load i32, i32* %19
%131 = add nsw i32 %130, 1
%132 = load i32, i32* %20
%133 = add nsw i32 %132, 0
%134 = load i32, i32* %14
%135 = mul nsw i32 %133, %134
%136 = add nsw i32 %131, %135
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds double, double* %129, i64 %137
%139 = load double, double* %138
%140 = fptrunc double %139 to float
%141 = load float*, float** %15
%142 = load i32, i32* %20
%143 = add nsw i32 %142, 0
%144 = mul nsw i32 %143, 4
%145 = add nsw i32 1, %144
%146 = load i32, i32* %19
%147 = load i32, i32* %16
%148 = mul nsw i32 %146, %147
%149 = add nsw i32 %145, %148
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float, float* %141, i64 %150
store float %140, float* %151
%152 = load double*, double** %13
%153 = load i32, i32* %19
%154 = add nsw i32 %153, 2
%155 = load i32, i32* %20
%156 = add nsw i32 %155, 0
%157 = load i32, i32* %14
%158 = mul nsw i32 %156, %157
%159 = add nsw i32 %154, %158
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds double, double* %152, i64 %160
%162 = load double, double* %161
%163 = fptrunc double %162 to float
%164 = load float*, float** %15
%165 = load i32, i32* %20
%166 = add nsw i32 %165, 0
%167 = mul nsw i32 %166, 4
%168 = add nsw i32 2, %167
%169 = load i32, i32* %19
%170 = load i32, i32* %16
%171 = mul nsw i32 %169, %170
%172 = add nsw i32 %168, %171
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %164, i64 %173
store float %163, float* %174
%175 = load double*, double** %13
%176 = load i32, i32* %19
%177 = add nsw i32 %176, 3
%178 = load i32, i32* %20
%179 = add nsw i32 %178, 0
%180 = load i32, i32* %14
%181 = mul nsw i32 %179, %180
%182 = add nsw i32 %177, %181
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %175, i64 %183
%185 = load double, double* %184
%186 = fptrunc double %185 to float
%187 = load float*, float** %15
%188 = load i32, i32* %20
%189 = add nsw i32 %188, 0
%190 = mul nsw i32 %189, 4
%191 = add nsw i32 3, %190
%192 = load i32, i32* %19
%193 = load i32, i32* %16
%194 = mul nsw i32 %192, %193
%195 = add nsw i32 %191, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %187, i64 %196
store float %186, float* %197
%198 = load double*, double** %13
%199 = load i32, i32* %19
%200 = add nsw i32 %199, 0
%201 = load i32, i32* %20
%202 = add nsw i32 %201, 1
%203 = load i32, i32* %14
%204 = mul nsw i32 %202, %203
%205 = add nsw i32 %200, %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds double, double* %198, i64 %206
%208 = load double, double* %207
%209 = fptrunc double %208 to float
%210 = load float*, float** %15
%211 = load i32, i32* %20
%212 = add nsw i32 %211, 1
%213 = mul nsw i32 %212, 4
%214 = add nsw i32 0, %213
%215 = load i32, i32* %19
%216 = load i32, i32* %16
%217 = mul nsw i32 %215, %216
%218 = add nsw i32 %214, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float, float* %210, i64 %219
store float %209, float* %220
%221 = load double*, double** %13
%222 = load i32, i32* %19
%223 = add nsw i32 %222, 1
%224 = load i32, i32* %20
%225 = add nsw i32 %224, 1
%226 = load i32, i32* %14
%227 = mul nsw i32 %225, %226
%228 = add nsw i32 %223, %227
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds double, double* %221, i64 %229
%231 = load double, double* %230
%232 = fptrunc double %231 to float
%233 = load float*, float** %15
%234 = load i32, i32* %20
%235 = add nsw i32 %234, 1
%236 = mul nsw i32 %235, 4
%237 = add nsw i32 1, %236
%238 = load i32, i32* %19
%239 = load i32, i32* %16
%240 = mul nsw i32 %238, %239
%241 = add nsw i32 %237, %240
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds float, float* %233, i64 %242
store float %232, float* %243
%244 = load double*, double** %13
%245 = load i32, i32* %19
%246 = add nsw i32 %245, 2
%247 = load i32, i32* %20
%248 = add nsw i32 %247, 1
%249 = load i32, i32* %14
%250 = mul nsw i32 %248, %249
%251 = add nsw i32 %246, %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %244, i64 %252
%254 = load double, double* %253
%255 = fptrunc double %254 to float
%256 = load float*, float** %15
%257 = load i32, i32* %20
%258 = add nsw i32 %257, 1
%259 = mul nsw i32 %258, 4
%260 = add nsw i32 2, %259
%261 = load i32, i32* %19
%262 = load i32, i32* %16
%263 = mul nsw i32 %261, %262
%264 = add nsw i32 %260, %263
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds float, float* %256, i64 %265
store float %255, float* %266
%267 = load double*, double** %13
%268 = load i32, i32* %19
%269 = add nsw i32 %268, 3
%270 = load i32, i32* %20
%271 = add nsw i32 %270, 1
%272 = load i32, i32* %14
%273 = mul nsw i32 %271, %272
%274 = add nsw i32 %269, %273
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %267, i64 %275
%277 = load double, double* %276
%278 = fptrunc double %277 to float
%279 = load float*, float** %15
%280 = load i32, i32* %20
%281 = add nsw i32 %280, 1
%282 = mul nsw i32 %281, 4
%283 = add nsw i32 3, %282
%284 = load i32, i32* %19
%285 = load i32, i32* %16
%286 = mul nsw i32 %284, %285
%287 = add nsw i32 %283, %286
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds float, float* %279, i64 %288
store float %278, float* %289
%290 = load double*, double** %13
%291 = load i32, i32* %19
%292 = add nsw i32 %291, 0
%293 = load i32, i32* %20
%294 = add nsw i32 %293, 2
%295 = load i32, i32* %14
%296 = mul nsw i32 %294, %295
%297 = add nsw i32 %292, %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %290, i64 %298
%300 = load double, double* %299
%301 = fptrunc double %300 to float
%302 = load float*, float** %15
%303 = load i32, i32* %20
%304 = add nsw i32 %303, 2
%305 = mul nsw i32 %304, 4
%306 = add nsw i32 0, %305
%307 = load i32, i32* %19
%308 = load i32, i32* %16
%309 = mul nsw i32 %307, %308
%310 = add nsw i32 %306, %309
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds float, float* %302, i64 %311
store float %301, float* %312
%313 = load double*, double** %13
%314 = load i32, i32* %19
%315 = add nsw i32 %314, 1
%316 = load i32, i32* %20
%317 = add nsw i32 %316, 2
%318 = load i32, i32* %14
%319 = mul nsw i32 %317, %318
%320 = add nsw i32 %315, %319
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds double, double* %313, i64 %321
%323 = load double, double* %322
%324 = fptrunc double %323 to float
%325 = load float*, float** %15
%326 = load i32, i32* %20
%327 = add nsw i32 %326, 2
%328 = mul nsw i32 %327, 4
%329 = add nsw i32 1, %328
%330 = load i32, i32* %19
%331 = load i32, i32* %16
%332 = mul nsw i32 %330, %331
%333 = add nsw i32 %329, %332
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds float, float* %325, i64 %334
store float %324, float* %335
%336 = load double*, double** %13
%337 = load i32, i32* %19
%338 = add nsw i32 %337, 2
%339 = load i32, i32* %20
%340 = add nsw i32 %339, 2
%341 = load i32, i32* %14
%342 = mul nsw i32 %340, %341
%343 = add nsw i32 %338, %342
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds double, double* %336, i64 %344
%346 = load double, double* %345
%347 = fptrunc double %346 to float
%348 = load float*, float** %15
%349 = load i32, i32* %20
%350 = add nsw i32 %349, 2
%351 = mul nsw i32 %350, 4
%352 = add nsw i32 2, %351
%353 = load i32, i32* %19
%354 = load i32, i32* %16
%355 = mul nsw i32 %353, %354
%356 = add nsw i32 %352, %355
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds float, float* %348, i64 %357
store float %347, float* %358
%359 = load double*, double** %13
%360 = load i32, i32* %19
%361 = add nsw i32 %360, 3
%362 = load i32, i32* %20
%363 = add nsw i32 %362, 2
%364 = load i32, i32* %14
%365 = mul nsw i32 %363, %364
%366 = add nsw i32 %361, %365
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds double, double* %359, i64 %367
%369 = load double, double* %368
%370 = fptrunc double %369 to float
%371 = load float*, float** %15
%372 = load i32, i32* %20
%373 = add nsw i32 %372, 2
%374 = mul nsw i32 %373, 4
%375 = add nsw i32 3, %374
%376 = load i32, i32* %19
%377 = load i32, i32* %16
%378 = mul nsw i32 %376, %377
%379 = add nsw i32 %375, %378
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds float, float* %371, i64 %380
store float %370, float* %381
%382 = load double*, double** %13
%383 = load i32, i32* %19
%384 = add nsw i32 %383, 0
%385 = load i32, i32* %20
%386 = add nsw i32 %385, 3
%387 = load i32, i32* %14
%388 = mul nsw i32 %386, %387
%389 = add nsw i32 %384, %388
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds double, double* %382, i64 %390
%392 = load double, double* %391
%393 = fptrunc double %392 to float
%394 = load float*, float** %15
%395 = load i32, i32* %20
%396 = add nsw i32 %395, 3
%397 = mul nsw i32 %396, 4
%398 = add nsw i32 0, %397
%399 = load i32, i32* %19
%400 = load i32, i32* %16
%401 = mul nsw i32 %399, %400
%402 = add nsw i32 %398, %401
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds float, float* %394, i64 %403
store float %393, float* %404
%405 = load double*, double** %13
%406 = load i32, i32* %19
%407 = add nsw i32 %406, 1
%408 = load i32, i32* %20
%409 = add nsw i32 %408, 3
%410 = load i32, i32* %14
%411 = mul nsw i32 %409, %410
%412 = add nsw i32 %407, %411
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds double, double* %405, i64 %413
%415 = load double, double* %414
%416 = fptrunc double %415 to float
%417 = load float*, float** %15
%418 = load i32, i32* %20
%419 = add nsw i32 %418, 3
%420 = mul nsw i32 %419, 4
%421 = add nsw i32 1, %420
%422 = load i32, i32* %19
%423 = load i32, i32* %16
%424 = mul nsw i32 %422, %423
%425 = add nsw i32 %421, %424
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %417, i64 %426
store float %416, float* %427
%428 = load double*, double** %13
%429 = load i32, i32* %19
%430 = add nsw i32 %429, 2
%431 = load i32, i32* %20
%432 = add nsw i32 %431, 3
%433 = load i32, i32* %14
%434 = mul nsw i32 %432, %433
%435 = add nsw i32 %430, %434
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds double, double* %428, i64 %436
%438 = load double, double* %437
%439 = fptrunc double %438 to float
%440 = load float*, float** %15
%441 = load i32, i32* %20
%442 = add nsw i32 %441, 3
%443 = mul nsw i32 %442, 4
%444 = add nsw i32 2, %443
%445 = load i32, i32* %19
%446 = load i32, i32* %16
%447 = mul nsw i32 %445, %446
%448 = add nsw i32 %444, %447
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds float, float* %440, i64 %449
store float %439, float* %450
%451 = load double*, double** %13
%452 = load i32, i32* %19
%453 = add nsw i32 %452, 3
%454 = load i32, i32* %20
%455 = add nsw i32 %454, 3
%456 = load i32, i32* %14
%457 = mul nsw i32 %455, %456
%458 = add nsw i32 %453, %457
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds double, double* %451, i64 %459
%461 = load double, double* %460
%462 = fptrunc double %461 to float
%463 = load float*, float** %15
%464 = load i32, i32* %20
%465 = add nsw i32 %464, 3
%466 = mul nsw i32 %465, 4
%467 = add nsw i32 3, %466
%468 = load i32, i32* %19
%469 = load i32, i32* %16
%470 = mul nsw i32 %468, %469
%471 = add nsw i32 %467, %470
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds float, float* %463, i64 %472
store float %462, float* %473
br label %474
474: ; preds = %105
%475 = load i32, i32* %20
%476 = add nsw i32 %475, 4
store i32 %476, i32* %20
br label %100
477: ; preds = %100
br label %478
478: ; preds = %575, %477
%479 = load i32, i32* %20
%480 = load i32, i32* %10
%481 = icmp slt i32 %479, %480
br i1 %481, label %482, label %578
482: ; preds = %478
%483 = load double*, double** %13
%484 = load i32, i32* %19
%485 = add nsw i32 %484, 0
%486 = load i32, i32* %20
%487 = add nsw i32 %486, 0
%488 = load i32, i32* %14
%489 = mul nsw i32 %487, %488
%490 = add nsw i32 %485, %489
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds double, double* %483, i64 %491
%493 = load double, double* %492
%494 = fptrunc double %493 to float
%495 = load float*, float** %15
%496 = load i32, i32* %20
%497 = add nsw i32 %496, 0
%498 = mul nsw i32 %497, 4
%499 = add nsw i32 0, %498
%500 = load i32, i32* %19
%501 = load i32, i32* %16
%502 = mul nsw i32 %500, %501
%503 = add nsw i32 %499, %502
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds float, float* %495, i64 %504
store float %494, float* %505
%506 = load double*, double** %13
%507 = load i32, i32* %19
%508 = add nsw i32 %507, 1
%509 = load i32, i32* %20
%510 = add nsw i32 %509, 0
%511 = load i32, i32* %14
%512 = mul nsw i32 %510, %511
%513 = add nsw i32 %508, %512
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds double, double* %506, i64 %514
%516 = load double, double* %515
%517 = fptrunc double %516 to float
%518 = load float*, float** %15
%519 = load i32, i32* %20
%520 = add nsw i32 %519, 0
%521 = mul nsw i32 %520, 4
%522 = add nsw i32 1, %521
%523 = load i32, i32* %19
%524 = load i32, i32* %16
%525 = mul nsw i32 %523, %524
%526 = add nsw i32 %522, %525
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds float, float* %518, i64 %527
store float %517, float* %528
%529 = load double*, double** %13
%530 = load i32, i32* %19
%531 = add nsw i32 %530, 2
%532 = load i32, i32* %20
%533 = add nsw i32 %532, 0
%534 = load i32, i32* %14
%535 = mul nsw i32 %533, %534
%536 = add nsw i32 %531, %535
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds double, double* %529, i64 %537
%539 = load double, double* %538
%540 = fptrunc double %539 to float
%541 = load float*, float** %15
%542 = load i32, i32* %20
%543 = add nsw i32 %542, 0
%544 = mul nsw i32 %543, 4
%545 = add nsw i32 2, %544
%546 = load i32, i32* %19
%547 = load i32, i32* %16
%548 = mul nsw i32 %546, %547
%549 = add nsw i32 %545, %548
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds float, float* %541, i64 %550
store float %540, float* %551
%552 = load double*, double** %13
%553 = load i32, i32* %19
%554 = add nsw i32 %553, 3
%555 = load i32, i32* %20
%556 = add nsw i32 %555, 0
%557 = load i32, i32* %14
%558 = mul nsw i32 %556, %557
%559 = add nsw i32 %554, %558
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds double, double* %552, i64 %560
%562 = load double, double* %561
%563 = fptrunc double %562 to float
%564 = load float*, float** %15
%565 = load i32, i32* %20
%566 = add nsw i32 %565, 0
%567 = mul nsw i32 %566, 4
%568 = add nsw i32 3, %567
%569 = load i32, i32* %19
%570 = load i32, i32* %16
%571 = mul nsw i32 %569, %570
%572 = add nsw i32 %568, %571
%573 = sext i32 %572 to i64
%574 = getelementptr inbounds float, float* %564, i64 %573
store float %563, float* %574
br label %575
575: ; preds = %482
%576 = load i32, i32* %20
%577 = add nsw i32 %576, 1
store i32 %577, i32* %20
br label %478
578: ; preds = %478
br label %579
579: ; preds = %578
%580 = load i32, i32* %19
%581 = add nsw i32 %580, 4
store i32 %581, i32* %19
br label %94
582: ; preds = %94
%583 = load i32, i32* %19
%584 = load i32, i32* %22
%585 = icmp slt i32 %583, %584
br i1 %585, label %586, label %635
586: ; preds = %582
%587 = load i32, i32* %22
%588 = load i32, i32* %19
%589 = sub nsw i32 %587, %588
store i32 %589, i32* %23
%590 = load i32, i32* %23
%591 = icmp slt i32 4, %590
br i1 %591, label %592, label %593
592: ; preds = %586
store i32 4, i32* %23
br label %593
593: ; preds = %592, %586
store i32 0, i32* %20
br label %594
594: ; preds = %631, %593
%595 = load i32, i32* %20
%596 = load i32, i32* %10
%597 = icmp slt i32 %595, %596
br i1 %597, label %598, label %634
598: ; preds = %594
store i32 0, i32* %18
br label %599
599: ; preds = %627, %598
%600 = load i32, i32* %18
%601 = load i32, i32* %23
%602 = icmp slt i32 %600, %601
br i1 %602, label %603, label %630
603: ; preds = %599
%604 = load double*, double** %13
%605 = load i32, i32* %18
%606 = load i32, i32* %19
%607 = add nsw i32 %605, %606
%608 = load i32, i32* %20
%609 = load i32, i32* %14
%610 = mul nsw i32 %608, %609
%611 = add nsw i32 %607, %610
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds double, double* %604, i64 %612
%614 = load double, double* %613
%615 = fptrunc double %614 to float
%616 = load float*, float** %15
%617 = load i32, i32* %18
%618 = load i32, i32* %20
%619 = mul nsw i32 %618, 4
%620 = add nsw i32 %617, %619
%621 = load i32, i32* %19
%622 = load i32, i32* %16
%623 = mul nsw i32 %621, %622
%624 = add nsw i32 %620, %623
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds float, float* %616, i64 %625
store float %615, float* %626
br label %627
627: ; preds = %603
%628 = load i32, i32* %18
%629 = add nsw i32 %628, 1
store i32 %629, i32* %18
br label %599
630: ; preds = %599
br label %631
631: ; preds = %630
%632 = load i32, i32* %20
%633 = add nsw i32 %632, 1
store i32 %633, i32* %20
br label %594
634: ; preds = %594
br label %635
635: ; preds = %634, %582
ret void
}

LLVM IR (-O2):
define void @cvt_d2s_mat2pmat(i32 %0, i32 %1, i32 %2, i32 %3, double* %4, i32 %5, float* writeonly %6, i32 %7) {
%9 = sub i32 0, %2
%10 = and i32 %9, 3
%11 = icmp sgt i32 %10, %0
%12 = select i1 %11, i32 %0, i32 %10
%13 = sub nsw i32 %0, %12
%14 = icmp sgt i32 %12, 0
br i1 %14, label %15, label %150
15: ; preds = %8
%16 = icmp sgt i32 %1, 0
br i1 %16, label %17, label %142
17: ; preds = %15
%18 = sext i32 %5 to i64
%19 = zext i32 %1 to i64
%20 = zext i32 %12 to i64
%21 = add nsw i64 %20, -1
%22 = and i64 %20, 4294967292
%23 = add nsw i64 %22, -4
%24 = lshr exact i64 %23, 2
%25 = add nuw nsw i64 %24, 1
%26 = icmp ult i32 %12, 4
%27 = trunc i64 %21 to i32
%28 = icmp ugt i64 %21, 4294967295
%29 = and i64 %20, 4294967292
%30 = and i64 %25, 1
%31 = icmp eq i64 %23, 0
%32 = and i64 %25, 9223372036854775806
%33 = icmp eq i64 %30, 0
%34 = icmp eq i64 %29, %20
%35 = and i64 %20, 1
%36 = icmp eq i64 %35, 0
%37 = sub nsw i64 0, %20
br label %38
38: ; preds = %139, %17
%39 = phi i64 [ 0, %17 ], [ %140, %139 ]
%40 = mul nsw i64 %39, %18
%41 = shl i64 %39, 2
br i1 %26, label %105, label %42
42: ; preds = %38
%43 = trunc i64 %39 to i32
%44 = shl i32 %43, 2
%45 = xor i32 %44, -1
%46 = icmp ult i32 %45, %27
%47 = or i1 %46, %28
br i1 %47, label %105, label %48
48: ; preds = %42
br i1 %31, label %86, label %49
49: ; preds = %48, %49
%50 = phi i64 [ %83, %49 ], [ 0, %48 ]
%51 = phi i64 [ %84, %49 ], [ 0, %48 ]
%52 = add nsw i64 %50, %40
%53 = getelementptr inbounds double, double* %4, i64 %52
%54 = bitcast double* %53 to <2 x double>*
%55 = load <2 x double>, <2 x double>* %54
%56 = getelementptr inbounds double, double* %53, i64 2
%57 = bitcast double* %56 to <2 x double>*
%58 = load <2 x double>, <2 x double>* %57
%59 = fptrunc <2 x double> %55 to <2 x float>
%60 = fptrunc <2 x double> %58 to <2 x float>
%61 = add i64 %50, %41
%62 = and i64 %61, 4294967292
%63 = getelementptr inbounds float, float* %6, i64 %62
%64 = bitcast float* %63 to <2 x float>*
store <2 x float> %59, <2 x float>* %64
%65 = getelementptr inbounds float, float* %63, i64 2
%66 = bitcast float* %65 to <2 x float>*
store <2 x float> %60, <2 x float>* %66
%67 = or i64 %50, 4
%68 = add nsw i64 %67, %40
%69 = getelementptr inbounds double, double* %4, i64 %68
%70 = bitcast double* %69 to <2 x double>*
%71 = load <2 x double>, <2 x double>* %70
%72 = getelementptr inbounds double, double* %69, i64 2
%73 = bitcast double* %72 to <2 x double>*
%74 = load <2 x double>, <2 x double>* %73
%75 = fptrunc <2 x double> %71 to <2 x float>
%76 = fptrunc <2 x double> %74 to <2 x float>
%77 = add i64 %67, %41
%78 = and i64 %77, 4294967292
%79 = getelementptr inbounds float, float* %6, i64 %78
%80 = bitcast float* %79 to <2 x float>*
store <2 x float> %75, <2 x float>* %80
%81 = getelementptr inbounds float, float* %79, i64 2
%82 = bitcast float* %81 to <2 x float>*
store <2 x float> %76, <2 x float>* %82
%83 = add nuw i64 %50, 8
%84 = add i64 %51, 2
%85 = icmp eq i64 %84, %32
br i1 %85, label %86, label %49
86: ; preds = %49, %48
%87 = phi i64 [ 0, %48 ], [ %83, %49 ]
br i1 %33, label %104, label %88
88: ; preds = %86
%89 = add nsw i64 %87, %40
%90 = getelementptr inbounds double, double* %4, i64 %89
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = getelementptr inbounds double, double* %90, i64 2
%94 = bitcast double* %93 to <2 x double>*
%95 = load <2 x double>, <2 x double>* %94
%96 = fptrunc <2 x double> %92 to <2 x float>
%97 = fptrunc <2 x double> %95 to <2 x float>
%98 = add i64 %87, %41
%99 = and i64 %98, 4294967292
%100 = getelementptr inbounds float, float* %6, i64 %99
%101 = bitcast float* %100 to <2 x float>*
store <2 x float> %96, <2 x float>* %101
%102 = getelementptr inbounds float, float* %100, i64 2
%103 = bitcast float* %102 to <2 x float>*
store <2 x float> %97, <2 x float>* %103
br label %104
104: ; preds = %86, %88
br i1 %34, label %139, label %105
105: ; preds = %42, %38, %104
%106 = phi i64 [ 0, %42 ], [ 0, %38 ], [ %29, %104 ]
%107 = xor i64 %106, -1
br i1 %36, label %117, label %108
108: ; preds = %105
%109 = add nsw i64 %106, %40
%110 = getelementptr inbounds double, double* %4, i64 %109
%111 = load double, double* %110
%112 = fptrunc double %111 to float
%113 = add i64 %106, %41
%114 = and i64 %113, 4294967292
%115 = getelementptr inbounds float, float* %6, i64 %114
store float %112, float* %115
%116 = or i64 %106, 1
br label %117
117: ; preds = %108, %105
%118 = phi i64 [ %106, %105 ], [ %116, %108 ]
%119 = icmp eq i64 %107, %37
br i1 %119, label %139, label %120
120: ; preds = %117, %120
%121 = phi i64 [ %137, %120 ], [ %118, %117 ]
%122 = add nsw i64 %121, %40
%123 = getelementptr inbounds double, double* %4, i64 %122
%124 = load double, double* %123
%125 = fptrunc double %124 to float
%126 = add i64 %121, %41
%127 = and i64 %126, 4294967295
%128 = getelementptr inbounds float, float* %6, i64 %127
store float %125, float* %128
%129 = add nuw nsw i64 %121, 1
%130 = add nsw i64 %129, %40
%131 = getelementptr inbounds double, double* %4, i64 %130
%132 = load double, double* %131
%133 = fptrunc double %132 to float
%134 = add i64 %129, %41
%135 = and i64 %134, 4294967295
%136 = getelementptr inbounds float, float* %6, i64 %135
store float %133, float* %136
%137 = add nuw nsw i64 %121, 2
%138 = icmp eq i64 %137, %20
br i1 %138, label %139, label %120
139: ; preds = %117, %120, %104
%140 = add nuw nsw i64 %39, 1
%141 = icmp eq i64 %140, %19
br i1 %141, label %142, label %38
142: ; preds = %139, %15
%143 = sext i32 %12 to i64
%144 = getelementptr inbounds double, double* %4, i64 %143
%145 = shl i32 %7, 2
%146 = add i32 %12, -4
%147 = add i32 %146, %145
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds float, float* %6, i64 %148
br label %150
150: ; preds = %142, %8
%151 = phi float* [ %149, %142 ], [ %6, %8 ]
%152 = phi double* [ %144, %142 ], [ %4, %8 ]
%153 = icmp sgt i32 %13, 3
br i1 %153, label %154, label %356
154: ; preds = %150
%155 = add nsw i32 %13, -3
%156 = add nsw i32 %1, -3
%157 = icmp sgt i32 %1, 3
%158 = sext i32 %5 to i64
%159 = sext i32 %156 to i64
%160 = sext i32 %7 to i64
%161 = zext i32 %155 to i64
%162 = zext i32 %1 to i64
br label %163
163: ; preds = %154, %351
%164 = phi i64 [ 0, %154 ], [ %352, %351 ]
br i1 %157, label %165, label %176
165: ; preds = %163
%166 = mul nsw i64 %164, %160
%167 = or i64 %164, 1
%168 = trunc i64 %166 to i32
%169 = or i32 %168, 1
%170 = or i64 %164, 2
%171 = or i32 %168, 2
%172 = or i64 %164, 3
%173 = or i32 %168, 3
br label %189
174: ; preds = %189
%175 = trunc i64 %314 to i32
br label %176
176: ; preds = %174, %163
%177 = phi i32 [ 0, %163 ], [ %175, %174 ]
%178 = icmp slt i32 %177, %1
br i1 %178, label %179, label %351
179: ; preds = %176
%180 = mul nsw i64 %164, %160
%181 = or i64 %164, 1
%182 = trunc i64 %180 to i32
%183 = or i32 %182, 1
%184 = or i64 %164, 2
%185 = or i32 %182, 2
%186 = or i64 %164, 3
%187 = or i32 %182, 3
%188 = zext i32 %177 to i64
br label %316
189: ; preds = %165, %189
%190 = phi i64 [ 0, %165 ], [ %314, %189 ]
%191 = mul nsw i64 %190, %158
%192 = add nsw i64 %191, %164
%193 = getelementptr inbounds double, double* %152, i64 %192
%194 = load double, double* %193
%195 = fptrunc double %194 to float
%196 = shl nsw i64 %190, 2
%197 = add nsw i64 %196, %166
%198 = getelementptr inbounds float, float* %151, i64 %197
store float %195, float* %198
%199 = add nsw i64 %191, %167
%200 = getelementptr inbounds double, double* %152, i64 %199
%201 = load double, double* %200
%202 = fptrunc double %201 to float
%203 = trunc i64 %196 to i32
%204 = add i32 %169, %203
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds float, float* %151, i64 %205
store float %202, float* %206
%207 = add nsw i64 %191, %170
%208 = getelementptr inbounds double, double* %152, i64 %207
%209 = load double, double* %208
%210 = fptrunc double %209 to float
%211 = add i32 %171, %203
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds float, float* %151, i64 %212
store float %210, float* %213
%214 = add nsw i64 %191, %172
%215 = getelementptr inbounds double, double* %152, i64 %214
%216 = load double, double* %215
%217 = fptrunc double %216 to float
%218 = add i32 %173, %203
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float, float* %151, i64 %219
store float %217, float* %220
%221 = or i64 %190, 1
%222 = mul nsw i64 %221, %158
%223 = add nsw i64 %222, %164
%224 = getelementptr inbounds double, double* %152, i64 %223
%225 = load double, double* %224
%226 = fptrunc double %225 to float
%227 = shl nsw i64 %221, 2
%228 = add nsw i64 %227, %166
%229 = getelementptr inbounds float, float* %151, i64 %228
store float %226, float* %229
%230 = add nsw i64 %222, %167
%231 = getelementptr inbounds double, double* %152, i64 %230
%232 = load double, double* %231
%233 = fptrunc double %232 to float
%234 = trunc i64 %227 to i32
%235 = add i32 %169, %234
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %151, i64 %236
store float %233, float* %237
%238 = add nsw i64 %222, %170
%239 = getelementptr inbounds double, double* %152, i64 %238
%240 = load double, double* %239
%241 = fptrunc double %240 to float
%242 = add i32 %171, %234
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds float, float* %151, i64 %243
store float %241, float* %244
%245 = add nsw i64 %222, %172
%246 = getelementptr inbounds double, double* %152, i64 %245
%247 = load double, double* %246
%248 = fptrunc double %247 to float
%249 = add i32 %173, %234
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds float, float* %151, i64 %250
store float %248, float* %251
%252 = or i64 %190, 2
%253 = mul nsw i64 %252, %158
%254 = add nsw i64 %253, %164
%255 = getelementptr inbounds double, double* %152, i64 %254
%256 = load double, double* %255
%257 = fptrunc double %256 to float
%258 = shl nsw i64 %252, 2
%259 = add nsw i64 %258, %166
%260 = getelementptr inbounds float, float* %151, i64 %259
store float %257, float* %260
%261 = add nsw i64 %253, %167
%262 = getelementptr inbounds double, double* %152, i64 %261
%263 = load double, double* %262
%264 = fptrunc double %263 to float
%265 = trunc i64 %258 to i32
%266 = add i32 %169, %265
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds float, float* %151, i64 %267
store float %264, float* %268
%269 = add nsw i64 %253, %170
%270 = getelementptr inbounds double, double* %152, i64 %269
%271 = load double, double* %270
%272 = fptrunc double %271 to float
%273 = add i32 %171, %265
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds float, float* %151, i64 %274
store float %272, float* %275
%276 = add nsw i64 %253, %172
%277 = getelementptr inbounds double, double* %152, i64 %276
%278 = load double, double* %277
%279 = fptrunc double %278 to float
%280 = add i32 %173, %265
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds float, float* %151, i64 %281
store float %279, float* %282
%283 = or i64 %190, 3
%284 = mul nsw i64 %283, %158
%285 = add nsw i64 %284, %164
%286 = getelementptr inbounds double, double* %152, i64 %285
%287 = load double, double* %286
%288 = fptrunc double %287 to float
%289 = shl nsw i64 %283, 2
%290 = add nsw i64 %289, %166
%291 = getelementptr inbounds float, float* %151, i64 %290
store float %288, float* %291
%292 = add nsw i64 %284, %167
%293 = getelementptr inbounds double, double* %152, i64 %292
%294 = load double, double* %293
%295 = fptrunc double %294 to float
%296 = trunc i64 %289 to i32
%297 = add i32 %169, %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds float, float* %151, i64 %298
store float %295, float* %299
%300 = add nsw i64 %284, %170
%301 = getelementptr inbounds double, double* %152, i64 %300
%302 = load double, double* %301
%303 = fptrunc double %302 to float
%304 = add i32 %171, %296
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds float, float* %151, i64 %305
store float %303, float* %306
%307 = add nsw i64 %284, %172
%308 = getelementptr inbounds double, double* %152, i64 %307
%309 = load double, double* %308
%310 = fptrunc double %309 to float
%311 = add i32 %173, %296
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds float, float* %151, i64 %312
store float %310, float* %313
%314 = add nuw nsw i64 %190, 4
%315 = icmp slt i64 %314, %159
br i1 %315, label %189, label %174
316: ; preds = %179, %316
%317 = phi i64 [ %188, %179 ], [ %349, %316 ]
%318 = trunc i64 %317 to i32
%319 = mul nsw i64 %317, %158
%320 = add nsw i64 %319, %164
%321 = getelementptr inbounds double, double* %152, i64 %320
%322 = load double, double* %321
%323 = fptrunc double %322 to float
%324 = shl nsw i32 %318, 2
%325 = sext i32 %324 to i64
%326 = add nsw i64 %180, %325
%327 = getelementptr inbounds float, float* %151, i64 %326
store float %323, float* %327
%328 = add nsw i64 %181, %319
%329 = getelementptr inbounds double, double* %152, i64 %328
%330 = load double, double* %329
%331 = fptrunc double %330 to float
%332 = add i32 %183, %324
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds float, float* %151, i64 %333
store float %331, float* %334
%335 = add nsw i64 %184, %319
%336 = getelementptr inbounds double, double* %152, i64 %335
%337 = load double, double* %336
%338 = fptrunc double %337 to float
%339 = add i32 %185, %324
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds float, float* %151, i64 %340
store float %338, float* %341
%342 = add nsw i64 %186, %319
%343 = getelementptr inbounds double, double* %152, i64 %342
%344 = load double, double* %343
%345 = fptrunc double %344 to float
%346 = add i32 %187, %324
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds float, float* %151, i64 %347
store float %345, float* %348
%349 = add nuw nsw i64 %317, 1
%350 = icmp eq i64 %349, %162
br i1 %350, label %351, label %316
351: ; preds = %316, %176
%352 = add nuw nsw i64 %164, 4
%353 = icmp ult i64 %352, %161
br i1 %353, label %163, label %354
354: ; preds = %351
%355 = trunc i64 %352 to i32
br label %356
356: ; preds = %354, %150
%357 = phi i32 [ 0, %150 ], [ %355, %354 ]
%358 = icmp sgt i32 %13, %357
br i1 %358, label %359, label %414
359: ; preds = %356
%360 = sub nsw i32 %13, %357
%361 = icmp sgt i32 %1, 0
br i1 %361, label %362, label %414
362: ; preds = %359
%363 = icmp slt i32 %360, 4
%364 = select i1 %363, i32 %360, i32 4
%365 = icmp sgt i32 %360, 0
%366 = mul nsw i32 %357, %7
%367 = call i32 @llvm.smax.i32(i32 %364, i32 1)
%368 = icmp slt i32 %364, 2
%369 = icmp eq i32 %367, 2
%370 = icmp eq i32 %367, 3
br label %371
371: ; preds = %362, %411
%372 = phi i32 [ 0, %362 ], [ %412, %411 ]
br i1 %365, label %373, label %411
373: ; preds = %371
%374 = mul nsw i32 %372, %5
%375 = add i32 %374, %357
%376 = shl nsw i32 %372, 2
%377 = add i32 %376, %366
%378 = sext i32 %375 to i64
%379 = getelementptr inbounds double, double* %152, i64 %378
%380 = load double, double* %379
%381 = fptrunc double %380 to float
%382 = sext i32 %377 to i64
%383 = getelementptr inbounds float, float* %151, i64 %382
store float %381, float* %383
br i1 %368, label %411, label %384
384: ; preds = %373
%385 = add i32 %375, 1
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double, double* %152, i64 %386
%388 = load double, double* %387
%389 = fptrunc double %388 to float
%390 = add i32 %377, 1
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds float, float* %151, i64 %391
store float %389, float* %392
br i1 %369, label %411, label %393
393: ; preds = %384
%394 = add i32 %375, 2
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds double, double* %152, i64 %395
%397 = load double, double* %396
%398 = fptrunc double %397 to float
%399 = add i32 %377, 2
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds float, float* %151, i64 %400
store float %398, float* %401
br i1 %370, label %411, label %402
402: ; preds = %393
%403 = add i32 %375, 3
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds double, double* %152, i64 %404
%406 = load double, double* %405
%407 = fptrunc double %406 to float
%408 = add i32 %377, 3
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds float, float* %151, i64 %409
store float %407, float* %410
br label %411
411: ; preds = %373, %384, %393, %402, %371
%412 = add nuw nsw i32 %372, 1
%413 = icmp eq i32 %412, %1
br i1 %413, label %414, label %371
414: ; preds = %411, %359, %356
ret void
}