#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 */
struct timespec {
  double tv_sec;
  double tv_nsec;
};

/* Variables and functions */
int /*<<< orphan*/ CLOCK_MONOTONIC;
char *calloc(int, int);
int /*<<< orphan*/ clock_gettime(int /*<<< orphan*/, struct timespec *);
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 *Fs;
  char *F;
  struct timespec tstart, tend;
  float timer;
  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));
  Fs = calloc((n + 1) * m, sizeof(char));
  F = calloc((n + 1) * m, sizeof(char));
  if (!s || !F || !Fs) {
    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;
    Fs[i * m] = 1;
  }
  printf("\n sum = %d\n", S);
  F[m + s[1]] = 1;
  Fs[m + s[1]] = 1;
  for (int i = 2; i <= n; i++) {
    for (int j = 1; j < s[i]; j++) {
      Fs[i * m + j] = Fs[(i - 1) * m + j];
    }
    for (int j = s[i]; j <= S; j++) {
      Fs[i * m + j] = Fs[(i - 1) * m + j] || Fs[(i - 1) * m + j - s[i]];
    }
  }
  clock_gettime(CLOCK_MONOTONIC, &tstart);
#pragma omp parallel
  for (int i = 2; i <= n; i++) {
#pragma omp for nowait
    for (int j = 1; j < s[i]; j++) {
      F[i * m + j] = F[(i - 1) * m + j];
    }
#pragma omp for
    for (int j = s[i]; j <= S; j++) {
      F[i * m + j] = F[(i - 1) * m + j] || F[(i - 1) * m + j - s[i]];
    }
  }
  clock_gettime(CLOCK_MONOTONIC, &tend);
  timer =
      (tend.tv_sec - tstart.tv_sec) + (tend.tv_nsec - tstart.tv_nsec) * 1.0e-9;
  printf("%s\n", F[n * m + S] ? "true" : "false");
  printf("time in s: %f\n", timer);
  int passed = 1;
  for (int i = 2; i <= n; i++) {
    for (int j = 1; j <= S; j++) {
      if (F[i * m + j] != Fs[i * m + j]) {
        printf("i=%d, j=%d, F=%d, Fs=%d\n", i, j, F[i * m + j], Fs[i * m + j]);
        passed = 0;
      }
    }
  }
  if (passed)
    printf("result verified\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x3,-0x8(%rbp)
jge    11dd <main+0x4d>
mov    0x2e1e(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0xe3e(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    179a <main+0x60a>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0xa,%edx
call   1080 <strtol@plt>
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0xa,%edx
call   1080 <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,-0x60(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%edi
add    $0x1,%edi
imul   -0x60(%rbp),%edi
mov    $0x1,%esi
call   1060 <calloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%edi
add    $0x1,%edi
imul   -0x60(%rbp),%edi
mov    $0x1,%esi
call   1060 <calloc@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     1292 <main+0x102>
cmpq   $0x0,-0x38(%rbp)
je     1292 <main+0x102>
cmpq   $0x0,-0x30(%rbp)
jne    12b5 <main+0x125>
mov    0x2d3f(%rip),%rax
mov    (%rax),%edi
lea    0xd7c(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    179a <main+0x60a>
mov    $0x4,%eax
cmp    -0x8(%rbp),%eax
jne    12e5 <main+0x155>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0xa,%edx
call   1080 <strtol@plt>
mov    %eax,%edi
call   1050 <srand@plt>
jmp    12f5 <main+0x165>
xor    %eax,%eax
mov    %eax,%edi
call   1090 <time@plt>
mov    %eax,%edi
call   1050 <srand@plt>
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1369 <main+0x1d9>
mov    $0x0,%al
call   10b0 <rand@plt>
cltd
idivl  -0x14(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xd08(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0x60(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0x60(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12fc <main+0x16c>
mov    -0x1c(%rbp),%esi
lea    0xcc9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x38(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x28(%rbp),%rdx
add    0x4(%rdx),%ecx
movslq %ecx,%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x28(%rbp),%rdx
add    0x4(%rdx),%ecx
movslq %ecx,%rcx
movb   $0x1,(%rax,%rcx,1)
movl   $0x2,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     14bf <main+0x32f>
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x68(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    140b <main+0x27b>
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x60(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    13be <main+0x22e>
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     14ac <main+0x31c>
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x60(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x0,%ecx
mov    %al,-0x89(%rbp)
jne    147d <main+0x2ed>
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x60(%rbp),%ecx
add    -0x70(%rbp),%ecx
mov    -0x28(%rbp),%rdx
movslq -0x68(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x89(%rbp)
mov    -0x89(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1419 <main+0x289>
jmp    14b1 <main+0x321>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    13ab <main+0x21b>
mov    0x2b22(%rip),%rax
mov    (%rax),%edi
lea    -0x48(%rbp),%rsi
call   1030 <clock_gettime@plt>
movl   $0x2,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     15ec <main+0x45c>
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x74(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1538 <main+0x3a8>
mov    -0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x60(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    14eb <main+0x35b>
mov    -0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     15d9 <main+0x449>
mov    -0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x60(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x0,%ecx
mov    %al,-0x8a(%rbp)
jne    15aa <main+0x41a>
mov    -0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x60(%rbp),%ecx
add    -0x7c(%rbp),%ecx
mov    -0x28(%rbp),%rdx
movslq -0x74(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x8a(%rbp)
mov    -0x8a(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1546 <main+0x3b6>
jmp    15de <main+0x44e>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    14d8 <main+0x348>
mov    0x29f5(%rip),%rax
mov    (%rax),%edi
lea    -0x58(%rbp),%rsi
call   1030 <clock_gettime@plt>
movsd  -0x58(%rbp),%xmm1
subsd  -0x48(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  0x9e6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
lea    0xa0a(%rip),%rsi
lea    0x9fe(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rsi
lea    0x9ec(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x9e4(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x80(%rbp)
movl   $0x2,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     177b <main+0x5eb>
movl   $0x1,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1762 <main+0x5d2>
mov    -0x38(%rbp),%rax
mov    -0x84(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x30(%rbp),%rcx
mov    -0x84(%rbp),%edx
imul   -0x60(%rbp),%edx
add    -0x88(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1749 <main+0x5b9>
mov    -0x84(%rbp),%esi
mov    -0x88(%rbp),%edx
mov    -0x38(%rbp),%rax
mov    -0x84(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
mov    -0x30(%rbp),%rax
mov    -0x84(%rbp),%edi
imul   -0x60(%rbp),%edi
add    -0x88(%rbp),%edi
movslq %edi,%rdi
movsbl (%rax,%rdi,1),%r8d
lea    0x92b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x80(%rbp)
jmp    174e <main+0x5be>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    16a4 <main+0x514>
jmp    1767 <main+0x5d7>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    168b <main+0x4fb>
cmpl   $0x0,-0x80(%rbp)
je     1793 <main+0x603>
lea    0x8f3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rsi,%r14
cmp    $0x2,%edi
jg     11de <main+0x3e>
mov    0x2e18(%rip),%rax
mov    (%rax),%edi
mov    (%r14),%rdx
lea    0xe3c(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    $0x1,%r15d
jmp    1865 <main+0x6c5>
mov    %edi,0x8(%rsp)
mov    0x8(%r14),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1090 <strtol@plt>
mov    %eax,%ebx
mov    0x10(%r14),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1090 <strtol@plt>
mov    %eax,%ecx
mov    %ebx,(%rsp)
imul   %ebx,%ecx
lea    0x3(%rcx),%r12d
test   %ecx,%ecx
mov    %rcx,0x70(%rsp)
cmovns %ecx,%r12d
sar    $0x2,%r12d
movslq %r12d,%rbx
add    $0x1,%rbx
lea    0x1(%rax),%ebp
mov    %rax,0x38(%rsp)
lea    0x4(,%rax,4),%edi
call   10b0 <malloc@plt>
mov    %rax,%r13
mov    %rbx,0x20(%rsp)
mov    %ebp,0x40(%rsp)
imul   %ebp,%ebx
mov    $0x1,%r15d
mov    %ebx,%edi
mov    $0x1,%esi
call   1070 <calloc@plt>
mov    %rax,%rbp
mov    %ebx,%edi
mov    $0x1,%esi
call   1070 <calloc@plt>
test   %rbp,%rbp
je     12a4 <main+0x104>
test   %r13,%r13
je     12a4 <main+0x104>
test   %rax,%rax
je     12a4 <main+0x104>
cmpl   $0x4,0x8(%rsp)
mov    %rbp,0x18(%rsp)
mov    %r12,0x30(%rsp)
mov    %rax,0x10(%rsp)
mov    %r13,%r12
jne    12c0 <main+0x120>
mov    0x18(%r14),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1090 <strtol@plt>
jmp    12c7 <main+0x127>
mov    0x2d2d(%rip),%rax
mov    (%rax),%edi
lea    0xd6a(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
jmp    1865 <main+0x6c5>
xor    %edi,%edi
call   10a0 <time@plt>
mov    %eax,%edi
mov    0x38(%rsp),%rbp
mov    0x40(%rsp),%ebx
call   1060 <srand@plt>
mov    %ebx,%r13d
test   %ebp,%ebp
mov    (%rsp),%r14d
jle    132d <main+0x18d>
movslq 0x20(%rsp),%r15
mov    $0x1,%ebx
mov    %r15,%rbp
nop
xor    %eax,%eax
call   10c0 <rand@plt>
cltd
idiv   %r14d
mov    %edx,(%r12,%rbx,4)
lea    0xd32(%rip),%rdi
mov    %edx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x10(%rsp),%rax
movb   $0x1,(%rax,%rbp,1)
mov    0x18(%rsp),%rax
movb   $0x1,(%rax,%rbp,1)
add    $0x1,%rbx
add    %r15,%rbp
cmp    %rbx,%r13
jne    12f0 <main+0x150>
mov    %r13,0x8(%rsp)
lea    0xd03(%rip),%rdi
mov    0x30(%rsp),%rbx
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%r14
movslq 0x4(%r12),%rax
mov    0x20(%rsp),%rcx
add    %rcx,%rax
mov    0x10(%rsp),%rdx
movb   $0x1,(%rdx,%rax,1)
mov    0x18(%rsp),%r12
movb   $0x1,(%r12,%rax,1)
mov    0x38(%rsp),%rax
cmp    $0x1,%eax
jg     138c <main+0x1ec>
mov    0x2c6d(%rip),%rax
mov    (%rax),%edi
lea    0x78(%rsp),%rsi
call   1040 <clock_gettime@plt>
jmp    170e <main+0x56e>
mov    %r14,0x40(%rsp)
movslq %ecx,%rax
lea    (%rax,%rax,1),%rcx
mov    %rcx,0x60(%rsp)
lea    (%rax,%rax,1),%rcx
add    $0x1,%rcx
mov    %rcx,0x68(%rsp)
lea    0x1(%rax),%rcx
mov    %rcx,0x58(%rsp)
lea    0x1(%rbx),%ecx
mov    %ecx,0x4c(%rsp)
lea    0x31(%r12,%rax,2),%r15
lea    0x31(%rax,%r12,1),%r14
lea    0x1(%rax,%r12,1),%r13
lea    0x1(%r12,%rax,2),%r8
lea    (%r12,%rax,2),%rdi
mov    %rax,(%rsp)
lea    (%r12,%rax,1),%rbx
mov    $0x2,%r10d
xor    %eax,%eax
mov    %rax,0x28(%rsp)
jmp    141b <main+0x27b>
nopl   0x0(%rax)
add    $0x1,%r10
addq   $0x1,0x28(%rsp)
mov    (%rsp),%rax
add    %rax,%r15
add    %rax,%r14
add    %rax,%r13
add    %rax,%r8
add    %rax,%rdi
add    %rax,%rbx
cmp    0x8(%rsp),%r10
je     16eb <main+0x54b>
mov    0x40(%rsp),%rax
movslq (%rax,%r10,4),%r9
mov    %r9d,%ebp
cmp    $0x2,%r9
jl     1633 <main+0x493>
lea    -0x1(%rbp),%rax
mov    $0x1,%r12d
cmp    $0x8,%rax
jb     15c0 <main+0x420>
mov    %rax,0x50(%rsp)
mov    0x28(%rsp),%rax
mov    (%rsp),%rdx
imul   %rdx,%rax
mov    0x68(%rsp),%rcx
add    %rax,%rcx
mov    0x18(%rsp),%rsi
add    %rsi,%rcx
add    %rax,%rdx
add    %rsi,%rdx
add    %rbp,%rdx
cmp    %rdx,%rcx
jae    1499 <main+0x2f9>
mov    0x60(%rsp),%rcx
add    %rax,%rcx
mov    0x18(%rsp),%rdx
add    %rdx,%rcx
add    0x58(%rsp),%rax
add    %rdx,%rax
add    %rbp,%rcx
cmp    %rcx,%rax
jb     15c0 <main+0x420>
mov    0x50(%rsp),%rsi
cmp    $0x20,%rsi
jae    14ac <main+0x30c>
xor    %r11d,%r11d
jmp    156b <main+0x3cb>
mov    %rsi,%r11
and    $0xffffffffffffffe0,%r11
lea    -0x20(%r11),%rax
mov    %rax,%r12
shr    $0x5,%r12
add    $0x1,%r12
test   %rax,%rax
je     159c <main+0x3fc>
mov    %r12,%rdx
movabs $0xffffffffffffffe,%rax
ff ff 0f
and    %rax,%rdx
xor    %eax,%eax
nopl   (%rax)
movups -0x30(%r14,%rax,1),%xmm0
movups -0x20(%r14,%rax,1),%xmm1
movups %xmm0,-0x30(%r15,%rax,1)
movups %xmm1,-0x20(%r15,%rax,1)
movups -0x10(%r14,%rax,1),%xmm0
movups (%r14,%rax,1),%xmm1
movups %xmm0,-0x10(%r15,%rax,1)
movups %xmm1,(%r15,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rdx
jne    14e0 <main+0x340>
test   $0x1,%r12b
je     1557 <main+0x3b7>
lea    -0x1(%r10),%rcx
mov    (%rsp),%rsi
imul   %rsi,%rcx
mov    %r10,%rdx
imul   %rsi,%rdx
or     $0x1,%rax
add    %rax,%rcx
mov    0x18(%rsp),%rsi
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
add    %rdx,%rax
movups %xmm0,(%rsi,%rax,1)
movups %xmm1,0x10(%rsi,%rax,1)
mov    0x50(%rsp),%rsi
cmp    %r11,%rsi
je     1633 <main+0x493>
mov    0x50(%rsp),%rsi
test   $0x18,%sil
je     15aa <main+0x40a>
mov    %rsi,%rax
and    $0xfffffffffffffff8,%rax
lea    0x1(%rax),%r12
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%r13,%r11,1),%rcx
mov    %rcx,(%r8,%r11,1)
add    $0x8,%r11
cmp    %r11,%rax
jne    1580 <main+0x3e0>
cmp    %rax,%rsi
jne    15c0 <main+0x420>
jmp    1633 <main+0x493>
xor    %eax,%eax
test   $0x1,%r12b
jne    151e <main+0x37e>
jmp    1557 <main+0x3b7>
or     $0x1,%r11
mov    %r11,%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebp,%edx
sub    %r12d,%edx
mov    %r12,%rax
not    %rax
add    %rbp,%rax
and    $0x3,%rdx
je     15f3 <main+0x453>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rbx,%r12,1),%ecx
mov    %cl,(%rdi,%r12,1)
add    $0x1,%r12
add    $0xffffffffffffffff,%rdx
jne    15e0 <main+0x440>
cmp    $0x3,%rax
jb     1633 <main+0x493>
nopl   0x0(%rax)
movzbl (%rbx,%r12,1),%eax
mov    %al,(%rdi,%r12,1)
movzbl 0x1(%rbx,%r12,1),%eax
mov    %al,0x1(%rdi,%r12,1)
movzbl 0x2(%rbx,%r12,1),%eax
mov    %al,0x2(%rdi,%r12,1)
movzbl 0x3(%rbx,%r12,1),%eax
mov    %al,0x3(%rdi,%r12,1)
add    $0x4,%r12
cmp    %r12,%rbp
jne    1600 <main+0x460>
mov    0x30(%rsp),%rdx
cmp    %r9d,%edx
mov    0x20(%rsp),%rsi
jl     13f0 <main+0x250>
mov    0x4c(%rsp),%ecx
sub    %ebp,%ecx
mov    %r9,%rax
test   $0x1,%cl
je     1692 <main+0x4f2>
lea    -0x1(%r10),%rcx
mov    (%rsp),%rdx
imul   %rdx,%rcx
mov    %r10,%rax
imul   %rdx,%rax
lea    (%rcx,%r9,1),%r12
mov    $0x1,%r11b
mov    0x18(%rsp),%rdx
cmpb   $0x0,(%rdx,%r12,1)
jne    1682 <main+0x4e2>
cmpb   $0x0,(%rdx,%rcx,1)
setne  %r11b
add    %r9,%rax
mov    %r11b,(%rdx,%rax,1)
lea    0x1(%r9),%rax
mov    0x30(%rsp),%rdx
cmp    %ebp,%edx
je     13f0 <main+0x250>
mov    %r13,%rbp
sub    %r9,%rbp
jmp    16c0 <main+0x520>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %cl,(%r8,%rax,1)
add    $0x2,%rax
cmp    %eax,%esi
je     13f0 <main+0x250>
mov    $0x1,%cl
cmpb   $0x0,-0x1(%r13,%rax,1)
mov    $0x1,%dl
jne    16d4 <main+0x534>
cmpb   $0x0,-0x1(%rbp,%rax,1)
setne  %dl
mov    %dl,-0x1(%r8,%rax,1)
cmpb   $0x0,0x0(%r13,%rax,1)
jne    16b0 <main+0x510>
cmpb   $0x0,0x0(%rbp,%rax,1)
setne  %cl
jmp    16b0 <main+0x510>
mov    0x28f6(%rip),%rax
mov    (%rax),%edi
lea    0x78(%rsp),%rsi
call   1040 <clock_gettime@plt>
cmpl   $0x2,0x38(%rsp)
mov    0x8(%rsp),%rbp
jge    187a <main+0x6da>
mov    0x28d3(%rip),%rax
mov    (%rax),%edi
lea    0x88(%rsp),%rsi
call   1040 <clock_gettime@plt>
movsd  0x88(%rsp),%xmm0
movsd  0x90(%rsp),%xmm1
subsd  0x78(%rsp),%xmm0
subsd  0x80(%rsp),%xmm1
mulsd  0x8b3(%rip),%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rsp)
mov    0x20(%rsp),%rbp
mov    %ebp,%eax
mov    0x38(%rsp),%rbx
imul   %ebx,%eax
add    0x30(%rsp),%eax
cltq
mov    0x10(%rsp),%r14
cmpb   $0x0,(%r14,%rax,1)
lea    0x8ca(%rip),%rax
lea    0x8be(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
movss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x8b0(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0x2,%ebx
jl     1856 <main+0x6b6>
movslq %ebp,%rcx
mov    %ebp,%r13d
lea    (%r14,%rcx,2),%rbx
add    $0x1,%rbx
mov    0x18(%rsp),%rax
mov    %rcx,0x20(%rsp)
lea    (%rax,%rcx,2),%r15
add    $0x1,%r15
mov    $0x1,%r14d
mov    $0x2,%r12d
jmp    1806 <main+0x666>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    0x20(%rsp),%rax
add    %rax,%rbx
add    %rax,%r15
cmp    0x8(%rsp),%r12
je     1851 <main+0x6b1>
cmpl   $0x4,0x70(%rsp)
jl     17f0 <main+0x650>
mov    $0x1,%ebp
jmp    1829 <main+0x689>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %rbp,%r13
je     17f0 <main+0x650>
movsbl -0x1(%rbx,%rbp,1),%ecx
movsbl -0x1(%r15,%rbp,1),%r8d
cmp    %r8b,%cl
je     1820 <main+0x680>
xor    %r14d,%r14d
lea    0x81f(%rip),%rdi
mov    %r12d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1050 <printf@plt>
jmp    1820 <main+0x680>
test   %r14d,%r14d
je     1862 <main+0x6c2>
lea    0x81e(%rip),%rdi
call   1030 <puts@plt>
xor    %r15d,%r15d
mov    %r15d,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x10(%rsp),%rax
mov    (%rsp),%rcx
lea    (%rax,%rcx,2),%r12
add    $0x31,%r12
lea    0x31(%rcx,%rax,1),%r15
lea    0x1(%rcx,%rax,1),%r11
lea    0x1(%rax,%rcx,2),%r14
lea    (%rax,%rcx,2),%rdi
lea    (%rax,%rcx,1),%rbx
mov    $0x2,%r10d
xor    %r8d,%r8d
jmp    18d7 <main+0x737>
nopl   (%rax)
add    $0x1,%r10
add    $0x1,%r8
mov    (%rsp),%rax
add    %rax,%r12
add    %rax,%r15
add    %rax,%r11
add    %rax,%r14
add    %rax,%rdi
add    %rax,%rbx
cmp    %rbp,%r10
je     170e <main+0x56e>
mov    0x40(%rsp),%rax
movslq (%rax,%r10,4),%r9
mov    %r9d,%r13d
cmp    $0x2,%r9
jl     1aeb <main+0x94b>
lea    -0x1(%r13),%rcx
mov    $0x1,%eax
cmp    $0x8,%rcx
jb     1a80 <main+0x8e0>
mov    %rcx,0x28(%rsp)
mov    %r8,%rcx
mov    (%rsp),%rbp
imul   %rbp,%rcx
mov    0x68(%rsp),%rdx
add    %rcx,%rdx
mov    0x10(%rsp),%rsi
add    %rsi,%rdx
add    %rcx,%rbp
add    %rsi,%rbp
add    %r13,%rbp
cmp    %rbp,%rdx
jae    1952 <main+0x7b2>
mov    0x60(%rsp),%rdx
add    %rcx,%rdx
mov    0x10(%rsp),%rsi
add    %rsi,%rdx
add    0x58(%rsp),%rcx
add    %rsi,%rcx
add    %r13,%rdx
cmp    %rdx,%rcx
jb     1a80 <main+0x8e0>
mov    0x28(%rsp),%rsi
cmp    $0x20,%rsi
jae    1964 <main+0x7c4>
xor    %ecx,%ecx
jmp    1a2f <main+0x88f>
mov    %rsi,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rax
mov    %rax,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     1a60 <main+0x8c0>
mov    %rdx,%rbp
movabs $0xffffffffffffffe,%rax
ff ff 0f
and    %rax,%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%r15,%rax,1),%xmm0
movups -0x20(%r15,%rax,1),%xmm1
movups %xmm0,-0x30(%r12,%rax,1)
movups %xmm1,-0x20(%r12,%rax,1)
movups -0x10(%r15,%rax,1),%xmm0
movups (%r15,%rax,1),%xmm1
movups %xmm0,-0x10(%r12,%rax,1)
movups %xmm1,(%r12,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rbp
jne    19a0 <main+0x800>
test   $0x1,%dl
je     1a16 <main+0x876>
lea    -0x1(%r10),%rdx
mov    (%rsp),%rsi
imul   %rsi,%rdx
mov    %r10,%rbp
imul   %rsi,%rbp
or     $0x1,%rax
add    %rax,%rdx
mov    0x10(%rsp),%rsi
movups (%rsi,%rdx,1),%xmm0
movups 0x10(%rsi,%rdx,1),%xmm1
add    %rbp,%rax
movups %xmm0,(%rsi,%rax,1)
movups %xmm1,0x10(%rsi,%rax,1)
mov    0x28(%rsp),%rsi
cmp    %rcx,%rsi
mov    0x8(%rsp),%rbp
je     1aeb <main+0x94b>
mov    0x28(%rsp),%rsi
test   $0x18,%sil
je     1a6d <main+0x8cd>
mov    %rsi,%rdx
and    $0xfffffffffffffff8,%rdx
lea    0x1(%rdx),%rax
nopw   0x0(%rax,%rax,1)
mov    (%r11,%rcx,1),%rbp
mov    %rbp,(%r14,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    1a40 <main+0x8a0>
cmp    %rdx,%rsi
mov    0x8(%rsp),%rbp
jne    1a80 <main+0x8e0>
jmp    1aeb <main+0x94b>
xor    %eax,%eax
test   $0x1,%dl
jne    19dd <main+0x83d>
jmp    1a16 <main+0x876>
or     $0x1,%rcx
mov    %rcx,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13d,%ebp
sub    %eax,%ebp
mov    %rax,%rcx
not    %rcx
add    %r13,%rcx
and    $0x3,%rbp
je     1ab1 <main+0x911>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rbx,%rax,1),%edx
mov    %dl,(%rdi,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbp
jne    1aa0 <main+0x900>
cmp    $0x3,%rcx
mov    0x8(%rsp),%rbp
jb     1aeb <main+0x94b>
nopl   0x0(%rax)
movzbl (%rbx,%rax,1),%ecx
mov    %cl,(%rdi,%rax,1)
movzbl 0x1(%rbx,%rax,1),%ecx
mov    %cl,0x1(%rdi,%rax,1)
movzbl 0x2(%rbx,%rax,1),%ecx
mov    %cl,0x2(%rdi,%rax,1)
movzbl 0x3(%rbx,%rax,1),%ecx
mov    %cl,0x3(%rdi,%rax,1)
add    $0x4,%rax
cmp    %rax,%r13
jne    1ac0 <main+0x920>
cmp    %r9d,0x30(%rsp)
jl     18b0 <main+0x710>
mov    0x4c(%rsp),%ecx
sub    %r13d,%ecx
mov    %r9,%rax
test   $0x1,%cl
je     1b42 <main+0x9a2>
lea    -0x1(%r10),%rcx
mov    (%rsp),%rdx
imul   %rdx,%rcx
mov    %r10,%rax
imul   %rdx,%rax
lea    (%rcx,%r9,1),%rsi
mov    $0x1,%dl
mov    0x10(%rsp),%rbp
cmpb   $0x0,0x0(%rbp,%rsi,1)
jne    1b32 <main+0x992>
cmpb   $0x0,0x0(%rbp,%rcx,1)
setne  %dl
add    %r9,%rax
mov    %dl,0x0(%rbp,%rax,1)
lea    0x1(%r9),%rax
mov    0x8(%rsp),%rbp
cmp    %r13d,0x30(%rsp)
je     18b0 <main+0x710>
mov    %r11,%rsi
sub    %r9,%rsi
jmp    1b72 <main+0x9d2>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %dl,(%r14,%rax,1)
add    $0x2,%rax
cmp    %eax,0x20(%rsp)
je     18b0 <main+0x710>
mov    $0x1,%dl
cmpb   $0x0,-0x1(%r11,%rax,1)
mov    $0x1,%cl
jne    1b86 <main+0x9e6>
cmpb   $0x0,-0x1(%rsi,%rax,1)
setne  %cl
mov    %cl,-0x1(%r14,%rax,1)
cmpb   $0x0,(%r11,%rax,1)
jne    1b60 <main+0x9c0>
cmpb   $0x0,(%rsi,%rax,1)
setne  %dl
jmp    1b60 <main+0x9c0>

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

LLVM IR (-O2):
%struct.timespec = type { double, double }
@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"
@CLOCK_MONOTONIC = global i32 0
@.str.5 = [5 x i8] c"true\00"
@.str.6 = [6 x i8] c"false\00"
@.str.7 = [15 x i8] c"time in s: %f\0A\00"
@.str.8 = [25 x i8] c"i=%d, j=%d, F=%d, Fs=%d\0A\00"
@str = [16 x i8] c"result verified\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca %struct.timespec
%4 = alloca %struct.timespec
%5 = bitcast %struct.timespec* %3 to i8*
%6 = bitcast %struct.timespec* %4 to i8*
%7 = icmp slt i32 %0, 3
br i1 %7, label %8, label %12
8: ; preds = %2
%9 = load i32, i32* @stderr
%10 = load i8*, i8** %1
%11 = tail call i32 (i32, i8*, ...) @fprintf(i32 %9, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0), i8* %10)
br label %609
12: ; preds = %2
%13 = getelementptr inbounds i8*, i8** %1, i64 1
%14 = load i8*, i8** %13
%15 = tail call i32 @strtol(i8* nocapture %14, i32* null, i32 10)
%16 = getelementptr inbounds i8*, i8** %1, i64 2
%17 = load i8*, i8** %16
%18 = tail call i32 @strtol(i8* nocapture %17, i32* null, i32 10)
%19 = mul nsw i32 %18, %15
%20 = sdiv i32 %19, 4
%21 = add nsw i32 %20, 1
%22 = add i32 %18, 1
%23 = shl i32 %22, 2
%24 = tail call i32* @malloc(i32 %23)
%25 = mul nsw i32 %21, %22
%26 = tail call i8* @calloc(i32 %25, i32 1)
%27 = tail call i8* @calloc(i32 %25, i32 1)
%28 = icmp ne i32* %24, null
%29 = icmp ne i8* %27, null
%30 = and i1 %28, %29
%31 = icmp ne i8* %26, null
%32 = and i1 %31, %30
br i1 %32, label %36, label %33
33: ; preds = %12
%34 = load i32, i32* @stderr
%35 = tail call i32 (i32, i8*, ...) @fprintf(i32 %34, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0))
br label %609
36: ; preds = %12
%37 = icmp eq i32 %0, 4
br i1 %37, label %38, label %42
38: ; preds = %36
%39 = getelementptr inbounds i8*, i8** %1, i64 3
%40 = load i8*, i8** %39
%41 = tail call i32 @strtol(i8* nocapture %40, i32* null, i32 10)
br label %44
42: ; preds = %36
%43 = tail call i32 @time(i32* null)
br label %44
44: ; preds = %42, %38
%45 = phi i32 [ %43, %42 ], [ %41, %38 ]
%46 = tail call i32 @srand(i32 %45)
%47 = icmp slt i32 %18, 1
br i1 %47, label %51, label %48
48: ; preds = %44
%49 = sext i32 %21 to i64
%50 = zext i32 %22 to i64
br label %70
51: ; preds = %70, %44
%52 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0), i32 %20)
%53 = getelementptr inbounds i32, i32* %24, i64 1
%54 = load i32, i32* %53
%55 = add nsw i32 %54, %21
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %27, i64 %56
store i8 1, i8* %57
%58 = getelementptr inbounds i8, i8* %26, i64 %56
store i8 1, i8* %58
%59 = icmp slt i32 %18, 2
br i1 %59, label %60, label %63
60: ; preds = %51
%61 = load i32, i32* @CLOCK_MONOTONIC
%62 = call i32 @clock_gettime(i32 %61, %struct.timespec* %3)
br label %454
63: ; preds = %51
%64 = sext i32 %21 to i64
%65 = zext i32 %22 to i64
%66 = shl nsw i64 %64, 1
%67 = or i64 %66, 1
%68 = add nsw i64 %64, 1
%69 = add nsw i32 %20, 1
br label %81
70: ; preds = %48, %70
%71 = phi i64 [ 1, %48 ], [ %79, %70 ]
%72 = tail call i32 (...) @rand()
%73 = srem i32 %72, %15
%74 = getelementptr inbounds i32, i32* %24, i64 %71
store i32 %73, i32* %74
%75 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %73)
%76 = mul nsw i64 %71, %49
%77 = getelementptr inbounds i8, i8* %27, i64 %76
store i8 1, i8* %77
%78 = getelementptr inbounds i8, i8* %26, i64 %76
store i8 1, i8* %78
%79 = add nuw nsw i64 %71, 1
%80 = icmp eq i64 %79, %50
br i1 %80, label %51, label %70
81: ; preds = %63, %281
%82 = phi i64 [ 0, %63 ], [ %284, %281 ]
%83 = phi i64 [ 2, %63 ], [ %282, %281 ]
%84 = mul i64 %82, %64
%85 = add i64 %67, %84
%86 = getelementptr i8, i8* %26, i64 %85
%87 = add i64 %66, %84
%88 = getelementptr i8, i8* %26, i64 %87
%89 = add i64 %68, %84
%90 = getelementptr i8, i8* %26, i64 %89
%91 = add i64 %84, %64
%92 = getelementptr i8, i8* %26, i64 %91
%93 = getelementptr inbounds i32, i32* %24, i64 %83
%94 = load i32, i32* %93
%95 = icmp sgt i32 %94, 1
br i1 %95, label %96, label %226
96: ; preds = %81
%97 = add nsw i64 %83, -1
%98 = mul nsw i64 %97, %64
%99 = mul nsw i64 %83, %64
%100 = zext i32 %94 to i64
%101 = add nsw i64 %100, -1
%102 = icmp ult i64 %101, 8
br i1 %102, label %195, label %103
103: ; preds = %96
%104 = getelementptr i8, i8* %88, i64 %100
%105 = getelementptr i8, i8* %92, i64 %100
%106 = icmp ult i8* %86, %105
%107 = icmp ult i8* %90, %104
%108 = and i1 %106, %107
br i1 %108, label %195, label %109
109: ; preds = %103
%110 = icmp ult i64 %101, 32
br i1 %110, label %175, label %111
111: ; preds = %109
%112 = and i64 %101, -32
%113 = add nsw i64 %112, -32
%114 = lshr exact i64 %113, 5
%115 = add nuw nsw i64 %114, 1
%116 = and i64 %115, 1
%117 = icmp eq i64 %113, 0
br i1 %117, label %152, label %118
118: ; preds = %111
%119 = and i64 %115, 1152921504606846974
br label %120
120: ; preds = %120, %118
%121 = phi i64 [ 0, %118 ], [ %149, %120 ]
%122 = phi i64 [ 0, %118 ], [ %150, %120 ]
%123 = or i64 %121, 1
%124 = add nsw i64 %123, %98
%125 = getelementptr inbounds i8, i8* %26, i64 %124
%126 = bitcast i8* %125 to <16 x i8>*
%127 = load <16 x i8>, <16 x i8>* %126
%128 = getelementptr inbounds i8, i8* %125, i64 16
%129 = bitcast i8* %128 to <16 x i8>*
%130 = load <16 x i8>, <16 x i8>* %129
%131 = add nsw i64 %123, %99
%132 = getelementptr inbounds i8, i8* %26, i64 %131
%133 = bitcast i8* %132 to <16 x i8>*
store <16 x i8> %127, <16 x i8>* %133
%134 = getelementptr inbounds i8, i8* %132, i64 16
%135 = bitcast i8* %134 to <16 x i8>*
store <16 x i8> %130, <16 x i8>* %135
%136 = or i64 %121, 33
%137 = add nsw i64 %136, %98
%138 = getelementptr inbounds i8, i8* %26, i64 %137
%139 = bitcast i8* %138 to <16 x i8>*
%140 = load <16 x i8>, <16 x i8>* %139
%141 = getelementptr inbounds i8, i8* %138, i64 16
%142 = bitcast i8* %141 to <16 x i8>*
%143 = load <16 x i8>, <16 x i8>* %142
%144 = add nsw i64 %136, %99
%145 = getelementptr inbounds i8, i8* %26, i64 %144
%146 = bitcast i8* %145 to <16 x i8>*
store <16 x i8> %140, <16 x i8>* %146
%147 = getelementptr inbounds i8, i8* %145, i64 16
%148 = bitcast i8* %147 to <16 x i8>*
store <16 x i8> %143, <16 x i8>* %148
%149 = add nuw i64 %121, 64
%150 = add i64 %122, 2
%151 = icmp eq i64 %150, %119
br i1 %151, label %152, label %120
152: ; preds = %120, %111
%153 = phi i64 [ 0, %111 ], [ %149, %120 ]
%154 = icmp eq i64 %116, 0
br i1 %154, label %169, label %155
155: ; preds = %152
%156 = or i64 %153, 1
%157 = add nsw i64 %156, %98
%158 = getelementptr inbounds i8, i8* %26, i64 %157
%159 = bitcast i8* %158 to <16 x i8>*
%160 = load <16 x i8>, <16 x i8>* %159
%161 = getelementptr inbounds i8, i8* %158, i64 16
%162 = bitcast i8* %161 to <16 x i8>*
%163 = load <16 x i8>, <16 x i8>* %162
%164 = add nsw i64 %156, %99
%165 = getelementptr inbounds i8, i8* %26, i64 %164
%166 = bitcast i8* %165 to <16 x i8>*
store <16 x i8> %160, <16 x i8>* %166
%167 = getelementptr inbounds i8, i8* %165, i64 16
%168 = bitcast i8* %167 to <16 x i8>*
store <16 x i8> %163, <16 x i8>* %168
br label %169
169: ; preds = %152, %155
%170 = icmp eq i64 %101, %112
br i1 %170, label %226, label %171
171: ; preds = %169
%172 = or i64 %112, 1
%173 = and i64 %101, 24
%174 = icmp eq i64 %173, 0
br i1 %174, label %195, label %175
175: ; preds = %109, %171
%176 = phi i64 [ %112, %171 ], [ 0, %109 ]
%177 = zext i32 %94 to i64
%178 = add nsw i64 %177, -1
%179 = and i64 %178, -8
%180 = or i64 %179, 1
br label %181
181: ; preds = %181, %175
%182 = phi i64 [ %176, %175 ], [ %191, %181 ]
%183 = or i64 %182, 1
%184 = add nsw i64 %183, %98
%185 = getelementptr inbounds i8, i8* %26, i64 %184
%186 = bitcast i8* %185 to <8 x i8>*
%187 = load <8 x i8>, <8 x i8>* %186
%188 = add nsw i64 %183, %99
%189 = getelementptr inbounds i8, i8* %26, i64 %188
%190 = bitcast i8* %189 to <8 x i8>*
store <8 x i8> %187, <8 x i8>* %190
%191 = add nuw i64 %182, 8
%192 = icmp eq i64 %191, %179
br i1 %192, label %193, label %181
193: ; preds = %181
%194 = icmp eq i64 %178, %179
br i1 %194, label %226, label %195
195: ; preds = %103, %96, %171, %193
%196 = phi i64 [ 1, %96 ], [ 1, %103 ], [ %172, %171 ], [ %180, %193 ]
%197 = sub nsw i64 %100, %196
%198 = xor i64 %196, -1
%199 = add nsw i64 %198, %100
%200 = and i64 %197, 3
%201 = icmp eq i64 %200, 0
br i1 %201, label %213, label %202
202: ; preds = %195, %202
%203 = phi i64 [ %210, %202 ], [ %196, %195 ]
%204 = phi i64 [ %211, %202 ], [ 0, %195 ]
%205 = add nsw i64 %203, %98
%206 = getelementptr inbounds i8, i8* %26, i64 %205
%207 = load i8, i8* %206
%208 = add nsw i64 %203, %99
%209 = getelementptr inbounds i8, i8* %26, i64 %208
store i8 %207, i8* %209
%210 = add nuw nsw i64 %203, 1
%211 = add i64 %204, 1
%212 = icmp eq i64 %211, %200
br i1 %212, label %213, label %202
213: ; preds = %202, %195
%214 = phi i64 [ %196, %195 ], [ %210, %202 ]
%215 = icmp ult i64 %199, 3
br i1 %215, label %226, label %254
216: ; preds = %281
%217 = load i32, i32* @CLOCK_MONOTONIC
%218 = call i32 @clock_gettime(i32 %217, %struct.timespec* %3)
br i1 %59, label %454, label %219
219: ; preds = %216
%220 = sext i32 %21 to i64
%221 = zext i32 %22 to i64
%222 = shl nsw i64 %64, 1
%223 = or i64 %222, 1
%224 = add nsw i64 %64, 1
%225 = add nsw i32 %20, 1
br label %319
226: ; preds = %213, %254, %169, %193, %81
%227 = icmp slt i32 %20, %94
br i1 %227, label %281, label %228
228: ; preds = %226
%229 = add nsw i64 %83, -1
%230 = mul nsw i64 %229, %64
%231 = mul nsw i64 %83, %64
%232 = sext i32 %94 to i64
%233 = sub i32 %69, %94
%234 = and i32 %233, 1
%235 = icmp eq i32 %234, 0
br i1 %235, label %251, label %236
236: ; preds = %228
%237 = add nsw i64 %230, %232
%238 = getelementptr inbounds i8, i8* %26, i64 %237
%239 = load i8, i8* %238
%240 = icmp eq i8 %239, 0
br i1 %240, label %241, label %245
241: ; preds = %236
%242 = getelementptr inbounds i8, i8* %26, i64 %230
%243 = load i8, i8* %242
%244 = icmp ne i8 %243, 0
br label %245
245: ; preds = %241, %236
%246 = phi i1 [ true, %236 ], [ %244, %241 ]
%247 = zext i1 %246 to i8
%248 = add nsw i64 %231, %232
%249 = getelementptr inbounds i8, i8* %26, i64 %248
store i8 %247, i8* %249
%250 = add nsw i64 %232, 1
br label %251
251: ; preds = %245, %228
%252 = phi i64 [ %232, %228 ], [ %250, %245 ]
%253 = icmp eq i32 %20, %94
br i1 %253, label %281, label %285
254: ; preds = %213, %254
%255 = phi i64 [ %279, %254 ], [ %214, %213 ]
%256 = add nsw i64 %255, %98
%257 = getelementptr inbounds i8, i8* %26, i64 %256
%258 = load i8, i8* %257
%259 = add nsw i64 %255, %99
%260 = getelementptr inbounds i8, i8* %26, i64 %259
store i8 %258, i8* %260
%261 = add nuw nsw i64 %255, 1
%262 = add nsw i64 %261, %98
%263 = getelementptr inbounds i8, i8* %26, i64 %262
%264 = load i8, i8* %263
%265 = add nsw i64 %261, %99
%266 = getelementptr inbounds i8, i8* %26, i64 %265
store i8 %264, i8* %266
%267 = add nuw nsw i64 %255, 2
%268 = add nsw i64 %267, %98
%269 = getelementptr inbounds i8, i8* %26, i64 %268
%270 = load i8, i8* %269
%271 = add nsw i64 %267, %99
%272 = getelementptr inbounds i8, i8* %26, i64 %271
store i8 %270, i8* %272
%273 = add nuw nsw i64 %255, 3
%274 = add nsw i64 %273, %98
%275 = getelementptr inbounds i8, i8* %26, i64 %274
%276 = load i8, i8* %275
%277 = add nsw i64 %273, %99
%278 = getelementptr inbounds i8, i8* %26, i64 %277
store i8 %276, i8* %278
%279 = add nuw nsw i64 %255, 4
%280 = icmp eq i64 %279, %100
br i1 %280, label %226, label %254
281: ; preds = %251, %311, %226
%282 = add nuw nsw i64 %83, 1
%283 = icmp eq i64 %282, %65
%284 = add i64 %82, 1
br i1 %283, label %216, label %81
285: ; preds = %251, %311
%286 = phi i64 [ %316, %311 ], [ %252, %251 ]
%287 = add nsw i64 %286, %230
%288 = getelementptr inbounds i8, i8* %26, i64 %287
%289 = load i8, i8* %288
%290 = icmp eq i8 %289, 0
br i1 %290, label %291, label %296
291: ; preds = %285
%292 = sub nsw i64 %287, %232
%293 = getelementptr inbounds i8, i8* %26, i64 %292
%294 = load i8, i8* %293
%295 = icmp ne i8 %294, 0
br label %296
296: ; preds = %291, %285
%297 = phi i1 [ true, %285 ], [ %295, %291 ]
%298 = zext i1 %297 to i8
%299 = add nsw i64 %286, %231
%300 = getelementptr inbounds i8, i8* %26, i64 %299
store i8 %298, i8* %300
%301 = add nsw i64 %286, 1
%302 = add nsw i64 %301, %230
%303 = getelementptr inbounds i8, i8* %26, i64 %302
%304 = load i8, i8* %303
%305 = icmp eq i8 %304, 0
br i1 %305, label %306, label %311
306: ; preds = %296
%307 = sub nsw i64 %302, %232
%308 = getelementptr inbounds i8, i8* %26, i64 %307
%309 = load i8, i8* %308
%310 = icmp ne i8 %309, 0
br label %311
311: ; preds = %306, %296
%312 = phi i1 [ true, %296 ], [ %310, %306 ]
%313 = zext i1 %312 to i8
%314 = add nsw i64 %301, %231
%315 = getelementptr inbounds i8, i8* %26, i64 %314
store i8 %313, i8* %315
%316 = add nsw i64 %286, 2
%317 = trunc i64 %316 to i32
%318 = icmp eq i32 %21, %317
br i1 %318, label %281, label %285
319: ; preds = %219, %539
%320 = phi i64 [ 0, %219 ], [ %542, %539 ]
%321 = phi i64 [ 2, %219 ], [ %540, %539 ]
%322 = mul i64 %320, %64
%323 = add i64 %223, %322
%324 = getelementptr i8, i8* %27, i64 %323
%325 = add i64 %222, %322
%326 = getelementptr i8, i8* %27, i64 %325
%327 = add i64 %224, %322
%328 = getelementptr i8, i8* %27, i64 %327
%329 = add i64 %322, %64
%330 = getelementptr i8, i8* %27, i64 %329
%331 = getelementptr inbounds i32, i32* %24, i64 %321
%332 = load i32, i32* %331
%333 = icmp sgt i32 %332, 1
br i1 %333, label %334, label %484
334: ; preds = %319
%335 = add nsw i64 %321, -1
%336 = mul nsw i64 %335, %220
%337 = mul nsw i64 %321, %220
%338 = zext i32 %332 to i64
%339 = add nsw i64 %338, -1
%340 = icmp ult i64 %339, 8
br i1 %340, label %433, label %341
341: ; preds = %334
%342 = getelementptr i8, i8* %326, i64 %338
%343 = getelementptr i8, i8* %330, i64 %338
%344 = icmp ult i8* %324, %343
%345 = icmp ult i8* %328, %342
%346 = and i1 %344, %345
br i1 %346, label %433, label %347
347: ; preds = %341
%348 = icmp ult i64 %339, 32
br i1 %348, label %413, label %349
349: ; preds = %347
%350 = and i64 %339, -32
%351 = add nsw i64 %350, -32
%352 = lshr exact i64 %351, 5
%353 = add nuw nsw i64 %352, 1
%354 = and i64 %353, 1
%355 = icmp eq i64 %351, 0
br i1 %355, label %390, label %356
356: ; preds = %349
%357 = and i64 %353, 1152921504606846974
br label %358
358: ; preds = %358, %356
%359 = phi i64 [ 0, %356 ], [ %387, %358 ]
%360 = phi i64 [ 0, %356 ], [ %388, %358 ]
%361 = or i64 %359, 1
%362 = add nsw i64 %361, %336
%363 = getelementptr inbounds i8, i8* %27, i64 %362
%364 = bitcast i8* %363 to <16 x i8>*
%365 = load <16 x i8>, <16 x i8>* %364
%366 = getelementptr inbounds i8, i8* %363, i64 16
%367 = bitcast i8* %366 to <16 x i8>*
%368 = load <16 x i8>, <16 x i8>* %367
%369 = add nsw i64 %361, %337
%370 = getelementptr inbounds i8, i8* %27, i64 %369
%371 = bitcast i8* %370 to <16 x i8>*
store <16 x i8> %365, <16 x i8>* %371
%372 = getelementptr inbounds i8, i8* %370, i64 16
%373 = bitcast i8* %372 to <16 x i8>*
store <16 x i8> %368, <16 x i8>* %373
%374 = or i64 %359, 33
%375 = add nsw i64 %374, %336
%376 = getelementptr inbounds i8, i8* %27, i64 %375
%377 = bitcast i8* %376 to <16 x i8>*
%378 = load <16 x i8>, <16 x i8>* %377
%379 = getelementptr inbounds i8, i8* %376, i64 16
%380 = bitcast i8* %379 to <16 x i8>*
%381 = load <16 x i8>, <16 x i8>* %380
%382 = add nsw i64 %374, %337
%383 = getelementptr inbounds i8, i8* %27, i64 %382
%384 = bitcast i8* %383 to <16 x i8>*
store <16 x i8> %378, <16 x i8>* %384
%385 = getelementptr inbounds i8, i8* %383, i64 16
%386 = bitcast i8* %385 to <16 x i8>*
store <16 x i8> %381, <16 x i8>* %386
%387 = add nuw i64 %359, 64
%388 = add i64 %360, 2
%389 = icmp eq i64 %388, %357
br i1 %389, label %390, label %358
390: ; preds = %358, %349
%391 = phi i64 [ 0, %349 ], [ %387, %358 ]
%392 = icmp eq i64 %354, 0
br i1 %392, label %407, label %393
393: ; preds = %390
%394 = or i64 %391, 1
%395 = add nsw i64 %394, %336
%396 = getelementptr inbounds i8, i8* %27, i64 %395
%397 = bitcast i8* %396 to <16 x i8>*
%398 = load <16 x i8>, <16 x i8>* %397
%399 = getelementptr inbounds i8, i8* %396, i64 16
%400 = bitcast i8* %399 to <16 x i8>*
%401 = load <16 x i8>, <16 x i8>* %400
%402 = add nsw i64 %394, %337
%403 = getelementptr inbounds i8, i8* %27, i64 %402
%404 = bitcast i8* %403 to <16 x i8>*
store <16 x i8> %398, <16 x i8>* %404
%405 = getelementptr inbounds i8, i8* %403, i64 16
%406 = bitcast i8* %405 to <16 x i8>*
store <16 x i8> %401, <16 x i8>* %406
br label %407
407: ; preds = %390, %393
%408 = icmp eq i64 %339, %350
br i1 %408, label %484, label %409
409: ; preds = %407
%410 = or i64 %350, 1
%411 = and i64 %339, 24
%412 = icmp eq i64 %411, 0
br i1 %412, label %433, label %413
413: ; preds = %347, %409
%414 = phi i64 [ %350, %409 ], [ 0, %347 ]
%415 = zext i32 %332 to i64
%416 = add nsw i64 %415, -1
%417 = and i64 %416, -8
%418 = or i64 %417, 1
br label %419
419: ; preds = %419, %413
%420 = phi i64 [ %414, %413 ], [ %429, %419 ]
%421 = or i64 %420, 1
%422 = add nsw i64 %421, %336
%423 = getelementptr inbounds i8, i8* %27, i64 %422
%424 = bitcast i8* %423 to <8 x i8>*
%425 = load <8 x i8>, <8 x i8>* %424
%426 = add nsw i64 %421, %337
%427 = getelementptr inbounds i8, i8* %27, i64 %426
%428 = bitcast i8* %427 to <8 x i8>*
store <8 x i8> %425, <8 x i8>* %428
%429 = add nuw i64 %420, 8
%430 = icmp eq i64 %429, %417
br i1 %430, label %431, label %419
431: ; preds = %419
%432 = icmp eq i64 %416, %417
br i1 %432, label %484, label %433
433: ; preds = %341, %334, %409, %431
%434 = phi i64 [ 1, %334 ], [ 1, %341 ], [ %410, %409 ], [ %418, %431 ]
%435 = sub nsw i64 %338, %434
%436 = xor i64 %434, -1
%437 = add nsw i64 %436, %338
%438 = and i64 %435, 3
%439 = icmp eq i64 %438, 0
br i1 %439, label %451, label %440
440: ; preds = %433, %440
%441 = phi i64 [ %448, %440 ], [ %434, %433 ]
%442 = phi i64 [ %449, %440 ], [ 0, %433 ]
%443 = add nsw i64 %441, %336
%444 = getelementptr inbounds i8, i8* %27, i64 %443
%445 = load i8, i8* %444
%446 = add nsw i64 %441, %337
%447 = getelementptr inbounds i8, i8* %27, i64 %446
store i8 %445, i8* %447
%448 = add nuw nsw i64 %441, 1
%449 = add i64 %442, 1
%450 = icmp eq i64 %449, %438
br i1 %450, label %451, label %440
451: ; preds = %440, %433
%452 = phi i64 [ %434, %433 ], [ %448, %440 ]
%453 = icmp ult i64 %437, 3
br i1 %453, label %484, label %512
454: ; preds = %539, %60, %216
%455 = load i32, i32* @CLOCK_MONOTONIC
%456 = call i32 @clock_gettime(i32 %455, %struct.timespec* %4)
%457 = getelementptr inbounds %struct.timespec, %struct.timespec* %4, i64 0, i32 0
%458 = load double, double* %457
%459 = getelementptr inbounds %struct.timespec, %struct.timespec* %3, i64 0, i32 0
%460 = load double, double* %459
%461 = fsub double %458, %460
%462 = getelementptr inbounds %struct.timespec, %struct.timespec* %4, i64 0, i32 1
%463 = load double, double* %462
%464 = getelementptr inbounds %struct.timespec, %struct.timespec* %3, i64 0, i32 1
%465 = load double, double* %464
%466 = fsub double %463, %465
%467 = call double @llvm.fmuladd.f64(double %466, double 1.000000e-09, double %461)
%468 = fptrunc double %467 to float
%469 = mul nsw i32 %21, %18
%470 = add nsw i32 %469, %20
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds i8, i8* %27, i64 %471
%473 = load i8, i8* %472
%474 = icmp eq i8 %473, 0
%475 = select i1 %474, 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)
%476 = call i32 @puts(i8* dereferenceable(1) %475)
%477 = fpext float %468 to double
%478 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0), double %477)
br i1 %59, label %607, label %479
479: ; preds = %454
%480 = icmp slt i32 %19, 4
%481 = sext i32 %21 to i64
%482 = zext i32 %22 to i64
%483 = zext i32 %21 to i64
br label %577
484: ; preds = %451, %512, %407, %431, %319
%485 = icmp slt i32 %20, %332
br i1 %485, label %539, label %486
486: ; preds = %484
%487 = add nsw i64 %321, -1
%488 = mul nsw i64 %487, %220
%489 = mul nsw i64 %321, %220
%490 = sext i32 %332 to i64
%491 = sub i32 %225, %332
%492 = and i32 %491, 1
%493 = icmp eq i32 %492, 0
br i1 %493, label %509, label %494
494: ; preds = %486
%495 = add nsw i64 %488, %490
%496 = getelementptr inbounds i8, i8* %27, i64 %495
%497 = load i8, i8* %496
%498 = icmp eq i8 %497, 0
br i1 %498, label %499, label %503
499: ; preds = %494
%500 = getelementptr inbounds i8, i8* %27, i64 %488
%501 = load i8, i8* %500
%502 = icmp ne i8 %501, 0
br label %503
503: ; preds = %499, %494
%504 = phi i1 [ true, %494 ], [ %502, %499 ]
%505 = zext i1 %504 to i8
%506 = add nsw i64 %489, %490
%507 = getelementptr inbounds i8, i8* %27, i64 %506
store i8 %505, i8* %507
%508 = add nsw i64 %490, 1
br label %509
509: ; preds = %503, %486
%510 = phi i64 [ %490, %486 ], [ %508, %503 ]
%511 = icmp eq i32 %20, %332
br i1 %511, label %539, label %543
512: ; preds = %451, %512
%513 = phi i64 [ %537, %512 ], [ %452, %451 ]
%514 = add nsw i64 %513, %336
%515 = getelementptr inbounds i8, i8* %27, i64 %514
%516 = load i8, i8* %515
%517 = add nsw i64 %513, %337
%518 = getelementptr inbounds i8, i8* %27, i64 %517
store i8 %516, i8* %518
%519 = add nuw nsw i64 %513, 1
%520 = add nsw i64 %519, %336
%521 = getelementptr inbounds i8, i8* %27, i64 %520
%522 = load i8, i8* %521
%523 = add nsw i64 %519, %337
%524 = getelementptr inbounds i8, i8* %27, i64 %523
store i8 %522, i8* %524
%525 = add nuw nsw i64 %513, 2
%526 = add nsw i64 %525, %336
%527 = getelementptr inbounds i8, i8* %27, i64 %526
%528 = load i8, i8* %527
%529 = add nsw i64 %525, %337
%530 = getelementptr inbounds i8, i8* %27, i64 %529
store i8 %528, i8* %530
%531 = add nuw nsw i64 %513, 3
%532 = add nsw i64 %531, %336
%533 = getelementptr inbounds i8, i8* %27, i64 %532
%534 = load i8, i8* %533
%535 = add nsw i64 %531, %337
%536 = getelementptr inbounds i8, i8* %27, i64 %535
store i8 %534, i8* %536
%537 = add nuw nsw i64 %513, 4
%538 = icmp eq i64 %537, %338
br i1 %538, label %484, label %512
539: ; preds = %509, %569, %484
%540 = add nuw nsw i64 %321, 1
%541 = icmp eq i64 %540, %221
%542 = add i64 %320, 1
br i1 %541, label %454, label %319
543: ; preds = %509, %569
%544 = phi i64 [ %574, %569 ], [ %510, %509 ]
%545 = add nsw i64 %544, %488
%546 = getelementptr inbounds i8, i8* %27, i64 %545
%547 = load i8, i8* %546
%548 = icmp eq i8 %547, 0
br i1 %548, label %549, label %554
549: ; preds = %543
%550 = sub nsw i64 %545, %490
%551 = getelementptr inbounds i8, i8* %27, i64 %550
%552 = load i8, i8* %551
%553 = icmp ne i8 %552, 0
br label %554
554: ; preds = %549, %543
%555 = phi i1 [ true, %543 ], [ %553, %549 ]
%556 = zext i1 %555 to i8
%557 = add nsw i64 %544, %489
%558 = getelementptr inbounds i8, i8* %27, i64 %557
store i8 %556, i8* %558
%559 = add nsw i64 %544, 1
%560 = add nsw i64 %559, %488
%561 = getelementptr inbounds i8, i8* %27, i64 %560
%562 = load i8, i8* %561
%563 = icmp eq i8 %562, 0
br i1 %563, label %564, label %569
564: ; preds = %554
%565 = sub nsw i64 %560, %490
%566 = getelementptr inbounds i8, i8* %27, i64 %565
%567 = load i8, i8* %566
%568 = icmp ne i8 %567, 0
br label %569
569: ; preds = %564, %554
%570 = phi i1 [ true, %554 ], [ %568, %564 ]
%571 = zext i1 %570 to i8
%572 = add nsw i64 %559, %489
%573 = getelementptr inbounds i8, i8* %27, i64 %572
store i8 %571, i8* %573
%574 = add nsw i64 %544, 2
%575 = trunc i64 %574 to i32
%576 = icmp eq i32 %21, %575
br i1 %576, label %539, label %543
577: ; preds = %479, %585
%578 = phi i64 [ 2, %479 ], [ %587, %585 ]
%579 = phi i32 [ 1, %479 ], [ %586, %585 ]
br i1 %480, label %585, label %580
580: ; preds = %577
%581 = mul nsw i64 %578, %481
%582 = trunc i64 %578 to i32
br label %589
583: ; preds = %585
%584 = icmp eq i32 %586, 0
br i1 %584, label %609, label %607
585: ; preds = %603, %577
%586 = phi i32 [ %579, %577 ], [ %604, %603 ]
%587 = add nuw nsw i64 %578, 1
%588 = icmp eq i64 %587, %482
br i1 %588, label %583, label %577
589: ; preds = %580, %603
%590 = phi i64 [ 1, %580 ], [ %605, %603 ]
%591 = phi i32 [ %579, %580 ], [ %604, %603 ]
%592 = add nsw i64 %590, %581
%593 = getelementptr inbounds i8, i8* %27, i64 %592
%594 = load i8, i8* %593
%595 = getelementptr inbounds i8, i8* %26, i64 %592
%596 = load i8, i8* %595
%597 = icmp eq i8 %594, %596
br i1 %597, label %603, label %598
598: ; preds = %589
%599 = sext i8 %596 to i32
%600 = sext i8 %594 to i32
%601 = trunc i64 %590 to i32
%602 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.8, i64 0, i64 0), i32 %582, i32 %601, i32 %600, i32 %599)
br label %603
603: ; preds = %589, %598
%604 = phi i32 [ 0, %598 ], [ %591, %589 ]
%605 = add nuw nsw i64 %590, 1
%606 = icmp eq i64 %605, %483
br i1 %606, label %585, label %589
607: ; preds = %454, %583
%608 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @str, i64 0, i64 0))
br label %609
609: ; preds = %33, %607, %583, %8
%610 = phi i32 [ 1, %8 ], [ 1, %33 ], [ 0, %607 ], [ 0, %583 ]
ret i32 %610
}