double relax_redblack(double *u, unsigned sizex, unsigned sizey) {
  double unew, diff, sum = 0.0;
  int nbx, bx, nby, by;
  int lsw;
  nbx = 8;
  bx = sizex / nbx;
  nby = 8;
  by = sizey / nby;
  for (int ii = 0; ii < nbx; ii++) {
    lsw = ii % 2;
    for (int jj = lsw; jj < nby; jj = jj + 2)
      for (int i = 1 + ii * bx;
           i <=
           ((((ii + 1) * bx) < (sizex - 2)) ? ((ii + 1) * bx) : (sizex - 2));
           i++)
        for (int j = 1 + jj * by;
             j <=
             ((((jj + 1) * by) < (sizey - 2)) ? ((jj + 1) * by) : (sizey - 2));
             j++) {
          unew = 0.25 * (u[i * sizey + (j - 1)] + u[i * sizey + (j + 1)] +
                         u[(i - 1) * sizey + j] + u[(i + 1) * sizey + j]);
          diff = unew - u[i * sizey + j];
          sum += diff * diff;
          u[i * sizey + j] = unew;
        }
  }
  for (int ii = 0; ii < nbx; ii++) {
    lsw = (ii + 1) % 2;
    for (int jj = lsw; jj < nby; jj = jj + 2)
      for (int i = 1 + ii * bx;
           i <=
           ((((ii + 1) * bx) < (sizex - 2)) ? ((ii + 1) * bx) : (sizex - 2));
           i++)
        for (int j = 1 + jj * by;
             j <=
             ((((jj + 1) * by) < (sizey - 2)) ? ((jj + 1) * by) : (sizey - 2));
             j++) {
          unew = 0.25 * (u[i * sizey + (j - 1)] + u[i * sizey + (j + 1)] +
                         u[(i - 1) * sizey + j] + u[(i + 1) * sizey + j]);
          diff = unew - u[i * sizey + j];
          sum += diff * diff;
          u[i * sizey + j] = unew;
        }
  }
  return sum;
}


