int main() {
  int it, i, j, k, data, sum;
  int seed, checksum;
  int data1[(1 * 32 + 2) * (30 + 2)], data2[(1 * 32 + 2) * (30 + 2)];
  seed = 74755;
  for (i = 0; i < 1; i++) {
    for (j = 0; j < 30; j++) {
      seed = (seed * 1309 + 13849);
      ;
      data = seed;
      for (k = 0; k < 32; k++) {
        int tmp = ((data & (1 << (31 - k))) != 0);
        data1[((j + 1) + ((i * 32) + k + 1) * (30 + 2))] = tmp;
        data2[((j + 1) + ((i * 32) + k + 1) * (30 + 2))] = tmp;
      }
    }
  }
  for (j = 0; j < 32; j++) {
    data1[((j) + (0) * (30 + 2))] = 0;
    data2[((j) + (0) * (30 + 2))] = 0;
    data1[((j) + (33) * (30 + 2))] = 0;
    data2[((j) + (33) * (30 + 2))] = 0;
  }
  for (i = 1; i < 33; i++) {
    data1[((0) + (i) * (30 + 2))] = 0;
    data2[((0) + (i) * (30 + 2))] = 0;
    data1[((31) + (i) * (30 + 2))] = 0;
    data2[((31) + (i) * (30 + 2))] = 0;
  }
  it = 0;
  while (it < 20) {
    for (i = 1; i < 33; i++) {
      for (j = 1; j < 31; j++) {
        sum = data1[((j) + (i - 1) * (30 + 2))] +
              data1[((j) + (i + 1) * (30 + 2))] +
              data1[((j - 1) + (i) * (30 + 2))] +
              data1[((j + 1) + (i) * (30 + 2))] +
              data1[((j - 1) + (i - 1) * (30 + 2))] +
              data1[((j + 1) + (i - 1) * (30 + 2))] +
              data1[((j - 1) + (i + 1) * (30 + 2))] +
              data1[((j + 1) + (i + 1) * (30 + 2))];
        if (data1[((j) + (i) * (30 + 2))]) {
          data2[((j) + (i) * (30 + 2))] = ((sum == 2) || (sum == 3)) ? 1 : 0;
        } else {
          data2[((j) + (i) * (30 + 2))] = (sum == 3) ? 1 : 0;
        }
      }
    }
    for (i = 1; i < 33; i++) {
      for (j = 1; j < 31; j++) {
        sum = data2[((j) + (i - 1) * (30 + 2))] +
              data2[((j) + (i + 1) * (30 + 2))] +
              data2[((j - 1) + (i) * (30 + 2))] +
              data2[((j + 1) + (i) * (30 + 2))] +
              data2[((j - 1) + (i - 1) * (30 + 2))] +
              data2[((j + 1) + (i - 1) * (30 + 2))] +
              data2[((j - 1) + (i + 1) * (30 + 2))] +
              data2[((j + 1) + (i + 1) * (30 + 2))];
        if (data2[((j) + (i) * (30 + 2))])
          data1[((j) + (i) * (30 + 2))] = ((sum == 2) || (sum == 3)) ? 1 : 0;
        else
          data1[((j) + (i) * (30 + 2))] = (sum == 3) ? 1 : 0;
      }
    }
    it += 2;
  }
  checksum = 0;
  for (i = 0; i < 33; i++)
    for (j = 0; j < 31; j++)
      checksum += data2[((j) + (i) * (30 + 2))];
  if (checksum == 191) {
    return 0xbadbeef;
  } else {
    return 0xbad;
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x21c0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x12403,-0x20(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x1,-0xc(%rbp)
jge    1208 <main+0x108>
movl   $0x0,-0x10(%rbp)
cmpl   $0x1e,-0x10(%rbp)
jge    11f5 <main+0xf5>
imul   $0x51d,-0x20(%rbp),%eax
add    $0x3619,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x20,-0x14(%rbp)
jge    11e2 <main+0xe2>
mov    -0x18(%rbp),%eax
mov    $0x1f,%ecx
sub    -0x14(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x2234(%rbp)
mov    -0x2234(%rbp),%ecx
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    -0xc(%rbp),%edx
shl    $0x5,%edx
add    -0x14(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
add    %edx,%eax
cltq
mov    %ecx,-0x1130(%rbp,%rax,4)
mov    -0x2234(%rbp),%ecx
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    -0xc(%rbp),%edx
shl    $0x5,%edx
add    -0x14(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
add    %edx,%eax
cltq
mov    %ecx,-0x2230(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1157 <main+0x57>
jmp    11e7 <main+0xe7>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1131 <main+0x31>
jmp    11fa <main+0xfa>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1120 <main+0x20>
movl   $0x0,-0x10(%rbp)
cmpl   $0x20,-0x10(%rbp)
jge    1277 <main+0x177>
mov    -0x10(%rbp),%eax
add    $0x0,%eax
cltq
movl   $0x0,-0x1130(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x0,%eax
cltq
movl   $0x0,-0x2230(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x420,%eax
cltq
movl   $0x0,-0x1130(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x420,%eax
cltq
movl   $0x0,-0x2230(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    120f <main+0x10f>
movl   $0x1,-0xc(%rbp)
cmpl   $0x21,-0xc(%rbp)
jge    12ee <main+0x1ee>
mov    -0xc(%rbp),%eax
shl    $0x5,%eax
add    $0x0,%eax
cltq
movl   $0x0,-0x1130(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
shl    $0x5,%eax
add    $0x0,%eax
cltq
movl   $0x0,-0x2230(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
shl    $0x5,%eax
add    $0x1f,%eax
cltq
movl   $0x0,-0x1130(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
shl    $0x5,%eax
add    $0x1f,%eax
cltq
movl   $0x0,-0x2230(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    127e <main+0x17e>
movl   $0x0,-0x8(%rbp)
cmpl   $0x14,-0x8(%rbp)
jge    164d <main+0x54d>
movl   $0x1,-0xc(%rbp)
cmpl   $0x21,-0xc(%rbp)
jge    149f <main+0x39f>
movl   $0x1,-0x10(%rbp)
cmpl   $0x1f,-0x10(%rbp)
jge    148c <main+0x38c>
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x5,%ecx
add    %ecx,%eax
cltq
mov    -0x1130(%rbp,%rax,4),%eax
mov    -0x10(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x1130(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x1130(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    -0xc(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x1130(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x1130(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x1130(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x1130(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x1130(%rbp,%rcx,4),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
cltq
cmpl   $0x0,-0x1130(%rbp,%rax,4)
je     1455 <main+0x355>
mov    $0x1,%al
cmpl   $0x2,-0x1c(%rbp)
mov    %al,-0x2235(%rbp)
je     1429 <main+0x329>
cmpl   $0x3,-0x1c(%rbp)
sete   %al
mov    %al,-0x2235(%rbp)
mov    -0x2235(%rbp),%dl
xor    %ecx,%ecx
mov    $0x1,%eax
test   $0x1,%dl
cmovne %eax,%ecx
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%edx
shl    $0x5,%edx
add    %edx,%eax
cltq
mov    %ecx,-0x2230(%rbp,%rax,4)
jmp    1479 <main+0x379>
mov    -0x1c(%rbp),%edx
xor    %ecx,%ecx
mov    $0x1,%eax
cmp    $0x3,%edx
cmove  %eax,%ecx
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%edx
shl    $0x5,%edx
add    %edx,%eax
cltq
mov    %ecx,-0x2230(%rbp,%rax,4)
jmp    147e <main+0x37e>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1317 <main+0x217>
jmp    1491 <main+0x391>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1306 <main+0x206>
movl   $0x1,-0xc(%rbp)
cmpl   $0x21,-0xc(%rbp)
jge    163f <main+0x53f>
movl   $0x1,-0x10(%rbp)
cmpl   $0x1f,-0x10(%rbp)
jge    162c <main+0x52c>
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x5,%ecx
add    %ecx,%eax
cltq
mov    -0x2230(%rbp,%rax,4),%eax
mov    -0x10(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x2230(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x2230(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    -0xc(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x2230(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x2230(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x2230(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x2230(%rbp,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    -0x2230(%rbp,%rcx,4),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
cltq
cmpl   $0x0,-0x2230(%rbp,%rax,4)
je     15f5 <main+0x4f5>
mov    $0x1,%al
cmpl   $0x2,-0x1c(%rbp)
mov    %al,-0x2236(%rbp)
je     15c9 <main+0x4c9>
cmpl   $0x3,-0x1c(%rbp)
sete   %al
mov    %al,-0x2236(%rbp)
mov    -0x2236(%rbp),%dl
xor    %ecx,%ecx
mov    $0x1,%eax
test   $0x1,%dl
cmovne %eax,%ecx
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%edx
shl    $0x5,%edx
add    %edx,%eax
cltq
mov    %ecx,-0x1130(%rbp,%rax,4)
jmp    1619 <main+0x519>
mov    -0x1c(%rbp),%edx
xor    %ecx,%ecx
mov    $0x1,%eax
cmp    $0x3,%edx
cmove  %eax,%ecx
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%edx
shl    $0x5,%edx
add    %edx,%eax
cltq
mov    %ecx,-0x1130(%rbp,%rax,4)
jmp    161e <main+0x51e>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14b7 <main+0x3b7>
jmp    1631 <main+0x531>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14a6 <main+0x3a6>
mov    -0x8(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x8(%rbp)
jmp    12f5 <main+0x1f5>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x21,-0xc(%rbp)
jge    16b1 <main+0x5b1>
movl   $0x0,-0x10(%rbp)
cmpl   $0x1f,-0x10(%rbp)
jge    169e <main+0x59e>
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
cltq
mov    -0x2230(%rbp,%rax,4),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    166c <main+0x56c>
jmp    16a3 <main+0x5a3>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    165b <main+0x55b>
cmpl   $0xbf,-0x24(%rbp)
jne    16ca <main+0x5ca>
movl   $0xbadbeef,-0x4(%rbp)
jmp    16d1 <main+0x5d1>
movl   $0xbad,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x21c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2198,%rsp
lea    0x94(%rsp),%r9
lea    0x1194(%rsp),%rsi
mov    $0x12403,%edx
xor    %r8d,%r8d
nopl   0x0(%rax)
imul   $0x51d,%edx,%edx
add    $0x3619,%edx
xor    %ebp,%ebp
xor    %eax,%eax
mov    %edx,%edi
mov    %eax,%ecx
shl    %cl,%edi
shr    $0x1f,%edi
or     $0x1,%cl
mov    %edx,%ebx
shl    %cl,%ebx
mov    %edi,-0x80(%rsi,%rbp,1)
mov    %edi,-0x80(%r9,%rbp,1)
shr    $0x1f,%ebx
mov    %ebx,(%rsi,%rbp,1)
mov    %ebx,(%r9,%rbp,1)
add    $0x2,%rax
add    $0x100,%rbp
cmp    $0x20,%rax
jne    1140 <main+0x40>
add    $0x1,%r8
add    $0x4,%r9
add    $0x4,%rsi
cmp    $0x1e,%r8
jne    1130 <main+0x30>
pxor   %xmm0,%xmm0
movdqa %xmm0,0x1100(%rsp)
movdqa %xmm0,0x10f0(%rsp)
movdqa %xmm0,0x10e0(%rsp)
movdqa %xmm0,0x10d0(%rsp)
movdqa %xmm0,0x10c0(%rsp)
movdqa %xmm0,0x10b0(%rsp)
movdqa %xmm0,0x10a0(%rsp)
movdqa %xmm0,0x1090(%rsp)
movdqa %xmm0,0x2110(%rsp)
movdqa %xmm0,0x2120(%rsp)
movdqa %xmm0,0x2130(%rsp)
movdqa %xmm0,0x2140(%rsp)
movdqa %xmm0,0x2150(%rsp)
movdqa %xmm0,0x2160(%rsp)
movdqa %xmm0,0x2170(%rsp)
movdqa %xmm0,0x2180(%rsp)
movdqa %xmm0,-0x70(%rsp)
movdqa %xmm0,-0x60(%rsp)
movdqa %xmm0,-0x50(%rsp)
movdqa %xmm0,-0x40(%rsp)
movdqa %xmm0,-0x30(%rsp)
movdqa %xmm0,-0x20(%rsp)
movdqa %xmm0,-0x10(%rsp)
movdqa %xmm0,(%rsp)
movdqa %xmm0,0x1080(%rsp)
movdqa %xmm0,0x1070(%rsp)
movdqa %xmm0,0x1060(%rsp)
movdqa %xmm0,0x1050(%rsp)
movdqa %xmm0,0x1040(%rsp)
movdqa %xmm0,0x1030(%rsp)
movdqa %xmm0,0x1020(%rsp)
movdqa %xmm0,0x1010(%rsp)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movl   $0x0,0x1110(%rsp,%rax,1)
movl   $0x0,0x10(%rsp,%rax,1)
movq   $0x0,0x118c(%rsp,%rax,1)
movq   $0x0,0x8c(%rsp,%rax,1)
movl   $0x0,0x120c(%rsp,%rax,1)
movl   $0x0,0x10c(%rsp,%rax,1)
add    $0x100,%rax
cmp    $0x1000,%rax
jne    12a0 <main+0x1a0>
xor    %eax,%eax
pxor   %xmm0,%xmm0
movdqa 0xd03(%rip),%xmm1
movdqa 0xd0b(%rip),%xmm2
movdqa 0xd13(%rip),%xmm3
nopl   (%rax)
mov    %rax,-0x80(%rsp)
mov    $0x1,%r15d
lea    0x14(%rsp),%rcx
lea    0x1198(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
mov    %r15,%rax
shl    $0x5,%rax
xor    %edi,%edi
nopl   0x0(%rax)
movdqu -0x4(%rdx,%rdi,4),%xmm4
movdqu -0x104(%rdx,%rdi,4),%xmm5
ff ff
paddd  %xmm4,%xmm5
movdqu -0x100(%rdx,%rdi,4),%xmm4
ff ff
movdqu -0x84(%rdx,%rdi,4),%xmm6
ff ff
paddd  -0x88(%rdx,%rdi,4),%xmm5
ff ff
movdqu -0x80(%rdx,%rdi,4),%xmm7
paddd  %xmm7,%xmm5
paddd  -0x108(%rdx,%rdi,4),%xmm5
ff ff
paddd  %xmm4,%xmm5
paddd  -0x8(%rdx,%rdi,4),%xmm5
movdqu (%rdx,%rdi,4),%xmm4
paddd  %xmm5,%xmm4
pcmpeqd %xmm0,%xmm6
movdqa %xmm4,%xmm5
pand   %xmm1,%xmm5
pcmpeqd %xmm2,%xmm4
pand   %xmm6,%xmm4
pcmpeqd %xmm3,%xmm5
pandn  %xmm5,%xmm6
por    %xmm4,%xmm6
psrld  $0x1f,%xmm6
movdqu %xmm6,(%rcx,%rdi,4)
add    $0x4,%rdi
cmp    $0x1c,%rdi
jne    1340 <main+0x240>
mov    0x1184(%rsp,%rax,4),%esi
mov    %rsi,-0x78(%rsp)
mov    0x1084(%rsp,%rax,4),%r13d
lea    (%rsi,%r13,1),%r9d
lea    0x0(,%rax,4),%rbx
mov    %rbx,%rdi
or     $0x70,%rdi
add    0x1090(%rsp,%rdi,1),%r9d
mov    %rbx,%rbp
or     $0x78,%rbp
mov    0x1090(%rsp,%rbp,1),%r12d
add    %r12d,%r9d
add    0x1080(%rsp,%rax,4),%r9d
mov    0x1088(%rsp,%rax,4),%r10d
add    %r10d,%r9d
add    0x1180(%rsp,%rax,4),%r9d
mov    0x1188(%rsp,%rax,4),%edi
add    %edi,%r9d
mov    %rbx,%r8
or     $0x74,%r8
xor    %r11d,%r11d
cmp    $0x3,%r9d
sete   %r11b
and    $0xfffffffe,%r9d
xor    %r14d,%r14d
cmp    $0x2,%r9d
mov    0x1090(%rsp,%r8,1),%esi
sete   %r14b
test   %esi,%esi
cmove  %r11d,%r14d
add    %r10d,%edi
add    %esi,%edi
or     $0x7c,%rbx
add    0x1090(%rsp,%rbx,1),%edi
add    %r13d,%edi
movzbl %r14b,%esi
add    0x108c(%rsp,%rax,4),%edi
mov    %esi,-0x70(%rsp,%r8,1)
add    -0x78(%rsp),%edi
add    0x118c(%rsp,%rax,4),%edi
xor    %eax,%eax
cmp    $0x3,%edi
sete   %al
and    $0xfffffffe,%edi
xor    %esi,%esi
cmp    $0x2,%edi
sete   %sil
test   %r12d,%r12d
cmove  %eax,%esi
movzbl %sil,%eax
mov    %eax,-0x70(%rsp,%rbp,1)
add    $0x1,%r15
sub    $0xffffffffffffff80,%rdx
sub    $0xffffffffffffff80,%rcx
cmp    $0x21,%r15
jne    1330 <main+0x230>
mov    $0x1,%r8d
lea    0x1114(%rsp),%rcx
lea    0x98(%rsp),%rdx
nopl   (%rax)
mov    %r8,%r14
shl    $0x5,%r14
xor    %edi,%edi
nopl   0x0(%rax)
movdqu -0x4(%rdx,%rdi,4),%xmm4
movdqu -0x104(%rdx,%rdi,4),%xmm5
ff ff
paddd  %xmm4,%xmm5
movdqu -0x100(%rdx,%rdi,4),%xmm4
ff ff
movdqu -0x84(%rdx,%rdi,4),%xmm6
ff ff
paddd  -0x88(%rdx,%rdi,4),%xmm5
ff ff
movdqu -0x80(%rdx,%rdi,4),%xmm7
paddd  %xmm7,%xmm5
paddd  -0x108(%rdx,%rdi,4),%xmm5
ff ff
paddd  %xmm4,%xmm5
paddd  -0x8(%rdx,%rdi,4),%xmm5
movdqu (%rdx,%rdi,4),%xmm4
paddd  %xmm5,%xmm4
pcmpeqd %xmm0,%xmm6
movdqa %xmm4,%xmm5
pand   %xmm1,%xmm5
pcmpeqd %xmm2,%xmm4
pand   %xmm6,%xmm4
pcmpeqd %xmm3,%xmm5
pandn  %xmm5,%xmm6
por    %xmm4,%xmm6
psrld  $0x1f,%xmm6
movdqu %xmm6,(%rcx,%rdi,4)
add    $0x4,%rdi
cmp    $0x1c,%rdi
jne    14f0 <main+0x3f0>
mov    0x84(%rsp,%r14,4),%r15d
mov    -0x7c(%rsp,%r14,4),%r13d
lea    (%r15,%r13,1),%ebp
lea    0x0(,%r14,4),%rbx
mov    %rbx,%rax
or     $0x70,%rax
add    -0x70(%rsp,%rax,1),%ebp
mov    %rbx,%r9
or     $0x78,%r9
mov    -0x70(%rsp,%r9,1),%r12d
add    %r12d,%ebp
add    -0x80(%rsp,%r14,4),%ebp
mov    -0x78(%rsp,%r14,4),%r10d
add    %r10d,%ebp
add    0x80(%rsp,%r14,4),%ebp
mov    0x88(%rsp,%r14,4),%edi
add    %edi,%ebp
mov    %rbx,%r11
or     $0x74,%r11
xor    %eax,%eax
cmp    $0x3,%ebp
sete   %al
and    $0xfffffffe,%ebp
xor    %esi,%esi
cmp    $0x2,%ebp
mov    -0x70(%rsp,%r11,1),%ebp
sete   %sil
test   %ebp,%ebp
cmove  %eax,%esi
add    %r10d,%edi
add    %ebp,%edi
or     $0x7c,%rbx
add    -0x70(%rsp,%rbx,1),%edi
add    %r13d,%edi
movzbl %sil,%eax
add    -0x74(%rsp,%r14,4),%edi
mov    %eax,0x1090(%rsp,%r11,1)
add    %r15d,%edi
add    0x8c(%rsp,%r14,4),%edi
xor    %eax,%eax
cmp    $0x3,%edi
sete   %al
and    $0xfffffffe,%edi
xor    %esi,%esi
cmp    $0x2,%edi
sete   %sil
test   %r12d,%r12d
cmove  %eax,%esi
movzbl %sil,%eax
mov    %eax,0x1090(%rsp,%r9,1)
add    $0x1,%r8
sub    $0xffffffffffffff80,%rdx
sub    $0xffffffffffffff80,%rcx
cmp    $0x21,%r8
jne    14e0 <main+0x3e0>
mov    -0x80(%rsp),%rcx
lea    0x2(%rcx),%eax
cmp    $0x12,%ecx
jb     1310 <main+0x210>
xor    %eax,%eax
xor    %ecx,%ecx
movdqu -0x14(%rsp,%rax,1),%xmm0
movdqu -0x64(%rsp,%rax,1),%xmm1
movdqu -0x54(%rsp,%rax,1),%xmm2
movdqu -0x44(%rsp,%rax,1),%xmm3
paddd  %xmm2,%xmm3
movdqu -0x34(%rsp,%rax,1),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x4(%rsp,%rax,1),%xmm0
movdqu -0x24(%rsp,%rax,1),%xmm4
paddd  %xmm0,%xmm4
paddd  %xmm2,%xmm4
pshufd $0xee,%xmm4,%xmm0
paddd  %xmm4,%xmm0
pshufd $0x55,%xmm0,%xmm2
paddd  %xmm0,%xmm2
movd   %xmm2,%edx
pshufd $0xee,%xmm3,%xmm0
paddd  %xmm3,%xmm0
pshufd $0x55,%xmm0,%xmm2
paddd  %xmm0,%xmm2
movd   %xmm2,%esi
add    %edx,%esi
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
add    %esi,%edx
add    -0x68(%rsp,%rax,1),%edx
add    -0x6c(%rsp,%rax,1),%edx
add    -0x70(%rsp,%rax,1),%edx
add    %edx,%ecx
sub    $0xffffffffffffff80,%rax
cmp    $0x1080,%rax
jne    1670 <main+0x570>
cmp    $0xbf,%ecx
mov    $0xbadbeef,%ecx
mov    $0xbad,%eax
cmove  %ecx,%eax
add    $0x2198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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