int main(int argc, char *argv[]) {
  unsigned char H[32] = {1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0,
                         1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1};
  unsigned char c[8] = {1, 0, 1, 0, 1, 1, 1, 1};
  float y[8] = {0.2, 0.2, -0.9, 0.6, 0.5, -1.1, -0.4, -1.2};
  float sigma = sqrtf(0.5f);
  unsigned int max_iterations = 10;
  unsigned int n = 8;
  unsigned int m = 4;
  unsigned int num_iterations = 0;
  float Lq[m * n];
  float Lr[m * n];
  float Lc[n];
  float LQ[n];
  unsigned char c_hat[n];
  unsigned char parity[m];
  unsigned int i;
  unsigned int j;
  unsigned int ip;
  unsigned int jp;
  float alpha_prod;
  float phi_sum;
  int parity_pass;
  int continue_running = 1;
  for (i = 0; i < n; i++)
    Lc[i] = 2.0f * y[i] / (sigma * sigma);
  for (j = 0; j < m; j++) {
    for (i = 0; i < n; i++) {
      Lq[j * n + i] = H[j * n + i] ? Lc[i] : 0.0f;
    }
  }
  while (continue_running) {
    for (i = 0; i < n; i++) {
      for (j = 0; j < m; j++) {
        alpha_prod = 1.0f;
        phi_sum = 0.0f;
        for (ip = 0; ip < n; ip++) {
          if (H[j * n + ip] == 1 && i != ip) {
            float alpha = Lq[j * n + ip] > 0.0f ? 1.0f : -1.0f;
            float beta = fabsf(Lq[j * n + ip]);
            phi_sum += phi(beta);
            alpha_prod *= alpha;
          }
        }
        Lr[j * n + i] = alpha_prod * phi(phi_sum);
      }
    }
    for (i = 0; i < n; i++) {
      for (j = 0; j < m; j++) {
        Lq[j * n + i] = Lc[i];
        for (jp = 0; jp < m; jp++) {
          if (H[jp * n + i] == 1 && j != jp)
            Lq[j * n + i] += Lr[jp * n + i];
        }
      }
    }
    for (i = 0; i < n; i++) {
      LQ[i] = Lc[i];
      for (j = 0; j < m; j++) {
        if (H[j * n + i] == 1)
          LQ[i] += Lr[j * n + i];
      }
    }
    for (i = 0; i < n; i++)
      c_hat[i] = LQ[i] < 0.0f ? 1 : 0;
    for (j = 0; j < m; j++) {
      parity[j] = 0;
      for (i = 0; i < n; i++)
        parity[j] += H[j * n + i] * c_hat[i];
      parity[j] %= 2;
    }
    parity_pass = 1;
    for (j = 0; j < m; j++) {
      if (parity[j])
        parity_pass = 0;
    }
    printf("%3u : c hat = [", num_iterations);
    for (i = 0; i < n; i++)
      printf(" %1u", c_hat[i]);
    printf(" ],  ");
    printf("parity = [");
    for (j = 0; j < m; j++)
      printf(" %1u", parity[j]);
    printf(" ],  ");
    printf(" (%s)\n", parity_pass ? "pass" : "FAIL");
    num_iterations++;
    if (parity_pass || num_iterations == max_iterations)
      continue_running = 0;
  }
  unsigned int num_errors = 0;
  for (i = 0; i < n; i++)
    num_errors += (c[i] == c_hat[i]) ? 0 : 1;
  printf("\nresults:\n");
  printf("c    :");
  for (i = 0; i < n; i++)
    printf(" %1u", c[i]);
  printf("\n");
  printf("c_hat:");
  for (i = 0; i < n; i++)
    printf(" %1u", c_hat[i]);
  printf("\n");
  printf("num errors: %u / %u\n", num_errors, n);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movaps 0xee0(%rip),%xmm0
movaps %xmm0,-0x20(%rbp)
movaps 0xec5(%rip),%xmm0
movaps %xmm0,-0x30(%rbp)
movabs $0x101010100010001,%rax
01 01 01
mov    %rax,-0x38(%rbp)
movaps 0xedc(%rip),%xmm0
movaps %xmm0,-0x50(%rbp)
movaps 0xec1(%rip),%xmm0
movaps %xmm0,-0x60(%rbp)
movss  0xe75(%rip),%xmm0
call   1050 <sqrtf@plt>
movss  %xmm0,-0x64(%rbp)
movl   $0xa,-0x68(%rbp)
movl   $0x8,-0x6c(%rbp)
movl   $0x4,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x6c(%rbp),%ecx
imul   %ecx,%eax
mov    %rsp,%rcx
mov    %rcx,-0x80(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x110(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x88(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x6c(%rbp),%ecx
imul   %ecx,%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x108(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x90(%rbp)
mov    -0x6c(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x100(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x98(%rbp)
mov    -0x6c(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xf8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa0(%rbp)
mov    -0x6c(%rbp),%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xf0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa8(%rbp)
mov    -0x70(%rbp),%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xe8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xb0(%rbp)
movl   $0x1,-0xd0(%rbp)
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    1311 <main+0x1e1>
mov    -0x100(%rbp),%rax
mov    -0xb4(%rbp),%ecx
movss  0xd2e(%rip),%xmm0
mulss  -0x60(%rbp,%rcx,4),%xmm0
movss  -0x64(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0xb4(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    12ba <main+0x18a>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x70(%rbp),%eax
jae    13e5 <main+0x2b5>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    13cc <main+0x29c>
mov    -0xb8(%rbp),%eax
imul   -0x6c(%rbp),%eax
add    -0xb4(%rbp),%eax
mov    %eax,%eax
movzbl -0x30(%rbp,%rax,1),%eax
cmp    $0x0,%eax
je     1382 <main+0x252>
mov    -0x100(%rbp),%rax
mov    -0xb4(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x114(%rbp)
ff
jmp    1392 <main+0x262>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x114(%rbp)
ff
jmp    1392 <main+0x262>
mov    -0x110(%rbp),%rax
movss  -0x114(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0xb4(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1334 <main+0x204>
jmp    13d1 <main+0x2a1>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    131b <main+0x1eb>
jmp    13ea <main+0x2ba>
cmpl   $0x0,-0xd0(%rbp)
je     1aab <main+0x97b>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    15db <main+0x4ab>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x70(%rbp),%eax
jae    15c2 <main+0x492>
movss  0xbd3(%rip),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    155b <main+0x42b>
mov    -0xb8(%rbp),%eax
imul   -0x6c(%rbp),%eax
add    -0xbc(%rbp),%eax
mov    %eax,%eax
movzbl -0x30(%rbp,%rax,1),%eax
cmp    $0x1,%eax
jne    1542 <main+0x412>
mov    -0xb4(%rbp),%eax
cmp    -0xbc(%rbp),%eax
je     1542 <main+0x412>
mov    -0x110(%rbp),%rax
mov    -0xb8(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0xbc(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm1
movss  0xb4f(%rip),%xmm3
movss  0xb4b(%rip),%xmm2
xorps  %xmm0,%xmm0
cmpltss %xmm1,%xmm0
movaps %xmm0,%xmm1
andps  %xmm3,%xmm1
andnps %xmm2,%xmm0
orps   %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
mov    -0xb8(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0xbc(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movaps 0xb19(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1040 <phi@plt>
cvtsi2ss %eax,%xmm0
addss  -0xc8(%rbp),%xmm0
ff
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
mulss  -0xc4(%rbp),%xmm0
ff
movss  %xmm0,-0xc4(%rbp)
ff
jmp    1547 <main+0x417>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    144e <main+0x31e>
movss  -0xc4(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
movss  -0xc8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1040 <phi@plt>
movss  -0x118(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0x108(%rbp),%rax
cvtsi2ss %ecx,%xmm1
mulss  %xmm1,%xmm0
mov    -0xb8(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0xb4(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    141a <main+0x2ea>
jmp    15c7 <main+0x497>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1401 <main+0x2d1>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    1714 <main+0x5e4>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x70(%rbp),%eax
jae    16fb <main+0x5cb>
mov    -0x110(%rbp),%rax
mov    -0x100(%rbp),%rcx
mov    -0xb4(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm0
mov    -0xb8(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0xb4(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
cmp    -0x70(%rbp),%eax
jae    16e2 <main+0x5b2>
mov    -0xc0(%rbp),%eax
imul   -0x6c(%rbp),%eax
add    -0xb4(%rbp),%eax
mov    %eax,%eax
movzbl -0x30(%rbp,%rax,1),%eax
cmp    $0x1,%eax
jne    16c9 <main+0x599>
mov    -0xb8(%rbp),%eax
cmp    -0xc0(%rbp),%eax
je     16c9 <main+0x599>
mov    -0x110(%rbp),%rax
mov    -0x108(%rbp),%rcx
mov    -0xc0(%rbp),%edx
imul   -0x6c(%rbp),%edx
add    -0xb4(%rbp),%edx
mov    %edx,%edx
movss  (%rcx,%rdx,4),%xmm0
mov    -0xb8(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0xb4(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    16ce <main+0x59e>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    1647 <main+0x517>
jmp    16e7 <main+0x5b7>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    15fe <main+0x4ce>
jmp    1700 <main+0x5d0>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    15e5 <main+0x4b5>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    17f1 <main+0x6c1>
mov    -0xf8(%rbp),%rax
mov    -0x100(%rbp),%rcx
mov    -0xb4(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm0
mov    -0xb4(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x70(%rbp),%eax
jae    17d8 <main+0x6a8>
mov    -0xb8(%rbp),%eax
imul   -0x6c(%rbp),%eax
add    -0xb4(%rbp),%eax
mov    %eax,%eax
movzbl -0x30(%rbp,%rax,1),%eax
cmp    $0x1,%eax
jne    17bf <main+0x68f>
mov    -0xf8(%rbp),%rax
mov    -0x108(%rbp),%rcx
mov    -0xb8(%rbp),%edx
imul   -0x6c(%rbp),%edx
add    -0xb4(%rbp),%edx
mov    %edx,%edx
movss  (%rcx,%rdx,4),%xmm0
mov    -0xb4(%rbp),%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    17c4 <main+0x694>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    175b <main+0x62b>
jmp    17dd <main+0x6ad>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    171e <main+0x5ee>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    1852 <main+0x722>
mov    -0xf0(%rbp),%rax
mov    -0xf8(%rbp),%rcx
mov    -0xb4(%rbp),%edx
movss  (%rcx,%rdx,4),%xmm1
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
mov    $0x1,%edx
ucomiss %xmm1,%xmm0
cmova  %edx,%ecx
mov    %cl,%dl
mov    -0xb4(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    17fb <main+0x6cb>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x70(%rbp),%eax
jae    1921 <main+0x7f1>
mov    -0xe8(%rbp),%rax
mov    -0xb8(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    18ea <main+0x7ba>
mov    -0xe8(%rbp),%rax
mov    -0xf0(%rbp),%rcx
mov    -0xb8(%rbp),%edx
imul   -0x6c(%rbp),%edx
add    -0xb4(%rbp),%edx
mov    %edx,%edx
movzbl -0x30(%rbp,%rdx,1),%esi
mov    -0xb4(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%esi
mov    -0xb8(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1886 <main+0x756>
mov    -0xe8(%rbp),%rax
mov    -0xb8(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0xe8(%rbp),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    185c <main+0x72c>
movl   $0x1,-0xcc(%rbp)
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x70(%rbp),%eax
jae    197e <main+0x84e>
mov    -0xe8(%rbp),%rax
mov    -0xb8(%rbp),%ecx
cmpb   $0x0,(%rax,%rcx,1)
je     1965 <main+0x835>
movl   $0x0,-0xcc(%rbp)
jmp    196a <main+0x83a>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1935 <main+0x805>
mov    -0x74(%rbp),%esi
lea    0x6e0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    19db <main+0x8ab>
mov    -0xf0(%rbp),%rax
mov    -0xb4(%rbp),%ecx
movzbl (%rax,%rcx,1),%esi
lea    0x6b8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1999 <main+0x869>
lea    0x69b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x693(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x70(%rbp),%eax
jae    1a43 <main+0x913>
mov    -0xe8(%rbp),%rax
mov    -0xb8(%rbp),%ecx
movzbl (%rax,%rcx,1),%esi
lea    0x650(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1a01 <main+0x8d1>
lea    0x633(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xcc(%rbp),%ecx
lea    0x63c(%rip),%rsi
lea    0x630(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rsi
lea    0x61b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
cmpl   $0x0,-0xcc(%rbp)
jne    1a9c <main+0x96c>
mov    -0x74(%rbp),%eax
cmp    -0x68(%rbp),%eax
jne    1aa6 <main+0x976>
movl   $0x0,-0xd0(%rbp)
jmp    13ea <main+0x2ba>
movl   $0x0,-0xdc(%rbp)
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    1b16 <main+0x9e6>
mov    -0xf0(%rbp),%rax
mov    -0xb4(%rbp),%ecx
movzbl -0x38(%rbp,%rcx,1),%edx
mov    -0xb4(%rbp),%ecx
movzbl (%rax,%rcx,1),%esi
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0xdc(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1abf <main+0x98f>
lea    0x582(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x57f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    1b78 <main+0xa48>
mov    -0xb4(%rbp),%eax
movzbl -0x38(%rbp,%rax,1),%esi
lea    0x51b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1b3c <main+0xa0c>
lea    0x514(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x524(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jae    1be0 <main+0xab0>
mov    -0xf0(%rbp),%rax
mov    -0xb4(%rbp),%ecx
movzbl (%rax,%rcx,1),%esi
lea    0x4b3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1b9e <main+0xa6e>
lea    0x4ac(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xdc(%rbp),%esi
mov    -0x6c(%rbp),%edx
lea    0x4ba(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
movaps 0xea8(%rip),%xmm0
movaps %xmm0,0x190(%rsp)
movaps 0xea9(%rip),%xmm0
movaps %xmm0,0x1a0(%rsp)
movabs $0x3f4cccce3f4cccce,%rax
cc 4c 3f
mov    %rax,0x40(%rsp)
movl   $0xc0666667,0x48(%rsp)
c0
xorps  %xmm0,%xmm0
movups %xmm0,0x4c(%rsp)
movups %xmm0,0x5c(%rsp)
movaps 0xe86(%rip),%xmm0
movups %xmm0,0x6c(%rsp)
movaps 0xe8a(%rip),%xmm0
movups %xmm0,0x7c(%rsp)
movaps 0xe8e(%rip),%xmm0
movups %xmm0,0x8c(%rsp)
movaps 0xe8f(%rip),%xmm0
movups %xmm0,0x9c(%rsp)
movaps 0xe90(%rip),%xmm0
movups %xmm0,0xac(%rsp)
movl   $0xc099999b,0xbc(%rsp)
9b 99 99 c0
mov    $0x92493807,%r12d
mov    $0x924938,%r15d
mov    $0x9249,%r13d
mov    $0x92,%r14d
xor    %eax,%eax
nopl   (%rax)
mov    %eax,0xc(%rsp)
xor    %ebp,%ebp
jmp    1245 <main+0x105>
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
mov    $0x1,%al
call   1060 <phi@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movaps 0x10(%rsp),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x170(%rsp,%rbp,4)
add    $0x1,%rbp
cmp    $0x8,%rbp
je     1520 <main+0x3e0>
xorps  %xmm3,%xmm3
xor    %ebx,%ebx
movss  0xe3e(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
jmp    126a <main+0x12a>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    $0x8,%rbx
je     12e0 <main+0x1a0>
bt     %rbx,%r12
jae    1260 <main+0x120>
cmp    %rbx,%rbp
je     1260 <main+0x120>
movss  0x40(%rsp,%rbx,4),%xmm0
movaps %xmm0,0x30(%rsp)
andps  0xde9(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
movss  %xmm3,0x4(%rsp)
call   1060 <phi@plt>
movss  0x4(%rsp),%xmm3
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
addss  %xmm0,%xmm3
xorps  %xmm0,%xmm0
cmpltss 0x30(%rsp),%xmm0
movaps %xmm0,%xmm1
movaps 0x10(%rsp),%xmm2
andps  %xmm2,%xmm1
xorps  0xdbb(%rip),%xmm2
andnps %xmm2,%xmm0
orps   %xmm1,%xmm0
movaps %xmm0,0x10(%rsp)
jmp    1260 <main+0x120>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
mov    $0x1,%al
call   1060 <phi@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movaps 0x10(%rsp),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x110(%rsp,%rbp,4)
xorps  %xmm3,%xmm3
xor    %ebx,%ebx
movss  0xd7c(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
jmp    132a <main+0x1ea>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x8,%rbx
je     13a0 <main+0x260>
bt     %rbx,%r15
jae    1320 <main+0x1e0>
cmp    %rbx,%rbp
je     1320 <main+0x1e0>
movss  0x60(%rsp,%rbx,4),%xmm0
movaps %xmm0,0x30(%rsp)
andps  0xd29(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
movss  %xmm3,0x4(%rsp)
call   1060 <phi@plt>
movss  0x4(%rsp),%xmm3
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
addss  %xmm0,%xmm3
xorps  %xmm0,%xmm0
cmpltss 0x30(%rsp),%xmm0
movaps %xmm0,%xmm1
movaps 0x10(%rsp),%xmm2
andps  %xmm2,%xmm1
xorps  0xcfb(%rip),%xmm2
andnps %xmm2,%xmm0
orps   %xmm1,%xmm0
movaps %xmm0,0x10(%rsp)
jmp    1320 <main+0x1e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
mov    $0x1,%al
call   1060 <phi@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movaps 0x10(%rsp),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x130(%rsp,%rbp,4)
xorps  %xmm3,%xmm3
xor    %ebx,%ebx
movss  0xcbc(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
jmp    13ea <main+0x2aa>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x8,%rbx
je     1460 <main+0x320>
bt     %rbx,%r13
jae    13e0 <main+0x2a0>
cmp    %rbx,%rbp
je     13e0 <main+0x2a0>
movss  0x80(%rsp,%rbx,4),%xmm0
movaps %xmm0,0x30(%rsp)
andps  0xc66(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
movss  %xmm3,0x4(%rsp)
call   1060 <phi@plt>
movss  0x4(%rsp),%xmm3
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
addss  %xmm0,%xmm3
xorps  %xmm0,%xmm0
cmpltss 0x30(%rsp),%xmm0
movaps %xmm0,%xmm1
movaps 0x10(%rsp),%xmm2
andps  %xmm2,%xmm1
xorps  0xc38(%rip),%xmm2
andnps %xmm2,%xmm0
orps   %xmm1,%xmm0
movaps %xmm0,0x10(%rsp)
jmp    13e0 <main+0x2a0>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
mov    $0x1,%al
call   1060 <phi@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movaps 0x10(%rsp),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x150(%rsp,%rbp,4)
xorps  %xmm3,%xmm3
xor    %ebx,%ebx
movss  0xbfc(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
jmp    14ae <main+0x36e>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x8,%rbx
je     1210 <main+0xd0>
bt     %rbx,%r14
jae    14a0 <main+0x360>
cmp    %rbx,%rbp
je     14a0 <main+0x360>
movss  0xa0(%rsp,%rbx,4),%xmm0
movaps %xmm0,0x30(%rsp)
andps  0xba2(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
movss  %xmm3,0x4(%rsp)
call   1060 <phi@plt>
movss  0x4(%rsp),%xmm3
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
addss  %xmm0,%xmm3
xorps  %xmm0,%xmm0
cmpltss 0x30(%rsp),%xmm0
movaps %xmm0,%xmm1
movaps 0x10(%rsp),%xmm2
andps  %xmm2,%xmm1
xorps  0xb74(%rip),%xmm2
andnps %xmm2,%xmm0
orps   %xmm1,%xmm0
movaps %xmm0,0x10(%rsp)
jmp    14a0 <main+0x360>
nopl   0x0(%rax)
movss  0x150(%rsp),%xmm0
movss  0x174(%rsp),%xmm1
movaps %xmm0,%xmm2
movss  0xb57(%rip),%xmm4
addss  %xmm4,%xmm2
movss  %xmm2,0x40(%rsp)
movss  0x110(%rsp),%xmm2
addss  %xmm4,%xmm2
addss  %xmm2,%xmm0
movss  %xmm0,0x60(%rsp)
movss  %xmm2,0x80(%rsp)
movss  %xmm0,0xa0(%rsp)
movss  0x194(%rsp),%xmm0
movss  0x198(%rsp),%xmm2
movaps %xmm1,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,0x44(%rsp)
addss  0x114(%rsp),%xmm0
addss  %xmm0,%xmm1
movss  %xmm1,0x64(%rsp)
movss  %xmm1,0x84(%rsp)
movss  %xmm0,0xa4(%rsp)
movss  %xmm2,0x48(%rsp)
movss  %xmm2,0x68(%rsp)
movss  0x118(%rsp),%xmm0
addss  %xmm2,%xmm0
addss  0x118(%rsp),%xmm2
movss  %xmm0,0x68(%rsp)
movss  %xmm2,0x88(%rsp)
movss  %xmm2,0xa8(%rsp)
movss  0x19c(%rsp),%xmm0
movss  0x13c(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  0x15c(%rsp),%xmm2
movaps %xmm2,%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0x4c(%rsp)
addss  %xmm0,%xmm2
movss  %xmm2,0x6c(%rsp)
movss  %xmm0,0x8c(%rsp)
movss  %xmm1,0x8c(%rsp)
movss  %xmm0,0xac(%rsp)
addss  0x13c(%rsp),%xmm0
movss  %xmm0,0xac(%rsp)
addss  0x15c(%rsp),%xmm0
movss  %xmm0,0xac(%rsp)
movss  0x1a0(%rsp),%xmm0
movss  %xmm0,0x50(%rsp)
movss  0x140(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x50(%rsp)
addss  0x180(%rsp),%xmm1
movss  %xmm1,0x50(%rsp)
movss  %xmm0,0x70(%rsp)
movss  0x180(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x70(%rsp)
movss  %xmm0,0x90(%rsp)
movss  0x140(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x90(%rsp)
addss  0x180(%rsp),%xmm1
movss  %xmm1,0x90(%rsp)
movss  %xmm0,0xb0(%rsp)
addss  0x140(%rsp),%xmm0
movss  %xmm0,0xb0(%rsp)
movss  0x1a4(%rsp),%xmm0
movss  %xmm0,0x54(%rsp)
movss  0x144(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x54(%rsp)
movss  %xmm0,0x74(%rsp)
movss  %xmm0,0x94(%rsp)
movss  0x144(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x94(%rsp)
movss  %xmm0,0xb4(%rsp)
addss  0x144(%rsp),%xmm0
movss  %xmm0,0xb4(%rsp)
movss  0x1a8(%rsp),%xmm0
movss  %xmm0,0x58(%rsp)
movss  0x168(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x58(%rsp)
movss  %xmm0,0x78(%rsp)
movss  0x168(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x78(%rsp)
movss  %xmm0,0x98(%rsp)
movss  %xmm0,0xb8(%rsp)
addss  0x168(%rsp),%xmm0
movss  %xmm0,0xb8(%rsp)
movss  0x1ac(%rsp),%xmm0
movss  %xmm0,0x5c(%rsp)
movss  0x18c(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x5c(%rsp)
movss  %xmm0,0x7c(%rsp)
movss  0x18c(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x7c(%rsp)
movss  %xmm0,0x9c(%rsp)
movss  0x18c(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x9c(%rsp)
movss  0x110(%rsp),%xmm2
addss  %xmm4,%xmm2
addss  0x150(%rsp),%xmm2
movss  0x114(%rsp),%xmm3
addss  %xmm4,%xmm3
addss  0x174(%rsp),%xmm3
movss  0x118(%rsp),%xmm4
movss  0x13c(%rsp),%xmm5
addss  0x842(%rip),%xmm5
addss  0x15c(%rsp),%xmm5
movss  0x140(%rsp),%xmm6
addss  0x82c(%rip),%xmm6
addss  0x180(%rsp),%xmm6
xor    %ebx,%ebx
xorps  %xmm1,%xmm1
movss  %xmm2,0xe8(%rsp)
ucomiss %xmm2,%xmm1
seta   %bl
addss  0x7ff(%rip),%xmm4
xor    %eax,%eax
movss  %xmm3,0xe4(%rsp)
ucomiss %xmm3,%xmm1
movss  0x144(%rsp),%xmm2
seta   %al
mov    %rax,%rcx
xor    %eax,%eax
movss  %xmm4,0xe0(%rsp)
ucomiss %xmm4,%xmm1
seta   %al
mov    %eax,%edx
mov    %eax,0x2c(%rsp)
addss  0x7cf(%rip),%xmm2
xor    %eax,%eax
movss  %xmm5,0xdc(%rsp)
ucomiss %xmm5,%xmm1
movss  0x168(%rsp),%xmm3
seta   %al
mov    %rax,%rbp
mov    %rax,0x100(%rsp)
xor    %eax,%eax
movss  %xmm6,0xd8(%rsp)
ucomiss %xmm6,%xmm1
seta   %al
mov    %rax,%rdi
addss  0x792(%rip),%xmm3
xor    %eax,%eax
movss  %xmm2,0xd4(%rsp)
ucomiss %xmm2,%xmm1
movss  0x18c(%rsp),%xmm2
seta   %al
mov    %eax,%esi
mov    %eax,0x30(%rsp)
xor    %eax,%eax
movss  %xmm3,0xd0(%rsp)
ucomiss %xmm3,%xmm1
seta   %al
mov    %eax,%r9d
mov    %eax,0x4(%rsp)
addss  0x756(%rip),%xmm2
xor    %eax,%eax
movss  %xmm2,0xcc(%rsp)
ucomiss %xmm2,%xmm1
movss  %xmm0,0xbc(%rsp)
seta   %al
mov    %eax,%r8d
mov    %eax,0x10(%rsp)
lea    (%rcx,%rbx,1),%eax
mov    %rcx,%r10
mov    %rcx,0xf8(%rsp)
add    %dl,%al
mov    %eax,0x28(%rsp)
and    $0x1,%al
mov    %al,0x24(%rsp)
lea    (%rdi,%rbp,1),%eax
mov    %rdi,0x108(%rsp)
add    %sil,%al
and    $0x1,%al
mov    %eax,0xf4(%rsp)
lea    (%rbx,%rbp,1),%eax
add    %r9b,%al
and    $0x1,%al
mov    %eax,%ecx
mov    %eax,0xec(%rsp)
lea    (%rdi,%r10,1),%eax
add    %r8b,%al
and    $0x1,%al
mov    %eax,0xf0(%rsp)
or     %cl,%al
mov    %al,0xb(%rsp)
lea    0x6da(%rip),%rdi
mov    0xc(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x6d8(%rip),%rbp
mov    %rbp,%rdi
mov    %rbx,0x1b0(%rsp)
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbp,%rdi
mov    0xf8(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbp,%rdi
mov    0x2c(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbp,%rdi
mov    0x100(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbp,%rdi
mov    0x108(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbp,%rdi
mov    0x30(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbp,%rdi
mov    0x4(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbp,%rdi
mov    0x10(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x654(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x64c(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
movzbl 0x24(%rsp),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
movzbl 0xf4(%rsp),%ebx
mov    %rbp,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
movzbl 0xec(%rsp),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
movzbl 0xf0(%rsp),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
or     0xb(%rsp),%bl
setne  %bl
lea    0x5ea(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
or     0x28(%rsp),%bl
test   $0x1,%bl
lea    0x5ed(%rip),%rsi
lea    0x5eb(%rip),%rax
cmovne %rax,%rsi
lea    0x5d4(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc(%rsp),%eax
test   $0x1,%bl
je     1b1e <main+0x9de>
add    $0x1,%eax
cmp    $0xa,%eax
jne    1200 <main+0xc0>
xorps  %xmm0,%xmm0
xor    %eax,%eax
ucomiss 0xcc(%rsp),%xmm0
setbe  %al
mov    %eax,0xc(%rsp)
xor    %eax,%eax
ucomiss 0xd0(%rsp),%xmm0
setbe  %al
mov    %eax,0x28(%rsp)
xor    %eax,%eax
ucomiss 0xd4(%rsp),%xmm0
setbe  %al
mov    %eax,0x24(%rsp)
xor    %r13d,%r13d
ucomiss 0xd8(%rsp),%xmm0
setbe  %r13b
xor    %ebx,%ebx
ucomiss 0xdc(%rsp),%xmm0
seta   %bl
xor    %ebp,%ebp
ucomiss 0xe0(%rsp),%xmm0
setbe  %bpl
xor    %r14d,%r14d
ucomiss 0xe4(%rsp),%xmm0
seta   %r14b
xor    %r15d,%r15d
ucomiss 0xe8(%rsp),%xmm0
setbe  %r15b
lea    0x567(%rip),%rdi
call   1040 <puts@plt>
lea    0x538(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x503(%rip),%r12
mov    %r12,%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1050 <printf@plt>
add    %r14d,%r15d
add    %ebp,%r15d
add    %ebx,%r15d
add    %r13d,%r15d
add    0x24(%rsp),%r15d
add    0x28(%rsp),%r15d
add    0xc(%rsp),%r15d
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x493(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    0x1b0(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    0xf8(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    0x2c(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    0x100(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    0x108(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    0x30(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    0x4(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    0x10(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x402(%rip),%rdi
mov    %r15d,%esi
mov    $0x8,%edx
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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