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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ ss_heapsort(unsigned char const *, int const *, int *, int);
void *ss_ilg(int);
int /*<<< orphan*/ ss_insertionsort(unsigned char const *, int const *, int *,
                                    int *, int);
int *ss_partition(int const *, int *, int *, int);
int *ss_pivot(unsigned char const *, int const *, int *, int *);
void ss_mintrosort(const unsigned char *T, const int *PA, int *first, int *last,
                   int depth) {
  struct {
    int *a, *b, c;
    int d;
  } stack[(16)];
  const unsigned char *Td;
  int *a, *b, *c, *d, *e, *f;
  int s, t;
  int ssize;
  int limit;
  int v, x = 0;
  for (ssize = 0, limit = ss_ilg(last - first);;) {
    if ((last - first) <= (8)) {
      if (1 < (last - first)) {
        ss_insertionsort(T, PA, first, last, depth);
      }
      do {
        assert(0 <= ssize);
        if (ssize == 0) {
          return;
        }
        (first) = stack[--ssize].a, (last) = stack[ssize].b,
        (depth) = stack[ssize].c, (limit) = stack[ssize].d;
      } while (0);
      continue;
    }
    Td = T + depth;
    if (limit-- == 0) {
      ss_heapsort(Td, PA, first, last - first);
    }
    if (limit < 0) {
      for (a = first + 1, v = Td[PA[*first]]; a < last; ++a) {
        if ((x = Td[PA[*a]]) != v) {
          if (1 < (a - first)) {
            break;
          }
          v = x;
          first = a;
        }
      }
      if (Td[PA[*first] - 1] < v) {
        first = ss_partition(PA, first, a, depth);
      }
      if ((a - first) <= (last - a)) {
        if (1 < (a - first)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (a), stack[ssize].b = (last),
            stack[ssize].c = (depth), stack[ssize++].d = (-1);
          } while (0);
          last = a, depth += 1, limit = ss_ilg(a - first);
        } else {
          first = a, limit = -1;
        }
      } else {
        if (1 < (last - a)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (first), stack[ssize].b = (a),
            stack[ssize].c = (depth + 1),
            stack[ssize++].d = (ss_ilg(a - first));
          } while (0);
          first = a, limit = -1;
        } else {
          last = a, depth += 1, limit = ss_ilg(a - first);
        }
      }
      continue;
    }
    a = ss_pivot(Td, PA, first, last);
    v = Td[PA[*a]];
    do {
      t = (*first);
      (*first) = (*a);
      (*a) = t;
    } while (0);
    for (b = first; (++b < last) && ((x = Td[PA[*b]]) == v);) {
    }
    if (((a = b) < last) && (x < v)) {
      for (; (++b < last) && ((x = Td[PA[*b]]) <= v);) {
        if (x == v) {
          do {
            t = (*b);
            (*b) = (*a);
            (*a) = t;
          } while (0);
          ++a;
        }
      }
    }
    for (c = last; (b < --c) && ((x = Td[PA[*c]]) == v);) {
    }
    if ((b < (d = c)) && (x > v)) {
      for (; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
        if (x == v) {
          do {
            t = (*c);
            (*c) = (*d);
            (*d) = t;
          } while (0);
          --d;
        }
      }
    }
    for (; b < c;) {
      do {
        t = (*b);
        (*b) = (*c);
        (*c) = t;
      } while (0);
      for (; (++b < c) && ((x = Td[PA[*b]]) <= v);) {
        if (x == v) {
          do {
            t = (*b);
            (*b) = (*a);
            (*a) = t;
          } while (0);
          ++a;
        }
      }
      for (; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
        if (x == v) {
          do {
            t = (*c);
            (*c) = (*d);
            (*d) = t;
          } while (0);
          --d;
        }
      }
    }
    if (a <= d) {
      c = b - 1;
      if ((s = a - first) > (t = b - a)) {
        s = t;
      }
      for (e = first, f = b - s; 0 < s; --s, ++e, ++f) {
        do {
          t = (*e);
          (*e) = (*f);
          (*f) = t;
        } while (0);
      }
      if ((s = d - c) > (t = last - d - 1)) {
        s = t;
      }
      for (e = b, f = last - s; 0 < s; --s, ++e, ++f) {
        do {
          t = (*e);
          (*e) = (*f);
          (*f) = t;
        } while (0);
      }
      a = first + (b - a), c = last - (d - c);
      b = (v <= Td[PA[*a] - 1]) ? a : ss_partition(PA, a, c, depth);
      if ((a - first) <= (last - c)) {
        if ((last - c) <= (c - b)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (b), stack[ssize].b = (c),
            stack[ssize].c = (depth + 1), stack[ssize++].d = (ss_ilg(c - b));
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (c), stack[ssize].b = (last),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          last = a;
        } else if ((a - first) <= (c - b)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (c), stack[ssize].b = (last),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (b), stack[ssize].b = (c),
            stack[ssize].c = (depth + 1), stack[ssize++].d = (ss_ilg(c - b));
          } while (0);
          last = a;
        } else {
          do {
            assert(ssize < (16));
            stack[ssize].a = (c), stack[ssize].b = (last),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (first), stack[ssize].b = (a),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
        }
      } else {
        if ((a - first) <= (c - b)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (b), stack[ssize].b = (c),
            stack[ssize].c = (depth + 1), stack[ssize++].d = (ss_ilg(c - b));
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (first), stack[ssize].b = (a),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          first = c;
        } else if ((last - c) <= (c - b)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (first), stack[ssize].b = (a),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (b), stack[ssize].b = (c),
            stack[ssize].c = (depth + 1), stack[ssize++].d = (ss_ilg(c - b));
          } while (0);
          first = c;
        } else {
          do {
            assert(ssize < (16));
            stack[ssize].a = (first), stack[ssize].b = (a),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (c), stack[ssize].b = (last),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
        }
      }
    } else {
      limit += 1;
      if (Td[PA[*first] - 1] < v) {
        first = ss_partition(PA, first, last, depth);
        limit = ss_ilg(last - first);
      }
      depth += 1;
    }
  }
}


