void camcguard2l(float amu[], int nx, int ny, int nxe, int nye, int ndim) {
  int i, j, k, nnxe;
  nnxe = ndim * nxe;
  for (k = 0; k < ny; k++) {
    for (i = 0; i < ndim; i++) {
      amu[i + nnxe * k] += amu[i + ndim * nx + nnxe * k];
      amu[i + ndim * nx + nnxe * k] = 0.0;
    }
  }
  for (j = 0; j < nx; j++) {
    for (i = 0; i < ndim; i++) {
      amu[i + ndim * j] += amu[i + ndim * j + nnxe * ny];
      amu[i + ndim * j + nnxe * ny] = 0.0;
    }
  }
  for (i = 0; i < ndim; i++) {
    amu[i] += amu[i + ndim * nx + nnxe * ny];
    amu[i + ndim * nx + nnxe * ny] = 0.0;
  }
  return;
}


x86 assembly (clang, -O0):
<camcguard2l>:
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)
mov    %r9d,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11cc <camcguard2l+0xcc>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11b9 <camcguard2l+0xb9>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x2c(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x2c(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    113d <camcguard2l+0x3d>
jmp    11be <camcguard2l+0xbe>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    112a <camcguard2l+0x2a>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1275 <camcguard2l+0x175>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1262 <camcguard2l+0x162>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11e6 <camcguard2l+0xe6>
jmp    1267 <camcguard2l+0x167>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11d3 <camcguard2l+0xd3>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12ed <camcguard2l+0x1ed>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    127c <camcguard2l+0x17c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<camcguard2l>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %esi,-0x68(%rsp)
mov    %r9d,%eax
mov    %ecx,-0x4c(%rsp)
imul   %ecx,%eax
mov    %rax,-0x48(%rsp)
mov    %r9d,-0x6c(%rsp)
mov    %r9d,%eax
mov    %edx,-0x64(%rsp)
test   %edx,%edx
jle    13bf <camcguard2l+0x2bf>
mov    -0x6c(%rsp),%ecx
mov    %ecx,%ebp
imul   -0x68(%rsp),%ebp
movslq -0x48(%rsp),%rcx
mov    -0x64(%rsp),%ebx
lea    -0x1(%rax),%rdx
mov    %rdx,-0x28(%rsp)
lea    (%rdi,%rax,4),%rdx
mov    %rdx,-0x30(%rsp)
mov    %eax,%edx
and    $0xfffffffc,%edx
mov    %rdx,-0x38(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x40(%rsp)
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rdx
mov    %rsi,-0x8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,-0x10(%rsp)
mov    %rax,%rdx
neg    %rdx
mov    %rdx,-0x20(%rsp)
lea    0x10(%rdi),%rdx
lea    0x0(,%rcx,4),%r9
lea    0x4(%rbp),%r13d
mov    %rcx,-0x18(%rsp)
mov    %ecx,%r15d
mov    %ebp,%r10d
add    $0x1,%r10d
xorps  %xmm0,%xmm0
lea    0x4(%rdi),%r12
xor    %r8d,%r8d
mov    %rbp,%rcx
mov    %rbp,-0x58(%rsp)
mov    %rbx,-0x60(%rsp)
jmp    11ec <camcguard2l+0xec>
nopl   0x0(%rax)
add    $0x1,%r8
add    %r9,%rdx
add    %r15,%r13
add    %r15,%rbp
add    %r15,%r10
add    %r9,%r12
cmp    %rbx,%r8
je     13bf <camcguard2l+0x2bf>
cmpl   $0x0,-0x6c(%rsp)
jle    11d0 <camcguard2l+0xd0>
mov    %r8,%r11
imul   -0x18(%rsp),%r11
cmpl   $0x4,-0x6c(%rsp)
jae    1210 <camcguard2l+0x110>
xor    %r14d,%r14d
jmp    1310 <camcguard2l+0x210>
nopl   0x0(%rax,%rax,1)
mov    -0x48(%rsp),%rcx
imul   %r8d,%ecx
add    -0x58(%rsp),%ecx
mov    -0x28(%rsp),%rsi
lea    (%rcx,%rsi,1),%ebx
cmp    %ecx,%ebx
jl     1267 <camcguard2l+0x167>
mov    %rsi,%rbx
shr    $0x20,%rbx
mov    $0x0,%r14d
mov    -0x60(%rsp),%rbx
jne    1310 <camcguard2l+0x210>
lea    (%rdi,%r11,4),%rbx
movslq %ecx,%rcx
mov    -0x30(%rsp),%rsi
lea    (%rsi,%rcx,4),%rsi
cmp    %rsi,%rbx
jae    1274 <camcguard2l+0x174>
lea    (%r11,%rax,1),%rsi
lea    (%rdi,%rsi,4),%rsi
lea    (%rdi,%rcx,4),%rcx
cmp    %rsi,%rcx
jae    1274 <camcguard2l+0x174>
xor    %r14d,%r14d
mov    -0x60(%rsp),%rbx
jmp    1310 <camcguard2l+0x210>
cmpq   $0x0,-0x40(%rsp)
je     13ad <camcguard2l+0x2ad>
mov    -0x10(%rsp),%rbx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%esi
movslq %esi,%rsi
movups (%rdi,%rsi,4),%xmm1
movups -0x10(%rdx,%rcx,4),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,-0x10(%rdx,%rcx,4)
movups %xmm0,(%rdi,%rsi,4)
lea    0x0(%r13,%rcx,1),%esi
movslq %esi,%rsi
movups (%rdi,%rsi,4),%xmm1
movups (%rdx,%rcx,4),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rdx,%rcx,4)
movups %xmm0,(%rdi,%rsi,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1290 <camcguard2l+0x190>
testb  $0x1,-0x8(%rsp)
je     12f7 <camcguard2l+0x1f7>
add    %r11,%rcx
mov    -0x58(%rsp),%rsi
add    %ecx,%esi
movslq %esi,%rsi
movups (%rdi,%rsi,4),%xmm1
movups (%rdi,%rcx,4),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rdi,%rcx,4)
movups %xmm0,(%rdi,%rsi,4)
mov    -0x38(%rsp),%rcx
mov    %rcx,%r14
cmp    %rax,%rcx
mov    -0x60(%rsp),%rbx
je     11d0 <camcguard2l+0xd0>
nopl   (%rax)
mov    %r14,%rcx
test   $0x1,%al
je     1344 <camcguard2l+0x244>
add    %r14,%r11
mov    -0x58(%rsp),%rcx
add    %r11d,%ecx
movslq %ecx,%rcx
movss  (%rdi,%rcx,4),%xmm1
addss  (%rdi,%r11,4),%xmm1
movss  %xmm1,(%rdi,%r11,4)
movl   $0x0,(%rdi,%rcx,4)
mov    %r14,%rcx
or     $0x1,%rcx
not    %r14
cmp    -0x20(%rsp),%r14
je     11d0 <camcguard2l+0xd0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rcx,%rbp,1),%esi
movslq %esi,%rsi
movss  (%rdi,%rsi,4),%xmm1
addss  -0x4(%r12,%rcx,4),%xmm1
movss  %xmm1,-0x4(%r12,%rcx,4)
movl   $0x0,(%rdi,%rsi,4)
lea    (%r10,%rcx,1),%esi
movslq %esi,%rsi
movss  (%rdi,%rsi,4),%xmm1
addss  (%r12,%rcx,4),%xmm1
movss  %xmm1,(%r12,%rcx,4)
movl   $0x0,(%rdi,%rsi,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1360 <camcguard2l+0x260>
jmp    11d0 <camcguard2l+0xd0>
xor    %ecx,%ecx
testb  $0x1,-0x8(%rsp)
jne    12d7 <camcguard2l+0x1d7>
jmp    12f7 <camcguard2l+0x1f7>
cmpl   $0x0,-0x68(%rsp)
mov    -0x6c(%rsp),%r15d
jle    164f <camcguard2l+0x54f>
mov    -0x48(%rsp),%rcx
imul   -0x64(%rsp),%ecx
movslq %ecx,%rsi
movslq %r15d,%r14
mov    -0x68(%rsp),%r9d
lea    (%rsi,%rax,1),%r12
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,-0x60(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x28(%rsp)
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,-0x30(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x38(%rsp)
mov    %rax,%rcx
neg    %rcx
mov    %rcx,-0x58(%rsp)
lea    0x30(%rdi),%rbx
lea    0x0(,%r14,4),%rdx
lea    0x0(,%rsi,4),%rcx
mov    %rcx,-0x40(%rsp)
lea    0x4(%rdi),%r13
lea    (%rdi,%rsi,4),%r11
xor    %r8d,%r8d
xorps  %xmm0,%xmm0
mov    %r14,-0x18(%rsp)
mov    %r12,-0x20(%rsp)
jmp    1476 <camcguard2l+0x376>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r8
add    %rdx,%rbx
add    %rdx,%r13
add    %rdx,%r11
cmp    %r9,%r8
je     164f <camcguard2l+0x54f>
test   %r15d,%r15d
jle    1460 <camcguard2l+0x360>
mov    %r8,%r10
imul   %r14,%r10
cmp    $0x8,%r15d
jb     14b6 <camcguard2l+0x3b6>
lea    (%r12,%r10,1),%rcx
lea    (%rdi,%r10,4),%rbp
lea    (%rdi,%rcx,4),%rcx
cmp    %rcx,%rbp
jae    1548 <camcguard2l+0x448>
lea    (%r10,%rax,1),%rcx
lea    (%r10,%rsi,1),%rbp
lea    (%rdi,%rcx,4),%rcx
lea    (%rdi,%rbp,4),%rbp
cmp    %rcx,%rbp
jae    1548 <camcguard2l+0x448>
xor    %ecx,%ecx
mov    %rcx,%rbp
test   $0x1,%al
je     14e5 <camcguard2l+0x3e5>
add    %rcx,%r10
lea    (%r10,%rsi,1),%rbp
movss  (%rdi,%rbp,4),%xmm1
addss  (%rdi,%r10,4),%xmm1
movss  %xmm1,(%rdi,%r10,4)
movl   $0x0,(%rdi,%rbp,4)
mov    %rcx,%rbp
or     $0x1,%rbp
not    %rcx
cmp    -0x58(%rsp),%rcx
je     1460 <camcguard2l+0x360>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r11,%rbp,4),%xmm1
addss  -0x4(%r13,%rbp,4),%xmm1
movss  %xmm1,-0x4(%r13,%rbp,4)
movl   $0x0,(%r11,%rbp,4)
movss  0x4(%r11,%rbp,4),%xmm1
addss  0x0(%r13,%rbp,4),%xmm1
movss  %xmm1,0x0(%r13,%rbp,4)
movl   $0x0,0x4(%r11,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%rax
jne    1500 <camcguard2l+0x400>
jmp    1460 <camcguard2l+0x360>
cmpq   $0x0,-0x28(%rsp)
je     1643 <camcguard2l+0x543>
mov    -0x40(%rsp),%rcx
lea    (%rbx,%rcx,1),%r15
mov    -0x38(%rsp),%r12
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%r15,%r14,4),%xmm1
movups -0x20(%r15,%r14,4),%xmm2
movups -0x30(%rbx,%r14,4),%xmm3
addps  %xmm1,%xmm3
movups -0x20(%rbx,%r14,4),%xmm1
addps  %xmm2,%xmm1
movups %xmm3,-0x30(%rbx,%r14,4)
movups %xmm1,-0x20(%rbx,%r14,4)
movups %xmm0,-0x30(%r15,%r14,4)
movups %xmm0,-0x20(%r15,%r14,4)
movups -0x10(%r15,%r14,4),%xmm1
movups (%r15,%r14,4),%xmm2
movups -0x10(%rbx,%r14,4),%xmm3
addps  %xmm1,%xmm3
movups (%rbx,%r14,4),%xmm1
addps  %xmm2,%xmm1
movups %xmm3,-0x10(%rbx,%r14,4)
movups %xmm1,(%rbx,%r14,4)
movups %xmm0,-0x10(%r15,%r14,4)
movups %xmm0,(%r15,%r14,4)
add    $0x10,%r14
add    $0xfffffffffffffffe,%r12
jne    1570 <camcguard2l+0x470>
testb  $0x1,-0x30(%rsp)
je     161e <camcguard2l+0x51e>
add    %r10,%r14
lea    (%r14,%rsi,1),%rcx
movups (%rdi,%rcx,4),%xmm1
movups 0x10(%rdi,%rcx,4),%xmm2
movups (%rdi,%r14,4),%xmm3
addps  %xmm1,%xmm3
movups 0x10(%rdi,%r14,4),%xmm1
addps  %xmm2,%xmm1
movups %xmm3,(%rdi,%r14,4)
movups %xmm1,0x10(%rdi,%r14,4)
movups %xmm0,(%rdi,%rcx,4)
movups %xmm0,0x10(%rdi,%rcx,4)
mov    -0x60(%rsp),%rbp
mov    %rbp,%rcx
cmp    %rax,%rbp
mov    -0x6c(%rsp),%r15d
mov    -0x18(%rsp),%r14
mov    -0x20(%rsp),%r12
je     1460 <camcguard2l+0x360>
jmp    14b8 <camcguard2l+0x3b8>
xor    %r14d,%r14d
testb  $0x1,-0x30(%rsp)
jne    15e9 <camcguard2l+0x4e9>
jmp    161e <camcguard2l+0x51e>
test   %r15d,%r15d
mov    -0x68(%rsp),%r10d
mov    -0x64(%rsp),%r11d
jle    171c <camcguard2l+0x61c>
mov    %r15d,%ecx
imul   %r10d,%ecx
mov    -0x48(%rsp),%r14
imul   %r11d,%r14d
add    %ecx,%r14d
cmp    $0x8,%r15d
jae    1727 <camcguard2l+0x627>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     16ab <camcguard2l+0x5ab>
add    %ecx,%r14d
movslq %r14d,%rsi
movss  (%rdi,%rsi,4),%xmm0
addss  (%rdi,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
movl   $0x0,(%rdi,%rsi,4)
or     $0x1,%rcx
neg    %rax
cmp    %rax,%rdx
je     171c <camcguard2l+0x61c>
lea    0x1(%rcx),%rdx
mov    -0x4c(%rsp),%esi
imul   %r11d,%esi
add    %esi,%r10d
imul   %r10d,%r15d
add    %r15d,%ecx
nopl   0x0(%rax)
movslq %ecx,%rcx
movss  (%rdi,%rcx,4),%xmm0
addss  -0x4(%rdi,%rdx,4),%xmm0
movss  %xmm0,-0x4(%rdi,%rdx,4)
movl   $0x0,(%rdi,%rcx,4)
lea    0x1(%rcx),%esi
movslq %esi,%rsi
movss  (%rdi,%rsi,4),%xmm0
addss  (%rdi,%rdx,4),%xmm0
movss  %xmm0,(%rdi,%rdx,4)
movl   $0x0,(%rdi,%rsi,4)
lea    (%rax,%rdx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdx
add    $0x2,%ecx
cmp    $0x1,%rsi
jne    16d0 <camcguard2l+0x5d0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%rax),%rbp
mov    -0x4c(%rsp),%esi
imul   %r11d,%esi
add    %r10d,%esi
mov    %esi,%edx
imul   %r15d,%edx
lea    (%rdx,%rbp,1),%ebx
xor    %ecx,%ecx
cmp    %edx,%ebx
jl     1681 <camcguard2l+0x581>
shr    $0x20,%rbp
jne    1681 <camcguard2l+0x581>
imul   %r15d,%esi
movslq %esi,%rcx
lea    (%rcx,%rax,1),%rsi
lea    (%rdi,%rsi,4),%rsi
cmp    %rdi,%rsi
jbe    1778 <camcguard2l+0x678>
lea    (%rdi,%rax,4),%rsi
lea    (%rdi,%rcx,4),%rcx
cmp    %rsi,%rcx
jb     167f <camcguard2l+0x57f>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1864 <camcguard2l+0x764>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %esi,%esi
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %edx,%rdx
movups (%rdi,%rdx,4),%xmm1
movups 0x10(%rdi,%rdx,4),%xmm2
movups (%rdi,%rsi,4),%xmm3
addps  %xmm1,%xmm3
movups 0x10(%rdi,%rsi,4),%xmm1
addps  %xmm2,%xmm1
movups %xmm3,(%rdi,%rsi,4)
movups %xmm1,0x10(%rdi,%rsi,4)
movups %xmm0,(%rdi,%rdx,4)
movups %xmm0,0x10(%rdi,%rdx,4)
lea    0x8(%rdx),%ebx
movslq %ebx,%rbx
movups (%rdi,%rbx,4),%xmm1
movups 0x10(%rdi,%rbx,4),%xmm2
movups 0x20(%rdi,%rsi,4),%xmm3
addps  %xmm1,%xmm3
movups 0x30(%rdi,%rsi,4),%xmm1
addps  %xmm2,%xmm1
movups %xmm3,0x20(%rdi,%rsi,4)
movups %xmm1,0x30(%rdi,%rsi,4)
movups %xmm0,(%rdi,%rbx,4)
movups %xmm0,0x10(%rdi,%rbx,4)
add    $0x10,%rsi
add    $0x10,%edx
add    $0xfffffffffffffffe,%rbp
jne    17b0 <camcguard2l+0x6b0>
test   $0x1,%r8b
je     1856 <camcguard2l+0x756>
lea    (%r14,%rsi,1),%edx
movslq %edx,%rdx
movups (%rdi,%rdx,4),%xmm0
movups 0x10(%rdi,%rdx,4),%xmm1
movups (%rdi,%rsi,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rdi,%rsi,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rdi,%rsi,4)
movups %xmm0,0x10(%rdi,%rsi,4)
xorps  %xmm0,%xmm0
movups %xmm0,(%rdi,%rdx,4)
movups %xmm0,0x10(%rdi,%rdx,4)
cmp    %rax,%rcx
jne    1681 <camcguard2l+0x581>
jmp    171c <camcguard2l+0x61c>
xor    %esi,%esi
test   $0x1,%r8b
jne    1822 <camcguard2l+0x722>
jmp    1856 <camcguard2l+0x756>

LLVM IR (-O0):
define void @camcguard2l(float* %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca float*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = 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 i32 %5, i32* %12
%17 = load i32, i32* %12
%18 = load i32, i32* %10
%19 = mul nsw i32 %17, %18
store i32 %19, i32* %16
store i32 0, i32* %15
br label %20
20: ; preds = %69, %6
%21 = load i32, i32* %15
%22 = load i32, i32* %9
%23 = icmp slt i32 %21, %22
br i1 %23, label %24, label %72
24: ; preds = %20
store i32 0, i32* %13
br label %25
25: ; preds = %65, %24
%26 = load i32, i32* %13
%27 = load i32, i32* %12
%28 = icmp slt i32 %26, %27
br i1 %28, label %29, label %68
29: ; preds = %25
%30 = load float*, float** %7
%31 = load i32, i32* %13
%32 = load i32, i32* %12
%33 = load i32, i32* %8
%34 = mul nsw i32 %32, %33
%35 = add nsw i32 %31, %34
%36 = load i32, i32* %16
%37 = load i32, i32* %15
%38 = mul nsw i32 %36, %37
%39 = add nsw i32 %35, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds float, float* %30, i64 %40
%42 = load float, float* %41
%43 = load float*, float** %7
%44 = load i32, i32* %13
%45 = load i32, i32* %16
%46 = load i32, i32* %15
%47 = mul nsw i32 %45, %46
%48 = add nsw i32 %44, %47
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float, float* %43, i64 %49
%51 = load float, float* %50
%52 = fadd float %51, %42
store float %52, float* %50
%53 = load float*, float** %7
%54 = load i32, i32* %13
%55 = load i32, i32* %12
%56 = load i32, i32* %8
%57 = mul nsw i32 %55, %56
%58 = add nsw i32 %54, %57
%59 = load i32, i32* %16
%60 = load i32, i32* %15
%61 = mul nsw i32 %59, %60
%62 = add nsw i32 %58, %61
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds float, float* %53, i64 %63
store float 0.000000e+00, float* %64
br label %65
65: ; preds = %29
%66 = load i32, i32* %13
%67 = add nsw i32 %66, 1
store i32 %67, i32* %13
br label %25
68: ; preds = %25
br label %69
69: ; preds = %68
%70 = load i32, i32* %15
%71 = add nsw i32 %70, 1
store i32 %71, i32* %15
br label %20
72: ; preds = %20
store i32 0, i32* %14
br label %73
73: ; preds = %122, %72
%74 = load i32, i32* %14
%75 = load i32, i32* %8
%76 = icmp slt i32 %74, %75
br i1 %76, label %77, label %125
77: ; preds = %73
store i32 0, i32* %13
br label %78
78: ; preds = %118, %77
%79 = load i32, i32* %13
%80 = load i32, i32* %12
%81 = icmp slt i32 %79, %80
br i1 %81, label %82, label %121
82: ; preds = %78
%83 = load float*, float** %7
%84 = load i32, i32* %13
%85 = load i32, i32* %12
%86 = load i32, i32* %14
%87 = mul nsw i32 %85, %86
%88 = add nsw i32 %84, %87
%89 = load i32, i32* %16
%90 = load i32, i32* %9
%91 = mul nsw i32 %89, %90
%92 = add nsw i32 %88, %91
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %83, i64 %93
%95 = load float, float* %94
%96 = load float*, float** %7
%97 = load i32, i32* %13
%98 = load i32, i32* %12
%99 = load i32, i32* %14
%100 = mul nsw i32 %98, %99
%101 = add nsw i32 %97, %100
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %96, i64 %102
%104 = load float, float* %103
%105 = fadd float %104, %95
store float %105, float* %103
%106 = load float*, float** %7
%107 = load i32, i32* %13
%108 = load i32, i32* %12
%109 = load i32, i32* %14
%110 = mul nsw i32 %108, %109
%111 = add nsw i32 %107, %110
%112 = load i32, i32* %16
%113 = load i32, i32* %9
%114 = mul nsw i32 %112, %113
%115 = add nsw i32 %111, %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %106, i64 %116
store float 0.000000e+00, float* %117
br label %118
118: ; preds = %82
%119 = load i32, i32* %13
%120 = add nsw i32 %119, 1
store i32 %120, i32* %13
br label %78
121: ; preds = %78
br label %122
122: ; preds = %121
%123 = load i32, i32* %14
%124 = add nsw i32 %123, 1
store i32 %124, i32* %14
br label %73
125: ; preds = %73
store i32 0, i32* %13
br label %126
126: ; preds = %162, %125
%127 = load i32, i32* %13
%128 = load i32, i32* %12
%129 = icmp slt i32 %127, %128
br i1 %129, label %130, label %165
130: ; preds = %126
%131 = load float*, float** %7
%132 = load i32, i32* %13
%133 = load i32, i32* %12
%134 = load i32, i32* %8
%135 = mul nsw i32 %133, %134
%136 = add nsw i32 %132, %135
%137 = load i32, i32* %16
%138 = load i32, i32* %9
%139 = mul nsw i32 %137, %138
%140 = add nsw i32 %136, %139
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds float, float* %131, i64 %141
%143 = load float, float* %142
%144 = load float*, float** %7
%145 = load i32, i32* %13
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
%148 = load float, float* %147
%149 = fadd float %148, %143
store float %149, float* %147
%150 = load float*, float** %7
%151 = load i32, i32* %13
%152 = load i32, i32* %12
%153 = load i32, i32* %8
%154 = mul nsw i32 %152, %153
%155 = add nsw i32 %151, %154
%156 = load i32, i32* %16
%157 = load i32, i32* %9
%158 = mul nsw i32 %156, %157
%159 = add nsw i32 %155, %158
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds float, float* %150, i64 %160
store float 0.000000e+00, float* %161
br label %162
162: ; preds = %130
%163 = load i32, i32* %13
%164 = add nsw i32 %163, 1
store i32 %164, i32* %13
br label %126
165: ; preds = %126
ret void
}

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