void s_copy_pmat(int row, int col, int bs_dummy, float *A, int sda, float *B,
                 int sdb) {
  const int bs = 8;
  int i, ii, j, row2;
  ii = 0;
  for (; ii < row - 7; ii += 8) {
    for (j = 0; j < col; j++) {
      B[0 + j * bs + ii * sdb] = A[0 + j * bs + ii * sda];
      B[1 + j * bs + ii * sdb] = A[1 + j * bs + ii * sda];
      B[2 + j * bs + ii * sdb] = A[2 + j * bs + ii * sda];
      B[3 + j * bs + ii * sdb] = A[3 + j * bs + ii * sda];
      B[4 + j * bs + ii * sdb] = A[4 + j * bs + ii * sda];
      B[5 + j * bs + ii * sdb] = A[5 + j * bs + ii * sda];
      B[6 + j * bs + ii * sdb] = A[6 + j * bs + ii * sda];
      B[7 + j * bs + ii * sdb] = A[7 + j * bs + ii * sda];
    }
  }
  if (ii < row) {
    row2 = row - ii;
    for (j = 0; j < col; j++) {
      for (i = 0; i < row2; i++) {
        B[i + j * bs + ii * sdb] = A[i + j * bs + ii * sda];
      }
    }
  }
}


x86 assembly (clang, -O0):
<s_copy_pmat>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x8,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    134f <s_copy_pmat+0x24f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    133c <s_copy_pmat+0x23c>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1142 <s_copy_pmat+0x42>
jmp    1341 <s_copy_pmat+0x241>
mov    -0x34(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x34(%rbp)
jmp    112a <s_copy_pmat+0x2a>
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13f0 <s_copy_pmat+0x2f0>
mov    -0x4(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13eb <s_copy_pmat+0x2eb>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    13d8 <s_copy_pmat+0x2d8>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x38(%rbp),%edx
shl    $0x3,%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x38(%rbp),%edx
shl    $0x3,%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    137e <s_copy_pmat+0x27e>
jmp    13dd <s_copy_pmat+0x2dd>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    136b <s_copy_pmat+0x26b>
jmp    13f0 <s_copy_pmat+0x2f0>
pop    %rbp
ret

x86 assembly (clang, -O2):
<s_copy_pmat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x38(%rsp),%eax
xor    %r11d,%r11d
cmp    $0x8,%edi
mov    %r9,-0x58(%rsp)
mov    %rcx,-0x10(%rsp)
jl     142d <s_copy_pmat+0x32d>
mov    %rdi,-0x40(%rsp)
lea    -0x7(%rdi),%r12d
mov    %r8d,-0x48(%rsp)
movslq %r8d,%r10
mov    %esi,-0x78(%rsp)
movslq %eax,%rsi
mov    -0x78(%rsp),%r15d
lea    -0x1(%r15),%rax
lea    0x0(,%rsi,8),%rdx
mov    %rdx,-0x18(%rsp)
lea    0x0(,%r15,8),%rbx
lea    0x0(,%r10,8),%rdx
mov    %rdx,-0x30(%rsp)
mov    $0x20,%edx
mul    %rdx
mov    %rax,-0x20(%rsp)
mov    %rsi,%rax
mov    -0x78(%rsp),%esi
seto   -0x28(%rsp)
mov    %r15d,%edx
and    $0xfffffffc,%edx
mov    %rdx,-0x38(%rsp)
shl    $0x5,%rax
shl    $0x5,%r10
mov    %r15,-0x50(%rsp)
shl    $0x5,%r15
and    $0xffffffffffffff80,%r15
xor    %r14d,%r14d
xor    %r11d,%r11d
mov    %rbx,-0x60(%rsp)
mov    %rax,-0x68(%rsp)
mov    %r10,-0x70(%rsp)
jmp    11d7 <s_copy_pmat+0xd7>
nopw   0x0(%rax,%rax,1)
add    $0x8,%r11
add    $0x1,%r14
add    %rax,%r9
add    %r10,%rcx
cmp    %r12,%r11
jae    1415 <s_copy_pmat+0x315>
test   %esi,%esi
jle    11c0 <s_copy_pmat+0xc0>
cmp    $0x4,%esi
jae    1280 <s_copy_pmat+0x180>
xor    %r8d,%r8d
mov    -0x50(%rsp),%rdi
sub    %r8,%rdi
shl    $0x5,%r8
or     $0x10,%r8
nopw   0x0(%rax,%rax,1)
movss  -0x10(%rcx,%r8,1),%xmm0
movss  %xmm0,-0x10(%r9,%r8,1)
movss  -0xc(%rcx,%r8,1),%xmm0
movss  %xmm0,-0xc(%r9,%r8,1)
movss  -0x8(%rcx,%r8,1),%xmm0
movss  %xmm0,-0x8(%r9,%r8,1)
movss  -0x4(%rcx,%r8,1),%xmm0
movss  %xmm0,-0x4(%r9,%r8,1)
movss  (%rcx,%r8,1),%xmm0
movss  %xmm0,(%r9,%r8,1)
movss  0x4(%rcx,%r8,1),%xmm0
movss  %xmm0,0x4(%r9,%r8,1)
movss  0x8(%rcx,%r8,1),%xmm0
movss  %xmm0,0x8(%r9,%r8,1)
movss  0xc(%rcx,%r8,1),%xmm0
movss  %xmm0,0xc(%r9,%r8,1)
add    $0x20,%r8
add    $0xffffffffffffffff,%rdi
jne    1200 <s_copy_pmat+0x100>
jmp    11c0 <s_copy_pmat+0xc0>
nopl   (%rax)
mov    %r12,%r10
mov    -0x18(%rsp),%r13
imul   %r14,%r13
lea    0x0(,%r13,4),%rdi
mov    %rdi,%rbx
or     $0x18,%rbx
mov    -0x58(%rsp),%rbp
add    %rbp,%rbx
mov    %rdi,%r8
or     $0x1c,%r8
add    %rbp,%r8
mov    %rdi,%rdx
or     $0x14,%rdx
add    %rbp,%rdx
or     $0x10,%rdi
add    %rbp,%rdi
mov    -0x20(%rsp),%rsi
lea    (%rbx,%rsi,1),%rbp
cmp    %rbx,%rbp
setb   %bl
mov    -0x28(%rsp),%al
or     %al,%bl
lea    (%r8,%rsi,1),%rbp
cmp    %r8,%rbp
setb   %r12b
lea    (%rdx,%rsi,1),%rbp
cmp    %rdx,%rbp
setb   %r8b
lea    (%rdi,%rsi,1),%rdx
cmp    %rdi,%rdx
setb   %dil
test   %bl,%bl
jne    13f7 <s_copy_pmat+0x2f7>
or     %al,%r12b
mov    -0x60(%rsp),%rbx
jne    13f7 <s_copy_pmat+0x2f7>
or     %al,%r8b
mov    %r10,%r12
jne    13ff <s_copy_pmat+0x2ff>
or     %al,%dil
mov    $0x0,%r8d
mov    -0x70(%rsp),%r10
mov    -0x68(%rsp),%rax
mov    -0x78(%rsp),%esi
jne    11e7 <s_copy_pmat+0xe7>
mov    -0x30(%rsp),%rdi
imul   %r14,%rdi
lea    (%rbx,%rdi,1),%rdx
mov    -0x58(%rsp),%rbx
lea    (%rbx,%r13,4),%r8
mov    -0x10(%rsp),%rbp
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
cmp    %rdx,%r8
jae    137b <s_copy_pmat+0x27b>
add    -0x60(%rsp),%r13
lea    (%rbx,%r13,4),%rdx
lea    0x0(,%rdi,4),%rdi
add    %rbp,%rdi
cmp    %rdx,%rdi
jb     11e4 <s_copy_pmat+0xe4>
xor    %edi,%edi
nopl   (%rax)
movups (%rcx,%rdi,1),%xmm0
movups 0x10(%rcx,%rdi,1),%xmm1
movups 0x20(%rcx,%rdi,1),%xmm2
movups 0x30(%rcx,%rdi,1),%xmm3
movups 0x50(%rcx,%rdi,1),%xmm4
movups 0x40(%rcx,%rdi,1),%xmm5
movups 0x70(%rcx,%rdi,1),%xmm6
movups 0x60(%rcx,%rdi,1),%xmm7
movups %xmm7,0x60(%r9,%rdi,1)
movups %xmm6,0x70(%r9,%rdi,1)
movups %xmm5,0x40(%r9,%rdi,1)
movups %xmm4,0x50(%r9,%rdi,1)
movups %xmm2,0x20(%r9,%rdi,1)
movups %xmm3,0x30(%r9,%rdi,1)
movups %xmm0,(%r9,%rdi,1)
movups %xmm1,0x10(%r9,%rdi,1)
sub    $0xffffffffffffff80,%rdi
cmp    %rdi,%r15
jne    1380 <s_copy_pmat+0x280>
mov    -0x38(%rsp),%rdx
mov    %rdx,%r8
cmp    -0x50(%rsp),%rdx
je     11c0 <s_copy_pmat+0xc0>
jmp    11e7 <s_copy_pmat+0xe7>
xor    %r8d,%r8d
mov    %r10,%r12
jmp    1402 <s_copy_pmat+0x302>
xor    %r8d,%r8d
mov    -0x70(%rsp),%r10
mov    -0x68(%rsp),%rax
mov    -0x78(%rsp),%esi
jmp    11e7 <s_copy_pmat+0xe7>
mov    -0x58(%rsp),%r9
mov    -0x10(%rsp),%rcx
mov    -0x40(%rsp),%rdi
mov    -0x48(%rsp),%r8d
mov    0x38(%rsp),%eax
cmp    %edi,%r11d
jge    167b <s_copy_pmat+0x57b>
test   %esi,%esi
jle    167b <s_copy_pmat+0x57b>
sub    %r11d,%edi
imul   %r11d,%r8d
imul   %r11d,%eax
movslq %r8d,%r10
movslq %eax,%r14
mov    %esi,%r12d
mov    %edi,%esi
lea    (%r9,%rsi,4),%rax
mov    %rax,-0x20(%rsp)
lea    (%rcx,%rsi,4),%rax
mov    %rax,-0x60(%rsp)
mov    %esi,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x70(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rsp)
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,%rax
mov    %rdx,-0x38(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x40(%rsp)
mov    %rsi,%rax
neg    %rax
mov    %rax,-0x50(%rsp)
lea    0x30(%r9),%rax
mov    %rax,-0x48(%rsp)
lea    0x30(%rcx),%rax
mov    %rax,-0x8(%rsp)
lea    0x4(%r9,%r14,4),%rax
mov    %rax,-0x78(%rsp)
lea    (%rcx,%r10,4),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rsp)
xor    %r13d,%r13d
xor    %r8d,%r8d
mov    %r10,-0x28(%rsp)
mov    %r14,-0x68(%rsp)
jmp    14f1 <s_copy_pmat+0x3f1>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
add    $0x8,%r13d
cmp    %r12,%r8
je     167b <s_copy_pmat+0x57b>
test   %edi,%edi
jle    14e0 <s_copy_pmat+0x3e0>
movslq %r13d,%r15
lea    0x0(,%r8,8),%eax
movslq %eax,%r11
cmp    $0x8,%edi
jb     1542 <s_copy_pmat+0x442>
lea    0x0(,%r8,8),%eax
movslq %eax,%rdx
lea    (%r14,%rdx,1),%rbp
add    %r10,%rdx
lea    (%r9,%rbp,4),%rbx
mov    -0x60(%rsp),%rax
lea    (%rax,%rdx,4),%rax
cmp    %rax,%rbx
jae    15b5 <s_copy_pmat+0x4b5>
mov    -0x20(%rsp),%rax
lea    (%rax,%rbp,4),%rax
lea    (%rcx,%rdx,4),%rdx
cmp    %rax,%rdx
jae    15b5 <s_copy_pmat+0x4b5>
xor    %ebp,%ebp
mov    %rbp,%rax
test   $0x1,%sil
je     1569 <s_copy_pmat+0x469>
add    %rbp,%r11
lea    (%r11,%r10,1),%rax
movss  (%rcx,%rax,4),%xmm0
add    %r14,%r11
movss  %xmm0,(%r9,%r11,4)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    -0x50(%rsp),%rbp
je     14e0 <s_copy_pmat+0x3e0>
mov    -0x78(%rsp),%rdx
lea    (%rdx,%r15,4),%rbp
mov    -0x18(%rsp),%rdx
lea    (%rdx,%r15,4),%rbx
nopl   0x0(%rax)
movss  -0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,-0x4(%rbp,%rax,4)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x2,%rax
cmp    %rax,%rsi
jne    1590 <s_copy_pmat+0x490>
jmp    14e0 <s_copy_pmat+0x3e0>
mov    %rdi,%rbx
cmpq   $0x0,-0x30(%rsp)
je     1627 <s_copy_pmat+0x527>
lea    (%r14,%r15,1),%rax
lea    (%r10,%r15,1),%rdi
mov    -0x48(%rsp),%rcx
lea    (%rcx,%rax,4),%rbp
mov    -0x8(%rsp),%rax
lea    (%rax,%rdi,4),%r10
mov    -0x40(%rsp),%r14
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%r10,%rdi,4),%xmm0
movups -0x20(%r10,%rdi,4),%xmm1
movups %xmm0,-0x30(%rbp,%rdi,4)
movups %xmm1,-0x20(%rbp,%rdi,4)
movups -0x10(%r10,%rdi,4),%xmm0
movups (%r10,%rdi,4),%xmm1
movups %xmm0,-0x10(%rbp,%rdi,4)
movups %xmm1,0x0(%rbp,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%r14
jne    15f0 <s_copy_pmat+0x4f0>
jmp    1629 <s_copy_pmat+0x529>
xor    %edi,%edi
testb  $0x1,-0x38(%rsp)
mov    -0x58(%rsp),%r9
mov    -0x10(%rsp),%rcx
mov    -0x28(%rsp),%r10
mov    -0x68(%rsp),%r14
je     1662 <s_copy_pmat+0x562>
add    %r11,%rdi
lea    (%rdi,%r10,1),%rax
movups (%rcx,%rax,4),%xmm0
movups 0x10(%rcx,%rax,4),%xmm1
add    %r14,%rdi
movups %xmm0,(%r9,%rdi,4)
movups %xmm1,0x10(%r9,%rdi,4)
mov    -0x70(%rsp),%rax
mov    %rax,%rbp
cmp    %rsi,%rax
mov    %rbx,%rdi
je     14e0 <s_copy_pmat+0x3e0>
jmp    1544 <s_copy_pmat+0x444>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @s_copy_pmat(i32 %0, i32 %1, i32 %2, float* %3, i32 %4, float* %5, i32 %6) {
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca float*
%12 = alloca i32
%13 = alloca float*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
store i32 %0, i32* %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store float* %3, float** %11
store i32 %4, i32* %12
store float* %5, float** %13
store i32 %6, i32* %14
store i32 8, i32* %15
store i32 0, i32* %17
br label %20
20: ; preds = %203, %7
%21 = load i32, i32* %17
%22 = load i32, i32* %8
%23 = sub nsw i32 %22, 7
%24 = icmp slt i32 %21, %23
br i1 %24, label %25, label %206
25: ; preds = %20
store i32 0, i32* %18
br label %26
26: ; preds = %199, %25
%27 = load i32, i32* %18
%28 = load i32, i32* %9
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %202
30: ; preds = %26
%31 = load float*, float** %11
%32 = load i32, i32* %18
%33 = mul nsw i32 %32, 8
%34 = add nsw i32 0, %33
%35 = load i32, i32* %17
%36 = load i32, i32* %12
%37 = mul nsw i32 %35, %36
%38 = add nsw i32 %34, %37
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds float, float* %31, i64 %39
%41 = load float, float* %40
%42 = load float*, float** %13
%43 = load i32, i32* %18
%44 = mul nsw i32 %43, 8
%45 = add nsw i32 0, %44
%46 = load i32, i32* %17
%47 = load i32, i32* %14
%48 = mul nsw i32 %46, %47
%49 = add nsw i32 %45, %48
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds float, float* %42, i64 %50
store float %41, float* %51
%52 = load float*, float** %11
%53 = load i32, i32* %18
%54 = mul nsw i32 %53, 8
%55 = add nsw i32 1, %54
%56 = load i32, i32* %17
%57 = load i32, i32* %12
%58 = mul nsw i32 %56, %57
%59 = add nsw i32 %55, %58
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds float, float* %52, i64 %60
%62 = load float, float* %61
%63 = load float*, float** %13
%64 = load i32, i32* %18
%65 = mul nsw i32 %64, 8
%66 = add nsw i32 1, %65
%67 = load i32, i32* %17
%68 = load i32, i32* %14
%69 = mul nsw i32 %67, %68
%70 = add nsw i32 %66, %69
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %63, i64 %71
store float %62, float* %72
%73 = load float*, float** %11
%74 = load i32, i32* %18
%75 = mul nsw i32 %74, 8
%76 = add nsw i32 2, %75
%77 = load i32, i32* %17
%78 = load i32, i32* %12
%79 = mul nsw i32 %77, %78
%80 = add nsw i32 %76, %79
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float, float* %73, i64 %81
%83 = load float, float* %82
%84 = load float*, float** %13
%85 = load i32, i32* %18
%86 = mul nsw i32 %85, 8
%87 = add nsw i32 2, %86
%88 = load i32, i32* %17
%89 = load i32, i32* %14
%90 = mul nsw i32 %88, %89
%91 = add nsw i32 %87, %90
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float, float* %84, i64 %92
store float %83, float* %93
%94 = load float*, float** %11
%95 = load i32, i32* %18
%96 = mul nsw i32 %95, 8
%97 = add nsw i32 3, %96
%98 = load i32, i32* %17
%99 = load i32, i32* %12
%100 = mul nsw i32 %98, %99
%101 = add nsw i32 %97, %100
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %94, i64 %102
%104 = load float, float* %103
%105 = load float*, float** %13
%106 = load i32, i32* %18
%107 = mul nsw i32 %106, 8
%108 = add nsw i32 3, %107
%109 = load i32, i32* %17
%110 = load i32, i32* %14
%111 = mul nsw i32 %109, %110
%112 = add nsw i32 %108, %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %105, i64 %113
store float %104, float* %114
%115 = load float*, float** %11
%116 = load i32, i32* %18
%117 = mul nsw i32 %116, 8
%118 = add nsw i32 4, %117
%119 = load i32, i32* %17
%120 = load i32, i32* %12
%121 = mul nsw i32 %119, %120
%122 = add nsw i32 %118, %121
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float, float* %115, i64 %123
%125 = load float, float* %124
%126 = load float*, float** %13
%127 = load i32, i32* %18
%128 = mul nsw i32 %127, 8
%129 = add nsw i32 4, %128
%130 = load i32, i32* %17
%131 = load i32, i32* %14
%132 = mul nsw i32 %130, %131
%133 = add nsw i32 %129, %132
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds float, float* %126, i64 %134
store float %125, float* %135
%136 = load float*, float** %11
%137 = load i32, i32* %18
%138 = mul nsw i32 %137, 8
%139 = add nsw i32 5, %138
%140 = load i32, i32* %17
%141 = load i32, i32* %12
%142 = mul nsw i32 %140, %141
%143 = add nsw i32 %139, %142
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds float, float* %136, i64 %144
%146 = load float, float* %145
%147 = load float*, float** %13
%148 = load i32, i32* %18
%149 = mul nsw i32 %148, 8
%150 = add nsw i32 5, %149
%151 = load i32, i32* %17
%152 = load i32, i32* %14
%153 = mul nsw i32 %151, %152
%154 = add nsw i32 %150, %153
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds float, float* %147, i64 %155
store float %146, float* %156
%157 = load float*, float** %11
%158 = load i32, i32* %18
%159 = mul nsw i32 %158, 8
%160 = add nsw i32 6, %159
%161 = load i32, i32* %17
%162 = load i32, i32* %12
%163 = mul nsw i32 %161, %162
%164 = add nsw i32 %160, %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %157, i64 %165
%167 = load float, float* %166
%168 = load float*, float** %13
%169 = load i32, i32* %18
%170 = mul nsw i32 %169, 8
%171 = add nsw i32 6, %170
%172 = load i32, i32* %17
%173 = load i32, i32* %14
%174 = mul nsw i32 %172, %173
%175 = add nsw i32 %171, %174
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds float, float* %168, i64 %176
store float %167, float* %177
%178 = load float*, float** %11
%179 = load i32, i32* %18
%180 = mul nsw i32 %179, 8
%181 = add nsw i32 7, %180
%182 = load i32, i32* %17
%183 = load i32, i32* %12
%184 = mul nsw i32 %182, %183
%185 = add nsw i32 %181, %184
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds float, float* %178, i64 %186
%188 = load float, float* %187
%189 = load float*, float** %13
%190 = load i32, i32* %18
%191 = mul nsw i32 %190, 8
%192 = add nsw i32 7, %191
%193 = load i32, i32* %17
%194 = load i32, i32* %14
%195 = mul nsw i32 %193, %194
%196 = add nsw i32 %192, %195
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds float, float* %189, i64 %197
store float %188, float* %198
br label %199
199: ; preds = %30
%200 = load i32, i32* %18
%201 = add nsw i32 %200, 1
store i32 %201, i32* %18
br label %26
202: ; preds = %26
br label %203
203: ; preds = %202
%204 = load i32, i32* %17
%205 = add nsw i32 %204, 8
store i32 %205, i32* %17
br label %20
206: ; preds = %20
%207 = load i32, i32* %17
%208 = load i32, i32* %8
%209 = icmp slt i32 %207, %208
br i1 %209, label %210, label %255
210: ; preds = %206
%211 = load i32, i32* %8
%212 = load i32, i32* %17
%213 = sub nsw i32 %211, %212
store i32 %213, i32* %19
store i32 0, i32* %18
br label %214
214: ; preds = %251, %210
%215 = load i32, i32* %18
%216 = load i32, i32* %9
%217 = icmp slt i32 %215, %216
br i1 %217, label %218, label %254
218: ; preds = %214
store i32 0, i32* %16
br label %219
219: ; preds = %247, %218
%220 = load i32, i32* %16
%221 = load i32, i32* %19
%222 = icmp slt i32 %220, %221
br i1 %222, label %223, label %250
223: ; preds = %219
%224 = load float*, float** %11
%225 = load i32, i32* %16
%226 = load i32, i32* %18
%227 = mul nsw i32 %226, 8
%228 = add nsw i32 %225, %227
%229 = load i32, i32* %17
%230 = load i32, i32* %12
%231 = mul nsw i32 %229, %230
%232 = add nsw i32 %228, %231
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds float, float* %224, i64 %233
%235 = load float, float* %234
%236 = load float*, float** %13
%237 = load i32, i32* %16
%238 = load i32, i32* %18
%239 = mul nsw i32 %238, 8
%240 = add nsw i32 %237, %239
%241 = load i32, i32* %17
%242 = load i32, i32* %14
%243 = mul nsw i32 %241, %242
%244 = add nsw i32 %240, %243
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds float, float* %236, i64 %245
store float %235, float* %246
br label %247
247: ; preds = %223
%248 = load i32, i32* %16
%249 = add nsw i32 %248, 1
store i32 %249, i32* %16
br label %219
250: ; preds = %219
br label %251
251: ; preds = %250
%252 = load i32, i32* %18
%253 = add nsw i32 %252, 1
store i32 %253, i32* %18
br label %214
254: ; preds = %214
br label %255
255: ; preds = %254, %206
ret void
}

LLVM IR (-O2):
define void @s_copy_pmat(i32 %0, i32 %1, i32 %2, float* nocapture %3, i32 %4, float* nocapture writeonly %5, i32 %6) {
%8 = icmp sgt i32 %0, 7
br i1 %8, label %9, label %173
9: ; preds = %7
%10 = add nsw i32 %0, -7
%11 = icmp sgt i32 %1, 0
%12 = sext i32 %4 to i64
%13 = sext i32 %6 to i64
%14 = zext i32 %10 to i64
%15 = zext i32 %1 to i64
%16 = add nsw i64 %15, -1
%17 = shl nsw i64 %13, 3
%18 = shl nsw i64 %13, 3
%19 = shl nuw nsw i64 %15, 3
%20 = shl nsw i64 %12, 3
%21 = icmp ult i32 %1, 4
%22 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %16, i64 32)
%23 = extractvalue { i64, i1 } %22, 0
%24 = extractvalue { i64, i1 } %22, 1
%25 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %16, i64 32)
%26 = extractvalue { i64, i1 } %25, 0
%27 = extractvalue { i64, i1 } %25, 1
%28 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %16, i64 32)
%29 = extractvalue { i64, i1 } %28, 0
%30 = extractvalue { i64, i1 } %28, 1
%31 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %16, i64 32)
%32 = extractvalue { i64, i1 } %31, 0
%33 = extractvalue { i64, i1 } %31, 1
%34 = and i64 %15, 4294967292
%35 = getelementptr inbounds float, float* %5, i64 -7
%36 = icmp eq i64 %34, %15
br label %37
37: ; preds = %9, %167
%38 = phi i64 [ 0, %9 ], [ %170, %167 ]
%39 = phi i64 [ 0, %9 ], [ %168, %167 ]
%40 = mul i64 %18, %38
%41 = getelementptr float, float* %5, i64 %40
%42 = add i64 %19, %40
%43 = getelementptr float, float* %5, i64 %42
%44 = mul i64 %20, %38
%45 = getelementptr float, float* %3, i64 %44
%46 = add i64 %19, %44
%47 = getelementptr float, float* %3, i64 %46
%48 = mul i64 %17, %38
%49 = or i64 %48, 6
%50 = getelementptr float, float* %5, i64 %49
%51 = bitcast float* %50 to i8*
%52 = or i64 %48, 7
%53 = getelementptr float, float* %5, i64 %52
%54 = bitcast float* %53 to i8*
%55 = or i64 %48, 5
%56 = getelementptr float, float* %5, i64 %55
%57 = bitcast float* %56 to i8*
%58 = or i64 %48, 4
%59 = getelementptr float, float* %5, i64 %58
%60 = bitcast float* %59 to i8*
br i1 %11, label %61, label %167
61: ; preds = %37
%62 = mul nsw i64 %39, %12
%63 = mul nsw i64 %39, %13
br i1 %21, label %113, label %64
64: ; preds = %61
%65 = getelementptr i8, i8* %51, i64 %23
%66 = icmp ult i8* %65, %51
%67 = or i1 %66, %24
%68 = getelementptr i8, i8* %54, i64 %26
%69 = icmp ult i8* %68, %54
%70 = or i1 %69, %27
%71 = getelementptr i8, i8* %57, i64 %29
%72 = icmp ult i8* %71, %57
%73 = or i1 %72, %30
%74 = getelementptr i8, i8* %60, i64 %32
%75 = icmp ult i8* %74, %60
%76 = or i1 %75, %33
%77 = or i1 %67, %70
%78 = or i1 %77, %73
%79 = or i1 %78, %76
br i1 %79, label %113, label %80
80: ; preds = %64
%81 = icmp ult float* %41, %47
%82 = icmp ult float* %45, %43
%83 = and i1 %81, %82
br i1 %83, label %113, label %84
84: ; preds = %80, %84
%85 = phi i64 [ %110, %84 ], [ 0, %80 ]
%86 = shl nsw i64 %85, 3
%87 = add nsw i64 %86, %62
%88 = getelementptr inbounds float, float* %3, i64 %87
%89 = bitcast float* %88 to <32 x float>*
%90 = load <32 x float>, <32 x float>* %89
%91 = shufflevector <32 x float> %90, <32 x float> poison, <4 x i32> <i32 0, i32 8, i32 16, i32 24>
%92 = shufflevector <32 x float> %90, <32 x float> poison, <4 x i32> <i32 1, i32 9, i32 17, i32 25>
%93 = shufflevector <32 x float> %90, <32 x float> poison, <4 x i32> <i32 2, i32 10, i32 18, i32 26>
%94 = shufflevector <32 x float> %90, <32 x float> poison, <4 x i32> <i32 3, i32 11, i32 19, i32 27>
%95 = shufflevector <32 x float> %90, <32 x float> poison, <4 x i32> <i32 4, i32 12, i32 20, i32 28>
%96 = shufflevector <32 x float> %90, <32 x float> poison, <4 x i32> <i32 5, i32 13, i32 21, i32 29>
%97 = shufflevector <32 x float> %90, <32 x float> poison, <4 x i32> <i32 6, i32 14, i32 22, i32 30>
%98 = shufflevector <32 x float> %90, <32 x float> poison, <4 x i32> <i32 7, i32 15, i32 23, i32 31>
%99 = or i64 %86, 7
%100 = add nsw i64 %99, %63
%101 = getelementptr inbounds float, float* %35, i64 %100
%102 = bitcast float* %101 to <32 x float>*
%103 = shufflevector <4 x float> %91, <4 x float> %92, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%104 = shufflevector <4 x float> %93, <4 x float> %94, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%105 = shufflevector <4 x float> %95, <4 x float> %96, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%106 = shufflevector <4 x float> %97, <4 x float> %98, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%107 = shufflevector <8 x float> %103, <8 x float> %104, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%108 = shufflevector <8 x float> %105, <8 x float> %106, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%109 = shufflevector <16 x float> %107, <16 x float> %108, <32 x i32> <i32 0, i32 4, i32 8, i32 12, i32 16, i32 20, i32 24, i32 28, i32 1, i32 5, i32 9, i32 13, i32 17, i32 21, i32 25, i32 29, i32 2, i32 6, i32 10, i32 14, i32 18, i32 22, i32 26, i32 30, i32 3, i32 7, i32 11, i32 15, i32 19, i32 23, i32 27, i32 31>
store <32 x float> %109, <32 x float>* %102
%110 = add nuw i64 %85, 4
%111 = icmp eq i64 %110, %34
br i1 %111, label %112, label %84
112: ; preds = %84
br i1 %36, label %167, label %113
113: ; preds = %80, %64, %61, %112
%114 = phi i64 [ 0, %80 ], [ 0, %64 ], [ 0, %61 ], [ %34, %112 ]
br label %115
115: ; preds = %113, %115
%116 = phi i64 [ %165, %115 ], [ %114, %113 ]
%117 = shl nsw i64 %116, 3
%118 = add nsw i64 %117, %62
%119 = getelementptr inbounds float, float* %3, i64 %118
%120 = load float, float* %119
%121 = add nsw i64 %117, %63
%122 = getelementptr inbounds float, float* %5, i64 %121
store float %120, float* %122
%123 = or i64 %117, 1
%124 = add nsw i64 %123, %62
%125 = getelementptr inbounds float, float* %3, i64 %124
%126 = load float, float* %125
%127 = add nsw i64 %123, %63
%128 = getelementptr inbounds float, float* %5, i64 %127
store float %126, float* %128
%129 = or i64 %117, 2
%130 = add nsw i64 %129, %62
%131 = getelementptr inbounds float, float* %3, i64 %130
%132 = load float, float* %131
%133 = add nsw i64 %129, %63
%134 = getelementptr inbounds float, float* %5, i64 %133
store float %132, float* %134
%135 = or i64 %117, 3
%136 = add nsw i64 %135, %62
%137 = getelementptr inbounds float, float* %3, i64 %136
%138 = load float, float* %137
%139 = add nsw i64 %135, %63
%140 = getelementptr inbounds float, float* %5, i64 %139
store float %138, float* %140
%141 = or i64 %117, 4
%142 = add nsw i64 %141, %62
%143 = getelementptr inbounds float, float* %3, i64 %142
%144 = load float, float* %143
%145 = add nsw i64 %141, %63
%146 = getelementptr inbounds float, float* %5, i64 %145
store float %144, float* %146
%147 = or i64 %117, 5
%148 = add nsw i64 %147, %62
%149 = getelementptr inbounds float, float* %3, i64 %148
%150 = load float, float* %149
%151 = add nsw i64 %147, %63
%152 = getelementptr inbounds float, float* %5, i64 %151
store float %150, float* %152
%153 = or i64 %117, 6
%154 = add nsw i64 %153, %62
%155 = getelementptr inbounds float, float* %3, i64 %154
%156 = load float, float* %155
%157 = add nsw i64 %153, %63
%158 = getelementptr inbounds float, float* %5, i64 %157
store float %156, float* %158
%159 = or i64 %117, 7
%160 = add nsw i64 %159, %62
%161 = getelementptr inbounds float, float* %3, i64 %160
%162 = load float, float* %161
%163 = add nsw i64 %159, %63
%164 = getelementptr inbounds float, float* %5, i64 %163
store float %162, float* %164
%165 = add nuw nsw i64 %116, 1
%166 = icmp eq i64 %165, %15
br i1 %166, label %167, label %115
167: ; preds = %115, %112, %37
%168 = add nuw nsw i64 %39, 8
%169 = icmp ult i64 %168, %14
%170 = add i64 %38, 1
br i1 %169, label %37, label %171
171: ; preds = %167
%172 = trunc i64 %168 to i32
br label %173
173: ; preds = %171, %7
%174 = phi i32 [ 0, %7 ], [ %172, %171 ]
%175 = icmp slt i32 %174, %0
br i1 %175, label %176, label %307
176: ; preds = %173
%177 = sub i32 %0, %174
%178 = icmp sgt i32 %1, 0
br i1 %178, label %179, label %307
179: ; preds = %176
%180 = icmp sgt i32 %177, 0
%181 = mul i32 %174, %4
%182 = mul i32 %174, %6
%183 = sext i32 %181 to i64
%184 = sext i32 %182 to i64
%185 = zext i32 %1 to i64
%186 = zext i32 %177 to i64
%187 = getelementptr float, float* %5, i64 %186
%188 = getelementptr float, float* %3, i64 %186
%189 = and i64 %186, 4294967288
%190 = add nsw i64 %189, -8
%191 = lshr exact i64 %190, 3
%192 = add nuw nsw i64 %191, 1
%193 = icmp ult i32 %177, 8
%194 = and i64 %186, 4294967288
%195 = and i64 %192, 1
%196 = icmp eq i64 %190, 0
%197 = and i64 %192, 4611686018427387902
%198 = icmp eq i64 %195, 0
%199 = icmp eq i64 %194, %186
%200 = and i64 %186, 1
%201 = icmp eq i64 %200, 0
%202 = sub nsw i64 0, %186
br label %203
203: ; preds = %179, %304
%204 = phi i64 [ 0, %179 ], [ %305, %304 ]
%205 = trunc i64 %204 to i32
%206 = shl i32 %205, 3
%207 = sext i32 %206 to i64
%208 = add nsw i64 %184, %207
%209 = getelementptr float, float* %5, i64 %208
%210 = getelementptr float, float* %187, i64 %208
%211 = add nsw i64 %183, %207
%212 = getelementptr float, float* %3, i64 %211
%213 = getelementptr float, float* %188, i64 %211
br i1 %180, label %214, label %304
214: ; preds = %203
%215 = trunc i64 %204 to i32
%216 = shl nsw i32 %215, 3
%217 = sext i32 %216 to i64
br i1 %193, label %273, label %218
218: ; preds = %214
%219 = icmp ult float* %209, %213
%220 = icmp ult float* %212, %210
%221 = and i1 %219, %220
br i1 %221, label %273, label %222
222: ; preds = %218
br i1 %196, label %256, label %223
223: ; preds = %222, %223
%224 = phi i64 [ %253, %223 ], [ 0, %222 ]
%225 = phi i64 [ %254, %223 ], [ 0, %222 ]
%226 = add nuw nsw i64 %224, %217
%227 = add nsw i64 %226, %183
%228 = getelementptr inbounds float, float* %3, i64 %227
%229 = bitcast float* %228 to <4 x float>*
%230 = load <4 x float>, <4 x float>* %229
%231 = getelementptr inbounds float, float* %228, i64 4
%232 = bitcast float* %231 to <4 x float>*
%233 = load <4 x float>, <4 x float>* %232
%234 = add nsw i64 %226, %184
%235 = getelementptr inbounds float, float* %5, i64 %234
%236 = bitcast float* %235 to <4 x float>*
store <4 x float> %230, <4 x float>* %236
%237 = getelementptr inbounds float, float* %235, i64 4
%238 = bitcast float* %237 to <4 x float>*
store <4 x float> %233, <4 x float>* %238
%239 = or i64 %224, 8
%240 = add nuw nsw i64 %239, %217
%241 = add nsw i64 %240, %183
%242 = getelementptr inbounds float, float* %3, i64 %241
%243 = bitcast float* %242 to <4 x float>*
%244 = load <4 x float>, <4 x float>* %243
%245 = getelementptr inbounds float, float* %242, i64 4
%246 = bitcast float* %245 to <4 x float>*
%247 = load <4 x float>, <4 x float>* %246
%248 = add nsw i64 %240, %184
%249 = getelementptr inbounds float, float* %5, i64 %248
%250 = bitcast float* %249 to <4 x float>*
store <4 x float> %244, <4 x float>* %250
%251 = getelementptr inbounds float, float* %249, i64 4
%252 = bitcast float* %251 to <4 x float>*
store <4 x float> %247, <4 x float>* %252
%253 = add nuw i64 %224, 16
%254 = add i64 %225, 2
%255 = icmp eq i64 %254, %197
br i1 %255, label %256, label %223
256: ; preds = %223, %222
%257 = phi i64 [ 0, %222 ], [ %253, %223 ]
br i1 %198, label %272, label %258
258: ; preds = %256
%259 = add nuw nsw i64 %257, %217
%260 = add nsw i64 %259, %183
%261 = getelementptr inbounds float, float* %3, i64 %260
%262 = bitcast float* %261 to <4 x float>*
%263 = load <4 x float>, <4 x float>* %262
%264 = getelementptr inbounds float, float* %261, i64 4
%265 = bitcast float* %264 to <4 x float>*
%266 = load <4 x float>, <4 x float>* %265
%267 = add nsw i64 %259, %184
%268 = getelementptr inbounds float, float* %5, i64 %267
%269 = bitcast float* %268 to <4 x float>*
store <4 x float> %263, <4 x float>* %269
%270 = getelementptr inbounds float, float* %268, i64 4
%271 = bitcast float* %270 to <4 x float>*
store <4 x float> %266, <4 x float>* %271
br label %272
272: ; preds = %256, %258
br i1 %199, label %304, label %273
273: ; preds = %218, %214, %272
%274 = phi i64 [ 0, %218 ], [ 0, %214 ], [ %194, %272 ]
%275 = xor i64 %274, -1
br i1 %201, label %284, label %276
276: ; preds = %273
%277 = add nuw nsw i64 %274, %217
%278 = add nsw i64 %277, %183
%279 = getelementptr inbounds float, float* %3, i64 %278
%280 = load float, float* %279
%281 = add nsw i64 %277, %184
%282 = getelementptr inbounds float, float* %5, i64 %281
store float %280, float* %282
%283 = or i64 %274, 1
br label %284
284: ; preds = %276, %273
%285 = phi i64 [ %274, %273 ], [ %283, %276 ]
%286 = icmp eq i64 %275, %202
br i1 %286, label %304, label %287
287: ; preds = %284, %287
%288 = phi i64 [ %302, %287 ], [ %285, %284 ]
%289 = add nuw nsw i64 %288, %217
%290 = add nsw i64 %289, %183
%291 = getelementptr inbounds float, float* %3, i64 %290
%292 = load float, float* %291
%293 = add nsw i64 %289, %184
%294 = getelementptr inbounds float, float* %5, i64 %293
store float %292, float* %294
%295 = add nuw nsw i64 %288, 1
%296 = add nuw nsw i64 %295, %217
%297 = add nsw i64 %296, %183
%298 = getelementptr inbounds float, float* %3, i64 %297
%299 = load float, float* %298
%300 = add nsw i64 %296, %184
%301 = getelementptr inbounds float, float* %5, i64 %300
store float %299, float* %301
%302 = add nuw nsw i64 %288, 2
%303 = icmp eq i64 %302, %186
br i1 %303, label %304, label %287
304: ; preds = %284, %287, %272, %203
%305 = add nuw nsw i64 %204, 1
%306 = icmp eq i64 %305, %185
br i1 %306, label %307, label %203
307: ; preds = %304, %176, %173
ret void
}