void blocksum2(float *A, float *B, float *workspace, int w, int h, int c,
               float *RA, float *RB) {
  int i, j;
  int y;
  int size;
  float *QA;
  float *NA;
  float *QB;
  float *NB;
  size = w * h;
  memset(workspace, 0, 4 * size * sizeof(float));
  QA = workspace;
  NA = workspace + size;
  QB = workspace + 2 * size;
  NB = workspace + 3 * size;
  for (j = 0; j < h; j++) {
    y = j * w;
    for (i = 0; i < c; i++) {
      QA[y] += A[y + i];
      QB[y] += B[y + i];
    }
  }
  for (j = 0; j < h; j++) {
    y = j * w;
    for (i = 1; i < w; i++) {
      if (y + i + c < size) {
        QA[y + i] = QA[y + i - 1] + A[y + i + c - 1] - A[y + i - 1];
        QB[y + i] = QB[y + i - 1] + B[y + i + c - 1] - B[y + i - 1];
      } else {
        QA[y + i] = QA[y + i - 1] - A[y + i - 1];
        QB[y + i] = QB[y + i - 1] - B[y + i - 1];
      }
    }
  }
  for (i = 0; i < w; i++) {
    for (j = 0; j < c; j++) {
      NA[i] += QA[j * w + i];
      NB[i] += QB[j * w + i];
    }
  }
  for (i = 0; i < w; i++) {
    for (j = 1; j < h; j++) {
      if ((j + c) * w + i < size) {
        NA[j * w + i] =
            NA[(j - 1) * w + i] + QA[(j + c - 1) * w + i] - QA[(j - 1) * w + i];
        NB[j * w + i] =
            NB[(j - 1) * w + i] + QB[(j + c - 1) * w + i] - QB[(j - 1) * w + i];
      } else {
        NA[j * w + i] = NA[(j - 1) * w + i] - QA[(j - 1) * w + i];
        NB[j * w + i] = NB[(j - 1) * w + i] - QB[(j - 1) * w + i];
      }
    }
  }
  for (i = 0; i < size; i++) {
    RA[i] = (float)NA[i];
    RB[i] = (float)NB[i];
  }
  return;
}


