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


x86 assembly (clang, -O0):
<s_cvt_mat2pmat>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
movl   $0x8,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    $0x8,%eax
sub    %edx,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jle    1155 <s_cvt_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    1226 <s_cvt_mat2pmat+0x126>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11f1 <s_cvt_mat2pmat+0xf1>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    11de <s_cvt_mat2pmat+0xde>
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
movss  (%rax,%rcx,4),%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 <s_cvt_mat2pmat+0x89>
jmp    11e3 <s_cvt_mat2pmat+0xe3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1176 <s_cvt_mat2pmat+0x76>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%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    244e <s_cvt_mat2pmat+0x134e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    2224 <s_cvt_mat2pmat+0x1124>
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
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%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    1245 <s_cvt_mat2pmat+0x145>
jmp    2229 <s_cvt_mat2pmat+0x1129>
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    243b <s_cvt_mat2pmat+0x133b>
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
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x4,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x5,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x6,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x7,%ecx
mov    -0x2c(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%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    2229 <s_cvt_mat2pmat+0x1129>
jmp    2440 <s_cvt_mat2pmat+0x1340>
mov    -0x28(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x28(%rbp)
jmp    122d <s_cvt_mat2pmat+0x12d>
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    24ff <s_cvt_mat2pmat+0x13ff>
mov    -0x34(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    $0x8,%eax
cmp    -0x38(%rbp),%eax
jge    2478 <s_cvt_mat2pmat+0x1378>
movl   $0x8,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    24fa <s_cvt_mat2pmat+0x13fa>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    24e7 <s_cvt_mat2pmat+0x13e7>
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
movss  (%rax,%rcx,4),%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    2492 <s_cvt_mat2pmat+0x1392>
jmp    24ec <s_cvt_mat2pmat+0x13ec>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    247f <s_cvt_mat2pmat+0x137f>
jmp    24ff <s_cvt_mat2pmat+0x13ff>
pop    %rbp
ret

x86 assembly (clang, -O2):
<s_cvt_mat2pmat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %esi,%r14d
mov    0x40(%rsp),%ebx
mov    0x38(%rsp),%rcx
neg    %edx
and    $0x7,%edx
cmp    %edi,%edx
cmovg  %edi,%edx
sub    %edx,%edi
test   %edx,%edx
mov    %r14,-0x28(%rsp)
mov    %r9d,-0x5c(%rsp)
mov    %rdi,-0x10(%rsp)
jle    139e <s_cvt_mat2pmat+0x29e>
test   %r14d,%r14d
jle    1378 <s_cvt_mat2pmat+0x278>
movslq -0x5c(%rsp),%r11
mov    -0x28(%rsp),%eax
mov    %rax,-0x48(%rsp)
mov    %edx,%ebp
lea    -0x1(%rbp),%rsi
lea    (%rcx,%rbp,4),%rax
mov    %rax,-0x50(%rsp)
mov    %ebp,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x30(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x38(%rsp)
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %rdi,%rax
mov    %rdi,-0x40(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,-0x8(%rsp)
mov    %rbp,-0x58(%rsp)
neg    %rbp
lea    0x30(%r8),%rdi
lea    0x0(,%r11,4),%rax
mov    %rax,-0x20(%rsp)
mov    $0x8,%r10d
xor    %r15d,%r15d
mov    %r8,%r14
xor    %r9d,%r9d
mov    %rsi,-0x18(%rsp)
jmp    11e7 <s_cvt_mat2pmat+0xe7>
nopl   (%rax)
add    $0x1,%r9
mov    -0x20(%rsp),%rax
add    %rax,%rdi
add    $0x8,%r10
add    $0x8,%r15
add    %rax,%r14
cmp    -0x48(%rsp),%r9
mov    -0x18(%rsp),%rsi
je     1378 <s_cvt_mat2pmat+0x278>
mov    %r9,%r13
imul   %r11,%r13
lea    0x0(,%r9,8),%r12
cmp    $0x8,%edx
jb     1260 <s_cvt_mat2pmat+0x160>
lea    0x0(,%r9,8),%eax
add    %esi,%eax
jb     1260 <s_cvt_mat2pmat+0x160>
mov    %rsi,%rax
shr    $0x20,%rax
mov    $0x0,%eax
jne    1262 <s_cvt_mat2pmat+0x162>
mov    %r11,%rbx
mov    %r9d,%eax
and    $0x1fffffff,%eax
shl    $0x5,%rax
mov    -0x50(%rsp),%rsi
add    %rax,%rsi
lea    (%r8,%r13,4),%r11
cmp    %rsi,%r11
jae    12d7 <s_cvt_mat2pmat+0x1d7>
mov    -0x58(%rsp),%rsi
add    %r13,%rsi
add    %rcx,%rax
lea    (%r8,%rsi,4),%rsi
cmp    %rsi,%rax
jae    12d7 <s_cvt_mat2pmat+0x1d7>
xor    %eax,%eax
mov    %rbx,%r11
jmp    1262 <s_cvt_mat2pmat+0x162>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    %rax,%rsi
testb  $0x1,-0x58(%rsp)
je     1289 <s_cvt_mat2pmat+0x189>
add    %rax,%r13
movss  (%r8,%r13,4),%xmm0
add    %eax,%r12d
and    $0xfffffff8,%r12d
movss  %xmm0,(%rcx,%r12,4)
mov    %rax,%rsi
or     $0x1,%rsi
not    %rax
cmp    %rbp,%rax
je     11c0 <s_cvt_mat2pmat+0xc0>
lea    0x1(%rsi),%rax
add    %r15,%rsi
nopl   0x0(%rax)
movss  -0x4(%r14,%rax,4),%xmm0
mov    %esi,%ebx
movss  %xmm0,(%rcx,%rbx,4)
movss  (%r14,%rax,4),%xmm0
lea    0x1(%rsi),%ebx
movss  %xmm0,(%rcx,%rbx,4)
lea    (%rax,%rbp,1),%rbx
add    $0x2,%rbx
add    $0x2,%rax
add    $0x2,%rsi
cmp    $0x1,%rbx
jne    12a0 <s_cvt_mat2pmat+0x1a0>
jmp    11c0 <s_cvt_mat2pmat+0xc0>
cmpq   $0x0,-0x38(%rsp)
je     136a <s_cvt_mat2pmat+0x26a>
mov    -0x8(%rsp),%rax
xor    %esi,%esi
mov    %rbx,%r11
nopl   (%rax)
movups -0x30(%rdi,%rsi,4),%xmm0
movups -0x20(%rdi,%rsi,4),%xmm1
lea    (%r15,%rsi,1),%ebx
and    $0xfffffff8,%ebx
movups %xmm0,(%rcx,%rbx,4)
movups %xmm1,0x10(%rcx,%rbx,4)
movups -0x10(%rdi,%rsi,4),%xmm0
movups (%rdi,%rsi,4),%xmm1
lea    (%r10,%rsi,1),%ebx
and    $0xfffffff8,%ebx
movups %xmm0,(%rcx,%rbx,4)
movups %xmm1,0x10(%rcx,%rbx,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rax
jne    12f0 <s_cvt_mat2pmat+0x1f0>
testb  $0x1,-0x40(%rsp)
je     1352 <s_cvt_mat2pmat+0x252>
lea    (%rsi,%r13,1),%rax
movups (%r8,%rax,4),%xmm0
movups 0x10(%r8,%rax,4),%xmm1
add    %r12d,%esi
and    $0xfffffff8,%esi
movups %xmm0,(%rcx,%rsi,4)
movups %xmm1,0x10(%rcx,%rsi,4)
mov    -0x30(%rsp),%rsi
mov    %rsi,%rax
cmp    -0x58(%rsp),%rsi
je     11c0 <s_cvt_mat2pmat+0xc0>
jmp    1262 <s_cvt_mat2pmat+0x162>
xor    %esi,%esi
mov    %rbx,%r11
testb  $0x1,-0x40(%rsp)
jne    1334 <s_cvt_mat2pmat+0x234>
jmp    1352 <s_cvt_mat2pmat+0x252>
movslq %edx,%rax
lea    (%r8,%rax,4),%r8
mov    0x40(%rsp),%ebx
lea    (%rdx,%rbx,8),%eax
add    $0xfffffff8,%eax
cltq
lea    (%rcx,%rax,4),%rcx
mov    -0x5c(%rsp),%r9d
mov    -0x28(%rsp),%r14
mov    -0x10(%rsp),%rdi
xor    %r12d,%r12d
cmp    $0x8,%edi
jl     1a38 <s_cvt_mat2pmat+0x938>
lea    -0x7(%rdi),%r15d
lea    -0x7(%r14),%edx
movslq %r9d,%rax
movslq %edx,%r11
movslq %ebx,%rdx
mov    %r14d,%esi
mov    %rsi,-0x40(%rsp)
mov    %rax,%r13
shl    $0x5,%r13
lea    0x0(,%rbx,8),%esi
mov    %rsi,-0x18(%rsp)
lea    0xe0(%rcx),%rbp
mov    %rdx,-0x38(%rsp)
shl    $0x5,%rdx
mov    %rdx,-0x20(%rsp)
lea    0x0(,%rax,4),%r9
mov    $0x4,%edx
mov    %rdx,-0x58(%rsp)
xor    %r10d,%r10d
mov    %r8,-0x50(%rsp)
mov    %r8,-0x48(%rsp)
xor    %r12d,%r12d
mov    %r15,-0x30(%rsp)
jmp    1443 <s_cvt_mat2pmat+0x343>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x8,%r12
addq   $0x20,-0x48(%rsp)
add    -0x18(%rsp),%r10
add    -0x20(%rsp),%rbp
addq   $0x8,-0x58(%rsp)
cmp    %r15,%r12
jae    1a25 <s_cvt_mat2pmat+0x925>
mov    $0x0,%edi
cmp    $0x8,%r14d
jl     1944 <s_cvt_mat2pmat+0x844>
xor    %r14d,%r14d
mov    -0x48(%rsp),%r8
xor    %edi,%edi
nopl   0x0(%rax)
movss  (%r8),%xmm0
movss  %xmm0,-0xe0(%rbp,%r14,4)
ff ff ff
movss  0x4(%r8),%xmm0
lea    (%r10,%r14,1),%edx
add    $0x1,%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x8(%r8),%xmm0
lea    0x2(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0xc(%r8),%xmm0
lea    0x3(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x10(%r8),%xmm0
lea    0x4(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x14(%r8),%xmm0
lea    0x5(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x18(%r8),%xmm0
lea    0x6(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x1c(%r8),%xmm0
lea    0x7(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  (%r8,%rax,4),%xmm0
movss  %xmm0,-0xc0(%rbp,%r14,4)
ff ff ff
movss  0x4(%r8,%rax,4),%xmm0
lea    0x9(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x8(%r8,%rax,4),%xmm0
lea    0xa(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0xc(%r8,%rax,4),%xmm0
lea    0xb(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x10(%r8,%rax,4),%xmm0
lea    0xc(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x14(%r8,%rax,4),%xmm0
lea    0xd(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x18(%r8,%rax,4),%xmm0
lea    0xe(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x1c(%r8,%rax,4),%xmm0
lea    0xf(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  (%r8,%rax,8),%xmm0
movss  %xmm0,-0xa0(%rbp,%r14,4)
ff ff ff
movss  0x4(%r8,%rax,8),%xmm0
lea    0x11(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x8(%r8,%rax,8),%xmm0
lea    0x12(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0xc(%r8,%rax,8),%xmm0
lea    0x13(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x10(%r8,%rax,8),%xmm0
lea    0x14(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x14(%r8,%rax,8),%xmm0
lea    0x15(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x18(%r8,%rax,8),%xmm0
lea    0x16(%r10,%r14,1),%edx
movslq %edx,%rdx
lea    (%r8,%r9,1),%rbx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x1c(%r8,%rax,8),%xmm0
lea    (%r10,%r14,1),%edx
add    $0x17,%edx
add    %r9,%rbx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,-0x80(%rbp,%r14,4)
movss  0x4(%rbx,%rax,4),%xmm0
lea    0x19(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x8(%rbx,%rax,4),%xmm0
lea    0x1a(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0xc(%rbx,%rax,4),%xmm0
lea    0x1b(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x10(%rbx,%rax,4),%xmm0
lea    0x1c(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x14(%rbx,%rax,4),%xmm0
lea    0x1d(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x18(%rbx,%rax,4),%xmm0
lea    0x1e(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x1c(%rbx,%rax,4),%xmm0
lea    0x1f(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  (%rbx,%rax,8),%xmm0
movss  %xmm0,-0x60(%rbp,%r14,4)
movss  0x4(%rbx,%rax,8),%xmm0
lea    0x21(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x8(%rbx,%rax,8),%xmm0
lea    0x22(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0xc(%rbx,%rax,8),%xmm0
lea    0x23(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x10(%rbx,%rax,8),%xmm0
lea    0x24(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x14(%rbx,%rax,8),%xmm0
lea    0x25(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x18(%rbx,%rax,8),%xmm0
lea    (%rbx,%r9,1),%rdx
lea    0x26(%r10,%r14,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
lea    (%rdx,%r9,1),%r15
movss  0x1c(%rbx,%rax,8),%xmm0
lea    0x27(%r10,%r14,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,-0x40(%rbp,%r14,4)
movss  0x4(%rdx,%rax,8),%xmm0
lea    0x29(%r10,%r14,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movss  0x8(%rdx,%rax,8),%xmm0
lea    0x2a(%r10,%r14,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movss  0xc(%rdx,%rax,8),%xmm0
lea    0x2b(%r10,%r14,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movss  0x10(%rdx,%rax,8),%xmm0
lea    0x2c(%r10,%r14,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movss  0x14(%rdx,%rax,8),%xmm0
lea    0x2d(%r10,%r14,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movss  0x18(%rdx,%rax,8),%xmm0
lea    0x2e(%r10,%r14,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
movss  0x1c(%rdx,%rax,8),%xmm0
lea    (%r15,%r9,1),%rsi
lea    0x2f(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,-0x20(%rbp,%r14,4)
movss  0x4(%r15,%rax,8),%xmm0
lea    0x31(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x8(%r15,%rax,8),%xmm0
lea    0x32(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0xc(%r15,%rax,8),%xmm0
lea    0x33(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x10(%r15,%rax,8),%xmm0
lea    0x34(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x14(%r15,%rax,8),%xmm0
lea    0x35(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x18(%r15,%rax,8),%xmm0
lea    0x36(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x1c(%r15,%rax,8),%xmm0
lea    0x37(%r10,%r14,1),%edx
lea    (%rsi,%r9,1),%rbx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%r14,4)
movss  0x4(%rsi,%rax,8),%xmm0
lea    0x39(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x8(%rsi,%rax,8),%xmm0
lea    0x3a(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0xc(%rsi,%rax,8),%xmm0
lea    0x3b(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x10(%rsi,%rax,8),%xmm0
lea    0x3c(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x14(%rsi,%rax,8),%xmm0
lea    0x3d(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x18(%rsi,%rax,8),%xmm0
lea    0x3e(%r10,%r14,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x1c(%rsi,%rax,8),%xmm0
lea    (%r10,%r14,1),%edx
add    $0x3f,%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
add    $0x8,%rdi
add    %r13,%r8
add    $0x40,%r14
cmp    %r11,%rdi
jl     1460 <s_cvt_mat2pmat+0x360>
mov    -0x28(%rsp),%r14
mov    -0x30(%rsp),%r15
cmp    %r14d,%edi
jge    1420 <s_cvt_mat2pmat+0x320>
mov    %r12,%r8
imul   -0x38(%rsp),%r8
mov    %edi,%edx
shl    $0x3,%edi
mov    -0x40(%rsp),%rsi
sub    %rdx,%rsi
imul   %rax,%rdx
add    -0x58(%rsp),%rdx
mov    -0x50(%rsp),%rbx
lea    (%rbx,%rdx,4),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x10(%rdx),%xmm0
movslq %edi,%rdi
lea    (%r8,%rdi,1),%rbx
movss  %xmm0,(%rcx,%rbx,4)
movss  -0xc(%rdx),%xmm0
lea    0x1(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movss  -0x8(%rdx),%xmm0
lea    0x2(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movss  -0x4(%rdx),%xmm0
lea    0x3(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movss  (%rdx),%xmm0
lea    0x4(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movss  0x4(%rdx),%xmm0
lea    0x5(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movss  0x8(%rdx),%xmm0
lea    0x6(%r10,%rdi,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movss  0xc(%rdx),%xmm0
lea    (%r10,%rdi,1),%ebx
add    $0x7,%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
add    $0x8,%edi
add    %r9,%rdx
add    $0xffffffffffffffff,%rsi
jne    1980 <s_cvt_mat2pmat+0x880>
jmp    1420 <s_cvt_mat2pmat+0x320>
mov    -0x5c(%rsp),%r9d
mov    -0x50(%rsp),%r8
mov    -0x10(%rsp),%rdi
mov    0x40(%rsp),%ebx
sub    %r12d,%edi
jle    1b7c <s_cvt_mat2pmat+0xa7c>
test   %r14d,%r14d
jle    1b7c <s_cvt_mat2pmat+0xa7c>
cmp    $0x8,%edi
mov    $0x8,%eax
cmovl  %edi,%eax
imul   %r12d,%ebx
cmp    $0x2,%eax
mov    $0x1,%edx
cmovge %eax,%edx
jmp    1a80 <s_cvt_mat2pmat+0x980>
cs nopw 0x0(%rax,%rax,1)
add    $0x8,%ebx
add    %r9d,%r12d
add    $0xffffffff,%r14d
je     1b7c <s_cvt_mat2pmat+0xa7c>
test   %edi,%edi
jle    1a70 <s_cvt_mat2pmat+0x970>
movslq %r12d,%rsi
movss  (%r8,%rsi,4),%xmm0
movslq %ebx,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x2,%eax
jl     1a70 <s_cvt_mat2pmat+0x970>
lea    0x1(%r12),%esi
lea    0x1(%rbx),%ebp
movslq %esi,%rsi
movss  (%r8,%rsi,4),%xmm0
movslq %ebp,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x2,%edx
je     1a70 <s_cvt_mat2pmat+0x970>
lea    0x2(%r12),%esi
lea    0x2(%rbx),%ebp
movslq %esi,%rsi
movss  (%r8,%rsi,4),%xmm0
movslq %ebp,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x3,%edx
je     1a70 <s_cvt_mat2pmat+0x970>
lea    0x3(%r12),%esi
lea    0x3(%rbx),%ebp
movslq %esi,%rsi
movss  (%r8,%rsi,4),%xmm0
movslq %ebp,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x4,%edx
je     1a70 <s_cvt_mat2pmat+0x970>
lea    0x4(%r12),%esi
lea    0x4(%rbx),%ebp
movslq %esi,%rsi
movss  (%r8,%rsi,4),%xmm0
movslq %ebp,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x5,%edx
je     1a70 <s_cvt_mat2pmat+0x970>
lea    0x5(%r12),%esi
lea    0x5(%rbx),%ebp
movslq %esi,%rsi
movss  (%r8,%rsi,4),%xmm0
movslq %ebp,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x6,%edx
je     1a70 <s_cvt_mat2pmat+0x970>
lea    0x6(%r12),%esi
lea    0x6(%rbx),%ebp
movslq %esi,%rsi
movss  (%r8,%rsi,4),%xmm0
movslq %ebp,%rsi
movss  %xmm0,(%rcx,%rsi,4)
cmp    $0x7,%edx
je     1a70 <s_cvt_mat2pmat+0x970>
lea    0x7(%r12),%esi
movslq %esi,%rsi
movss  (%r8,%rsi,4),%xmm0
lea    0x7(%rbx),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
jmp    1a70 <s_cvt_mat2pmat+0x970>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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