x86 assembly (clang, -O0):
<ss_mintrosort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x210,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movl   $0x0,-0x200(%rbp)
movl   $0x0,-0x1f4(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edi
call   1030 <ss_ilg@plt>
mov    %eax,-0x1f8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
cmp    $0x8,%rax
jg     12b0 <ss_mintrosort+0x150>
mov    -0x20(%rbp),%rcx
mov    -0x18(%rbp),%rax
sub    %rax,%rcx
sar    $0x2,%rcx
mov    $0x1,%eax
cmp    %rcx,%rax
jge    11fe <ss_mintrosort+0x9e>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%r8d
call   1040 <ss_insertionsort@plt>
jmp    1203 <ss_mintrosort+0xa3>
xor    %eax,%eax
cmp    -0x1f4(%rbp),%eax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
cmpl   $0x0,-0x1f4(%rbp)
jne    122e <ss_mintrosort+0xce>
add    $0x210,%rsp
pop    %rbp
ret
mov    -0x1f4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1f4(%rbp)
movslq %eax,%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%rax
mov    %rax,-0x18(%rbp)
movslq -0x1f4(%rbp),%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%rax
mov    %rax,-0x20(%rbp)
movslq -0x1f4(%rbp),%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x10(%rax),%eax
mov    %eax,-0x24(%rbp)
movslq -0x1f4(%rbp),%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x14(%rax),%eax
mov    %eax,-0x1f8(%rbp)
jmp    11af <ss_mintrosort+0x4f>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x1f8(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1f8(%rbp)
cmp    $0x0,%eax
jne    1301 <ss_mintrosort+0x1a1>
mov    -0x1b8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%ecx
call   1070 <ss_heapsort@plt>
cmpl   $0x0,-0x1f8(%rbp)
jge    167d <ss_mintrosort+0x51d>
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x1b8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
movslq (%rdx),%rdx
movslq (%rcx,%rdx,4),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x1fc(%rbp)
mov    -0x1c0(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    13d5 <ss_mintrosort+0x275>
mov    -0x1b8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x1c0(%rbp),%rdx
movslq (%rdx),%rdx
movslq (%rcx,%rdx,4),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x200(%rbp)
cmp    -0x1fc(%rbp),%eax
je     13b9 <ss_mintrosort+0x259>
mov    -0x1c0(%rbp),%rcx
mov    -0x18(%rbp),%rax
sub    %rax,%rcx
sar    $0x2,%rcx
mov    $0x1,%eax
cmp    %rcx,%rax
jge    13a2 <ss_mintrosort+0x242>
jmp    13d5 <ss_mintrosort+0x275>
mov    -0x200(%rbp),%eax
mov    %eax,-0x1fc(%rbp)
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    13be <ss_mintrosort+0x25e>
mov    -0x1c0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1c0(%rbp)
jmp    133d <ss_mintrosort+0x1dd>
mov    -0x1b8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
movslq (%rdx),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    -0x1fc(%rbp),%eax
jge    141b <ss_mintrosort+0x2bb>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c0(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1060 <ss_partition@plt>
mov    %rax,-0x18(%rbp)
mov    -0x1c0(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    -0x20(%rbp),%rcx
mov    -0x1c0(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%rax
jg     1553 <ss_mintrosort+0x3f3>
mov    -0x1c0(%rbp),%rcx
mov    -0x18(%rbp),%rax
sub    %rax,%rcx
sar    $0x2,%rcx
mov    $0x1,%eax
cmp    %rcx,%rax
jge    1539 <ss_mintrosort+0x3d9>
jmp    146d <ss_mintrosort+0x30d>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x1c0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1f4(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x1f4(%rbp)
movslq %eax,%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movl   $0xffffffff,0x14(%rax)
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c0(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edi
call   1030 <ss_ilg@plt>
mov    %eax,-0x1f8(%rbp)
jmp    154e <ss_mintrosort+0x3ee>
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x18(%rbp)
movl   $0xffffffff,-0x1f8(%rbp)
ff ff ff
jmp    1678 <ss_mintrosort+0x518>
mov    -0x20(%rbp),%rcx
mov    -0x1c0(%rbp),%rax
sub    %rax,%rcx
sar    $0x2,%rcx
mov    $0x1,%eax
cmp    %rcx,%rax
jge    1640 <ss_mintrosort+0x4e0>
jmp    1578 <ss_mintrosort+0x418>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x18(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x1c0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1c0(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edi
call   1030 <ss_ilg@plt>
mov    %eax,%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x18(%rbp)
movl   $0xffffffff,-0x1f8(%rbp)
ff ff ff
jmp    1673 <ss_mintrosort+0x513>
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c0(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edi
call   1030 <ss_ilg@plt>
mov    %eax,-0x1f8(%rbp)
jmp    1678 <ss_mintrosort+0x518>
jmp    11af <ss_mintrosort+0x4f>
mov    -0x1b8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1080 <ss_pivot@plt>
mov    %rax,-0x1c0(%rbp)
mov    -0x1b8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x1c0(%rbp),%rdx
movslq (%rdx),%rdx
movslq (%rcx,%rdx,4),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x1fc(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f0(%rbp)
mov    -0x1c0(%rbp),%rax
mov    (%rax),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1f0(%rbp),%ecx
mov    -0x1c0(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x1c8(%rbp),%rcx
add    $0x4,%rcx
mov    %rcx,-0x1c8(%rbp)
xor    %eax,%eax
cmp    -0x20(%rbp),%rcx
mov    %al,-0x201(%rbp)
jae    174a <ss_mintrosort+0x5ea>
mov    -0x1b8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x1c8(%rbp),%rdx
movslq (%rdx),%rdx
movslq (%rcx,%rdx,4),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x200(%rbp)
cmp    -0x1fc(%rbp),%eax
sete   %al
mov    %al,-0x201(%rbp)
mov    -0x201(%rbp),%al
test   $0x1,%al
jne    175d <ss_mintrosort+0x5fd>
jmp    1762 <ss_mintrosort+0x602>
jmp    16f4 <ss_mintrosort+0x594>
mov    -0x1c8(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
cmp    -0x20(%rbp),%rax
jae    185d <ss_mintrosort+0x6fd>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jge    185d <ss_mintrosort+0x6fd>
jmp    1791 <ss_mintrosort+0x631>
mov    -0x1c8(%rbp),%rcx
add    $0x4,%rcx
mov    %rcx,-0x1c8(%rbp)
xor    %eax,%eax
cmp    -0x20(%rbp),%rcx
mov    %al,-0x202(%rbp)
jae    17e7 <ss_mintrosort+0x687>
mov    -0x1b8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x1c8(%rbp),%rdx
movslq (%rdx),%rdx
movslq (%rcx,%rdx,4),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x200(%rbp)
cmp    -0x1fc(%rbp),%eax
setle  %al
mov    %al,-0x202(%rbp)
mov    -0x202(%rbp),%al
test   $0x1,%al
jne    17fa <ss_mintrosort+0x69a>
jmp    1858 <ss_mintrosort+0x6f8>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jne    1853 <ss_mintrosort+0x6f3>
jmp    1811 <ss_mintrosort+0x6b1>
mov    -0x1c8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f0(%rbp)
mov    -0x1c0(%rbp),%rax
mov    (%rax),%ecx
mov    -0x1c8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1f0(%rbp),%ecx
mov    -0x1c0(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1c0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1c0(%rbp)
jmp    1791 <ss_mintrosort+0x631>
jmp    185d <ss_mintrosort+0x6fd>
mov    -0x20(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x1c8(%rbp),%rcx
mov    -0x1d0(%rbp),%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x1d0(%rbp)
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x203(%rbp)
jae    18c4 <ss_mintrosort+0x764>
mov    -0x1b8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x1d0(%rbp),%rdx
movslq (%rdx),%rdx
movslq (%rcx,%rdx,4),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x200(%rbp)
cmp    -0x1fc(%rbp),%eax
sete   %al
mov    %al,-0x203(%rbp)
mov    -0x203(%rbp),%al
test   $0x1,%al
jne    18d7 <ss_mintrosort+0x777>
jmp    18dc <ss_mintrosort+0x77c>
jmp    1868 <ss_mintrosort+0x708>
mov    -0x1c8(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
mov    %rcx,-0x1d8(%rbp)
cmp    %rcx,%rax
jae    19e3 <ss_mintrosort+0x883>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jle    19e3 <ss_mintrosort+0x883>
jmp    1911 <ss_mintrosort+0x7b1>
mov    -0x1c8(%rbp),%rcx
mov    -0x1d0(%rbp),%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x1d0(%rbp)
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x204(%rbp)
jae    196d <ss_mintrosort+0x80d>
mov    -0x1b8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x1d0(%rbp),%rdx
movslq (%rdx),%rdx
movslq (%rcx,%rdx,4),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x200(%rbp)
cmp    -0x1fc(%rbp),%eax
setge  %al
mov    %al,-0x204(%rbp)
mov    -0x204(%rbp),%al
test   $0x1,%al
jne    1980 <ss_mintrosort+0x820>
jmp    19de <ss_mintrosort+0x87e>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jne    19d9 <ss_mintrosort+0x879>
jmp    1997 <ss_mintrosort+0x837>
mov    -0x1d0(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f0(%rbp)
mov    -0x1d8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x1d0(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1f0(%rbp),%ecx
mov    -0x1d8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1d8(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x1d8(%rbp)
jmp    1911 <ss_mintrosort+0x7b1>
jmp    19e3 <ss_mintrosort+0x883>
jmp    19e8 <ss_mintrosort+0x888>
mov    -0x1c8(%rbp),%rax
cmp    -0x1d0(%rbp),%rax
jae    1bd7 <ss_mintrosort+0xa77>
jmp    1a01 <ss_mintrosort+0x8a1>
mov    -0x1c8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f0(%rbp)
mov    -0x1d0(%rbp),%rax
mov    (%rax),%ecx
mov    -0x1c8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1f0(%rbp),%ecx
mov    -0x1d0(%rbp),%rax
mov    %ecx,(%rax)
jmp    1a36 <ss_mintrosort+0x8d6>
mov    -0x1c8(%rbp),%rcx
add    $0x4,%rcx
mov    %rcx,-0x1c8(%rbp)
xor    %eax,%eax
cmp    -0x1d0(%rbp),%rcx
mov    %al,-0x205(%rbp)
jae    1a8f <ss_mintrosort+0x92f>
mov    -0x1b8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x1c8(%rbp),%rdx
movslq (%rdx),%rdx
movslq (%rcx,%rdx,4),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x200(%rbp)
cmp    -0x1fc(%rbp),%eax
setle  %al
mov    %al,-0x205(%rbp)
mov    -0x205(%rbp),%al
test   $0x1,%al
jne    1aa2 <ss_mintrosort+0x942>
jmp    1b00 <ss_mintrosort+0x9a0>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jne    1afb <ss_mintrosort+0x99b>
jmp    1ab9 <ss_mintrosort+0x959>
mov    -0x1c8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f0(%rbp)
mov    -0x1c0(%rbp),%rax
mov    (%rax),%ecx
mov    -0x1c8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1f0(%rbp),%ecx
mov    -0x1c0(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1c0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1c0(%rbp)
jmp    1a36 <ss_mintrosort+0x8d6>
jmp    1b05 <ss_mintrosort+0x9a5>
mov    -0x1c8(%rbp),%rcx
mov    -0x1d0(%rbp),%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x1d0(%rbp)
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x206(%rbp)
jae    1b61 <ss_mintrosort+0xa01>
mov    -0x1b8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x1d0(%rbp),%rdx
movslq (%rdx),%rdx
movslq (%rcx,%rdx,4),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x200(%rbp)
cmp    -0x1fc(%rbp),%eax
setge  %al
mov    %al,-0x206(%rbp)
mov    -0x206(%rbp),%al
test   $0x1,%al
jne    1b74 <ss_mintrosort+0xa14>
jmp    1bd2 <ss_mintrosort+0xa72>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jne    1bcd <ss_mintrosort+0xa6d>
jmp    1b8b <ss_mintrosort+0xa2b>
mov    -0x1d0(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f0(%rbp)
mov    -0x1d8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x1d0(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1f0(%rbp),%ecx
mov    -0x1d8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1d8(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x1d8(%rbp)
jmp    1b05 <ss_mintrosort+0x9a5>
jmp    19e8 <ss_mintrosort+0x888>
mov    -0x1c0(%rbp),%rax
cmp    -0x1d8(%rbp),%rax
ja     2830 <ss_mintrosort+0x16d0>
mov    -0x1c8(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x1c0(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x1ec(%rbp)
mov    -0x1c8(%rbp),%rcx
mov    -0x1c0(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
mov    %ecx,-0x1f0(%rbp)
cmp    %ecx,%eax
jle    1c44 <ss_mintrosort+0xae4>
mov    -0x1f0(%rbp),%eax
mov    %eax,-0x1ec(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x1c8(%rbp),%rax
movslq -0x1ec(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x1e8(%rbp)
xor    %eax,%eax
cmp    -0x1ec(%rbp),%eax
jge    1cf0 <ss_mintrosort+0xb90>
jmp    1c83 <ss_mintrosort+0xb23>
mov    -0x1e0(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f0(%rbp)
mov    -0x1e8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x1e0(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1f0(%rbp),%ecx
mov    -0x1e8(%rbp),%rax
mov    %ecx,(%rax)
jmp    1cb8 <ss_mintrosort+0xb58>
mov    -0x1ec(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1ec(%rbp)
mov    -0x1e0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x1e8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1e8(%rbp)
jmp    1c70 <ss_mintrosort+0xb10>
mov    -0x1d8(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x1ec(%rbp)
mov    -0x20(%rbp),%rcx
mov    -0x1d8(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
sub    $0x1,%rcx
mov    %ecx,-0x1f0(%rbp)
cmp    %ecx,%eax
jle    1d3b <ss_mintrosort+0xbdb>
mov    -0x1f0(%rbp),%eax
mov    %eax,-0x1ec(%rbp)
mov    -0x1c8(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x1ec(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x1e8(%rbp)
xor    %eax,%eax
cmp    -0x1ec(%rbp),%eax
jge    1de7 <ss_mintrosort+0xc87>
jmp    1d7a <ss_mintrosort+0xc1a>
mov    -0x1e0(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f0(%rbp)
mov    -0x1e8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x1e0(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1f0(%rbp),%ecx
mov    -0x1e8(%rbp),%rax
mov    %ecx,(%rax)
jmp    1daf <ss_mintrosort+0xc4f>
mov    -0x1ec(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1ec(%rbp)
mov    -0x1e0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x1e8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1e8(%rbp)
jmp    1d67 <ss_mintrosort+0xc07>
mov    -0x18(%rbp),%rax
mov    -0x1c8(%rbp),%rcx
mov    -0x1c0(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x1d8(%rbp),%rdx
mov    -0x1d0(%rbp),%rcx
sub    %rcx,%rdx
sar    $0x2,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x1fc(%rbp),%eax
mov    -0x1b8(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    -0x1c0(%rbp),%rsi
movslq (%rsi),%rsi
mov    (%rdx,%rsi,4),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jg     1e7d <ss_mintrosort+0xd1d>
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x210(%rbp)
jmp    1e9e <ss_mintrosort+0xd3e>
mov    -0x10(%rbp),%rdi
mov    -0x1c0(%rbp),%rsi
mov    -0x1d0(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1060 <ss_partition@plt>
mov    %rax,-0x210(%rbp)
mov    -0x210(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x1c0(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    -0x20(%rbp),%rcx
mov    -0x1d0(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%rax
jg     2382 <ss_mintrosort+0x1222>
mov    -0x20(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    -0x1d0(%rbp),%rcx
mov    -0x1c8(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%rax
jg     206d <ss_mintrosort+0xf0d>
jmp    1f0e <ss_mintrosort+0xdae>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x1c8(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x1d0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1d0(%rbp),%rax
mov    -0x1c8(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edi
call   1030 <ss_ilg@plt>
mov    %eax,%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
jmp    1fc7 <ss_mintrosort+0xe67>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x1d0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1f8(%rbp),%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    237d <ss_mintrosort+0x121d>
mov    -0x1c0(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    -0x1d0(%rbp),%rcx
mov    -0x1c8(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%rax
jg     2201 <ss_mintrosort+0x10a1>
jmp    20a2 <ss_mintrosort+0xf42>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x1d0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1f8(%rbp),%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
jmp    213d <ss_mintrosort+0xfdd>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x1c8(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x1d0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1d0(%rbp),%rax
mov    -0x1c8(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edi
call   1030 <ss_ilg@plt>
mov    %eax,%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    2378 <ss_mintrosort+0x1218>
jmp    2206 <ss_mintrosort+0x10a6>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x1d0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1f8(%rbp),%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
jmp    22a1 <ss_mintrosort+0x1141>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x18(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x1c0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1f8(%rbp),%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
mov    -0x1c8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x1d0(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1d0(%rbp),%rax
mov    -0x1c8(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edi
call   1030 <ss_ilg@plt>
mov    %eax,-0x1f8(%rbp)
jmp    237d <ss_mintrosort+0x121d>
jmp    282b <ss_mintrosort+0x16cb>
mov    -0x1c0(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    -0x1d0(%rbp),%rcx
mov    -0x1c8(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%rax
jg     2516 <ss_mintrosort+0x13b6>
jmp    23b7 <ss_mintrosort+0x1257>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x1c8(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x1d0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1d0(%rbp),%rax
mov    -0x1c8(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edi
call   1030 <ss_ilg@plt>
mov    %eax,%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
jmp    2470 <ss_mintrosort+0x1310>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x18(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x1c0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1f8(%rbp),%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
mov    -0x1d0(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    2826 <ss_mintrosort+0x16c6>
mov    -0x20(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    -0x1d0(%rbp),%rcx
mov    -0x1c8(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%rax
jg     26aa <ss_mintrosort+0x154a>
jmp    254b <ss_mintrosort+0x13eb>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x18(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x1c0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1f8(%rbp),%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
jmp    25e6 <ss_mintrosort+0x1486>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x1c8(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x1d0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1d0(%rbp),%rax
mov    -0x1c8(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edi
call   1030 <ss_ilg@plt>
mov    %eax,%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
mov    -0x1d0(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    2821 <ss_mintrosort+0x16c1>
jmp    26af <ss_mintrosort+0x154f>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x18(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x1c0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1f8(%rbp),%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
jmp    274a <ss_mintrosort+0x15ea>
cmpl   $0x10,-0x1f4(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x1d0(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rcx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x1f4(%rbp),%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x10(%rax)
mov    -0x1f8(%rbp),%ecx
mov    -0x1f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1f4(%rbp)
movslq %eax,%rdx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x14(%rax)
mov    -0x1c8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x1d0(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1d0(%rbp),%rax
mov    -0x1c8(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edi
call   1030 <ss_ilg@plt>
mov    %eax,-0x1f8(%rbp)
jmp    2826 <ss_mintrosort+0x16c6>
jmp    282b <ss_mintrosort+0x16cb>
jmp    28a7 <ss_mintrosort+0x1747>
mov    -0x1f8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f8(%rbp)
mov    -0x1b8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
movslq (%rdx),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    -0x1fc(%rbp),%eax
jge    289e <ss_mintrosort+0x173e>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1060 <ss_partition@plt>
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edi
call   1030 <ss_ilg@plt>
mov    %eax,-0x1f8(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11af <ss_mintrosort+0x4f>

x86 assembly (clang, -O2):
<ss_mintrosort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1d8,%rsp
mov    %r8,0x8(%rsp)
mov    %rcx,%rbx
mov    %rdx,%r12
mov    %rsi,%r15
mov    %rdi,0x48(%rsp)
mov    %rcx,%rdi
sub    %rdx,%rdi
shr    $0x2,%rdi
call   1030 <ss_ilg@plt>
mov    %rbx,%r11
xor    %ebx,%ebx
mov    %r11,%rcx
sub    %r12,%rcx
cmp    $0x23,%rcx
jg     1230 <ss_mintrosort+0xd0>
mov    %rbx,0x28(%rsp)
movslq %ebx,%r14
mov    %r14d,%r13d
not    %r13d
lea    (%r14,%r14,2),%rax
lea    0x38(%rsp),%rdx
lea    (%rdx,%rax,8),%rbx
xor    %ebp,%ebp
mov    0x8(%rsp),%r8
nopw   0x0(%rax,%rax,1)
cmp    $0x5,%rcx
jl     11e9 <ss_mintrosort+0x89>
mov    0x48(%rsp),%rdi
mov    %r15,%rsi
mov    %r12,%rdx
mov    %r11,%rcx
call   1040 <ss_insertionsort@plt>
lea    0x0(%r13,%rbp,1),%edi
shr    $0x1f,%edi
call   1050 <assert@plt>
cmp    %rbp,%r14
je     1c81 <ss_mintrosort+0xb21>
mov    (%rbx),%r12
mov    0x8(%rbx),%r11
mov    0x10(%rbx),%r8d
mov    %r11,%rcx
sub    %r12,%rcx
add    $0x1,%rbp
add    $0xffffffffffffffe8,%rbx
cmp    $0x24,%rcx
jl     11d0 <ss_mintrosort+0x70>
mov    0x2c(%rbx),%eax
mov    0x28(%rsp),%rbx
sub    %ebp,%ebx
mov    %r11,%rdx
mov    %r12,%rbp
jmp    123b <ss_mintrosort+0xdb>
mov    %r11,%rdx
mov    %r12,%rbp
mov    0x8(%rsp),%r8
mov    %r8,0x8(%rsp)
movslq %r8d,%r14
add    0x48(%rsp),%r14
mov    %eax,%esi
sub    $0x1,%esi
mov    %r11,0x20(%rsp)
mov    %rdx,0x18(%rsp)
jae    1280 <ss_mintrosort+0x120>
shr    $0x2,%rcx
mov    %r14,%rdi
mov    %r15,%rsi
mov    %rbp,%rdx
call   1070 <ss_heapsort@plt>
mov    0x20(%rsp),%r11
jmp    12f0 <ss_mintrosort+0x190>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
jl     12f0 <ss_mintrosort+0x190>
mov    %rax,0x38(%rsp)
mov    %esi,0x14(%rsp)
mov    %r14,%rdi
mov    %r15,%rsi
mov    %rbp,%rdx
mov    %r11,%rcx
call   1080 <ss_pivot@plt>
mov    0x20(%rsp),%r11
movslq (%rax),%rdx
movslq (%r15,%rdx,4),%rcx
mov    (%r14,%rcx,1),%cl
mov    0x0(%rbp),%esi
mov    %edx,0x0(%rbp)
mov    %esi,(%rax)
lea    0x4(%rbp),%rdx
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rax
cmp    %r11,%rdx
jae    14b0 <ss_mintrosort+0x350>
movslq (%rdx),%rax
movslq (%r15,%rax,4),%rax
cmp    %cl,(%r14,%rax,1)
jne    146f <ss_mintrosort+0x30f>
add    $0x4,%rdx
jmp    12c0 <ss_mintrosort+0x160>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq 0x0(%rbp),%rax
movslq (%r15,%rax,4),%rax
movzbl (%r14,%rax,1),%edx
lea    0x4(%rbp),%r12
cmp    %r11,%r12
jae    1347 <ss_mintrosort+0x1e7>
lea    0x4(%rbp),%rax
jmp    1327 <ss_mintrosort+0x1c7>
nopl   0x0(%rax)
mov    %rbp,%r13
mov    %edx,%ecx
add    $0x4,%r12
add    $0x4,%rax
mov    %ecx,%edx
mov    %r13,%rbp
cmp    %r11,%r12
jae    134c <ss_mintrosort+0x1ec>
movslq (%r12),%rcx
movslq (%r15,%rcx,4),%rcx
movzbl (%r14,%rcx,1),%ecx
cmp    %ecx,%edx
je     1310 <ss_mintrosort+0x1b0>
mov    %rax,%rsi
sub    %rbp,%rsi
mov    %r12,%r13
cmp    $0x4,%rsi
jle    1315 <ss_mintrosort+0x1b5>
mov    %rbp,%r13
mov    %edx,%ecx
movslq 0x0(%r13),%rax
movslq (%r15,%rax,4),%rax
movzbl -0x1(%rax,%r14,1),%eax
cmp    %eax,%ecx
jle    1379 <ss_mintrosort+0x219>
mov    %r15,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    0x8(%rsp),%rcx
call   1060 <ss_partition@plt>
mov    0x20(%rsp),%r11
mov    %rax,%r13
mov    0x18(%rsp),%rdx
mov    %r12,%rsi
sub    %r13,%rsi
mov    %rsi,%r14
sar    $0x2,%r14
sub    %r12,%rdx
mov    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%r14
jle    1400 <ss_mintrosort+0x2a0>
cmp    $0x5,%rdx
jl     144f <ss_mintrosort+0x2ef>
xor    %edi,%edi
cmp    $0x10,%ebx
setl   %dil
call   1050 <assert@plt>
movslq %ebx,%rax
mov    %rbx,%rbp
lea    (%rax,%rax,2),%rbx
mov    %r13,0x50(%rsp,%rbx,8)
mov    %r12,0x58(%rsp,%rbx,8)
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x60(%rsp,%rbx,8)
mov    %r14d,%edi
call   1030 <ss_ilg@plt>
mov    0x20(%rsp),%r11
add    $0x1,%ebp
mov    %eax,0x64(%rsp,%rbx,8)
mov    %rbp,%rbx
mov    $0xffffffff,%eax
jmp    1198 <ss_mintrosort+0x38>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0xffffffff,%eax
cmp    $0x5,%rsi
jl     1198 <ss_mintrosort+0x38>
xor    %edi,%edi
cmp    $0x10,%ebx
setl   %dil
mov    %r11,%rbp
call   1050 <assert@plt>
movslq %ebx,%rax
lea    (%rax,%rax,2),%rax
mov    %r12,0x50(%rsp,%rax,8)
mov    %rbp,0x58(%rsp,%rax,8)
mov    0x8(%rsp),%rcx
mov    %ecx,0x60(%rsp,%rax,8)
add    $0x1,%ebx
movl   $0xffffffff,0x64(%rsp,%rax,8)
ff
add    $0x1,%ecx
mov    %rcx,0x8(%rsp)
jmp    145c <ss_mintrosort+0x2fc>
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x8(%rsp)
mov    %r14d,%edi
call   1030 <ss_ilg@plt>
mov    %r12,%r11
mov    %r13,%r12
jmp    1198 <ss_mintrosort+0x38>
jae    14a4 <ss_mintrosort+0x344>
lea    0x4(%rdx),%rax
jmp    1484 <ss_mintrosort+0x324>
nopw   0x0(%rax,%rax,1)
add    $0x4,%rax
cmp    %r11,%rax
jae    14b0 <ss_mintrosort+0x350>
movslq (%rax),%rsi
movslq (%r15,%rsi,4),%rdi
cmp    %cl,(%r14,%rdi,1)
ja     14b0 <ss_mintrosort+0x350>
jne    1480 <ss_mintrosort+0x320>
mov    (%rdx),%edi
mov    %edi,(%rax)
mov    %esi,(%rdx)
add    $0x4,%rdx
jmp    1480 <ss_mintrosort+0x320>
mov    %rdx,%rax
nopw   0x0(%rax,%rax,1)
lea    -0x4(%r11),%r13
mov    %r13,%rsi
cmp    %r13,%rax
mov    %rbp,0x30(%rsp)
jae    15a6 <ss_mintrosort+0x446>
cs nopw 0x0(%rax,%rax,1)
nop
movslq 0x0(%r13),%rsi
movslq (%r15,%rsi,4),%rsi
cmp    %cl,(%r14,%rsi,1)
jne    14ef <ss_mintrosort+0x38f>
add    $0xfffffffffffffffc,%r13
mov    %r13,%rsi
cmp    %r13,%rax
jb     14d0 <ss_mintrosort+0x370>
jmp    15a6 <ss_mintrosort+0x446>
jbe    1530 <ss_mintrosort+0x3d0>
lea    -0x4(%r13),%rsi
jmp    1504 <ss_mintrosort+0x3a4>
nopw   0x0(%rax,%rax,1)
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%rax
jae    15a6 <ss_mintrosort+0x446>
movslq (%rsi),%rdi
movslq (%r15,%rdi,4),%rbp
cmp    %cl,(%r14,%rbp,1)
jb     15a6 <ss_mintrosort+0x446>
jne    1500 <ss_mintrosort+0x3a0>
mov    0x0(%r13),%ebp
mov    %ebp,(%rsi)
mov    %edi,0x0(%r13)
add    $0xfffffffffffffffc,%r13
jmp    1500 <ss_mintrosort+0x3a0>
mov    %r13,%rsi
jmp    15a6 <ss_mintrosort+0x446>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rax),%edi
mov    (%rsi),%ebp
mov    %ebp,(%rax)
mov    %edi,(%rsi)
nopl   0x0(%rax,%rax,1)
add    $0x4,%rax
cmp    %rsi,%rax
jae    1590 <ss_mintrosort+0x430>
movslq (%rax),%rdi
movslq (%r15,%rdi,4),%rbp
cmp    %cl,(%r14,%rbp,1)
ja     1590 <ss_mintrosort+0x430>
jne    1550 <ss_mintrosort+0x3f0>
mov    (%rdx),%ebp
mov    %ebp,(%rax)
mov    %edi,(%rdx)
add    $0x4,%rdx
jmp    1550 <ss_mintrosort+0x3f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
jne    1590 <ss_mintrosort+0x430>
mov    0x0(%r13),%ebp
mov    %ebp,(%rsi)
mov    %edi,0x0(%r13)
add    $0xfffffffffffffffc,%r13
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%rax
jae    15a6 <ss_mintrosort+0x446>
movslq (%rsi),%rdi
movslq (%r15,%rdi,4),%rbp
cmp    %cl,(%r14,%rbp,1)
jae    1580 <ss_mintrosort+0x420>
cmp    %rsi,%rax
jb     1540 <ss_mintrosort+0x3e0>
cmp    %r13,%rdx
jbe    15f8 <ss_mintrosort+0x498>
mov    0x30(%rsp),%r12
movslq (%r12),%rax
movslq (%r15,%rax,4),%rax
cmp    %cl,-0x1(%rax,%r14,1)
jae    164d <ss_mintrosort+0x4ed>
mov    %r15,%rdi
mov    %r12,%rsi
mov    %r11,%rdx
mov    0x8(%rsp),%rbp
mov    %ebp,%ecx
call   1060 <ss_partition@plt>
mov    %rax,%r12
mov    0x18(%rsp),%rdi
sub    %rax,%rdi
shr    $0x2,%rdi
call   1030 <ss_ilg@plt>
mov    0x20(%rsp),%r11
jmp    1657 <ss_mintrosort+0x4f7>
mov    %rbx,0x28(%rsp)
lea    -0x4(%rax),%r9
mov    %rax,%rsi
sub    %rdx,%rsi
sub    %r12,%rdx
shr    $0x2,%rdx
sar    $0x2,%rsi
cmp    %esi,%edx
mov    %rsi,0x40(%rsp)
cmovg  %esi,%edx
test   %edx,%edx
jle    179a <ss_mintrosort+0x63a>
mov    %edx,%esi
lea    0x0(,%rsi,4),%rdi
mov    %rax,%r12
sub    %rdi,%r12
lea    -0x1(%rdx),%r11d
cmp    $0x7,%r11d
jae    1664 <ss_mintrosort+0x504>
mov    0x30(%rsp),%rsi
mov    0x20(%rsp),%r11
jmp    1773 <ss_mintrosort+0x613>
mov    0x8(%rsp),%rbp
mov    0x38(%rsp),%rax
add    $0x1,%ebp
mov    %rbp,0x8(%rsp)
jmp    1198 <ss_mintrosort+0x38>
mov    %r11,%rdi
sub    %rsi,%rdi
lea    (%rax,%rdi,4),%rdi
add    $0x4,%rdi
mov    0x30(%rsp),%rbx
cmp    %rdi,%rbx
jae    1696 <ss_mintrosort+0x536>
lea    (%rbx,%r11,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%r12
jae    1696 <ss_mintrosort+0x536>
mov    %rbx,%rsi
mov    0x20(%rsp),%r11
jmp    1773 <ss_mintrosort+0x613>
add    $0x1,%r11
mov    %r11,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdi
mov    %rdi,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rdi,%rdi
je     1c5f <ss_mintrosort+0xaff>
neg    %rsi
mov    %r10,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rax,%rsi,4),%rdi
add    $0x30,%rdi
xor    %esi,%esi
nopl   (%rax)
movups (%rbx,%rsi,4),%xmm0
movups 0x10(%rbx,%rsi,4),%xmm1
movups -0x30(%rdi,%rsi,4),%xmm2
movups -0x20(%rdi,%rsi,4),%xmm3
movups %xmm2,(%rbx,%rsi,4)
movups %xmm3,0x10(%rbx,%rsi,4)
movups %xmm0,-0x30(%rdi,%rsi,4)
movups %xmm1,-0x20(%rdi,%rsi,4)
movups 0x20(%rbx,%rsi,4),%xmm0
movups 0x30(%rbx,%rsi,4),%xmm1
movups -0x10(%rdi,%rsi,4),%xmm2
movups (%rdi,%rsi,4),%xmm3
movups %xmm2,0x20(%rbx,%rsi,4)
movups %xmm3,0x30(%rbx,%rsi,4)
movups %xmm0,-0x10(%rdi,%rsi,4)
movups %xmm1,(%rdi,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rbp
jne    16d0 <ss_mintrosort+0x570>
test   $0x1,%r10b
je     1759 <ss_mintrosort+0x5f9>
mov    0x30(%rsp),%rdi
movups (%rdi,%rsi,4),%xmm0
movups 0x10(%rdi,%rsi,4),%xmm1
movups (%r12,%rsi,4),%xmm2
movups 0x10(%r12,%rsi,4),%xmm3
movups %xmm2,(%rdi,%rsi,4)
movups %xmm3,0x10(%rdi,%rsi,4)
movups %xmm0,(%r12,%rsi,4)
movups %xmm1,0x10(%r12,%rsi,4)
cmp    %r8,%r11
mov    0x20(%rsp),%r11
je     179a <ss_mintrosort+0x63a>
sub    %r8d,%edx
lea    (%r12,%r8,4),%r12
mov    0x30(%rsp),%rsi
lea    (%rsi,%r8,4),%rsi
add    $0x1,%edx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rdi,1),%ebp
mov    (%r12,%rdi,1),%ebx
mov    %ebx,(%rsi,%rdi,1)
mov    %ebp,(%r12,%rdi,1)
add    $0xffffffff,%edx
add    $0x4,%rdi
cmp    $0x1,%edx
ja     1780 <ss_mintrosort+0x620>
mov    0x18(%rsp),%rbx
sub    %r13,%rbx
sub    %r9,%r13
sar    $0x2,%r13
shr    $0x2,%rbx
add    $0xffffffff,%ebx
cmp    %r13d,%ebx
cmovge %r13d,%ebx
test   %ebx,%ebx
jle    18f8 <ss_mintrosort+0x798>
mov    %ebx,%edi
lea    0x0(,%rdi,4),%rsi
mov    %r11,%rdx
sub    %rsi,%rdx
lea    -0x1(%rbx),%r10d
cmp    $0x7,%r10d
jb     18d0 <ss_mintrosort+0x770>
mov    %r10,%rsi
sub    %rdi,%rsi
lea    (%r11,%rsi,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rax
jae    1801 <ss_mintrosort+0x6a1>
lea    (%rax,%r10,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rdx
jb     18d0 <ss_mintrosort+0x770>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1c70 <ss_mintrosort+0xb10>
neg    %rdi
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%r11,%rdi,4),%rsi
add    $0x30,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movups -0x30(%rsi,%rdi,4),%xmm2
movups -0x20(%rsi,%rdi,4),%xmm3
movups %xmm2,(%rax,%rdi,4)
movups %xmm3,0x10(%rax,%rdi,4)
movups %xmm0,-0x30(%rsi,%rdi,4)
movups %xmm1,-0x20(%rsi,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm0
movups 0x30(%rax,%rdi,4),%xmm1
movups -0x10(%rsi,%rdi,4),%xmm2
movups (%rsi,%rdi,4),%xmm3
movups %xmm2,0x20(%rax,%rdi,4)
movups %xmm3,0x30(%rax,%rdi,4)
movups %xmm0,-0x10(%rsi,%rdi,4)
movups %xmm1,(%rsi,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1840 <ss_mintrosort+0x6e0>
test   $0x1,%r9b
je     18c0 <ss_mintrosort+0x760>
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movups (%rdx,%rdi,4),%xmm2
movups 0x10(%rdx,%rdi,4),%xmm3
movups %xmm2,(%rax,%rdi,4)
movups %xmm3,0x10(%rax,%rdi,4)
movups %xmm0,(%rdx,%rdi,4)
movups %xmm1,0x10(%rdx,%rdi,4)
cmp    %r8,%r10
je     18f8 <ss_mintrosort+0x798>
sub    %r8d,%ebx
lea    (%rdx,%r8,4),%rdx
lea    (%rax,%r8,4),%rax
add    $0x1,%ebx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rax,%rsi,1),%edi
mov    (%rdx,%rsi,1),%ebp
mov    %ebp,(%rax,%rsi,1)
mov    %edi,(%rdx,%rsi,1)
add    $0xffffffff,%ebx
add    $0x4,%rsi
cmp    $0x1,%ebx
ja     18e0 <ss_mintrosort+0x780>
mov    0x30(%rsp),%rbp
mov    0x40(%rsp),%rbx
lea    0x0(,%rbx,4),%r12
add    %rbp,%r12
lea    0x0(,%r13,4),%rax
sub    %rax,%r11
movslq 0x0(%rbp,%rbx,4),%rax
movslq (%r15,%rax,4),%rax
mov    %r12,0x38(%rsp)
cmp    -0x1(%rax,%r14,1),%cl
mov    %r11,0x18(%rsp)
jbe    1951 <ss_mintrosort+0x7f1>
mov    %r15,%rdi
mov    0x38(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    0x8(%rsp),%rcx
call   1060 <ss_partition@plt>
mov    0x18(%rsp),%r11
mov    %rax,%r12
mov    %r11,%r14
sub    %r12,%r14
sar    $0x2,%r14
xor    %edi,%edi
cmp    %r13,%rbx
jle    1a17 <ss_mintrosort+0x8b7>
cmp    %r14,%rbx
jle    1ac9 <ss_mintrosort+0x969>
mov    0x28(%rsp),%rbx
cmp    $0x10,%ebx
setl   %dil
call   1050 <assert@plt>
movslq %ebx,%rax
lea    (%rax,%rax,2),%rax
mov    %rbp,0x50(%rsp,%rax,8)
mov    0x38(%rsp),%rcx
mov    %rcx,0x58(%rsp,%rax,8)
mov    0x8(%rsp),%rbp
mov    %ebp,0x60(%rsp,%rax,8)
mov    %rbx,%rcx
add    $0x1,%ebx
mov    0x14(%rsp),%edx
mov    %edx,0x64(%rsp,%rax,8)
xor    %edi,%edi
cmp    $0xf,%ecx
setl   %dil
call   1050 <assert@plt>
movslq %ebx,%rax
lea    (%rax,%rax,2),%rbx
lea    (%rsp,%rbx,8),%rax
add    $0x50,%rax
cmp    %r14,%r13
jle    1bef <ss_mintrosort+0xa8f>
mov    0x18(%rsp),%rcx
mov    %rcx,(%rax)
mov    0x20(%rsp),%rax
mov    %rax,0x58(%rsp,%rbx,8)
mov    %ebp,0x60(%rsp,%rbx,8)
mov    0x28(%rsp),%r13
add    $0x2,%r13d
mov    0x14(%rsp),%eax
mov    %eax,0x64(%rsp,%rbx,8)
add    $0x1,%ebp
mov    %rbp,0x8(%rsp)
mov    %r14d,%edi
call   1030 <ss_ilg@plt>
mov    0x18(%rsp),%r11
mov    %r13,%rbx
jmp    1198 <ss_mintrosort+0x38>
cmp    %r14,%r13
jle    1b5b <ss_mintrosort+0x9fb>
mov    0x28(%rsp),%rbp
cmp    $0x10,%ebp
setl   %dil
call   1050 <assert@plt>
movslq %ebp,%rax
lea    (%rax,%rax,2),%rax
mov    0x18(%rsp),%rcx
mov    %rcx,0x50(%rsp,%rax,8)
mov    0x20(%rsp),%rcx
mov    %rcx,0x58(%rsp,%rax,8)
mov    0x8(%rsp),%r13
mov    %r13d,0x60(%rsp,%rax,8)
mov    %rbp,%rbx
add    $0x1,%ebp
mov    0x14(%rsp),%ecx
mov    %ecx,0x64(%rsp,%rax,8)
xor    %edi,%edi
cmp    $0xf,%ebx
setl   %dil
call   1050 <assert@plt>
movslq %ebp,%rax
lea    (%rax,%rax,2),%rbp
lea    (%rsp,%rbp,8),%rax
add    $0x50,%rax
cmp    %r14,0x40(%rsp)
jle    1c28 <ss_mintrosort+0xac8>
mov    0x30(%rsp),%rcx
mov    %rcx,(%rax)
mov    0x38(%rsp),%rax
mov    %rax,0x58(%rsp,%rbp,8)
mov    %r13d,0x60(%rsp,%rbp,8)
add    $0x2,%ebx
mov    0x14(%rsp),%eax
mov    %eax,0x64(%rsp,%rbp,8)
add    $0x1,%r13d
mov    %r13,0x8(%rsp)
mov    %r14d,%edi
call   1030 <ss_ilg@plt>
mov    0x18(%rsp),%r11
jmp    1198 <ss_mintrosort+0x38>
mov    0x28(%rsp),%rbx
cmp    $0x10,%ebx
setl   %dil
call   1050 <assert@plt>
movslq %ebx,%rax
lea    (%rax,%rax,2),%rbx
mov    %r12,0x50(%rsp,%rbx,8)
mov    0x18(%rsp),%r13
mov    %r13,0x58(%rsp,%rbx,8)
mov    %rbp,%r12
mov    0x8(%rsp),%rbp
lea    0x1(%rbp),%eax
mov    %eax,0x60(%rsp,%rbx,8)
mov    %r14d,%edi
call   1030 <ss_ilg@plt>
mov    0x28(%rsp),%rcx
lea    0x1(%rcx),%r14d
mov    %eax,0x64(%rsp,%rbx,8)
mov    0x28(%rsp),%rbx
xor    %edi,%edi
cmp    $0xf,%ebx
setl   %dil
call   1050 <assert@plt>
movslq %r14d,%rax
lea    (%rax,%rax,2),%rax
mov    %r12,0x50(%rsp,%rax,8)
mov    0x38(%rsp),%rcx
mov    %rcx,0x58(%rsp,%rax,8)
mov    %ebp,0x60(%rsp,%rax,8)
add    $0x2,%ebx
mov    0x14(%rsp),%ecx
mov    %ecx,0x64(%rsp,%rax,8)
mov    %r13,%r12
mov    %ecx,%eax
mov    0x20(%rsp),%r11
jmp    1198 <ss_mintrosort+0x38>
mov    0x28(%rsp),%rbp
cmp    $0x10,%ebp
setl   %dil
call   1050 <assert@plt>
movslq %ebp,%rbp
lea    0x0(,%rbp,2),%rbx
add    %rbp,%rbx
mov    %r12,0x50(%rsp,%rbx,8)
mov    0x18(%rsp),%r13
mov    %r13,0x58(%rsp,%rbx,8)
mov    0x8(%rsp),%r12
lea    0x1(%r12),%eax
mov    %eax,0x60(%rsp,%rbx,8)
mov    %r14d,%edi
call   1030 <ss_ilg@plt>
lea    0x1(%rbp),%r14d
mov    %eax,0x64(%rsp,%rbx,8)
mov    %rbp,%rbx
xor    %edi,%edi
cmp    $0xf,%ebx
setl   %dil
call   1050 <assert@plt>
movslq %r14d,%rax
lea    (%rax,%rax,2),%rax
mov    %r13,0x50(%rsp,%rax,8)
mov    0x20(%rsp),%rcx
mov    %rcx,0x58(%rsp,%rax,8)
mov    %r12d,0x60(%rsp,%rax,8)
add    $0x2,%ebx
mov    0x14(%rsp),%ecx
mov    %ecx,0x64(%rsp,%rax,8)
mov    0x38(%rsp),%r11
mov    0x30(%rsp),%r12
mov    %ecx,%eax
jmp    1198 <ss_mintrosort+0x38>
mov    %r12,(%rax)
mov    0x18(%rsp),%r12
mov    %r12,0x58(%rsp,%rbx,8)
lea    0x1(%rbp),%eax
mov    %eax,0x60(%rsp,%rbx,8)
mov    %r14d,%edi
call   1030 <ss_ilg@plt>
mov    0x28(%rsp),%rcx
add    $0x2,%ecx
mov    %eax,0x64(%rsp,%rbx,8)
mov    0x14(%rsp),%eax
mov    %rcx,%rbx
mov    0x20(%rsp),%r11
jmp    1198 <ss_mintrosort+0x38>
mov    %r12,(%rax)
mov    0x18(%rsp),%rax
mov    %rax,0x58(%rsp,%rbp,8)
lea    0x1(%r13),%eax
mov    %eax,0x60(%rsp,%rbp,8)
mov    %r14d,%edi
call   1030 <ss_ilg@plt>
add    $0x2,%ebx
mov    %eax,0x64(%rsp,%rbp,8)
mov    0x38(%rsp),%r11
mov    0x30(%rsp),%r12
mov    0x14(%rsp),%eax
jmp    1198 <ss_mintrosort+0x38>
xor    %esi,%esi
test   $0x1,%r10b
jne    172c <ss_mintrosort+0x5cc>
jmp    1759 <ss_mintrosort+0x5f9>
xor    %edi,%edi
test   $0x1,%r9b
jne    189c <ss_mintrosort+0x73c>
jmp    18c0 <ss_mintrosort+0x760>
add    $0x1d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.anon = type { i32*, i32*, i32, i32 }
define void @ss_mintrosort(i8* %0, i32* %1, i32* %2, i32* %3, i32 %4) {
%6 = alloca i8*
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca i32
%11 = alloca [16 x %struct.anon]
%12 = alloca i8*
%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
store i8* %0, i8** %6
store i32* %1, i32** %7
store i32* %2, i32** %8
store i32* %3, i32** %9
store i32 %4, i32* %10
store i32 0, i32* %24
store i32 0, i32* %21
%25 = load i32*, i32** %9
%26 = load i32*, i32** %8
%27 = ptrtoint i32* %25 to i64
%28 = ptrtoint i32* %26 to i64
%29 = sub i64 %27, %28
%30 = sdiv exact i64 %29, 4
%31 = trunc i64 %30 to i32
%32 = call i8* @ss_ilg(i32 %31)
%33 = ptrtoint i8* %32 to i32
store i32 %33, i32* %22
br label %34
34: ; preds = %1212, %305, %88, %5
%35 = load i32*, i32** %9
%36 = load i32*, i32** %8
%37 = ptrtoint i32* %35 to i64
%38 = ptrtoint i32* %36 to i64
%39 = sub i64 %37, %38
%40 = sdiv exact i64 %39, 4
%41 = icmp sle i64 %40, 8
br i1 %41, label %42, label %89
42: ; preds = %34
%43 = load i32*, i32** %9
%44 = load i32*, i32** %8
%45 = ptrtoint i32* %43 to i64
%46 = ptrtoint i32* %44 to i64
%47 = sub i64 %45, %46
%48 = sdiv exact i64 %47, 4
%49 = icmp slt i64 1, %48
br i1 %49, label %50, label %57
50: ; preds = %42
%51 = load i8*, i8** %6
%52 = load i32*, i32** %7
%53 = load i32*, i32** %8
%54 = load i32*, i32** %9
%55 = load i32, i32* %10
%56 = call i32 @ss_insertionsort(i8* %51, i32* %52, i32* %53, i32* %54, i32 %55)
br label %57
57: ; preds = %50, %42
br label %58
58: ; preds = %57
%59 = load i32, i32* %21
%60 = icmp sle i32 0, %59
%61 = zext i1 %60 to i32
%62 = call i32 @assert(i32 %61)
%63 = load i32, i32* %21
%64 = icmp eq i32 %63, 0
br i1 %64, label %65, label %66
65: ; preds = %58
ret void
66: ; preds = %58
%67 = load i32, i32* %21
%68 = add nsw i32 %67, -1
store i32 %68, i32* %21
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %69
%71 = getelementptr inbounds %struct.anon, %struct.anon* %70, i32 0, i32 0
%72 = load i32*, i32** %71
store i32* %72, i32** %8
%73 = load i32, i32* %21
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %74
%76 = getelementptr inbounds %struct.anon, %struct.anon* %75, i32 0, i32 1
%77 = load i32*, i32** %76
store i32* %77, i32** %9
%78 = load i32, i32* %21
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %79
%81 = getelementptr inbounds %struct.anon, %struct.anon* %80, i32 0, i32 2
%82 = load i32, i32* %81
store i32 %82, i32* %10
%83 = load i32, i32* %21
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %84
%86 = getelementptr inbounds %struct.anon, %struct.anon* %85, i32 0, i32 3
%87 = load i32, i32* %86
store i32 %87, i32* %22
br label %88
88: ; preds = %66
br label %34
89: ; preds = %34
%90 = load i8*, i8** %6
%91 = load i32, i32* %10
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i8, i8* %90, i64 %92
store i8* %93, i8** %12
%94 = load i32, i32* %22
%95 = add nsw i32 %94, -1
store i32 %95, i32* %22
%96 = icmp eq i32 %94, 0
br i1 %96, label %97, label %109
97: ; preds = %89
%98 = load i8*, i8** %12
%99 = load i32*, i32** %7
%100 = load i32*, i32** %8
%101 = load i32*, i32** %9
%102 = load i32*, i32** %8
%103 = ptrtoint i32* %101 to i64
%104 = ptrtoint i32* %102 to i64
%105 = sub i64 %103, %104
%106 = sdiv exact i64 %105, 4
%107 = trunc i64 %106 to i32
%108 = call i32 @ss_heapsort(i8* %98, i32* %99, i32* %100, i32 %107)
br label %109
109: ; preds = %97, %89
%110 = load i32, i32* %22
%111 = icmp slt i32 %110, 0
br i1 %111, label %112, label %306
112: ; preds = %109
%113 = load i32*, i32** %8
%114 = getelementptr inbounds i32, i32* %113, i64 1
store i32* %114, i32** %13
%115 = load i8*, i8** %12
%116 = load i32*, i32** %7
%117 = load i32*, i32** %8
%118 = load i32, i32* %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i32, i32* %116, i64 %119
%121 = load i32, i32* %120
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i8, i8* %115, i64 %122
%124 = load i8, i8* %123
%125 = zext i8 %124 to i32
store i32 %125, i32* %23
br label %126
126: ; preds = %157, %112
%127 = load i32*, i32** %13
%128 = load i32*, i32** %9
%129 = icmp ult i32* %127, %128
br i1 %129, label %130, label %160
130: ; preds = %126
%131 = load i8*, i8** %12
%132 = load i32*, i32** %7
%133 = load i32*, i32** %13
%134 = load i32, i32* %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %132, i64 %135
%137 = load i32, i32* %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds i8, i8* %131, i64 %138
%140 = load i8, i8* %139
%141 = zext i8 %140 to i32
store i32 %141, i32* %24
%142 = load i32, i32* %23
%143 = icmp ne i32 %141, %142
br i1 %143, label %144, label %156
144: ; preds = %130
%145 = load i32*, i32** %13
%146 = load i32*, i32** %8
%147 = ptrtoint i32* %145 to i64
%148 = ptrtoint i32* %146 to i64
%149 = sub i64 %147, %148
%150 = sdiv exact i64 %149, 4
%151 = icmp slt i64 1, %150
br i1 %151, label %152, label %153
152: ; preds = %144
br label %160
153: ; preds = %144
%154 = load i32, i32* %24
store i32 %154, i32* %23
%155 = load i32*, i32** %13
store i32* %155, i32** %8
br label %156
156: ; preds = %153, %130
br label %157
157: ; preds = %156
%158 = load i32*, i32** %13
%159 = getelementptr inbounds i32, i32* %158, i32 1
store i32* %159, i32** %13
br label %126
160: ; preds = %152, %126
%161 = load i8*, i8** %12
%162 = load i32*, i32** %7
%163 = load i32*, i32** %8
%164 = load i32, i32* %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i32, i32* %162, i64 %165
%167 = load i32, i32* %166
%168 = sub nsw i32 %167, 1
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i8, i8* %161, i64 %169
%171 = load i8, i8* %170
%172 = zext i8 %171 to i32
%173 = load i32, i32* %23
%174 = icmp slt i32 %172, %173
br i1 %174, label %175, label %181
175: ; preds = %160
%176 = load i32*, i32** %7
%177 = load i32*, i32** %8
%178 = load i32*, i32** %13
%179 = load i32, i32* %10
%180 = call i32* @ss_partition(i32* %176, i32* %177, i32* %178, i32 %179)
store i32* %180, i32** %8
br label %181
181: ; preds = %175, %160
%182 = load i32*, i32** %13
%183 = load i32*, i32** %8
%184 = ptrtoint i32* %182 to i64
%185 = ptrtoint i32* %183 to i64
%186 = sub i64 %184, %185
%187 = sdiv exact i64 %186, 4
%188 = load i32*, i32** %9
%189 = load i32*, i32** %13
%190 = ptrtoint i32* %188 to i64
%191 = ptrtoint i32* %189 to i64
%192 = sub i64 %190, %191
%193 = sdiv exact i64 %192, 4
%194 = icmp sle i64 %187, %193
br i1 %194, label %195, label %245
195: ; preds = %181
%196 = load i32*, i32** %13
%197 = load i32*, i32** %8
%198 = ptrtoint i32* %196 to i64
%199 = ptrtoint i32* %197 to i64
%200 = sub i64 %198, %199
%201 = sdiv exact i64 %200, 4
%202 = icmp slt i64 1, %201
br i1 %202, label %203, label %242
203: ; preds = %195
br label %204
204: ; preds = %203
%205 = load i32, i32* %21
%206 = icmp slt i32 %205, 16
%207 = zext i1 %206 to i32
%208 = call i32 @assert(i32 %207)
%209 = load i32*, i32** %13
%210 = load i32, i32* %21
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %211
%213 = getelementptr inbounds %struct.anon, %struct.anon* %212, i32 0, i32 0
store i32* %209, i32** %213
%214 = load i32*, i32** %9
%215 = load i32, i32* %21
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %216
%218 = getelementptr inbounds %struct.anon, %struct.anon* %217, i32 0, i32 1
store i32* %214, i32** %218
%219 = load i32, i32* %10
%220 = load i32, i32* %21
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %221
%223 = getelementptr inbounds %struct.anon, %struct.anon* %222, i32 0, i32 2
store i32 %219, i32* %223
%224 = load i32, i32* %21
%225 = add nsw i32 %224, 1
store i32 %225, i32* %21
%226 = sext i32 %224 to i64
%227 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %226
%228 = getelementptr inbounds %struct.anon, %struct.anon* %227, i32 0, i32 3
store i32 -1, i32* %228
br label %229
229: ; preds = %204
%230 = load i32*, i32** %13
store i32* %230, i32** %9
%231 = load i32, i32* %10
%232 = add nsw i32 %231, 1
store i32 %232, i32* %10
%233 = load i32*, i32** %13
%234 = load i32*, i32** %8
%235 = ptrtoint i32* %233 to i64
%236 = ptrtoint i32* %234 to i64
%237 = sub i64 %235, %236
%238 = sdiv exact i64 %237, 4
%239 = trunc i64 %238 to i32
%240 = call i8* @ss_ilg(i32 %239)
%241 = ptrtoint i8* %240 to i32
store i32 %241, i32* %22
br label %244
242: ; preds = %195
%243 = load i32*, i32** %13
store i32* %243, i32** %8
store i32 -1, i32* %22
br label %244
244: ; preds = %242, %229
br label %305
245: ; preds = %181
%246 = load i32*, i32** %9
%247 = load i32*, i32** %13
%248 = ptrtoint i32* %246 to i64
%249 = ptrtoint i32* %247 to i64
%250 = sub i64 %248, %249
%251 = sdiv exact i64 %250, 4
%252 = icmp slt i64 1, %251
br i1 %252, label %253, label %291
253: ; preds = %245
br label %254
254: ; preds = %253
%255 = load i32, i32* %21
%256 = icmp slt i32 %255, 16
%257 = zext i1 %256 to i32
%258 = call i32 @assert(i32 %257)
%259 = load i32*, i32** %8
%260 = load i32, i32* %21
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %261
%263 = getelementptr inbounds %struct.anon, %struct.anon* %262, i32 0, i32 0
store i32* %259, i32** %263
%264 = load i32*, i32** %13
%265 = load i32, i32* %21
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %266
%268 = getelementptr inbounds %struct.anon, %struct.anon* %267, i32 0, i32 1
store i32* %264, i32** %268
%269 = load i32, i32* %10
%270 = add nsw i32 %269, 1
%271 = load i32, i32* %21
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %272
%274 = getelementptr inbounds %struct.anon, %struct.anon* %273, i32 0, i32 2
store i32 %270, i32* %274
%275 = load i32*, i32** %13
%276 = load i32*, i32** %8
%277 = ptrtoint i32* %275 to i64
%278 = ptrtoint i32* %276 to i64
%279 = sub i64 %277, %278
%280 = sdiv exact i64 %279, 4
%281 = trunc i64 %280 to i32
%282 = call i8* @ss_ilg(i32 %281)
%283 = ptrtoint i8* %282 to i32
%284 = load i32, i32* %21
%285 = add nsw i32 %284, 1
store i32 %285, i32* %21
%286 = sext i32 %284 to i64
%287 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %286
%288 = getelementptr inbounds %struct.anon, %struct.anon* %287, i32 0, i32 3
store i32 %283, i32* %288
br label %289
289: ; preds = %254
%290 = load i32*, i32** %13
store i32* %290, i32** %8
store i32 -1, i32* %22
br label %304
291: ; preds = %245
%292 = load i32*, i32** %13
store i32* %292, i32** %9
%293 = load i32, i32* %10
%294 = add nsw i32 %293, 1
store i32 %294, i32* %10
%295 = load i32*, i32** %13
%296 = load i32*, i32** %8
%297 = ptrtoint i32* %295 to i64
%298 = ptrtoint i32* %296 to i64
%299 = sub i64 %297, %298
%300 = sdiv exact i64 %299, 4
%301 = trunc i64 %300 to i32
%302 = call i8* @ss_ilg(i32 %301)
%303 = ptrtoint i8* %302 to i32
store i32 %303, i32* %22
br label %304
304: ; preds = %291, %289
br label %305
305: ; preds = %304, %244
br label %34
306: ; preds = %109
%307 = load i8*, i8** %12
%308 = load i32*, i32** %7
%309 = load i32*, i32** %8
%310 = load i32*, i32** %9
%311 = call i32* @ss_pivot(i8* %307, i32* %308, i32* %309, i32* %310)
store i32* %311, i32** %13
%312 = load i8*, i8** %12
%313 = load i32*, i32** %7
%314 = load i32*, i32** %13
%315 = load i32, i32* %314
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds i32, i32* %313, i64 %316
%318 = load i32, i32* %317
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds i8, i8* %312, i64 %319
%321 = load i8, i8* %320
%322 = zext i8 %321 to i32
store i32 %322, i32* %23
br label %323
323: ; preds = %306
%324 = load i32*, i32** %8
%325 = load i32, i32* %324
store i32 %325, i32* %20
%326 = load i32*, i32** %13
%327 = load i32, i32* %326
%328 = load i32*, i32** %8
store i32 %327, i32* %328
%329 = load i32, i32* %20
%330 = load i32*, i32** %13
store i32 %329, i32* %330
br label %331
331: ; preds = %323
%332 = load i32*, i32** %8
store i32* %332, i32** %14
br label %333
333: ; preds = %354, %331
%334 = load i32*, i32** %14
%335 = getelementptr inbounds i32, i32* %334, i32 1
store i32* %335, i32** %14
%336 = load i32*, i32** %9
%337 = icmp ult i32* %335, %336
br i1 %337, label %338, label %352
338: ; preds = %333
%339 = load i8*, i8** %12
%340 = load i32*, i32** %7
%341 = load i32*, i32** %14
%342 = load i32, i32* %341
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds i32, i32* %340, i64 %343
%345 = load i32, i32* %344
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i8, i8* %339, i64 %346
%348 = load i8, i8* %347
%349 = zext i8 %348 to i32
store i32 %349, i32* %24
%350 = load i32, i32* %23
%351 = icmp eq i32 %349, %350
br label %352
352: ; preds = %338, %333
%353 = phi i1 [ false, %333 ], [ %351, %338 ]
br i1 %353, label %354, label %355
354: ; preds = %352
br label %333
355: ; preds = %352
%356 = load i32*, i32** %14
store i32* %356, i32** %13
%357 = load i32*, i32** %9
%358 = icmp ult i32* %356, %357
br i1 %358, label %359, label %403
359: ; preds = %355
%360 = load i32, i32* %24
%361 = load i32, i32* %23
%362 = icmp slt i32 %360, %361
br i1 %362, label %363, label %403
363: ; preds = %359
br label %364
364: ; preds = %401, %363
%365 = load i32*, i32** %14
%366 = getelementptr inbounds i32, i32* %365, i32 1
store i32* %366, i32** %14
%367 = load i32*, i32** %9
%368 = icmp ult i32* %366, %367
br i1 %368, label %369, label %383
369: ; preds = %364
%370 = load i8*, i8** %12
%371 = load i32*, i32** %7
%372 = load i32*, i32** %14
%373 = load i32, i32* %372
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds i32, i32* %371, i64 %374
%376 = load i32, i32* %375
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds i8, i8* %370, i64 %377
%379 = load i8, i8* %378
%380 = zext i8 %379 to i32
store i32 %380, i32* %24
%381 = load i32, i32* %23
%382 = icmp sle i32 %380, %381
br label %383
383: ; preds = %369, %364
%384 = phi i1 [ false, %364 ], [ %382, %369 ]
br i1 %384, label %385, label %402
385: ; preds = %383
%386 = load i32, i32* %24
%387 = load i32, i32* %23
%388 = icmp eq i32 %386, %387
br i1 %388, label %389, label %401
389: ; preds = %385
br label %390
390: ; preds = %389
%391 = load i32*, i32** %14
%392 = load i32, i32* %391
store i32 %392, i32* %20
%393 = load i32*, i32** %13
%394 = load i32, i32* %393
%395 = load i32*, i32** %14
store i32 %394, i32* %395
%396 = load i32, i32* %20
%397 = load i32*, i32** %13
store i32 %396, i32* %397
br label %398
398: ; preds = %390
%399 = load i32*, i32** %13
%400 = getelementptr inbounds i32, i32* %399, i32 1
store i32* %400, i32** %13
br label %401
401: ; preds = %398, %385
br label %364
402: ; preds = %383
br label %403
403: ; preds = %402, %359, %355
%404 = load i32*, i32** %9
store i32* %404, i32** %15
br label %405
405: ; preds = %426, %403
%406 = load i32*, i32** %14
%407 = load i32*, i32** %15
%408 = getelementptr inbounds i32, i32* %407, i32 -1
store i32* %408, i32** %15
%409 = icmp ult i32* %406, %408
br i1 %409, label %410, label %424
410: ; preds = %405
%411 = load i8*, i8** %12
%412 = load i32*, i32** %7
%413 = load i32*, i32** %15
%414 = load i32, i32* %413
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds i32, i32* %412, i64 %415
%417 = load i32, i32* %416
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds i8, i8* %411, i64 %418
%420 = load i8, i8* %419
%421 = zext i8 %420 to i32
store i32 %421, i32* %24
%422 = load i32, i32* %23
%423 = icmp eq i32 %421, %422
br label %424
424: ; preds = %410, %405
%425 = phi i1 [ false, %405 ], [ %423, %410 ]
br i1 %425, label %426, label %427
426: ; preds = %424
br label %405
427: ; preds = %424
%428 = load i32*, i32** %14
%429 = load i32*, i32** %15
store i32* %429, i32** %16
%430 = icmp ult i32* %428, %429
br i1 %430, label %431, label %475
431: ; preds = %427
%432 = load i32, i32* %24
%433 = load i32, i32* %23
%434 = icmp sgt i32 %432, %433
br i1 %434, label %435, label %475
435: ; preds = %431
br label %436
436: ; preds = %473, %435
%437 = load i32*, i32** %14
%438 = load i32*, i32** %15
%439 = getelementptr inbounds i32, i32* %438, i32 -1
store i32* %439, i32** %15
%440 = icmp ult i32* %437, %439
br i1 %440, label %441, label %455
441: ; preds = %436
%442 = load i8*, i8** %12
%443 = load i32*, i32** %7
%444 = load i32*, i32** %15
%445 = load i32, i32* %444
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds i32, i32* %443, i64 %446
%448 = load i32, i32* %447
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds i8, i8* %442, i64 %449
%451 = load i8, i8* %450
%452 = zext i8 %451 to i32
store i32 %452, i32* %24
%453 = load i32, i32* %23
%454 = icmp sge i32 %452, %453
br label %455
455: ; preds = %441, %436
%456 = phi i1 [ false, %436 ], [ %454, %441 ]
br i1 %456, label %457, label %474
457: ; preds = %455
%458 = load i32, i32* %24
%459 = load i32, i32* %23
%460 = icmp eq i32 %458, %459
br i1 %460, label %461, label %473
461: ; preds = %457
br label %462
462: ; preds = %461
%463 = load i32*, i32** %15
%464 = load i32, i32* %463
store i32 %464, i32* %20
%465 = load i32*, i32** %16
%466 = load i32, i32* %465
%467 = load i32*, i32** %15
store i32 %466, i32* %467
%468 = load i32, i32* %20
%469 = load i32*, i32** %16
store i32 %468, i32* %469
br label %470
470: ; preds = %462
%471 = load i32*, i32** %16
%472 = getelementptr inbounds i32, i32* %471, i32 -1
store i32* %472, i32** %16
br label %473
473: ; preds = %470, %457
br label %436
474: ; preds = %455
br label %475
475: ; preds = %474, %431, %427
br label %476
476: ; preds = %567, %475
%477 = load i32*, i32** %14
%478 = load i32*, i32** %15
%479 = icmp ult i32* %477, %478
br i1 %479, label %480, label %568
480: ; preds = %476
br label %481
481: ; preds = %480
%482 = load i32*, i32** %14
%483 = load i32, i32* %482
store i32 %483, i32* %20
%484 = load i32*, i32** %15
%485 = load i32, i32* %484
%486 = load i32*, i32** %14
store i32 %485, i32* %486
%487 = load i32, i32* %20
%488 = load i32*, i32** %15
store i32 %487, i32* %488
br label %489
489: ; preds = %481
br label %490
490: ; preds = %527, %489
%491 = load i32*, i32** %14
%492 = getelementptr inbounds i32, i32* %491, i32 1
store i32* %492, i32** %14
%493 = load i32*, i32** %15
%494 = icmp ult i32* %492, %493
br i1 %494, label %495, label %509
495: ; preds = %490
%496 = load i8*, i8** %12
%497 = load i32*, i32** %7
%498 = load i32*, i32** %14
%499 = load i32, i32* %498
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds i32, i32* %497, i64 %500
%502 = load i32, i32* %501
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds i8, i8* %496, i64 %503
%505 = load i8, i8* %504
%506 = zext i8 %505 to i32
store i32 %506, i32* %24
%507 = load i32, i32* %23
%508 = icmp sle i32 %506, %507
br label %509
509: ; preds = %495, %490
%510 = phi i1 [ false, %490 ], [ %508, %495 ]
br i1 %510, label %511, label %528
511: ; preds = %509
%512 = load i32, i32* %24
%513 = load i32, i32* %23
%514 = icmp eq i32 %512, %513
br i1 %514, label %515, label %527
515: ; preds = %511
br label %516
516: ; preds = %515
%517 = load i32*, i32** %14
%518 = load i32, i32* %517
store i32 %518, i32* %20
%519 = load i32*, i32** %13
%520 = load i32, i32* %519
%521 = load i32*, i32** %14
store i32 %520, i32* %521
%522 = load i32, i32* %20
%523 = load i32*, i32** %13
store i32 %522, i32* %523
br label %524
524: ; preds = %516
%525 = load i32*, i32** %13
%526 = getelementptr inbounds i32, i32* %525, i32 1
store i32* %526, i32** %13
br label %527
527: ; preds = %524, %511
br label %490
528: ; preds = %509
br label %529
529: ; preds = %566, %528
%530 = load i32*, i32** %14
%531 = load i32*, i32** %15
%532 = getelementptr inbounds i32, i32* %531, i32 -1
store i32* %532, i32** %15
%533 = icmp ult i32* %530, %532
br i1 %533, label %534, label %548
534: ; preds = %529
%535 = load i8*, i8** %12
%536 = load i32*, i32** %7
%537 = load i32*, i32** %15
%538 = load i32, i32* %537
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds i32, i32* %536, i64 %539
%541 = load i32, i32* %540
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds i8, i8* %535, i64 %542
%544 = load i8, i8* %543
%545 = zext i8 %544 to i32
store i32 %545, i32* %24
%546 = load i32, i32* %23
%547 = icmp sge i32 %545, %546
br label %548
548: ; preds = %534, %529
%549 = phi i1 [ false, %529 ], [ %547, %534 ]
br i1 %549, label %550, label %567
550: ; preds = %548
%551 = load i32, i32* %24
%552 = load i32, i32* %23
%553 = icmp eq i32 %551, %552
br i1 %553, label %554, label %566
554: ; preds = %550
br label %555
555: ; preds = %554
%556 = load i32*, i32** %15
%557 = load i32, i32* %556
store i32 %557, i32* %20
%558 = load i32*, i32** %16
%559 = load i32, i32* %558
%560 = load i32*, i32** %15
store i32 %559, i32* %560
%561 = load i32, i32* %20
%562 = load i32*, i32** %16
store i32 %561, i32* %562
br label %563
563: ; preds = %555
%564 = load i32*, i32** %16
%565 = getelementptr inbounds i32, i32* %564, i32 -1
store i32* %565, i32** %16
br label %566
566: ; preds = %563, %550
br label %529
567: ; preds = %548
br label %476
568: ; preds = %476
%569 = load i32*, i32** %13
%570 = load i32*, i32** %16
%571 = icmp ule i32* %569, %570
br i1 %571, label %572, label %1177
572: ; preds = %568
%573 = load i32*, i32** %14
%574 = getelementptr inbounds i32, i32* %573, i64 -1
store i32* %574, i32** %15
%575 = load i32*, i32** %13
%576 = load i32*, i32** %8
%577 = ptrtoint i32* %575 to i64
%578 = ptrtoint i32* %576 to i64
%579 = sub i64 %577, %578
%580 = sdiv exact i64 %579, 4
%581 = trunc i64 %580 to i32
store i32 %581, i32* %19
%582 = load i32*, i32** %14
%583 = load i32*, i32** %13
%584 = ptrtoint i32* %582 to i64
%585 = ptrtoint i32* %583 to i64
%586 = sub i64 %584, %585
%587 = sdiv exact i64 %586, 4
%588 = trunc i64 %587 to i32
store i32 %588, i32* %20
%589 = icmp sgt i32 %581, %588
br i1 %589, label %590, label %592
590: ; preds = %572
%591 = load i32, i32* %20
store i32 %591, i32* %19
br label %592
592: ; preds = %590, %572
%593 = load i32*, i32** %8
store i32* %593, i32** %17
%594 = load i32*, i32** %14
%595 = load i32, i32* %19
%596 = sext i32 %595 to i64
%597 = sub i64 0, %596
%598 = getelementptr inbounds i32, i32* %594, i64 %597
store i32* %598, i32** %18
br label %599
599: ; preds = %612, %592
%600 = load i32, i32* %19
%601 = icmp slt i32 0, %600
br i1 %601, label %602, label %619
602: ; preds = %599
br label %603
603: ; preds = %602
%604 = load i32*, i32** %17
%605 = load i32, i32* %604
store i32 %605, i32* %20
%606 = load i32*, i32** %18
%607 = load i32, i32* %606
%608 = load i32*, i32** %17
store i32 %607, i32* %608
%609 = load i32, i32* %20
%610 = load i32*, i32** %18
store i32 %609, i32* %610
br label %611
611: ; preds = %603
br label %612
612: ; preds = %611
%613 = load i32, i32* %19
%614 = add nsw i32 %613, -1
store i32 %614, i32* %19
%615 = load i32*, i32** %17
%616 = getelementptr inbounds i32, i32* %615, i32 1
store i32* %616, i32** %17
%617 = load i32*, i32** %18
%618 = getelementptr inbounds i32, i32* %617, i32 1
store i32* %618, i32** %18
br label %599
619: ; preds = %599
%620 = load i32*, i32** %16
%621 = load i32*, i32** %15
%622 = ptrtoint i32* %620 to i64
%623 = ptrtoint i32* %621 to i64
%624 = sub i64 %622, %623
%625 = sdiv exact i64 %624, 4
%626 = trunc i64 %625 to i32
store i32 %626, i32* %19
%627 = load i32*, i32** %9
%628 = load i32*, i32** %16
%629 = ptrtoint i32* %627 to i64
%630 = ptrtoint i32* %628 to i64
%631 = sub i64 %629, %630
%632 = sdiv exact i64 %631, 4
%633 = sub nsw i64 %632, 1
%634 = trunc i64 %633 to i32
store i32 %634, i32* %20
%635 = icmp sgt i32 %626, %634
br i1 %635, label %636, label %638
636: ; preds = %619
%637 = load i32, i32* %20
store i32 %637, i32* %19
br label %638
638: ; preds = %636, %619
%639 = load i32*, i32** %14
store i32* %639, i32** %17
%640 = load i32*, i32** %9
%641 = load i32, i32* %19
%642 = sext i32 %641 to i64
%643 = sub i64 0, %642
%644 = getelementptr inbounds i32, i32* %640, i64 %643
store i32* %644, i32** %18
br label %645
645: ; preds = %658, %638
%646 = load i32, i32* %19
%647 = icmp slt i32 0, %646
br i1 %647, label %648, label %665
648: ; preds = %645
br label %649
649: ; preds = %648
%650 = load i32*, i32** %17
%651 = load i32, i32* %650
store i32 %651, i32* %20
%652 = load i32*, i32** %18
%653 = load i32, i32* %652
%654 = load i32*, i32** %17
store i32 %653, i32* %654
%655 = load i32, i32* %20
%656 = load i32*, i32** %18
store i32 %655, i32* %656
br label %657
657: ; preds = %649
br label %658
658: ; preds = %657
%659 = load i32, i32* %19
%660 = add nsw i32 %659, -1
store i32 %660, i32* %19
%661 = load i32*, i32** %17
%662 = getelementptr inbounds i32, i32* %661, i32 1
store i32* %662, i32** %17
%663 = load i32*, i32** %18
%664 = getelementptr inbounds i32, i32* %663, i32 1
store i32* %664, i32** %18
br label %645
665: ; preds = %645
%666 = load i32*, i32** %8
%667 = load i32*, i32** %14
%668 = load i32*, i32** %13
%669 = ptrtoint i32* %667 to i64
%670 = ptrtoint i32* %668 to i64
%671 = sub i64 %669, %670
%672 = sdiv exact i64 %671, 4
%673 = getelementptr inbounds i32, i32* %666, i64 %672
store i32* %673, i32** %13
%674 = load i32*, i32** %9
%675 = load i32*, i32** %16
%676 = load i32*, i32** %15
%677 = ptrtoint i32* %675 to i64
%678 = ptrtoint i32* %676 to i64
%679 = sub i64 %677, %678
%680 = sdiv exact i64 %679, 4
%681 = sub i64 0, %680
%682 = getelementptr inbounds i32, i32* %674, i64 %681
store i32* %682, i32** %15
%683 = load i32, i32* %23
%684 = load i8*, i8** %12
%685 = load i32*, i32** %7
%686 = load i32*, i32** %13
%687 = load i32, i32* %686
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds i32, i32* %685, i64 %688
%690 = load i32, i32* %689
%691 = sub nsw i32 %690, 1
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds i8, i8* %684, i64 %692
%694 = load i8, i8* %693
%695 = zext i8 %694 to i32
%696 = icmp sle i32 %683, %695
br i1 %696, label %697, label %699
697: ; preds = %665
%698 = load i32*, i32** %13
br label %705
699: ; preds = %665
%700 = load i32*, i32** %7
%701 = load i32*, i32** %13
%702 = load i32*, i32** %15
%703 = load i32, i32* %10
%704 = call i32* @ss_partition(i32* %700, i32* %701, i32* %702, i32 %703)
br label %705
705: ; preds = %699, %697
%706 = phi i32* [ %698, %697 ], [ %704, %699 ]
store i32* %706, i32** %14
%707 = load i32*, i32** %13
%708 = load i32*, i32** %8
%709 = ptrtoint i32* %707 to i64
%710 = ptrtoint i32* %708 to i64
%711 = sub i64 %709, %710
%712 = sdiv exact i64 %711, 4
%713 = load i32*, i32** %9
%714 = load i32*, i32** %15
%715 = ptrtoint i32* %713 to i64
%716 = ptrtoint i32* %714 to i64
%717 = sub i64 %715, %716
%718 = sdiv exact i64 %717, 4
%719 = icmp sle i64 %712, %718
br i1 %719, label %720, label %948
720: ; preds = %705
%721 = load i32*, i32** %9
%722 = load i32*, i32** %15
%723 = ptrtoint i32* %721 to i64
%724 = ptrtoint i32* %722 to i64
%725 = sub i64 %723, %724
%726 = sdiv exact i64 %725, 4
%727 = load i32*, i32** %15
%728 = load i32*, i32** %14
%729 = ptrtoint i32* %727 to i64
%730 = ptrtoint i32* %728 to i64
%731 = sub i64 %729, %730
%732 = sdiv exact i64 %731, 4
%733 = icmp sle i64 %726, %732
br i1 %733, label %734, label %799
734: ; preds = %720
br label %735
735: ; preds = %734
%736 = load i32, i32* %21
%737 = icmp slt i32 %736, 16
%738 = zext i1 %737 to i32
%739 = call i32 @assert(i32 %738)
%740 = load i32*, i32** %14
%741 = load i32, i32* %21
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %742
%744 = getelementptr inbounds %struct.anon, %struct.anon* %743, i32 0, i32 0
store i32* %740, i32** %744
%745 = load i32*, i32** %15
%746 = load i32, i32* %21
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %747
%749 = getelementptr inbounds %struct.anon, %struct.anon* %748, i32 0, i32 1
store i32* %745, i32** %749
%750 = load i32, i32* %10
%751 = add nsw i32 %750, 1
%752 = load i32, i32* %21
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %753
%755 = getelementptr inbounds %struct.anon, %struct.anon* %754, i32 0, i32 2
store i32 %751, i32* %755
%756 = load i32*, i32** %15
%757 = load i32*, i32** %14
%758 = ptrtoint i32* %756 to i64
%759 = ptrtoint i32* %757 to i64
%760 = sub i64 %758, %759
%761 = sdiv exact i64 %760, 4
%762 = trunc i64 %761 to i32
%763 = call i8* @ss_ilg(i32 %762)
%764 = ptrtoint i8* %763 to i32
%765 = load i32, i32* %21
%766 = add nsw i32 %765, 1
store i32 %766, i32* %21
%767 = sext i32 %765 to i64
%768 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %767
%769 = getelementptr inbounds %struct.anon, %struct.anon* %768, i32 0, i32 3
store i32 %764, i32* %769
br label %770
770: ; preds = %735
br label %771
771: ; preds = %770
%772 = load i32, i32* %21
%773 = icmp slt i32 %772, 16
%774 = zext i1 %773 to i32
%775 = call i32 @assert(i32 %774)
%776 = load i32*, i32** %15
%777 = load i32, i32* %21
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %778
%780 = getelementptr inbounds %struct.anon, %struct.anon* %779, i32 0, i32 0
store i32* %776, i32** %780
%781 = load i32*, i32** %9
%782 = load i32, i32* %21
%783 = sext i32 %782 to i64
%784 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %783
%785 = getelementptr inbounds %struct.anon, %struct.anon* %784, i32 0, i32 1
store i32* %781, i32** %785
%786 = load i32, i32* %10
%787 = load i32, i32* %21
%788 = sext i32 %787 to i64
%789 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %788
%790 = getelementptr inbounds %struct.anon, %struct.anon* %789, i32 0, i32 2
store i32 %786, i32* %790
%791 = load i32, i32* %22
%792 = load i32, i32* %21
%793 = add nsw i32 %792, 1
store i32 %793, i32* %21
%794 = sext i32 %792 to i64
%795 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %794
%796 = getelementptr inbounds %struct.anon, %struct.anon* %795, i32 0, i32 3
store i32 %791, i32* %796
br label %797
797: ; preds = %771
%798 = load i32*, i32** %13
store i32* %798, i32** %9
br label %947
799: ; preds = %720
%800 = load i32*, i32** %13
%801 = load i32*, i32** %8
%802 = ptrtoint i32* %800 to i64
%803 = ptrtoint i32* %801 to i64
%804 = sub i64 %802, %803
%805 = sdiv exact i64 %804, 4
%806 = load i32*, i32** %15
%807 = load i32*, i32** %14
%808 = ptrtoint i32* %806 to i64
%809 = ptrtoint i32* %807 to i64
%810 = sub i64 %808, %809
%811 = sdiv exact i64 %810, 4
%812 = icmp sle i64 %805, %811
br i1 %812, label %813, label %878
813: ; preds = %799
br label %814
814: ; preds = %813
%815 = load i32, i32* %21
%816 = icmp slt i32 %815, 16
%817 = zext i1 %816 to i32
%818 = call i32 @assert(i32 %817)
%819 = load i32*, i32** %15
%820 = load i32, i32* %21
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %821
%823 = getelementptr inbounds %struct.anon, %struct.anon* %822, i32 0, i32 0
store i32* %819, i32** %823
%824 = load i32*, i32** %9
%825 = load i32, i32* %21
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %826
%828 = getelementptr inbounds %struct.anon, %struct.anon* %827, i32 0, i32 1
store i32* %824, i32** %828
%829 = load i32, i32* %10
%830 = load i32, i32* %21
%831 = sext i32 %830 to i64
%832 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %831
%833 = getelementptr inbounds %struct.anon, %struct.anon* %832, i32 0, i32 2
store i32 %829, i32* %833
%834 = load i32, i32* %22
%835 = load i32, i32* %21
%836 = add nsw i32 %835, 1
store i32 %836, i32* %21
%837 = sext i32 %835 to i64
%838 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %837
%839 = getelementptr inbounds %struct.anon, %struct.anon* %838, i32 0, i32 3
store i32 %834, i32* %839
br label %840
840: ; preds = %814
br label %841
841: ; preds = %840
%842 = load i32, i32* %21
%843 = icmp slt i32 %842, 16
%844 = zext i1 %843 to i32
%845 = call i32 @assert(i32 %844)
%846 = load i32*, i32** %14
%847 = load i32, i32* %21
%848 = sext i32 %847 to i64
%849 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %848
%850 = getelementptr inbounds %struct.anon, %struct.anon* %849, i32 0, i32 0
store i32* %846, i32** %850
%851 = load i32*, i32** %15
%852 = load i32, i32* %21
%853 = sext i32 %852 to i64
%854 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %853
%855 = getelementptr inbounds %struct.anon, %struct.anon* %854, i32 0, i32 1
store i32* %851, i32** %855
%856 = load i32, i32* %10
%857 = add nsw i32 %856, 1
%858 = load i32, i32* %21
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %859
%861 = getelementptr inbounds %struct.anon, %struct.anon* %860, i32 0, i32 2
store i32 %857, i32* %861
%862 = load i32*, i32** %15
%863 = load i32*, i32** %14
%864 = ptrtoint i32* %862 to i64
%865 = ptrtoint i32* %863 to i64
%866 = sub i64 %864, %865
%867 = sdiv exact i64 %866, 4
%868 = trunc i64 %867 to i32
%869 = call i8* @ss_ilg(i32 %868)
%870 = ptrtoint i8* %869 to i32
%871 = load i32, i32* %21
%872 = add nsw i32 %871, 1
store i32 %872, i32* %21
%873 = sext i32 %871 to i64
%874 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %873
%875 = getelementptr inbounds %struct.anon, %struct.anon* %874, i32 0, i32 3
store i32 %870, i32* %875
br label %876
876: ; preds = %841
%877 = load i32*, i32** %13
store i32* %877, i32** %9
br label %946
878: ; preds = %799
br label %879
879: ; preds = %878
%880 = load i32, i32* %21
%881 = icmp slt i32 %880, 16
%882 = zext i1 %881 to i32
%883 = call i32 @assert(i32 %882)
%884 = load i32*, i32** %15
%885 = load i32, i32* %21
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %886
%888 = getelementptr inbounds %struct.anon, %struct.anon* %887, i32 0, i32 0
store i32* %884, i32** %888
%889 = load i32*, i32** %9
%890 = load i32, i32* %21
%891 = sext i32 %890 to i64
%892 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %891
%893 = getelementptr inbounds %struct.anon, %struct.anon* %892, i32 0, i32 1
store i32* %889, i32** %893
%894 = load i32, i32* %10
%895 = load i32, i32* %21
%896 = sext i32 %895 to i64
%897 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %896
%898 = getelementptr inbounds %struct.anon, %struct.anon* %897, i32 0, i32 2
store i32 %894, i32* %898
%899 = load i32, i32* %22
%900 = load i32, i32* %21
%901 = add nsw i32 %900, 1
store i32 %901, i32* %21
%902 = sext i32 %900 to i64
%903 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %902
%904 = getelementptr inbounds %struct.anon, %struct.anon* %903, i32 0, i32 3
store i32 %899, i32* %904
br label %905
905: ; preds = %879
br label %906
906: ; preds = %905
%907 = load i32, i32* %21
%908 = icmp slt i32 %907, 16
%909 = zext i1 %908 to i32
%910 = call i32 @assert(i32 %909)
%911 = load i32*, i32** %8
%912 = load i32, i32* %21
%913 = sext i32 %912 to i64
%914 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %913
%915 = getelementptr inbounds %struct.anon, %struct.anon* %914, i32 0, i32 0
store i32* %911, i32** %915
%916 = load i32*, i32** %13
%917 = load i32, i32* %21
%918 = sext i32 %917 to i64
%919 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %918
%920 = getelementptr inbounds %struct.anon, %struct.anon* %919, i32 0, i32 1
store i32* %916, i32** %920
%921 = load i32, i32* %10
%922 = load i32, i32* %21
%923 = sext i32 %922 to i64
%924 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %923
%925 = getelementptr inbounds %struct.anon, %struct.anon* %924, i32 0, i32 2
store i32 %921, i32* %925
%926 = load i32, i32* %22
%927 = load i32, i32* %21
%928 = add nsw i32 %927, 1
store i32 %928, i32* %21
%929 = sext i32 %927 to i64
%930 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %929
%931 = getelementptr inbounds %struct.anon, %struct.anon* %930, i32 0, i32 3
store i32 %926, i32* %931
br label %932
932: ; preds = %906
%933 = load i32*, i32** %14
store i32* %933, i32** %8
%934 = load i32*, i32** %15
store i32* %934, i32** %9
%935 = load i32, i32* %10
%936 = add nsw i32 %935, 1
store i32 %936, i32* %10
%937 = load i32*, i32** %15
%938 = load i32*, i32** %14
%939 = ptrtoint i32* %937 to i64
%940 = ptrtoint i32* %938 to i64
%941 = sub i64 %939, %940
%942 = sdiv exact i64 %941, 4
%943 = trunc i64 %942 to i32
%944 = call i8* @ss_ilg(i32 %943)
%945 = ptrtoint i8* %944 to i32
store i32 %945, i32* %22
br label %946
946: ; preds = %932, %876
br label %947
947: ; preds = %946, %797
br label %1176
948: ; preds = %705
%949 = load i32*, i32** %13
%950 = load i32*, i32** %8
%951 = ptrtoint i32* %949 to i64
%952 = ptrtoint i32* %950 to i64
%953 = sub i64 %951, %952
%954 = sdiv exact i64 %953, 4
%955 = load i32*, i32** %15
%956 = load i32*, i32** %14
%957 = ptrtoint i32* %955 to i64
%958 = ptrtoint i32* %956 to i64
%959 = sub i64 %957, %958
%960 = sdiv exact i64 %959, 4
%961 = icmp sle i64 %954, %960
br i1 %961, label %962, label %1027
962: ; preds = %948
br label %963
963: ; preds = %962
%964 = load i32, i32* %21
%965 = icmp slt i32 %964, 16
%966 = zext i1 %965 to i32
%967 = call i32 @assert(i32 %966)
%968 = load i32*, i32** %14
%969 = load i32, i32* %21
%970 = sext i32 %969 to i64
%971 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %970
%972 = getelementptr inbounds %struct.anon, %struct.anon* %971, i32 0, i32 0
store i32* %968, i32** %972
%973 = load i32*, i32** %15
%974 = load i32, i32* %21
%975 = sext i32 %974 to i64
%976 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %975
%977 = getelementptr inbounds %struct.anon, %struct.anon* %976, i32 0, i32 1
store i32* %973, i32** %977
%978 = load i32, i32* %10
%979 = add nsw i32 %978, 1
%980 = load i32, i32* %21
%981 = sext i32 %980 to i64
%982 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %981
%983 = getelementptr inbounds %struct.anon, %struct.anon* %982, i32 0, i32 2
store i32 %979, i32* %983
%984 = load i32*, i32** %15
%985 = load i32*, i32** %14
%986 = ptrtoint i32* %984 to i64
%987 = ptrtoint i32* %985 to i64
%988 = sub i64 %986, %987
%989 = sdiv exact i64 %988, 4
%990 = trunc i64 %989 to i32
%991 = call i8* @ss_ilg(i32 %990)
%992 = ptrtoint i8* %991 to i32
%993 = load i32, i32* %21
%994 = add nsw i32 %993, 1
store i32 %994, i32* %21
%995 = sext i32 %993 to i64
%996 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %995
%997 = getelementptr inbounds %struct.anon, %struct.anon* %996, i32 0, i32 3
store i32 %992, i32* %997
br label %998
998: ; preds = %963
br label %999
999: ; preds = %998
%1000 = load i32, i32* %21
%1001 = icmp slt i32 %1000, 16
%1002 = zext i1 %1001 to i32
%1003 = call i32 @assert(i32 %1002)
%1004 = load i32*, i32** %8
%1005 = load i32, i32* %21
%1006 = sext i32 %1005 to i64
%1007 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1006
%1008 = getelementptr inbounds %struct.anon, %struct.anon* %1007, i32 0, i32 0
store i32* %1004, i32** %1008
%1009 = load i32*, i32** %13
%1010 = load i32, i32* %21
%1011 = sext i32 %1010 to i64
%1012 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1011
%1013 = getelementptr inbounds %struct.anon, %struct.anon* %1012, i32 0, i32 1
store i32* %1009, i32** %1013
%1014 = load i32, i32* %10
%1015 = load i32, i32* %21
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1016
%1018 = getelementptr inbounds %struct.anon, %struct.anon* %1017, i32 0, i32 2
store i32 %1014, i32* %1018
%1019 = load i32, i32* %22
%1020 = load i32, i32* %21
%1021 = add nsw i32 %1020, 1
store i32 %1021, i32* %21
%1022 = sext i32 %1020 to i64
%1023 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1022
%1024 = getelementptr inbounds %struct.anon, %struct.anon* %1023, i32 0, i32 3
store i32 %1019, i32* %1024
br label %1025
1025: ; preds = %999
%1026 = load i32*, i32** %15
store i32* %1026, i32** %8
br label %1175
1027: ; preds = %948
%1028 = load i32*, i32** %9
%1029 = load i32*, i32** %15
%1030 = ptrtoint i32* %1028 to i64
%1031 = ptrtoint i32* %1029 to i64
%1032 = sub i64 %1030, %1031
%1033 = sdiv exact i64 %1032, 4
%1034 = load i32*, i32** %15
%1035 = load i32*, i32** %14
%1036 = ptrtoint i32* %1034 to i64
%1037 = ptrtoint i32* %1035 to i64
%1038 = sub i64 %1036, %1037
%1039 = sdiv exact i64 %1038, 4
%1040 = icmp sle i64 %1033, %1039
br i1 %1040, label %1041, label %1106
1041: ; preds = %1027
br label %1042
1042: ; preds = %1041
%1043 = load i32, i32* %21
%1044 = icmp slt i32 %1043, 16
%1045 = zext i1 %1044 to i32
%1046 = call i32 @assert(i32 %1045)
%1047 = load i32*, i32** %8
%1048 = load i32, i32* %21
%1049 = sext i32 %1048 to i64
%1050 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1049
%1051 = getelementptr inbounds %struct.anon, %struct.anon* %1050, i32 0, i32 0
store i32* %1047, i32** %1051
%1052 = load i32*, i32** %13
%1053 = load i32, i32* %21
%1054 = sext i32 %1053 to i64
%1055 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1054
%1056 = getelementptr inbounds %struct.anon, %struct.anon* %1055, i32 0, i32 1
store i32* %1052, i32** %1056
%1057 = load i32, i32* %10
%1058 = load i32, i32* %21
%1059 = sext i32 %1058 to i64
%1060 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1059
%1061 = getelementptr inbounds %struct.anon, %struct.anon* %1060, i32 0, i32 2
store i32 %1057, i32* %1061
%1062 = load i32, i32* %22
%1063 = load i32, i32* %21
%1064 = add nsw i32 %1063, 1
store i32 %1064, i32* %21
%1065 = sext i32 %1063 to i64
%1066 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1065
%1067 = getelementptr inbounds %struct.anon, %struct.anon* %1066, i32 0, i32 3
store i32 %1062, i32* %1067
br label %1068
1068: ; preds = %1042
br label %1069
1069: ; preds = %1068
%1070 = load i32, i32* %21
%1071 = icmp slt i32 %1070, 16
%1072 = zext i1 %1071 to i32
%1073 = call i32 @assert(i32 %1072)
%1074 = load i32*, i32** %14
%1075 = load i32, i32* %21
%1076 = sext i32 %1075 to i64
%1077 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1076
%1078 = getelementptr inbounds %struct.anon, %struct.anon* %1077, i32 0, i32 0
store i32* %1074, i32** %1078
%1079 = load i32*, i32** %15
%1080 = load i32, i32* %21
%1081 = sext i32 %1080 to i64
%1082 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1081
%1083 = getelementptr inbounds %struct.anon, %struct.anon* %1082, i32 0, i32 1
store i32* %1079, i32** %1083
%1084 = load i32, i32* %10
%1085 = add nsw i32 %1084, 1
%1086 = load i32, i32* %21
%1087 = sext i32 %1086 to i64
%1088 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1087
%1089 = getelementptr inbounds %struct.anon, %struct.anon* %1088, i32 0, i32 2
store i32 %1085, i32* %1089
%1090 = load i32*, i32** %15
%1091 = load i32*, i32** %14
%1092 = ptrtoint i32* %1090 to i64
%1093 = ptrtoint i32* %1091 to i64
%1094 = sub i64 %1092, %1093
%1095 = sdiv exact i64 %1094, 4
%1096 = trunc i64 %1095 to i32
%1097 = call i8* @ss_ilg(i32 %1096)
%1098 = ptrtoint i8* %1097 to i32
%1099 = load i32, i32* %21
%1100 = add nsw i32 %1099, 1
store i32 %1100, i32* %21
%1101 = sext i32 %1099 to i64
%1102 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1101
%1103 = getelementptr inbounds %struct.anon, %struct.anon* %1102, i32 0, i32 3
store i32 %1098, i32* %1103
br label %1104
1104: ; preds = %1069
%1105 = load i32*, i32** %15
store i32* %1105, i32** %8
br label %1174
1106: ; preds = %1027
br label %1107
1107: ; preds = %1106
%1108 = load i32, i32* %21
%1109 = icmp slt i32 %1108, 16
%1110 = zext i1 %1109 to i32
%1111 = call i32 @assert(i32 %1110)
%1112 = load i32*, i32** %8
%1113 = load i32, i32* %21
%1114 = sext i32 %1113 to i64
%1115 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1114
%1116 = getelementptr inbounds %struct.anon, %struct.anon* %1115, i32 0, i32 0
store i32* %1112, i32** %1116
%1117 = load i32*, i32** %13
%1118 = load i32, i32* %21
%1119 = sext i32 %1118 to i64
%1120 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1119
%1121 = getelementptr inbounds %struct.anon, %struct.anon* %1120, i32 0, i32 1
store i32* %1117, i32** %1121
%1122 = load i32, i32* %10
%1123 = load i32, i32* %21
%1124 = sext i32 %1123 to i64
%1125 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1124
%1126 = getelementptr inbounds %struct.anon, %struct.anon* %1125, i32 0, i32 2
store i32 %1122, i32* %1126
%1127 = load i32, i32* %22
%1128 = load i32, i32* %21
%1129 = add nsw i32 %1128, 1
store i32 %1129, i32* %21
%1130 = sext i32 %1128 to i64
%1131 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1130
%1132 = getelementptr inbounds %struct.anon, %struct.anon* %1131, i32 0, i32 3
store i32 %1127, i32* %1132
br label %1133
1133: ; preds = %1107
br label %1134
1134: ; preds = %1133
%1135 = load i32, i32* %21
%1136 = icmp slt i32 %1135, 16
%1137 = zext i1 %1136 to i32
%1138 = call i32 @assert(i32 %1137)
%1139 = load i32*, i32** %15
%1140 = load i32, i32* %21
%1141 = sext i32 %1140 to i64
%1142 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1141
%1143 = getelementptr inbounds %struct.anon, %struct.anon* %1142, i32 0, i32 0
store i32* %1139, i32** %1143
%1144 = load i32*, i32** %9
%1145 = load i32, i32* %21
%1146 = sext i32 %1145 to i64
%1147 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1146
%1148 = getelementptr inbounds %struct.anon, %struct.anon* %1147, i32 0, i32 1
store i32* %1144, i32** %1148
%1149 = load i32, i32* %10
%1150 = load i32, i32* %21
%1151 = sext i32 %1150 to i64
%1152 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1151
%1153 = getelementptr inbounds %struct.anon, %struct.anon* %1152, i32 0, i32 2
store i32 %1149, i32* %1153
%1154 = load i32, i32* %22
%1155 = load i32, i32* %21
%1156 = add nsw i32 %1155, 1
store i32 %1156, i32* %21
%1157 = sext i32 %1155 to i64
%1158 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1157
%1159 = getelementptr inbounds %struct.anon, %struct.anon* %1158, i32 0, i32 3
store i32 %1154, i32* %1159
br label %1160
1160: ; preds = %1134
%1161 = load i32*, i32** %14
store i32* %1161, i32** %8
%1162 = load i32*, i32** %15
store i32* %1162, i32** %9
%1163 = load i32, i32* %10
%1164 = add nsw i32 %1163, 1
store i32 %1164, i32* %10
%1165 = load i32*, i32** %15
%1166 = load i32*, i32** %14
%1167 = ptrtoint i32* %1165 to i64
%1168 = ptrtoint i32* %1166 to i64
%1169 = sub i64 %1167, %1168
%1170 = sdiv exact i64 %1169, 4
%1171 = trunc i64 %1170 to i32
%1172 = call i8* @ss_ilg(i32 %1171)
%1173 = ptrtoint i8* %1172 to i32
store i32 %1173, i32* %22
br label %1174
1174: ; preds = %1160, %1104
br label %1175
1175: ; preds = %1174, %1025
br label %1176
1176: ; preds = %1175, %947
br label %1212
1177: ; preds = %568
%1178 = load i32, i32* %22
%1179 = add nsw i32 %1178, 1
store i32 %1179, i32* %22
%1180 = load i8*, i8** %12
%1181 = load i32*, i32** %7
%1182 = load i32*, i32** %8
%1183 = load i32, i32* %1182
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds i32, i32* %1181, i64 %1184
%1186 = load i32, i32* %1185
%1187 = sub nsw i32 %1186, 1
%1188 = sext i32 %1187 to i64
%1189 = getelementptr inbounds i8, i8* %1180, i64 %1188
%1190 = load i8, i8* %1189
%1191 = zext i8 %1190 to i32
%1192 = load i32, i32* %23
%1193 = icmp slt i32 %1191, %1192
br i1 %1193, label %1194, label %1209
1194: ; preds = %1177
%1195 = load i32*, i32** %7
%1196 = load i32*, i32** %8
%1197 = load i32*, i32** %9
%1198 = load i32, i32* %10
%1199 = call i32* @ss_partition(i32* %1195, i32* %1196, i32* %1197, i32 %1198)
store i32* %1199, i32** %8
%1200 = load i32*, i32** %9
%1201 = load i32*, i32** %8
%1202 = ptrtoint i32* %1200 to i64
%1203 = ptrtoint i32* %1201 to i64
%1204 = sub i64 %1202, %1203
%1205 = sdiv exact i64 %1204, 4
%1206 = trunc i64 %1205 to i32
%1207 = call i8* @ss_ilg(i32 %1206)
%1208 = ptrtoint i8* %1207 to i32
store i32 %1208, i32* %22
br label %1209
1209: ; preds = %1194, %1177
%1210 = load i32, i32* %10
%1211 = add nsw i32 %1210, 1
store i32 %1211, i32* %10
br label %1212
1212: ; preds = %1209, %1176
br label %34
}

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