x86 assembly (clang, -O0):
<relax_redblack>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x8,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
xor    %edx,%edx
divl   -0x2c(%rbp)
mov    %eax,-0x30(%rbp)
movl   $0x8,-0x34(%rbp)
mov    -0x10(%rbp),%eax
xor    %edx,%edx
divl   -0x34(%rbp)
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1326 <relax_redblack+0x226>
mov    -0x40(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %edx,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1313 <relax_redblack+0x213>
mov    -0x40(%rbp),%eax
imul   -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
imul   -0x30(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jae    11aa <relax_redblack+0xaa>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
imul   -0x30(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    11b3 <relax_redblack+0xb3>
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x64(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x64(%rbp),%ecx
cmp    %ecx,%eax
ja     1300 <relax_redblack+0x200>
mov    -0x44(%rbp),%eax
imul   -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
imul   -0x38(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jae    11fe <relax_redblack+0xfe>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
imul   -0x38(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1207 <relax_redblack+0x107>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x6c(%rbp),%ecx
cmp    %ecx,%eax
ja     12ed <relax_redblack+0x1ed>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x10(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    %ecx,%ecx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
imul   -0x10(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    %ecx,%ecx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xd7f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    %ecx,%ecx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11ce <relax_redblack+0xce>
jmp    12f2 <relax_redblack+0x1f2>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    117a <relax_redblack+0x7a>
jmp    1305 <relax_redblack+0x205>
mov    -0x44(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x44(%rbp)
jmp    1161 <relax_redblack+0x61>
jmp    1318 <relax_redblack+0x218>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1141 <relax_redblack+0x41>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1515 <relax_redblack+0x415>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %edx,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1502 <relax_redblack+0x402>
mov    -0x50(%rbp),%eax
imul   -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
imul   -0x30(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jae    1399 <relax_redblack+0x299>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
imul   -0x30(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    13a2 <relax_redblack+0x2a2>
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x74(%rbp),%ecx
cmp    %ecx,%eax
ja     14ef <relax_redblack+0x3ef>
mov    -0x54(%rbp),%eax
imul   -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
imul   -0x38(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jae    13ed <relax_redblack+0x2ed>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
imul   -0x38(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    13f6 <relax_redblack+0x2f6>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x7c(%rbp),%ecx
cmp    %ecx,%eax
ja     14dc <relax_redblack+0x3dc>
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x5c(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x5c(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x10(%rbp),%ecx
add    -0x5c(%rbp),%ecx
mov    %ecx,%ecx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
imul   -0x10(%rbp),%ecx
add    -0x5c(%rbp),%ecx
mov    %ecx,%ecx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xb90(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x5c(%rbp),%ecx
mov    %ecx,%ecx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x5c(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13bd <relax_redblack+0x2bd>
jmp    14e1 <relax_redblack+0x3e1>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1369 <relax_redblack+0x269>
jmp    14f4 <relax_redblack+0x3f4>
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
jmp    1350 <relax_redblack+0x250>
jmp    1507 <relax_redblack+0x407>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    132d <relax_redblack+0x22d>
movsd  -0x28(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<relax_redblack>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%eax
shr    $0x3,%eax
mov    %edx,%ecx
shr    $0x3,%ecx
add    $0xfffffffe,%esi
mov    %esi,-0x74(%rsp)
lea    -0x2(%rdx),%esi
mov    %esi,-0x70(%rsp)
mov    %rcx,-0x68(%rsp)
add    %ecx,%ecx
mov    %ecx,-0x6c(%rsp)
lea    (%rdx,%rdx,1),%esi
add    $0x1,%esi
mov    %edx,%ecx
mov    %eax,-0x78(%rsp)
imul   %eax,%ecx
mov    %ecx,-0x7c(%rsp)
mov    %edx,%eax
mov    %rax,%rcx
shr    $0x2,%rcx
and    $0xfffffffe,%ecx
mov    %rcx,-0x38(%rsp)
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
movsd  0xea0(%rip),%xmm1
mov    %rdx,-0x40(%rsp)
mov    %edx,%ebx
xor    %r14d,%r14d
jmp    1198 <relax_redblack+0x98>
nopl   0x0(%rax)
mov    -0x7c(%rsp),%ecx
mov    -0x48(%rsp),%rsi
add    %ecx,%esi
mov    -0x50(%rsp),%rbp
add    %ecx,%ebp
mov    -0x58(%rsp),%rbx
add    %ecx,%ebx
mov    -0x60(%rsp),%r14d
cmp    $0x8,%r14d
je     1300 <relax_redblack+0x200>
mov    %r14d,%edx
and    $0x1,%edx
mov    -0x68(%rsp),%rcx
imul   %edx,%ecx
mov    %rsi,-0x48(%rsp)
lea    (%rsi,%rcx,1),%r11d
mov    %rbp,-0x50(%rsp)
lea    (%rcx,%rbp,1),%r8d
mov    %rbx,-0x58(%rsp)
lea    (%rbx,%rcx,1),%ebp
add    $0x1,%ecx
mov    %r14d,%r13d
mov    -0x78(%rsp),%esi
imul   %esi,%r13d
add    $0x1,%r14d
mov    %r14d,-0x60(%rsp)
imul   %esi,%r14d
mov    -0x74(%rsp),%esi
cmp    %esi,%r14d
cmovae %esi,%r14d
mov    %r13d,-0x30(%rsp)
jmp    122e <relax_redblack+0x12e>
nopl   (%rax)
mov    -0x10(%rsp),%rbx
lea    0x2(%rbx),%esi
mov    -0x8(%rsp),%rcx
add    -0x6c(%rsp),%ecx
mov    -0x38(%rsp),%rdx
mov    -0x18(%rsp),%r11
add    %rdx,%r11
mov    -0x20(%rsp),%r8
add    %rdx,%r8
mov    -0x28(%rsp),%rbp
add    %rdx,%rbp
cmp    $0x6,%ebx
mov    %esi,%edx
mov    -0x30(%rsp),%r13d
jae    1170 <relax_redblack+0x70>
cmp    %r14d,%r13d
mov    %rcx,-0x8(%rsp)
mov    %rdx,-0x10(%rsp)
mov    %r11,-0x18(%rsp)
mov    %r8,-0x20(%rsp)
mov    %rbp,-0x28(%rsp)
jae    11f0 <relax_redblack+0xf0>
mov    %ecx,%esi
add    $0xffffffffffffffff,%rsi
mov    %edx,%ebx
mov    -0x68(%rsp),%rcx
imul   %ecx,%ebx
lea    0x1(%rdx),%r15d
imul   %ecx,%r15d
mov    -0x70(%rsp),%ecx
cmp    %ecx,%r15d
cmovae %ecx,%r15d
mov    %r8,%rcx
jmp    1292 <relax_redblack+0x192>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %rax,%r11
add    %rax,%rcx
add    %rax,%rbp
cmp    %r14d,%r13d
jae    11f0 <relax_redblack+0xf0>
add    $0x1,%r13d
cmp    %r15d,%ebx
jae    1280 <relax_redblack+0x180>
xor    %r9d,%r9d
xchg   %ax,%ax
lea    (%r9,%rbp,1),%r12
lea    0x1(%r12),%r10d
mov    %r12d,%r8d
movsd  (%rdi,%r8,8),%xmm2
add    $0x2,%r12d
addsd  (%rdi,%r12,8),%xmm2
lea    (%rcx,%r9,1),%edx
add    $0x1,%edx
addsd  (%rdi,%rdx,8),%xmm2
lea    (%r11,%r9,1),%edx
addsd  (%rdi,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm2,%xmm3
subsd  (%rdi,%r10,8),%xmm3
mulsd  %xmm3,%xmm3
addsd  %xmm3,%xmm0
movsd  %xmm2,(%rdi,%r10,8)
lea    (%rsi,%r9,1),%rdx
add    $0x1,%rdx
add    $0x1,%r9
cmp    %r15,%rdx
jb     12a0 <relax_redblack+0x1a0>
jmp    1280 <relax_redblack+0x180>
mov    -0x68(%rsp),%rcx
add    $0x1,%ecx
mov    %ecx,(%rsp)
mov    -0x40(%rsp),%rcx
lea    (%rcx,%rcx,1),%r8d
mov    %rax,%rdx
shr    $0x2,%rdx
and    $0xfffffffe,%edx
mov    %rdx,-0x38(%rsp)
lea    -0x1(%rcx),%r10d
mov    $0x1,%bl
xor    %r11d,%r11d
xor    %edx,%edx
jmp    1367 <relax_redblack+0x267>
mov    -0x58(%rsp),%bl
xor    $0x1,%bl
mov    -0x7c(%rsp),%edx
mov    -0x48(%rsp),%r8
add    %edx,%r8d
mov    -0x60(%rsp),%r11
add    %edx,%r11d
mov    -0x40(%rsp),%rcx
add    %edx,%ecx
mov    -0x50(%rsp),%r10
add    %edx,%r10d
mov    0x4(%rsp),%edx
cmp    $0x8,%edx
je     14f9 <relax_redblack+0x3f9>
mov    %bl,-0x58(%rsp)
test   $0x1,%bl
mov    $0x1,%ebx
cmovne (%rsp),%ebx
mov    %edx,%ebp
lea    0x1(%rbp),%r14d
mov    %r14d,%edx
and    $0x1,%edx
mov    -0x78(%rsp),%r9d
imul   %r9d,%ebp
mov    %rbp,-0x30(%rsp)
mov    %r14d,0x4(%rsp)
imul   %r9d,%r14d
mov    -0x74(%rsp),%ebp
cmp    %ebp,%r14d
cmovae %ebp,%r14d
mov    %r8,-0x48(%rsp)
lea    (%rbx,%r8,1),%esi
mov    %r11,-0x60(%rsp)
lea    (%rbx,%r11,1),%r15d
mov    %rcx,-0x40(%rsp)
add    %ebx,%ecx
mov    %r10,-0x50(%rsp)
mov    %r10,%rbp
lea    (%rbx,%r10,1),%r12d
jmp    140e <relax_redblack+0x30e>
nopl   0x0(%rax)
mov    -0x10(%rsp),%rbp
lea    0x2(%rbp),%r8d
mov    -0x8(%rsp),%rbx
add    -0x6c(%rsp),%ebx
mov    -0x38(%rsp),%rdx
mov    -0x18(%rsp),%rsi
add    %rdx,%rsi
mov    -0x20(%rsp),%r15
add    %rdx,%r15
mov    -0x28(%rsp),%rcx
add    %rdx,%rcx
add    %rdx,%r12
cmp    $0x6,%ebp
mov    %r8d,%edx
jae    1330 <relax_redblack+0x230>
mov    -0x30(%rsp),%rbp
cmp    %r14d,%ebp
mov    %rbx,-0x8(%rsp)
mov    %rdx,-0x10(%rsp)
mov    %rsi,-0x18(%rsp)
mov    %r15,-0x20(%rsp)
mov    %rcx,-0x28(%rsp)
jae    13d0 <relax_redblack+0x2d0>
mov    %ebx,%ebx
add    $0xffffffffffffffff,%rbx
mov    %edx,%r9d
mov    -0x68(%rsp),%r8
imul   %r8d,%r9d
lea    0x1(%rdx),%r11d
imul   %r8d,%r11d
mov    -0x70(%rsp),%edx
cmp    %edx,%r11d
cmovae %edx,%r11d
mov    %r12,%r13
mov    %rsi,%rdx
mov    %rbp,%rsi
mov    %esi,%r8d
jmp    1485 <relax_redblack+0x385>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %rax,%rdx
add    %rax,%r15
add    %rax,%rcx
add    %rax,%r13
cmp    %r14d,%r8d
jae    13d0 <relax_redblack+0x2d0>
add    $0x1,%r8d
cmp    %r11d,%r9d
jae    1470 <relax_redblack+0x370>
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%r10,1),%rbp
lea    (%r10,%r13,1),%esi
movsd  (%rdi,%rsi,8),%xmm2
lea    0x1(%rbp),%esi
addsd  (%rdi,%rsi,8),%xmm2
lea    (%r15,%r10,1),%esi
addsd  (%rdi,%rsi,8),%xmm2
lea    (%rdx,%r10,1),%esi
addsd  (%rdi,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
mov    %ebp,%esi
movapd %xmm2,%xmm3
subsd  (%rdi,%rsi,8),%xmm3
mulsd  %xmm3,%xmm3
addsd  %xmm3,%xmm0
movsd  %xmm2,(%rdi,%rsi,8)
lea    (%rbx,%r10,1),%rsi
add    $0x1,%rsi
add    $0x1,%r10
cmp    %r11,%rsi
jb     14a0 <relax_redblack+0x3a0>
jmp    1470 <relax_redblack+0x370>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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