void bpairitymultiply(float *vector, int xlength, int ylength, int zlength,
                      int pairity, float factor) {
  int j;
  int k;
  if ((pairity == 0) && (xlength > 1))
    for (k = 0; k < zlength; k++)
      for (j = 0; j < ylength; j++)
        vector[xlength * (k * ylength + j)] *= factor;
  if (((xlength & 1) == (1 - pairity)) && (xlength > 1))
    for (k = 0; k < zlength; k++)
      for (j = 0; j < ylength; j++)
        vector[xlength * (k * ylength + j + 1) - 1] *= factor;
  if ((pairity == 0) && (ylength > 1))
    for (k = 0; k < zlength; k++)
      for (j = 0; j < xlength; j++)
        vector[xlength * k * ylength + j] *= factor;
  if (((ylength & 1) == (1 - pairity)) && (ylength > 1))
    for (k = 0; k < zlength; k++)
      for (j = 0; j < xlength; j++)
        vector[j + xlength * ((k + 1) * ylength - 1)] *= factor;
  if ((pairity == 0) && (zlength > 1))
    for (k = 0; k < ylength; k++)
      for (j = 0; j < xlength; j++)
        vector[(xlength * k) + j] *= factor;
  if (((zlength & 1) == (1 - pairity)) && (zlength > 1))
    for (k = 0; k < ylength; k++)
      for (j = 0; j < xlength; j++)
        vector[xlength * (k + (zlength - 1) * ylength) + j] *= factor;
}