x86 assembly (clang, -O0):
<blocksum2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x34(%rbp),%eax
shl    $0x2,%eax
movslq %eax,%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
imul   $0x3,-0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    123b <blocksum2+0x12b>
mov    -0x2c(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1228 <blocksum2+0x118>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11c6 <blocksum2+0xb6>
jmp    122d <blocksum2+0x11d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a9 <blocksum2+0x99>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13c8 <blocksum2+0x2b8>
mov    -0x2c(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13b5 <blocksum2+0x2a5>
mov    -0x30(%rbp),%eax
add    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    132a <blocksum2+0x21a>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    13a2 <blocksum2+0x292>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    13a7 <blocksum2+0x297>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    125f <blocksum2+0x14f>
jmp    13ba <blocksum2+0x2aa>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1242 <blocksum2+0x132>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    145f <blocksum2+0x34f>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    144c <blocksum2+0x33c>
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13e2 <blocksum2+0x2d2>
jmp    1451 <blocksum2+0x341>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13cf <blocksum2+0x2bf>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    161e <blocksum2+0x50e>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    160b <blocksum2+0x4fb>
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1568 <blocksum2+0x458>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    15f8 <blocksum2+0x4e8>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    15fd <blocksum2+0x4ed>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1479 <blocksum2+0x369>
jmp    1610 <blocksum2+0x500>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1466 <blocksum2+0x356>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1673 <blocksum2+0x563>
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1625 <blocksum2+0x515>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<blocksum2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9d,%r14d
mov    %r8d,%ebp
mov    %ecx,%r15d
mov    %rdx,%r12
mov    %rsi,0x40(%rsp)
mov    %rdi,%r13
mov    %r8d,%ebx
imul   %ecx,%ebx
lea    0x0(,%rbx,4),%eax
movslq %eax,%rdx
shl    $0x2,%rdx
mov    %r12,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    %rbx,0x48(%rsp)
movslq %ebx,%rcx
lea    (%rcx,%rcx,1),%eax
cltq
mov    %rax,0x30(%rsp)
lea    (%r12,%rax,4),%rdx
mov    %rcx,0x10(%rsp)
lea    (%rcx,%rcx,2),%eax
cltq
mov    %rax,0x20(%rsp)
mov    %ebp,%eax
mov    %rax,0x8(%rsp)
mov    %r14d,0x4(%rsp)
mov    %r14d,%eax
mov    %rax,0x28(%rsp)
mov    %r15d,%r11d
mov    %ebp,0x1c(%rsp)
test   %ebp,%ebp
mov    0x40(%rsp),%rax
mov    %r15d,%ebx
mov    %r15d,0x18(%rsp)
jle    1367 <blocksum2+0x257>
movslq %ebx,%rsi
mov    0x28(%rsp),%rcx
and    $0xfffffffe,%ecx
mov    %rax,%r8
lea    0x4(%rax),%rdi
mov    %rsi,0x38(%rsp)
lea    0x0(,%rsi,4),%r9
lea    0x4(%r13),%rbx
xor    %esi,%esi
jmp    11e5 <blocksum2+0xd5>
nopl   0x0(%rax)
add    $0x1,%rsi
add    %r9,%rdi
add    %r9,%rbx
cmp    0x8(%rsp),%rsi
je     1291 <blocksum2+0x181>
cmpl   $0x0,0x4(%rsp)
jle    11d0 <blocksum2+0xc0>
mov    %rsi,%rax
imul   0x38(%rsp),%rax
cmpl   $0x1,0x4(%rsp)
jne    1200 <blocksum2+0xf0>
xor    %ebp,%ebp
jmp    125b <blocksum2+0x14b>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x4(%rbx,%rbp,4),%xmm0
addss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
movss  -0x4(%rdi,%rbp,4),%xmm0
addss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
movss  (%rbx,%rbp,4),%xmm0
addss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
movss  (%rdi,%rbp,4),%xmm0
addss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0x2,%rbp
cmp    %rbp,%rcx
jne    1210 <blocksum2+0x100>
testb  $0x1,0x28(%rsp)
je     11d0 <blocksum2+0xc0>
add    %rax,%rbp
movss  0x0(%r13,%rbp,4),%xmm0
addss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
movss  (%r8,%rbp,4),%xmm0
addss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
jmp    11d0 <blocksum2+0xc0>
mov    %r9,0x50(%rsp)
cmpl   $0x0,0x1c(%rsp)
mov    0x18(%rsp),%ebx
jle    1367 <blocksum2+0x257>
mov    %r8,%rbp
movslq 0x4(%rsp),%r8
lea    0x0(,%r8,4),%r9
add    %r13,%r9
lea    0x0(,%r8,4),%r14
add    %rbp,%r14
add    $0x1,%r8
lea    -0x1(%r11),%r15
xor    %r10d,%r10d
mov    %r12,%rcx
mov    %rdx,%rdi
jmp    1307 <blocksum2+0x1f7>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r10
mov    0x50(%rsp),%rax
add    %rax,%rdi
add    %rax,%rbp
add    %rax,%r13
add    %rax,%rcx
add    %rax,%r9
add    %rax,%r14
add    0x38(%rsp),%r8
cmp    0x8(%rsp),%r10
je     1367 <blocksum2+0x257>
cmp    $0x2,%ebx
jl     12e0 <blocksum2+0x1d0>
xor    %eax,%eax
jmp    1337 <blocksum2+0x227>
subss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,0x4(%rcx,%rax,4)
movss  (%rdi,%rax,4),%xmm0
subss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x4(%rdi,%rax,4)
add    $0x1,%rax
cmp    %rax,%r15
je     12e0 <blocksum2+0x1d0>
lea    (%r8,%rax,1),%rsi
movss  (%rcx,%rax,4),%xmm0
cmp    0x10(%rsp),%rsi
jge    1310 <blocksum2+0x200>
addss  (%r9,%rax,4),%xmm0
subss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,0x4(%rcx,%rax,4)
movss  (%rdi,%rax,4),%xmm0
addss  (%r14,%rax,4),%xmm0
jmp    1322 <blocksum2+0x212>
mov    0x10(%rsp),%r13
lea    (%r12,%r13,4),%rcx
mov    0x20(%rsp),%rax
lea    (%r12,%rax,4),%rbp
test   %ebx,%ebx
jle    1556 <blocksum2+0x446>
mov    0x28(%rsp),%r8
and    $0xfffffffe,%r8d
mov    0x30(%rsp),%rax
lea    0x0(,%rax,4),%r9
lea    0x0(,%r11,4),%r14
lea    (%r14,%rax,4),%r15
lea    0x0(,%r11,8),%rsi
xor    %eax,%eax
mov    %r12,%r10
jmp    13d1 <blocksum2+0x2c1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
add    $0x4,%r10
cmp    %r11,%rax
je     1486 <blocksum2+0x376>
cmpl   $0x0,0x4(%rsp)
jle    13c0 <blocksum2+0x2b0>
cmpl   $0x1,0x4(%rsp)
jne    13f0 <blocksum2+0x2e0>
xor    %edi,%edi
jmp    144e <blocksum2+0x33e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r10,%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx),%xmm0
addss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
movss  (%rbx,%r9,1),%xmm0
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
movss  (%rbx,%r14,1),%xmm0
addss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
movss  (%rbx,%r15,1),%xmm0
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x2,%rdi
add    %rsi,%rbx
cmp    %rdi,%r8
jne    1400 <blocksum2+0x2f0>
testb  $0x1,0x28(%rsp)
je     13c0 <blocksum2+0x2b0>
imul   %r11,%rdi
add    %rax,%rdi
movss  (%r12,%rdi,4),%xmm0
addss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
movss  (%rdx,%rdi,4),%xmm0
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
jmp    13c0 <blocksum2+0x2b0>
cmpl   $0x0,0x18(%rsp)
jle    1556 <blocksum2+0x446>
movslq 0x4(%rsp),%r10
lea    (%r11,%r13,1),%rax
lea    (%r12,%rax,4),%r14
mov    %r10,%rax
imul   %r11,%rax
lea    (%r12,%rax,4),%r8
add    0x30(%rsp),%rax
lea    (%r12,%rax,4),%r9
add    $0x1,%r10
imul   %r11,%r10
addq   $0xffffffffffffffff,0x8(%rsp)
xor    %r15d,%r15d
jmp    14d9 <blocksum2+0x3c9>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15
cmp    %r11,%r15
je     1556 <blocksum2+0x446>
cmpl   $0x2,0x1c(%rsp)
jl     14d0 <blocksum2+0x3c0>
mov    $0x1,%eax
mov    0x8(%rsp),%rsi
mov    %r15,%rdi
jmp    151e <blocksum2+0x40e>
nop
subss  (%r12,%rdi,4),%xmm0
lea    (%r11,%rdi,1),%rbx
movss  %xmm0,(%r14,%rdi,4)
movss  0x0(%rbp,%rdi,4),%xmm0
subss  (%rdx,%rdi,4),%xmm0
movss  %xmm0,0x0(%rbp,%rbx,4)
add    $0x1,%rax
add    %r11,%rdi
add    $0xffffffffffffffff,%rsi
je     14d0 <blocksum2+0x3c0>
lea    (%r10,%rdi,1),%rbx
movss  (%rcx,%rdi,4),%xmm0
cmp    %r13,%rbx
jge    14f0 <blocksum2+0x3e0>
addss  (%r8,%rdi,4),%xmm0
subss  (%r12,%rdi,4),%xmm0
mov    %rax,%rbx
imul   %r11,%rbx
add    %r15,%rbx
movss  %xmm0,(%r14,%rdi,4)
movss  0x0(%rbp,%rdi,4),%xmm0
addss  (%r9,%rdi,4),%xmm0
jmp    1506 <blocksum2+0x3f6>
mov    0x48(%rsp),%rax
test   %eax,%eax
jle    1789 <blocksum2+0x679>
mov    0x98(%rsp),%r10
mov    0x90(%rsp),%r11
mov    %eax,%r9d
cmp    $0x8,%eax
jae    1582 <blocksum2+0x472>
xor    %edi,%edi
jmp    1706 <blocksum2+0x5f6>
lea    (%r11,%r9,4),%rsi
lea    (%r10,%r9,4),%rdi
mov    0x20(%rsp),%rax
add    %r9,%rax
cmp    %r11,%rdi
seta   0x4(%rsp)
lea    (%r12,%rax,4),%rbx
cmp    %r10,%rsi
seta   %r15b
lea    (%r9,%r13,1),%rdx
cmp    %r11,%rbx
seta   %al
lea    (%r12,%rdx,4),%r14
cmp    %rsi,%rbp
setb   %r8b
cmp    %r11,%r14
seta   %dl
cmp    %rsi,%rcx
setb   %r13b
cmp    %r10,%rbx
seta   %bl
cmp    %rdi,%rbp
setb   0x8(%rsp)
cmp    %r10,%r14
seta   %sil
cmp    %rdi,%rcx
setb   %r14b
xor    %edi,%edi
test   %r15b,0x4(%rsp)
jne    1701 <blocksum2+0x5f1>
and    %r8b,%al
jne    1701 <blocksum2+0x5f1>
and    %r13b,%dl
jne    1701 <blocksum2+0x5f1>
and    0x8(%rsp),%bl
mov    0x10(%rsp),%r13
jne    1706 <blocksum2+0x5f6>
and    %r14b,%sil
jne    1706 <blocksum2+0x5f6>
mov    %r9d,%edi
and    $0xfffffff8,%edi
lea    -0x8(%rdi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     16f7 <blocksum2+0x5e7>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
lea    (%r12,%r13,4),%rdx
add    $0x30,%rdx
mov    0x20(%rsp),%rsi
lea    (%r12,%rsi,4),%rsi
add    $0x30,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%rdx,%rbx,4),%xmm0
movups -0x20(%rdx,%rbx,4),%xmm1
movups %xmm0,(%r11,%rbx,4)
movups %xmm1,0x10(%r11,%rbx,4)
movups -0x30(%rsi,%rbx,4),%xmm0
movups -0x20(%rsi,%rbx,4),%xmm1
movups %xmm0,(%r10,%rbx,4)
movups %xmm1,0x10(%r10,%rbx,4)
movups -0x10(%rdx,%rbx,4),%xmm0
movups (%rdx,%rbx,4),%xmm1
movups %xmm0,0x20(%r11,%rbx,4)
movups %xmm1,0x30(%r11,%rbx,4)
movups -0x10(%rsi,%rbx,4),%xmm0
movups (%rsi,%rbx,4),%xmm1
movups %xmm0,0x20(%r10,%rbx,4)
movups %xmm1,0x30(%r10,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rax
jne    1660 <blocksum2+0x550>
test   $0x1,%r8b
je     16ed <blocksum2+0x5dd>
movups (%rcx,%rbx,4),%xmm0
movups 0x10(%rcx,%rbx,4),%xmm1
movups %xmm0,(%r11,%rbx,4)
movups %xmm1,0x10(%r11,%rbx,4)
movups 0x0(%rbp,%rbx,4),%xmm0
movups 0x10(%rbp,%rbx,4),%xmm1
movups %xmm0,(%r10,%rbx,4)
movups %xmm1,0x10(%r10,%rbx,4)
cmp    %r9,%rdi
jne    1706 <blocksum2+0x5f6>
jmp    1789 <blocksum2+0x679>
xor    %ebx,%ebx
test   $0x1,%r8b
jne    16c4 <blocksum2+0x5b4>
jmp    16ed <blocksum2+0x5dd>
mov    0x10(%rsp),%r13
mov    %rdi,%rax
not    %rax
test   $0x1,%r9b
je     172d <blocksum2+0x61d>
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,(%r11,%rdi,4)
movss  0x0(%rbp,%rdi,4),%xmm0
movss  %xmm0,(%r10,%rdi,4)
or     $0x1,%rdi
add    %r9,%rax
je     1789 <blocksum2+0x679>
mov    0x20(%rsp),%rax
lea    (%r12,%rax,4),%rax
add    $0x4,%rax
lea    (%r12,%r13,4),%rcx
add    $0x4,%rcx
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rcx,%rdi,4),%xmm0
movss  %xmm0,(%r11,%rdi,4)
movss  -0x4(%rax,%rdi,4),%xmm0
movss  %xmm0,(%r10,%rdi,4)
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,0x4(%r11,%rdi,4)
movss  (%rax,%rdi,4),%xmm0
movss  %xmm0,0x4(%r10,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r9
jne    1750 <blocksum2+0x640>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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