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


x86 assembly (clang, -O0):
<s_cvt_tran_mat2pmat>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
movl   $0x8,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    $0x8,%eax
sub    %edx,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    1155 <s_cvt_tran_mat2pmat+0x55>
mov    -0x8(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    122a <s_cvt_tran_mat2pmat+0x12a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11f1 <s_cvt_tran_mat2pmat+0xf1>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    11de <s_cvt_tran_mat2pmat+0xde>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x24(%rbp),%edx
add    -0x28(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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_tran_mat2pmat+0x89>
jmp    11e3 <s_cvt_tran_mat2pmat+0xe3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1176 <s_cvt_tran_mat2pmat+0x76>
mov    -0x30(%rbp),%ecx
imul   -0x1c(%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    2452 <s_cvt_tran_mat2pmat+0x1352>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    2228 <s_cvt_tran_mat2pmat+0x1128>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $0x0,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $0x0,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $0x0,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $0x0,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    $0x1,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    $0x1,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%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    $0x1,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    $0x2,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    $0x2,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    $0x2,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%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    $0x2,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    $0x3,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    $0x3,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%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    $0x3,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    $0x4,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    $0x4,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    $0x4,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x4,%ecx
mov    -0x28(%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    $0x4,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    $0x5,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    $0x5,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%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    $0x5,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
add    $0x7,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    $0x6,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    $0x6,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
add    $0x3,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    $0x6,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%rbp),%edx
add    $0x5,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    -0x2c(%rbp),%ecx
add    $0x6,%ecx
mov    -0x28(%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    $0x6,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    $0x7,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    $0x7,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    $0x7,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x7,%ecx
mov    -0x28(%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    1249 <s_cvt_tran_mat2pmat+0x149>
jmp    222d <s_cvt_tran_mat2pmat+0x112d>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    243f <s_cvt_tran_mat2pmat+0x133f>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
add    $0x0,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $0x0,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $0x0,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
add    $0x4,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $0x0,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x28(%rbp),%edx
imul   0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%rbp),%edx
add    $0x6,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -0x2c(%rbp),%ecx
add    $0x0,%ecx
mov    -0x28(%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    $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    222d <s_cvt_tran_mat2pmat+0x112d>
jmp    2444 <s_cvt_tran_mat2pmat+0x1344>
mov    -0x28(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x28(%rbp)
jmp    1231 <s_cvt_tran_mat2pmat+0x131>
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2503 <s_cvt_tran_mat2pmat+0x1403>
mov    -0x34(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    $0x8,%eax
cmp    -0x38(%rbp),%eax
jge    247c <s_cvt_tran_mat2pmat+0x137c>
movl   $0x8,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    24fe <s_cvt_tran_mat2pmat+0x13fe>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    24eb <s_cvt_tran_mat2pmat+0x13eb>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x24(%rbp),%edx
add    -0x28(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    2496 <s_cvt_tran_mat2pmat+0x1396>
jmp    24f0 <s_cvt_tran_mat2pmat+0x13f0>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2483 <s_cvt_tran_mat2pmat+0x1383>
jmp    2503 <s_cvt_tran_mat2pmat+0x1403>
pop    %rbp
ret

x86 assembly (clang, -O2):
<s_cvt_tran_mat2pmat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r9d,-0x7c(%rsp)
mov    %edi,%r15d
mov    0x48(%rsp),%edi
mov    0x40(%rsp),%rcx
neg    %edx
and    $0x7,%edx
cmp    %esi,%edx
cmovg  %esi,%edx
sub    %edx,%esi
test   %edx,%edx
mov    %r15,-0x68(%rsp)
jle    1222 <s_cvt_tran_mat2pmat+0x122>
mov    %r8,-0x78(%rsp)
test   %r15d,%r15d
jle    11fb <s_cvt_tran_mat2pmat+0xfb>
movslq -0x7c(%rsp),%r15
mov    -0x68(%rsp),%r9d
mov    %edx,%r10d
mov    %r10d,%r12d
and    $0xfffffffe,%r12d
lea    0x0(,%r15,8),%r13
mov    $0x1,%r11d
xor    %r14d,%r14d
mov    -0x78(%rsp),%r8
jmp    1181 <s_cvt_tran_mat2pmat+0x81>
nop
add    $0x1,%r14
add    $0x4,%r8
add    $0x8,%r11
cmp    %r9,%r14
je     11fb <s_cvt_tran_mat2pmat+0xfb>
cmp    $0x1,%edx
jne    1190 <s_cvt_tran_mat2pmat+0x90>
xor    %ebx,%ebx
jmp    11cc <s_cvt_tran_mat2pmat+0xcc>
nopw   0x0(%rax,%rax,1)
mov    %r11,%rbp
mov    %r8,%rax
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movss  (%rax),%xmm0
lea    -0x1(%rbp),%edi
and    $0xfffffffe,%edi
movss  %xmm0,(%rcx,%rdi,4)
movss  (%rax,%r15,4),%xmm0
mov    %ebp,%edi
movss  %xmm0,(%rcx,%rdi,4)
add    $0x2,%rbx
add    %r13,%rax
add    $0x2,%rbp
cmp    %rbx,%r12
jne    11a0 <s_cvt_tran_mat2pmat+0xa0>
test   $0x1,%r10b
je     1170 <s_cvt_tran_mat2pmat+0x70>
lea    0x0(,%r14,8),%rax
mov    %rbx,%rdi
imul   %r15,%rdi
add    %r14,%rdi
mov    -0x78(%rsp),%rbp
movss  0x0(%rbp,%rdi,4),%xmm0
add    %eax,%ebx
movss  %xmm0,(%rcx,%rbx,4)
jmp    1170 <s_cvt_tran_mat2pmat+0x70>
mov    %edx,%eax
imul   -0x7c(%rsp),%eax
cltq
mov    -0x78(%rsp),%r8
lea    (%r8,%rax,4),%r8
mov    0x48(%rsp),%edi
lea    (%rdx,%rdi,8),%eax
add    $0xfffffff8,%eax
cltq
lea    (%rcx,%rax,4),%rcx
mov    -0x68(%rsp),%r15
xor    %edx,%edx
cmp    $0x8,%esi
jl     19f4 <s_cvt_tran_mat2pmat+0x8f4>
mov    %rsi,-0x48(%rsp)
lea    -0x7(%rsi),%eax
mov    %rax,-0x10(%rsp)
lea    -0x7(%r15),%eax
cltq
mov    %rax,-0x30(%rsp)
movslq -0x7c(%rsp),%rax
movslq %edi,%rdx
mov    %r15d,%r9d
lea    0x1c(%r8),%rbx
mov    %rax,%rsi
shl    $0x5,%rsi
mov    %rsi,-0x18(%rsp)
lea    0x0(,%rdi,8),%esi
mov    %rsi,-0x20(%rsp)
lea    0xe0(%rcx),%r14
mov    %rdx,-0x40(%rsp)
shl    $0x5,%rdx
mov    %rdx,-0x28(%rsp)
lea    0x0(,%rax,4),%r10
mov    %rax,-0x38(%rsp)
lea    0x0(,%rax,8),%rax
lea    (%rax,%rax,2),%rax
mov    $0x4,%esi
sub    %rax,%rsi
xor    %ebp,%ebp
mov    %r8,-0x78(%rsp)
mov    %r8,%r12
xor    %edx,%edx
mov    %r9,-0x8(%rsp)
jmp    12f3 <s_cvt_tran_mat2pmat+0x1f3>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x50(%rsp),%rdx
add    $0x8,%rdx
mov    -0x18(%rsp),%rax
add    %rax,%rbx
add    -0x20(%rsp),%rbp
add    -0x28(%rsp),%r14
mov    -0x70(%rsp),%r12
add    %rax,%r12
cmp    -0x10(%rsp),%rdx
mov    -0x68(%rsp),%r15
jae    19e6 <s_cvt_tran_mat2pmat+0x8e6>
mov    %rdx,-0x50(%rsp)
mov    $0x0,%r13d
cmp    $0x8,%r15d
jl     187d <s_cvt_tran_mat2pmat+0x77d>
xor    %edi,%edi
xor    %r13d,%r13d
mov    -0x30(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rbx,%r13,4),%rax
movss  -0x1c(%rbx,%r13,4),%xmm0
movss  %xmm0,-0xe0(%r14,%rdi,4)
ff ff ff
movss  -0x1c(%r10,%rax,1),%xmm0
lea    (%rdi,%rbp,1),%edx
add    $0x1,%edx
movslq %edx,%rdx
lea    -0x1c(%r10,%rax,1),%r11
movss  %xmm0,(%rcx,%rdx,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x2,%eax
add    %r10,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x3,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x4,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x5,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x6,%eax
add    %r10,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x7,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  -0x18(%rbx,%r13,4),%xmm0
add    %r10,%r11
movss  %xmm0,-0xc0(%r14,%rdi,4)
ff ff ff
movss  (%rsi,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x9,%eax
add    %rsi,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0xa,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0xb,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0xc,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0xd,%eax
add    %r10,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0xe,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0xf,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
add    %r10,%r11
movss  -0x14(%rbx,%r13,4),%xmm0
movss  %xmm0,-0xa0(%r14,%rdi,4)
ff ff ff
movss  (%rsi,%r11,1),%xmm0
add    %rsi,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x11,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x12,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x13,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x14,%eax
add    %r10,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x15,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x16,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x17,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  -0x10(%rbx,%r13,4),%xmm0
movss  %xmm0,-0x80(%r14,%rdi,4)
movss  (%rsi,%r11,1),%xmm0
add    %rsi,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x19,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x1a,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x1b,%eax
add    %r10,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x1c,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x1d,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x1e,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x1f,%eax
add    %r10,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  -0xc(%rbx,%r13,4),%xmm0
movss  %xmm0,-0x60(%r14,%rdi,4)
movss  (%rsi,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x21,%eax
cltq
add    %rsi,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x22,%eax
add    %r10,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x23,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x24,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x25,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x26,%eax
add    %r10,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x27,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  -0x8(%rbx,%r13,4),%xmm0
add    %r10,%r11
movss  %xmm0,-0x40(%r14,%rdi,4)
movss  (%rsi,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x29,%eax
add    %rsi,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x2a,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x2b,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x2c,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x2d,%eax
add    %r10,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x2e,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x2f,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
add    %r10,%r11
movss  -0x4(%rbx,%r13,4),%xmm0
movss  %xmm0,-0x20(%r14,%rdi,4)
movss  (%rsi,%r11,1),%xmm0
add    %rsi,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x31,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x32,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x33,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x34,%eax
add    %r10,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x35,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x36,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x37,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%rbx,%r13,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
movss  (%rsi,%r11,1),%xmm0
add    %rsi,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x39,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x3a,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x3b,%eax
add    %r10,%r11
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x3c,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
add    %r10,%r11
lea    (%rdi,%rbp,1),%eax
add    $0x3d,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x3e,%eax
cltq
add    %r10,%r11
movss  %xmm0,(%rcx,%rax,4)
movss  (%r10,%r11,1),%xmm0
lea    (%rdi,%rbp,1),%eax
add    $0x3f,%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
add    $0x8,%r13
add    $0x40,%rdi
cmp    %r8,%r13
jl     1320 <s_cvt_tran_mat2pmat+0x220>
cmp    %r15d,%r13d
mov    -0x78(%rsp),%rax
mov    %r12,-0x70(%rsp)
jge    12c0 <s_cvt_tran_mat2pmat+0x1c0>
mov    -0x50(%rsp),%r11
mov    %r11,%rdx
imul   -0x40(%rsp),%rdx
mov    %rdx,-0x58(%rsp)
mov    %r11,%rdi
or     $0x1,%rdi
mov    -0x38(%rsp),%rdx
imul   %rdx,%rdi
mov    %rdi,-0x60(%rsp)
mov    %r11,%rdi
or     $0x2,%rdi
imul   %rdx,%rdi
mov    %rdi,(%rsp)
mov    %r11,%rdi
or     $0x3,%rdi
imul   %rdx,%rdi
mov    %r11,%r15
or     $0x4,%r15
imul   %rdx,%r15
mov    %r11,%r12
or     $0x5,%r12
imul   %rdx,%r12
mov    %r11,%r9
or     $0x6,%r9
imul   %rdx,%r9
or     $0x7,%r11
imul   %rdx,%r11
mov    %r13d,%r8d
shl    $0x3,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x70(%rsp),%rdx
movss  (%rdx,%r8,4),%xmm0
movslq %r13d,%r13
mov    -0x58(%rsp),%rdx
add    %r13,%rdx
movss  %xmm0,(%rcx,%rdx,4)
mov    -0x60(%rsp),%rdx
lea    (%r8,%rdx,1),%rdx
movss  (%rax,%rdx,4),%xmm0
lea    0x1(%rbp,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
mov    (%rsp),%rdx
lea    (%r8,%rdx,1),%rdx
movss  (%rax,%rdx,4),%xmm0
lea    0x2(%rbp,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
lea    (%r8,%rdi,1),%rdx
movss  (%rax,%rdx,4),%xmm0
lea    0x3(%rbp,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
lea    (%r8,%r15,1),%rdx
movss  (%rax,%rdx,4),%xmm0
lea    0x4(%rbp,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
lea    (%r8,%r12,1),%rdx
movss  (%rax,%rdx,4),%xmm0
lea    0x5(%rbp,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
lea    (%r8,%r9,1),%rdx
movss  (%rax,%rdx,4),%xmm0
lea    0x6(%rbp,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
lea    (%r8,%r11,1),%rdx
movss  (%rax,%rdx,4),%xmm0
lea    0x7(%rbp,%r13,1),%edx
movslq %edx,%rdx
movss  %xmm0,(%rcx,%rdx,4)
add    $0x1,%r8
add    $0x8,%r13d
cmp    %r8,-0x8(%rsp)
jne    1910 <s_cvt_tran_mat2pmat+0x810>
jmp    12c0 <s_cvt_tran_mat2pmat+0x1c0>
mov    -0x48(%rsp),%rsi
mov    0x48(%rsp),%edi
mov    -0x78(%rsp),%r8
sub    %edx,%esi
jle    1ba9 <s_cvt_tran_mat2pmat+0xaa9>
test   %r15d,%r15d
jle    1ba9 <s_cvt_tran_mat2pmat+0xaa9>
mov    %rsi,%r9
cmp    $0x8,%esi
mov    $0x8,%eax
cmovl  %esi,%eax
imul   %edx,%edi
mov    %rdi,-0x70(%rsp)
movslq %edx,%rdi
movslq -0x7c(%rsp),%rbx
cmp    $0x2,%eax
mov    $0x1,%r10d
cmovge %eax,%r10d
mov    %r15d,%esi
mov    %rdi,%rdx
imul   %rbx,%rdx
lea    0x1(%rdi),%r13
imul   %rbx,%r13
lea    0x2(%rdi),%r12
imul   %rbx,%r12
lea    0x3(%rdi),%r15
imul   %rbx,%r15
lea    0x4(%rdi),%r14
imul   %rbx,%r14
lea    0x5(%rdi),%r11
imul   %rbx,%r11
lea    0x6(%rdi),%rbp
imul   %rbx,%rbp
add    $0x7,%rdi
imul   %rbx,%rdi
lea    (%r8,%rdi,4),%rdi
mov    %rdi,-0x60(%rsp)
mov    -0x70(%rsp),%rdi
lea    (%r8,%rbp,4),%rbx
mov    %rbx,-0x58(%rsp)
lea    (%r8,%r11,4),%r11
lea    (%r8,%r14,4),%r14
lea    (%r8,%r15,4),%r15
lea    (%r8,%r12,4),%r12
lea    (%r8,%r13,4),%r13
lea    (%r8,%rdx,4),%rbp
shl    $0x2,%rsi
xor    %ebx,%ebx
jmp    1ac0 <s_cvt_tran_mat2pmat+0x9c0>
nopl   0x0(%rax)
add    $0x4,%rbx
add    $0x8,%edi
cmp    %rbx,%rsi
je     1ba9 <s_cvt_tran_mat2pmat+0xaa9>
test   %r9d,%r9d
jle    1ab0 <s_cvt_tran_mat2pmat+0x9b0>
movss  0x0(%rbp,%rbx,1),%xmm0
mov    %rdi,%rdx
movslq %edx,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    %rdx,%rdi
cmp    $0x2,%eax
jl     1ab0 <s_cvt_tran_mat2pmat+0x9b0>
lea    0x1(%rdx),%edi
movss  0x0(%r13,%rbx,1),%xmm0
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    %rdx,%rdi
cmp    $0x2,%r10d
je     1ab0 <s_cvt_tran_mat2pmat+0x9b0>
lea    0x2(%rdx),%edi
movss  (%r12,%rbx,1),%xmm0
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    %rdx,%rdi
cmp    $0x3,%r10d
je     1ab0 <s_cvt_tran_mat2pmat+0x9b0>
lea    0x3(%rdx),%edi
movss  (%r15,%rbx,1),%xmm0
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    %rdx,%rdi
cmp    $0x4,%r10d
je     1ab0 <s_cvt_tran_mat2pmat+0x9b0>
lea    0x4(%rdx),%edi
movss  (%r14,%rbx,1),%xmm0
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    %rdx,%rdi
cmp    $0x5,%r10d
je     1ab0 <s_cvt_tran_mat2pmat+0x9b0>
lea    0x5(%rdx),%edi
movss  (%r11,%rbx,1),%xmm0
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    %rdx,%rdi
cmp    $0x6,%r10d
je     1ab0 <s_cvt_tran_mat2pmat+0x9b0>
lea    0x6(%rdx),%r8d
mov    -0x58(%rsp),%rdi
movss  (%rdi,%rbx,1),%xmm0
movslq %r8d,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    %rdx,%rdi
cmp    $0x7,%r10d
je     1ab0 <s_cvt_tran_mat2pmat+0x9b0>
mov    -0x60(%rsp),%rdi
movss  (%rdi,%rbx,1),%xmm0
lea    0x7(%rdx),%edi
movslq %edi,%rdi
movss  %xmm0,(%rcx,%rdi,4)
mov    %rdx,%rdi
jmp    1ab0 <s_cvt_tran_mat2pmat+0x9b0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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