x86 assembly (clang, -O0):
<bpairitymultiply>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
cmpl   $0x0,-0x18(%rbp)
jne    11a0 <bpairitymultiply+0xa0>
cmpl   $0x1,-0xc(%rbp)
jle    11a0 <bpairitymultiply+0xa0>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    119b <bpairitymultiply+0x9b>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1188 <bpairitymultiply+0x88>
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x24(%rbp),%edx
imul   -0x10(%rbp),%edx
add    -0x20(%rbp),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1148 <bpairitymultiply+0x48>
jmp    118d <bpairitymultiply+0x8d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1135 <bpairitymultiply+0x35>
jmp    11a0 <bpairitymultiply+0xa0>
mov    -0xc(%rbp),%eax
and    $0x1,%eax
mov    $0x1,%ecx
sub    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jne    1238 <bpairitymultiply+0x138>
cmpl   $0x1,-0xc(%rbp)
jle    1238 <bpairitymultiply+0x138>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1233 <bpairitymultiply+0x133>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1220 <bpairitymultiply+0x120>
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x24(%rbp),%edx
imul   -0x10(%rbp),%edx
add    -0x20(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11da <bpairitymultiply+0xda>
jmp    1225 <bpairitymultiply+0x125>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11c7 <bpairitymultiply+0xc7>
jmp    1238 <bpairitymultiply+0x138>
cmpl   $0x0,-0x18(%rbp)
jne    12bc <bpairitymultiply+0x1bc>
cmpl   $0x1,-0x10(%rbp)
jle    12bc <bpairitymultiply+0x1bc>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b7 <bpairitymultiply+0x1b7>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12a4 <bpairitymultiply+0x1a4>
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x24(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1266 <bpairitymultiply+0x166>
jmp    12a9 <bpairitymultiply+0x1a9>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1253 <bpairitymultiply+0x153>
jmp    12bc <bpairitymultiply+0x1bc>
mov    -0x10(%rbp),%eax
and    $0x1,%eax
mov    $0x1,%ecx
sub    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jne    1356 <bpairitymultiply+0x256>
cmpl   $0x1,-0x10(%rbp)
jle    1356 <bpairitymultiply+0x256>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1351 <bpairitymultiply+0x251>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    133e <bpairitymultiply+0x23e>
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0xc(%rbp),%edx
mov    -0x24(%rbp),%esi
add    $0x1,%esi
imul   -0x10(%rbp),%esi
sub    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12f6 <bpairitymultiply+0x1f6>
jmp    1343 <bpairitymultiply+0x243>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12e3 <bpairitymultiply+0x1e3>
jmp    1356 <bpairitymultiply+0x256>
cmpl   $0x0,-0x18(%rbp)
jne    13d6 <bpairitymultiply+0x2d6>
cmpl   $0x1,-0x14(%rbp)
jle    13d6 <bpairitymultiply+0x2d6>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13d1 <bpairitymultiply+0x2d1>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13be <bpairitymultiply+0x2be>
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1384 <bpairitymultiply+0x284>
jmp    13c3 <bpairitymultiply+0x2c3>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1371 <bpairitymultiply+0x271>
jmp    13d6 <bpairitymultiply+0x2d6>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
mov    $0x1,%ecx
sub    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jne    1470 <bpairitymultiply+0x370>
cmpl   $0x1,-0x14(%rbp)
jle    1470 <bpairitymultiply+0x370>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    146b <bpairitymultiply+0x36b>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1458 <bpairitymultiply+0x358>
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x24(%rbp),%edx
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
imul   -0x10(%rbp),%esi
add    %esi,%edx
imul   %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1410 <bpairitymultiply+0x310>
jmp    145d <bpairitymultiply+0x35d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13fd <bpairitymultiply+0x2fd>
jmp    1470 <bpairitymultiply+0x370>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bpairitymultiply>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %esi,%eax
mov    %ecx,-0x5c(%rsp)
mov    %ecx,%ecx
mov    %rcx,-0x48(%rsp)
mov    %edx,-0x60(%rsp)
mov    %edx,%r14d
cmp    $0x2,%esi
jl     11ee <bpairitymultiply+0xee>
test   %r8d,%r8d
jne    11ee <bpairitymultiply+0xee>
cmpl   $0x0,-0x5c(%rsp)
jle    11ee <bpairitymultiply+0xee>
movslq -0x60(%rsp),%r15
mov    %r14d,%edx
and    $0xfffffffe,%edx
mov    %r15,%r11
imul   %rax,%r11
shl    $0x2,%r11
lea    0x0(,%rax,8),%rbx
xor    %r10d,%r10d
mov    %rdi,%r9
jmp    117e <bpairitymultiply+0x7e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %r11,%r9
cmp    -0x48(%rsp),%r10
je     11ee <bpairitymultiply+0xee>
cmpl   $0x0,-0x60(%rsp)
jle    1170 <bpairitymultiply+0x70>
cmpl   $0x1,-0x60(%rsp)
jne    1190 <bpairitymultiply+0x90>
xor    %ecx,%ecx
jmp    11ca <bpairitymultiply+0xca>
mov    %r9,%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%rbp),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp)
movss  0x0(%rbp,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
add    $0x2,%rcx
add    %rbx,%rbp
cmp    %rcx,%rdx
jne    11a0 <bpairitymultiply+0xa0>
test   $0x1,%r14b
je     1170 <bpairitymultiply+0x70>
mov    %r10,%rbp
imul   %r15,%rbp
add    %rbp,%rcx
imul   %rax,%rcx
movss  (%rdi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rcx,4)
jmp    1170 <bpairitymultiply+0x70>
mov    %r14,-0x58(%rsp)
mov    $0x1,%ecx
mov    %r8d,-0x4c(%rsp)
sub    %r8d,%ecx
mov    %ecx,-0x50(%rsp)
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
mov    %rcx,-0x38(%rsp)
cmp    $0x2,%esi
mov    -0x5c(%rsp),%r9d
mov    -0x60(%rsp),%r10d
jl     1473 <bpairitymultiply+0x373>
mov    %esi,%ecx
and    $0x1,%ecx
cmp    -0x50(%rsp),%ecx
jne    1473 <bpairitymultiply+0x373>
test   %r9d,%r9d
jle    1473 <bpairitymultiply+0x373>
mov    -0x58(%rsp),%rcx
lea    -0x1(%rcx),%rdx
mov    %rdx,-0x10(%rsp)
mov    %ecx,%edx
and    $0xfffffff8,%edx
mov    %rdx,-0x18(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,-0x20(%rsp)
mov    %rdx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
mov    %rbp,%rdx
mov    %rbp,-0x28(%rsp)
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
and    %rdx,%rbp
mov    %rbp,-0x30(%rsp)
neg    %rcx
mov    %rcx,-0x8(%rsp)
lea    (%rsi,%rsi,8),%r8d
add    $0xffffffff,%r8d
mov    %r10d,%ecx
imul   %esi,%ecx
mov    %ecx,-0x3c(%rsp)
mov    %esi,%ebp
shl    $0x4,%ebp
lea    -0x1(%rsi),%r12d
lea    (%rsi,%rsi,1),%r13d
xor    %r15d,%r15d
mov    $0x1,%r14d
mov    $0x2,%r11d
jmp    12ed <bpairitymultiply+0x1ed>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r15d
mov    -0x3c(%rsp),%ecx
add    %ecx,%r8d
add    %ecx,%r12d
add    %r10d,%r14d
add    %r10d,%r11d
cmp    %r9d,%r15d
je     1473 <bpairitymultiply+0x373>
test   %r10d,%r10d
jle    12d0 <bpairitymultiply+0x1d0>
mov    %r15d,%ecx
imul   %r10d,%ecx
cmp    $0x8,%r10d
jb     1390 <bpairitymultiply+0x290>
cmp    $0x1,%esi
jne    1390 <bpairitymultiply+0x290>
mov    -0x10(%rsp),%rbx
lea    (%rcx,%rbx,1),%edx
cmp    %ecx,%edx
jl     1390 <bpairitymultiply+0x290>
mov    %rbx,%rdx
shr    $0x20,%rdx
mov    $0x0,%edx
jne    1392 <bpairitymultiply+0x292>
cmpq   $0x0,-0x20(%rsp)
je     1423 <bpairitymultiply+0x323>
mov    -0x30(%rsp),%r9
mov    %r12d,%r10d
mov    %r8d,%edx
xor    %ebx,%ebx
nop
movslq %r10d,%r10
movups (%rdi,%r10,4),%xmm2
movups 0x10(%rdi,%r10,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%r10,4)
movups %xmm3,0x10(%rdi,%r10,4)
movslq %edx,%rdx
movups (%rdi,%rdx,4),%xmm2
movups 0x10(%rdi,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%rdx,4)
movups %xmm3,0x10(%rdi,%rdx,4)
add    $0x10,%rbx
add    %ebp,%edx
add    %ebp,%r10d
add    $0xfffffffffffffffe,%r9
jne    1340 <bpairitymultiply+0x240>
jmp    1425 <bpairitymultiply+0x325>
xchg   %ax,%ax
xor    %edx,%edx
mov    %rdx,%rbx
testb  $0x1,-0x58(%rsp)
je     13bb <bpairitymultiply+0x2bb>
mov    %rdx,%rbx
or     $0x1,%rbx
add    %ebx,%ecx
imul   %esi,%ecx
movslq %ecx,%rcx
movss  -0x4(%rdi,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,-0x4(%rdi,%rcx,4)
not    %rdx
cmp    -0x8(%rsp),%rdx
je     12d0 <bpairitymultiply+0x1d0>
lea    (%r14,%rbx,1),%ecx
imul   %esi,%ecx
add    $0xffffffff,%ecx
mov    -0x58(%rsp),%rdx
sub    %rbx,%rdx
add    %r11d,%ebx
imul   %esi,%ebx
add    $0xffffffff,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %ecx,%rcx
movss  (%rdi,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rdi,%rcx,4)
movslq %ebx,%rbx
movss  (%rdi,%rbx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rdi,%rbx,4)
add    %r13d,%ecx
add    %r13d,%ebx
add    $0xfffffffffffffffe,%rdx
jne    13f0 <bpairitymultiply+0x2f0>
jmp    12d0 <bpairitymultiply+0x1d0>
xor    %ebx,%ebx
testb  $0x1,-0x28(%rsp)
mov    -0x5c(%rsp),%r9d
mov    -0x60(%rsp),%r10d
je     145b <bpairitymultiply+0x35b>
or     $0x1,%ebx
add    %ecx,%ebx
imul   %esi,%ebx
movslq %ebx,%rdx
movups -0x4(%rdi,%rdx,4),%xmm2
movups 0xc(%rdi,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x4(%rdi,%rdx,4)
movups %xmm3,0xc(%rdi,%rdx,4)
mov    -0x18(%rsp),%rbx
mov    %rbx,%rdx
cmp    -0x58(%rsp),%rbx
je     12d0 <bpairitymultiply+0x1d0>
jmp    1392 <bpairitymultiply+0x292>
cmp    $0x2,%r10d
jl     15d6 <bpairitymultiply+0x4d6>
cmpl   $0x0,-0x4c(%rsp)
jne    15d6 <bpairitymultiply+0x4d6>
cmpl   $0x0,-0x5c(%rsp)
jle    15d6 <bpairitymultiply+0x4d6>
mov    -0x60(%rsp),%r13d
imul   %esi,%r13d
mov    %eax,%r12d
and    $0xfffffff8,%r12d
lea    -0x8(%r12),%r8
mov    %r8,%r15
shr    $0x3,%r15
add    $0x1,%r15
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
mov    %r15,%r14
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
and    %rcx,%r14
lea    0x30(%rdi),%r11
xor    %r10d,%r10d
xor    %ebp,%ebp
jmp    14f2 <bpairitymultiply+0x3f2>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
add    %r13d,%r10d
cmp    -0x48(%rsp),%rbp
je     15d6 <bpairitymultiply+0x4d6>
test   %esi,%esi
jle    14e0 <bpairitymultiply+0x3e0>
movslq %r10d,%r9
cmp    $0x8,%esi
jae    1510 <bpairitymultiply+0x410>
xor    %ecx,%ecx
jmp    15a2 <bpairitymultiply+0x4a2>
cs nopw 0x0(%rax,%rax,1)
nop
test   %r8,%r8
je     15cc <bpairitymultiply+0x4cc>
lea    (%r11,%r9,4),%rdx
mov    %r14,%rbx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%rdx,%rcx,4),%xmm2
movups -0x20(%rdx,%rcx,4),%xmm3
movups -0x10(%rdx,%rcx,4),%xmm4
movups (%rdx,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%rdx,%rcx,4)
movups %xmm3,-0x20(%rdx,%rcx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%rdx,%rcx,4)
movups %xmm5,(%rdx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1530 <bpairitymultiply+0x430>
test   $0x1,%r15b
je     1596 <bpairitymultiply+0x496>
mov    %r13d,%edx
imul   %ebp,%edx
movslq %edx,%rdx
add    %rdx,%rcx
movups (%rdi,%rcx,4),%xmm2
movups 0x10(%rdi,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%rcx,4)
movups %xmm3,0x10(%rdi,%rcx,4)
mov    %r12,%rcx
cmp    %rax,%r12
je     14e0 <bpairitymultiply+0x3e0>
lea    (%rdi,%r9,4),%rdx
cs nopw 0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    15b0 <bpairitymultiply+0x4b0>
jmp    14e0 <bpairitymultiply+0x3e0>
xor    %ecx,%ecx
test   $0x1,%r15b
jne    1572 <bpairitymultiply+0x472>
jmp    1596 <bpairitymultiply+0x496>
movslq %esi,%r14
cmpl   $0x2,-0x60(%rsp)
mov    -0x5c(%rsp),%r10d
jl     1746 <bpairitymultiply+0x646>
mov    -0x60(%rsp),%ecx
and    $0x1,%ecx
cmp    -0x50(%rsp),%ecx
jne    1746 <bpairitymultiply+0x646>
test   %r10d,%r10d
jle    1746 <bpairitymultiply+0x646>
mov    %eax,%r12d
and    $0xfffffff8,%r12d
lea    -0x8(%r12),%r11
mov    %r11,%r15
shr    $0x3,%r15
add    $0x1,%r15
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
mov    %r15,%r8
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
and    %rcx,%r8
mov    -0x58(%rsp),%rdx
lea    -0x1(%rdx),%rcx
imul   %r14,%rcx
lea    (%rdi,%rcx,4),%rbp
add    $0x30,%rbp
mov    %r14,%r13
imul   %rdx,%r13
shl    $0x2,%r13
lea    (%rdi,%rcx,4),%rbx
xor    %r9d,%r9d
jmp    1671 <bpairitymultiply+0x571>
nopw   0x0(%rax,%rax,1)
add    %r13,%rbp
add    %r13,%rbx
cmp    -0x48(%rsp),%r9
je     1746 <bpairitymultiply+0x646>
add    $0x1,%r9
test   %esi,%esi
jle    1660 <bpairitymultiply+0x560>
cmp    $0x8,%esi
jae    1690 <bpairitymultiply+0x590>
xor    %ecx,%ecx
jmp    1720 <bpairitymultiply+0x620>
cs nopw 0x0(%rax,%rax,1)
nop
test   %r11,%r11
je     173c <bpairitymultiply+0x63c>
mov    %r8,%rcx
xor    %edx,%edx
xchg   %ax,%ax
movups -0x30(%rbp,%rdx,4),%xmm2
movups -0x20(%rbp,%rdx,4),%xmm3
movups -0x10(%rbp,%rdx,4),%xmm4
movups 0x0(%rbp,%rdx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%rbp,%rdx,4)
movups %xmm3,-0x20(%rbp,%rdx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%rbp,%rdx,4)
movups %xmm5,0x0(%rbp,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rcx
jne    16a0 <bpairitymultiply+0x5a0>
test   $0x1,%r15b
je     1710 <bpairitymultiply+0x610>
mov    %r9,%rcx
imul   -0x58(%rsp),%rcx
add    $0xffffffffffffffff,%rcx
imul   %r14,%rcx
add    %rcx,%rdx
movups (%rdi,%rdx,4),%xmm2
movups 0x10(%rdi,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%rdx,4)
movups %xmm3,0x10(%rdi,%rdx,4)
mov    %r12,%rcx
cmp    %rax,%r12
je     1660 <bpairitymultiply+0x560>
nopl   0x0(%rax)
movss  (%rbx,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1720 <bpairitymultiply+0x620>
jmp    1660 <bpairitymultiply+0x560>
xor    %edx,%edx
test   $0x1,%r15b
jne    16e4 <bpairitymultiply+0x5e4>
jmp    1710 <bpairitymultiply+0x610>
cmp    $0x2,%r10d
mov    -0x58(%rsp),%r13
jl     1886 <bpairitymultiply+0x786>
cmpl   $0x0,-0x4c(%rsp)
jne    1886 <bpairitymultiply+0x786>
cmpl   $0x0,-0x60(%rsp)
jle    1886 <bpairitymultiply+0x786>
mov    %eax,%r15d
and    $0xfffffff8,%r15d
lea    -0x8(%r15),%r9
mov    %r9,%r11
shr    $0x3,%r11
add    $0x1,%r11
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
mov    %r11,%r8
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
and    %rcx,%r8
lea    0x30(%rdi),%rbx
lea    0x0(,%r14,4),%r12
xor    %r10d,%r10d
mov    %rdi,%rcx
jmp    17c3 <bpairitymultiply+0x6c3>
nopl   0x0(%rax)
add    $0x1,%r10
add    %r12,%rbx
add    %r12,%rcx
cmp    %r13,%r10
je     1886 <bpairitymultiply+0x786>
test   %esi,%esi
jle    17b0 <bpairitymultiply+0x6b0>
cmp    $0x8,%esi
jae    17e0 <bpairitymultiply+0x6e0>
xor    %edx,%edx
jmp    1860 <bpairitymultiply+0x760>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r9,%r9
je     187c <bpairitymultiply+0x77c>
mov    %r8,%rdx
xor    %ebp,%ebp
xchg   %ax,%ax
movups -0x30(%rbx,%rbp,4),%xmm2
movups -0x20(%rbx,%rbp,4),%xmm3
movups -0x10(%rbx,%rbp,4),%xmm4
movups (%rbx,%rbp,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%rbx,%rbp,4)
movups %xmm3,-0x20(%rbx,%rbp,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%rbx,%rbp,4)
movups %xmm5,(%rbx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdx
jne    17f0 <bpairitymultiply+0x6f0>
test   $0x1,%r11b
je     1854 <bpairitymultiply+0x754>
mov    %r10,%rdx
imul   %r14,%rdx
add    %rdx,%rbp
movups (%rdi,%rbp,4),%xmm2
movups 0x10(%rdi,%rbp,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%rbp,4)
movups %xmm3,0x10(%rdi,%rbp,4)
mov    %r15,%rdx
cmp    %rax,%r15
je     17b0 <bpairitymultiply+0x6b0>
movss  (%rcx,%rdx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rcx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1860 <bpairitymultiply+0x760>
jmp    17b0 <bpairitymultiply+0x6b0>
xor    %ebp,%ebp
test   $0x1,%r11b
jne    1832 <bpairitymultiply+0x732>
jmp    1854 <bpairitymultiply+0x754>
mov    -0x5c(%rsp),%edx
cmp    $0x2,%edx
mov    -0x60(%rsp),%ebp
jl     19e8 <bpairitymultiply+0x8e8>
mov    %edx,%ecx
and    $0x1,%ecx
cmp    -0x50(%rsp),%ecx
jne    19e8 <bpairitymultiply+0x8e8>
test   %ebp,%ebp
jle    19e8 <bpairitymultiply+0x8e8>
add    $0xffffffff,%edx
imul   %ebp,%edx
movslq %edx,%r8
mov    %eax,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
and    %r10,-0x38(%rsp)
mov    %r14,%rdx
imul   %r8,%rdx
lea    (%rdi,%rdx,4),%rcx
add    $0x30,%rcx
lea    0x0(,%r14,4),%r15
lea    (%rdi,%rdx,4),%rbp
xor    %r12d,%r12d
jmp    1913 <bpairitymultiply+0x813>
nopl   0x0(%rax)
add    $0x1,%r12
add    %r15,%rcx
add    %r15,%rbp
cmp    %r13,%r12
je     19e8 <bpairitymultiply+0x8e8>
test   %esi,%esi
jle    1900 <bpairitymultiply+0x800>
cmp    $0x8,%esi
jae    1930 <bpairitymultiply+0x830>
xor    %edx,%edx
jmp    19c0 <bpairitymultiply+0x8c0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r9,%r9
je     19de <bpairitymultiply+0x8de>
mov    -0x38(%rsp),%rdx
xor    %ebx,%ebx
movups -0x30(%rcx,%rbx,4),%xmm2
movups -0x20(%rcx,%rbx,4),%xmm3
movups -0x10(%rcx,%rbx,4),%xmm4
movups (%rcx,%rbx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%rcx,%rbx,4)
movups %xmm3,-0x20(%rcx,%rbx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%rcx,%rbx,4)
movups %xmm5,(%rcx,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdx
jne    1940 <bpairitymultiply+0x840>
test   $0x1,%r10b
je     19a5 <bpairitymultiply+0x8a5>
lea    (%r12,%r8,1),%rdx
imul   %r14,%rdx
add    %rdx,%rbx
movups (%rdi,%rbx,4),%xmm2
movups 0x10(%rdi,%rbx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%rbx,4)
movups %xmm3,0x10(%rdi,%rbx,4)
mov    %r11,%rdx
cmp    %rax,%r11
je     1900 <bpairitymultiply+0x800>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rdx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x0(%rbp,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    19c0 <bpairitymultiply+0x8c0>
jmp    1900 <bpairitymultiply+0x800>
xor    %ebx,%ebx
test   $0x1,%r10b
jne    1982 <bpairitymultiply+0x882>
jmp    19a5 <bpairitymultiply+0x8a5>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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