#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int rand();
int move(const int s, const int *const u, const int *const v, const int k) {
  int i, j;
  switch (s) {
  case 0:
    return 1;
  case 1:
    return 0;
  case 2:
    return rand() & 1;
  case 3:
    return k && v[k - 1];
  case 4:
    return !k || v[k - 1];
  case 5:
    return k > 1 && v[k - 1] && v[k - 2];
  case 6:
    return (k > 1 && (v[k - 1] || v[k - 2])) || (k && v[k - 1]);
  case 7:
    return k && (u[k - 1] || v[k - 1]);
  case 8:
    return k ? u[k - 1] ^ v[k - 1] : rand() & 1;
  case 9:
    for (i = j = 0; j < k; ++j)
      i += v[j];
    return k && ((i << 1) > k);
  case 10:
    for (i = j = 0; j < k; ++j)
      i += v[j];
    return !k || ((i << 1) >= k);
  case 11:
    return k > 1 ? u[0] != v[0] || u[1] != v[1] : !k;
  case 12:
    return !(k && v[k - 1]);
  case 13:
    return k && rand() % 10 > 0 && v[k - 1];
  case 14:
    return k && !u[k - 1];
  default:
    return 1;
  }
}


x86 assembly (clang, -O0):
<move>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x8(%rbp),%eax
mov    %rax,-0x30(%rbp)
sub    $0xe,%rax
ja     1545 <move+0x435>
mov    -0x30(%rbp),%rax
lea    0xebe(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x1,-0x4(%rbp)
jmp    154c <move+0x43c>
movl   $0x0,-0x4(%rbp)
jmp    154c <move+0x43c>
mov    $0x0,%al
call   1030 <rand@plt>
and    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
xor    %eax,%eax
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x31(%rbp)
je     119b <move+0x8b>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
mov    $0x1,%al
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x32(%rbp)
je     11d1 <move+0xc1>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
xor    %eax,%eax
cmpl   $0x1,-0x1c(%rbp)
mov    %al,-0x33(%rbp)
jle    1223 <move+0x113>
mov    -0x18(%rbp),%rcx
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
xor    %eax,%eax
cmpl   $0x0,(%rcx,%rdx,4)
mov    %al,-0x33(%rbp)
je     1223 <move+0x113>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
mov    %al,-0x33(%rbp)
mov    -0x33(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
cmpl   $0x1,-0x1c(%rbp)
jle    1275 <move+0x165>
mov    -0x18(%rbp),%rcx
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
mov    $0x1,%al
cmpl   $0x0,(%rcx,%rdx,4)
mov    %al,-0x34(%rbp)
jne    12a1 <move+0x191>
mov    -0x18(%rbp),%rcx
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
movslq %eax,%rdx
mov    $0x1,%al
cmpl   $0x0,(%rcx,%rdx,4)
mov    %al,-0x34(%rbp)
jne    12a1 <move+0x191>
xor    %eax,%eax
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x35(%rbp)
je     129b <move+0x18b>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
mov    %al,-0x35(%rbp)
mov    -0x35(%rbp),%al
mov    %al,-0x34(%rbp)
mov    -0x34(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
xor    %eax,%eax
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x36(%rbp)
je     12f9 <move+0x1e9>
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
mov    $0x1,%al
cmpl   $0x0,(%rcx,%rdx,4)
mov    %al,-0x37(%rbp)
jne    12f3 <move+0x1e3>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
mov    %al,-0x37(%rbp)
mov    -0x37(%rbp),%al
mov    %al,-0x36(%rbp)
mov    -0x36(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
cmpl   $0x0,-0x1c(%rbp)
je     133b <move+0x22b>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
xor    (%rcx,%rdx,4),%eax
mov    %eax,-0x3c(%rbp)
jmp    1348 <move+0x238>
mov    $0x0,%al
call   1030 <rand@plt>
and    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    138c <move+0x27c>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1361 <move+0x251>
xor    %eax,%eax
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x3d(%rbp)
je     13aa <move+0x29a>
mov    -0x20(%rbp),%eax
shl    $0x1,%eax
cmp    -0x1c(%rbp),%eax
setg   %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13f3 <move+0x2e3>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13c8 <move+0x2b8>
mov    $0x1,%al
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x3e(%rbp)
je     1411 <move+0x301>
mov    -0x20(%rbp),%eax
shl    $0x1,%eax
cmp    -0x1c(%rbp),%eax
setge  %al
mov    %al,-0x3e(%rbp)
mov    -0x3e(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
cmpl   $0x1,-0x1c(%rbp)
jle    1466 <move+0x356>
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
mov    -0x18(%rbp),%rdx
mov    $0x1,%al
cmp    (%rdx),%ecx
mov    %al,-0x3f(%rbp)
jne    1456 <move+0x346>
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    -0x18(%rbp),%rcx
cmp    0x4(%rcx),%eax
setne  %al
mov    %al,-0x3f(%rbp)
mov    -0x3f(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
jmp    1477 <move+0x367>
cmpl   $0x0,-0x1c(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
xor    %eax,%eax
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x45(%rbp)
je     14a8 <move+0x398>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
mov    %al,-0x45(%rbp)
mov    -0x45(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
xor    %eax,%eax
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x46(%rbp)
je     14fd <move+0x3ed>
mov    $0x0,%al
call   1030 <rand@plt>
mov    $0xa,%ecx
cltd
idiv   %ecx
xor    %eax,%eax
cmp    $0x0,%edx
mov    %al,-0x46(%rbp)
jle    14fd <move+0x3ed>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
mov    %al,-0x46(%rbp)
mov    -0x46(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
xor    %eax,%eax
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x47(%rbp)
je     1535 <move+0x425>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
xor    $0xff,%al
mov    %al,-0x47(%rbp)
mov    -0x47(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    154c <move+0x43c>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<move>:
push   %rbp
push   %r14
push   %rbx
mov    $0x1,%ebp
add    $0xffffffff,%edi
cmp    $0xd,%edi
ja     153f <move+0x42f>
mov    %ecx,%r14d
mov    %rdx,%rbx
lea    0xece(%rip),%rax
movslq (%rax,%rdi,4),%rcx
add    %rax,%rcx
jmp    *%rcx
test   %r14d,%r14d
jne    12a8 <move+0x198>
jmp    12f0 <move+0x1e0>
test   %r14d,%r14d
jne    12a8 <move+0x198>
jmp    153f <move+0x42f>
xor    %ebp,%ebp
cmp    $0x2,%r14d
jl     153f <move+0x42f>
lea    -0x1(%r14),%eax
cmpl   $0x0,(%rbx,%rax,4)
je     153f <move+0x42f>
add    $0xfffffffe,%r14d
xor    %ebp,%ebp
cmpl   $0x0,(%rbx,%r14,4)
setne  %bpl
jmp    153f <move+0x42f>
cmp    $0x2,%r14d
jl     12d3 <move+0x1c3>
lea    -0x1(%r14),%eax
cmpl   $0x0,(%rbx,%rax,4)
jne    153f <move+0x42f>
add    $0xfffffffe,%r14d
cmpl   $0x0,(%rbx,%r14,4)
jne    153f <move+0x42f>
jmp    12df <move+0x1cf>
test   %r14d,%r14d
je     12f0 <move+0x1e0>
movslq %r14d,%rax
cmpl   $0x0,-0x4(%rsi,%rax,4)
jne    153f <move+0x42f>
add    $0xffffffffffffffff,%rax
jmp    12e1 <move+0x1d1>
test   %r14d,%r14d
je     11e6 <move+0xd6>
movslq %r14d,%rax
mov    -0x4(%rbx,%rax,4),%ebp
xor    -0x4(%rsi,%rax,4),%ebp
jmp    153f <move+0x42f>
xor    %eax,%eax
call   1030 <rand@plt>
mov    %eax,%ebp
and    $0x1,%ebp
jmp    153f <move+0x42f>
test   %r14d,%r14d
jle    1305 <move+0x1f5>
mov    %r14d,%eax
cmp    $0x8,%r14d
jae    1313 <move+0x203>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1440 <move+0x330>
test   %r14d,%r14d
jle    130c <move+0x1fc>
mov    %r14d,%eax
cmp    $0x8,%r14d
jae    1341 <move+0x231>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1520 <move+0x410>
cmp    $0x2,%r14d
jl     12f7 <move+0x1e7>
mov    (%rsi),%ecx
mov    $0x1,%al
cmp    (%rbx),%ecx
jne    12fd <move+0x1ed>
mov    0x4(%rsi),%eax
cmp    0x4(%rbx),%eax
setne  %al
movzbl %al,%ebp
jmp    153f <move+0x42f>
test   %r14d,%r14d
je     153f <move+0x42f>
movslq %r14d,%rax
xor    %ebp,%ebp
cmpl   $0x0,-0x4(%rbx,%rax,4)
jmp    12ca <move+0x1ba>
xor    %ebp,%ebp
test   %r14d,%r14d
je     153f <move+0x42f>
xor    %eax,%eax
call   1030 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
test   %eax,%eax
jle    153f <move+0x42f>
movslq %r14d,%rax
xor    %ebp,%ebp
cmpl   $0x0,-0x4(%rbx,%rax,4)
setne  %bpl
jmp    153f <move+0x42f>
test   %r14d,%r14d
je     12f0 <move+0x1e0>
movslq %r14d,%rax
xor    %ebp,%ebp
cmpl   $0x0,-0x4(%rsi,%rax,4)
sete   %bpl
jmp    153f <move+0x42f>
test   %r14d,%r14d
je     12f0 <move+0x1e0>
add    $0xffffffff,%r14d
mov    %r14d,%eax
cltq
xor    %ebp,%ebp
cmpl   $0x0,(%rbx,%rax,4)
setne  %bpl
jmp    153f <move+0x42f>
xor    %ebp,%ebp
jmp    153f <move+0x42f>
test   %r14d,%r14d
sete   %al
movzbl %al,%ebp
jmp    153f <move+0x42f>
xor    %edx,%edx
jmp    144e <move+0x33e>
xor    %edx,%edx
jmp    152e <move+0x41e>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    1373 <move+0x263>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
jmp    13e9 <move+0x2d9>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    1461 <move+0x351>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
jmp    14c9 <move+0x3b9>
and    $0xfffffffffffffffc,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu (%rbx,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rsi,4),%xmm1
movdqu 0x30(%rbx,%rsi,4),%xmm3
movdqu 0x40(%rbx,%rsi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%rbx,%rsi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%rbx,%rsi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%rbx,%rsi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1390 <move+0x280>
test   %rdx,%rdx
je     141c <move+0x30c>
lea    (%rbx,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movdqu -0x10(%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1400 <move+0x2f0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
cmp    %rax,%rcx
je     144c <move+0x33c>
nopl   0x0(%rax,%rax,1)
add    (%rbx,%rcx,4),%edx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1440 <move+0x330>
add    %edx,%edx
test   %r14d,%r14d
setne  %al
cmp    %r14d,%edx
setg   %cl
and    %al,%cl
jmp    153c <move+0x42c>
and    $0xfffffffffffffffc,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
nop
movdqu (%rbx,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rsi,4),%xmm1
movdqu 0x30(%rbx,%rsi,4),%xmm3
movdqu 0x40(%rbx,%rsi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%rbx,%rsi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%rbx,%rsi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%rbx,%rsi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1470 <move+0x360>
test   %rdx,%rdx
je     14fc <move+0x3ec>
lea    (%rbx,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movdqu -0x10(%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    14e0 <move+0x3d0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
cmp    %rax,%rcx
je     152c <move+0x41c>
nopl   0x0(%rax,%rax,1)
add    (%rbx,%rcx,4),%edx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1520 <move+0x410>
add    %edx,%edx
test   %r14d,%r14d
sete   %al
cmp    %r14d,%edx
setge  %cl
or     %al,%cl
movzbl %cl,%ebp
mov    %ebp,%eax
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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