void ss_swapmerge(const unsigned char *T, const int *PA, int *first,
                  int *middle, int *last, int *buf, int bufsize, int depth) {
  struct {
    int *a, *b, *c;
    int d;
  } stack[(32)];
  int *l, *r, *lm, *rm;
  int m, len, half;
  int ssize;
  int check, next;
  for (check = 0, ssize = 0;;) {
    if ((last - middle) <= bufsize) {
      if ((first < middle) && (middle < last)) {
        ss_mergebackward(T, PA, first, middle, last, buf, depth);
      }
      do {
        if (((check)&1) ||
            (((check)&2) &&
             (ss_compare(T,
                         PA + ((0 <= (*((first)-1))) ? (*((first)-1))
                                                     : (~(*((first)-1)))),
                         PA + *(first), depth) == 0))) {
          *(first) = ~*(first);
        }
        if (((check)&4) &&
            ((ss_compare(T,
                         PA + ((0 <= (*((last)-1))) ? (*((last)-1))
                                                    : (~(*((last)-1)))),
                         PA + *(last), depth) == 0))) {
          *(last) = ~*(last);
        }
      } while (0);
      do {
        assert(0 <= ssize);
        if (ssize == 0) {
          return;
        }
        (first) = stack[--ssize].a, (middle) = stack[ssize].b,
        (last) = stack[ssize].c, (check) = stack[ssize].d;
      } while (0);
      continue;
    }
    if ((middle - first) <= bufsize) {
      if (first < middle) {
        ss_mergeforward(T, PA, first, middle, last, buf, depth);
      }
      do {
        if (((check)&1) ||
            (((check)&2) &&
             (ss_compare(T,
                         PA + ((0 <= (*((first)-1))) ? (*((first)-1))
                                                     : (~(*((first)-1)))),
                         PA + *(first), depth) == 0))) {
          *(first) = ~*(first);
        }
        if (((check)&4) &&
            ((ss_compare(T,
                         PA + ((0 <= (*((last)-1))) ? (*((last)-1))
                                                    : (~(*((last)-1)))),
                         PA + *(last), depth) == 0))) {
          *(last) = ~*(last);
        }
      } while (0);
      do {
        assert(0 <= ssize);
        if (ssize == 0) {
          return;
        }
        (first) = stack[--ssize].a, (middle) = stack[ssize].b,
        (last) = stack[ssize].c, (check) = stack[ssize].d;
      } while (0);
      continue;
    }
    for (m = 0,
        len = (((middle - first) < (last - middle)) ? (middle - first)
                                                    : (last - middle)),
        half = len >> 1;
         0 < len; len = half, half >>= 1) {
      if (ss_compare(T,
                     PA + ((0 <= (*(middle + m + half)))
                               ? (*(middle + m + half))
                               : (~(*(middle + m + half)))),
                     PA + ((0 <= (*(middle - m - half - 1)))
                               ? (*(middle - m - half - 1))
                               : (~(*(middle - m - half - 1)))),
                     depth) < 0) {
        m += half + 1;
        half -= (len & 1) ^ 1;
      }
    }
    if (0 < m) {
      lm = middle - m, rm = middle + m;
      ss_blockswap(lm, middle, m);
      l = r = middle, next = 0;
      if (rm < last) {
        if (*rm < 0) {
          *rm = ~*rm;
          if (first < lm) {
            for (; *--l < 0;) {
            }
            next |= 4;
          }
          next |= 1;
        } else if (first < lm) {
          for (; *r < 0; ++r) {
          }
          next |= 2;
        }
      }
      if ((l - first) <= (last - r)) {
        do {
          assert(ssize < (32));
          stack[ssize].a = (r), stack[ssize].b = (rm), stack[ssize].c = (last),
          stack[ssize++].d = ((next & 3) | (check & 4));
        } while (0);
        middle = lm, last = l, check = (check & 3) | (next & 4);
      } else {
        if ((next & 2) && (r == middle)) {
          next ^= 6;
        }
        do {
          assert(ssize < (32));
          stack[ssize].a = (first), stack[ssize].b = (lm), stack[ssize].c = (l),
          stack[ssize++].d = ((check & 3) | (next & 4));
        } while (0);
        first = r, middle = rm, check = (next & 3) | (check & 4);
      }
    } else {
      if (ss_compare(T,
                     PA + ((0 <= (*(middle - 1))) ? (*(middle - 1))
                                                  : (~(*(middle - 1)))),
                     PA + *middle, depth) == 0) {
        *middle = ~*middle;
      }
      do {
        if (((check)&1) ||
            (((check)&2) &&
             (ss_compare(T,
                         PA + ((0 <= (*((first)-1))) ? (*((first)-1))
                                                     : (~(*((first)-1)))),
                         PA + *(first), depth) == 0))) {
          *(first) = ~*(first);
        }
        if (((check)&4) &&
            ((ss_compare(T,
                         PA + ((0 <= (*((last)-1))) ? (*((last)-1))
                                                    : (~(*((last)-1)))),
                         PA + *(last), depth) == 0))) {
          *(last) = ~*(last);
        }
      } while (0);
      do {
        assert(0 <= ssize);
        if (ssize == 0) {
          return;
        }
        (first) = stack[--ssize].a, (middle) = stack[ssize].b,
        (last) = stack[ssize].c, (check) = stack[ssize].d;
      } while (0);
    }
  }
}


