void build_coverage_map(double real[4][4][4096], int good[4][4][4096],
                        double ng, int stage) {
  int i, j, k, l, tmp, decomp[3];
  double thresh = 0.2;
  for (i = 0; i < 4; i++)
    for (j = 0; j < 4; j++)
      for (k = 0; k < 4096; k++)
        good[i][j][k] = 0;
  for (i = 0; i < 4; i++)
    for (j = 0; j < 64; j++) {
      if (real[0][i][j] / ng >= thresh) {
        for (k = 0; k < 4; k++)
          good[0][k][j] = 1;
      }
    }
  for (i = 0; i < 4; i++)
    for (j = 0; j < 256; j++) {
      decomp[0] = (j & 252) >> 2;
      decomp[1] = j & 63;
      if (good[0][i][decomp[0]] == 0 || good[0][i][decomp[1]] == 0)
        continue;
      good[1][i][j] = 1;
    }
  for (i = 0; i < 4; i++)
    for (j = 0; j < 1024; j++) {
      decomp[0] = (j & 1008) >> 4;
      decomp[1] = (j & 252) >> 2;
      decomp[2] = j & 63;
      if (good[0][i][decomp[0]] == 0 || good[0][i][decomp[1]] == 0 ||
          good[0][i][decomp[2]] == 0)
        continue;
      good[2][i][j] = 1;
      tmp = j;
      for (k = 0; k <= 16; k += 16) {
        tmp = tmp ^ k;
        for (l = 0; l <= 32; l += 32) {
          tmp = tmp ^ l;
          if (good[2][i][tmp] == 0)
            good[2][i][tmp] = 2;
        }
      }
    }
  for (i = 0; i < 4; i++)
    for (j = 0; j < 4096; j++) {
      decomp[0] = (j & 4092) >> 2;
      decomp[1] = j & 1023;
      if (good[2][i][decomp[0]] == 0 || good[2][i][decomp[1]] == 0)
        continue;
      if (good[2][i][decomp[0]] == 1 && good[2][i][decomp[1]] == 1)
        good[3][i][j] = 1;
      else
        good[3][i][j] = 2;
    }
}


