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 {
        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 {
            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 {
            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 {
            stack[ssize].a = (b), stack[ssize].b = (c),
            stack[ssize].c = (depth + 1), stack[ssize++].d = (ss_ilg(c - b));
          } while (0);
          do {
            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 {
            stack[ssize].a = (c), stack[ssize].b = (last),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            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 {
            stack[ssize].a = (c), stack[ssize].b = (last),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            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 {
            stack[ssize].a = (b), stack[ssize].b = (c),
            stack[ssize].c = (depth + 1), stack[ssize++].d = (ss_ilg(c - b));
          } while (0);
          do {
            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 {
            stack[ssize].a = (first), stack[ssize].b = (a),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            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 {
            stack[ssize].a = (first), stack[ssize].b = (a),
            stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            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),%rdi
mov    -0x18(%rbp),%rax
sub    %rax,%rdi
sar    $0x2,%rdi
mov    $0x0,%al
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     128d <ss_mintrosort+0x13d>
mov    -0x20(%rbp),%rcx
mov    -0x18(%rbp),%rax
sub    %rax,%rcx
sar    $0x2,%rcx
mov    $0x1,%eax
cmp    %rcx,%rax
jge    11f0 <ss_mintrosort+0xa0>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%r8d
mov    $0x0,%al
call   1040 <ss_insertionsort@plt>
jmp    11f5 <ss_mintrosort+0xa5>
cmpl   $0x0,-0x1f4(%rbp)
jne    120b <ss_mintrosort+0xbb>
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    119f <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    12de <ss_mintrosort+0x18e>
mov    -0x1b8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x18(%rbp),%rax
sub    %rax,%rcx
sar    $0x2,%rcx
mov    $0x0,%al
call   1060 <ss_heapsort@plt>
cmpl   $0x0,-0x1f8(%rbp)
jge    1636 <ss_mintrosort+0x4e6>
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    13b2 <ss_mintrosort+0x262>
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     1396 <ss_mintrosort+0x246>
mov    -0x1c0(%rbp),%rcx
mov    -0x18(%rbp),%rax
sub    %rax,%rcx
sar    $0x2,%rcx
mov    $0x1,%eax
cmp    %rcx,%rax
jge    137f <ss_mintrosort+0x22f>
jmp    13b2 <ss_mintrosort+0x262>
mov    -0x200(%rbp),%eax
mov    %eax,-0x1fc(%rbp)
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    139b <ss_mintrosort+0x24b>
mov    -0x1c0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1c0(%rbp)
jmp    131a <ss_mintrosort+0x1ca>
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    13fc <ss_mintrosort+0x2ac>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c0(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    $0x0,%al
call   1050 <ss_partition@plt>
cltq
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     1520 <ss_mintrosort+0x3d0>
mov    -0x1c0(%rbp),%rcx
mov    -0x18(%rbp),%rax
sub    %rax,%rcx
sar    $0x2,%rcx
mov    $0x1,%eax
cmp    %rcx,%rax
jge    1506 <ss_mintrosort+0x3b6>
jmp    144e <ss_mintrosort+0x2fe>
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),%rdi
mov    -0x18(%rbp),%rax
sub    %rax,%rdi
sar    $0x2,%rdi
mov    $0x0,%al
call   1030 <ss_ilg@plt>
mov    %eax,-0x1f8(%rbp)
jmp    151b <ss_mintrosort+0x3cb>
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x18(%rbp)
movl   $0xffffffff,-0x1f8(%rbp)
ff ff ff
jmp    1631 <ss_mintrosort+0x4e1>
mov    -0x20(%rbp),%rcx
mov    -0x1c0(%rbp),%rax
sub    %rax,%rcx
sar    $0x2,%rcx
mov    $0x1,%eax
cmp    %rcx,%rax
jge    15f9 <ss_mintrosort+0x4a9>
jmp    1545 <ss_mintrosort+0x3f5>
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),%rdi
mov    -0x18(%rbp),%rax
sub    %rax,%rdi
sar    $0x2,%rdi
mov    $0x0,%al
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    162c <ss_mintrosort+0x4dc>
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c0(%rbp),%rdi
mov    -0x18(%rbp),%rax
sub    %rax,%rdi
sar    $0x2,%rdi
mov    $0x0,%al
call   1030 <ss_ilg@plt>
mov    %eax,-0x1f8(%rbp)
jmp    1631 <ss_mintrosort+0x4e1>
jmp    119f <ss_mintrosort+0x4f>
mov    -0x1b8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    $0x0,%al
call   1070 <ss_pivot@plt>
cltq
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    1707 <ss_mintrosort+0x5b7>
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    171a <ss_mintrosort+0x5ca>
jmp    171f <ss_mintrosort+0x5cf>
jmp    16b1 <ss_mintrosort+0x561>
mov    -0x1c8(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
cmp    -0x20(%rbp),%rax
jae    181a <ss_mintrosort+0x6ca>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jge    181a <ss_mintrosort+0x6ca>
jmp    174e <ss_mintrosort+0x5fe>
mov    -0x1c8(%rbp),%rcx
add    $0x4,%rcx
mov    %rcx,-0x1c8(%rbp)
xor    %eax,%eax
cmp    -0x20(%rbp),%rcx
mov    %al,-0x202(%rbp)
jae    17a4 <ss_mintrosort+0x654>
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    17b7 <ss_mintrosort+0x667>
jmp    1815 <ss_mintrosort+0x6c5>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jne    1810 <ss_mintrosort+0x6c0>
jmp    17ce <ss_mintrosort+0x67e>
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    174e <ss_mintrosort+0x5fe>
jmp    181a <ss_mintrosort+0x6ca>
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    1881 <ss_mintrosort+0x731>
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    1894 <ss_mintrosort+0x744>
jmp    1899 <ss_mintrosort+0x749>
jmp    1825 <ss_mintrosort+0x6d5>
mov    -0x1c8(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
mov    %rcx,-0x1d8(%rbp)
cmp    %rcx,%rax
jae    19a0 <ss_mintrosort+0x850>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jle    19a0 <ss_mintrosort+0x850>
jmp    18ce <ss_mintrosort+0x77e>
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    192a <ss_mintrosort+0x7da>
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    193d <ss_mintrosort+0x7ed>
jmp    199b <ss_mintrosort+0x84b>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jne    1996 <ss_mintrosort+0x846>
jmp    1954 <ss_mintrosort+0x804>
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    18ce <ss_mintrosort+0x77e>
jmp    19a0 <ss_mintrosort+0x850>
jmp    19a5 <ss_mintrosort+0x855>
mov    -0x1c8(%rbp),%rax
cmp    -0x1d0(%rbp),%rax
jae    1b94 <ss_mintrosort+0xa44>
jmp    19be <ss_mintrosort+0x86e>
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    19f3 <ss_mintrosort+0x8a3>
mov    -0x1c8(%rbp),%rcx
add    $0x4,%rcx
mov    %rcx,-0x1c8(%rbp)
xor    %eax,%eax
cmp    -0x1d0(%rbp),%rcx
mov    %al,-0x205(%rbp)
jae    1a4c <ss_mintrosort+0x8fc>
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    1a5f <ss_mintrosort+0x90f>
jmp    1abd <ss_mintrosort+0x96d>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jne    1ab8 <ss_mintrosort+0x968>
jmp    1a76 <ss_mintrosort+0x926>
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    19f3 <ss_mintrosort+0x8a3>
jmp    1ac2 <ss_mintrosort+0x972>
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    1b1e <ss_mintrosort+0x9ce>
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    1b31 <ss_mintrosort+0x9e1>
jmp    1b8f <ss_mintrosort+0xa3f>
mov    -0x200(%rbp),%eax
cmp    -0x1fc(%rbp),%eax
jne    1b8a <ss_mintrosort+0xa3a>
jmp    1b48 <ss_mintrosort+0x9f8>
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    1ac2 <ss_mintrosort+0x972>
jmp    19a5 <ss_mintrosort+0x855>
mov    -0x1c0(%rbp),%rax
cmp    -0x1d8(%rbp),%rax
ja     2701 <ss_mintrosort+0x15b1>
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    1c01 <ss_mintrosort+0xab1>
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    1cad <ss_mintrosort+0xb5d>
jmp    1c40 <ss_mintrosort+0xaf0>
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    1c75 <ss_mintrosort+0xb25>
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    1c2d <ss_mintrosort+0xadd>
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    1cf8 <ss_mintrosort+0xba8>
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    1da4 <ss_mintrosort+0xc54>
jmp    1d37 <ss_mintrosort+0xbe7>
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    1d6c <ss_mintrosort+0xc1c>
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    1d24 <ss_mintrosort+0xbd4>
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     1e3a <ss_mintrosort+0xcea>
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x210(%rbp)
jmp    1e5f <ss_mintrosort+0xd0f>
mov    -0x10(%rbp),%rdi
mov    -0x1c0(%rbp),%rsi
mov    -0x1d0(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    $0x0,%al
call   1050 <ss_partition@plt>
cltq
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     22cb <ss_mintrosort+0x117b>
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     2006 <ss_mintrosort+0xeb6>
jmp    1ecf <ss_mintrosort+0xd7f>
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),%rdi
mov    -0x1c8(%rbp),%rax
sub    %rax,%rdi
sar    $0x2,%rdi
mov    $0x0,%al
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    1f74 <ss_mintrosort+0xe24>
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    22c6 <ss_mintrosort+0x1176>
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     2172 <ss_mintrosort+0x1022>
jmp    203b <ss_mintrosort+0xeeb>
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    20c2 <ss_mintrosort+0xf72>
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),%rdi
mov    -0x1c8(%rbp),%rax
sub    %rax,%rdi
sar    $0x2,%rdi
mov    $0x0,%al
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    22c1 <ss_mintrosort+0x1171>
jmp    2177 <ss_mintrosort+0x1027>
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    21fe <ss_mintrosort+0x10ae>
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),%rdi
mov    -0x1c8(%rbp),%rax
sub    %rax,%rdi
sar    $0x2,%rdi
mov    $0x0,%al
call   1030 <ss_ilg@plt>
mov    %eax,-0x1f8(%rbp)
jmp    22c6 <ss_mintrosort+0x1176>
jmp    26fc <ss_mintrosort+0x15ac>
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     2437 <ss_mintrosort+0x12e7>
jmp    2300 <ss_mintrosort+0x11b0>
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),%rdi
mov    -0x1c8(%rbp),%rax
sub    %rax,%rdi
sar    $0x2,%rdi
mov    $0x0,%al
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    23a5 <ss_mintrosort+0x1255>
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    26f7 <ss_mintrosort+0x15a7>
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     25a3 <ss_mintrosort+0x1453>
jmp    246c <ss_mintrosort+0x131c>
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    24f3 <ss_mintrosort+0x13a3>
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),%rdi
mov    -0x1c8(%rbp),%rax
sub    %rax,%rdi
sar    $0x2,%rdi
mov    $0x0,%al
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    26f2 <ss_mintrosort+0x15a2>
jmp    25a8 <ss_mintrosort+0x1458>
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    262f <ss_mintrosort+0x14df>
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),%rdi
mov    -0x1c8(%rbp),%rax
sub    %rax,%rdi
sar    $0x2,%rdi
mov    $0x0,%al
call   1030 <ss_ilg@plt>
mov    %eax,-0x1f8(%rbp)
jmp    26f7 <ss_mintrosort+0x15a7>
jmp    26fc <ss_mintrosort+0x15ac>
jmp    277c <ss_mintrosort+0x162c>
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    2773 <ss_mintrosort+0x1623>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    $0x0,%al
call   1050 <ss_partition@plt>
cltq
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rax
sub    %rax,%rdi
sar    $0x2,%rdi
mov    $0x0,%al
call   1030 <ss_ilg@plt>
mov    %eax,-0x1f8(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    119f <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,%r13
mov    %rsi,%r15
mov    %rdi,0x40(%rsp)
mov    %rcx,%rdi
sub    %rdx,%rdi
sar    $0x2,%rdi
xor    %eax,%eax
call   1030 <ss_ilg@plt>
mov    %rbx,%r10
xor    %ebx,%ebx
mov    %r10,%rcx
sub    %r13,%rcx
cmp    $0x23,%rcx
jg     1220 <ss_mintrosort+0xd0>
mov    %rbx,0x30(%rsp)
movslq %ebx,%r14
lea    (%r14,%r14,2),%rax
lea    0x38(%rsp),%rdx
lea    (%rdx,%rax,8),%rbp
xor    %ebx,%ebx
mov    0x8(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
cmp    $0x5,%rcx
jl     11db <ss_mintrosort+0x8b>
mov    0x40(%rsp),%rdi
mov    %r15,%rsi
mov    %r13,%rdx
mov    %r10,%rcx
xor    %eax,%eax
call   1040 <ss_insertionsort@plt>
cmp    %rbx,%r14
je     1bb8 <ss_mintrosort+0xa68>
mov    0x0(%rbp),%r13
mov    0x8(%rbp),%r10
mov    0x10(%rbp),%r8d
mov    %r10,%rcx
sub    %r13,%rcx
add    $0x1,%rbx
add    $0xffffffffffffffe8,%rbp
cmp    $0x24,%rcx
jl     11c0 <ss_mintrosort+0x70>
mov    0x2c(%rbp),%eax
mov    0x30(%rsp),%rdx
sub    %ebx,%edx
mov    %rdx,%rbx
mov    %r10,%rsi
mov    %r13,%rdx
jmp    122b <ss_mintrosort+0xdb>
nopl   0x0(%rax)
mov    %r10,%rsi
mov    %r13,%rdx
mov    0x8(%rsp),%r8
mov    %r8,0x8(%rsp)
movslq %r8d,%r12
add    0x40(%rsp),%r12
mov    %eax,%edi
sub    $0x1,%edi
mov    %r10,0x10(%rsp)
mov    %rsi,0x18(%rsp)
jae    1270 <ss_mintrosort+0x120>
shr    $0x2,%rcx
mov    %r12,%rdi
mov    %r15,%rsi
xor    %eax,%eax
mov    %rdx,%rbp
call   1060 <ss_heapsort@plt>
mov    0x10(%rsp),%r10
mov    %rbp,%rdx
jmp    12f0 <ss_mintrosort+0x1a0>
nopw   0x0(%rax,%rax,1)
jl     12f0 <ss_mintrosort+0x1a0>
mov    %eax,0x38(%rsp)
mov    %edi,0x24(%rsp)
mov    %r12,%rdi
mov    %r15,%rsi
mov    %r10,%rcx
xor    %eax,%eax
mov    %rdx,0x28(%rsp)
call   1070 <ss_pivot@plt>
mov    0x10(%rsp),%r10
mov    0x28(%rsp),%rsi
movslq %eax,%rcx
movslq (%rcx),%rdx
movslq (%r15,%rdx,4),%rax
mov    (%r12,%rax,1),%r11b
mov    (%rsi),%edi
mov    %edx,(%rsi)
mov    %edi,(%rcx)
lea    0x4(%rsi),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rcx
cmp    %r10,%rdx
jae    1490 <ss_mintrosort+0x340>
movslq (%rdx),%rcx
movslq (%r15,%rcx,4),%rcx
cmp    %r11b,(%r12,%rcx,1)
jne    144d <ss_mintrosort+0x2fd>
add    $0x4,%rdx
jmp    12c0 <ss_mintrosort+0x170>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq (%rdx),%rax
movslq (%r15,%rax,4),%rax
movzbl (%r12,%rax,1),%edi
lea    0x4(%rdx),%r13
cmp    %r10,%r13
jae    1347 <ss_mintrosort+0x1f7>
lea    0x4(%rdx),%rax
jmp    1327 <ss_mintrosort+0x1d7>
nopl   0x0(%rax,%rax,1)
mov    %rdx,%r14
mov    %edi,%ecx
add    $0x4,%r13
add    $0x4,%rax
mov    %ecx,%edi
mov    %r14,%rdx
cmp    %r10,%r13
jae    134c <ss_mintrosort+0x1fc>
movslq 0x0(%r13),%rcx
movslq (%r15,%rcx,4),%rcx
movzbl (%r12,%rcx,1),%ecx
cmp    %ecx,%edi
je     1310 <ss_mintrosort+0x1c0>
mov    %rax,%rsi
sub    %rdx,%rsi
mov    %r13,%r14
cmp    $0x4,%rsi
jle    1315 <ss_mintrosort+0x1c5>
mov    %rdx,%r14
mov    %edi,%ecx
movslq (%r14),%rax
movslq (%r15,%rax,4),%rax
movzbl -0x1(%rax,%r12,1),%eax
cmp    %eax,%ecx
jle    137a <ss_mintrosort+0x22a>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r13,%rdx
mov    0x8(%rsp),%rcx
xor    %eax,%eax
call   1050 <ss_partition@plt>
mov    0x10(%rsp),%r10
movslq %eax,%r14
mov    0x18(%rsp),%rdx
mov    %r13,%rsi
sub    %r14,%rsi
mov    %rsi,%rdi
sar    $0x2,%rdi
sub    %r13,%rdx
mov    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%rdi
jle    13f0 <ss_mintrosort+0x2a0>
cmp    $0x5,%rdx
jl     142e <ss_mintrosort+0x2de>
movslq %ebx,%rax
mov    %rbx,%rbp
lea    (%rax,%rax,2),%rbx
mov    %r14,0x50(%rsp,%rbx,8)
mov    %r13,0x58(%rsp,%rbx,8)
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x60(%rsp,%rbx,8)
xor    %eax,%eax
call   1030 <ss_ilg@plt>
mov    0x10(%rsp),%r10
add    $0x1,%ebp
mov    %eax,0x64(%rsp,%rbx,8)
mov    %rbp,%rbx
mov    $0xffffffff,%eax
jmp    118a <ss_mintrosort+0x3a>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0xffffffff,%eax
cmp    $0x5,%rsi
jl     118a <ss_mintrosort+0x3a>
movslq %ebx,%rax
lea    (%rax,%rax,2),%rax
mov    %r13,0x50(%rsp,%rax,8)
mov    %r10,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    143b <ss_mintrosort+0x2eb>
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x8(%rsp)
xor    %eax,%eax
call   1030 <ss_ilg@plt>
mov    %r13,%r10
mov    %r14,%r13
jmp    118a <ss_mintrosort+0x3a>
jae    1484 <ss_mintrosort+0x334>
lea    0x4(%rdx),%rcx
jmp    1464 <ss_mintrosort+0x314>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x4,%rcx
cmp    %r10,%rcx
jae    1490 <ss_mintrosort+0x340>
movslq (%rcx),%rbp
movslq (%r15,%rbp,4),%rdi
cmp    %r11b,(%r12,%rdi,1)
ja     1490 <ss_mintrosort+0x340>
jne    1460 <ss_mintrosort+0x310>
mov    (%rdx),%edi
mov    %edi,(%rcx)
mov    %ebp,(%rdx)
add    $0x4,%rdx
jmp    1460 <ss_mintrosort+0x310>
mov    %rdx,%rcx
nopw   0x0(%rax,%rax,1)
lea    -0x4(%r10),%r14
mov    %r14,%rbp
cmp    %r14,%rcx
mov    0x38(%rsp),%eax
jae    1500 <ss_mintrosort+0x3b0>
movslq (%r14),%rdi
movslq (%r15,%rdi,4),%rdi
cmp    %r11b,(%r12,%rdi,1)
jne    14bb <ss_mintrosort+0x36b>
add    $0xfffffffffffffffc,%r14
mov    %r14,%rbp
cmp    %r14,%rcx
jb     14a0 <ss_mintrosort+0x350>
jmp    1500 <ss_mintrosort+0x3b0>
jbe    14f8 <ss_mintrosort+0x3a8>
lea    -0x4(%r14),%rbp
jmp    14d4 <ss_mintrosort+0x384>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xfffffffffffffffc,%rbp
cmp    %rbp,%rcx
jae    1500 <ss_mintrosort+0x3b0>
movslq 0x0(%rbp),%r8
movslq (%r15,%r8,4),%rdi
cmp    %r11b,(%r12,%rdi,1)
jb     1500 <ss_mintrosort+0x3b0>
jne    14d0 <ss_mintrosort+0x380>
mov    (%r14),%edi
mov    %edi,0x0(%rbp)
mov    %r8d,(%r14)
add    $0xfffffffffffffffc,%r14
jmp    14d0 <ss_mintrosort+0x380>
mov    %r14,%rbp
nopl   0x0(%rax,%rax,1)
cmp    %rbp,%rcx
mov    %rbx,0x30(%rsp)
jb     1565 <ss_mintrosort+0x415>
cmp    %r14,%rdx
jbe    15c8 <ss_mintrosort+0x478>
movslq (%rsi),%rcx
movslq (%r15,%rcx,4),%rcx
cmp    %r11b,-0x1(%rcx,%r12,1)
jae    16ad <ss_mintrosort+0x55d>
mov    %r15,%rdi
mov    %r10,%rdx
mov    0x8(%rsp),%rbx
mov    %ebx,%ecx
xor    %eax,%eax
call   1050 <ss_partition@plt>
movslq %eax,%rbp
mov    0x18(%rsp),%rdi
sub    %rbp,%rdi
sar    $0x2,%rdi
xor    %eax,%eax
call   1030 <ss_ilg@plt>
mov    0x10(%rsp),%r10
mov    %rbp,%rsi
jmp    16b2 <ss_mintrosort+0x562>
nopl   0x0(%rax)
cmp    %rbp,%rcx
jae    150a <ss_mintrosort+0x3ba>
mov    (%rcx),%edi
mov    0x0(%rbp),%ebx
mov    %ebx,(%rcx)
mov    %edi,0x0(%rbp)
nop
add    $0x4,%rcx
cmp    %rbp,%rcx
jae    15af <ss_mintrosort+0x45f>
movslq (%rcx),%rdi
movslq (%r15,%rdi,4),%rbx
cmp    %r11b,(%r12,%rbx,1)
ja     15af <ss_mintrosort+0x45f>
jne    1570 <ss_mintrosort+0x420>
mov    (%rdx),%ebx
mov    %ebx,(%rcx)
mov    %edi,(%rdx)
add    $0x4,%rdx
jmp    1570 <ss_mintrosort+0x420>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
jne    15af <ss_mintrosort+0x45f>
mov    (%r14),%ebx
mov    %ebx,0x0(%rbp)
mov    %edi,(%r14)
add    $0xfffffffffffffffc,%r14
add    $0xfffffffffffffffc,%rbp
cmp    %rbp,%rcx
jae    1560 <ss_mintrosort+0x410>
movslq 0x0(%rbp),%rdi
movslq (%r15,%rdi,4),%rbx
cmp    %r11b,(%r12,%rbx,1)
jae    15a0 <ss_mintrosort+0x450>
jmp    1560 <ss_mintrosort+0x410>
lea    -0x4(%rcx),%r8
mov    %rcx,%rax
sub    %rdx,%rax
sub    %r13,%rdx
shr    $0x2,%rdx
sar    $0x2,%rax
cmp    %eax,%edx
mov    %rax,0x38(%rsp)
cmovg  %eax,%edx
test   %edx,%edx
jle    165e <ss_mintrosort+0x50e>
mov    %edx,%ebp
lea    0x0(,%rbp,4),%rdi
mov    %rcx,%r13
sub    %rdi,%r13
lea    -0x1(%rdx),%eax
cmp    $0x7,%eax
jb     162b <ss_mintrosort+0x4db>
mov    %rax,%rdi
sub    %rbp,%rdi
lea    (%rcx,%rdi,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    1701 <ss_mintrosort+0x5b1>
lea    (%rsi,%rax,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%r13
jae    1701 <ss_mintrosort+0x5b1>
mov    %rsi,%r9
add    $0x1,%edx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r9,%rdi,1),%ebx
mov    0x0(%r13,%rdi,1),%ebp
mov    %ebp,(%r9,%rdi,1)
mov    %ebx,0x0(%r13,%rdi,1)
add    $0xffffffff,%edx
add    $0x4,%rdi
cmp    $0x1,%edx
ja     1640 <ss_mintrosort+0x4f0>
mov    0x18(%rsp),%rbx
sub    %r14,%rbx
sub    %r8,%r14
sar    $0x2,%r14
shr    $0x2,%rbx
add    $0xffffffff,%ebx
cmp    %r14d,%ebx
cmovge %r14d,%ebx
test   %ebx,%ebx
jle    18f8 <ss_mintrosort+0x7a8>
mov    %ebx,%edi
lea    0x0(,%rdi,4),%rdx
mov    %r10,%rax
sub    %rdx,%rax
mov    %r10,%rbp
lea    -0x1(%rbx),%r10d
cmp    $0x7,%r10d
jae    16c7 <ss_mintrosort+0x577>
mov    0x28(%rsp),%rsi
mov    %rbp,%r10
jmp    18da <ss_mintrosort+0x78a>
mov    0x8(%rsp),%rbx
add    $0x1,%ebx
mov    %rbx,0x8(%rsp)
mov    %rsi,%r13
mov    0x30(%rsp),%rbx
jmp    118a <ss_mintrosort+0x3a>
mov    %r10,%rdx
sub    %rdi,%rdx
lea    0x4(,%rdx,4),%rdx
add    %rbp,%rdx
cmp    %rdx,%rcx
jae    1801 <ss_mintrosort+0x6b1>
lea    (%rcx,%r10,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%rax
jae    1801 <ss_mintrosort+0x6b1>
mov    0x28(%rsp),%rsi
mov    0x10(%rsp),%r10
jmp    18da <ss_mintrosort+0x78a>
add    $0x1,%rax
mov    %rax,%rsi
and    $0xfffffffffffffff8,%rsi
lea    -0x8(%rsi),%rdi
mov    %rdi,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rdi,%rdi
mov    %rsi,0x48(%rsp)
je     1b91 <ss_mintrosort+0xa41>
neg    %rbp
mov    %r10,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%rcx,%rbp,4),%r9
add    $0x30,%r9
xor    %ebx,%ebx
mov    0x28(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rsi,%rbx,4),%xmm0
movups 0x10(%rsi,%rbx,4),%xmm1
movups -0x30(%r9,%rbx,4),%xmm2
movups -0x20(%r9,%rbx,4),%xmm3
movups %xmm2,(%rsi,%rbx,4)
movups %xmm3,0x10(%rsi,%rbx,4)
movups %xmm0,-0x30(%r9,%rbx,4)
movups %xmm1,-0x20(%r9,%rbx,4)
movups 0x20(%rsi,%rbx,4),%xmm0
movups 0x30(%rsi,%rbx,4),%xmm1
movups -0x10(%r9,%rbx,4),%xmm2
movups (%r9,%rbx,4),%xmm3
movups %xmm2,0x20(%rsi,%rbx,4)
movups %xmm3,0x30(%rsi,%rbx,4)
movups %xmm0,-0x10(%r9,%rbx,4)
movups %xmm1,(%r9,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdi
jne    1750 <ss_mintrosort+0x600>
test   $0x1,%r10b
je     17de <ss_mintrosort+0x68e>
movups (%rsi,%rbx,4),%xmm0
movups 0x10(%rsi,%rbx,4),%xmm1
movups 0x0(%r13,%rbx,4),%xmm2
movups 0x10(%r13,%rbx,4),%xmm3
movups %xmm2,(%rsi,%rbx,4)
movups %xmm3,0x10(%rsi,%rbx,4)
movups %xmm0,0x0(%r13,%rbx,4)
movups %xmm1,0x10(%r13,%rbx,4)
mov    0x48(%rsp),%rdi
cmp    %rdi,%rax
mov    0x10(%rsp),%r10
je     165e <ss_mintrosort+0x50e>
sub    %edi,%edx
lea    0x0(%r13,%rdi,4),%r13
lea    (%rsi,%rdi,4),%r9
jmp    162e <ss_mintrosort+0x4de>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1ba7 <ss_mintrosort+0xa57>
neg    %rdi
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x10(%rsp),%rdx
lea    (%rdx,%rdi,4),%rdx
add    $0x30,%rdx
xor    %edi,%edi
nopl   (%rax)
movups (%rcx,%rdi,4),%xmm0
movups 0x10(%rcx,%rdi,4),%xmm1
movups -0x30(%rdx,%rdi,4),%xmm2
movups -0x20(%rdx,%rdi,4),%xmm3
movups %xmm2,(%rcx,%rdi,4)
movups %xmm3,0x10(%rcx,%rdi,4)
movups %xmm0,-0x30(%rdx,%rdi,4)
movups %xmm1,-0x20(%rdx,%rdi,4)
movups 0x20(%rcx,%rdi,4),%xmm0
movups 0x30(%rcx,%rdi,4),%xmm1
movups -0x10(%rdx,%rdi,4),%xmm2
movups (%rdx,%rdi,4),%xmm3
movups %xmm2,0x20(%rcx,%rdi,4)
movups %xmm3,0x30(%rcx,%rdi,4)
movups %xmm0,-0x10(%rdx,%rdi,4)
movups %xmm1,(%rdx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1840 <ss_mintrosort+0x6f0>
test   $0x1,%r9b
je     18c0 <ss_mintrosort+0x770>
movups (%rcx,%rdi,4),%xmm0
movups 0x10(%rcx,%rdi,4),%xmm1
movups (%rax,%rdi,4),%xmm2
movups 0x10(%rax,%rdi,4),%xmm3
movups %xmm2,(%rcx,%rdi,4)
movups %xmm3,0x10(%rcx,%rdi,4)
movups %xmm0,(%rax,%rdi,4)
movups %xmm1,0x10(%rax,%rdi,4)
cmp    %r8,%r10
mov    0x28(%rsp),%rsi
mov    0x10(%rsp),%r10
je     18f8 <ss_mintrosort+0x7a8>
sub    %r8d,%ebx
lea    (%rax,%r8,4),%rax
lea    (%rcx,%r8,4),%rcx
add    $0x1,%ebx
xor    %edx,%edx
nop
mov    (%rcx,%rdx,1),%ebp
mov    (%rax,%rdx,1),%edi
mov    %edi,(%rcx,%rdx,1)
mov    %ebp,(%rax,%rdx,1)
add    $0xffffffff,%ebx
add    $0x4,%rdx
cmp    $0x1,%ebx
ja     18e0 <ss_mintrosort+0x790>
mov    0x38(%rsp),%rbp
lea    (%rsi,%rbp,4),%r13
lea    0x0(,%r14,4),%rcx
mov    %r10,%rdx
sub    %rcx,%rdx
movslq (%rsi,%rbp,4),%rcx
movslq (%r15,%rcx,4),%rcx
mov    %r13,0x18(%rsp)
cmp    -0x1(%rcx,%r12,1),%r11b
jbe    194a <ss_mintrosort+0x7fa>
mov    %r15,%rdi
mov    0x18(%rsp),%rsi
mov    0x8(%rsp),%rcx
xor    %eax,%eax
mov    %rdx,%rbx
call   1050 <ss_partition@plt>
mov    %rbx,%rdx
mov    0x10(%rsp),%r10
mov    0x28(%rsp),%rsi
movslq %eax,%r13
mov    %rdx,%rdi
sub    %r13,%rdi
sar    $0x2,%rdi
cmp    %r14,%rbp
mov    0x30(%rsp),%rbx
jle    19dd <ss_mintrosort+0x88d>
movslq %ebx,%rax
cmp    %rdi,%rbp
jle    1a5c <ss_mintrosort+0x90c>
lea    (%rax,%rax,2),%rax
mov    %rsi,0x50(%rsp,%rax,8)
lea    0x1(%rbx),%ecx
mov    0x18(%rsp),%rsi
mov    %rsi,0x58(%rsp,%rax,8)
mov    0x8(%rsp),%rbp
mov    %ebp,0x60(%rsp,%rax,8)
mov    0x24(%rsp),%esi
mov    %esi,0x64(%rsp,%rax,8)
movslq %ecx,%rax
mov    %rbx,%r12
lea    (%rax,%rax,2),%rbx
lea    (%rsp,%rbx,8),%rax
add    $0x50,%rax
cmp    %rdi,%r14
jle    1b2d <ss_mintrosort+0x9dd>
mov    %rdx,(%rax)
mov    %r10,0x58(%rsp,%rbx,8)
mov    %ebp,0x60(%rsp,%rbx,8)
add    $0x2,%r12d
mov    %esi,0x64(%rsp,%rbx,8)
add    $0x1,%ebp
mov    %rbp,0x8(%rsp)
xor    %eax,%eax
mov    %rdx,%rbx
call   1030 <ss_ilg@plt>
mov    %rbx,%r10
mov    %r12,%rbx
jmp    118a <ss_mintrosort+0x3a>
cmp    %rdi,%r14
jle    1ac3 <ss_mintrosort+0x973>
movslq %ebx,%rax
lea    (%rax,%rax,2),%rax
mov    %rdx,0x50(%rsp,%rax,8)
mov    %r10,0x58(%rsp,%rax,8)
lea    0x1(%rbx),%r9d
mov    0x8(%rsp),%rcx
mov    %ecx,0x60(%rsp,%rax,8)
mov    0x24(%rsp),%r8d
mov    %r8d,0x64(%rsp,%rax,8)
movslq %r9d,%rax
mov    %rbp,%r9
lea    (%rax,%rax,2),%rbp
lea    (%rsp,%rbp,8),%rax
add    $0x50,%rax
cmp    %rdi,%r9
jle    1b61 <ss_mintrosort+0xa11>
mov    %rsi,(%rax)
mov    0x18(%rsp),%rax
mov    %rax,0x58(%rsp,%rbp,8)
mov    %ecx,0x60(%rsp,%rbp,8)
add    $0x2,%ebx
mov    %r8d,0x64(%rsp,%rbp,8)
add    $0x1,%ecx
mov    %rcx,0x8(%rsp)
xor    %eax,%eax
mov    %rdx,%rbp
call   1030 <ss_ilg@plt>
mov    %rbp,%r10
jmp    118a <ss_mintrosort+0x3a>
mov    %rbx,%rbp
lea    (%rax,%rax,2),%rbx
mov    %r13,0x50(%rsp,%rbx,8)
mov    %rdx,0x58(%rsp,%rbx,8)
mov    0x8(%rsp),%r14
lea    0x1(%r14),%eax
mov    %eax,0x60(%rsp,%rbx,8)
xor    %eax,%eax
mov    %rsi,%r12
mov    %rdx,%r13
call   1030 <ss_ilg@plt>
mov    0x10(%rsp),%r10
lea    0x1(%rbp),%ecx
mov    %eax,0x64(%rsp,%rbx,8)
mov    %rbp,%rbx
movslq %ecx,%rax
lea    (%rax,%rax,2),%rax
mov    %r12,0x50(%rsp,%rax,8)
mov    0x18(%rsp),%rcx
mov    %rcx,0x58(%rsp,%rax,8)
mov    %r14d,0x60(%rsp,%rax,8)
add    $0x2,%ebx
mov    0x24(%rsp),%ecx
mov    %ecx,0x64(%rsp,%rax,8)
mov    %ecx,%eax
jmp    118a <ss_mintrosort+0x3a>
movslq %ebx,%rbx
mov    %rbx,%rbp
lea    (%rbx,%rbx,2),%rbx
mov    %r13,0x50(%rsp,%rbx,8)
mov    %rdx,0x58(%rsp,%rbx,8)
mov    0x8(%rsp),%r14
lea    0x1(%r14),%eax
mov    %eax,0x60(%rsp,%rbx,8)
xor    %eax,%eax
mov    %r10,%r13
mov    %rdx,%r12
call   1030 <ss_ilg@plt>
lea    0x1(%rbp),%ecx
mov    %eax,0x64(%rsp,%rbx,8)
mov    %rbp,%rbx
movslq %ecx,%rax
lea    (%rax,%rax,2),%rax
mov    %r12,0x50(%rsp,%rax,8)
mov    %r13,0x58(%rsp,%rax,8)
mov    %r14d,0x60(%rsp,%rax,8)
add    $0x2,%ebx
mov    0x24(%rsp),%ecx
mov    %ecx,0x64(%rsp,%rax,8)
mov    0x18(%rsp),%r10
mov    0x28(%rsp),%r13
mov    %ecx,%eax
jmp    118a <ss_mintrosort+0x3a>
mov    %r13,(%rax)
mov    %rdx,0x58(%rsp,%rbx,8)
lea    0x1(%rbp),%eax
mov    %eax,0x60(%rsp,%rbx,8)
xor    %eax,%eax
mov    %esi,%r14d
mov    %rdx,%r13
call   1030 <ss_ilg@plt>
mov    0x10(%rsp),%r10
add    $0x2,%r12d
mov    %eax,0x64(%rsp,%rbx,8)
mov    %r14d,%eax
mov    %r12,%rbx
jmp    118a <ss_mintrosort+0x3a>
mov    %r13,(%rax)
mov    %rdx,0x58(%rsp,%rbp,8)
lea    0x1(%rcx),%eax
mov    %eax,0x60(%rsp,%rbp,8)
xor    %eax,%eax
mov    %rsi,%r13
mov    %r8d,%r14d
call   1030 <ss_ilg@plt>
add    $0x2,%ebx
mov    %eax,0x64(%rsp,%rbp,8)
mov    0x18(%rsp),%r10
mov    %r14d,%eax
jmp    118a <ss_mintrosort+0x3a>
xor    %ebx,%ebx
mov    0x28(%rsp),%rsi
test   $0x1,%r10b
jne    17b4 <ss_mintrosort+0x664>
jmp    17de <ss_mintrosort+0x68e>
xor    %edi,%edi
test   $0x1,%r9b
jne    189c <ss_mintrosort+0x74c>
jmp    18c0 <ss_mintrosort+0x770>
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 = call i32 (i64, ...) bitcast (i32 (...)* @ss_ilg to i32 (i64, ...)*)(i64 %30)
store i32 %31, i32* %22
br label %32
32: ; preds = %1137, %286, %82, %5
%33 = load i32*, i32** %9
%34 = load i32*, i32** %8
%35 = ptrtoint i32* %33 to i64
%36 = ptrtoint i32* %34 to i64
%37 = sub i64 %35, %36
%38 = sdiv exact i64 %37, 4
%39 = icmp sle i64 %38, 8
br i1 %39, label %40, label %83
40: ; preds = %32
%41 = load i32*, i32** %9
%42 = load i32*, i32** %8
%43 = ptrtoint i32* %41 to i64
%44 = ptrtoint i32* %42 to i64
%45 = sub i64 %43, %44
%46 = sdiv exact i64 %45, 4
%47 = icmp slt i64 1, %46
br i1 %47, label %48, label %55
48: ; preds = %40
%49 = load i8*, i8** %6
%50 = load i32*, i32** %7
%51 = load i32*, i32** %8
%52 = load i32*, i32** %9
%53 = load i32, i32* %10
%54 = call i32 (i8*, i32*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_insertionsort to i32 (i8*, i32*, i32*, i32*, i32, ...)*)(i8* %49, i32* %50, i32* %51, i32* %52, i32 %53)
br label %55
55: ; preds = %48, %40
br label %56
56: ; preds = %55
%57 = load i32, i32* %21
%58 = icmp eq i32 %57, 0
br i1 %58, label %59, label %60
59: ; preds = %56
ret void
60: ; preds = %56
%61 = load i32, i32* %21
%62 = add nsw i32 %61, -1
store i32 %62, i32* %21
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %63
%65 = getelementptr inbounds %struct.anon, %struct.anon* %64, i32 0, i32 0
%66 = load i32*, i32** %65
store i32* %66, i32** %8
%67 = load i32, i32* %21
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %68
%70 = getelementptr inbounds %struct.anon, %struct.anon* %69, i32 0, i32 1
%71 = load i32*, i32** %70
store i32* %71, i32** %9
%72 = load i32, i32* %21
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %73
%75 = getelementptr inbounds %struct.anon, %struct.anon* %74, i32 0, i32 2
%76 = load i32, i32* %75
store i32 %76, i32* %10
%77 = load i32, i32* %21
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %78
%80 = getelementptr inbounds %struct.anon, %struct.anon* %79, i32 0, i32 3
%81 = load i32, i32* %80
store i32 %81, i32* %22
br label %82
82: ; preds = %60
br label %32
83: ; preds = %32
%84 = load i8*, i8** %6
%85 = load i32, i32* %10
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i8, i8* %84, i64 %86
store i8* %87, i8** %12
%88 = load i32, i32* %22
%89 = add nsw i32 %88, -1
store i32 %89, i32* %22
%90 = icmp eq i32 %88, 0
br i1 %90, label %91, label %102
91: ; preds = %83
%92 = load i8*, i8** %12
%93 = load i32*, i32** %7
%94 = load i32*, i32** %8
%95 = load i32*, i32** %9
%96 = load i32*, i32** %8
%97 = ptrtoint i32* %95 to i64
%98 = ptrtoint i32* %96 to i64
%99 = sub i64 %97, %98
%100 = sdiv exact i64 %99, 4
%101 = call i32 (i8*, i32*, i32*, i64, ...) bitcast (i32 (...)* @ss_heapsort to i32 (i8*, i32*, i32*, i64, ...)*)(i8* %92, i32* %93, i32* %94, i64 %100)
br label %102
102: ; preds = %91, %83
%103 = load i32, i32* %22
%104 = icmp slt i32 %103, 0
br i1 %104, label %105, label %287
105: ; preds = %102
%106 = load i32*, i32** %8
%107 = getelementptr inbounds i32, i32* %106, i64 1
store i32* %107, i32** %13
%108 = load i8*, i8** %12
%109 = load i32*, i32** %7
%110 = load i32*, i32** %8
%111 = load i32, i32* %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i32, i32* %109, i64 %112
%114 = load i32, i32* %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i8, i8* %108, i64 %115
%117 = load i8, i8* %116
%118 = zext i8 %117 to i32
store i32 %118, i32* %23
br label %119
119: ; preds = %150, %105
%120 = load i32*, i32** %13
%121 = load i32*, i32** %9
%122 = icmp ult i32* %120, %121
br i1 %122, label %123, label %153
123: ; preds = %119
%124 = load i8*, i8** %12
%125 = load i32*, i32** %7
%126 = load i32*, i32** %13
%127 = load i32, i32* %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %125, i64 %128
%130 = load i32, i32* %129
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i8, i8* %124, i64 %131
%133 = load i8, i8* %132
%134 = zext i8 %133 to i32
store i32 %134, i32* %24
%135 = load i32, i32* %23
%136 = icmp ne i32 %134, %135
br i1 %136, label %137, label %149
137: ; preds = %123
%138 = load i32*, i32** %13
%139 = load i32*, i32** %8
%140 = ptrtoint i32* %138 to i64
%141 = ptrtoint i32* %139 to i64
%142 = sub i64 %140, %141
%143 = sdiv exact i64 %142, 4
%144 = icmp slt i64 1, %143
br i1 %144, label %145, label %146
145: ; preds = %137
br label %153
146: ; preds = %137
%147 = load i32, i32* %24
store i32 %147, i32* %23
%148 = load i32*, i32** %13
store i32* %148, i32** %8
br label %149
149: ; preds = %146, %123
br label %150
150: ; preds = %149
%151 = load i32*, i32** %13
%152 = getelementptr inbounds i32, i32* %151, i32 1
store i32* %152, i32** %13
br label %119
153: ; preds = %145, %119
%154 = load i8*, i8** %12
%155 = load i32*, i32** %7
%156 = load i32*, i32** %8
%157 = load i32, i32* %156
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i32, i32* %155, i64 %158
%160 = load i32, i32* %159
%161 = sub nsw i32 %160, 1
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i8, i8* %154, i64 %162
%164 = load i8, i8* %163
%165 = zext i8 %164 to i32
%166 = load i32, i32* %23
%167 = icmp slt i32 %165, %166
br i1 %167, label %168, label %176
168: ; preds = %153
%169 = load i32*, i32** %7
%170 = load i32*, i32** %8
%171 = load i32*, i32** %13
%172 = load i32, i32* %10
%173 = call i32 (i32*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_partition to i32 (i32*, i32*, i32*, i32, ...)*)(i32* %169, i32* %170, i32* %171, i32 %172)
%174 = sext i32 %173 to i64
%175 = inttoptr i64 %174 to i32*
store i32* %175, i32** %8
br label %176
176: ; preds = %168, %153
%177 = load i32*, i32** %13
%178 = load i32*, i32** %8
%179 = ptrtoint i32* %177 to i64
%180 = ptrtoint i32* %178 to i64
%181 = sub i64 %179, %180
%182 = sdiv exact i64 %181, 4
%183 = load i32*, i32** %9
%184 = load i32*, i32** %13
%185 = ptrtoint i32* %183 to i64
%186 = ptrtoint i32* %184 to i64
%187 = sub i64 %185, %186
%188 = sdiv exact i64 %187, 4
%189 = icmp sle i64 %182, %188
br i1 %189, label %190, label %234
190: ; preds = %176
%191 = load i32*, i32** %13
%192 = load i32*, i32** %8
%193 = ptrtoint i32* %191 to i64
%194 = ptrtoint i32* %192 to i64
%195 = sub i64 %193, %194
%196 = sdiv exact i64 %195, 4
%197 = icmp slt i64 1, %196
br i1 %197, label %198, label %231
198: ; preds = %190
br label %199
199: ; preds = %198
%200 = load i32*, i32** %13
%201 = load i32, i32* %21
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %202
%204 = getelementptr inbounds %struct.anon, %struct.anon* %203, i32 0, i32 0
store i32* %200, i32** %204
%205 = load i32*, i32** %9
%206 = load i32, i32* %21
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %207
%209 = getelementptr inbounds %struct.anon, %struct.anon* %208, i32 0, i32 1
store i32* %205, i32** %209
%210 = load i32, i32* %10
%211 = load i32, i32* %21
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %212
%214 = getelementptr inbounds %struct.anon, %struct.anon* %213, i32 0, i32 2
store i32 %210, i32* %214
%215 = load i32, i32* %21
%216 = add nsw i32 %215, 1
store i32 %216, i32* %21
%217 = sext i32 %215 to i64
%218 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %217
%219 = getelementptr inbounds %struct.anon, %struct.anon* %218, i32 0, i32 3
store i32 -1, i32* %219
br label %220
220: ; preds = %199
%221 = load i32*, i32** %13
store i32* %221, i32** %9
%222 = load i32, i32* %10
%223 = add nsw i32 %222, 1
store i32 %223, i32* %10
%224 = load i32*, i32** %13
%225 = load i32*, i32** %8
%226 = ptrtoint i32* %224 to i64
%227 = ptrtoint i32* %225 to i64
%228 = sub i64 %226, %227
%229 = sdiv exact i64 %228, 4
%230 = call i32 (i64, ...) bitcast (i32 (...)* @ss_ilg to i32 (i64, ...)*)(i64 %229)
store i32 %230, i32* %22
br label %233
231: ; preds = %190
%232 = load i32*, i32** %13
store i32* %232, i32** %8
store i32 -1, i32* %22
br label %233
233: ; preds = %231, %220
br label %286
234: ; preds = %176
%235 = load i32*, i32** %9
%236 = load i32*, i32** %13
%237 = ptrtoint i32* %235 to i64
%238 = ptrtoint i32* %236 to i64
%239 = sub i64 %237, %238
%240 = sdiv exact i64 %239, 4
%241 = icmp slt i64 1, %240
br i1 %241, label %242, label %274
242: ; preds = %234
br label %243
243: ; preds = %242
%244 = load i32*, i32** %8
%245 = load i32, i32* %21
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %246
%248 = getelementptr inbounds %struct.anon, %struct.anon* %247, i32 0, i32 0
store i32* %244, i32** %248
%249 = load i32*, i32** %13
%250 = load i32, i32* %21
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %251
%253 = getelementptr inbounds %struct.anon, %struct.anon* %252, i32 0, i32 1
store i32* %249, i32** %253
%254 = load i32, i32* %10
%255 = add nsw i32 %254, 1
%256 = load i32, i32* %21
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %257
%259 = getelementptr inbounds %struct.anon, %struct.anon* %258, i32 0, i32 2
store i32 %255, i32* %259
%260 = load i32*, i32** %13
%261 = load i32*, i32** %8
%262 = ptrtoint i32* %260 to i64
%263 = ptrtoint i32* %261 to i64
%264 = sub i64 %262, %263
%265 = sdiv exact i64 %264, 4
%266 = call i32 (i64, ...) bitcast (i32 (...)* @ss_ilg to i32 (i64, ...)*)(i64 %265)
%267 = load i32, i32* %21
%268 = add nsw i32 %267, 1
store i32 %268, i32* %21
%269 = sext i32 %267 to i64
%270 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %269
%271 = getelementptr inbounds %struct.anon, %struct.anon* %270, i32 0, i32 3
store i32 %266, i32* %271
br label %272
272: ; preds = %243
%273 = load i32*, i32** %13
store i32* %273, i32** %8
store i32 -1, i32* %22
br label %285
274: ; preds = %234
%275 = load i32*, i32** %13
store i32* %275, i32** %9
%276 = load i32, i32* %10
%277 = add nsw i32 %276, 1
store i32 %277, i32* %10
%278 = load i32*, i32** %13
%279 = load i32*, i32** %8
%280 = ptrtoint i32* %278 to i64
%281 = ptrtoint i32* %279 to i64
%282 = sub i64 %280, %281
%283 = sdiv exact i64 %282, 4
%284 = call i32 (i64, ...) bitcast (i32 (...)* @ss_ilg to i32 (i64, ...)*)(i64 %283)
store i32 %284, i32* %22
br label %285
285: ; preds = %274, %272
br label %286
286: ; preds = %285, %233
br label %32
287: ; preds = %102
%288 = load i8*, i8** %12
%289 = load i32*, i32** %7
%290 = load i32*, i32** %8
%291 = load i32*, i32** %9
%292 = call i32 (i8*, i32*, i32*, i32*, ...) bitcast (i32 (...)* @ss_pivot to i32 (i8*, i32*, i32*, i32*, ...)*)(i8* %288, i32* %289, i32* %290, i32* %291)
%293 = sext i32 %292 to i64
%294 = inttoptr i64 %293 to i32*
store i32* %294, i32** %13
%295 = load i8*, i8** %12
%296 = load i32*, i32** %7
%297 = load i32*, i32** %13
%298 = load i32, i32* %297
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds i32, i32* %296, i64 %299
%301 = load i32, i32* %300
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds i8, i8* %295, i64 %302
%304 = load i8, i8* %303
%305 = zext i8 %304 to i32
store i32 %305, i32* %23
br label %306
306: ; preds = %287
%307 = load i32*, i32** %8
%308 = load i32, i32* %307
store i32 %308, i32* %20
%309 = load i32*, i32** %13
%310 = load i32, i32* %309
%311 = load i32*, i32** %8
store i32 %310, i32* %311
%312 = load i32, i32* %20
%313 = load i32*, i32** %13
store i32 %312, i32* %313
br label %314
314: ; preds = %306
%315 = load i32*, i32** %8
store i32* %315, i32** %14
br label %316
316: ; preds = %337, %314
%317 = load i32*, i32** %14
%318 = getelementptr inbounds i32, i32* %317, i32 1
store i32* %318, i32** %14
%319 = load i32*, i32** %9
%320 = icmp ult i32* %318, %319
br i1 %320, label %321, label %335
321: ; preds = %316
%322 = load i8*, i8** %12
%323 = load i32*, i32** %7
%324 = load i32*, i32** %14
%325 = load i32, i32* %324
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds i32, i32* %323, i64 %326
%328 = load i32, i32* %327
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i8, i8* %322, i64 %329
%331 = load i8, i8* %330
%332 = zext i8 %331 to i32
store i32 %332, i32* %24
%333 = load i32, i32* %23
%334 = icmp eq i32 %332, %333
br label %335
335: ; preds = %321, %316
%336 = phi i1 [ false, %316 ], [ %334, %321 ]
br i1 %336, label %337, label %338
337: ; preds = %335
br label %316
338: ; preds = %335
%339 = load i32*, i32** %14
store i32* %339, i32** %13
%340 = load i32*, i32** %9
%341 = icmp ult i32* %339, %340
br i1 %341, label %342, label %386
342: ; preds = %338
%343 = load i32, i32* %24
%344 = load i32, i32* %23
%345 = icmp slt i32 %343, %344
br i1 %345, label %346, label %386
346: ; preds = %342
br label %347
347: ; preds = %384, %346
%348 = load i32*, i32** %14
%349 = getelementptr inbounds i32, i32* %348, i32 1
store i32* %349, i32** %14
%350 = load i32*, i32** %9
%351 = icmp ult i32* %349, %350
br i1 %351, label %352, label %366
352: ; preds = %347
%353 = load i8*, i8** %12
%354 = load i32*, i32** %7
%355 = load i32*, i32** %14
%356 = load i32, i32* %355
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds i32, i32* %354, i64 %357
%359 = load i32, i32* %358
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds i8, i8* %353, i64 %360
%362 = load i8, i8* %361
%363 = zext i8 %362 to i32
store i32 %363, i32* %24
%364 = load i32, i32* %23
%365 = icmp sle i32 %363, %364
br label %366
366: ; preds = %352, %347
%367 = phi i1 [ false, %347 ], [ %365, %352 ]
br i1 %367, label %368, label %385
368: ; preds = %366
%369 = load i32, i32* %24
%370 = load i32, i32* %23
%371 = icmp eq i32 %369, %370
br i1 %371, label %372, label %384
372: ; preds = %368
br label %373
373: ; preds = %372
%374 = load i32*, i32** %14
%375 = load i32, i32* %374
store i32 %375, i32* %20
%376 = load i32*, i32** %13
%377 = load i32, i32* %376
%378 = load i32*, i32** %14
store i32 %377, i32* %378
%379 = load i32, i32* %20
%380 = load i32*, i32** %13
store i32 %379, i32* %380
br label %381
381: ; preds = %373
%382 = load i32*, i32** %13
%383 = getelementptr inbounds i32, i32* %382, i32 1
store i32* %383, i32** %13
br label %384
384: ; preds = %381, %368
br label %347
385: ; preds = %366
br label %386
386: ; preds = %385, %342, %338
%387 = load i32*, i32** %9
store i32* %387, i32** %15
br label %388
388: ; preds = %409, %386
%389 = load i32*, i32** %14
%390 = load i32*, i32** %15
%391 = getelementptr inbounds i32, i32* %390, i32 -1
store i32* %391, i32** %15
%392 = icmp ult i32* %389, %391
br i1 %392, label %393, label %407
393: ; preds = %388
%394 = load i8*, i8** %12
%395 = load i32*, i32** %7
%396 = load i32*, i32** %15
%397 = load i32, i32* %396
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds i32, i32* %395, i64 %398
%400 = load i32, i32* %399
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds i8, i8* %394, i64 %401
%403 = load i8, i8* %402
%404 = zext i8 %403 to i32
store i32 %404, i32* %24
%405 = load i32, i32* %23
%406 = icmp eq i32 %404, %405
br label %407
407: ; preds = %393, %388
%408 = phi i1 [ false, %388 ], [ %406, %393 ]
br i1 %408, label %409, label %410
409: ; preds = %407
br label %388
410: ; preds = %407
%411 = load i32*, i32** %14
%412 = load i32*, i32** %15
store i32* %412, i32** %16
%413 = icmp ult i32* %411, %412
br i1 %413, label %414, label %458
414: ; preds = %410
%415 = load i32, i32* %24
%416 = load i32, i32* %23
%417 = icmp sgt i32 %415, %416
br i1 %417, label %418, label %458
418: ; preds = %414
br label %419
419: ; preds = %456, %418
%420 = load i32*, i32** %14
%421 = load i32*, i32** %15
%422 = getelementptr inbounds i32, i32* %421, i32 -1
store i32* %422, i32** %15
%423 = icmp ult i32* %420, %422
br i1 %423, label %424, label %438
424: ; preds = %419
%425 = load i8*, i8** %12
%426 = load i32*, i32** %7
%427 = load i32*, i32** %15
%428 = load i32, i32* %427
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds i32, i32* %426, i64 %429
%431 = load i32, i32* %430
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds i8, i8* %425, i64 %432
%434 = load i8, i8* %433
%435 = zext i8 %434 to i32
store i32 %435, i32* %24
%436 = load i32, i32* %23
%437 = icmp sge i32 %435, %436
br label %438
438: ; preds = %424, %419
%439 = phi i1 [ false, %419 ], [ %437, %424 ]
br i1 %439, label %440, label %457
440: ; preds = %438
%441 = load i32, i32* %24
%442 = load i32, i32* %23
%443 = icmp eq i32 %441, %442
br i1 %443, label %444, label %456
444: ; preds = %440
br label %445
445: ; preds = %444
%446 = load i32*, i32** %15
%447 = load i32, i32* %446
store i32 %447, i32* %20
%448 = load i32*, i32** %16
%449 = load i32, i32* %448
%450 = load i32*, i32** %15
store i32 %449, i32* %450
%451 = load i32, i32* %20
%452 = load i32*, i32** %16
store i32 %451, i32* %452
br label %453
453: ; preds = %445
%454 = load i32*, i32** %16
%455 = getelementptr inbounds i32, i32* %454, i32 -1
store i32* %455, i32** %16
br label %456
456: ; preds = %453, %440
br label %419
457: ; preds = %438
br label %458
458: ; preds = %457, %414, %410
br label %459
459: ; preds = %550, %458
%460 = load i32*, i32** %14
%461 = load i32*, i32** %15
%462 = icmp ult i32* %460, %461
br i1 %462, label %463, label %551
463: ; preds = %459
br label %464
464: ; preds = %463
%465 = load i32*, i32** %14
%466 = load i32, i32* %465
store i32 %466, i32* %20
%467 = load i32*, i32** %15
%468 = load i32, i32* %467
%469 = load i32*, i32** %14
store i32 %468, i32* %469
%470 = load i32, i32* %20
%471 = load i32*, i32** %15
store i32 %470, i32* %471
br label %472
472: ; preds = %464
br label %473
473: ; preds = %510, %472
%474 = load i32*, i32** %14
%475 = getelementptr inbounds i32, i32* %474, i32 1
store i32* %475, i32** %14
%476 = load i32*, i32** %15
%477 = icmp ult i32* %475, %476
br i1 %477, label %478, label %492
478: ; preds = %473
%479 = load i8*, i8** %12
%480 = load i32*, i32** %7
%481 = load i32*, i32** %14
%482 = load i32, i32* %481
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds i32, i32* %480, i64 %483
%485 = load i32, i32* %484
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds i8, i8* %479, i64 %486
%488 = load i8, i8* %487
%489 = zext i8 %488 to i32
store i32 %489, i32* %24
%490 = load i32, i32* %23
%491 = icmp sle i32 %489, %490
br label %492
492: ; preds = %478, %473
%493 = phi i1 [ false, %473 ], [ %491, %478 ]
br i1 %493, label %494, label %511
494: ; preds = %492
%495 = load i32, i32* %24
%496 = load i32, i32* %23
%497 = icmp eq i32 %495, %496
br i1 %497, label %498, label %510
498: ; preds = %494
br label %499
499: ; preds = %498
%500 = load i32*, i32** %14
%501 = load i32, i32* %500
store i32 %501, i32* %20
%502 = load i32*, i32** %13
%503 = load i32, i32* %502
%504 = load i32*, i32** %14
store i32 %503, i32* %504
%505 = load i32, i32* %20
%506 = load i32*, i32** %13
store i32 %505, i32* %506
br label %507
507: ; preds = %499
%508 = load i32*, i32** %13
%509 = getelementptr inbounds i32, i32* %508, i32 1
store i32* %509, i32** %13
br label %510
510: ; preds = %507, %494
br label %473
511: ; preds = %492
br label %512
512: ; preds = %549, %511
%513 = load i32*, i32** %14
%514 = load i32*, i32** %15
%515 = getelementptr inbounds i32, i32* %514, i32 -1
store i32* %515, i32** %15
%516 = icmp ult i32* %513, %515
br i1 %516, label %517, label %531
517: ; preds = %512
%518 = load i8*, i8** %12
%519 = load i32*, i32** %7
%520 = load i32*, i32** %15
%521 = load i32, i32* %520
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds i32, i32* %519, i64 %522
%524 = load i32, i32* %523
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds i8, i8* %518, i64 %525
%527 = load i8, i8* %526
%528 = zext i8 %527 to i32
store i32 %528, i32* %24
%529 = load i32, i32* %23
%530 = icmp sge i32 %528, %529
br label %531
531: ; preds = %517, %512
%532 = phi i1 [ false, %512 ], [ %530, %517 ]
br i1 %532, label %533, label %550
533: ; preds = %531
%534 = load i32, i32* %24
%535 = load i32, i32* %23
%536 = icmp eq i32 %534, %535
br i1 %536, label %537, label %549
537: ; preds = %533
br label %538
538: ; preds = %537
%539 = load i32*, i32** %15
%540 = load i32, i32* %539
store i32 %540, i32* %20
%541 = load i32*, i32** %16
%542 = load i32, i32* %541
%543 = load i32*, i32** %15
store i32 %542, i32* %543
%544 = load i32, i32* %20
%545 = load i32*, i32** %16
store i32 %544, i32* %545
br label %546
546: ; preds = %538
%547 = load i32*, i32** %16
%548 = getelementptr inbounds i32, i32* %547, i32 -1
store i32* %548, i32** %16
br label %549
549: ; preds = %546, %533
br label %512
550: ; preds = %531
br label %459
551: ; preds = %459
%552 = load i32*, i32** %13
%553 = load i32*, i32** %16
%554 = icmp ule i32* %552, %553
br i1 %554, label %555, label %1102
555: ; preds = %551
%556 = load i32*, i32** %14
%557 = getelementptr inbounds i32, i32* %556, i64 -1
store i32* %557, i32** %15
%558 = load i32*, i32** %13
%559 = load i32*, i32** %8
%560 = ptrtoint i32* %558 to i64
%561 = ptrtoint i32* %559 to i64
%562 = sub i64 %560, %561
%563 = sdiv exact i64 %562, 4
%564 = trunc i64 %563 to i32
store i32 %564, i32* %19
%565 = load i32*, i32** %14
%566 = load i32*, i32** %13
%567 = ptrtoint i32* %565 to i64
%568 = ptrtoint i32* %566 to i64
%569 = sub i64 %567, %568
%570 = sdiv exact i64 %569, 4
%571 = trunc i64 %570 to i32
store i32 %571, i32* %20
%572 = icmp sgt i32 %564, %571
br i1 %572, label %573, label %575
573: ; preds = %555
%574 = load i32, i32* %20
store i32 %574, i32* %19
br label %575
575: ; preds = %573, %555
%576 = load i32*, i32** %8
store i32* %576, i32** %17
%577 = load i32*, i32** %14
%578 = load i32, i32* %19
%579 = sext i32 %578 to i64
%580 = sub i64 0, %579
%581 = getelementptr inbounds i32, i32* %577, i64 %580
store i32* %581, i32** %18
br label %582
582: ; preds = %595, %575
%583 = load i32, i32* %19
%584 = icmp slt i32 0, %583
br i1 %584, label %585, label %602
585: ; preds = %582
br label %586
586: ; preds = %585
%587 = load i32*, i32** %17
%588 = load i32, i32* %587
store i32 %588, i32* %20
%589 = load i32*, i32** %18
%590 = load i32, i32* %589
%591 = load i32*, i32** %17
store i32 %590, i32* %591
%592 = load i32, i32* %20
%593 = load i32*, i32** %18
store i32 %592, i32* %593
br label %594
594: ; preds = %586
br label %595
595: ; preds = %594
%596 = load i32, i32* %19
%597 = add nsw i32 %596, -1
store i32 %597, i32* %19
%598 = load i32*, i32** %17
%599 = getelementptr inbounds i32, i32* %598, i32 1
store i32* %599, i32** %17
%600 = load i32*, i32** %18
%601 = getelementptr inbounds i32, i32* %600, i32 1
store i32* %601, i32** %18
br label %582
602: ; preds = %582
%603 = load i32*, i32** %16
%604 = load i32*, i32** %15
%605 = ptrtoint i32* %603 to i64
%606 = ptrtoint i32* %604 to i64
%607 = sub i64 %605, %606
%608 = sdiv exact i64 %607, 4
%609 = trunc i64 %608 to i32
store i32 %609, i32* %19
%610 = load i32*, i32** %9
%611 = load i32*, i32** %16
%612 = ptrtoint i32* %610 to i64
%613 = ptrtoint i32* %611 to i64
%614 = sub i64 %612, %613
%615 = sdiv exact i64 %614, 4
%616 = sub nsw i64 %615, 1
%617 = trunc i64 %616 to i32
store i32 %617, i32* %20
%618 = icmp sgt i32 %609, %617
br i1 %618, label %619, label %621
619: ; preds = %602
%620 = load i32, i32* %20
store i32 %620, i32* %19
br label %621
621: ; preds = %619, %602
%622 = load i32*, i32** %14
store i32* %622, i32** %17
%623 = load i32*, i32** %9
%624 = load i32, i32* %19
%625 = sext i32 %624 to i64
%626 = sub i64 0, %625
%627 = getelementptr inbounds i32, i32* %623, i64 %626
store i32* %627, i32** %18
br label %628
628: ; preds = %641, %621
%629 = load i32, i32* %19
%630 = icmp slt i32 0, %629
br i1 %630, label %631, label %648
631: ; preds = %628
br label %632
632: ; preds = %631
%633 = load i32*, i32** %17
%634 = load i32, i32* %633
store i32 %634, i32* %20
%635 = load i32*, i32** %18
%636 = load i32, i32* %635
%637 = load i32*, i32** %17
store i32 %636, i32* %637
%638 = load i32, i32* %20
%639 = load i32*, i32** %18
store i32 %638, i32* %639
br label %640
640: ; preds = %632
br label %641
641: ; preds = %640
%642 = load i32, i32* %19
%643 = add nsw i32 %642, -1
store i32 %643, i32* %19
%644 = load i32*, i32** %17
%645 = getelementptr inbounds i32, i32* %644, i32 1
store i32* %645, i32** %17
%646 = load i32*, i32** %18
%647 = getelementptr inbounds i32, i32* %646, i32 1
store i32* %647, i32** %18
br label %628
648: ; preds = %628
%649 = load i32*, i32** %8
%650 = load i32*, i32** %14
%651 = load i32*, i32** %13
%652 = ptrtoint i32* %650 to i64
%653 = ptrtoint i32* %651 to i64
%654 = sub i64 %652, %653
%655 = sdiv exact i64 %654, 4
%656 = getelementptr inbounds i32, i32* %649, i64 %655
store i32* %656, i32** %13
%657 = load i32*, i32** %9
%658 = load i32*, i32** %16
%659 = load i32*, i32** %15
%660 = ptrtoint i32* %658 to i64
%661 = ptrtoint i32* %659 to i64
%662 = sub i64 %660, %661
%663 = sdiv exact i64 %662, 4
%664 = sub i64 0, %663
%665 = getelementptr inbounds i32, i32* %657, i64 %664
store i32* %665, i32** %15
%666 = load i32, i32* %23
%667 = load i8*, i8** %12
%668 = load i32*, i32** %7
%669 = load i32*, i32** %13
%670 = load i32, i32* %669
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds i32, i32* %668, i64 %671
%673 = load i32, i32* %672
%674 = sub nsw i32 %673, 1
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds i8, i8* %667, i64 %675
%677 = load i8, i8* %676
%678 = zext i8 %677 to i32
%679 = icmp sle i32 %666, %678
br i1 %679, label %680, label %682
680: ; preds = %648
%681 = load i32*, i32** %13
br label %690
682: ; preds = %648
%683 = load i32*, i32** %7
%684 = load i32*, i32** %13
%685 = load i32*, i32** %15
%686 = load i32, i32* %10
%687 = call i32 (i32*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_partition to i32 (i32*, i32*, i32*, i32, ...)*)(i32* %683, i32* %684, i32* %685, i32 %686)
%688 = sext i32 %687 to i64
%689 = inttoptr i64 %688 to i32*
br label %690
690: ; preds = %682, %680
%691 = phi i32* [ %681, %680 ], [ %689, %682 ]
store i32* %691, i32** %14
%692 = load i32*, i32** %13
%693 = load i32*, i32** %8
%694 = ptrtoint i32* %692 to i64
%695 = ptrtoint i32* %693 to i64
%696 = sub i64 %694, %695
%697 = sdiv exact i64 %696, 4
%698 = load i32*, i32** %9
%699 = load i32*, i32** %15
%700 = ptrtoint i32* %698 to i64
%701 = ptrtoint i32* %699 to i64
%702 = sub i64 %700, %701
%703 = sdiv exact i64 %702, 4
%704 = icmp sle i64 %697, %703
br i1 %704, label %705, label %903
705: ; preds = %690
%706 = load i32*, i32** %9
%707 = load i32*, i32** %15
%708 = ptrtoint i32* %706 to i64
%709 = ptrtoint i32* %707 to i64
%710 = sub i64 %708, %709
%711 = sdiv exact i64 %710, 4
%712 = load i32*, i32** %15
%713 = load i32*, i32** %14
%714 = ptrtoint i32* %712 to i64
%715 = ptrtoint i32* %713 to i64
%716 = sub i64 %714, %715
%717 = sdiv exact i64 %716, 4
%718 = icmp sle i64 %711, %717
br i1 %718, label %719, label %774
719: ; preds = %705
br label %720
720: ; preds = %719
%721 = load i32*, i32** %14
%722 = load i32, i32* %21
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %723
%725 = getelementptr inbounds %struct.anon, %struct.anon* %724, i32 0, i32 0
store i32* %721, i32** %725
%726 = load i32*, i32** %15
%727 = load i32, i32* %21
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %728
%730 = getelementptr inbounds %struct.anon, %struct.anon* %729, i32 0, i32 1
store i32* %726, i32** %730
%731 = load i32, i32* %10
%732 = add nsw i32 %731, 1
%733 = load i32, i32* %21
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %734
%736 = getelementptr inbounds %struct.anon, %struct.anon* %735, i32 0, i32 2
store i32 %732, i32* %736
%737 = load i32*, i32** %15
%738 = load i32*, i32** %14
%739 = ptrtoint i32* %737 to i64
%740 = ptrtoint i32* %738 to i64
%741 = sub i64 %739, %740
%742 = sdiv exact i64 %741, 4
%743 = call i32 (i64, ...) bitcast (i32 (...)* @ss_ilg to i32 (i64, ...)*)(i64 %742)
%744 = load i32, i32* %21
%745 = add nsw i32 %744, 1
store i32 %745, i32* %21
%746 = sext i32 %744 to i64
%747 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %746
%748 = getelementptr inbounds %struct.anon, %struct.anon* %747, i32 0, i32 3
store i32 %743, i32* %748
br label %749
749: ; preds = %720
br label %750
750: ; preds = %749
%751 = load i32*, i32** %15
%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 0
store i32* %751, i32** %755
%756 = load i32*, i32** %9
%757 = load i32, i32* %21
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %758
%760 = getelementptr inbounds %struct.anon, %struct.anon* %759, i32 0, i32 1
store i32* %756, i32** %760
%761 = load i32, i32* %10
%762 = load i32, i32* %21
%763 = sext i32 %762 to i64
%764 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %763
%765 = getelementptr inbounds %struct.anon, %struct.anon* %764, i32 0, i32 2
store i32 %761, i32* %765
%766 = load i32, i32* %22
%767 = load i32, i32* %21
%768 = add nsw i32 %767, 1
store i32 %768, i32* %21
%769 = sext i32 %767 to i64
%770 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %769
%771 = getelementptr inbounds %struct.anon, %struct.anon* %770, i32 0, i32 3
store i32 %766, i32* %771
br label %772
772: ; preds = %750
%773 = load i32*, i32** %13
store i32* %773, i32** %9
br label %902
774: ; preds = %705
%775 = load i32*, i32** %13
%776 = load i32*, i32** %8
%777 = ptrtoint i32* %775 to i64
%778 = ptrtoint i32* %776 to i64
%779 = sub i64 %777, %778
%780 = sdiv exact i64 %779, 4
%781 = load i32*, i32** %15
%782 = load i32*, i32** %14
%783 = ptrtoint i32* %781 to i64
%784 = ptrtoint i32* %782 to i64
%785 = sub i64 %783, %784
%786 = sdiv exact i64 %785, 4
%787 = icmp sle i64 %780, %786
br i1 %787, label %788, label %843
788: ; preds = %774
br label %789
789: ; preds = %788
%790 = load i32*, i32** %15
%791 = load i32, i32* %21
%792 = sext i32 %791 to i64
%793 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %792
%794 = getelementptr inbounds %struct.anon, %struct.anon* %793, i32 0, i32 0
store i32* %790, i32** %794
%795 = load i32*, i32** %9
%796 = load i32, i32* %21
%797 = sext i32 %796 to i64
%798 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %797
%799 = getelementptr inbounds %struct.anon, %struct.anon* %798, i32 0, i32 1
store i32* %795, i32** %799
%800 = load i32, i32* %10
%801 = load i32, i32* %21
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %802
%804 = getelementptr inbounds %struct.anon, %struct.anon* %803, i32 0, i32 2
store i32 %800, i32* %804
%805 = load i32, i32* %22
%806 = load i32, i32* %21
%807 = add nsw i32 %806, 1
store i32 %807, i32* %21
%808 = sext i32 %806 to i64
%809 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %808
%810 = getelementptr inbounds %struct.anon, %struct.anon* %809, i32 0, i32 3
store i32 %805, i32* %810
br label %811
811: ; preds = %789
br label %812
812: ; preds = %811
%813 = load i32*, i32** %14
%814 = load i32, i32* %21
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %815
%817 = getelementptr inbounds %struct.anon, %struct.anon* %816, i32 0, i32 0
store i32* %813, i32** %817
%818 = load i32*, i32** %15
%819 = load i32, i32* %21
%820 = sext i32 %819 to i64
%821 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %820
%822 = getelementptr inbounds %struct.anon, %struct.anon* %821, i32 0, i32 1
store i32* %818, i32** %822
%823 = load i32, i32* %10
%824 = add nsw i32 %823, 1
%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 2
store i32 %824, i32* %828
%829 = load i32*, i32** %15
%830 = load i32*, i32** %14
%831 = ptrtoint i32* %829 to i64
%832 = ptrtoint i32* %830 to i64
%833 = sub i64 %831, %832
%834 = sdiv exact i64 %833, 4
%835 = call i32 (i64, ...) bitcast (i32 (...)* @ss_ilg to i32 (i64, ...)*)(i64 %834)
%836 = load i32, i32* %21
%837 = add nsw i32 %836, 1
store i32 %837, i32* %21
%838 = sext i32 %836 to i64
%839 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %838
%840 = getelementptr inbounds %struct.anon, %struct.anon* %839, i32 0, i32 3
store i32 %835, i32* %840
br label %841
841: ; preds = %812
%842 = load i32*, i32** %13
store i32* %842, i32** %9
br label %901
843: ; preds = %774
br label %844
844: ; preds = %843
%845 = load i32*, i32** %15
%846 = load i32, i32* %21
%847 = sext i32 %846 to i64
%848 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %847
%849 = getelementptr inbounds %struct.anon, %struct.anon* %848, i32 0, i32 0
store i32* %845, i32** %849
%850 = load i32*, i32** %9
%851 = load i32, i32* %21
%852 = sext i32 %851 to i64
%853 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %852
%854 = getelementptr inbounds %struct.anon, %struct.anon* %853, i32 0, i32 1
store i32* %850, i32** %854
%855 = load i32, i32* %10
%856 = load i32, i32* %21
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %857
%859 = getelementptr inbounds %struct.anon, %struct.anon* %858, i32 0, i32 2
store i32 %855, i32* %859
%860 = load i32, i32* %22
%861 = load i32, i32* %21
%862 = add nsw i32 %861, 1
store i32 %862, i32* %21
%863 = sext i32 %861 to i64
%864 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %863
%865 = getelementptr inbounds %struct.anon, %struct.anon* %864, i32 0, i32 3
store i32 %860, i32* %865
br label %866
866: ; preds = %844
br label %867
867: ; preds = %866
%868 = load i32*, i32** %8
%869 = load i32, i32* %21
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %870
%872 = getelementptr inbounds %struct.anon, %struct.anon* %871, i32 0, i32 0
store i32* %868, i32** %872
%873 = load i32*, i32** %13
%874 = load i32, i32* %21
%875 = sext i32 %874 to i64
%876 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %875
%877 = getelementptr inbounds %struct.anon, %struct.anon* %876, i32 0, i32 1
store i32* %873, i32** %877
%878 = load i32, i32* %10
%879 = load i32, i32* %21
%880 = sext i32 %879 to i64
%881 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %880
%882 = getelementptr inbounds %struct.anon, %struct.anon* %881, i32 0, i32 2
store i32 %878, i32* %882
%883 = load i32, i32* %22
%884 = load i32, i32* %21
%885 = add nsw i32 %884, 1
store i32 %885, i32* %21
%886 = sext i32 %884 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 3
store i32 %883, i32* %888
br label %889
889: ; preds = %867
%890 = load i32*, i32** %14
store i32* %890, i32** %8
%891 = load i32*, i32** %15
store i32* %891, i32** %9
%892 = load i32, i32* %10
%893 = add nsw i32 %892, 1
store i32 %893, i32* %10
%894 = load i32*, i32** %15
%895 = load i32*, i32** %14
%896 = ptrtoint i32* %894 to i64
%897 = ptrtoint i32* %895 to i64
%898 = sub i64 %896, %897
%899 = sdiv exact i64 %898, 4
%900 = call i32 (i64, ...) bitcast (i32 (...)* @ss_ilg to i32 (i64, ...)*)(i64 %899)
store i32 %900, i32* %22
br label %901
901: ; preds = %889, %841
br label %902
902: ; preds = %901, %772
br label %1101
903: ; preds = %690
%904 = load i32*, i32** %13
%905 = load i32*, i32** %8
%906 = ptrtoint i32* %904 to i64
%907 = ptrtoint i32* %905 to i64
%908 = sub i64 %906, %907
%909 = sdiv exact i64 %908, 4
%910 = load i32*, i32** %15
%911 = load i32*, i32** %14
%912 = ptrtoint i32* %910 to i64
%913 = ptrtoint i32* %911 to i64
%914 = sub i64 %912, %913
%915 = sdiv exact i64 %914, 4
%916 = icmp sle i64 %909, %915
br i1 %916, label %917, label %972
917: ; preds = %903
br label %918
918: ; preds = %917
%919 = load i32*, i32** %14
%920 = load i32, i32* %21
%921 = sext i32 %920 to i64
%922 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %921
%923 = getelementptr inbounds %struct.anon, %struct.anon* %922, i32 0, i32 0
store i32* %919, i32** %923
%924 = load i32*, i32** %15
%925 = load i32, i32* %21
%926 = sext i32 %925 to i64
%927 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %926
%928 = getelementptr inbounds %struct.anon, %struct.anon* %927, i32 0, i32 1
store i32* %924, i32** %928
%929 = load i32, i32* %10
%930 = add nsw i32 %929, 1
%931 = load i32, i32* %21
%932 = sext i32 %931 to i64
%933 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %932
%934 = getelementptr inbounds %struct.anon, %struct.anon* %933, i32 0, i32 2
store i32 %930, i32* %934
%935 = load i32*, i32** %15
%936 = load i32*, i32** %14
%937 = ptrtoint i32* %935 to i64
%938 = ptrtoint i32* %936 to i64
%939 = sub i64 %937, %938
%940 = sdiv exact i64 %939, 4
%941 = call i32 (i64, ...) bitcast (i32 (...)* @ss_ilg to i32 (i64, ...)*)(i64 %940)
%942 = load i32, i32* %21
%943 = add nsw i32 %942, 1
store i32 %943, i32* %21
%944 = sext i32 %942 to i64
%945 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %944
%946 = getelementptr inbounds %struct.anon, %struct.anon* %945, i32 0, i32 3
store i32 %941, i32* %946
br label %947
947: ; preds = %918
br label %948
948: ; preds = %947
%949 = load i32*, i32** %8
%950 = load i32, i32* %21
%951 = sext i32 %950 to i64
%952 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %951
%953 = getelementptr inbounds %struct.anon, %struct.anon* %952, i32 0, i32 0
store i32* %949, i32** %953
%954 = load i32*, i32** %13
%955 = load i32, i32* %21
%956 = sext i32 %955 to i64
%957 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %956
%958 = getelementptr inbounds %struct.anon, %struct.anon* %957, i32 0, i32 1
store i32* %954, i32** %958
%959 = load i32, i32* %10
%960 = load i32, i32* %21
%961 = sext i32 %960 to i64
%962 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %961
%963 = getelementptr inbounds %struct.anon, %struct.anon* %962, i32 0, i32 2
store i32 %959, i32* %963
%964 = load i32, i32* %22
%965 = load i32, i32* %21
%966 = add nsw i32 %965, 1
store i32 %966, i32* %21
%967 = sext i32 %965 to i64
%968 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %967
%969 = getelementptr inbounds %struct.anon, %struct.anon* %968, i32 0, i32 3
store i32 %964, i32* %969
br label %970
970: ; preds = %948
%971 = load i32*, i32** %15
store i32* %971, i32** %8
br label %1100
972: ; preds = %903
%973 = load i32*, i32** %9
%974 = load i32*, i32** %15
%975 = ptrtoint i32* %973 to i64
%976 = ptrtoint i32* %974 to i64
%977 = sub i64 %975, %976
%978 = sdiv exact i64 %977, 4
%979 = load i32*, i32** %15
%980 = load i32*, i32** %14
%981 = ptrtoint i32* %979 to i64
%982 = ptrtoint i32* %980 to i64
%983 = sub i64 %981, %982
%984 = sdiv exact i64 %983, 4
%985 = icmp sle i64 %978, %984
br i1 %985, label %986, label %1041
986: ; preds = %972
br label %987
987: ; preds = %986
%988 = load i32*, i32** %8
%989 = load i32, i32* %21
%990 = sext i32 %989 to i64
%991 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %990
%992 = getelementptr inbounds %struct.anon, %struct.anon* %991, i32 0, i32 0
store i32* %988, i32** %992
%993 = load i32*, i32** %13
%994 = load i32, i32* %21
%995 = sext i32 %994 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 1
store i32* %993, i32** %997
%998 = load i32, i32* %10
%999 = load i32, i32* %21
%1000 = sext i32 %999 to i64
%1001 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1000
%1002 = getelementptr inbounds %struct.anon, %struct.anon* %1001, i32 0, i32 2
store i32 %998, i32* %1002
%1003 = load i32, i32* %22
%1004 = load i32, i32* %21
%1005 = add nsw i32 %1004, 1
store i32 %1005, i32* %21
%1006 = sext i32 %1004 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 3
store i32 %1003, i32* %1008
br label %1009
1009: ; preds = %987
br label %1010
1010: ; preds = %1009
%1011 = load i32*, i32** %14
%1012 = load i32, i32* %21
%1013 = sext i32 %1012 to i64
%1014 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1013
%1015 = getelementptr inbounds %struct.anon, %struct.anon* %1014, i32 0, i32 0
store i32* %1011, i32** %1015
%1016 = load i32*, i32** %15
%1017 = load i32, i32* %21
%1018 = sext i32 %1017 to i64
%1019 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1018
%1020 = getelementptr inbounds %struct.anon, %struct.anon* %1019, i32 0, i32 1
store i32* %1016, i32** %1020
%1021 = load i32, i32* %10
%1022 = add nsw i32 %1021, 1
%1023 = load i32, i32* %21
%1024 = sext i32 %1023 to i64
%1025 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1024
%1026 = getelementptr inbounds %struct.anon, %struct.anon* %1025, i32 0, i32 2
store i32 %1022, i32* %1026
%1027 = load i32*, i32** %15
%1028 = load i32*, i32** %14
%1029 = ptrtoint i32* %1027 to i64
%1030 = ptrtoint i32* %1028 to i64
%1031 = sub i64 %1029, %1030
%1032 = sdiv exact i64 %1031, 4
%1033 = call i32 (i64, ...) bitcast (i32 (...)* @ss_ilg to i32 (i64, ...)*)(i64 %1032)
%1034 = load i32, i32* %21
%1035 = add nsw i32 %1034, 1
store i32 %1035, i32* %21
%1036 = sext i32 %1034 to i64
%1037 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1036
%1038 = getelementptr inbounds %struct.anon, %struct.anon* %1037, i32 0, i32 3
store i32 %1033, i32* %1038
br label %1039
1039: ; preds = %1010
%1040 = load i32*, i32** %15
store i32* %1040, i32** %8
br label %1099
1041: ; preds = %972
br label %1042
1042: ; preds = %1041
%1043 = load i32*, i32** %8
%1044 = load i32, i32* %21
%1045 = sext i32 %1044 to i64
%1046 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1045
%1047 = getelementptr inbounds %struct.anon, %struct.anon* %1046, i32 0, i32 0
store i32* %1043, i32** %1047
%1048 = load i32*, i32** %13
%1049 = load i32, i32* %21
%1050 = sext i32 %1049 to i64
%1051 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1050
%1052 = getelementptr inbounds %struct.anon, %struct.anon* %1051, i32 0, i32 1
store i32* %1048, i32** %1052
%1053 = load i32, i32* %10
%1054 = load i32, i32* %21
%1055 = sext i32 %1054 to i64
%1056 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1055
%1057 = getelementptr inbounds %struct.anon, %struct.anon* %1056, i32 0, i32 2
store i32 %1053, i32* %1057
%1058 = load i32, i32* %22
%1059 = load i32, i32* %21
%1060 = add nsw i32 %1059, 1
store i32 %1060, i32* %21
%1061 = sext i32 %1059 to i64
%1062 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1061
%1063 = getelementptr inbounds %struct.anon, %struct.anon* %1062, i32 0, i32 3
store i32 %1058, i32* %1063
br label %1064
1064: ; preds = %1042
br label %1065
1065: ; preds = %1064
%1066 = load i32*, i32** %15
%1067 = load i32, i32* %21
%1068 = sext i32 %1067 to i64
%1069 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1068
%1070 = getelementptr inbounds %struct.anon, %struct.anon* %1069, i32 0, i32 0
store i32* %1066, i32** %1070
%1071 = load i32*, i32** %9
%1072 = load i32, i32* %21
%1073 = sext i32 %1072 to i64
%1074 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1073
%1075 = getelementptr inbounds %struct.anon, %struct.anon* %1074, i32 0, i32 1
store i32* %1071, i32** %1075
%1076 = load i32, i32* %10
%1077 = load i32, i32* %21
%1078 = sext i32 %1077 to i64
%1079 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1078
%1080 = getelementptr inbounds %struct.anon, %struct.anon* %1079, i32 0, i32 2
store i32 %1076, i32* %1080
%1081 = load i32, i32* %22
%1082 = load i32, i32* %21
%1083 = add nsw i32 %1082, 1
store i32 %1083, i32* %21
%1084 = sext i32 %1082 to i64
%1085 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %11, i64 0, i64 %1084
%1086 = getelementptr inbounds %struct.anon, %struct.anon* %1085, i32 0, i32 3
store i32 %1081, i32* %1086
br label %1087
1087: ; preds = %1065
%1088 = load i32*, i32** %14
store i32* %1088, i32** %8
%1089 = load i32*, i32** %15
store i32* %1089, i32** %9
%1090 = load i32, i32* %10
%1091 = add nsw i32 %1090, 1
store i32 %1091, i32* %10
%1092 = load i32*, i32** %15
%1093 = load i32*, i32** %14
%1094 = ptrtoint i32* %1092 to i64
%1095 = ptrtoint i32* %1093 to i64
%1096 = sub i64 %1094, %1095
%1097 = sdiv exact i64 %1096, 4
%1098 = call i32 (i64, ...) bitcast (i32 (...)* @ss_ilg to i32 (i64, ...)*)(i64 %1097)
store i32 %1098, i32* %22
br label %1099
1099: ; preds = %1087, %1039
br label %1100
1100: ; preds = %1099, %970
br label %1101
1101: ; preds = %1100, %902
br label %1137
1102: ; preds = %551
%1103 = load i32, i32* %22
%1104 = add nsw i32 %1103, 1
store i32 %1104, i32* %22
%1105 = load i8*, i8** %12
%1106 = load i32*, i32** %7
%1107 = load i32*, i32** %8
%1108 = load i32, i32* %1107
%1109 = sext i32 %1108 to i64
%1110 = getelementptr inbounds i32, i32* %1106, i64 %1109
%1111 = load i32, i32* %1110
%1112 = sub nsw i32 %1111, 1
%1113 = sext i32 %1112 to i64
%1114 = getelementptr inbounds i8, i8* %1105, i64 %1113
%1115 = load i8, i8* %1114
%1116 = zext i8 %1115 to i32
%1117 = load i32, i32* %23
%1118 = icmp slt i32 %1116, %1117
br i1 %1118, label %1119, label %1134
1119: ; preds = %1102
%1120 = load i32*, i32** %7
%1121 = load i32*, i32** %8
%1122 = load i32*, i32** %9
%1123 = load i32, i32* %10
%1124 = call i32 (i32*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_partition to i32 (i32*, i32*, i32*, i32, ...)*)(i32* %1120, i32* %1121, i32* %1122, i32 %1123)
%1125 = sext i32 %1124 to i64
%1126 = inttoptr i64 %1125 to i32*
store i32* %1126, i32** %8
%1127 = load i32*, i32** %9
%1128 = load i32*, i32** %8
%1129 = ptrtoint i32* %1127 to i64
%1130 = ptrtoint i32* %1128 to i64
%1131 = sub i64 %1129, %1130
%1132 = sdiv exact i64 %1131, 4
%1133 = call i32 (i64, ...) bitcast (i32 (...)* @ss_ilg to i32 (i64, ...)*)(i64 %1132)
store i32 %1133, i32* %22
br label %1134
1134: ; preds = %1119, %1102
%1135 = load i32, i32* %10
%1136 = add nsw i32 %1135, 1
store i32 %1136, i32* %10
br label %1137
1137: ; preds = %1134, %1101
br label %32
}

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