#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 */
char *calloc(int, int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int *malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int rand();
int /*<<< orphan*/ srand(int);
int /*<<< orphan*/ stderr;
int strtol(char *, int /*<<< orphan*/ *, int);
int time(int /*<<< orphan*/ *);
int main(int argc, char **argv) {
  int R;
  int n;
  int S;
  int *s;
  char *F;
  if (argc < 3) {
    fprintf(stderr, "usage: %s R n [seed]\n", argv[0]);
    return 1;
  }
  R = strtol(argv[1], NULL, 10);
  n = strtol(argv[2], NULL, 10);
  S = n * R / 4;
  int m = S + 1;
  s = malloc((n + 1) * sizeof(int));
  F = calloc((n + 1) * m, sizeof(char));
  if (!s || !F) {
    fprintf(stderr, "couldn't allocate memory\n");
    return 1;
  }
  if (4 == argc)
    srand(strtol(argv[3], NULL, 10));
  else
    srand(time(NULL));
  for (int i = 1; i <= n; i++) {
    s[i] = rand() % R;
    printf("%d ", s[i]);
    F[i * m] = 1;
  }
  printf("\n sum = %d\n", S);
  F[m + s[1]] = 1;
  for (int i = 2; i <= n; i++) {
    for (int j = 1; j < s[i]; j++) {
      F[i * m + j] = F[(i - 1) * m + j];
    }
    for (int j = s[i]; j <= S; j++) {
      F[i * m + j] = F[(i - 1) * m + j] || F[(i - 1) * m + j - s[i]];
    }
  }
  printf("%s\n", F[n * m + S] ? "true" : "false");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x3,-0x8(%rbp)
jge    11ca <main+0x4a>
mov    0x2e39(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0xe49(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1498 <main+0x318>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0xa,%edx
call   1070 <strtol@plt>
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0xa,%edx
call   1070 <strtol@plt>
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%edi
add    $0x1,%edi
imul   -0x34(%rbp),%edi
mov    $0x1,%esi
call   1050 <calloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     125c <main+0xdc>
cmpq   $0x0,-0x30(%rbp)
jne    127f <main+0xff>
mov    0x2d7d(%rip),%rax
mov    (%rax),%edi
lea    0xdaa(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1498 <main+0x318>
mov    $0x4,%eax
cmp    -0x8(%rbp),%eax
jne    12af <main+0x12f>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0xa,%edx
call   1070 <strtol@plt>
mov    %eax,%edi
call   1040 <srand@plt>
jmp    12bf <main+0x13f>
xor    %eax,%eax
mov    %eax,%edi
call   1080 <time@plt>
mov    %eax,%edi
call   1040 <srand@plt>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1321 <main+0x1a1>
mov    $0x0,%al
call   10a0 <rand@plt>
cltd
idivl  -0x14(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xd36(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12c6 <main+0x146>
mov    -0x1c(%rbp),%esi
lea    0xd09(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x28(%rbp),%rdx
add    0x4(%rdx),%ecx
movslq %ecx,%rcx
movb   $0x1,(%rax,%rcx,1)
movl   $0x2,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1459 <main+0x2d9>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    13ae <main+0x22e>
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x34(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1361 <main+0x1e1>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1446 <main+0x2c6>
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x34(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x0,%ecx
mov    %al,-0x45(%rbp)
jne    141a <main+0x29a>
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x34(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    -0x28(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x45(%rbp)
mov    -0x45(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13bc <main+0x23c>
jmp    144b <main+0x2cb>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    134e <main+0x1ce>
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
lea    0xbd4(%rip),%rsi
lea    0xbc8(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rsi
lea    0xbb6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rsi,%r13
cmp    $0x2,%edi
jg     11cb <main+0x3b>
mov    0x2e33(%rip),%rax
mov    (%rax),%edi
mov    0x0(%r13),%rdx
lea    0xe46(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    $0x1,%ebp
jmp    135b <main+0x1cb>
mov    %edi,0x18(%rsp)
mov    0x8(%r13),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1080 <strtol@plt>
mov    %eax,%r12d
mov    0x10(%r13),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1080 <strtol@plt>
mov    %eax,%r15d
imul   %r12d,%eax
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
sar    $0x2,%ecx
mov    %rcx,0x10(%rsp)
movslq %ecx,%rbp
add    $0x1,%rbp
lea    0x1(%r15),%r14d
lea    0x4(,%r15,4),%edi
call   10a0 <malloc@plt>
mov    %rax,%rbx
mov    %rbp,0x38(%rsp)
mov    %ebp,%edi
mov    %r14d,0x8(%rsp)
imul   %r14d,%edi
mov    $0x1,%ebp
mov    $0x1,%esi
call   1060 <calloc@plt>
mov    %rbx,0x30(%rsp)
test   %rbx,%rbx
je     1274 <main+0xe4>
test   %rax,%rax
je     1274 <main+0xe4>
mov    %rax,(%rsp)
cmpl   $0x4,0x18(%rsp)
mov    %r15,0x20(%rsp)
jne    1290 <main+0x100>
mov    0x18(%r13),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1080 <strtol@plt>
jmp    1297 <main+0x107>
mov    0x2d65(%rip),%rax
mov    (%rax),%edi
lea    0xd92(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
jmp    135b <main+0x1cb>
xor    %edi,%edi
call   1090 <time@plt>
mov    0x30(%rsp),%r13
mov    %eax,%edi
call   1050 <srand@plt>
movslq 0x38(%rsp),%rcx
mov    0x8(%rsp),%r15d
cmpl   $0x0,0x20(%rsp)
mov    %rcx,0x8(%rsp)
jle    12fe <main+0x16e>
mov    (%rsp),%rax
lea    (%rax,%rcx,1),%rbp
mov    $0x1,%ebx
lea    0xd63(%rip),%r14
nopl   (%rax)
xor    %eax,%eax
call   10b0 <rand@plt>
cltd
idiv   %r12d
mov    %edx,0x0(%r13,%rbx,4)
mov    %r14,%rdi
mov    %edx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
movb   $0x1,0x0(%rbp)
add    $0x1,%rbx
add    0x8(%rsp),%rbp
cmp    %rbx,%r15
jne    12d0 <main+0x140>
lea    0xd2f(%rip),%rdi
mov    0x10(%rsp),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
movslq 0x4(%r13),%rax
mov    0x38(%rsp),%rdi
add    %rdi,%rax
mov    (%rsp),%rcx
movb   $0x1,(%rcx,%rax,1)
cmpl   $0x2,0x20(%rsp)
jge    136c <main+0x1dc>
mov    0x20(%rsp),%rax
imul   %edi,%eax
add    0x10(%rsp),%eax
cltq
mov    (%rsp),%rcx
cmpb   $0x0,(%rcx,%rax,1)
lea    0xcfc(%rip),%rax
lea    0xcf0(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
xor    %ebp,%ebp
mov    %ebp,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r15,%rbp
mov    0x8(%rsp),%rdx
lea    (%rdx,%rdx,1),%rax
mov    %rax,0x50(%rsp)
lea    (%rdx,%rdx,1),%rax
add    $0x1,%rax
mov    %rax,0x58(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0x48(%rsp)
mov    0x10(%rsp),%rax
lea    0x1(%rax),%eax
mov    %eax,0x44(%rsp)
mov    (%rsp),%rax
lea    0x31(%rax,%rdx,2),%r8
lea    0x31(%rdx,%rax,1),%r12
lea    0x1(%rdx,%rax,1),%r15
lea    0x1(%rax,%rdx,2),%r13
lea    (%rax,%rdx,2),%rcx
lea    (%rax,%rdx,1),%rsi
mov    $0x2,%r14d
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %rbp,0x60(%rsp)
jmp    140f <main+0x27f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
addq   $0x1,0x18(%rsp)
mov    0x8(%rsp),%rax
add    %rax,%r8
add    %rax,%r12
add    %rax,%r15
add    %rax,%r13
add    %rax,%rcx
add    %rax,%rsi
mov    0x60(%rsp),%rbp
cmp    %rbp,%r14
je     132c <main+0x19c>
mov    0x30(%rsp),%rax
movslq (%rax,%r14,4),%rbx
mov    %ebx,%r9d
cmp    $0x2,%rbx
jl     1623 <main+0x493>
lea    -0x1(%r9),%rax
mov    $0x1,%r11d
cmp    $0x8,%rax
jb     15b0 <main+0x420>
mov    %rax,0x28(%rsp)
mov    0x18(%rsp),%rax
mov    0x8(%rsp),%rbp
imul   %rbp,%rax
mov    0x58(%rsp),%rdx
add    %rax,%rdx
mov    (%rsp),%rdi
add    %rdi,%rdx
add    %rax,%rbp
add    %rdi,%rbp
add    %r9,%rbp
cmp    %rbp,%rdx
jae    148c <main+0x2fc>
mov    0x50(%rsp),%rdx
add    %rax,%rdx
mov    (%rsp),%rdi
add    %rdi,%rdx
add    0x48(%rsp),%rax
add    %rdi,%rax
add    %r9,%rdx
cmp    %rdx,%rax
jb     15b0 <main+0x420>
mov    0x28(%rsp),%rdi
cmp    $0x20,%rdi
jae    149f <main+0x30f>
xor    %r10d,%r10d
jmp    155b <main+0x3cb>
mov    %rdi,%r10
and    $0xffffffffffffffe0,%r10
lea    -0x20(%r10),%rax
mov    %rax,%r11
shr    $0x5,%r11
add    $0x1,%r11
test   %rax,%rax
je     158c <main+0x3fc>
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x30(%r12,%rbp,1),%xmm0
movups -0x20(%r12,%rbp,1),%xmm1
movups %xmm0,-0x30(%r8,%rbp,1)
movups %xmm1,-0x20(%r8,%rbp,1)
movups -0x10(%r12,%rbp,1),%xmm0
movups (%r12,%rbp,1),%xmm1
movups %xmm0,-0x10(%r8,%rbp,1)
movups %xmm1,(%r8,%rbp,1)
add    $0x40,%rbp
add    $0xfffffffffffffffe,%rax
jne    14d0 <main+0x340>
test   $0x1,%r11b
je     1547 <main+0x3b7>
lea    -0x1(%r14),%rax
mov    0x8(%rsp),%rdi
imul   %rdi,%rax
mov    %r14,%rdx
imul   %rdi,%rdx
or     $0x1,%rbp
add    %rbp,%rax
mov    (%rsp),%rdi
movups (%rdi,%rax,1),%xmm0
movups 0x10(%rdi,%rax,1),%xmm1
add    %rdx,%rbp
movups %xmm0,(%rdi,%rbp,1)
movups %xmm1,0x10(%rdi,%rbp,1)
mov    0x28(%rsp),%rdi
cmp    %r10,%rdi
je     1623 <main+0x493>
mov    0x28(%rsp),%rdi
test   $0x18,%dil
je     159a <main+0x40a>
mov    %rdi,%rax
and    $0xfffffffffffffff8,%rax
lea    0x1(%rax),%r11
cs nopw 0x0(%rax,%rax,1)
mov    (%r15,%r10,1),%rdx
mov    %rdx,0x0(%r13,%r10,1)
add    $0x8,%r10
cmp    %r10,%rax
jne    1570 <main+0x3e0>
cmp    %rax,%rdi
jne    15b0 <main+0x420>
jmp    1623 <main+0x493>
xor    %ebp,%ebp
test   $0x1,%r11b
jne    150e <main+0x37e>
jmp    1547 <main+0x3b7>
or     $0x1,%r10
mov    %r10,%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r9d,%ebp
sub    %r11d,%ebp
mov    %r11,%rax
not    %rax
add    %r9,%rax
and    $0x3,%rbp
je     15e3 <main+0x453>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rsi,%r11,1),%edx
mov    %dl,(%rcx,%r11,1)
add    $0x1,%r11
add    $0xffffffffffffffff,%rbp
jne    15d0 <main+0x440>
cmp    $0x3,%rax
jb     1623 <main+0x493>
nopl   0x0(%rax)
movzbl (%rsi,%r11,1),%eax
mov    %al,(%rcx,%r11,1)
movzbl 0x1(%rsi,%r11,1),%eax
mov    %al,0x1(%rcx,%r11,1)
movzbl 0x2(%rsi,%r11,1),%eax
mov    %al,0x2(%rcx,%r11,1)
movzbl 0x3(%rsi,%r11,1),%eax
mov    %al,0x3(%rcx,%r11,1)
add    $0x4,%r11
cmp    %r11,%r9
jne    15f0 <main+0x460>
cmp    %ebx,0x10(%rsp)
mov    0x38(%rsp),%rdi
jl     13e0 <main+0x250>
mov    0x44(%rsp),%eax
sub    %r9d,%eax
mov    %rbx,%rbp
test   $0x1,%al
je     1679 <main+0x4e9>
lea    -0x1(%r14),%rbp
mov    0x8(%rsp),%rdx
imul   %rdx,%rbp
mov    %r14,%rax
imul   %rdx,%rax
lea    (%rbx,%rbp,1),%r11
mov    $0x1,%r10b
mov    (%rsp),%rdx
cmpb   $0x0,(%rdx,%r11,1)
jne    166e <main+0x4de>
cmpb   $0x0,(%rdx,%rbp,1)
setne  %r10b
add    %rbx,%rax
mov    %r10b,(%rdx,%rax,1)
lea    0x1(%rbx),%rbp
cmp    %r9d,0x10(%rsp)
je     13e0 <main+0x250>
mov    %r15,%rax
sub    %rbx,%rax
jmp    16a1 <main+0x511>
nopl   0x0(%rax)
mov    %bl,0x0(%r13,%rbp,1)
add    $0x2,%rbp
cmp    %ebp,%edi
je     13e0 <main+0x250>
mov    $0x1,%bl
cmpb   $0x0,-0x1(%r15,%rbp,1)
mov    $0x1,%dl
jne    16b5 <main+0x525>
cmpb   $0x0,-0x1(%rax,%rbp,1)
setne  %dl
mov    %dl,-0x1(%r13,%rbp,1)
cmpb   $0x0,(%r15,%rbp,1)
jne    1690 <main+0x500>
cmpb   $0x0,(%rax,%rbp,1)
setne  %bl
jmp    1690 <main+0x500>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [22 x i8] c"usage: %s R n [seed]\0A\00"
@.str.1 = [26 x i8] c"couldn't allocate memory\0A\00"
@.str.2 = [4 x i8] c"%d \00"
@.str.3 = [12 x i8] c"\0A sum = %d\0A\00"
@.str.4 = [4 x i8] c"%s\0A\00"
@.str.5 = [5 x i8] c"true\00"
@.str.6 = [6 x i8] c"false\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%16 = load i32, i32* %4
%17 = icmp slt i32 %16, 3
br i1 %17, label %18, label %24
18: ; preds = %2
%19 = load i32, i32* @stderr
%20 = load i8**, i8*** %5
%21 = getelementptr inbounds i8*, i8** %20, i64 0
%22 = load i8*, i8** %21
%23 = call i32 (i32, i8*, ...) @fprintf(i32 %19, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0), i8* %22)
store i32 1, i32* %3
br label %220
24: ; preds = %2
%25 = load i8**, i8*** %5
%26 = getelementptr inbounds i8*, i8** %25, i64 1
%27 = load i8*, i8** %26
%28 = call i32 @strtol(i8* %27, i32* null, i32 10)
store i32 %28, i32* %6
%29 = load i8**, i8*** %5
%30 = getelementptr inbounds i8*, i8** %29, i64 2
%31 = load i8*, i8** %30
%32 = call i32 @strtol(i8* %31, i32* null, i32 10)
store i32 %32, i32* %7
%33 = load i32, i32* %7
%34 = load i32, i32* %6
%35 = mul nsw i32 %33, %34
%36 = sdiv i32 %35, 4
store i32 %36, i32* %8
%37 = load i32, i32* %8
%38 = add nsw i32 %37, 1
store i32 %38, i32* %11
%39 = load i32, i32* %7
%40 = add nsw i32 %39, 1
%41 = sext i32 %40 to i64
%42 = mul i64 %41, 4
%43 = trunc i64 %42 to i32
%44 = call i32* @malloc(i32 %43)
store i32* %44, i32** %9
%45 = load i32, i32* %7
%46 = add nsw i32 %45, 1
%47 = load i32, i32* %11
%48 = mul nsw i32 %46, %47
%49 = call i8* @calloc(i32 %48, i32 1)
store i8* %49, i8** %10
%50 = load i32*, i32** %9
%51 = icmp ne i32* %50, null
br i1 %51, label %52, label %55
52: ; preds = %24
%53 = load i8*, i8** %10
%54 = icmp ne i8* %53, null
br i1 %54, label %58, label %55
55: ; preds = %52, %24
%56 = load i32, i32* @stderr
%57 = call i32 (i32, i8*, ...) @fprintf(i32 %56, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %3
br label %220
58: ; preds = %52
%59 = load i32, i32* %4
%60 = icmp eq i32 4, %59
br i1 %60, label %61, label %67
61: ; preds = %58
%62 = load i8**, i8*** %5
%63 = getelementptr inbounds i8*, i8** %62, i64 3
%64 = load i8*, i8** %63
%65 = call i32 @strtol(i8* %64, i32* null, i32 10)
%66 = call i32 @srand(i32 %65)
br label %70
67: ; preds = %58
%68 = call i32 @time(i32* null)
%69 = call i32 @srand(i32 %68)
br label %70
70: ; preds = %67, %61
store i32 1, i32* %12
br label %71
71: ; preds = %95, %70
%72 = load i32, i32* %12
%73 = load i32, i32* %7
%74 = icmp sle i32 %72, %73
br i1 %74, label %75, label %98
75: ; preds = %71
%76 = call i32 (...) @rand()
%77 = load i32, i32* %6
%78 = srem i32 %76, %77
%79 = load i32*, i32** %9
%80 = load i32, i32* %12
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32, i32* %79, i64 %81
store i32 %78, i32* %82
%83 = load i32*, i32** %9
%84 = load i32, i32* %12
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i32, i32* %83, i64 %85
%87 = load i32, i32* %86
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %87)
%89 = load i8*, i8** %10
%90 = load i32, i32* %12
%91 = load i32, i32* %11
%92 = mul nsw i32 %90, %91
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %89, i64 %93
store i8 1, i8* %94
br label %95
95: ; preds = %75
%96 = load i32, i32* %12
%97 = add nsw i32 %96, 1
store i32 %97, i32* %12
br label %71
98: ; preds = %71
%99 = load i32, i32* %8
%100 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0), i32 %99)
%101 = load i8*, i8** %10
%102 = load i32, i32* %11
%103 = load i32*, i32** %9
%104 = getelementptr inbounds i32, i32* %103, i64 1
%105 = load i32, i32* %104
%106 = add nsw i32 %102, %105
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds i8, i8* %101, i64 %107
store i8 1, i8* %108
store i32 2, i32* %13
br label %109
109: ; preds = %202, %98
%110 = load i32, i32* %13
%111 = load i32, i32* %7
%112 = icmp sle i32 %110, %111
br i1 %112, label %113, label %205
113: ; preds = %109
store i32 1, i32* %14
br label %114
114: ; preds = %141, %113
%115 = load i32, i32* %14
%116 = load i32*, i32** %9
%117 = load i32, i32* %13
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32, i32* %116, i64 %118
%120 = load i32, i32* %119
%121 = icmp slt i32 %115, %120
br i1 %121, label %122, label %144
122: ; preds = %114
%123 = load i8*, i8** %10
%124 = load i32, i32* %13
%125 = sub nsw i32 %124, 1
%126 = load i32, i32* %11
%127 = mul nsw i32 %125, %126
%128 = load i32, i32* %14
%129 = add nsw i32 %127, %128
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds i8, i8* %123, i64 %130
%132 = load i8, i8* %131
%133 = load i8*, i8** %10
%134 = load i32, i32* %13
%135 = load i32, i32* %11
%136 = mul nsw i32 %134, %135
%137 = load i32, i32* %14
%138 = add nsw i32 %136, %137
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i8, i8* %133, i64 %139
store i8 %132, i8* %140
br label %141
141: ; preds = %122
%142 = load i32, i32* %14
%143 = add nsw i32 %142, 1
store i32 %143, i32* %14
br label %114
144: ; preds = %114
%145 = load i32*, i32** %9
%146 = load i32, i32* %13
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %145, i64 %147
%149 = load i32, i32* %148
store i32 %149, i32* %15
br label %150
150: ; preds = %198, %144
%151 = load i32, i32* %15
%152 = load i32, i32* %8
%153 = icmp sle i32 %151, %152
br i1 %153, label %154, label %201
154: ; preds = %150
%155 = load i8*, i8** %10
%156 = load i32, i32* %13
%157 = sub nsw i32 %156, 1
%158 = load i32, i32* %11
%159 = mul nsw i32 %157, %158
%160 = load i32, i32* %15
%161 = add nsw i32 %159, %160
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i8, i8* %155, i64 %162
%164 = load i8, i8* %163
%165 = sext i8 %164 to i32
%166 = icmp ne i32 %165, 0
br i1 %166, label %186, label %167
167: ; preds = %154
%168 = load i8*, i8** %10
%169 = load i32, i32* %13
%170 = sub nsw i32 %169, 1
%171 = load i32, i32* %11
%172 = mul nsw i32 %170, %171
%173 = load i32, i32* %15
%174 = add nsw i32 %172, %173
%175 = load i32*, i32** %9
%176 = load i32, i32* %13
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i32, i32* %175, i64 %177
%179 = load i32, i32* %178
%180 = sub nsw i32 %174, %179
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %168, i64 %181
%183 = load i8, i8* %182
%184 = sext i8 %183 to i32
%185 = icmp ne i32 %184, 0
br label %186
186: ; preds = %167, %154
%187 = phi i1 [ true, %154 ], [ %185, %167 ]
%188 = zext i1 %187 to i32
%189 = trunc i32 %188 to i8
%190 = load i8*, i8** %10
%191 = load i32, i32* %13
%192 = load i32, i32* %11
%193 = mul nsw i32 %191, %192
%194 = load i32, i32* %15
%195 = add nsw i32 %193, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds i8, i8* %190, i64 %196
store i8 %189, i8* %197
br label %198
198: ; preds = %186
%199 = load i32, i32* %15
%200 = add nsw i32 %199, 1
store i32 %200, i32* %15
br label %150
201: ; preds = %150
br label %202
202: ; preds = %201
%203 = load i32, i32* %13
%204 = add nsw i32 %203, 1
store i32 %204, i32* %13
br label %109
205: ; preds = %109
%206 = load i8*, i8** %10
%207 = load i32, i32* %7
%208 = load i32, i32* %11
%209 = mul nsw i32 %207, %208
%210 = load i32, i32* %8
%211 = add nsw i32 %209, %210
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i8, i8* %206, i64 %212
%214 = load i8, i8* %213
%215 = sext i8 %214 to i32
%216 = icmp ne i32 %215, 0
%217 = zext i1 %216 to i64
%218 = select i1 %216, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0)
%219 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %218)
store i32 0, i32* %3
br label %220
220: ; preds = %205, %55, %18
%221 = load i32, i32* %3
ret i32 %221
}

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