x86 assembly (clang, -O0):
<build_coverage_map>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movsd  0xee4(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x4,-0x20(%rbp)
jge    11b0 <build_coverage_map+0xb0>
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    119d <build_coverage_map+0x9d>
movl   $0x0,-0x28(%rbp)
cmpl   $0x1000,-0x28(%rbp)
jge    118a <build_coverage_map+0x8a>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x10,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    114a <build_coverage_map+0x4a>
jmp    118f <build_coverage_map+0x8f>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1139 <build_coverage_map+0x39>
jmp    11a2 <build_coverage_map+0xa2>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1128 <build_coverage_map+0x28>
movl   $0x0,-0x20(%rbp)
cmpl   $0x4,-0x20(%rbp)
jge    125e <build_coverage_map+0x15e>
movl   $0x0,-0x24(%rbp)
cmpl   $0x40,-0x24(%rbp)
jge    124b <build_coverage_map+0x14b>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0xf,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x18(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jb     1238 <build_coverage_map+0x138>
movl   $0x0,-0x28(%rbp)
cmpl   $0x4,-0x28(%rbp)
jge    1233 <build_coverage_map+0x133>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1201 <build_coverage_map+0x101>
jmp    1238 <build_coverage_map+0x138>
jmp    123d <build_coverage_map+0x13d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11c8 <build_coverage_map+0xc8>
jmp    1250 <build_coverage_map+0x150>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11b7 <build_coverage_map+0xb7>
movl   $0x0,-0x20(%rbp)
cmpl   $0x4,-0x20(%rbp)
jge    131a <build_coverage_map+0x21a>
movl   $0x0,-0x24(%rbp)
cmpl   $0x100,-0x24(%rbp)
jge    1307 <build_coverage_map+0x207>
mov    -0x24(%rbp),%eax
and    $0xfc,%eax
sar    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x24(%rbp),%eax
and    $0x3f,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     12d4 <build_coverage_map+0x1d4>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    12d9 <build_coverage_map+0x1d9>
jmp    12f9 <build_coverage_map+0x1f9>
mov    -0x10(%rbp),%rax
add    $0x10000,%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1276 <build_coverage_map+0x176>
jmp    130c <build_coverage_map+0x20c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1265 <build_coverage_map+0x165>
movl   $0x0,-0x20(%rbp)
cmpl   $0x4,-0x20(%rbp)
jge    14a9 <build_coverage_map+0x3a9>
movl   $0x0,-0x24(%rbp)
cmpl   $0x400,-0x24(%rbp)
jge    1496 <build_coverage_map+0x396>
mov    -0x24(%rbp),%eax
and    $0x3f0,%eax
sar    $0x4,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x24(%rbp),%eax
and    $0xfc,%eax
sar    $0x2,%eax
mov    %eax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
and    $0x3f,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     13bb <build_coverage_map+0x2bb>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     13bb <build_coverage_map+0x2bb>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    13c0 <build_coverage_map+0x2c0>
jmp    1488 <build_coverage_map+0x388>
mov    -0x10(%rbp),%rax
add    $0x20000,%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x10,-0x28(%rbp)
jg     1483 <build_coverage_map+0x383>
mov    -0x30(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x20,-0x2c(%rbp)
jg     1470 <build_coverage_map+0x370>
mov    -0x30(%rbp),%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20000,%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    145d <build_coverage_map+0x35d>
mov    -0x10(%rbp),%rax
add    $0x20000,%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movl   $0x2,(%rax,%rcx,4)
jmp    1462 <build_coverage_map+0x362>
mov    -0x2c(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x2c(%rbp)
jmp    1407 <build_coverage_map+0x307>
jmp    1475 <build_coverage_map+0x375>
mov    -0x28(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x28(%rbp)
jmp    13ed <build_coverage_map+0x2ed>
jmp    1488 <build_coverage_map+0x388>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1332 <build_coverage_map+0x232>
jmp    149b <build_coverage_map+0x39b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1321 <build_coverage_map+0x221>
movl   $0x0,-0x20(%rbp)
cmpl   $0x4,-0x20(%rbp)
jge    15e3 <build_coverage_map+0x4e3>
movl   $0x0,-0x24(%rbp)
cmpl   $0x1000,-0x24(%rbp)
jge    15d0 <build_coverage_map+0x4d0>
mov    -0x24(%rbp),%eax
and    $0xffc,%eax
sar    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x24(%rbp),%eax
and    $0x3ff,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20000,%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     152d <build_coverage_map+0x42d>
mov    -0x10(%rbp),%rax
add    $0x20000,%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1532 <build_coverage_map+0x432>
jmp    15c2 <build_coverage_map+0x4c2>
mov    -0x10(%rbp),%rax
add    $0x20000,%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    159d <build_coverage_map+0x49d>
mov    -0x10(%rbp),%rax
add    $0x20000,%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    159d <build_coverage_map+0x49d>
mov    -0x10(%rbp),%rax
add    $0x30000,%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    15bd <build_coverage_map+0x4bd>
mov    -0x10(%rbp),%rax
add    $0x30000,%rax
movslq -0x20(%rbp),%rcx
shl    $0xe,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movl   $0x2,(%rax,%rcx,4)
jmp    15c2 <build_coverage_map+0x4c2>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14c1 <build_coverage_map+0x3c1>
jmp    15d5 <build_coverage_map+0x4d5>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14b0 <build_coverage_map+0x3b0>
pop    %rbp
ret

x86 assembly (clang, -O2):
<build_coverage_map>:
push   %r15
push   %r14
push   %rbx
sub    $0x10,%rsp
movsd  %xmm0,0x8(%rsp)
mov    %rsi,%r15
mov    %rdi,%r14
xor    %ebx,%ebx
mov    $0x40000,%edx
mov    %rsi,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
movsd  0x8(%rsp),%xmm2
movsd  0xebc(%rip),%xmm0
jmp    115a <build_coverage_map+0x4a>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x40,%rbx
je     1198 <build_coverage_map+0x88>
movsd  (%r14,%rbx,8),%xmm1
divsd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
jb     1150 <build_coverage_map+0x40>
movl   $0x1,(%r15,%rbx,4)
movl   $0x1,0x4000(%r15,%rbx,4)
movl   $0x1,0x8000(%r15,%rbx,4)
movl   $0x1,0xc000(%r15,%rbx,4)
jmp    1150 <build_coverage_map+0x40>
xor    %eax,%eax
jmp    11aa <build_coverage_map+0x9a>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    $0x40,%rax
je     11ec <build_coverage_map+0xdc>
movsd  0x8000(%r14,%rax,8),%xmm1
divsd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
jb     11a0 <build_coverage_map+0x90>
movl   $0x1,(%r15,%rax,4)
movl   $0x1,0x4000(%r15,%rax,4)
movl   $0x1,0x8000(%r15,%rax,4)
movl   $0x1,0xc000(%r15,%rax,4)
jmp    11a0 <build_coverage_map+0x90>
xor    %eax,%eax
jmp    11fa <build_coverage_map+0xea>
add    $0x1,%rax
cmp    $0x40,%rax
je     123c <build_coverage_map+0x12c>
movsd  0x10000(%r14,%rax,8),%xmm1
divsd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
jb     11f0 <build_coverage_map+0xe0>
movl   $0x1,(%r15,%rax,4)
movl   $0x1,0x4000(%r15,%rax,4)
movl   $0x1,0x8000(%r15,%rax,4)
movl   $0x1,0xc000(%r15,%rax,4)
jmp    11f0 <build_coverage_map+0xe0>
xor    %eax,%eax
jmp    124a <build_coverage_map+0x13a>
add    $0x1,%rax
cmp    $0x40,%rax
je     128c <build_coverage_map+0x17c>
movsd  0x18000(%r14,%rax,8),%xmm1
divsd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
jb     1240 <build_coverage_map+0x130>
movl   $0x1,(%r15,%rax,4)
movl   $0x1,0x4000(%r15,%rax,4)
movl   $0x1,0x8000(%r15,%rax,4)
movl   $0x1,0xc000(%r15,%rax,4)
jmp    1240 <build_coverage_map+0x130>
xor    %eax,%eax
jmp    129c <build_coverage_map+0x18c>
add    $0x2,%rax
cmp    $0x100,%rax
je     12e8 <build_coverage_map+0x1d8>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
cmpl   $0x0,(%r15,%rcx,1)
je     12c0 <build_coverage_map+0x1b0>
mov    %eax,%ecx
and    $0x3e,%ecx
cmpl   $0x0,(%r15,%rcx,4)
je     12c0 <build_coverage_map+0x1b0>
movl   $0x1,0x10000(%r15,%rax,4)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
cmpl   $0x0,(%r15,%rcx,1)
je     1290 <build_coverage_map+0x180>
lea    0x1(%rax),%rcx
and    $0x3f,%ecx
cmpl   $0x0,(%r15,%rcx,4)
je     1290 <build_coverage_map+0x180>
movl   $0x1,0x10004(%r15,%rax,4)
jmp    1290 <build_coverage_map+0x180>
xor    %eax,%eax
jmp    12fc <build_coverage_map+0x1ec>
nopl   0x0(%rax)
add    $0x2,%rax
cmp    $0x100,%rax
je     1358 <build_coverage_map+0x248>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
cmpl   $0x0,0x4000(%r15,%rcx,1)
je     1328 <build_coverage_map+0x218>
mov    %eax,%ecx
and    $0x3e,%ecx
cmpl   $0x0,0x4000(%r15,%rcx,4)
je     1328 <build_coverage_map+0x218>
movl   $0x1,0x14000(%r15,%rax,4)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
cmpl   $0x0,0x4000(%r15,%rcx,1)
je     12f0 <build_coverage_map+0x1e0>
lea    0x1(%rax),%rcx
and    $0x3f,%ecx
cmpl   $0x0,0x4000(%r15,%rcx,4)
je     12f0 <build_coverage_map+0x1e0>
movl   $0x1,0x14004(%r15,%rax,4)
jmp    12f0 <build_coverage_map+0x1e0>
xor    %eax,%eax
jmp    136c <build_coverage_map+0x25c>
nopl   0x0(%rax)
add    $0x2,%rax
cmp    $0x100,%rax
je     13c8 <build_coverage_map+0x2b8>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
cmpl   $0x0,0x8000(%r15,%rcx,1)
je     1398 <build_coverage_map+0x288>
mov    %eax,%ecx
and    $0x3e,%ecx
cmpl   $0x0,0x8000(%r15,%rcx,4)
je     1398 <build_coverage_map+0x288>
movl   $0x1,0x18000(%r15,%rax,4)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
cmpl   $0x0,0x8000(%r15,%rcx,1)
je     1360 <build_coverage_map+0x250>
lea    0x1(%rax),%rcx
and    $0x3f,%ecx
cmpl   $0x0,0x8000(%r15,%rcx,4)
je     1360 <build_coverage_map+0x250>
movl   $0x1,0x18004(%r15,%rax,4)
jmp    1360 <build_coverage_map+0x250>
xor    %eax,%eax
jmp    13dc <build_coverage_map+0x2cc>
nopl   0x0(%rax)
add    $0x2,%rax
cmp    $0x100,%rax
je     1438 <build_coverage_map+0x328>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
cmpl   $0x0,0xc000(%r15,%rcx,1)
je     1408 <build_coverage_map+0x2f8>
mov    %eax,%ecx
and    $0x3e,%ecx
cmpl   $0x0,0xc000(%r15,%rcx,4)
je     1408 <build_coverage_map+0x2f8>
movl   $0x1,0x1c000(%r15,%rax,4)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
cmpl   $0x0,0xc000(%r15,%rcx,1)
je     13d0 <build_coverage_map+0x2c0>
lea    0x1(%rax),%rcx
and    $0x3f,%ecx
cmpl   $0x0,0xc000(%r15,%rcx,4)
je     13d0 <build_coverage_map+0x2c0>
movl   $0x1,0x1c004(%r15,%rax,4)
jmp    13d0 <build_coverage_map+0x2c0>
lea    0x20000(%r15),%rax
xor    %ecx,%ecx
jmp    1464 <build_coverage_map+0x354>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rcx
add    $0x4000,%rax
cmp    $0x4,%rcx
je     1529 <build_coverage_map+0x419>
xor    %edx,%edx
jmp    147d <build_coverage_map+0x36d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    $0x400,%rdx
je     1450 <build_coverage_map+0x340>
mov    %rcx,%rsi
shl    $0xe,%rsi
add    %r15,%rsi
mov    %rdx,%rdi
shr    $0x2,%rdi
and    $0x3ffffffc,%edi
cmpl   $0x0,(%rdi,%rsi,1)
je     1470 <build_coverage_map+0x360>
mov    %edx,%edi
and    $0xfc,%edi
cmpl   $0x0,(%rdi,%rsi,1)
je     1470 <build_coverage_map+0x360>
mov    %edx,%edi
and    $0x3f,%edi
cmpl   $0x0,(%rsi,%rdi,4)
je     1470 <build_coverage_map+0x360>
movl   $0x1,(%rax,%rdx,4)
mov    %rdx,%rdi
xor    $0x20,%rdi
cmpl   $0x0,0x20000(%rsi,%rdi,4)
jne    14dc <build_coverage_map+0x3cc>
lea    (%rsi,%rdi,4),%rdi
add    $0x20000,%rdi
movl   $0x2,(%rdi)
mov    %rdx,%rdi
xor    $0x30,%rdi
cmpl   $0x0,0x20000(%rsi,%rdi,4)
jne    14fe <build_coverage_map+0x3ee>
lea    (%rsi,%rdi,4),%rdi
add    $0x20000,%rdi
movl   $0x2,(%rdi)
mov    %rdx,%rdi
xor    $0x10,%rdi
cmpl   $0x0,0x20000(%rsi,%rdi,4)
jne    1470 <build_coverage_map+0x360>
lea    (%rsi,%rdi,4),%rsi
add    $0x20000,%rsi
movl   $0x2,(%rsi)
jmp    1470 <build_coverage_map+0x360>
xor    %eax,%eax
jmp    153c <build_coverage_map+0x42c>
nopl   (%rax)
add    $0x1,%rax
cmp    $0x1000,%rax
je     1580 <build_coverage_map+0x470>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    0x20000(%r15,%rcx,1),%ecx
test   %ecx,%ecx
je     1530 <build_coverage_map+0x420>
mov    %eax,%edx
and    $0x3ff,%edx
mov    0x20000(%r15,%rdx,4),%edx
test   %edx,%edx
je     1530 <build_coverage_map+0x420>
xor    $0x1,%ecx
xor    $0x1,%edx
xor    %esi,%esi
or     %ecx,%edx
sete   %sil
mov    $0x2,%ecx
sub    %esi,%ecx
mov    %ecx,0x30000(%r15,%rax,4)
jmp    1530 <build_coverage_map+0x420>
xor    %eax,%eax
jmp    159c <build_coverage_map+0x48c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0x1000,%rax
je     15e0 <build_coverage_map+0x4d0>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    0x24000(%r15,%rcx,1),%ecx
test   %ecx,%ecx
je     1590 <build_coverage_map+0x480>
mov    %eax,%edx
and    $0x3ff,%edx
mov    0x24000(%r15,%rdx,4),%edx
test   %edx,%edx
je     1590 <build_coverage_map+0x480>
xor    $0x1,%ecx
xor    $0x1,%edx
xor    %esi,%esi
or     %ecx,%edx
sete   %sil
mov    $0x2,%ecx
sub    %esi,%ecx
mov    %ecx,0x34000(%r15,%rax,4)
jmp    1590 <build_coverage_map+0x480>
xor    %eax,%eax
jmp    15fc <build_coverage_map+0x4ec>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0x1000,%rax
je     1640 <build_coverage_map+0x530>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    0x28000(%r15,%rcx,1),%ecx
test   %ecx,%ecx
je     15f0 <build_coverage_map+0x4e0>
mov    %eax,%edx
and    $0x3ff,%edx
mov    0x28000(%r15,%rdx,4),%edx
test   %edx,%edx
je     15f0 <build_coverage_map+0x4e0>
xor    $0x1,%ecx
xor    $0x1,%edx
xor    %esi,%esi
or     %ecx,%edx
sete   %sil
mov    $0x2,%ecx
sub    %esi,%ecx
mov    %ecx,0x38000(%r15,%rax,4)
jmp    15f0 <build_coverage_map+0x4e0>
xor    %eax,%eax
jmp    165c <build_coverage_map+0x54c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0x1000,%rax
je     16a0 <build_coverage_map+0x590>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    0x2c000(%r15,%rcx,1),%ecx
test   %ecx,%ecx
je     1650 <build_coverage_map+0x540>
mov    %eax,%edx
and    $0x3ff,%edx
mov    0x2c000(%r15,%rdx,4),%edx
test   %edx,%edx
je     1650 <build_coverage_map+0x540>
xor    $0x1,%ecx
xor    $0x1,%edx
xor    %esi,%esi
or     %ecx,%edx
sete   %sil
mov    $0x2,%ecx
sub    %esi,%ecx
mov    %ecx,0x3c000(%r15,%rax,4)
jmp    1650 <build_coverage_map+0x540>
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

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