#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 */
typedef int time_t;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ free(int *);
int *malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int rand();
int /*<<< orphan*/ srand(int);
int time(int /*<<< orphan*/ *);
int main() {
  int *arr;
  int N = 30;
  int mx = 100;
  int i;
  int L = 0;
  int R = N - 1;
  time_t t;
  t = time(NULL);
  t = t % 1000;
  printf("t=%i\n", (int)t);
  srand(t);
  arr = malloc(N * sizeof(int));
  for (i = 0; i < N; i++)
    arr[i] = rand() % mx;
  {
    int low, high, median, middle, ll, hh;
    int nless, nequal;
    int equal, greater;
    int midval;
    int midpos;
    low = L;
    high = R;
    median = (low + high) / 2;
    while (1) {
      if (high <= (low + 1))
        break;
      middle = (low + high) / 2;
      printf("low=%i, middle=%i, high=%i.\n", low, middle, high);
      printf("median=%i\n", median);
      if ((arr[(middle)]) > (arr[(high)])) {
        if ((middle) != (high)) {
          int tmp = arr[(middle)];
          arr[(middle)] = arr[(high)];
          arr[(high)] = tmp;
        }
      };
      if ((arr[(low)]) > (arr[(high)])) {
        if ((low) != (high)) {
          int tmp = arr[(low)];
          arr[(low)] = arr[(high)];
          arr[(high)] = tmp;
        }
      };
      if ((arr[(middle)]) > (arr[(low)])) {
        if ((middle) != (low)) {
          int tmp = arr[(middle)];
          arr[(middle)] = arr[(low)];
          arr[(low)] = tmp;
        }
      };
      {
        if ((middle) != (low + 1)) {
          int tmp = arr[(middle)];
          arr[(middle)] = arr[(low + 1)];
          arr[(low + 1)] = tmp;
        }
      };
      midval = (arr[(low)]);
      printf("middle value: %i\n", midval);
      printf("beginning:\n");
      for (i = L; i <= R; i++) {
        if (i == low)
          printf("( ");
        printf("%i ", (arr[(i)]));
        if (i == high)
          printf(") ");
      }
      printf("\n");
      nless = nequal = 0;
      for (i = low; i <= high; i++) {
        if ((arr[(i)]) < midval)
          nless++;
        else if ((arr[(i)]) == midval)
          nequal++;
      }
      equal = low + nless;
      greater = equal + nequal;
      ll = low + 1;
      hh = high;
      for (;;) {
        while (((arr[(ll)]) < midval) && (ll <= hh))
          ll++;
        while (((arr[(hh)]) >= midval) && (ll <= hh))
          hh--;
        if (hh < ll)
          break;
        {
          if ((ll) != (hh)) {
            int tmp = arr[(ll)];
            arr[(ll)] = arr[(hh)];
            arr[(hh)] = tmp;
          }
        };
      }
      {
        if ((low) != (hh)) {
          int tmp = arr[(low)];
          arr[(low)] = arr[(hh)];
          arr[(hh)] = tmp;
        }
      };
      midpos = hh;
      printf("after swapping middle value back into place:\n");
      for (i = L; i <= R; i++) {
        if (i == low)
          printf("( ");
        if (i == midpos)
          printf("*");
        printf("%i ", (arr[(i)]));
        if (i == high)
          printf(") ");
      }
      printf("\n");
      for (i = low; i < equal; i++)
        assert((arr[(i)]) < midval);
      for (i = equal; i <= high; i++)
        assert((arr[(i)]) >= midval);
      ll = equal;
      hh = high;
      for (;;) {
        while (((arr[(ll)]) == midval) && (ll < greater))
          ll++;
        while (((arr[(hh)]) > midval) && (hh >= ll))
          hh--;
        if (hh < ll)
          break;
        {
          if ((ll) != (hh)) {
            int tmp = arr[(ll)];
            arr[(ll)] = arr[(hh)];
            arr[(hh)] = tmp;
          }
        };
      }
      printf("after collecting equal items:\n");
      for (i = L; i <= R; i++) {
        if (i == low)
          printf("( ");
        if (i == midpos)
          printf("*");
        printf("%i ", (arr[(i)]));
        if (i == high)
          printf(") ");
      }
      printf("\n");
      for (i = low; i < equal; i++)
        assert((arr[(i)]) < midval);
      for (i = equal; i < greater; i++)
        assert((arr[(i)]) == midval);
      for (i = greater; i <= high; i++)
        assert((arr[(i)]) > midval);
      {
        int nl = equal - L;
        int nh = R + 1 - greater;
        printf("nl=%i, ne=%i, nh=%i.\n", nl, nequal, nh);
        printf("greater=%i, high=%i.\n", greater, high);
        if ((greater <= high) && (nh > nl) && (nl + nequal >= nh)) {
          median = greater;
          printf("Changed \"median\" to %i.\n", median);
          low = greater;
          continue;
        }
      }
      if (median < equal) {
        high = equal - 1;
        printf("median is in low partition.\n");
      } else if (median < greater) {
        low = high = equal;
        printf("median is in middle partition.\n");
        break;
      } else {
        low = greater;
        printf("median is in high partition.\n");
      }
    }
    if (high == low + 1) {
      if ((arr[(low)]) > (arr[(high)])) {
        if ((low) != (high)) {
          int tmp = arr[(low)];
          arr[(low)] = arr[(high)];
          arr[(high)] = tmp;
        }
      };
    }
    median = low;
    midval = (arr[(median)]);
    printf("end:\n");
    for (i = L; i <= R; i++) {
      if (i == median)
        printf("*");
      printf("%i ", (arr[(i)]));
    }
    printf("\n");
    for (i = L; i < median; i++) {
      assert((arr[(i)]) < midval);
    }
    for (i = median; i <= R; i++) {
      assert((arr[(i)]) >= midval);
    }
  }
  free(arr);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x1e,-0x14(%rbp)
movl   $0x64,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1070 <time@plt>
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    $0x3e8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x28(%rbp)
mov    -0x28(%rbp),%esi
lea    0xe3c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x28(%rbp),%edi
call   1050 <srand@plt>
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    121d <main+0xad>
mov    $0x0,%al
call   1090 <rand@plt>
cltd
idivl  -0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11ed <main+0x7d>
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1250 <main+0xe0>
jmp    1ae2 <main+0x972>
mov    -0x2c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x30(%rbp),%ecx
lea    0xd95(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x34(%rbp),%esi
lea    0xda1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    12e8 <main+0x178>
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     12e3 <main+0x173>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x5c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12e8 <main+0x178>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1347 <main+0x1d7>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1342 <main+0x1d2>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x60(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1347 <main+0x1d7>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    13a6 <main+0x236>
mov    -0x38(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     13a1 <main+0x231>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    13a6 <main+0x236>
mov    -0x38(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
je     13f3 <main+0x283>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%esi
lea    0xc23(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xc27(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1492 <main+0x322>
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    144c <main+0x2dc>
lea    0xc07(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xbf1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    147f <main+0x30f>
lea    0xbdb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1484 <main+0x314>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1426 <main+0x2b6>
lea    0xc4f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1517 <main+0x3a7>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
jge    14e2 <main+0x372>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1504 <main+0x394>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
jne    14ff <main+0x38f>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1504 <main+0x394>
jmp    1509 <main+0x399>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14b4 <main+0x344>
mov    -0x2c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    153d <main+0x3cd>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
xor    %eax,%eax
cmp    -0x54(%rbp),%ecx
mov    %al,-0x81(%rbp)
jge    1568 <main+0x3f8>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
setle  %al
mov    %al,-0x81(%rbp)
mov    -0x81(%rbp),%al
test   $0x1,%al
jne    157b <main+0x40b>
jmp    1589 <main+0x419>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    153d <main+0x3cd>
jmp    158e <main+0x41e>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
xor    %eax,%eax
cmp    -0x54(%rbp),%ecx
mov    %al,-0x82(%rbp)
jl     15b9 <main+0x449>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
setle  %al
mov    %al,-0x82(%rbp)
mov    -0x82(%rbp),%al
test   $0x1,%al
jne    15cc <main+0x45c>
jmp    15da <main+0x46a>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    158e <main+0x41e>
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    15eb <main+0x47b>
jmp    162e <main+0x4be>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
je     1629 <main+0x4b9>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1538 <main+0x3c8>
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
je     166c <main+0x4fc>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x70(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
mov    %eax,-0x58(%rbp)
lea    0x9dd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     170c <main+0x59c>
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    16ac <main+0x53c>
lea    0x9a7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jne    16c6 <main+0x556>
lea    0x9c5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x977(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    16f9 <main+0x589>
lea    0x961(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    16fe <main+0x58e>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1686 <main+0x516>
lea    0x9d5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1755 <main+0x5e5>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1720 <main+0x5b0>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1790 <main+0x620>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    175b <main+0x5eb>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    17a1 <main+0x631>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
xor    %eax,%eax
cmp    -0x54(%rbp),%ecx
mov    %al,-0x83(%rbp)
jne    17cc <main+0x65c>
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
setl   %al
mov    %al,-0x83(%rbp)
mov    -0x83(%rbp),%al
test   $0x1,%al
jne    17df <main+0x66f>
jmp    17ed <main+0x67d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17a1 <main+0x631>
jmp    17f2 <main+0x682>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
xor    %eax,%eax
cmp    -0x54(%rbp),%ecx
mov    %al,-0x84(%rbp)
jle    181d <main+0x6ad>
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
setge  %al
mov    %al,-0x84(%rbp)
mov    -0x84(%rbp),%al
test   $0x1,%al
jne    1830 <main+0x6c0>
jmp    183e <main+0x6ce>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    17f2 <main+0x682>
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    184f <main+0x6df>
jmp    1892 <main+0x722>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
je     188d <main+0x71d>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x74(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    179c <main+0x62c>
lea    0x7ed(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     192c <main+0x7bc>
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    18cc <main+0x75c>
lea    0x787(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jne    18e6 <main+0x776>
lea    0x7a5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x757(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    1919 <main+0x7a9>
lea    0x741(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    191e <main+0x7ae>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    18a6 <main+0x736>
lea    0x7b5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1975 <main+0x805>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1940 <main+0x7d0>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    19b0 <main+0x840>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    197b <main+0x80b>
mov    -0x50(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     19eb <main+0x87b>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
setg   %al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    19b6 <main+0x846>
mov    -0x4c(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x78(%rbp),%esi
mov    -0x48(%rbp),%edx
mov    -0x7c(%rbp),%ecx
lea    0x695(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x50(%rbp),%esi
mov    -0x30(%rbp),%edx
lea    0x697(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x50(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1a74 <main+0x904>
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    1a74 <main+0x904>
mov    -0x78(%rbp),%eax
add    -0x48(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jl     1a74 <main+0x904>
mov    -0x50(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%esi
lea    0x66f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x50(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    123a <main+0xca>
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1a9c <main+0x92c>
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
lea    0x65a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1add <main+0x96d>
mov    -0x34(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1ac4 <main+0x954>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    %eax,-0x2c(%rbp)
lea    0x64f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1ae2 <main+0x972>
mov    -0x50(%rbp),%eax
mov    %eax,-0x2c(%rbp)
lea    0x656(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1add <main+0x96d>
jmp    123a <main+0xca>
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1b57 <main+0x9e7>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1b52 <main+0x9e2>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1b4d <main+0x9dd>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x80(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1b52 <main+0x9e2>
jmp    1b57 <main+0x9e7>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
lea    0x5d3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1bcc <main+0xa5c>
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jne    1ba5 <main+0xa35>
lea    0x4e6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x498(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1b7f <main+0xa0f>
lea    0x515(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1c15 <main+0xaa5>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1be0 <main+0xa70>
mov    -0x34(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1c50 <main+0xae0>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1c1b <main+0xaab>
mov    -0x10(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%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    $0x78,%rsp
xor    %edi,%edi
call   1090 <time@plt>
movslq %eax,%rbx
imul   $0x10624dd3,%rbx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x26,%rax
add    %ecx,%eax
imul   $0x3e8,%eax,%eax
sub    %eax,%ebx
lea    0xe35(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %ebx,%edi
call   1070 <srand@plt>
mov    $0x78,%edi
call   10a0 <malloc@plt>
mov    %rax,%r15
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10b0 <rand@plt>
cltq
imul   $0x51eb851f,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x25,%rcx
add    %edx,%ecx
imul   $0x64,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,(%r15,%rbx,4)
add    $0x1,%rbx
cmp    $0x1e,%rbx
jne    11f0 <main+0x60>
movabs $0xffffffff00000000,%r13
ff ff ff
lea    0x10(%r15),%rax
mov    %rax,0x68(%rsp)
lea    0x4(%r15),%rax
mov    %rax,0x70(%rsp)
mov    $0xe,%r14d
mov    $0x1d,%ebp
mov    $0x1,%r12d
xor    %ebx,%ebx
mov    %ebx,%esi
mov    %r14d,0x44(%rsp)
jmp    1289 <main+0xf9>
nopl   0x0(%rax,%rax,1)
add    $0xffffffff,%r12d
lea    0xebb(%rip),%rdi
mov    %r12d,%ebp
mov    0x18(%rsp),%rax
mov    %eax,%ebx
call   1050 <puts@plt>
lea    0x1(%rbx),%r12d
mov    %ebx,%esi
cmp    %r12d,%ebp
jle    1975 <main+0x7e5>
lea    (%rsi,%rbp,1),%eax
mov    %eax,%ebx
shr    $0x1f,%ebx
add    %eax,%ebx
sar    %ebx
lea    0xd6a(%rip),%rdi
mov    %rsi,0x18(%rsp)
mov    %ebx,%edx
mov    %ebp,%ecx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xd70(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
movslq %ebx,%rax
mov    (%r15,%rax,4),%esi
movslq %ebp,%rdx
mov    (%r15,%rdx,4),%ecx
cmp    %ecx,%esi
jle    12e0 <main+0x150>
cmp    %ebp,%ebx
je     12e0 <main+0x150>
mov    %ecx,(%r15,%rax,4)
mov    %esi,(%r15,%rdx,4)
jmp    12e2 <main+0x152>
nopl   (%rax)
mov    %ecx,%esi
mov    0x18(%rsp),%rdi
movslq %edi,%rcx
mov    %rcx,0x10(%rsp)
mov    (%r15,%rcx,4),%ecx
cmp    %esi,%ecx
mov    %rbp,0x8(%rsp)
jle    1311 <main+0x181>
cmp    %edi,%ebp
je     1311 <main+0x181>
mov    0x10(%rsp),%rbp
mov    %esi,(%r15,%rbp,4)
mov    %ecx,(%r15,%rdx,4)
mov    (%r15,%rbp,4),%ecx
mov    (%r15,%rax,4),%r14d
cmp    %ecx,%r14d
jle    1930 <main+0x7a0>
cmp    %edi,%ebx
je     1930 <main+0x7a0>
mov    %ecx,(%r15,%rax,4)
mov    0x10(%rsp),%rcx
mov    %r14d,(%r15,%rcx,4)
cmp    %r12d,%ebx
je     1354 <main+0x1c4>
mov    (%r15,%rax,4),%ecx
movslq %r12d,%rdx
mov    (%r15,%rdx,4),%esi
mov    %esi,(%r15,%rax,4)
mov    %ecx,(%r15,%rdx,4)
mov    0x10(%rsp),%rax
mov    (%r15,%rax,4),%r14d
lea    0xcd3(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xd23(%rip),%rdi
call   1050 <puts@plt>
mov    0x18(%rsp),%ebp
mov    0x8(%rsp),%eax
mov    %rax,0x38(%rsp)
xor    %ebx,%ebx
jmp    139a <main+0x20a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    $0x1e,%rbx
je     13e0 <main+0x250>
cmp    %rbx,%rbp
jne    13ad <main+0x21d>
lea    0xc9a(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    (%r15,%rbx,4),%esi
lea    0xc8b(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    %rbx,0x38(%rsp)
jne    1390 <main+0x200>
lea    0xc7a(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    1390 <main+0x200>
cs nopw 0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1040 <putchar@plt>
xor    %edi,%edi
mov    0x8(%rsp),%rcx
mov    $0x0,%ebx
mov    0x18(%rsp),%r8
sub    %r8d,%ecx
jl     14fb <main+0x36b>
xor    %ebx,%ebx
mov    0x10(%rsp),%rax
mov    $0x0,%edi
cmp    $0x7,%ecx
jb     14d5 <main+0x345>
add    $0x1,%rcx
mov    %rcx,%rdx
and    $0xfffffffffffffff8,%rdx
mov    0x10(%rsp),%rdi
lea    (%rdx,%rdi,1),%rax
movd   %r14d,%xmm0
pshufd $0x0,%xmm0,%xmm2
mov    0x68(%rsp),%rsi
lea    (%rsi,%rdi,4),%rsi
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
pxor   %xmm4,%xmm4
pxor   %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x10(%rsi,%rdi,4),%xmm5
movdqu (%rsi,%rdi,4),%xmm6
movdqa %xmm2,%xmm7
pcmpgtd %xmm5,%xmm7
pcmpeqd %xmm2,%xmm5
psubd  %xmm5,%xmm4
movdqa %xmm2,%xmm5
pcmpgtd %xmm6,%xmm5
pcmpeqd %xmm2,%xmm6
psubd  %xmm6,%xmm3
psubd  %xmm7,%xmm0
psubd  %xmm5,%xmm1
add    $0x8,%rdi
cmp    %rdi,%rdx
jne    1460 <main+0x2d0>
paddd  %xmm4,%xmm3
pshufd $0xee,%xmm3,%xmm2
paddd  %xmm3,%xmm2
pshufd $0x55,%xmm2,%xmm3
paddd  %xmm2,%xmm3
movd   %xmm3,%edi
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ebx
cmp    %rdx,%rcx
je     14fb <main+0x36b>
mov    0x8(%rsp),%rcx
add    $0x1,%ecx
mov    %ecx,%ecx
nop
xor    %edx,%edx
xor    %esi,%esi
cmp    %r14d,(%r15,%rax,4)
setl   %dl
sete   %sil
add    %esi,%edi
add    %edx,%ebx
add    $0x1,%rax
cmp    %eax,%ecx
jne    14e0 <main+0x350>
mov    %rdi,0x30(%rsp)
mov    %rbp,0x58(%rsp)
mov    %rbx,0x50(%rsp)
lea    (%rbx,%r8,1),%eax
mov    %rax,0x20(%rsp)
mov    0x8(%rsp),%r8
jmp    152d <main+0x39d>
nopw   0x0(%rax,%rax,1)
mov    %esi,%r8d
movabs $0xffffffff00000000,%r13
ff ff ff
movslq %r12d,%rcx
movslq %r8d,%r10
mov    %rcx,%rsi
shl    $0x20,%rsi
add    %r13,%rsi
mov    %ecx,%ebp
lea    -0x1(%rcx),%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbp,%rax
mov    (%r15,%rcx,4),%r11d
lea    0x1(%rcx),%rdi
add    $0x1,%r12d
movabs $0x100000000,%rdx
add    %rdx,%rsi
cmp    %r14d,%r11d
jge    157d <main+0x3ed>
lea    0x1(%rax),%rbp
cmp    %r10,%rcx
mov    %rdi,%rcx
jle    1550 <main+0x3c0>
sar    $0x20,%rsi
mov    0x70(%rsp),%rcx
lea    (%rcx,%r10,4),%r9
mov    %r8d,%r13d
xor    %ebx,%ebx
nop
mov    %r13d,%ebp
mov    -0x4(%r9,%rbx,4),%ecx
lea    -0x1(%rbx),%rdx
add    $0x1,%rax
cmp    %r14d,%ecx
jl     15b4 <main+0x424>
add    %r10,%rbx
lea    -0x1(%rbp),%r13d
cmp    %rbx,%rsi
mov    %rdx,%rbx
jle    1590 <main+0x400>
lea    0x1(%r8),%ebx
lea    (%rbx,%rdx,1),%rsi
cmp    %r12d,%esi
jl     15e0 <main+0x450>
cmp    %eax,%ebx
je     1520 <main+0x390>
mov    %ecx,-0x4(%r15,%rdi,4)
mov    %r11d,(%r9,%rdx,4)
jmp    1520 <main+0x390>
nopw   0x0(%rax,%rax,1)
not    %r8d
add    0x18(%rsp),%r8d
cmp    %edx,%r8d
je     15fe <main+0x46e>
mov    0x10(%rsp),%rsi
mov    (%r15,%rsi,4),%eax
mov    %ecx,(%r15,%rsi,4)
mov    %eax,(%r9,%rdx,4)
mov    0x30(%rsp),%rax
mov    0x20(%rsp),%r12
add    %r12d,%eax
mov    %rax,0x28(%rsp)
lea    0xa83(%rip),%rdi
call   1050 <puts@plt>
mov    %ebp,%eax
mov    %rax,0x60(%rsp)
xor    %ebx,%ebx
movabs $0xffffffff00000000,%r13
ff ff ff
mov    0x58(%rsp),%rbp
jmp    164a <main+0x4ba>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x1e,%rbx
je     16a0 <main+0x510>
cmp    %rbx,%rbp
jne    165d <main+0x4cd>
lea    0x9ea(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    %rbx,0x60(%rsp)
jne    166e <main+0x4de>
mov    $0x2a,%edi
call   1040 <putchar@plt>
mov    (%r15,%rbx,4),%esi
lea    0x9ca(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    %rbx,0x38(%rsp)
jne    1640 <main+0x4b0>
lea    0x9b9(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    1640 <main+0x4b0>
nopw   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1040 <putchar@plt>
cmpl   $0x0,0x50(%rsp)
jle    16d8 <main+0x548>
movslq %r12d,%rbx
mov    0x10(%rsp),%rbp
nopl   0x0(%rax)
xor    %edi,%edi
cmp    %r14d,(%r15,%rbp,4)
setl   %dil
call   1080 <assert@plt>
add    $0x1,%rbp
cmp    %rbx,%rbp
jl     16c0 <main+0x530>
movslq %r12d,%rax
mov    %rax,0x48(%rsp)
cmp    0x8(%rsp),%r12d
jg     1717 <main+0x587>
mov    0x48(%rsp),%rax
lea    (%r15,%rax,4),%r12
mov    0x8(%rsp),%rbx
sub    0x20(%rsp),%ebx
add    $0x1,%ebx
xor    %ebp,%ebp
xchg   %ax,%ax
xor    %edi,%edi
cmp    %r14d,(%r12,%rbp,4)
setge  %dil
call   1080 <assert@plt>
add    $0x1,%rbp
cmp    %ebp,%ebx
jne    1700 <main+0x570>
movslq 0x28(%rsp),%r12
mov    0x8(%rsp),%rax
mov    %eax,%r8d
mov    0x20(%rsp),%rax
mov    %eax,%r9d
nopl   0x0(%rax)
movslq %r9d,%rsi
lea    -0x1(%rsi),%r9d
mov    %rsi,%rdi
shl    $0x20,%rdi
add    %r13,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r9d,%ebp
mov    (%r15,%rsi,4),%edx
lea    0x1(%rsi),%rbx
lea    0x1(%rbp),%r9d
movabs $0x100000000,%rax
add    %rax,%rdi
cmp    %r14d,%edx
jne    1779 <main+0x5e9>
cmp    %r12,%rsi
mov    %rbx,%rsi
jl     1750 <main+0x5c0>
movslq %r8d,%rcx
sar    $0x20,%rdi
mov    (%r15,%rcx,4),%esi
lea    -0x1(%rcx),%rax
cmp    %r14d,%esi
jle    1795 <main+0x605>
cmp    %rdi,%rcx
mov    %rax,%rcx
jge    1780 <main+0x5f0>
lea    0x1(%rax),%r8d
cmp    %r9d,%r8d
jl     17b0 <main+0x620>
cmp    %eax,%ebp
je     1730 <main+0x5a0>
mov    %esi,-0x4(%r15,%rbx,4)
mov    %edx,0x4(%r15,%rax,4)
jmp    1730 <main+0x5a0>
xchg   %ax,%ax
lea    0x910(%rip),%rdi
call   1050 <puts@plt>
xor    %ebp,%ebp
jmp    17ca <main+0x63a>
add    $0x1,%rbp
cmp    $0x1e,%rbp
je     1820 <main+0x690>
cmp    %rbp,0x58(%rsp)
jne    17df <main+0x64f>
lea    0x868(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    %rbp,0x60(%rsp)
jne    17f0 <main+0x660>
mov    $0x2a,%edi
call   1040 <putchar@plt>
mov    (%r15,%rbp,4),%esi
lea    0x848(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    %rbp,0x38(%rsp)
jne    17c0 <main+0x630>
lea    0x837(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    17c0 <main+0x630>
nopl   0x0(%rax)
mov    $0xa,%edi
call   1040 <putchar@plt>
cmpl   $0x0,0x50(%rsp)
mov    0x10(%rsp),%rbp
jle    1858 <main+0x6c8>
movslq 0x20(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
cmp    %r14d,(%r15,%rbp,4)
setl   %dil
call   1080 <assert@plt>
add    $0x1,%rbp
cmp    %rbx,%rbp
jl     1840 <main+0x6b0>
cmpl   $0x0,0x30(%rsp)
mov    0x8(%rsp),%rbx
mov    0x48(%rsp),%rbp
jle    1888 <main+0x6f8>
nopl   0x0(%rax)
xor    %edi,%edi
cmp    %r14d,(%r15,%rbp,4)
sete   %dil
call   1080 <assert@plt>
add    $0x1,%rbp
cmp    %r12,%rbp
jl     1870 <main+0x6e0>
cmp    %ebx,0x28(%rsp)
jg     18b7 <main+0x727>
lea    (%r15,%r12,4),%r12
mov    0x8(%rsp),%rbp
sub    0x28(%rsp),%ebp
add    $0x1,%ebp
xor    %ebx,%ebx
xor    %edi,%edi
cmp    %r14d,(%r12,%rbx,4)
setg   %dil
call   1080 <assert@plt>
add    $0x1,%rbx
cmp    %ebx,%ebp
jne    18a0 <main+0x710>
mov    $0x1e,%ebp
mov    0x28(%rsp),%rbx
sub    %ebx,%ebp
lea    0x780(%rip),%rdi
mov    0x20(%rsp),%r12
mov    %r12d,%esi
mov    0x30(%rsp),%rdx
mov    %ebp,%ecx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x779(%rip),%rdi
mov    %ebx,%esi
mov    0x8(%rsp),%rdx
xor    %eax,%eax
call   1060 <printf@plt>
cmp    %ebp,%ebx
jl     1904 <main+0x774>
cmp    0x8(%rsp),%ebx
jg     1904 <main+0x774>
cmp    %r12d,%ebp
jg     1950 <main+0x7c0>
mov    0x44(%rsp),%r14d
cmp    %r12d,%r14d
jl     1260 <main+0xd0>
lea    0x7cc(%rip),%rdi
cmp    %ebx,%r14d
mov    0x8(%rsp),%rbp
jge    1275 <main+0xe5>
jmp    19a2 <main+0x812>
nopl   0x0(%rax)
mov    %ecx,%r14d
cmp    %r12d,%ebx
je     1354 <main+0x1c4>
jmp    1338 <main+0x1a8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x71f(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x1(%rbx),%r12d
mov    %ebx,%r14d
mov    0x8(%rsp),%rbp
cmp    %r12d,%ebp
jg     124f <main+0xbf>
cmp    %r12d,%ebp
jne    199d <main+0x80d>
mov    %rbp,%rsi
movslq %ebx,%rbp
mov    (%r15,%rbp,4),%eax
movslq %esi,%rcx
mov    (%r15,%rcx,4),%edx
cmp    %edx,%eax
jle    19b4 <main+0x824>
cmp    %esi,%ebx
je     19b4 <main+0x824>
mov    %edx,(%r15,%rbp,4)
mov    %eax,(%r15,%rcx,4)
jmp    19b4 <main+0x824>
mov    %ebx,%r12d
jmp    19ae <main+0x81e>
lea    0x759(%rip),%rdi
call   1050 <puts@plt>
movslq %r12d,%rbp
mov    %r12d,%ebx
mov    (%r15,%rbp,4),%r13d
lea    0x762(%rip),%rdi
call   1050 <puts@plt>
mov    %ebx,%r12d
lea    0x675(%rip),%r14
xor    %ebx,%ebx
jmp    19f8 <main+0x868>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbx
cmp    $0x1e,%rbx
je     1a09 <main+0x879>
cmp    %rbx,%r12
jne    19e0 <main+0x850>
mov    $0x2a,%edi
call   1040 <putchar@plt>
jmp    19e0 <main+0x850>
mov    $0xa,%edi
call   1040 <putchar@plt>
test   %r12d,%r12d
jle    1a40 <main+0x8b0>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
xor    %edi,%edi
cmp    %r13d,(%r15,%rbx,4)
setl   %dil
call   1080 <assert@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1a20 <main+0x890>
cmp    $0x1d,%r12d
jg     1a58 <main+0x8c8>
xchg   %ax,%ax
xor    %edi,%edi
cmp    %r13d,(%r15,%rbp,4)
setge  %dil
call   1080 <assert@plt>
add    $0x1,%rbp
cmp    $0x1e,%ebp
jne    1a40 <main+0x8b0>
mov    %r15,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [6 x i8] c"t=%i\0A\00"
@.str.1 = [29 x i8] c"low=%i, middle=%i, high=%i.\0A\00"
@.str.2 = [11 x i8] c"median=%i\0A\00"
@.str.3 = [18 x i8] c"middle value: %i\0A\00"
@.str.4 = [12 x i8] c"beginning:\0A\00"
@.str.5 = [3 x i8] c"( \00"
@.str.6 = [4 x i8] c"%i \00"
@.str.7 = [3 x i8] c") \00"
@.str.8 = [2 x i8] c"\0A\00"
@.str.9 = [46 x i8] c"after swapping middle value back into place:\0A\00"
@.str.10 = [2 x i8] c"*\00"
@.str.11 = [31 x i8] c"after collecting equal items:\0A\00"
@.str.12 = [22 x i8] c"nl=%i, ne=%i, nh=%i.\0A\00"
@.str.13 = [22 x i8] c"greater=%i, high=%i.\0A\00"
@.str.14 = [25 x i8] c"Changed \22median\22 to %i.\0A\00"
@.str.15 = [29 x i8] c"median is in low partition.\0A\00"
@.str.16 = [32 x i8] c"median is in middle partition.\0A\00"
@.str.17 = [30 x i8] c"median is in high partition.\0A\00"
@.str.18 = [6 x i8] c"end:\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%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
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
store i32 0, i32* %1
store i32 30, i32* %3
store i32 100, i32* %4
store i32 0, i32* %6
%31 = load i32, i32* %3
%32 = sub nsw i32 %31, 1
store i32 %32, i32* %7
%33 = call i32 @time(i32* null)
store i32 %33, i32* %8
%34 = load i32, i32* %8
%35 = srem i32 %34, 1000
store i32 %35, i32* %8
%36 = load i32, i32* %8
%37 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32 %36)
%38 = load i32, i32* %8
%39 = call i32 @srand(i32 %38)
%40 = load i32, i32* %3
%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** %2
store i32 0, i32* %5
br label %45
45: ; preds = %57, %0
%46 = load i32, i32* %5
%47 = load i32, i32* %3
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %60
49: ; preds = %45
%50 = call i32 (...) @rand()
%51 = load i32, i32* %4
%52 = srem i32 %50, %51
%53 = load i32*, i32** %2
%54 = load i32, i32* %5
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i32, i32* %53, i64 %55
store i32 %52, i32* %56
br label %57
57: ; preds = %49
%58 = load i32, i32* %5
%59 = add nsw i32 %58, 1
store i32 %59, i32* %5
br label %45
60: ; preds = %45
%61 = load i32, i32* %6
store i32 %61, i32* %9
%62 = load i32, i32* %7
store i32 %62, i32* %10
%63 = load i32, i32* %9
%64 = load i32, i32* %10
%65 = add nsw i32 %63, %64
%66 = sdiv i32 %65, 2
store i32 %66, i32* %11
br label %67
67: ; preds = %60, %656, %680
%68 = load i32, i32* %10
%69 = load i32, i32* %9
%70 = add nsw i32 %69, 1
%71 = icmp sle i32 %68, %70
br i1 %71, label %72, label %73
72: ; preds = %67
br label %681
73: ; preds = %67
%74 = load i32, i32* %9
%75 = load i32, i32* %10
%76 = add nsw i32 %74, %75
%77 = sdiv i32 %76, 2
store i32 %77, i32* %12
%78 = load i32, i32* %9
%79 = load i32, i32* %12
%80 = load i32, i32* %10
%81 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0), i32 %78, i32 %79, i32 %80)
%82 = load i32, i32* %11
%83 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), i32 %82)
%84 = load i32*, i32** %2
%85 = load i32, i32* %12
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i32, i32* %84, i64 %86
%88 = load i32, i32* %87
%89 = load i32*, i32** %2
%90 = load i32, i32* %10
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i32, i32* %89, i64 %91
%93 = load i32, i32* %92
%94 = icmp sgt i32 %88, %93
br i1 %94, label %95, label %120
95: ; preds = %73
%96 = load i32, i32* %12
%97 = load i32, i32* %10
%98 = icmp ne i32 %96, %97
br i1 %98, label %99, label %119
99: ; preds = %95
%100 = load i32*, i32** %2
%101 = load i32, i32* %12
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i32, i32* %100, i64 %102
%104 = load i32, i32* %103
store i32 %104, i32* %21
%105 = load i32*, i32** %2
%106 = load i32, i32* %10
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds i32, i32* %105, i64 %107
%109 = load i32, i32* %108
%110 = load i32*, i32** %2
%111 = load i32, i32* %12
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i32, i32* %110, i64 %112
store i32 %109, i32* %113
%114 = load i32, i32* %21
%115 = load i32*, i32** %2
%116 = load i32, i32* %10
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i32, i32* %115, i64 %117
store i32 %114, i32* %118
br label %119
119: ; preds = %99, %95
br label %120
120: ; preds = %119, %73
%121 = load i32*, i32** %2
%122 = load i32, i32* %9
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i32, i32* %121, i64 %123
%125 = load i32, i32* %124
%126 = load i32*, i32** %2
%127 = load i32, i32* %10
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %126, i64 %128
%130 = load i32, i32* %129
%131 = icmp sgt i32 %125, %130
br i1 %131, label %132, label %157
132: ; preds = %120
%133 = load i32, i32* %9
%134 = load i32, i32* %10
%135 = icmp ne i32 %133, %134
br i1 %135, label %136, label %156
136: ; preds = %132
%137 = load i32*, i32** %2
%138 = load i32, i32* %9
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i32, i32* %137, i64 %139
%141 = load i32, i32* %140
store i32 %141, i32* %22
%142 = load i32*, i32** %2
%143 = load i32, i32* %10
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i32, i32* %142, i64 %144
%146 = load i32, i32* %145
%147 = load i32*, i32** %2
%148 = load i32, i32* %9
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i32, i32* %147, i64 %149
store i32 %146, i32* %150
%151 = load i32, i32* %22
%152 = load i32*, i32** %2
%153 = load i32, i32* %10
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds i32, i32* %152, i64 %154
store i32 %151, i32* %155
br label %156
156: ; preds = %136, %132
br label %157
157: ; preds = %156, %120
%158 = load i32*, i32** %2
%159 = load i32, i32* %12
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32, i32* %158, i64 %160
%162 = load i32, i32* %161
%163 = load i32*, i32** %2
%164 = load i32, i32* %9
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i32, i32* %163, i64 %165
%167 = load i32, i32* %166
%168 = icmp sgt i32 %162, %167
br i1 %168, label %169, label %194
169: ; preds = %157
%170 = load i32, i32* %12
%171 = load i32, i32* %9
%172 = icmp ne i32 %170, %171
br i1 %172, label %173, label %193
173: ; preds = %169
%174 = load i32*, i32** %2
%175 = load i32, i32* %12
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i32, i32* %174, i64 %176
%178 = load i32, i32* %177
store i32 %178, i32* %23
%179 = load i32*, i32** %2
%180 = load i32, i32* %9
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i32, i32* %179, i64 %181
%183 = load i32, i32* %182
%184 = load i32*, i32** %2
%185 = load i32, i32* %12
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i32, i32* %184, i64 %186
store i32 %183, i32* %187
%188 = load i32, i32* %23
%189 = load i32*, i32** %2
%190 = load i32, i32* %9
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i32, i32* %189, i64 %191
store i32 %188, i32* %192
br label %193
193: ; preds = %173, %169
br label %194
194: ; preds = %193, %157
%195 = load i32, i32* %12
%196 = load i32, i32* %9
%197 = add nsw i32 %196, 1
%198 = icmp ne i32 %195, %197
br i1 %198, label %199, label %221
199: ; preds = %194
%200 = load i32*, i32** %2
%201 = load i32, i32* %12
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds i32, i32* %200, i64 %202
%204 = load i32, i32* %203
store i32 %204, i32* %24
%205 = load i32*, i32** %2
%206 = load i32, i32* %9
%207 = add nsw i32 %206, 1
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i32, i32* %205, i64 %208
%210 = load i32, i32* %209
%211 = load i32*, i32** %2
%212 = load i32, i32* %12
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds i32, i32* %211, i64 %213
store i32 %210, i32* %214
%215 = load i32, i32* %24
%216 = load i32*, i32** %2
%217 = load i32, i32* %9
%218 = add nsw i32 %217, 1
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i32, i32* %216, i64 %219
store i32 %215, i32* %220
br label %221
221: ; preds = %199, %194
%222 = load i32*, i32** %2
%223 = load i32, i32* %9
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i32, i32* %222, i64 %224
%226 = load i32, i32* %225
store i32 %226, i32* %19
%227 = load i32, i32* %19
%228 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), i32 %227)
%229 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i64 0, i64 0))
%230 = load i32, i32* %6
store i32 %230, i32* %5
br label %231
231: ; preds = %254, %221
%232 = load i32, i32* %5
%233 = load i32, i32* %7
%234 = icmp sle i32 %232, %233
br i1 %234, label %235, label %257
235: ; preds = %231
%236 = load i32, i32* %5
%237 = load i32, i32* %9
%238 = icmp eq i32 %236, %237
br i1 %238, label %239, label %241
239: ; preds = %235
%240 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
br label %241
241: ; preds = %239, %235
%242 = load i32*, i32** %2
%243 = load i32, i32* %5
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds i32, i32* %242, i64 %244
%246 = load i32, i32* %245
%247 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %246)
%248 = load i32, i32* %5
%249 = load i32, i32* %10
%250 = icmp eq i32 %248, %249
br i1 %250, label %251, label %253
251: ; preds = %241
%252 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
br label %253
253: ; preds = %251, %241
br label %254
254: ; preds = %253
%255 = load i32, i32* %5
%256 = add nsw i32 %255, 1
store i32 %256, i32* %5
br label %231
257: ; preds = %231
%258 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
store i32 0, i32* %16
store i32 0, i32* %15
%259 = load i32, i32* %9
store i32 %259, i32* %5
br label %260
260: ; preds = %288, %257
%261 = load i32, i32* %5
%262 = load i32, i32* %10
%263 = icmp sle i32 %261, %262
br i1 %263, label %264, label %291
264: ; preds = %260
%265 = load i32*, i32** %2
%266 = load i32, i32* %5
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i32, i32* %265, i64 %267
%269 = load i32, i32* %268
%270 = load i32, i32* %19
%271 = icmp slt i32 %269, %270
br i1 %271, label %272, label %275
272: ; preds = %264
%273 = load i32, i32* %15
%274 = add nsw i32 %273, 1
store i32 %274, i32* %15
br label %287
275: ; preds = %264
%276 = load i32*, i32** %2
%277 = load i32, i32* %5
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i32, i32* %276, i64 %278
%280 = load i32, i32* %279
%281 = load i32, i32* %19
%282 = icmp eq i32 %280, %281
br i1 %282, label %283, label %286
283: ; preds = %275
%284 = load i32, i32* %16
%285 = add nsw i32 %284, 1
store i32 %285, i32* %16
br label %286
286: ; preds = %283, %275
br label %287
287: ; preds = %286, %272
br label %288
288: ; preds = %287
%289 = load i32, i32* %5
%290 = add nsw i32 %289, 1
store i32 %290, i32* %5
br label %260
291: ; preds = %260
%292 = load i32, i32* %9
%293 = load i32, i32* %15
%294 = add nsw i32 %292, %293
store i32 %294, i32* %17
%295 = load i32, i32* %17
%296 = load i32, i32* %16
%297 = add nsw i32 %295, %296
store i32 %297, i32* %18
%298 = load i32, i32* %9
%299 = add nsw i32 %298, 1
store i32 %299, i32* %13
%300 = load i32, i32* %10
store i32 %300, i32* %14
br label %301
301: ; preds = %366, %291
br label %302
302: ; preds = %316, %301
%303 = load i32*, i32** %2
%304 = load i32, i32* %13
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds i32, i32* %303, i64 %305
%307 = load i32, i32* %306
%308 = load i32, i32* %19
%309 = icmp slt i32 %307, %308
br i1 %309, label %310, label %314
310: ; preds = %302
%311 = load i32, i32* %13
%312 = load i32, i32* %14
%313 = icmp sle i32 %311, %312
br label %314
314: ; preds = %310, %302
%315 = phi i1 [ false, %302 ], [ %313, %310 ]
br i1 %315, label %316, label %319
316: ; preds = %314
%317 = load i32, i32* %13
%318 = add nsw i32 %317, 1
store i32 %318, i32* %13
br label %302
319: ; preds = %314
br label %320
320: ; preds = %334, %319
%321 = load i32*, i32** %2
%322 = load i32, i32* %14
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds i32, i32* %321, i64 %323
%325 = load i32, i32* %324
%326 = load i32, i32* %19
%327 = icmp sge i32 %325, %326
br i1 %327, label %328, label %332
328: ; preds = %320
%329 = load i32, i32* %13
%330 = load i32, i32* %14
%331 = icmp sle i32 %329, %330
br label %332
332: ; preds = %328, %320
%333 = phi i1 [ false, %320 ], [ %331, %328 ]
br i1 %333, label %334, label %337
334: ; preds = %332
%335 = load i32, i32* %14
%336 = add nsw i32 %335, -1
store i32 %336, i32* %14
br label %320
337: ; preds = %332
%338 = load i32, i32* %14
%339 = load i32, i32* %13
%340 = icmp slt i32 %338, %339
br i1 %340, label %341, label %342
341: ; preds = %337
br label %367
342: ; preds = %337
%343 = load i32, i32* %13
%344 = load i32, i32* %14
%345 = icmp ne i32 %343, %344
br i1 %345, label %346, label %366
346: ; preds = %342
%347 = load i32*, i32** %2
%348 = load i32, i32* %13
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds i32, i32* %347, i64 %349
%351 = load i32, i32* %350
store i32 %351, i32* %25
%352 = load i32*, i32** %2
%353 = load i32, i32* %14
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds i32, i32* %352, i64 %354
%356 = load i32, i32* %355
%357 = load i32*, i32** %2
%358 = load i32, i32* %13
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds i32, i32* %357, i64 %359
store i32 %356, i32* %360
%361 = load i32, i32* %25
%362 = load i32*, i32** %2
%363 = load i32, i32* %14
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds i32, i32* %362, i64 %364
store i32 %361, i32* %365
br label %366
366: ; preds = %346, %342
br label %301
367: ; preds = %341
%368 = load i32, i32* %9
%369 = load i32, i32* %14
%370 = icmp ne i32 %368, %369
br i1 %370, label %371, label %391
371: ; preds = %367
%372 = load i32*, i32** %2
%373 = load i32, i32* %9
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds i32, i32* %372, i64 %374
%376 = load i32, i32* %375
store i32 %376, i32* %26
%377 = load i32*, i32** %2
%378 = load i32, i32* %14
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds i32, i32* %377, i64 %379
%381 = load i32, i32* %380
%382 = load i32*, i32** %2
%383 = load i32, i32* %9
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds i32, i32* %382, i64 %384
store i32 %381, i32* %385
%386 = load i32, i32* %26
%387 = load i32*, i32** %2
%388 = load i32, i32* %14
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds i32, i32* %387, i64 %389
store i32 %386, i32* %390
br label %391
391: ; preds = %371, %367
%392 = load i32, i32* %14
store i32 %392, i32* %20
%393 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.9, i64 0, i64 0))
%394 = load i32, i32* %6
store i32 %394, i32* %5
br label %395
395: ; preds = %424, %391
%396 = load i32, i32* %5
%397 = load i32, i32* %7
%398 = icmp sle i32 %396, %397
br i1 %398, label %399, label %427
399: ; preds = %395
%400 = load i32, i32* %5
%401 = load i32, i32* %9
%402 = icmp eq i32 %400, %401
br i1 %402, label %403, label %405
403: ; preds = %399
%404 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
br label %405
405: ; preds = %403, %399
%406 = load i32, i32* %5
%407 = load i32, i32* %20
%408 = icmp eq i32 %406, %407
br i1 %408, label %409, label %411
409: ; preds = %405
%410 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0))
br label %411
411: ; preds = %409, %405
%412 = load i32*, i32** %2
%413 = load i32, i32* %5
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds i32, i32* %412, i64 %414
%416 = load i32, i32* %415
%417 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %416)
%418 = load i32, i32* %5
%419 = load i32, i32* %10
%420 = icmp eq i32 %418, %419
br i1 %420, label %421, label %423
421: ; preds = %411
%422 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
br label %423
423: ; preds = %421, %411
br label %424
424: ; preds = %423
%425 = load i32, i32* %5
%426 = add nsw i32 %425, 1
store i32 %426, i32* %5
br label %395
427: ; preds = %395
%428 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%429 = load i32, i32* %9
store i32 %429, i32* %5
br label %430
430: ; preds = %444, %427
%431 = load i32, i32* %5
%432 = load i32, i32* %17
%433 = icmp slt i32 %431, %432
br i1 %433, label %434, label %447
434: ; preds = %430
%435 = load i32*, i32** %2
%436 = load i32, i32* %5
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds i32, i32* %435, i64 %437
%439 = load i32, i32* %438
%440 = load i32, i32* %19
%441 = icmp slt i32 %439, %440
%442 = zext i1 %441 to i32
%443 = call i32 @assert(i32 %442)
br label %444
444: ; preds = %434
%445 = load i32, i32* %5
%446 = add nsw i32 %445, 1
store i32 %446, i32* %5
br label %430
447: ; preds = %430
%448 = load i32, i32* %17
store i32 %448, i32* %5
br label %449
449: ; preds = %463, %447
%450 = load i32, i32* %5
%451 = load i32, i32* %10
%452 = icmp sle i32 %450, %451
br i1 %452, label %453, label %466
453: ; preds = %449
%454 = load i32*, i32** %2
%455 = load i32, i32* %5
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds i32, i32* %454, i64 %456
%458 = load i32, i32* %457
%459 = load i32, i32* %19
%460 = icmp sge i32 %458, %459
%461 = zext i1 %460 to i32
%462 = call i32 @assert(i32 %461)
br label %463
463: ; preds = %453
%464 = load i32, i32* %5
%465 = add nsw i32 %464, 1
store i32 %465, i32* %5
br label %449
466: ; preds = %449
%467 = load i32, i32* %17
store i32 %467, i32* %13
%468 = load i32, i32* %10
store i32 %468, i32* %14
br label %469
469: ; preds = %534, %466
br label %470
470: ; preds = %484, %469
%471 = load i32*, i32** %2
%472 = load i32, i32* %13
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds i32, i32* %471, i64 %473
%475 = load i32, i32* %474
%476 = load i32, i32* %19
%477 = icmp eq i32 %475, %476
br i1 %477, label %478, label %482
478: ; preds = %470
%479 = load i32, i32* %13
%480 = load i32, i32* %18
%481 = icmp slt i32 %479, %480
br label %482
482: ; preds = %478, %470
%483 = phi i1 [ false, %470 ], [ %481, %478 ]
br i1 %483, label %484, label %487
484: ; preds = %482
%485 = load i32, i32* %13
%486 = add nsw i32 %485, 1
store i32 %486, i32* %13
br label %470
487: ; preds = %482
br label %488
488: ; preds = %502, %487
%489 = load i32*, i32** %2
%490 = load i32, i32* %14
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds i32, i32* %489, i64 %491
%493 = load i32, i32* %492
%494 = load i32, i32* %19
%495 = icmp sgt i32 %493, %494
br i1 %495, label %496, label %500
496: ; preds = %488
%497 = load i32, i32* %14
%498 = load i32, i32* %13
%499 = icmp sge i32 %497, %498
br label %500
500: ; preds = %496, %488
%501 = phi i1 [ false, %488 ], [ %499, %496 ]
br i1 %501, label %502, label %505
502: ; preds = %500
%503 = load i32, i32* %14
%504 = add nsw i32 %503, -1
store i32 %504, i32* %14
br label %488
505: ; preds = %500
%506 = load i32, i32* %14
%507 = load i32, i32* %13
%508 = icmp slt i32 %506, %507
br i1 %508, label %509, label %510
509: ; preds = %505
br label %535
510: ; preds = %505
%511 = load i32, i32* %13
%512 = load i32, i32* %14
%513 = icmp ne i32 %511, %512
br i1 %513, label %514, label %534
514: ; preds = %510
%515 = load i32*, i32** %2
%516 = load i32, i32* %13
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds i32, i32* %515, i64 %517
%519 = load i32, i32* %518
store i32 %519, i32* %27
%520 = load i32*, i32** %2
%521 = load i32, i32* %14
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds i32, i32* %520, i64 %522
%524 = load i32, i32* %523
%525 = load i32*, i32** %2
%526 = load i32, i32* %13
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds i32, i32* %525, i64 %527
store i32 %524, i32* %528
%529 = load i32, i32* %27
%530 = load i32*, i32** %2
%531 = load i32, i32* %14
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds i32, i32* %530, i64 %532
store i32 %529, i32* %533
br label %534
534: ; preds = %514, %510
br label %469
535: ; preds = %509
%536 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.11, i64 0, i64 0))
%537 = load i32, i32* %6
store i32 %537, i32* %5
br label %538
538: ; preds = %567, %535
%539 = load i32, i32* %5
%540 = load i32, i32* %7
%541 = icmp sle i32 %539, %540
br i1 %541, label %542, label %570
542: ; preds = %538
%543 = load i32, i32* %5
%544 = load i32, i32* %9
%545 = icmp eq i32 %543, %544
br i1 %545, label %546, label %548
546: ; preds = %542
%547 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
br label %548
548: ; preds = %546, %542
%549 = load i32, i32* %5
%550 = load i32, i32* %20
%551 = icmp eq i32 %549, %550
br i1 %551, label %552, label %554
552: ; preds = %548
%553 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0))
br label %554
554: ; preds = %552, %548
%555 = load i32*, i32** %2
%556 = load i32, i32* %5
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds i32, i32* %555, i64 %557
%559 = load i32, i32* %558
%560 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %559)
%561 = load i32, i32* %5
%562 = load i32, i32* %10
%563 = icmp eq i32 %561, %562
br i1 %563, label %564, label %566
564: ; preds = %554
%565 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
br label %566
566: ; preds = %564, %554
br label %567
567: ; preds = %566
%568 = load i32, i32* %5
%569 = add nsw i32 %568, 1
store i32 %569, i32* %5
br label %538
570: ; preds = %538
%571 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%572 = load i32, i32* %9
store i32 %572, i32* %5
br label %573
573: ; preds = %587, %570
%574 = load i32, i32* %5
%575 = load i32, i32* %17
%576 = icmp slt i32 %574, %575
br i1 %576, label %577, label %590
577: ; preds = %573
%578 = load i32*, i32** %2
%579 = load i32, i32* %5
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds i32, i32* %578, i64 %580
%582 = load i32, i32* %581
%583 = load i32, i32* %19
%584 = icmp slt i32 %582, %583
%585 = zext i1 %584 to i32
%586 = call i32 @assert(i32 %585)
br label %587
587: ; preds = %577
%588 = load i32, i32* %5
%589 = add nsw i32 %588, 1
store i32 %589, i32* %5
br label %573
590: ; preds = %573
%591 = load i32, i32* %17
store i32 %591, i32* %5
br label %592
592: ; preds = %606, %590
%593 = load i32, i32* %5
%594 = load i32, i32* %18
%595 = icmp slt i32 %593, %594
br i1 %595, label %596, label %609
596: ; preds = %592
%597 = load i32*, i32** %2
%598 = load i32, i32* %5
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds i32, i32* %597, i64 %599
%601 = load i32, i32* %600
%602 = load i32, i32* %19
%603 = icmp eq i32 %601, %602
%604 = zext i1 %603 to i32
%605 = call i32 @assert(i32 %604)
br label %606
606: ; preds = %596
%607 = load i32, i32* %5
%608 = add nsw i32 %607, 1
store i32 %608, i32* %5
br label %592
609: ; preds = %592
%610 = load i32, i32* %18
store i32 %610, i32* %5
br label %611
611: ; preds = %625, %609
%612 = load i32, i32* %5
%613 = load i32, i32* %10
%614 = icmp sle i32 %612, %613
br i1 %614, label %615, label %628
615: ; preds = %611
%616 = load i32*, i32** %2
%617 = load i32, i32* %5
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds i32, i32* %616, i64 %618
%620 = load i32, i32* %619
%621 = load i32, i32* %19
%622 = icmp sgt i32 %620, %621
%623 = zext i1 %622 to i32
%624 = call i32 @assert(i32 %623)
br label %625
625: ; preds = %615
%626 = load i32, i32* %5
%627 = add nsw i32 %626, 1
store i32 %627, i32* %5
br label %611
628: ; preds = %611
%629 = load i32, i32* %17
%630 = load i32, i32* %6
%631 = sub nsw i32 %629, %630
store i32 %631, i32* %28
%632 = load i32, i32* %7
%633 = add nsw i32 %632, 1
%634 = load i32, i32* %18
%635 = sub nsw i32 %633, %634
store i32 %635, i32* %29
%636 = load i32, i32* %28
%637 = load i32, i32* %16
%638 = load i32, i32* %29
%639 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.12, i64 0, i64 0), i32 %636, i32 %637, i32 %638)
%640 = load i32, i32* %18
%641 = load i32, i32* %10
%642 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.13, i64 0, i64 0), i32 %640, i32 %641)
%643 = load i32, i32* %18
%644 = load i32, i32* %10
%645 = icmp sle i32 %643, %644
br i1 %645, label %646, label %661
646: ; preds = %628
%647 = load i32, i32* %29
%648 = load i32, i32* %28
%649 = icmp sgt i32 %647, %648
br i1 %649, label %650, label %661
650: ; preds = %646
%651 = load i32, i32* %28
%652 = load i32, i32* %16
%653 = add nsw i32 %651, %652
%654 = load i32, i32* %29
%655 = icmp sge i32 %653, %654
br i1 %655, label %656, label %661
656: ; preds = %650
%657 = load i32, i32* %18
store i32 %657, i32* %11
%658 = load i32, i32* %11
%659 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.14, i64 0, i64 0), i32 %658)
%660 = load i32, i32* %18
store i32 %660, i32* %9
br label %67
661: ; preds = %650, %646, %628
%662 = load i32, i32* %11
%663 = load i32, i32* %17
%664 = icmp slt i32 %662, %663
br i1 %664, label %665, label %669
665: ; preds = %661
%666 = load i32, i32* %17
%667 = sub nsw i32 %666, 1
store i32 %667, i32* %10
%668 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.15, i64 0, i64 0))
br label %680
669: ; preds = %661
%670 = load i32, i32* %11
%671 = load i32, i32* %18
%672 = icmp slt i32 %670, %671
br i1 %672, label %673, label %676
673: ; preds = %669
%674 = load i32, i32* %17
store i32 %674, i32* %10
store i32 %674, i32* %9
%675 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.16, i64 0, i64 0))
br label %681
676: ; preds = %669
%677 = load i32, i32* %18
store i32 %677, i32* %9
%678 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.17, i64 0, i64 0))
br label %679
679: ; preds = %676
br label %680
680: ; preds = %679, %665
br label %67
681: ; preds = %673, %72
%682 = load i32, i32* %10
%683 = load i32, i32* %9
%684 = add nsw i32 %683, 1
%685 = icmp eq i32 %682, %684
br i1 %685, label %686, label %724
686: ; preds = %681
%687 = load i32*, i32** %2
%688 = load i32, i32* %9
%689 = sext i32 %688 to i64
%690 = getelementptr inbounds i32, i32* %687, i64 %689
%691 = load i32, i32* %690
%692 = load i32*, i32** %2
%693 = load i32, i32* %10
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds i32, i32* %692, i64 %694
%696 = load i32, i32* %695
%697 = icmp sgt i32 %691, %696
br i1 %697, label %698, label %723
698: ; preds = %686
%699 = load i32, i32* %9
%700 = load i32, i32* %10
%701 = icmp ne i32 %699, %700
br i1 %701, label %702, label %722
702: ; preds = %698
%703 = load i32*, i32** %2
%704 = load i32, i32* %9
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds i32, i32* %703, i64 %705
%707 = load i32, i32* %706
store i32 %707, i32* %30
%708 = load i32*, i32** %2
%709 = load i32, i32* %10
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds i32, i32* %708, i64 %710
%712 = load i32, i32* %711
%713 = load i32*, i32** %2
%714 = load i32, i32* %9
%715 = sext i32 %714 to i64
%716 = getelementptr inbounds i32, i32* %713, i64 %715
store i32 %712, i32* %716
%717 = load i32, i32* %30
%718 = load i32*, i32** %2
%719 = load i32, i32* %10
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds i32, i32* %718, i64 %720
store i32 %717, i32* %721
br label %722
722: ; preds = %702, %698
br label %723
723: ; preds = %722, %686
br label %724
724: ; preds = %723, %681
%725 = load i32, i32* %9
store i32 %725, i32* %11
%726 = load i32*, i32** %2
%727 = load i32, i32* %11
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds i32, i32* %726, i64 %728
%730 = load i32, i32* %729
store i32 %730, i32* %19
%731 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.18, i64 0, i64 0))
%732 = load i32, i32* %6
store i32 %732, i32* %5
br label %733
733: ; preds = %750, %724
%734 = load i32, i32* %5
%735 = load i32, i32* %7
%736 = icmp sle i32 %734, %735
br i1 %736, label %737, label %753
737: ; preds = %733
%738 = load i32, i32* %5
%739 = load i32, i32* %11
%740 = icmp eq i32 %738, %739
br i1 %740, label %741, label %743
741: ; preds = %737
%742 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0))
br label %743
743: ; preds = %741, %737
%744 = load i32*, i32** %2
%745 = load i32, i32* %5
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds i32, i32* %744, i64 %746
%748 = load i32, i32* %747
%749 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %748)
br label %750
750: ; preds = %743
%751 = load i32, i32* %5
%752 = add nsw i32 %751, 1
store i32 %752, i32* %5
br label %733
753: ; preds = %733
%754 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%755 = load i32, i32* %6
store i32 %755, i32* %5
br label %756
756: ; preds = %770, %753
%757 = load i32, i32* %5
%758 = load i32, i32* %11
%759 = icmp slt i32 %757, %758
br i1 %759, label %760, label %773
760: ; preds = %756
%761 = load i32*, i32** %2
%762 = load i32, i32* %5
%763 = sext i32 %762 to i64
%764 = getelementptr inbounds i32, i32* %761, i64 %763
%765 = load i32, i32* %764
%766 = load i32, i32* %19
%767 = icmp slt i32 %765, %766
%768 = zext i1 %767 to i32
%769 = call i32 @assert(i32 %768)
br label %770
770: ; preds = %760
%771 = load i32, i32* %5
%772 = add nsw i32 %771, 1
store i32 %772, i32* %5
br label %756
773: ; preds = %756
%774 = load i32, i32* %11
store i32 %774, i32* %5
br label %775
775: ; preds = %789, %773
%776 = load i32, i32* %5
%777 = load i32, i32* %7
%778 = icmp sle i32 %776, %777
br i1 %778, label %779, label %792
779: ; preds = %775
%780 = load i32*, i32** %2
%781 = load i32, i32* %5
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds i32, i32* %780, i64 %782
%784 = load i32, i32* %783
%785 = load i32, i32* %19
%786 = icmp sge i32 %784, %785
%787 = zext i1 %786 to i32
%788 = call i32 @assert(i32 %787)
br label %789
789: ; preds = %779
%790 = load i32, i32* %5
%791 = add nsw i32 %790, 1
store i32 %791, i32* %5
br label %775
792: ; preds = %775
%793 = load i32*, i32** %2
%794 = call i32 @free(i32* %793)
ret i32 0
}

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