x86 assembly (clang, -O0):
<ss_swapmerge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x550,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x464(%rbp)
movl   $0x0,-0x460(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
movslq 0x10(%rbp),%rcx
cmp    %rcx,%rax
jg     140c <ss_swapmerge+0x2bc>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    11ea <ss_swapmerge+0x9a>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    11ea <ss_swapmerge+0x9a>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    -0x30(%rbp),%r9
mov    0x18(%rbp),%eax
mov    %eax,(%rsp)
mov    $0x0,%al
call   1070 <ss_mergebackward@plt>
jmp    11ef <ss_swapmerge+0x9f>
mov    -0x464(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    129c <ss_swapmerge+0x14c>
mov    -0x464(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     12ab <ss_swapmerge+0x15b>
mov    -0x8(%rbp),%rax
mov    %rax,-0x478(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x470(%rbp)
mov    -0x18(%rbp),%rcx
xor    %eax,%eax
cmp    -0x4(%rcx),%eax
jg     124a <ss_swapmerge+0xfa>
mov    -0x18(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x47c(%rbp)
jmp    125a <ss_swapmerge+0x10a>
mov    -0x18(%rbp),%rax
mov    -0x4(%rax),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x47c(%rbp)
mov    -0x478(%rbp),%rdi
mov    -0x470(%rbp),%rsi
mov    -0x47c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    0x18(%rbp),%ecx
mov    $0x0,%al
call   1050 <ss_compare@plt>
cmp    $0x0,%eax
jne    12ab <ss_swapmerge+0x15b>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
xor    $0xffffffff,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x464(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     1355 <ss_swapmerge+0x205>
mov    -0x8(%rbp),%rax
mov    %rax,-0x490(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x488(%rbp)
mov    -0x28(%rbp),%rcx
xor    %eax,%eax
cmp    -0x4(%rcx),%eax
jg     12f4 <ss_swapmerge+0x1a4>
mov    -0x28(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x494(%rbp)
jmp    1304 <ss_swapmerge+0x1b4>
mov    -0x28(%rbp),%rax
mov    -0x4(%rax),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x494(%rbp)
mov    -0x490(%rbp),%rdi
mov    -0x488(%rbp),%rsi
mov    -0x494(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x10(%rbp),%rdx
mov    -0x28(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    0x18(%rbp),%ecx
mov    $0x0,%al
call   1050 <ss_compare@plt>
cmp    $0x0,%eax
jne    1355 <ss_swapmerge+0x205>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
xor    $0xffffffff,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
jmp    135a <ss_swapmerge+0x20a>
jmp    135f <ss_swapmerge+0x20f>
xor    %eax,%eax
cmp    -0x460(%rbp),%eax
setle  %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
cmpl   $0x0,-0x460(%rbp)
jne    1388 <ss_swapmerge+0x238>
jmp    1f23 <ss_swapmerge+0xdd3>
mov    -0x460(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x460(%rbp)
movslq %eax,%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    (%rax),%rax
mov    %rax,-0x18(%rbp)
movslq -0x460(%rbp),%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    0x8(%rax),%rax
mov    %rax,-0x20(%rbp)
movslq -0x460(%rbp),%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    0x10(%rax),%rax
mov    %rax,-0x28(%rbp)
movslq -0x460(%rbp),%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    0x18(%rax),%eax
mov    %eax,-0x464(%rbp)
jmp    118d <ss_swapmerge+0x3d>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
movslq 0x10(%rbp),%rcx
cmp    %rcx,%rax
jg     167d <ss_swapmerge+0x52d>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    145b <ss_swapmerge+0x30b>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    -0x30(%rbp),%r9
mov    0x18(%rbp),%eax
mov    %eax,(%rsp)
mov    $0x0,%al
call   1030 <ss_mergeforward@plt>
jmp    1460 <ss_swapmerge+0x310>
mov    -0x464(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    150d <ss_swapmerge+0x3bd>
mov    -0x464(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     151c <ss_swapmerge+0x3cc>
mov    -0x8(%rbp),%rax
mov    %rax,-0x4a8(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x4a0(%rbp)
mov    -0x18(%rbp),%rcx
xor    %eax,%eax
cmp    -0x4(%rcx),%eax
jg     14bb <ss_swapmerge+0x36b>
mov    -0x18(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x4ac(%rbp)
jmp    14cb <ss_swapmerge+0x37b>
mov    -0x18(%rbp),%rax
mov    -0x4(%rax),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x4ac(%rbp)
mov    -0x4a8(%rbp),%rdi
mov    -0x4a0(%rbp),%rsi
mov    -0x4ac(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    0x18(%rbp),%ecx
mov    $0x0,%al
call   1050 <ss_compare@plt>
cmp    $0x0,%eax
jne    151c <ss_swapmerge+0x3cc>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
xor    $0xffffffff,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x464(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     15c6 <ss_swapmerge+0x476>
mov    -0x8(%rbp),%rax
mov    %rax,-0x4c0(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x4b8(%rbp)
mov    -0x28(%rbp),%rcx
xor    %eax,%eax
cmp    -0x4(%rcx),%eax
jg     1565 <ss_swapmerge+0x415>
mov    -0x28(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x4c4(%rbp)
jmp    1575 <ss_swapmerge+0x425>
mov    -0x28(%rbp),%rax
mov    -0x4(%rax),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x4c4(%rbp)
mov    -0x4c0(%rbp),%rdi
mov    -0x4b8(%rbp),%rsi
mov    -0x4c4(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x10(%rbp),%rdx
mov    -0x28(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    0x18(%rbp),%ecx
mov    $0x0,%al
call   1050 <ss_compare@plt>
cmp    $0x0,%eax
jne    15c6 <ss_swapmerge+0x476>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
xor    $0xffffffff,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
jmp    15cb <ss_swapmerge+0x47b>
jmp    15d0 <ss_swapmerge+0x480>
xor    %eax,%eax
cmp    -0x460(%rbp),%eax
setle  %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
cmpl   $0x0,-0x460(%rbp)
jne    15f9 <ss_swapmerge+0x4a9>
jmp    1f23 <ss_swapmerge+0xdd3>
mov    -0x460(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x460(%rbp)
movslq %eax,%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    (%rax),%rax
mov    %rax,-0x18(%rbp)
movslq -0x460(%rbp),%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    0x8(%rax),%rax
mov    %rax,-0x20(%rbp)
movslq -0x460(%rbp),%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    0x10(%rax),%rax
mov    %rax,-0x28(%rbp)
movslq -0x460(%rbp),%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    0x18(%rax),%eax
mov    %eax,-0x464(%rbp)
jmp    118d <ss_swapmerge+0x3d>
movl   $0x0,-0x454(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%rax
jge    16c9 <ss_swapmerge+0x579>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %rax,-0x4d0(%rbp)
jmp    16df <ss_swapmerge+0x58f>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %rax,-0x4d0(%rbp)
mov    -0x4d0(%rbp),%rax
mov    %eax,-0x458(%rbp)
mov    -0x458(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x45c(%rbp)
xor    %eax,%eax
cmp    -0x458(%rbp),%eax
jge    18d4 <ss_swapmerge+0x784>
mov    -0x8(%rbp),%rax
mov    %rax,-0x4e0(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x4d8(%rbp)
mov    -0x20(%rbp),%rcx
movslq -0x454(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
movslq -0x45c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
jg     176a <ss_swapmerge+0x61a>
mov    -0x20(%rbp),%rax
movslq -0x454(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x45c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4e4(%rbp)
jmp    178f <ss_swapmerge+0x63f>
mov    -0x20(%rbp),%rax
movslq -0x454(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x45c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x4e4(%rbp)
mov    -0x4d8(%rbp),%rax
mov    -0x4e4(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x4f8(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x4f0(%rbp)
mov    -0x20(%rbp),%rcx
movslq -0x454(%rbp),%rdx
xor    %eax,%eax
sub    %rdx,%rax
shl    $0x2,%rax
add    %rax,%rcx
movslq -0x45c(%rbp),%rax
xor    %edx,%edx
sub    %rax,%rdx
xor    %eax,%eax
cmp    -0x4(%rcx,%rdx,4),%eax
jg     1819 <ss_swapmerge+0x6c9>
mov    -0x20(%rbp),%rax
movslq -0x454(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x45c(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    -0x4(%rax,%rcx,4),%eax
mov    %eax,-0x4fc(%rbp)
jmp    1849 <ss_swapmerge+0x6f9>
mov    -0x20(%rbp),%rax
movslq -0x454(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x45c(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    -0x4(%rax,%rcx,4),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x4fc(%rbp)
mov    -0x4f8(%rbp),%rsi
mov    -0x4e0(%rbp),%rdi
mov    -0x4f0(%rbp),%rdx
mov    -0x4fc(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    0x18(%rbp),%ecx
mov    $0x0,%al
call   1050 <ss_compare@plt>
cmp    $0x0,%eax
jge    18af <ss_swapmerge+0x75f>
mov    -0x45c(%rbp),%eax
add    $0x1,%eax
add    -0x454(%rbp),%eax
mov    %eax,-0x454(%rbp)
mov    -0x458(%rbp),%ecx
and    $0x1,%ecx
xor    $0x1,%ecx
mov    -0x45c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x45c(%rbp)
jmp    18b4 <ss_swapmerge+0x764>
mov    -0x45c(%rbp),%eax
mov    %eax,-0x458(%rbp)
mov    -0x45c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x45c(%rbp)
jmp    16fb <ss_swapmerge+0x5ab>
xor    %eax,%eax
cmp    -0x454(%rbp),%eax
jge    1c64 <ss_swapmerge+0xb14>
mov    -0x20(%rbp),%rax
movslq -0x454(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x448(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x454(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x450(%rbp)
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x454(%rbp),%edx
mov    $0x0,%al
call   1060 <ss_blockswap@plt>
mov    -0x20(%rbp),%rax
mov    %rax,-0x440(%rbp)
mov    %rax,-0x438(%rbp)
movl   $0x0,-0x468(%rbp)
mov    -0x450(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1a3b <ss_swapmerge+0x8eb>
mov    -0x450(%rbp),%rax
cmpl   $0x0,(%rax)
jge    19e0 <ss_swapmerge+0x890>
mov    -0x450(%rbp),%rax
mov    (%rax),%ecx
xor    $0xffffffff,%ecx
mov    -0x450(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
cmp    -0x448(%rbp),%rax
jae    19cc <ss_swapmerge+0x87c>
jmp    1999 <ss_swapmerge+0x849>
mov    -0x438(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x438(%rbp)
cmpl   $0x0,-0x4(%rax)
jge    19bd <ss_swapmerge+0x86d>
jmp    1999 <ss_swapmerge+0x849>
mov    -0x468(%rbp),%eax
or     $0x4,%eax
mov    %eax,-0x468(%rbp)
mov    -0x468(%rbp),%eax
or     $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    1a36 <ss_swapmerge+0x8e6>
mov    -0x18(%rbp),%rax
cmp    -0x448(%rbp),%rax
jae    1a31 <ss_swapmerge+0x8e1>
jmp    19f6 <ss_swapmerge+0x8a6>
mov    -0x440(%rbp),%rax
cmpl   $0x0,(%rax)
jge    1a22 <ss_swapmerge+0x8d2>
jmp    1a0b <ss_swapmerge+0x8bb>
mov    -0x440(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x440(%rbp)
jmp    19f6 <ss_swapmerge+0x8a6>
mov    -0x468(%rbp),%eax
or     $0x2,%eax
mov    %eax,-0x468(%rbp)
jmp    1a36 <ss_swapmerge+0x8e6>
jmp    1a3b <ss_swapmerge+0x8eb>
mov    -0x438(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    -0x28(%rbp),%rcx
mov    -0x440(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%rax
jg     1b4d <ss_swapmerge+0x9fd>
jmp    1a6d <ss_swapmerge+0x91d>
cmpl   $0x20,-0x460(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
mov    -0x440(%rbp),%rcx
movslq -0x460(%rbp),%rdx
lea    -0x430(%rbp),%rax
shl    $0x5,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x450(%rbp),%rcx
movslq -0x460(%rbp),%rdx
lea    -0x430(%rbp),%rax
shl    $0x5,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x28(%rbp),%rcx
movslq -0x460(%rbp),%rdx
lea    -0x430(%rbp),%rax
shl    $0x5,%rdx
add    %rdx,%rax
mov    %rcx,0x10(%rax)
mov    -0x468(%rbp),%ecx
and    $0x3,%ecx
mov    -0x464(%rbp),%eax
and    $0x4,%eax
or     %eax,%ecx
mov    -0x460(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x460(%rbp)
movslq %eax,%rdx
lea    -0x430(%rbp),%rax
shl    $0x5,%rdx
add    %rdx,%rax
mov    %ecx,0x18(%rax)
mov    -0x448(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x438(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x464(%rbp),%eax
and    $0x3,%eax
mov    -0x468(%rbp),%ecx
and    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x464(%rbp)
jmp    1c5f <ss_swapmerge+0xb0f>
mov    -0x468(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     1b7f <ss_swapmerge+0xa2f>
mov    -0x440(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    1b7f <ss_swapmerge+0xa2f>
mov    -0x468(%rbp),%eax
xor    $0x6,%eax
mov    %eax,-0x468(%rbp)
jmp    1b84 <ss_swapmerge+0xa34>
cmpl   $0x20,-0x460(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
mov    -0x18(%rbp),%rcx
movslq -0x460(%rbp),%rdx
lea    -0x430(%rbp),%rax
shl    $0x5,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x448(%rbp),%rcx
movslq -0x460(%rbp),%rdx
lea    -0x430(%rbp),%rax
shl    $0x5,%rdx
add    %rdx,%rax
mov    %rcx,0x8(%rax)
mov    -0x438(%rbp),%rcx
movslq -0x460(%rbp),%rdx
lea    -0x430(%rbp),%rax
shl    $0x5,%rdx
add    %rdx,%rax
mov    %rcx,0x10(%rax)
mov    -0x464(%rbp),%ecx
and    $0x3,%ecx
mov    -0x468(%rbp),%eax
and    $0x4,%eax
or     %eax,%ecx
mov    -0x460(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x460(%rbp)
movslq %eax,%rdx
lea    -0x430(%rbp),%rax
shl    $0x5,%rdx
add    %rdx,%rax
mov    %ecx,0x18(%rax)
mov    -0x440(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x450(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x468(%rbp),%eax
and    $0x3,%eax
mov    -0x464(%rbp),%ecx
and    $0x4,%ecx
or     %ecx,%eax
mov    %eax,-0x464(%rbp)
jmp    1f1e <ss_swapmerge+0xdce>
mov    -0x8(%rbp),%rax
mov    %rax,-0x510(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x508(%rbp)
mov    -0x20(%rbp),%rcx
xor    %eax,%eax
cmp    -0x4(%rcx),%eax
jg     1c9b <ss_swapmerge+0xb4b>
mov    -0x20(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x514(%rbp)
jmp    1cab <ss_swapmerge+0xb5b>
mov    -0x20(%rbp),%rax
mov    -0x4(%rax),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x514(%rbp)
mov    -0x510(%rbp),%rdi
mov    -0x508(%rbp),%rsi
mov    -0x514(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x10(%rbp),%rdx
mov    -0x20(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    0x18(%rbp),%ecx
mov    $0x0,%al
call   1050 <ss_compare@plt>
cmp    $0x0,%eax
jne    1cfc <ss_swapmerge+0xbac>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
xor    $0xffffffff,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1d01 <ss_swapmerge+0xbb1>
mov    -0x464(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    1dae <ss_swapmerge+0xc5e>
mov    -0x464(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     1dbd <ss_swapmerge+0xc6d>
mov    -0x8(%rbp),%rax
mov    %rax,-0x528(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x520(%rbp)
mov    -0x18(%rbp),%rcx
xor    %eax,%eax
cmp    -0x4(%rcx),%eax
jg     1d5c <ss_swapmerge+0xc0c>
mov    -0x18(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x52c(%rbp)
jmp    1d6c <ss_swapmerge+0xc1c>
mov    -0x18(%rbp),%rax
mov    -0x4(%rax),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x52c(%rbp)
mov    -0x528(%rbp),%rdi
mov    -0x520(%rbp),%rsi
mov    -0x52c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    0x18(%rbp),%ecx
mov    $0x0,%al
call   1050 <ss_compare@plt>
cmp    $0x0,%eax
jne    1dbd <ss_swapmerge+0xc6d>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
xor    $0xffffffff,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x464(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     1e67 <ss_swapmerge+0xd17>
mov    -0x8(%rbp),%rax
mov    %rax,-0x540(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x538(%rbp)
mov    -0x28(%rbp),%rcx
xor    %eax,%eax
cmp    -0x4(%rcx),%eax
jg     1e06 <ss_swapmerge+0xcb6>
mov    -0x28(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x544(%rbp)
jmp    1e16 <ss_swapmerge+0xcc6>
mov    -0x28(%rbp),%rax
mov    -0x4(%rax),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x544(%rbp)
mov    -0x540(%rbp),%rdi
mov    -0x538(%rbp),%rsi
mov    -0x544(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x10(%rbp),%rdx
mov    -0x28(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    0x18(%rbp),%ecx
mov    $0x0,%al
call   1050 <ss_compare@plt>
cmp    $0x0,%eax
jne    1e67 <ss_swapmerge+0xd17>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
xor    $0xffffffff,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
jmp    1e6c <ss_swapmerge+0xd1c>
jmp    1e71 <ss_swapmerge+0xd21>
xor    %eax,%eax
cmp    -0x460(%rbp),%eax
setle  %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
cmpl   $0x0,-0x460(%rbp)
jne    1e9a <ss_swapmerge+0xd4a>
jmp    1f23 <ss_swapmerge+0xdd3>
mov    -0x460(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x460(%rbp)
movslq %eax,%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    (%rax),%rax
mov    %rax,-0x18(%rbp)
movslq -0x460(%rbp),%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    0x8(%rax),%rax
mov    %rax,-0x20(%rbp)
movslq -0x460(%rbp),%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    0x10(%rax),%rax
mov    %rax,-0x28(%rbp)
movslq -0x460(%rbp),%rcx
lea    -0x430(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    0x18(%rax),%eax
mov    %eax,-0x464(%rbp)
jmp    1f1e <ss_swapmerge+0xdce>
jmp    118d <ss_swapmerge+0x3d>
add    $0x550,%rsp
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.anon = type { i32*, i32*, i32*, i32 }
define void @ss_swapmerge(i8* %0, i32* %1, i32* %2, i32* %3, i32* %4, i32* %5, i32 %6, i32 %7) {
%9 = alloca [32 x %struct.anon]
%10 = bitcast [32 x %struct.anon]* %9 to i8*
%11 = sext i32 %6 to i64
br label %12
12: ; preds = %89, %8
%13 = phi i32* [ %4, %8 ], [ %90, %89 ]
%14 = phi i32* [ %3, %8 ], [ %91, %89 ]
%15 = phi i32* [ %2, %8 ], [ %92, %89 ]
%16 = phi i32 [ 0, %8 ], [ %93, %89 ]
%17 = phi i32 [ 0, %8 ], [ %94, %89 ]
%18 = ptrtoint i32* %13 to i64
br label %19
19: ; preds = %12, %253
%20 = phi i32* [ %203, %253 ], [ %14, %12 ]
%21 = phi i32* [ %234, %253 ], [ %15, %12 ]
%22 = phi i32 [ %270, %253 ], [ %16, %12 ]
%23 = phi i32 [ %274, %253 ], [ %17, %12 ]
%24 = ptrtoint i32* %20 to i64
%25 = sub i64 %18, %24
%26 = ashr exact i64 %25, 2
%27 = icmp sgt i64 %26, %11
br i1 %27, label %95, label %28
28: ; preds = %19
%29 = icmp ult i32* %21, %20
%30 = icmp ult i32* %20, %13
%31 = select i1 %29, i1 %30, i1 false
br i1 %31, label %32, label %34
32: ; preds = %28
%33 = tail call i32 (i8*, i32*, i32*, i32*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_mergebackward to i32 (i8*, i32*, i32*, i32*, i32*, i32*, i32, ...)*)(i8* %0, i32* %1, i32* %21, i32* %20, i32* %13, i32* %5, i32 %7)
br label %34
34: ; preds = %28, %32
%35 = and i32 %23, 1
%36 = icmp eq i32 %35, 0
br i1 %36, label %37, label %52
37: ; preds = %34
%38 = and i32 %23, 2
%39 = icmp eq i32 %38, 0
br i1 %39, label %55, label %40
40: ; preds = %37
%41 = getelementptr inbounds i32, i32* %21, i64 -1
%42 = load i32, i32* %41
%43 = ashr i32 %42, 31
%44 = xor i32 %43, %42
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %1, i64 %45
%47 = load i32, i32* %21
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i32, i32* %1, i64 %48
%50 = tail call i32 (i8*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_compare to i32 (i8*, i32*, i32*, i32, ...)*)(i8* %0, i32* %46, i32* %49, i32 %7)
%51 = icmp eq i32 %50, 0
br i1 %51, label %52, label %55
52: ; preds = %40, %34
%53 = load i32, i32* %21
%54 = xor i32 %53, -1
store i32 %54, i32* %21
br label %55
55: ; preds = %52, %40, %37
%56 = and i32 %23, 4
%57 = icmp eq i32 %56, 0
br i1 %57, label %73, label %58
58: ; preds = %55
%59 = getelementptr inbounds i32, i32* %13, i64 -1
%60 = load i32, i32* %59
%61 = ashr i32 %60, 31
%62 = xor i32 %61, %60
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %1, i64 %63
%65 = load i32, i32* %13
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %1, i64 %66
%68 = tail call i32 (i8*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_compare to i32 (i8*, i32*, i32*, i32, ...)*)(i8* %0, i32* %64, i32* %67, i32 %7)
%69 = icmp eq i32 %68, 0
br i1 %69, label %70, label %73
70: ; preds = %58
%71 = load i32, i32* %13
%72 = xor i32 %71, -1
store i32 %72, i32* %13
br label %73
73: ; preds = %55, %58, %70
%74 = xor i32 %22, -1
%75 = lshr i32 %74, 31
%76 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %75)
%77 = icmp eq i32 %22, 0
br i1 %77, label %345, label %78
78: ; preds = %73
%79 = add nsw i32 %22, -1
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %80, i32 0
%82 = load i32*, i32** %81
%83 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %80, i32 1
%84 = load i32*, i32** %83
%85 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %80, i32 2
%86 = load i32*, i32** %85
%87 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %80, i32 3
%88 = load i32, i32* %87
br label %89
89: ; preds = %78, %148, %237, %334
%90 = phi i32* [ %342, %334 ], [ %233, %237 ], [ %156, %148 ], [ %86, %78 ]
%91 = phi i32* [ %340, %334 ], [ %202, %237 ], [ %154, %148 ], [ %84, %78 ]
%92 = phi i32* [ %338, %334 ], [ %21, %237 ], [ %152, %148 ], [ %82, %78 ]
%93 = phi i32 [ %335, %334 ], [ %248, %237 ], [ %149, %148 ], [ %79, %78 ]
%94 = phi i32 [ %344, %334 ], [ %252, %237 ], [ %158, %148 ], [ %88, %78 ]
br label %12
95: ; preds = %19
%96 = ptrtoint i32* %21 to i64
%97 = sub i64 %24, %96
%98 = ashr exact i64 %97, 2
%99 = icmp sgt i64 %98, %11
br i1 %99, label %159, label %100
100: ; preds = %95
%101 = icmp ult i32* %21, %20
br i1 %101, label %102, label %104
102: ; preds = %100
%103 = tail call i32 (i8*, i32*, i32*, i32*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_mergeforward to i32 (i8*, i32*, i32*, i32*, i32*, i32*, i32, ...)*)(i8* %0, i32* %1, i32* %21, i32* %20, i32* %13, i32* %5, i32 %7)
br label %104
104: ; preds = %100, %102
%105 = and i32 %23, 1
%106 = icmp eq i32 %105, 0
br i1 %106, label %107, label %122
107: ; preds = %104
%108 = and i32 %23, 2
%109 = icmp eq i32 %108, 0
br i1 %109, label %125, label %110
110: ; preds = %107
%111 = getelementptr inbounds i32, i32* %21, i64 -1
%112 = load i32, i32* %111
%113 = ashr i32 %112, 31
%114 = xor i32 %113, %112
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32, i32* %1, i64 %115
%117 = load i32, i32* %21
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32, i32* %1, i64 %118
%120 = tail call i32 (i8*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_compare to i32 (i8*, i32*, i32*, i32, ...)*)(i8* %0, i32* %116, i32* %119, i32 %7)
%121 = icmp eq i32 %120, 0
br i1 %121, label %122, label %125
122: ; preds = %110, %104
%123 = load i32, i32* %21
%124 = xor i32 %123, -1
store i32 %124, i32* %21
br label %125
125: ; preds = %122, %110, %107
%126 = and i32 %23, 4
%127 = icmp eq i32 %126, 0
br i1 %127, label %143, label %128
128: ; preds = %125
%129 = getelementptr inbounds i32, i32* %13, i64 -1
%130 = load i32, i32* %129
%131 = ashr i32 %130, 31
%132 = xor i32 %131, %130
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i32, i32* %1, i64 %133
%135 = load i32, i32* %13
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i32, i32* %1, i64 %136
%138 = tail call i32 (i8*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_compare to i32 (i8*, i32*, i32*, i32, ...)*)(i8* %0, i32* %134, i32* %137, i32 %7)
%139 = icmp eq i32 %138, 0
br i1 %139, label %140, label %143
140: ; preds = %128
%141 = load i32, i32* %13
%142 = xor i32 %141, -1
store i32 %142, i32* %13
br label %143
143: ; preds = %125, %128, %140
%144 = xor i32 %22, -1
%145 = lshr i32 %144, 31
%146 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %145)
%147 = icmp eq i32 %22, 0
br i1 %147, label %345, label %148
148: ; preds = %143
%149 = add nsw i32 %22, -1
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %150, i32 0
%152 = load i32*, i32** %151
%153 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %150, i32 1
%154 = load i32*, i32** %153
%155 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %150, i32 2
%156 = load i32*, i32** %155
%157 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %150, i32 3
%158 = load i32, i32* %157
br label %89
159: ; preds = %95
%160 = icmp slt i64 %98, %26
%161 = select i1 %160, i64 %98, i64 %26
%162 = trunc i64 %161 to i32
%163 = icmp sgt i32 %162, 0
br i1 %163, label %164, label %275
164: ; preds = %159
%165 = getelementptr inbounds i32, i32* %20, i64 -1
br label %166
166: ; preds = %164, %166
%167 = phi i32 [ %195, %166 ], [ %162, %164 ]
%168 = phi i32 [ %194, %166 ], [ 0, %164 ]
%169 = lshr i32 %167, 1
%170 = zext i32 %168 to i64
%171 = getelementptr inbounds i32, i32* %20, i64 %170
%172 = zext i32 %169 to i64
%173 = getelementptr inbounds i32, i32* %171, i64 %172
%174 = load i32, i32* %173
%175 = ashr i32 %174, 31
%176 = xor i32 %175, %174
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i32, i32* %1, i64 %177
%179 = sub nsw i64 0, %170
%180 = sub nsw i64 0, %172
%181 = getelementptr inbounds i32, i32* %165, i64 %179
%182 = getelementptr inbounds i32, i32* %181, i64 %180
%183 = load i32, i32* %182
%184 = ashr i32 %183, 31
%185 = xor i32 %184, %183
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i32, i32* %1, i64 %186
%188 = tail call i32 (i8*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_compare to i32 (i8*, i32*, i32*, i32, ...)*)(i8* %0, i32* %178, i32* %187, i32 %7)
%189 = icmp slt i32 %188, 0
%190 = add nuw nsw i32 %169, 1
%191 = or i32 %167, -2
%192 = add nsw i32 %190, %191
%193 = select i1 %189, i32 %190, i32 0
%194 = add nuw nsw i32 %168, %193
%195 = select i1 %189, i32 %192, i32 %169
%196 = icmp sgt i32 %195, 0
br i1 %196, label %166, label %197
197: ; preds = %166
%198 = icmp eq i32 %194, 0
br i1 %198, label %275, label %199
199: ; preds = %197
%200 = zext i32 %194 to i64
%201 = sub nsw i64 0, %200
%202 = getelementptr inbounds i32, i32* %20, i64 %201
%203 = getelementptr inbounds i32, i32* %20, i64 %200
%204 = tail call i32 (i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_blockswap to i32 (i32*, i32*, i32, ...)*)(i32* %202, i32* %20, i32 %194)
%205 = icmp ult i32* %203, %13
br i1 %205, label %206, label %230
206: ; preds = %199
%207 = load i32, i32* %203
%208 = icmp slt i32 %207, 0
br i1 %208, label %209, label %217
209: ; preds = %206
%210 = xor i32 %207, -1
store i32 %210, i32* %203
%211 = icmp ult i32* %21, %202
br i1 %211, label %212, label %230
212: ; preds = %209, %212
%213 = phi i32* [ %214, %212 ], [ %20, %209 ]
%214 = getelementptr inbounds i32, i32* %213, i64 -1
%215 = load i32, i32* %214
%216 = icmp slt i32 %215, 0
br i1 %216, label %212, label %224
217: ; preds = %206
%218 = icmp ult i32* %21, %202
br i1 %218, label %219, label %230
219: ; preds = %217, %219
%220 = phi i32* [ %223, %219 ], [ %20, %217 ]
%221 = load i32, i32* %220
%222 = icmp slt i32 %221, 0
%223 = getelementptr inbounds i32, i32* %220, i64 1
br i1 %222, label %219, label %227
224: ; preds = %212
%225 = ptrtoint i32* %214 to i64
%226 = sub i64 %225, %96
br label %230
227: ; preds = %219
%228 = ptrtoint i32* %220 to i64
%229 = sub i64 %18, %228
br label %230
230: ; preds = %227, %224, %209, %217, %199
%231 = phi i64 [ %229, %227 ], [ %25, %224 ], [ %25, %209 ], [ %25, %217 ], [ %25, %199 ]
%232 = phi i64 [ %97, %227 ], [ %226, %224 ], [ %97, %209 ], [ %97, %217 ], [ %97, %199 ]
%233 = phi i32* [ %20, %227 ], [ %214, %224 ], [ %20, %209 ], [ %20, %217 ], [ %20, %199 ]
%234 = phi i32* [ %220, %227 ], [ %20, %224 ], [ %20, %209 ], [ %20, %217 ], [ %20, %199 ]
%235 = phi i32 [ 2, %227 ], [ 5, %224 ], [ 1, %209 ], [ 0, %217 ], [ 0, %199 ]
%236 = icmp sgt i64 %232, %231
br i1 %236, label %253, label %237
237: ; preds = %230
%238 = icmp slt i32 %22, 32
%239 = zext i1 %238 to i32
%240 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %239)
%241 = sext i32 %22 to i64
%242 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %241, i32 0
store i32* %234, i32** %242
%243 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %241, i32 1
store i32* %203, i32** %243
%244 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %241, i32 2
store i32* %13, i32** %244
%245 = and i32 %235, 3
%246 = and i32 %23, 4
%247 = or i32 %245, %246
%248 = add nsw i32 %22, 1
%249 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %241, i32 3
store i32 %247, i32* %249
%250 = and i32 %23, 3
%251 = and i32 %235, 4
%252 = or i32 %251, %250
br label %89
253: ; preds = %230
%254 = and i32 %235, 2
%255 = icmp ne i32 %254, 0
%256 = icmp eq i32* %234, %20
%257 = select i1 %255, i1 %256, i1 false
%258 = xor i32 %235, 6
%259 = select i1 %257, i32 %258, i32 %235
%260 = icmp slt i32 %22, 32
%261 = zext i1 %260 to i32
%262 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %261)
%263 = sext i32 %22 to i64
%264 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %263, i32 0
store i32* %21, i32** %264
%265 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %263, i32 1
store i32* %202, i32** %265
%266 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %263, i32 2
store i32* %233, i32** %266
%267 = and i32 %23, 3
%268 = and i32 %259, 4
%269 = or i32 %268, %267
%270 = add nsw i32 %22, 1
%271 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %263, i32 3
store i32 %269, i32* %271
%272 = and i32 %259, 3
%273 = and i32 %23, 4
%274 = or i32 %272, %273
br label %19
275: ; preds = %159, %197
%276 = getelementptr inbounds i32, i32* %20, i64 -1
%277 = load i32, i32* %276
%278 = ashr i32 %277, 31
%279 = xor i32 %278, %277
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i32, i32* %1, i64 %280
%282 = load i32, i32* %20
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds i32, i32* %1, i64 %283
%285 = tail call i32 (i8*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_compare to i32 (i8*, i32*, i32*, i32, ...)*)(i8* %0, i32* %281, i32* %284, i32 %7)
%286 = icmp eq i32 %285, 0
br i1 %286, label %287, label %290
287: ; preds = %275
%288 = load i32, i32* %20
%289 = xor i32 %288, -1
store i32 %289, i32* %20
br label %290
290: ; preds = %275, %287
%291 = and i32 %23, 1
%292 = icmp eq i32 %291, 0
br i1 %292, label %293, label %308
293: ; preds = %290
%294 = and i32 %23, 2
%295 = icmp eq i32 %294, 0
br i1 %295, label %311, label %296
296: ; preds = %293
%297 = getelementptr inbounds i32, i32* %21, i64 -1
%298 = load i32, i32* %297
%299 = ashr i32 %298, 31
%300 = xor i32 %299, %298
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds i32, i32* %1, i64 %301
%303 = load i32, i32* %21
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds i32, i32* %1, i64 %304
%306 = tail call i32 (i8*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_compare to i32 (i8*, i32*, i32*, i32, ...)*)(i8* %0, i32* %302, i32* %305, i32 %7)
%307 = icmp eq i32 %306, 0
br i1 %307, label %308, label %311
308: ; preds = %296, %290
%309 = load i32, i32* %21
%310 = xor i32 %309, -1
store i32 %310, i32* %21
br label %311
311: ; preds = %308, %296, %293
%312 = and i32 %23, 4
%313 = icmp eq i32 %312, 0
br i1 %313, label %329, label %314
314: ; preds = %311
%315 = getelementptr inbounds i32, i32* %13, i64 -1
%316 = load i32, i32* %315
%317 = ashr i32 %316, 31
%318 = xor i32 %317, %316
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds i32, i32* %1, i64 %319
%321 = load i32, i32* %13
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds i32, i32* %1, i64 %322
%324 = tail call i32 (i8*, i32*, i32*, i32, ...) bitcast (i32 (...)* @ss_compare to i32 (i8*, i32*, i32*, i32, ...)*)(i8* %0, i32* %320, i32* %323, i32 %7)
%325 = icmp eq i32 %324, 0
br i1 %325, label %326, label %329
326: ; preds = %314
%327 = load i32, i32* %13
%328 = xor i32 %327, -1
store i32 %328, i32* %13
br label %329
329: ; preds = %311, %314, %326
%330 = xor i32 %22, -1
%331 = lshr i32 %330, 31
%332 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %331)
%333 = icmp eq i32 %22, 0
br i1 %333, label %345, label %334
334: ; preds = %329
%335 = add nsw i32 %22, -1
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %336, i32 0
%338 = load i32*, i32** %337
%339 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %336, i32 1
%340 = load i32*, i32** %339
%341 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %336, i32 2
%342 = load i32*, i32** %341
%343 = getelementptr inbounds [32 x %struct.anon], [32 x %struct.anon]* %9, i64 0, i64 %336, i32 3
%344 = load i32, i32* %343
br label %89
345: ; preds = %329, %143, %73
ret void
}