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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int stub1(void const *, void const *);
int stub2(void const *, void const *);
int stub3(void const *, void const *);
int stub4(void const *, void const *);
int stub5(void const *, void const *);
void partition_sort(void *base, size_t nmemb, size_t size,
                    int (*compar)(const void *, const void *)) {
  int stackpointer = 1;
  void *basestack[32];
  int sizestack[32];
  basestack[0] = base;
  sizestack[0] = nmemb;
  while (stackpointer != 0) {
    char *b = (char *)basestack[--stackpointer];
    int n = sizestack[stackpointer];
    for (;;) {
      int halfn = (n >> 1) * size;
      char *bmid = b + halfn;
      char *btop;
      if ((n & 1) == 0)
        halfn -= size;
      btop = bmid + halfn;
      if ((*compar)(b, bmid) > 0) {
        int xsize = size;
        if (((xsize | (int)b) & 0x3) == 0) {
          do {
            int temp = *(int *)b;
            *(int *)b = *(int *)bmid;
            *(int *)bmid = temp;
            b += 4;
            bmid += 4;
            xsize -= 4;
            ;
          } while (xsize != 0);
        } else {
          do {
            char temp = *b;
            *b++ = *bmid;
            *bmid++ = temp;
            xsize--;
          } while (xsize != 0);
        }
        b -= size;
        bmid -= size;
      };
      if ((*compar)(bmid, btop) > 0) {
        if ((*compar)(b, btop) > 0) {
          int xsize = size;
          if (((xsize | (int)b) & 0x3) == 0) {
            do {
              int temp = *(int *)b;
              *(int *)b = *(int *)btop;
              *(int *)btop = temp;
              b += 4;
              btop += 4;
              xsize -= 4;
              ;
            } while (xsize != 0);
          } else {
            do {
              char temp = *b;
              *b++ = *btop;
              *btop++ = temp;
              xsize--;
            } while (xsize != 0);
          }
          b -= size;
          btop -= size;
        };
        {
          int xsize = size;
          if (((xsize | (int)bmid) & 0x3) == 0) {
            do {
              int temp = *(int *)bmid;
              *(int *)bmid = *(int *)btop;
              *(int *)btop = temp;
              bmid += 4;
              btop += 4;
              xsize -= 4;
              ;
            } while (xsize != 0);
          } else {
            do {
              char temp = *bmid;
              *bmid++ = *btop;
              *btop++ = temp;
              xsize--;
            } while (xsize != 0);
          }
          bmid -= size;
          btop -= size;
        };
      }
      {
        char *l;
        char *r = btop - size;
        char *pivot;
        int s1, s2;
        {
          int xsize = size;
          if (((xsize | (int)bmid) & 0x3) == 0) {
            do {
              int temp = *(int *)bmid;
              *(int *)bmid = *(int *)r;
              *(int *)r = temp;
              bmid += 4;
              r += 4;
              xsize -= 4;
              ;
            } while (xsize != 0);
          } else {
            do {
              char temp = *bmid;
              *bmid++ = *r;
              *r++ = temp;
              xsize--;
            } while (xsize != 0);
          }
          bmid -= size;
          r -= size;
        };
        l = b;
        pivot = r;
        for (;;) {
          do
            l += size;
          while ((*compar)(l, pivot) < 0);
          do
            r -= size;
          while ((*compar)(r, pivot) > 0);
          if (r <= l)
            break;
          {
            int xsize = size;
            if (((xsize | (int)l) & 0x3) == 0) {
              do {
                int temp = *(int *)l;
                *(int *)l = *(int *)r;
                *(int *)r = temp;
                l += 4;
                r += 4;
                xsize -= 4;
                ;
              } while (xsize != 0);
            } else {
              do {
                char temp = *l;
                *l++ = *r;
                *r++ = temp;
                xsize--;
              } while (xsize != 0);
            }
            l -= size;
            r -= size;
          };
        }
        {
          int xsize = size;
          if (((xsize | (int)l) & 0x3) == 0) {
            do {
              int temp = *(int *)l;
              *(int *)l = *(int *)pivot;
              *(int *)pivot = temp;
              l += 4;
              pivot += 4;
              xsize -= 4;
              ;
            } while (xsize != 0);
          } else {
            do {
              char temp = *l;
              *l++ = *pivot;
              *pivot++ = temp;
              xsize--;
            } while (xsize != 0);
          }
          l -= size;
          pivot -= size;
        };
        s1 = ((l - b) / size) - 1;
        s2 = n - s1 - 1;
        if (s1 > s2) {
          if (s2 > 10) {
            (basestack[stackpointer] = (void *)(b),
             sizestack[stackpointer++] = (s1));
            b = l;
            n = s2;
          } else if (s1 > 10)
            n = s1;
          else
            break;
        } else {
          if (s1 > 10) {
            (basestack[stackpointer] = (void *)(l),
             sizestack[stackpointer++] = (s2));
            n = s1;
          } else if (s2 > 10) {
            b = l;
            n = s2;
          } else
            break;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<partition_sort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x240,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x10(%rbp),%rax
mov    %eax,-0x1b0(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     1bee <partition_sort+0xaee>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cltq
mov    -0x130(%rbp,%rax,8),%rax
ff
mov    %rax,-0x1b8(%rbp)
movslq -0x24(%rbp),%rax
mov    -0x1b0(%rbp,%rax,4),%eax
mov    %eax,-0x1bc(%rbp)
mov    -0x1bc(%rbp),%eax
sar    $0x1,%eax
cltq
imul   -0x18(%rbp),%rax
mov    %eax,-0x1c0(%rbp)
mov    -0x1b8(%rbp),%rax
movslq -0x1c0(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x1bc(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    11c0 <partition_sort+0xc0>
mov    -0x18(%rbp),%rcx
movslq -0x1c0(%rbp),%rax
sub    %rcx,%rax
mov    %eax,-0x1c0(%rbp)
mov    -0x1c8(%rbp),%rax
movslq -0x1c0(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x1b8(%rbp),%rdi
mov    -0x1c8(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jle    133a <partition_sort+0x23a>
mov    -0x18(%rbp),%rax
mov    %eax,-0x1d4(%rbp)
mov    -0x1d4(%rbp),%eax
mov    -0x1b8(%rbp),%rcx
or     %ecx,%eax
and    $0x3,%eax
cmp    $0x0,%eax
jne    1294 <partition_sort+0x194>
jmp    121f <partition_sort+0x11f>
mov    -0x1b8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1d8(%rbp)
mov    -0x1c8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x1b8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1d8(%rbp),%ecx
mov    -0x1c8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1b8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x1c8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x1d4(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x1d4(%rbp)
cmpl   $0x0,-0x1d4(%rbp)
jne    121f <partition_sort+0x11f>
jmp    1306 <partition_sort+0x206>
jmp    1299 <partition_sort+0x199>
mov    -0x1b8(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x1d9(%rbp)
mov    -0x1c8(%rbp),%rax
mov    (%rax),%cl
mov    -0x1b8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x1b8(%rbp)
mov    %cl,(%rax)
mov    -0x1d9(%rbp),%cl
mov    -0x1c8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x1c8(%rbp)
mov    %cl,(%rax)
mov    -0x1d4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1d4(%rbp)
cmpl   $0x0,-0x1d4(%rbp)
jne    1299 <partition_sort+0x199>
jmp    1306 <partition_sort+0x206>
mov    -0x18(%rbp),%rdx
mov    -0x1b8(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x1c8(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x1c8(%rbp),%rdi
mov    -0x1d0(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jle    15fe <partition_sort+0x4fe>
mov    -0x20(%rbp),%rax
mov    -0x1b8(%rbp),%rdi
mov    -0x1d0(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jle    14b9 <partition_sort+0x3b9>
mov    -0x18(%rbp),%rax
mov    %eax,-0x1e0(%rbp)
mov    -0x1e0(%rbp),%eax
mov    -0x1b8(%rbp),%rcx
or     %ecx,%eax
and    $0x3,%eax
cmp    $0x0,%eax
jne    1413 <partition_sort+0x313>
jmp    139e <partition_sort+0x29e>
mov    -0x1b8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1e4(%rbp)
mov    -0x1d0(%rbp),%rax
mov    (%rax),%ecx
mov    -0x1b8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1e4(%rbp),%ecx
mov    -0x1d0(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1b8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x1d0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x1e0(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x1e0(%rbp)
cmpl   $0x0,-0x1e0(%rbp)
jne    139e <partition_sort+0x29e>
jmp    1485 <partition_sort+0x385>
jmp    1418 <partition_sort+0x318>
mov    -0x1b8(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x1e5(%rbp)
mov    -0x1d0(%rbp),%rax
mov    (%rax),%cl
mov    -0x1b8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x1b8(%rbp)
mov    %cl,(%rax)
mov    -0x1e5(%rbp),%cl
mov    -0x1d0(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x1d0(%rbp)
mov    %cl,(%rax)
mov    -0x1e0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1e0(%rbp)
cmpl   $0x0,-0x1e0(%rbp)
jne    1418 <partition_sort+0x318>
jmp    1485 <partition_sort+0x385>
mov    -0x18(%rbp),%rdx
mov    -0x1b8(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x1d0(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x18(%rbp),%rax
mov    %eax,-0x1ec(%rbp)
mov    -0x1ec(%rbp),%eax
mov    -0x1c8(%rbp),%rcx
or     %ecx,%eax
and    $0x3,%eax
cmp    $0x0,%eax
jne    1558 <partition_sort+0x458>
jmp    14e3 <partition_sort+0x3e3>
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)
mov    -0x1c8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x1d0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x1ec(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x1ec(%rbp)
cmpl   $0x0,-0x1ec(%rbp)
jne    14e3 <partition_sort+0x3e3>
jmp    15ca <partition_sort+0x4ca>
jmp    155d <partition_sort+0x45d>
mov    -0x1c8(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x1f1(%rbp)
mov    -0x1d0(%rbp),%rax
mov    (%rax),%cl
mov    -0x1c8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x1c8(%rbp)
mov    %cl,(%rax)
mov    -0x1f1(%rbp),%cl
mov    -0x1d0(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x1d0(%rbp)
mov    %cl,(%rax)
mov    -0x1ec(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1ec(%rbp)
cmpl   $0x0,-0x1ec(%rbp)
jne    155d <partition_sort+0x45d>
jmp    15ca <partition_sort+0x4ca>
mov    -0x18(%rbp),%rdx
mov    -0x1c8(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x1d0(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x1d0(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x208(%rbp)
mov    -0x18(%rbp),%rax
mov    %eax,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
mov    -0x1c8(%rbp),%rcx
or     %ecx,%eax
and    $0x3,%eax
cmp    $0x0,%eax
jne    16b4 <partition_sort+0x5b4>
jmp    163f <partition_sort+0x53f>
mov    -0x1c8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x220(%rbp)
mov    -0x208(%rbp),%rax
mov    (%rax),%ecx
mov    -0x1c8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x220(%rbp),%ecx
mov    -0x208(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1c8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x208(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x208(%rbp)
mov    -0x21c(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x21c(%rbp)
cmpl   $0x0,-0x21c(%rbp)
jne    163f <partition_sort+0x53f>
jmp    1726 <partition_sort+0x626>
jmp    16b9 <partition_sort+0x5b9>
mov    -0x1c8(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x221(%rbp)
mov    -0x208(%rbp),%rax
mov    (%rax),%cl
mov    -0x1c8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x1c8(%rbp)
mov    %cl,(%rax)
mov    -0x221(%rbp),%cl
mov    -0x208(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x208(%rbp)
mov    %cl,(%rax)
mov    -0x21c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x21c(%rbp)
cmpl   $0x0,-0x21c(%rbp)
jne    16b9 <partition_sort+0x5b9>
jmp    1726 <partition_sort+0x626>
mov    -0x18(%rbp),%rdx
mov    -0x1c8(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x208(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x208(%rbp)
mov    -0x1b8(%rbp),%rax
mov    %rax,-0x200(%rbp)
mov    -0x208(%rbp),%rax
mov    %rax,-0x210(%rbp)
jmp    177b <partition_sort+0x67b>
mov    -0x18(%rbp),%rax
add    -0x200(%rbp),%rax
mov    %rax,-0x200(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x200(%rbp),%rdi
mov    -0x210(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jl     177b <partition_sort+0x67b>
jmp    17af <partition_sort+0x6af>
mov    -0x18(%rbp),%rdx
mov    -0x208(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x208(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x208(%rbp),%rdi
mov    -0x210(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jg     17af <partition_sort+0x6af>
mov    -0x208(%rbp),%rax
cmp    -0x200(%rbp),%rax
ja     17ff <partition_sort+0x6ff>
jmp    1949 <partition_sort+0x849>
mov    -0x18(%rbp),%rax
mov    %eax,-0x228(%rbp)
mov    -0x228(%rbp),%eax
mov    -0x200(%rbp),%rcx
or     %ecx,%eax
and    $0x3,%eax
cmp    $0x0,%eax
jne    189e <partition_sort+0x79e>
jmp    1829 <partition_sort+0x729>
mov    -0x200(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x22c(%rbp)
mov    -0x208(%rbp),%rax
mov    (%rax),%ecx
mov    -0x200(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x22c(%rbp),%ecx
mov    -0x208(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x200(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x200(%rbp)
mov    -0x208(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x208(%rbp)
mov    -0x228(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x228(%rbp)
cmpl   $0x0,-0x228(%rbp)
jne    1829 <partition_sort+0x729>
jmp    1910 <partition_sort+0x810>
jmp    18a3 <partition_sort+0x7a3>
mov    -0x200(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x22d(%rbp)
mov    -0x208(%rbp),%rax
mov    (%rax),%cl
mov    -0x200(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x200(%rbp)
mov    %cl,(%rax)
mov    -0x22d(%rbp),%cl
mov    -0x208(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x208(%rbp)
mov    %cl,(%rax)
mov    -0x228(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x228(%rbp)
cmpl   $0x0,-0x228(%rbp)
jne    18a3 <partition_sort+0x7a3>
jmp    1910 <partition_sort+0x810>
mov    -0x18(%rbp),%rdx
mov    -0x200(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x200(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x208(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x208(%rbp)
jmp    1776 <partition_sort+0x676>
mov    -0x18(%rbp),%rax
mov    %eax,-0x234(%rbp)
mov    -0x234(%rbp),%eax
mov    -0x200(%rbp),%rcx
or     %ecx,%eax
and    $0x3,%eax
cmp    $0x0,%eax
jne    19e8 <partition_sort+0x8e8>
jmp    1973 <partition_sort+0x873>
mov    -0x200(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x238(%rbp)
mov    -0x210(%rbp),%rax
mov    (%rax),%ecx
mov    -0x200(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x238(%rbp),%ecx
mov    -0x210(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x200(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x200(%rbp)
mov    -0x210(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x210(%rbp)
mov    -0x234(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x234(%rbp)
cmpl   $0x0,-0x234(%rbp)
jne    1973 <partition_sort+0x873>
jmp    1a5a <partition_sort+0x95a>
jmp    19ed <partition_sort+0x8ed>
mov    -0x200(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x239(%rbp)
mov    -0x210(%rbp),%rax
mov    (%rax),%cl
mov    -0x200(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x200(%rbp)
mov    %cl,(%rax)
mov    -0x239(%rbp),%cl
mov    -0x210(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x210(%rbp)
mov    %cl,(%rax)
mov    -0x234(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x234(%rbp)
cmpl   $0x0,-0x234(%rbp)
jne    19ed <partition_sort+0x8ed>
jmp    1a5a <partition_sort+0x95a>
mov    -0x18(%rbp),%rdx
mov    -0x200(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x200(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x210(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x210(%rbp)
mov    -0x200(%rbp),%rax
mov    -0x1b8(%rbp),%rcx
sub    %rcx,%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x18(%rbp)
sub    $0x1,%rax
mov    %eax,-0x214(%rbp)
mov    -0x1bc(%rbp),%eax
sub    -0x214(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x218(%rbp)
mov    -0x214(%rbp),%eax
cmp    -0x218(%rbp),%eax
jle    1b5e <partition_sort+0xa5e>
cmpl   $0xa,-0x218(%rbp)
jle    1b31 <partition_sort+0xa31>
mov    -0x1b8(%rbp),%rcx
movslq -0x24(%rbp),%rax
mov    %rcx,-0x130(%rbp,%rax,8)
ff
mov    -0x214(%rbp),%ecx
mov    -0x24(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
cltq
mov    %ecx,-0x1b0(%rbp,%rax,4)
mov    -0x200(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x218(%rbp),%eax
mov    %eax,-0x1bc(%rbp)
jmp    1b59 <partition_sort+0xa59>
cmpl   $0xa,-0x214(%rbp)
jle    1b4f <partition_sort+0xa4f>
mov    -0x214(%rbp),%eax
mov    %eax,-0x1bc(%rbp)
jmp    1b54 <partition_sort+0xa54>
jmp    1be9 <partition_sort+0xae9>
jmp    1b59 <partition_sort+0xa59>
jmp    1be4 <partition_sort+0xae4>
cmpl   $0xa,-0x214(%rbp)
jle    1ba9 <partition_sort+0xaa9>
mov    -0x200(%rbp),%rcx
movslq -0x24(%rbp),%rax
mov    %rcx,-0x130(%rbp,%rax,8)
ff
mov    -0x218(%rbp),%ecx
mov    -0x24(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
cltq
mov    %ecx,-0x1b0(%rbp,%rax,4)
mov    -0x214(%rbp),%eax
mov    %eax,-0x1bc(%rbp)
jmp    1bdf <partition_sort+0xadf>
cmpl   $0xa,-0x218(%rbp)
jle    1bd5 <partition_sort+0xad5>
mov    -0x200(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x218(%rbp),%eax
mov    %eax,-0x1bc(%rbp)
jmp    1bda <partition_sort+0xada>
jmp    1be9 <partition_sort+0xae9>
jmp    1bdf <partition_sort+0xadf>
jmp    1be4 <partition_sort+0xae4>
jmp    116c <partition_sort+0x6c>
jmp    1137 <partition_sort+0x37>
add    $0x240,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<partition_sort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x288,%rsp
mov    %rcx,%r15
mov    %rdx,%r13
mov    %rdi,0x180(%rsp)
mov    %esi,0x100(%rsp)
mov    %rdx,%r14
neg    %r14
mov    $0xfffffffc,%eax
add    %rdx,%rax
mov    %eax,%edx
and    $0xfffffffc,%edx
add    $0x4,%rdx
mov    %rdx,%rcx
mov    %rdx,0xd0(%rsp)
sub    %r13,%rdx
mov    %rdx,0xd8(%rsp)
shr    $0x2,%eax
mov    %rax,0xf0(%rsp)
add    $0x1,%rax
lea    -0x1(%r13),%ecx
lea    -0x4(%r13),%edx
mov    %edx,%esi
shr    $0x2,%esi
add    $0x1,%esi
mov    %rsi,0x98(%rsp)
and    $0xfffffff8,%esi
mov    %rax,0xc8(%rsp)
mov    %eax,%r8d
and    $0xfffffff8,%r8d
lea    0x0(,%rsi,4),%eax
mov    %r13d,%ebp
sub    %eax,%ebp
mov    %ebp,0x18(%rsp)
lea    0x0(,%r8,4),%eax
mov    %r13d,%ebp
sub    %eax,%ebp
mov    %ebp,0x60(%rsp)
mov    %rcx,0x50(%rsp)
add    $0x1,%rcx
mov    %rcx,%rax
sub    %r13,%rax
mov    %rax,0xe8(%rsp)
mov    %edx,0x1c(%rsp)
mov    %edx,%ebp
and    $0xfffffffc,%ebp
add    $0x4,%rbp
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rax
mov    %rax,0x40(%rsp)
mov    %rax,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
lea    -0x8(%rsi),%rax
mov    %rax,0x88(%rsp)
mov    %rax,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
lea    -0x8(%r8),%rax
mov    %rax,0xb8(%rsp)
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %r13d,%eax
mov    %rcx,0x48(%rsp)
sub    %ecx,%eax
mov    %eax,0xc(%rsp)
mov    %rdx,%rax
mov    %rdx,0x38(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x30(%rsp)
mov    %rbx,%rax
mov    %rbx,0x80(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0x70(%rsp)
mov    %rdi,%rax
mov    %rdi,0xb0(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xa8(%rsp)
mov    $0x30,%eax
sub    %r13,%rax
mov    %rax,0x68(%rsp)
mov    %rsi,0x90(%rsp)
lea    0x0(,%rsi,4),%rax
mov    %rax,0x78(%rsp)
mov    %r8,0xc0(%rsp)
lea    0x0(,%r8,4),%rax
mov    %rax,0xe0(%rsp)
mov    $0x1,%eax
mov    %rbp,0xa0(%rsp)
jmp    12cc <partition_sort+0x1cc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x2c(%rsp),%eax
test   %eax,%eax
je     29b6 <partition_sort+0x18b6>
mov    %eax,%ecx
cltq
add    $0xffffffff,%ecx
mov    %ecx,0x2c(%rsp)
mov    0x178(%rsp,%rax,8),%rdi
mov    0xfc(%rsp,%rax,4),%esi
cs nopw 0x0(%rax,%rax,1)
mov    %esi,%eax
sar    %eax
imul   %r13d,%eax
movslq %eax,%rcx
mov    %esi,0x64(%rsp)
test   $0x1,%sil
mov    $0x0,%eax
cmove  %r13d,%eax
lea    (%rdi,%rcx,1),%r12
mov    %rcx,0x20(%rsp)
sub    %eax,%ecx
movslq %ecx,%rax
mov    %rax,0xf8(%rsp)
lea    (%r12,%rax,1),%rbp
mov    %r12,%rsi
mov    %rdi,%rbx
call   *%r15
test   %eax,%eax
mov    %rbx,0x58(%rsp)
jle    16a6 <partition_sort+0x5a6>
mov    %ebx,%eax
or     %r13d,%eax
test   $0x3,%al
je     1420 <partition_sort+0x320>
cmpl   $0x1f,0x50(%rsp)
jb     1373 <partition_sort+0x273>
mov    0x10(%rsp),%rax
add    %rbx,%rax
mov    0x20(%rsp),%rdx
lea    (%rax,%rdx,1),%rcx
cmp    %rcx,%rbx
jae    14fe <partition_sort+0x3fe>
cmp    %rax,%r12
jae    14fe <partition_sort+0x3fe>
mov    %r13d,%esi
lea    -0x1(%rsi),%r8d
test   $0x3,%sil
je     13b0 <partition_sort+0x2b0>
mov    %esi,%edi
and    $0x3,%edi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movzbl (%rbx,%rdx,1),%ecx
movzbl (%r12,%rdx,1),%eax
mov    %al,(%rbx,%rdx,1)
mov    %cl,(%r12,%rdx,1)
add    $0x1,%rdx
cmp    %edx,%edi
jne    1390 <partition_sort+0x290>
sub    %edx,%esi
add    %rdx,%r12
add    %rdx,%rbx
cmp    $0x3,%r8d
jb     16a0 <partition_sort+0x5a0>
nopw   0x0(%rax,%rax,1)
movzbl (%rbx),%eax
movzbl (%r12),%ecx
mov    %cl,(%rbx)
mov    %al,(%r12)
movzbl 0x1(%rbx),%eax
movzbl 0x1(%r12),%ecx
mov    %cl,0x1(%rbx)
mov    %al,0x1(%r12)
movzbl 0x2(%rbx),%eax
movzbl 0x2(%r12),%ecx
mov    %cl,0x2(%rbx)
mov    %al,0x2(%r12)
movzbl 0x3(%rbx),%eax
movzbl 0x3(%r12),%ecx
mov    %cl,0x3(%rbx)
add    $0x4,%rbx
mov    %al,0x3(%r12)
add    $0x4,%r12
add    $0xfffffffc,%esi
jne    13c0 <partition_sort+0x2c0>
jmp    16a0 <partition_sort+0x5a0>
cs nopw 0x0(%rax,%rax,1)
cmpl   $0x1c,0x1c(%rsp)
jb     144d <partition_sort+0x34d>
mov    0xa0(%rsp),%rax
add    %rbx,%rax
mov    0x20(%rsp),%rdx
lea    (%rax,%rdx,1),%rcx
cmp    %rcx,%rbx
jae    15c6 <partition_sort+0x4c6>
cmp    %rax,%r12
jae    15c6 <partition_sort+0x4c6>
mov    %r13d,%eax
lea    -0x4(%rax),%r8d
mov    %r8d,%edx
shr    $0x2,%edx
lea    0x1(%rdx),%esi
test   $0x3,%sil
je     149e <partition_sort+0x39e>
add    $0x1,%dl
movzbl %dl,%edx
and    $0x3,%edx
shl    $0x2,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rsi,1),%edi
mov    (%r12,%rsi,1),%ecx
mov    %ecx,(%rbx,%rsi,1)
mov    %edi,(%r12,%rsi,1)
add    $0x4,%rsi
cmp    %esi,%edx
jne    1480 <partition_sort+0x380>
sub    %esi,%eax
add    %rsi,%r12
add    %rsi,%rbx
cmp    $0xc,%r8d
jb     16a0 <partition_sort+0x5a0>
nopl   0x0(%rax,%rax,1)
mov    (%rbx),%ecx
mov    (%r12),%edx
mov    %edx,(%rbx)
mov    %ecx,(%r12)
mov    0x4(%rbx),%ecx
mov    0x4(%r12),%edx
mov    %edx,0x4(%rbx)
mov    %ecx,0x4(%r12)
mov    0x8(%rbx),%ecx
mov    0x8(%r12),%edx
mov    %edx,0x8(%rbx)
mov    %ecx,0x8(%r12)
mov    0xc(%rbx),%ecx
mov    0xc(%r12),%edx
mov    %edx,0xc(%rbx)
mov    %ecx,0xc(%r12)
add    $0x10,%rbx
add    $0x10,%r12
add    $0xfffffff0,%eax
jne    14b0 <partition_sort+0x3b0>
jmp    16a0 <partition_sort+0x5a0>
cmpq   $0x0,0x40(%rsp)
je     27b4 <partition_sort+0x16b4>
lea    (%rbx,%rdx,1),%rcx
add    $0x30,%rcx
mov    0x30(%rsp),%rdx
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rbx,%rax,1),%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
movups -0x30(%rcx,%rax,1),%xmm2
movups -0x20(%rcx,%rax,1),%xmm3
movups %xmm2,(%rbx,%rax,1)
movups %xmm3,0x10(%rbx,%rax,1)
movups %xmm0,-0x30(%rcx,%rax,1)
movups %xmm1,-0x20(%rcx,%rax,1)
movups 0x20(%rbx,%rax,1),%xmm0
movups 0x30(%rbx,%rax,1),%xmm1
movups -0x10(%rcx,%rax,1),%xmm2
movups (%rcx,%rax,1),%xmm3
movups %xmm2,0x20(%rbx,%rax,1)
movups %xmm3,0x30(%rbx,%rax,1)
movups %xmm0,-0x10(%rcx,%rax,1)
movups %xmm1,(%rcx,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rdx
jne    1520 <partition_sort+0x420>
testb  $0x1,0x38(%rsp)
je     15a5 <partition_sort+0x4a5>
movups (%rbx,%rax,1),%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
movups (%r12,%rax,1),%xmm2
movups 0x10(%r12,%rax,1),%xmm3
movups %xmm2,(%rbx,%rax,1)
movups %xmm3,0x10(%rbx,%rax,1)
movups %xmm0,(%r12,%rax,1)
movups %xmm1,0x10(%r12,%rax,1)
mov    0x48(%rsp),%rax
add    %rax,%r12
add    %rax,%rbx
mov    0xc(%rsp),%ecx
mov    %ecx,%esi
cmp    %rax,0x10(%rsp)
je     16a0 <partition_sort+0x5a0>
jmp    1376 <partition_sort+0x276>
cmpq   $0x0,0x88(%rsp)
je     2942 <partition_sort+0x1842>
lea    (%rbx,%rdx,1),%rcx
add    $0x30,%rcx
mov    0x70(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rbx,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
movups -0x30(%rcx,%rax,4),%xmm2
movups -0x20(%rcx,%rax,4),%xmm3
movups %xmm2,(%rbx,%rax,4)
movups %xmm3,0x10(%rbx,%rax,4)
movups %xmm0,-0x30(%rcx,%rax,4)
movups %xmm1,-0x20(%rcx,%rax,4)
movups 0x20(%rbx,%rax,4),%xmm0
movups 0x30(%rbx,%rax,4),%xmm1
movups -0x10(%rcx,%rax,4),%xmm2
movups (%rcx,%rax,4),%xmm3
movups %xmm2,0x20(%rbx,%rax,4)
movups %xmm3,0x30(%rbx,%rax,4)
movups %xmm0,-0x10(%rcx,%rax,4)
movups %xmm1,(%rcx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    15f0 <partition_sort+0x4f0>
testb  $0x1,0x80(%rsp)
01
je     1678 <partition_sort+0x578>
movups (%rbx,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
movups (%r12,%rax,4),%xmm2
movups 0x10(%r12,%rax,4),%xmm3
movups %xmm2,(%rbx,%rax,4)
movups %xmm3,0x10(%rbx,%rax,4)
movups %xmm0,(%r12,%rax,4)
movups %xmm1,0x10(%r12,%rax,4)
mov    0x78(%rsp),%rax
add    %rax,%r12
add    %rax,%rbx
mov    0x18(%rsp),%eax
mov    0x90(%rsp),%rcx
cmp    0x98(%rsp),%rcx
jne    1450 <partition_sort+0x350>
nopl   (%rax)
add    %r14,%rbx
add    %r14,%r12
mov    %r12,%rdi
mov    %rbp,%rsi
call   *%r15
test   %eax,%eax
jle    1760 <partition_sort+0x660>
mov    %rbx,%rdi
mov    %rbp,%rsi
call   *%r15
test   %eax,%eax
jle    1770 <partition_sort+0x670>
mov    %ebx,%eax
or     %r13d,%eax
test   $0x3,%al
je     1778 <partition_sort+0x678>
cmpl   $0x1f,0x50(%rsp)
jb     1710 <partition_sort+0x610>
mov    0x10(%rsp),%rcx
mov    0x58(%rsp),%rdx
lea    (%rdx,%rcx,1),%rax
mov    0x20(%rsp),%rsi
add    0xf8(%rsp),%rsi
add    %rsi,%rax
cmp    %rax,%rbx
jae    1868 <partition_sort+0x768>
lea    (%rbx,%rcx,1),%rax
cmp    %rax,%rbp
jae    1868 <partition_sort+0x768>
mov    %r13d,%esi
lea    -0x1(%rsi),%r8d
test   $0x3,%sil
je     1806 <partition_sort+0x706>
mov    %esi,%edi
and    $0x3,%edi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rdx,1),%ecx
movzbl 0x0(%rbp,%rdx,1),%eax
mov    %al,(%rbx,%rdx,1)
mov    %cl,0x0(%rbp,%rdx,1)
add    $0x1,%rdx
cmp    %edx,%edi
jne    1730 <partition_sort+0x630>
sub    %edx,%esi
add    %rdx,%rbp
add    %rdx,%rbx
mov    %rbx,%rax
jmp    1806 <partition_sort+0x706>
nopl   0x0(%rax,%rax,1)
mov    %rbx,%r8
jmp    1ce6 <partition_sort+0xbe6>
nopl   0x0(%rax,%rax,1)
mov    %rbx,%r8
jmp    1984 <partition_sort+0x884>
cmpl   $0x1c,0x1c(%rsp)
jb     17b6 <partition_sort+0x6b6>
mov    0xa0(%rsp),%rcx
mov    0x58(%rsp),%rdx
lea    (%rdx,%rcx,1),%rax
mov    0x20(%rsp),%rsi
add    0xf8(%rsp),%rsi
add    %rsi,%rax
cmp    %rax,%rbx
jae    27c6 <partition_sort+0x16c6>
lea    (%rbx,%rcx,1),%rax
cmp    %rax,%rbp
jae    27c6 <partition_sort+0x16c6>
mov    %r13d,%eax
lea    -0x4(%rax),%r8d
mov    %r8d,%edx
shr    $0x2,%edx
lea    0x1(%rdx),%esi
test   $0x3,%sil
je     1933 <partition_sort+0x833>
add    $0x1,%dl
movzbl %dl,%edx
and    $0x3,%edx
shl    $0x2,%rdx
xor    %esi,%esi
nop
mov    (%rbx,%rsi,1),%edi
mov    0x0(%rbp,%rsi,1),%ecx
mov    %ecx,(%rbx,%rsi,1)
mov    %edi,0x0(%rbp,%rsi,1)
add    $0x4,%rsi
cmp    %esi,%edx
jne    17e0 <partition_sort+0x6e0>
sub    %esi,%eax
add    %rsi,%rbp
add    %rsi,%rbx
mov    %rbx,%rcx
jmp    1933 <partition_sort+0x833>
cmp    $0x3,%r8d
mov    %rax,%r8
jb     197e <partition_sort+0x87e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rbx),%eax
movzbl 0x0(%rbp),%ecx
mov    %cl,(%rbx)
mov    %al,0x0(%rbp)
movzbl 0x1(%rbx),%eax
movzbl 0x1(%rbp),%ecx
mov    %cl,0x1(%rbx)
mov    %al,0x1(%rbp)
movzbl 0x2(%rbx),%eax
movzbl 0x2(%rbp),%ecx
mov    %cl,0x2(%rbx)
mov    %al,0x2(%rbp)
movzbl 0x3(%rbx),%eax
movzbl 0x3(%rbp),%ecx
mov    %cl,0x3(%rbx)
add    $0x4,%rbx
mov    %al,0x3(%rbp)
add    $0x4,%rbp
add    $0xfffffffc,%esi
jne    1820 <partition_sort+0x720>
jmp    197b <partition_sort+0x87b>
cmpq   $0x0,0x40(%rsp)
je     2930 <partition_sort+0x1830>
lea    (%rdx,%rsi,1),%rcx
add    $0x30,%rcx
mov    0x30(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx,%rax,1),%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
movups -0x30(%rcx,%rax,1),%xmm2
movups -0x20(%rcx,%rax,1),%xmm3
movups %xmm2,(%rbx,%rax,1)
movups %xmm3,0x10(%rbx,%rax,1)
movups %xmm0,-0x30(%rcx,%rax,1)
movups %xmm1,-0x20(%rcx,%rax,1)
movups 0x20(%rbx,%rax,1),%xmm0
movups 0x30(%rbx,%rax,1),%xmm1
movups -0x10(%rcx,%rax,1),%xmm2
movups (%rcx,%rax,1),%xmm3
movups %xmm2,0x20(%rbx,%rax,1)
movups %xmm3,0x30(%rbx,%rax,1)
movups %xmm0,-0x10(%rcx,%rax,1)
movups %xmm1,(%rcx,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rdx
jne    1890 <partition_sort+0x790>
testb  $0x1,0x38(%rsp)
je     1913 <partition_sort+0x813>
movups (%rbx,%rax,1),%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
movups 0x0(%rbp,%rax,1),%xmm2
movups 0x10(%rbp,%rax,1),%xmm3
movups %xmm2,(%rbx,%rax,1)
movups %xmm3,0x10(%rbx,%rax,1)
movups %xmm0,0x0(%rbp,%rax,1)
movups %xmm1,0x10(%rbp,%rax,1)
mov    0x48(%rsp),%rax
add    %rax,%rbp
add    %rax,%rbx
mov    0xc(%rsp),%ecx
mov    %ecx,%esi
mov    %rbx,%r8
cmp    %rax,0x10(%rsp)
je     197e <partition_sort+0x87e>
jmp    1713 <partition_sort+0x613>
cmp    $0xc,%r8d
mov    %rcx,%r8
jb     197e <partition_sort+0x87e>
nopl   0x0(%rax)
mov    (%rbx),%ecx
mov    0x0(%rbp),%edx
mov    %edx,(%rbx)
mov    %ecx,0x0(%rbp)
mov    0x4(%rbx),%ecx
mov    0x4(%rbp),%edx
mov    %edx,0x4(%rbx)
mov    %ecx,0x4(%rbp)
mov    0x8(%rbx),%ecx
mov    0x8(%rbp),%edx
mov    %edx,0x8(%rbx)
mov    %ecx,0x8(%rbp)
mov    0xc(%rbx),%ecx
mov    0xc(%rbp),%edx
mov    %edx,0xc(%rbx)
mov    %ecx,0xc(%rbp)
add    $0x10,%rbx
add    $0x10,%rbp
add    $0xfffffff0,%eax
jne    1940 <partition_sort+0x840>
mov    %rbx,%r8
add    %r14,%r8
add    %r14,%rbp
mov    %r12d,%eax
or     %r13d,%eax
test   $0x3,%al
je     1a60 <partition_sort+0x960>
cmpl   $0x1f,0x50(%rsp)
jb     19b8 <partition_sort+0x8b8>
mov    0x10(%rsp),%rcx
lea    (%rcx,%rbp,1),%rax
cmp    %rax,%r12
jae    1b30 <partition_sort+0xa30>
lea    (%r12,%rcx,1),%rax
cmp    %rax,%rbp
jae    1b30 <partition_sort+0xa30>
mov    %r13d,%eax
lea    -0x1(%rax),%edi
test   $0x3,%al
je     19f2 <partition_sort+0x8f2>
mov    %eax,%esi
and    $0x3,%esi
xor    %edx,%edx
nopl   0x0(%rax)
movzbl (%r12,%rdx,1),%ebx
movzbl 0x0(%rbp,%rdx,1),%ecx
mov    %cl,(%r12,%rdx,1)
mov    %bl,0x0(%rbp,%rdx,1)
add    $0x1,%rdx
cmp    %edx,%esi
jne    19d0 <partition_sort+0x8d0>
sub    %edx,%eax
add    %rdx,%rbp
add    %rdx,%r12
cmp    $0x3,%edi
jb     1ce0 <partition_sort+0xbe0>
nopl   0x0(%rax,%rax,1)
movzbl (%r12),%ecx
movzbl 0x0(%rbp),%edx
mov    %dl,(%r12)
mov    %cl,0x0(%rbp)
movzbl 0x1(%r12),%ecx
movzbl 0x1(%rbp),%edx
mov    %dl,0x1(%r12)
mov    %cl,0x1(%rbp)
movzbl 0x2(%r12),%ecx
movzbl 0x2(%rbp),%edx
mov    %dl,0x2(%r12)
mov    %cl,0x2(%rbp)
movzbl 0x3(%r12),%ecx
movzbl 0x3(%rbp),%edx
mov    %dl,0x3(%r12)
add    $0x4,%r12
mov    %cl,0x3(%rbp)
add    $0x4,%rbp
add    $0xfffffffc,%eax
jne    1a00 <partition_sort+0x900>
jmp    1ce0 <partition_sort+0xbe0>
nopl   0x0(%rax,%rax,1)
cmpl   $0x1c,0x1c(%rsp)
jb     1a89 <partition_sort+0x989>
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rbp,1),%rax
cmp    %rax,%r12
jae    1c00 <partition_sort+0xb00>
lea    (%r12,%rcx,1),%rax
cmp    %rax,%rbp
jae    1c00 <partition_sort+0xb00>
mov    %r13d,%eax
lea    -0x4(%rax),%ecx
mov    %ecx,%edx
shr    $0x2,%edx
lea    0x1(%rdx),%esi
test   $0x3,%sil
je     1ad0 <partition_sort+0x9d0>
add    $0x1,%dl
movzbl %dl,%edx
and    $0x3,%edx
shl    $0x2,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
mov    (%r12,%rsi,1),%edi
mov    0x0(%rbp,%rsi,1),%ebx
mov    %ebx,(%r12,%rsi,1)
mov    %edi,0x0(%rbp,%rsi,1)
add    $0x4,%rsi
cmp    %esi,%edx
jne    1ab0 <partition_sort+0x9b0>
sub    %esi,%eax
add    %rsi,%rbp
add    %rsi,%r12
cmp    $0xc,%ecx
jb     1ce0 <partition_sort+0xbe0>
nopl   0x0(%rax)
mov    (%r12),%ecx
mov    0x0(%rbp),%edx
mov    %edx,(%r12)
mov    %ecx,0x0(%rbp)
mov    0x4(%r12),%ecx
mov    0x4(%rbp),%edx
mov    %edx,0x4(%r12)
mov    %ecx,0x4(%rbp)
mov    0x8(%r12),%ecx
mov    0x8(%rbp),%edx
mov    %edx,0x8(%r12)
mov    %ecx,0x8(%rbp)
mov    0xc(%r12),%ecx
mov    0xc(%rbp),%edx
mov    %edx,0xc(%r12)
mov    %ecx,0xc(%rbp)
add    $0x10,%r12
add    $0x10,%rbp
add    $0xfffffff0,%eax
jne    1ae0 <partition_sort+0x9e0>
jmp    1ce0 <partition_sort+0xbe0>
cmpq   $0x0,0x40(%rsp)
je     28a3 <partition_sort+0x17a3>
mov    0x30(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r12,%rax,1),%xmm0
movups 0x10(%r12,%rax,1),%xmm1
movups 0x0(%rbp,%rax,1),%xmm2
movups 0x10(%rbp,%rax,1),%xmm3
movups %xmm2,(%r12,%rax,1)
movups %xmm3,0x10(%r12,%rax,1)
movups %xmm0,0x0(%rbp,%rax,1)
movups %xmm1,0x10(%rbp,%rax,1)
movups 0x20(%r12,%rax,1),%xmm0
movups 0x30(%r12,%rax,1),%xmm1
movups 0x20(%rbp,%rax,1),%xmm2
movups 0x30(%rbp,%rax,1),%xmm3
movups %xmm2,0x20(%r12,%rax,1)
movups %xmm3,0x30(%r12,%rax,1)
movups %xmm0,0x20(%rbp,%rax,1)
movups %xmm1,0x30(%rbp,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rcx
jne    1b50 <partition_sort+0xa50>
testb  $0x1,0x38(%rsp)
je     1be1 <partition_sort+0xae1>
movups (%r12,%rax,1),%xmm0
movups 0x10(%r12,%rax,1),%xmm1
movups 0x0(%rbp,%rax,1),%xmm2
movups 0x10(%rbp,%rax,1),%xmm3
movups %xmm2,(%r12,%rax,1)
movups %xmm3,0x10(%r12,%rax,1)
movups %xmm0,0x0(%rbp,%rax,1)
movups %xmm1,0x10(%rbp,%rax,1)
mov    0x48(%rsp),%rcx
add    %rcx,%rbp
add    %rcx,%r12
mov    0xc(%rsp),%eax
cmp    %rcx,0x10(%rsp)
je     1ce0 <partition_sort+0xbe0>
jmp    19bb <partition_sort+0x8bb>
cmpq   $0x0,0x88(%rsp)
je     2957 <partition_sort+0x1857>
mov    0x70(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups (%r12,%rax,4),%xmm0
movups 0x10(%r12,%rax,4),%xmm1
movups 0x0(%rbp,%rax,4),%xmm2
movups 0x10(%rbp,%rax,4),%xmm3
movups %xmm2,(%r12,%rax,4)
movups %xmm3,0x10(%r12,%rax,4)
movups %xmm0,0x0(%rbp,%rax,4)
movups %xmm1,0x10(%rbp,%rax,4)
movups 0x20(%r12,%rax,4),%xmm0
movups 0x30(%r12,%rax,4),%xmm1
movups 0x20(%rbp,%rax,4),%xmm2
movups 0x30(%rbp,%rax,4),%xmm3
movups %xmm2,0x20(%r12,%rax,4)
movups %xmm3,0x30(%r12,%rax,4)
movups %xmm0,0x20(%rbp,%rax,4)
movups %xmm1,0x30(%rbp,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1c20 <partition_sort+0xb20>
testb  $0x1,0x80(%rsp)
01
je     1cb4 <partition_sort+0xbb4>
movups (%r12,%rax,4),%xmm0
movups 0x10(%r12,%rax,4),%xmm1
movups 0x0(%rbp,%rax,4),%xmm2
movups 0x10(%rbp,%rax,4),%xmm3
movups %xmm2,(%r12,%rax,4)
movups %xmm3,0x10(%r12,%rax,4)
movups %xmm0,0x0(%rbp,%rax,4)
movups %xmm1,0x10(%rbp,%rax,4)
mov    0x78(%rsp),%rax
add    %rax,%rbp
add    %rax,%r12
mov    0x18(%rsp),%eax
mov    0x90(%rsp),%rcx
cmp    0x98(%rsp),%rcx
jne    1a8c <partition_sort+0x98c>
nopl   0x0(%rax)
add    %r14,%r12
add    %r14,%rbp
lea    (%r14,%rbp,1),%rdx
mov    %r12d,%eax
or     %r13d,%eax
test   $0x3,%al
je     1dd0 <partition_sort+0xcd0>
cmpl   $0x1f,0x50(%rsp)
jb     1d24 <partition_sort+0xc24>
mov    0xe8(%rsp),%rax
add    %rbp,%rax
cmp    %rax,%r12
jae    249a <partition_sort+0x139a>
mov    0x10(%rsp),%rax
add    %r12,%rax
cmp    %rax,%rdx
jae    249a <partition_sort+0x139a>
mov    %r13d,%eax
mov    %rdx,%rbp
lea    -0x1(%rax),%edi
test   $0x3,%al
je     1d62 <partition_sort+0xc62>
mov    %eax,%esi
and    $0x3,%esi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movzbl (%r12,%rdx,1),%ebx
movzbl 0x0(%rbp,%rdx,1),%ecx
mov    %cl,(%r12,%rdx,1)
mov    %bl,0x0(%rbp,%rdx,1)
add    $0x1,%rdx
cmp    %edx,%esi
jne    1d40 <partition_sort+0xc40>
add    %rdx,%rbp
sub    %edx,%eax
add    %rdx,%r12
cmp    $0x3,%edi
jb     1eb1 <partition_sort+0xdb1>
mov    %eax,%eax
xor    %ecx,%ecx
nop
movzbl (%r12,%rcx,1),%edx
movzbl 0x0(%rbp,%rcx,1),%ebx
mov    %bl,(%r12,%rcx,1)
mov    %dl,0x0(%rbp,%rcx,1)
movzbl 0x1(%r12,%rcx,1),%edx
movzbl 0x1(%rbp,%rcx,1),%ebx
mov    %bl,0x1(%r12,%rcx,1)
mov    %dl,0x1(%rbp,%rcx,1)
movzbl 0x2(%r12,%rcx,1),%edx
movzbl 0x2(%rbp,%rcx,1),%ebx
mov    %bl,0x2(%r12,%rcx,1)
mov    %dl,0x2(%rbp,%rcx,1)
movzbl 0x3(%r12,%rcx,1),%edx
movzbl 0x3(%rbp,%rcx,1),%ebx
mov    %bl,0x3(%r12,%rcx,1)
mov    %dl,0x3(%rbp,%rcx,1)
add    $0x4,%rcx
cmp    %ecx,%eax
jne    1d70 <partition_sort+0xc70>
jmp    1eae <partition_sort+0xdae>
nopl   0x0(%rax,%rax,1)
cmpl   $0x7,0xf0(%rsp)
07
jb     1e02 <partition_sort+0xd02>
mov    0xd8(%rsp),%rax
add    %rbp,%rax
cmp    %rax,%r12
jae    25e6 <partition_sort+0x14e6>
mov    0xd0(%rsp),%rax
add    %r12,%rax
cmp    %rax,%rdx
jae    25e6 <partition_sort+0x14e6>
mov    %r13d,%eax
mov    %rdx,%rbp
lea    -0x4(%rax),%ecx
mov    %ecx,%edx
shr    $0x2,%edx
lea    0x1(%rdx),%esi
test   $0x3,%sil
je     1e55 <partition_sort+0xd55>
add    $0x1,%dl
movzbl %dl,%edx
and    $0x3,%edx
shl    $0x2,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rsi,1),%edi
mov    %rbp,%rbx
mov    0x0(%rbp,%rsi,1),%ebp
mov    %ebp,(%r12,%rsi,1)
mov    %rbx,%rbp
mov    %edi,(%rbx,%rsi,1)
add    $0x4,%rsi
cmp    %esi,%edx
jne    1e30 <partition_sort+0xd30>
add    %rsi,%rbp
sub    %esi,%eax
add    %rsi,%r12
cmp    $0xc,%ecx
jb     1eb1 <partition_sort+0xdb1>
mov    %eax,%eax
xor    %ecx,%ecx
xchg   %ax,%ax
mov    (%r12,%rcx,1),%edx
mov    0x0(%rbp,%rcx,1),%esi
mov    %esi,(%r12,%rcx,1)
mov    %edx,0x0(%rbp,%rcx,1)
mov    0x4(%r12,%rcx,1),%edx
mov    0x4(%rbp,%rcx,1),%esi
mov    %esi,0x4(%r12,%rcx,1)
mov    %edx,0x4(%rbp,%rcx,1)
mov    0x8(%r12,%rcx,1),%edx
mov    0x8(%rbp,%rcx,1),%esi
mov    %esi,0x8(%r12,%rcx,1)
mov    %edx,0x8(%rbp,%rcx,1)
mov    0xc(%r12,%rcx,1),%edx
mov    0xc(%rbp,%rcx,1),%esi
mov    %esi,0xc(%r12,%rcx,1)
mov    %edx,0xc(%rbp,%rcx,1)
add    $0x10,%rcx
cmp    %ecx,%eax
jne    1e60 <partition_sort+0xd60>
add    %rcx,%rbp
mov    %rbp,0x20(%rsp)
lea    (%r14,%rbp,1),%r12
mov    %r8,0x58(%rsp)
mov    %r8,%rbx
mov    %r12,%rbp
jmp    1ed0 <partition_sort+0xdd0>
add    %r14,%rbx
add    %r14,%rbp
nopl   (%rax)
add    %r13,%rbx
mov    %rbx,%rdi
mov    %r12,%rsi
call   *%r15
test   %eax,%eax
js     1ed0 <partition_sort+0xdd0>
add    %r14,%rbp
mov    %rbp,%rdi
mov    %r12,%rsi
call   *%r15
test   %eax,%eax
jg     1ee0 <partition_sort+0xde0>
mov    %rbx,%rax
or     %r13,%rax
cmp    %rbx,%rbp
jbe    2250 <partition_sort+0x1150>
test   $0x3,%al
je     1fc8 <partition_sort+0xec8>
cmpl   $0x1f,0x50(%rsp)
jb     1f2d <partition_sort+0xe2d>
mov    0x10(%rsp),%rcx
lea    (%rcx,%rbp,1),%rax
cmp    %rax,%rbx
jae    2090 <partition_sort+0xf90>
lea    (%rbx,%rcx,1),%rax
cmp    %rax,%rbp
jae    2090 <partition_sort+0xf90>
mov    %r13d,%esi
lea    -0x1(%rsi),%r8d
test   $0x3,%sil
je     1f70 <partition_sort+0xe70>
mov    %esi,%edi
and    $0x3,%edi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rdx,1),%ecx
movzbl 0x0(%rbp,%rdx,1),%eax
mov    %al,(%rbx,%rdx,1)
mov    %cl,0x0(%rbp,%rdx,1)
add    $0x1,%rdx
cmp    %edx,%edi
jne    1f50 <partition_sort+0xe50>
add    %rdx,%rbx
add    %rdx,%rbp
sub    %edx,%esi
cmp    $0x3,%r8d
jb     1ec7 <partition_sort+0xdc7>
nopw   0x0(%rax,%rax,1)
movzbl (%rbx),%eax
movzbl 0x0(%rbp),%ecx
mov    %cl,(%rbx)
mov    %al,0x0(%rbp)
movzbl 0x1(%rbx),%eax
movzbl 0x1(%rbp),%ecx
mov    %cl,0x1(%rbx)
mov    %al,0x1(%rbp)
movzbl 0x2(%rbx),%eax
movzbl 0x2(%rbp),%ecx
mov    %cl,0x2(%rbx)
mov    %al,0x2(%rbp)
movzbl 0x3(%rbx),%eax
movzbl 0x3(%rbp),%ecx
mov    %cl,0x3(%rbx)
add    $0x4,%rbx
mov    %al,0x3(%rbp)
add    $0x4,%rbp
add    $0xfffffffc,%esi
jne    1f80 <partition_sort+0xe80>
jmp    1ec7 <partition_sort+0xdc7>
cmpl   $0x1c,0x1c(%rsp)
jb     1ff1 <partition_sort+0xef1>
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rbp,1),%rax
cmp    %rax,%rbx
jae    2156 <partition_sort+0x1056>
lea    (%rbx,%rcx,1),%rax
cmp    %rax,%rbp
jae    2156 <partition_sort+0x1056>
mov    %r13d,%eax
lea    -0x4(%rax),%r8d
mov    %r8d,%edx
shr    $0x2,%edx
lea    0x1(%rdx),%esi
test   $0x3,%sil
je     203e <partition_sort+0xf3e>
add    $0x1,%dl
movzbl %dl,%edx
and    $0x3,%edx
shl    $0x2,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
mov    (%rbx,%rsi,1),%edi
mov    0x0(%rbp,%rsi,1),%ecx
mov    %ecx,(%rbx,%rsi,1)
mov    %edi,0x0(%rbp,%rsi,1)
add    $0x4,%rsi
cmp    %esi,%edx
jne    2020 <partition_sort+0xf20>
add    %rsi,%rbx
add    %rsi,%rbp
sub    %esi,%eax
cmp    $0xc,%r8d
jb     1ec7 <partition_sort+0xdc7>
nopl   0x0(%rax,%rax,1)
mov    (%rbx),%ecx
mov    0x0(%rbp),%edx
mov    %edx,(%rbx)
mov    %ecx,0x0(%rbp)
mov    0x4(%rbx),%ecx
mov    0x4(%rbp),%edx
mov    %edx,0x4(%rbx)
mov    %ecx,0x4(%rbp)
mov    0x8(%rbx),%ecx
mov    0x8(%rbp),%edx
mov    %edx,0x8(%rbx)
mov    %ecx,0x8(%rbp)
mov    0xc(%rbx),%ecx
mov    0xc(%rbp),%edx
mov    %edx,0xc(%rbx)
mov    %ecx,0xc(%rbp)
add    $0x10,%rbx
add    $0x10,%rbp
add    $0xfffffff0,%eax
jne    2050 <partition_sort+0xf50>
jmp    1ec7 <partition_sort+0xdc7>
cmpq   $0x0,0x40(%rsp)
je     2222 <partition_sort+0x1122>
mov    0x30(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx,%rax,1),%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
movups 0x0(%rbp,%rax,1),%xmm2
movups 0x10(%rbp,%rax,1),%xmm3
movups %xmm2,(%rbx,%rax,1)
movups %xmm3,0x10(%rbx,%rax,1)
movups %xmm0,0x0(%rbp,%rax,1)
movups %xmm1,0x10(%rbp,%rax,1)
movups 0x20(%rbx,%rax,1),%xmm0
movups 0x30(%rbx,%rax,1),%xmm1
movups 0x20(%rbp,%rax,1),%xmm2
movups 0x30(%rbp,%rax,1),%xmm3
movups %xmm2,0x20(%rbx,%rax,1)
movups %xmm3,0x30(%rbx,%rax,1)
movups %xmm0,0x20(%rbp,%rax,1)
movups %xmm1,0x30(%rbp,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rcx
jne    20b0 <partition_sort+0xfb0>
testb  $0x1,0x38(%rsp)
je     2135 <partition_sort+0x1035>
movups (%rbx,%rax,1),%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
movups 0x0(%rbp,%rax,1),%xmm2
movups 0x10(%rbp,%rax,1),%xmm3
movups %xmm2,(%rbx,%rax,1)
movups %xmm3,0x10(%rbx,%rax,1)
movups %xmm0,0x0(%rbp,%rax,1)
movups %xmm1,0x10(%rbp,%rax,1)
mov    0x48(%rsp),%rax
add    %rax,%rbx
add    %rax,%rbp
mov    0xc(%rsp),%ecx
mov    %ecx,%esi
cmp    %rax,0x10(%rsp)
je     1ec7 <partition_sort+0xdc7>
jmp    1f30 <partition_sort+0xe30>
cmpq   $0x0,0x88(%rsp)
je     2234 <partition_sort+0x1134>
mov    0x70(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rbx,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
movups 0x0(%rbp,%rax,4),%xmm2
movups 0x10(%rbp,%rax,4),%xmm3
movups %xmm2,(%rbx,%rax,4)
movups %xmm3,0x10(%rbx,%rax,4)
movups %xmm0,0x0(%rbp,%rax,4)
movups %xmm1,0x10(%rbp,%rax,4)
movups 0x20(%rbx,%rax,4),%xmm0
movups 0x30(%rbx,%rax,4),%xmm1
movups 0x20(%rbp,%rax,4),%xmm2
movups 0x30(%rbp,%rax,4),%xmm3
movups %xmm2,0x20(%rbx,%rax,4)
movups %xmm3,0x30(%rbx,%rax,4)
movups %xmm0,0x20(%rbp,%rax,4)
movups %xmm1,0x30(%rbp,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2170 <partition_sort+0x1070>
testb  $0x1,0x80(%rsp)
01
je     21f8 <partition_sort+0x10f8>
movups (%rbx,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
movups 0x0(%rbp,%rax,4),%xmm2
movups 0x10(%rbp,%rax,4),%xmm3
movups %xmm2,(%rbx,%rax,4)
movups %xmm3,0x10(%rbx,%rax,4)
movups %xmm0,0x0(%rbp,%rax,4)
movups %xmm1,0x10(%rbp,%rax,4)
mov    0x78(%rsp),%rax
add    %rax,%rbx
add    %rax,%rbp
mov    0x18(%rsp),%eax
mov    0x90(%rsp),%rcx
cmp    0x98(%rsp),%rcx
je     1ec7 <partition_sort+0xdc7>
jmp    1ff4 <partition_sort+0xef4>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
jne    210f <partition_sort+0x100f>
jmp    2135 <partition_sort+0x1035>
xor    %eax,%eax
testb  $0x1,0x80(%rsp)
01
jne    21d2 <partition_sort+0x10d2>
jmp    21f8 <partition_sort+0x10f8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   $0x3,%al
je     2340 <partition_sort+0x1240>
cmpl   $0x1f,0x50(%rsp)
mov    0x58(%rsp),%rdi
mov    0x20(%rsp),%rdx
jb     228e <partition_sort+0x118e>
mov    0xe8(%rsp),%rax
add    %rdx,%rax
cmp    %rax,%rbx
jae    2525 <partition_sort+0x1425>
mov    0x10(%rsp),%rax
add    %rbx,%rax
cmp    %rax,%r12
jae    2525 <partition_sort+0x1425>
mov    %r13d,%ebp
lea    -0x1(%rbp),%r8d
test   $0x3,%bpl
je     22d0 <partition_sort+0x11d0>
mov    %ebp,%esi
and    $0x3,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rbx,%rdx,1),%ecx
movzbl (%r12,%rdx,1),%eax
mov    %al,(%rbx,%rdx,1)
mov    %cl,(%r12,%rdx,1)
add    $0x1,%rdx
cmp    %edx,%esi
jne    22b0 <partition_sort+0x11b0>
add    %rdx,%rbx
add    %rdx,%r12
sub    %edx,%ebp
cmp    $0x3,%r8d
jb     242f <partition_sort+0x132f>
mov    %ebp,%esi
xor    %ecx,%ecx
xchg   %ax,%ax
movzbl (%rbx,%rcx,1),%edx
movzbl (%r12,%rcx,1),%eax
mov    %al,(%rbx,%rcx,1)
mov    %dl,(%r12,%rcx,1)
movzbl 0x1(%rbx,%rcx,1),%eax
movzbl 0x1(%r12,%rcx,1),%edx
mov    %dl,0x1(%rbx,%rcx,1)
mov    %al,0x1(%r12,%rcx,1)
movzbl 0x2(%rbx,%rcx,1),%eax
movzbl 0x2(%r12,%rcx,1),%edx
mov    %dl,0x2(%rbx,%rcx,1)
mov    %al,0x2(%r12,%rcx,1)
movzbl 0x3(%rbx,%rcx,1),%eax
movzbl 0x3(%r12,%rcx,1),%edx
mov    %dl,0x3(%rbx,%rcx,1)
mov    %al,0x3(%r12,%rcx,1)
add    $0x4,%rcx
cmp    %ecx,%esi
jne    22e0 <partition_sort+0x11e0>
jmp    242c <partition_sort+0x132c>
nopl   0x0(%rax)
cmpl   $0x7,0xf0(%rsp)
07
mov    0xe0(%rsp),%rdx
mov    0x58(%rsp),%rdi
mov    0x20(%rsp),%rsi
jb     2384 <partition_sort+0x1284>
mov    0xd8(%rsp),%rax
add    %rsi,%rax
cmp    %rax,%rbx
jae    2675 <partition_sort+0x1575>
mov    0xd0(%rsp),%rax
add    %rbx,%rax
cmp    %rax,%r12
jae    2675 <partition_sort+0x1575>
mov    %r13d,%eax
lea    -0x4(%rax),%r8d
mov    %r8d,%edx
shr    $0x2,%edx
lea    0x1(%rdx),%esi
test   $0x3,%sil
je     23ce <partition_sort+0x12ce>
add    $0x1,%dl
movzbl %dl,%edx
and    $0x3,%edx
shl    $0x2,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
mov    (%rbx,%rsi,1),%ecx
mov    (%r12,%rsi,1),%ebp
mov    %ebp,(%rbx,%rsi,1)
mov    %ecx,(%r12,%rsi,1)
add    $0x4,%rsi
cmp    %esi,%edx
jne    23b0 <partition_sort+0x12b0>
add    %rsi,%rbx
add    %rsi,%r12
sub    %esi,%eax
cmp    $0xc,%r8d
jb     242f <partition_sort+0x132f>
mov    %eax,%eax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,1),%edx
mov    (%r12,%rcx,1),%esi
mov    %esi,(%rbx,%rcx,1)
mov    %edx,(%r12,%rcx,1)
mov    0x4(%rbx,%rcx,1),%edx
mov    0x4(%r12,%rcx,1),%esi
mov    %esi,0x4(%rbx,%rcx,1)
mov    %edx,0x4(%r12,%rcx,1)
mov    0x8(%rbx,%rcx,1),%edx
mov    0x8(%r12,%rcx,1),%esi
mov    %esi,0x8(%rbx,%rcx,1)
mov    %edx,0x8(%r12,%rcx,1)
mov    0xc(%rbx,%rcx,1),%edx
mov    0xc(%r12,%rcx,1),%esi
mov    %esi,0xc(%rbx,%rcx,1)
mov    %edx,0xc(%r12,%rcx,1)
add    $0x10,%rcx
cmp    %ecx,%eax
jne    23e0 <partition_sort+0x12e0>
add    %rcx,%rbx
add    %r14,%rbx
mov    %rbx,%rax
sub    %rdi,%rax
mov    %rax,%rcx
or     %r13,%rcx
shr    $0x20,%rcx
je     2450 <partition_sort+0x1350>
xor    %edx,%edx
div    %r13
jmp    2455 <partition_sort+0x1355>
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
div    %r13d
mov    0x64(%rsp),%esi
sub    %eax,%esi
add    $0xffffffff,%eax
cmp    %esi,%eax
jle    2480 <partition_sort+0x1380>
cmp    $0xa,%esi
jg     296c <partition_sort+0x186c>
mov    %eax,%esi
cmp    $0xa,%eax
jg     12f0 <partition_sort+0x1f0>
jmp    12c0 <partition_sort+0x1c0>
nopl   0x0(%rax,%rax,1)
cmp    $0xa,%eax
jg     2978 <partition_sort+0x1878>
mov    %rbx,%rdi
cmp    $0xa,%esi
jg     12f0 <partition_sort+0x1f0>
jmp    12c0 <partition_sort+0x1c0>
cmpq   $0x0,0x40(%rsp)
je     274d <partition_sort+0x164d>
add    0x68(%rsp),%rbp
mov    0x30(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r12,%rax,1),%xmm0
movups 0x10(%r12,%rax,1),%xmm1
movups -0x30(%rbp,%rax,1),%xmm2
movups -0x20(%rbp,%rax,1),%xmm3
movups %xmm2,(%r12,%rax,1)
movups %xmm3,0x10(%r12,%rax,1)
movups %xmm0,-0x30(%rbp,%rax,1)
movups %xmm1,-0x20(%rbp,%rax,1)
movups 0x20(%r12,%rax,1),%xmm0
movups 0x30(%r12,%rax,1),%xmm1
movups -0x10(%rbp,%rax,1),%xmm2
movups 0x0(%rbp,%rax,1),%xmm3
movups %xmm2,0x20(%r12,%rax,1)
movups %xmm3,0x30(%r12,%rax,1)
movups %xmm0,-0x10(%rbp,%rax,1)
movups %xmm1,0x0(%rbp,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rcx
jne    24c0 <partition_sort+0x13c0>
jmp    274f <partition_sort+0x164f>
cmpq   $0x0,0x40(%rsp)
je     27a2 <partition_sort+0x16a2>
add    0x68(%rsp),%rdx
mov    0x30(%rsp),%rcx
xor    %eax,%eax
nopl   (%rax)
movups (%rbx,%rax,1),%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
movups -0x30(%rdx,%rax,1),%xmm2
movups -0x20(%rdx,%rax,1),%xmm3
movups %xmm2,(%rbx,%rax,1)
movups %xmm3,0x10(%rbx,%rax,1)
movups %xmm0,-0x30(%rdx,%rax,1)
movups %xmm1,-0x20(%rdx,%rax,1)
movups 0x20(%rbx,%rax,1),%xmm0
movups 0x30(%rbx,%rax,1),%xmm1
movups -0x10(%rdx,%rax,1),%xmm2
movups (%rdx,%rax,1),%xmm3
movups %xmm2,0x20(%rbx,%rax,1)
movups %xmm3,0x30(%rbx,%rax,1)
movups %xmm0,-0x10(%rdx,%rax,1)
movups %xmm1,(%rdx,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rcx
jne    2540 <partition_sort+0x1440>
testb  $0x1,0x38(%rsp)
je     25c5 <partition_sort+0x14c5>
movups (%rbx,%rax,1),%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
movups (%r12,%rax,1),%xmm2
movups 0x10(%r12,%rax,1),%xmm3
movups %xmm2,(%rbx,%rax,1)
movups %xmm3,0x10(%rbx,%rax,1)
movups %xmm0,(%r12,%rax,1)
movups %xmm1,0x10(%r12,%rax,1)
mov    0x48(%rsp),%rax
add    %rax,%rbx
cmp    %rax,0x10(%rsp)
je     242f <partition_sort+0x132f>
add    %rax,%r12
mov    0xc(%rsp),%eax
mov    %eax,%ebp
jmp    2291 <partition_sort+0x1191>
cmpq   $0x0,0xb8(%rsp)
je     28b5 <partition_sort+0x17b5>
add    0x68(%rsp),%rbp
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r12,%rax,4),%xmm0
movups 0x10(%r12,%rax,4),%xmm1
movups -0x30(%rbp,%rax,4),%xmm2
movups -0x20(%rbp,%rax,4),%xmm3
movups %xmm2,(%r12,%rax,4)
movups %xmm3,0x10(%r12,%rax,4)
movups %xmm0,-0x30(%rbp,%rax,4)
movups %xmm1,-0x20(%rbp,%rax,4)
movups 0x20(%r12,%rax,4),%xmm0
movups 0x30(%r12,%rax,4),%xmm1
movups -0x10(%rbp,%rax,4),%xmm2
movups 0x0(%rbp,%rax,4),%xmm3
movups %xmm2,0x20(%r12,%rax,4)
movups %xmm3,0x30(%r12,%rax,4)
movups %xmm0,-0x10(%rbp,%rax,4)
movups %xmm1,0x0(%rbp,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2610 <partition_sort+0x1510>
jmp    28b7 <partition_sort+0x17b7>
cmpq   $0x0,0xb8(%rsp)
je     291b <partition_sort+0x181b>
add    0x68(%rsp),%rsi
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
movups -0x30(%rsi,%rax,4),%xmm2
movups -0x20(%rsi,%rax,4),%xmm3
movups %xmm2,(%rbx,%rax,4)
movups %xmm3,0x10(%rbx,%rax,4)
movups %xmm0,-0x30(%rsi,%rax,4)
movups %xmm1,-0x20(%rsi,%rax,4)
movups 0x20(%rbx,%rax,4),%xmm0
movups 0x30(%rbx,%rax,4),%xmm1
movups -0x10(%rsi,%rax,4),%xmm2
movups (%rsi,%rax,4),%xmm3
movups %xmm2,0x20(%rbx,%rax,4)
movups %xmm3,0x30(%rbx,%rax,4)
movups %xmm0,-0x10(%rsi,%rax,4)
movups %xmm1,(%rsi,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    26a0 <partition_sort+0x15a0>
testb  $0x1,0xb0(%rsp)
01
je     2728 <partition_sort+0x1628>
movups (%rbx,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
movups (%r12,%rax,4),%xmm2
movups 0x10(%r12,%rax,4),%xmm3
movups %xmm2,(%rbx,%rax,4)
movups %xmm3,0x10(%rbx,%rax,4)
movups %xmm0,(%r12,%rax,4)
movups %xmm1,0x10(%r12,%rax,4)
add    %rdx,%rbx
mov    0xc0(%rsp),%rax
cmp    %rax,0xc8(%rsp)
je     242f <partition_sort+0x132f>
add    %rdx,%r12
mov    0x60(%rsp),%eax
jmp    2387 <partition_sort+0x1287>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
mov    %rdx,%rbp
je     2783 <partition_sort+0x1683>
movups (%r12,%rax,1),%xmm0
movups 0x10(%r12,%rax,1),%xmm1
movups 0x0(%rbp,%rax,1),%xmm2
movups 0x10(%rbp,%rax,1),%xmm3
movups %xmm2,(%r12,%rax,1)
movups %xmm3,0x10(%r12,%rax,1)
movups %xmm0,0x0(%rbp,%rax,1)
movups %xmm1,0x10(%rbp,%rax,1)
mov    0x48(%rsp),%rax
add    %rax,%rbp
cmp    %rax,0x10(%rsp)
je     1eb1 <partition_sort+0xdb1>
add    %rax,%r12
mov    0xc(%rsp),%eax
jmp    1d2a <partition_sort+0xc2a>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
jne    259d <partition_sort+0x149d>
jmp    25c5 <partition_sort+0x14c5>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
jne    157d <partition_sort+0x47d>
jmp    15a5 <partition_sort+0x4a5>
cmpq   $0x0,0x88(%rsp)
je     29a1 <partition_sort+0x18a1>
lea    (%rdx,%rsi,1),%rcx
add    $0x30,%rcx
mov    0x70(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rbx,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
movups -0x30(%rcx,%rax,4),%xmm2
movups -0x20(%rcx,%rax,4),%xmm3
movups %xmm2,(%rbx,%rax,4)
movups %xmm3,0x10(%rbx,%rax,4)
movups %xmm0,-0x30(%rcx,%rax,4)
movups %xmm1,-0x20(%rcx,%rax,4)
movups 0x20(%rbx,%rax,4),%xmm0
movups 0x30(%rbx,%rax,4),%xmm1
movups -0x10(%rcx,%rax,4),%xmm2
movups (%rcx,%rax,4),%xmm3
movups %xmm2,0x20(%rbx,%rax,4)
movups %xmm3,0x30(%rbx,%rax,4)
movups %xmm0,-0x10(%rcx,%rax,4)
movups %xmm1,(%rcx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    27f0 <partition_sort+0x16f0>
testb  $0x1,0x80(%rsp)
01
je     2876 <partition_sort+0x1776>
movups (%rbx,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
movups 0x0(%rbp,%rax,4),%xmm2
movups 0x10(%rbp,%rax,4),%xmm3
movups %xmm2,(%rbx,%rax,4)
movups %xmm3,0x10(%rbx,%rax,4)
movups %xmm0,0x0(%rbp,%rax,4)
movups %xmm1,0x10(%rbp,%rax,4)
mov    0x78(%rsp),%rax
add    %rax,%rbp
add    %rax,%rbx
mov    0x18(%rsp),%eax
mov    %rbx,%r8
mov    0x90(%rsp),%rcx
cmp    0x98(%rsp),%rcx
je     197e <partition_sort+0x87e>
jmp    17b9 <partition_sort+0x6b9>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
jne    1bb7 <partition_sort+0xab7>
jmp    1be1 <partition_sort+0xae1>
xor    %eax,%eax
testb  $0x1,0xb0(%rsp)
01
mov    %rdx,%rbp
je     28ee <partition_sort+0x17ee>
movups (%r12,%rax,4),%xmm0
movups 0x10(%r12,%rax,4),%xmm1
movups 0x0(%rbp,%rax,4),%xmm2
movups 0x10(%rbp,%rax,4),%xmm3
movups %xmm2,(%r12,%rax,4)
movups %xmm3,0x10(%r12,%rax,4)
movups %xmm0,0x0(%rbp,%rax,4)
movups %xmm1,0x10(%rbp,%rax,4)
mov    0xe0(%rsp),%rcx
add    %rcx,%rbp
mov    0xc0(%rsp),%rax
cmp    %rax,0xc8(%rsp)
je     1eb1 <partition_sort+0xdb1>
add    %rcx,%r12
mov    0x60(%rsp),%eax
jmp    1e08 <partition_sort+0xd08>
xor    %eax,%eax
testb  $0x1,0xb0(%rsp)
01
jne    2700 <partition_sort+0x1600>
jmp    2728 <partition_sort+0x1628>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
jne    18ed <partition_sort+0x7ed>
jmp    1913 <partition_sort+0x813>
xor    %eax,%eax
testb  $0x1,0x80(%rsp)
01
jne    1650 <partition_sort+0x550>
jmp    1678 <partition_sort+0x578>
xor    %eax,%eax
testb  $0x1,0x80(%rsp)
01
jne    1c8a <partition_sort+0xb8a>
jmp    1cb4 <partition_sort+0xbb4>
mov    %rdi,%rdx
mov    %eax,%ecx
mov    %esi,%eax
mov    %rbx,%rdi
jmp    297d <partition_sort+0x187d>
mov    %rbx,%rdx
mov    %esi,%ecx
mov    0x2c(%rsp),%ebx
movslq %ebx,%rsi
mov    %rdx,0x180(%rsp,%rsi,8)
add    $0x1,%ebx
mov    %ebx,0x2c(%rsp)
mov    %ecx,0x100(%rsp,%rsi,4)
mov    %eax,%esi
jmp    12f0 <partition_sort+0x1f0>
xor    %eax,%eax
testb  $0x1,0x80(%rsp)
01
jne    2850 <partition_sort+0x1750>
jmp    2876 <partition_sort+0x1776>
add    $0x288,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @partition_sort(i8* %0, i64 %1, i64 %2, i32 (i8*, i8*)* nocapture %3) {
%5 = alloca [32 x i8*]
%6 = alloca [32 x i32]
%7 = bitcast [32 x i8*]* %5 to i8*
%8 = bitcast [32 x i32]* %6 to i8*
%9 = getelementptr inbounds [32 x i8*], [32 x i8*]* %5, i64 0, i64 0
store i8* %0, i8** %9
%10 = trunc i64 %1 to i32
%11 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 0
store i32 %10, i32* %11
%12 = trunc i64 %2 to i32
%13 = sub i64 0, %2
%14 = add i64 %2, 4294967292
%15 = and i64 %14, 4294967292
%16 = add nuw nsw i64 %15, 4
%17 = add nuw nsw i64 %15, 4
%18 = sub i64 %17, %2
%19 = add i64 %2, 4294967292
%20 = lshr i64 %19, 2
%21 = and i64 %20, 1073741823
%22 = add nuw nsw i64 %21, 1
%23 = add i32 %12, -1
%24 = zext i32 %23 to i64
%25 = add nuw nsw i64 %24, 1
%26 = add nuw nsw i64 %24, 1
%27 = sub i64 %26, %2
%28 = zext i32 %23 to i64
%29 = add nuw nsw i64 %28, 1
%30 = add i32 %12, -4
%31 = and i32 %30, -4
%32 = zext i32 %31 to i64
%33 = add nuw nsw i64 %32, 4
%34 = lshr i32 %30, 2
%35 = add nuw nsw i32 %34, 1
%36 = zext i32 %35 to i64
%37 = add i32 %12, -1
%38 = zext i32 %37 to i64
%39 = add nuw nsw i64 %38, 1
%40 = zext i32 %37 to i64
%41 = add nuw nsw i64 %40, 1
%42 = add i64 %2, 4294967292
%43 = and i64 %42, 4294967292
%44 = add nuw nsw i64 %43, 4
%45 = add nuw nsw i64 %43, 4
%46 = sub i64 %45, %2
%47 = add i64 %2, 4294967292
%48 = lshr i64 %47, 2
%49 = and i64 %48, 1073741823
%50 = add nuw nsw i64 %49, 1
%51 = add i32 %12, -1
%52 = zext i32 %51 to i64
%53 = add nuw nsw i64 %52, 1
%54 = add nuw nsw i64 %52, 1
%55 = sub i64 %54, %2
%56 = zext i32 %51 to i64
%57 = add nuw nsw i64 %56, 1
%58 = add i32 %12, -4
%59 = and i32 %58, -4
%60 = zext i32 %59 to i64
%61 = add nuw nsw i64 %60, 4
%62 = lshr i32 %58, 2
%63 = add nuw nsw i32 %62, 1
%64 = zext i32 %63 to i64
%65 = add i32 %12, -1
%66 = zext i32 %65 to i64
%67 = add nuw nsw i64 %66, 1
%68 = zext i32 %65 to i64
%69 = add nuw nsw i64 %68, 1
%70 = add i32 %12, -4
%71 = and i32 %70, -4
%72 = zext i32 %71 to i64
%73 = add nuw nsw i64 %72, 4
%74 = lshr i32 %70, 2
%75 = add nuw nsw i32 %74, 1
%76 = zext i32 %75 to i64
%77 = add i32 %12, -1
%78 = zext i32 %77 to i64
%79 = add nuw nsw i64 %78, 1
%80 = zext i32 %77 to i64
%81 = add nuw nsw i64 %80, 1
%82 = add i32 %12, -4
%83 = and i32 %82, -4
%84 = zext i32 %83 to i64
%85 = add nuw nsw i64 %84, 4
%86 = lshr i32 %82, 2
%87 = add nuw nsw i32 %86, 1
%88 = zext i32 %87 to i64
%89 = add i32 %12, -1
%90 = zext i32 %89 to i64
%91 = add nuw nsw i64 %90, 1
%92 = zext i32 %89 to i64
%93 = add nuw nsw i64 %92, 1
%94 = and i64 %91, 8589934560
%95 = add nsw i64 %94, -32
%96 = lshr exact i64 %95, 5
%97 = add nuw nsw i64 %96, 1
%98 = and i64 %76, 2147483640
%99 = add nsw i64 %98, -8
%100 = lshr exact i64 %99, 3
%101 = add nuw nsw i64 %100, 1
%102 = and i64 %22, 2147483640
%103 = add nsw i64 %102, -8
%104 = lshr exact i64 %103, 3
%105 = add nuw nsw i64 %104, 1
%106 = icmp ult i32 %89, 31
%107 = and i64 %93, 8589934560
%108 = trunc i64 %107 to i32
%109 = sub i32 %12, %108
%110 = and i64 %97, 1
%111 = icmp eq i64 %95, 0
%112 = and i64 %97, 1152921504606846974
%113 = icmp eq i64 %110, 0
%114 = icmp eq i64 %93, %107
%115 = icmp ult i32 %82, 28
%116 = and i64 %88, 2147483640
%117 = trunc i64 %116 to i32
%118 = mul i32 %117, -4
%119 = add i32 %118, %12
%120 = shl nuw nsw i64 %116, 2
%121 = shl nuw nsw i64 %116, 2
%122 = and i64 %101, 1
%123 = icmp eq i64 %99, 0
%124 = and i64 %101, 4611686018427387902
%125 = icmp eq i64 %122, 0
%126 = icmp eq i64 %116, %88
%127 = icmp ult i32 %77, 31
%128 = and i64 %81, 8589934560
%129 = trunc i64 %128 to i32
%130 = sub i32 %12, %129
%131 = and i64 %97, 1
%132 = icmp eq i64 %95, 0
%133 = and i64 %97, 1152921504606846974
%134 = icmp eq i64 %131, 0
%135 = icmp eq i64 %81, %128
%136 = icmp ult i32 %70, 28
%137 = and i64 %76, 2147483640
%138 = trunc i64 %137 to i32
%139 = mul i32 %138, -4
%140 = add i32 %139, %12
%141 = shl nuw nsw i64 %137, 2
%142 = shl nuw nsw i64 %137, 2
%143 = and i64 %101, 1
%144 = icmp eq i64 %99, 0
%145 = and i64 %101, 4611686018427387902
%146 = icmp eq i64 %143, 0
%147 = icmp eq i64 %137, %76
%148 = icmp ult i32 %65, 31
%149 = and i64 %69, 8589934560
%150 = trunc i64 %149 to i32
%151 = sub i32 %12, %150
%152 = and i64 %97, 1
%153 = icmp eq i64 %95, 0
%154 = and i64 %97, 1152921504606846974
%155 = icmp eq i64 %152, 0
%156 = icmp eq i64 %69, %149
%157 = icmp ult i32 %58, 28
%158 = and i64 %64, 2147483640
%159 = trunc i64 %158 to i32
%160 = mul i32 %159, -4
%161 = add i32 %160, %12
%162 = shl nuw nsw i64 %158, 2
%163 = shl nuw nsw i64 %158, 2
%164 = and i64 %101, 1
%165 = icmp eq i64 %99, 0
%166 = and i64 %101, 4611686018427387902
%167 = icmp eq i64 %164, 0
%168 = icmp eq i64 %158, %64
%169 = icmp ult i32 %51, 31
%170 = and i64 %57, 8589934560
%171 = trunc i64 %170 to i32
%172 = sub i32 %12, %171
%173 = and i64 %97, 1
%174 = icmp eq i64 %95, 0
%175 = and i64 %97, 1152921504606846974
%176 = icmp eq i64 %173, 0
%177 = icmp eq i64 %57, %170
%178 = icmp ult i64 %49, 7
%179 = and i64 %50, 2147483640
%180 = shl nuw nsw i64 %179, 2
%181 = trunc i64 %179 to i32
%182 = mul i32 %181, -4
%183 = add i32 %182, %12
%184 = shl nuw nsw i64 %179, 2
%185 = and i64 %105, 1
%186 = icmp eq i64 %103, 0
%187 = and i64 %105, 4611686018427387902
%188 = icmp eq i64 %185, 0
%189 = icmp eq i64 %50, %179
%190 = icmp ult i32 %37, 31
%191 = and i64 %41, 8589934560
%192 = trunc i64 %191 to i32
%193 = sub i32 %12, %192
%194 = and i64 %97, 1
%195 = icmp eq i64 %95, 0
%196 = and i64 %97, 1152921504606846974
%197 = icmp eq i64 %194, 0
%198 = icmp eq i64 %41, %191
%199 = icmp ult i32 %30, 28
%200 = and i64 %36, 2147483640
%201 = shl nuw nsw i64 %200, 2
%202 = shl nuw nsw i64 %200, 2
%203 = trunc i64 %200 to i32
%204 = mul i32 %203, -4
%205 = add i32 %204, %12
%206 = and i64 %101, 1
%207 = icmp eq i64 %99, 0
%208 = and i64 %101, 4611686018427387902
%209 = icmp eq i64 %206, 0
%210 = icmp eq i64 %200, %36
%211 = icmp ult i32 %23, 31
%212 = and i64 %29, 8589934560
%213 = trunc i64 %212 to i32
%214 = sub i32 %12, %213
%215 = and i64 %97, 1
%216 = icmp eq i64 %95, 0
%217 = and i64 %97, 1152921504606846974
%218 = icmp eq i64 %215, 0
%219 = icmp eq i64 %29, %212
%220 = icmp ult i64 %21, 7
%221 = and i64 %22, 2147483640
%222 = shl nuw nsw i64 %221, 2
%223 = shl nuw nsw i64 %221, 2
%224 = trunc i64 %221 to i32
%225 = mul i32 %224, -4
%226 = add i32 %225, %12
%227 = and i64 %105, 1
%228 = icmp eq i64 %103, 0
%229 = and i64 %105, 4611686018427387902
%230 = icmp eq i64 %227, 0
%231 = icmp eq i64 %22, %221
br label %234
232: ; preds = %1866, %1873
%233 = icmp eq i32 %245, 0
br i1 %233, label %1884, label %234
234: ; preds = %232, %4
%235 = phi i32 [ 1, %4 ], [ %245, %232 ]
%236 = add nsw i32 %235, -1
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds [32 x i8*], [32 x i8*]* %5, i64 0, i64 %237
%239 = load i8*, i8** %238
%240 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %237
%241 = load i32, i32* %240
br label %242
242: ; preds = %1875, %234
%243 = phi i32 [ %1878, %1875 ], [ %241, %234 ]
%244 = phi i8* [ %1879, %1875 ], [ %239, %234 ]
%245 = phi i32 [ %1882, %1875 ], [ %236, %234 ]
br label %246
246: ; preds = %1868, %242
%247 = phi i32 [ %243, %242 ], [ %1869, %1868 ]
%248 = phi i8* [ %244, %242 ], [ %1870, %1868 ]
%249 = ashr i32 %247, 1
%250 = mul i32 %249, %12
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i8, i8* %248, i64 %251
%253 = and i32 %247, 1
%254 = icmp eq i32 %253, 0
%255 = select i1 %254, i32 %12, i32 0
%256 = sub i32 %250, %255
%257 = sext i32 %256 to i64
%258 = getelementptr i8, i8* %252, i64 %257
%259 = tail call i32 %3(i8* %248, i8* %252)
%260 = icmp sgt i32 %259, 0
br i1 %260, label %261, label %525
261: ; preds = %246
%262 = ptrtoint i8* %248 to i64
%263 = or i64 %262, %2
%264 = and i64 %263, 3
%265 = icmp eq i64 %264, 0
br i1 %265, label %362, label %266
266: ; preds = %261
br i1 %106, label %336, label %267
267: ; preds = %266
%268 = getelementptr i8, i8* %248, i64 %91
%269 = getelementptr i8, i8* %248, i64 %91
%270 = getelementptr i8, i8* %269, i64 %251
%271 = icmp ult i8* %248, %270
%272 = icmp ult i8* %252, %268
%273 = and i1 %271, %272
br i1 %273, label %336, label %274
274: ; preds = %267
%275 = getelementptr i8, i8* %252, i64 %107
%276 = getelementptr i8, i8* %248, i64 %107
br i1 %111, label %316, label %277
277: ; preds = %274, %277
%278 = phi i64 [ %313, %277 ], [ 0, %274 ]
%279 = phi i64 [ %314, %277 ], [ 0, %274 ]
%280 = getelementptr i8, i8* %252, i64 %278
%281 = getelementptr i8, i8* %248, i64 %278
%282 = bitcast i8* %281 to <16 x i8>*
%283 = load <16 x i8>, <16 x i8>* %282
%284 = getelementptr i8, i8* %281, i64 16
%285 = bitcast i8* %284 to <16 x i8>*
%286 = load <16 x i8>, <16 x i8>* %285
%287 = bitcast i8* %280 to <16 x i8>*
%288 = load <16 x i8>, <16 x i8>* %287
%289 = getelementptr i8, i8* %280, i64 16
%290 = bitcast i8* %289 to <16 x i8>*
%291 = load <16 x i8>, <16 x i8>* %290
%292 = bitcast i8* %281 to <16 x i8>*
store <16 x i8> %288, <16 x i8>* %292
%293 = bitcast i8* %284 to <16 x i8>*
store <16 x i8> %291, <16 x i8>* %293
%294 = bitcast i8* %280 to <16 x i8>*
store <16 x i8> %283, <16 x i8>* %294
%295 = bitcast i8* %289 to <16 x i8>*
store <16 x i8> %286, <16 x i8>* %295
%296 = or i64 %278, 32
%297 = getelementptr i8, i8* %252, i64 %296
%298 = getelementptr i8, i8* %248, i64 %296
%299 = bitcast i8* %298 to <16 x i8>*
%300 = load <16 x i8>, <16 x i8>* %299
%301 = getelementptr i8, i8* %298, i64 16
%302 = bitcast i8* %301 to <16 x i8>*
%303 = load <16 x i8>, <16 x i8>* %302
%304 = bitcast i8* %297 to <16 x i8>*
%305 = load <16 x i8>, <16 x i8>* %304
%306 = getelementptr i8, i8* %297, i64 16
%307 = bitcast i8* %306 to <16 x i8>*
%308 = load <16 x i8>, <16 x i8>* %307
%309 = bitcast i8* %298 to <16 x i8>*
store <16 x i8> %305, <16 x i8>* %309
%310 = bitcast i8* %301 to <16 x i8>*
store <16 x i8> %308, <16 x i8>* %310
%311 = bitcast i8* %297 to <16 x i8>*
store <16 x i8> %300, <16 x i8>* %311
%312 = bitcast i8* %306 to <16 x i8>*
store <16 x i8> %303, <16 x i8>* %312
%313 = add nuw i64 %278, 64
%314 = add i64 %279, 2
%315 = icmp eq i64 %314, %112
br i1 %315, label %316, label %277
316: ; preds = %277, %274
%317 = phi i64 [ 0, %274 ], [ %313, %277 ]
br i1 %113, label %335, label %318
318: ; preds = %316
%319 = getelementptr i8, i8* %252, i64 %317
%320 = getelementptr i8, i8* %248, i64 %317
%321 = bitcast i8* %320 to <16 x i8>*
%322 = load <16 x i8>, <16 x i8>* %321
%323 = getelementptr i8, i8* %320, i64 16
%324 = bitcast i8* %323 to <16 x i8>*
%325 = load <16 x i8>, <16 x i8>* %324
%326 = bitcast i8* %319 to <16 x i8>*
%327 = load <16 x i8>, <16 x i8>* %326
%328 = getelementptr i8, i8* %319, i64 16
%329 = bitcast i8* %328 to <16 x i8>*
%330 = load <16 x i8>, <16 x i8>* %329
%331 = bitcast i8* %320 to <16 x i8>*
store <16 x i8> %327, <16 x i8>* %331
%332 = bitcast i8* %323 to <16 x i8>*
store <16 x i8> %330, <16 x i8>* %332
%333 = bitcast i8* %319 to <16 x i8>*
store <16 x i8> %322, <16 x i8>* %333
%334 = bitcast i8* %328 to <16 x i8>*
store <16 x i8> %325, <16 x i8>* %334
br label %335
335: ; preds = %316, %318
br i1 %114, label %520, label %336
336: ; preds = %267, %266, %335
%337 = phi i32 [ %12, %267 ], [ %12, %266 ], [ %109, %335 ]
%338 = phi i8* [ %252, %267 ], [ %252, %266 ], [ %275, %335 ]
%339 = phi i8* [ %248, %267 ], [ %248, %266 ], [ %276, %335 ]
%340 = add i32 %337, -1
%341 = and i32 %337, 3
%342 = icmp eq i32 %341, 0
br i1 %342, label %355, label %343
343: ; preds = %336, %343
%344 = phi i32 [ %352, %343 ], [ %337, %336 ]
%345 = phi i8* [ %351, %343 ], [ %338, %336 ]
%346 = phi i8* [ %350, %343 ], [ %339, %336 ]
%347 = phi i32 [ %353, %343 ], [ 0, %336 ]
%348 = load i8, i8* %346
%349 = load i8, i8* %345
%350 = getelementptr inbounds i8, i8* %346, i64 1
store i8 %349, i8* %346
%351 = getelementptr inbounds i8, i8* %345, i64 1
store i8 %348, i8* %345
%352 = add nsw i32 %344, -1
%353 = add i32 %347, 1
%354 = icmp eq i32 %353, %341
br i1 %354, label %355, label %343
355: ; preds = %343, %336
%356 = phi i8* [ undef, %336 ], [ %350, %343 ]
%357 = phi i8* [ undef, %336 ], [ %351, %343 ]
%358 = phi i32 [ %337, %336 ], [ %352, %343 ]
%359 = phi i8* [ %338, %336 ], [ %351, %343 ]
%360 = phi i8* [ %339, %336 ], [ %350, %343 ]
%361 = icmp ult i32 %340, 3
br i1 %361, label %520, label %498
362: ; preds = %261
br i1 %115, label %438, label %363
363: ; preds = %362
%364 = getelementptr i8, i8* %248, i64 %85
%365 = getelementptr i8, i8* %248, i64 %85
%366 = getelementptr i8, i8* %365, i64 %251
%367 = icmp ult i8* %248, %366
%368 = icmp ult i8* %252, %364
%369 = and i1 %367, %368
br i1 %369, label %438, label %370
370: ; preds = %363
%371 = getelementptr i8, i8* %252, i64 %120
%372 = getelementptr i8, i8* %248, i64 %121
br i1 %123, label %416, label %373
373: ; preds = %370, %373
%374 = phi i64 [ %413, %373 ], [ 0, %370 ]
%375 = phi i64 [ %414, %373 ], [ 0, %370 ]
%376 = shl i64 %374, 2
%377 = getelementptr i8, i8* %252, i64 %376
%378 = shl i64 %374, 2
%379 = getelementptr i8, i8* %248, i64 %378
%380 = bitcast i8* %379 to <4 x i32>*
%381 = load <4 x i32>, <4 x i32>* %380
%382 = getelementptr i8, i8* %379, i64 16
%383 = bitcast i8* %382 to <4 x i32>*
%384 = load <4 x i32>, <4 x i32>* %383
%385 = bitcast i8* %377 to <4 x i32>*
%386 = load <4 x i32>, <4 x i32>* %385
%387 = getelementptr i8, i8* %377, i64 16
%388 = bitcast i8* %387 to <4 x i32>*
%389 = load <4 x i32>, <4 x i32>* %388
%390 = bitcast i8* %379 to <4 x i32>*
store <4 x i32> %386, <4 x i32>* %390
%391 = bitcast i8* %382 to <4 x i32>*
store <4 x i32> %389, <4 x i32>* %391
%392 = bitcast i8* %377 to <4 x i32>*
store <4 x i32> %381, <4 x i32>* %392
%393 = bitcast i8* %387 to <4 x i32>*
store <4 x i32> %384, <4 x i32>* %393
%394 = or i64 %374, 8
%395 = shl i64 %394, 2
%396 = getelementptr i8, i8* %252, i64 %395
%397 = shl i64 %394, 2
%398 = getelementptr i8, i8* %248, i64 %397
%399 = bitcast i8* %398 to <4 x i32>*
%400 = load <4 x i32>, <4 x i32>* %399
%401 = getelementptr i8, i8* %398, i64 16
%402 = bitcast i8* %401 to <4 x i32>*
%403 = load <4 x i32>, <4 x i32>* %402
%404 = bitcast i8* %396 to <4 x i32>*
%405 = load <4 x i32>, <4 x i32>* %404
%406 = getelementptr i8, i8* %396, i64 16
%407 = bitcast i8* %406 to <4 x i32>*
%408 = load <4 x i32>, <4 x i32>* %407
%409 = bitcast i8* %398 to <4 x i32>*
store <4 x i32> %405, <4 x i32>* %409
%410 = bitcast i8* %401 to <4 x i32>*
store <4 x i32> %408, <4 x i32>* %410
%411 = bitcast i8* %396 to <4 x i32>*
store <4 x i32> %400, <4 x i32>* %411
%412 = bitcast i8* %406 to <4 x i32>*
store <4 x i32> %403, <4 x i32>* %412
%413 = add nuw i64 %374, 16
%414 = add i64 %375, 2
%415 = icmp eq i64 %414, %124
br i1 %415, label %416, label %373
416: ; preds = %373, %370
%417 = phi i64 [ 0, %370 ], [ %413, %373 ]
br i1 %125, label %437, label %418
418: ; preds = %416
%419 = shl i64 %417, 2
%420 = getelementptr i8, i8* %252, i64 %419
%421 = shl i64 %417, 2
%422 = getelementptr i8, i8* %248, i64 %421
%423 = bitcast i8* %422 to <4 x i32>*
%424 = load <4 x i32>, <4 x i32>* %423
%425 = getelementptr i8, i8* %422, i64 16
%426 = bitcast i8* %425 to <4 x i32>*
%427 = load <4 x i32>, <4 x i32>* %426
%428 = bitcast i8* %420 to <4 x i32>*
%429 = load <4 x i32>, <4 x i32>* %428
%430 = getelementptr i8, i8* %420, i64 16
%431 = bitcast i8* %430 to <4 x i32>*
%432 = load <4 x i32>, <4 x i32>* %431
%433 = bitcast i8* %422 to <4 x i32>*
store <4 x i32> %429, <4 x i32>* %433
%434 = bitcast i8* %425 to <4 x i32>*
store <4 x i32> %432, <4 x i32>* %434
%435 = bitcast i8* %420 to <4 x i32>*
store <4 x i32> %424, <4 x i32>* %435
%436 = bitcast i8* %430 to <4 x i32>*
store <4 x i32> %427, <4 x i32>* %436
br label %437
437: ; preds = %416, %418
br i1 %126, label %520, label %438
438: ; preds = %363, %362, %437
%439 = phi i32 [ %12, %363 ], [ %12, %362 ], [ %119, %437 ]
%440 = phi i8* [ %252, %363 ], [ %252, %362 ], [ %371, %437 ]
%441 = phi i8* [ %248, %363 ], [ %248, %362 ], [ %372, %437 ]
%442 = add i32 %439, -4
%443 = lshr i32 %442, 2
%444 = add nuw nsw i32 %443, 1
%445 = and i32 %444, 3
%446 = icmp eq i32 %445, 0
br i1 %446, label %461, label %447
447: ; preds = %438, %447
%448 = phi i32 [ %458, %447 ], [ %439, %438 ]
%449 = phi i8* [ %457, %447 ], [ %440, %438 ]
%450 = phi i8* [ %456, %447 ], [ %441, %438 ]
%451 = phi i32 [ %459, %447 ], [ 0, %438 ]
%452 = bitcast i8* %450 to i32*
%453 = load i32, i32* %452
%454 = bitcast i8* %449 to i32*
%455 = load i32, i32* %454
store i32 %455, i32* %452
store i32 %453, i32* %454
%456 = getelementptr inbounds i8, i8* %450, i64 4
%457 = getelementptr inbounds i8, i8* %449, i64 4
%458 = add nsw i32 %448, -4
%459 = add i32 %451, 1
%460 = icmp eq i32 %459, %445
br i1 %460, label %461, label %447
461: ; preds = %447, %438
%462 = phi i8* [ undef, %438 ], [ %456, %447 ]
%463 = phi i8* [ undef, %438 ], [ %457, %447 ]
%464 = phi i32 [ %439, %438 ], [ %458, %447 ]
%465 = phi i8* [ %440, %438 ], [ %457, %447 ]
%466 = phi i8* [ %441, %438 ], [ %456, %447 ]
%467 = icmp ult i32 %442, 12
br i1 %467, label %520, label %468
468: ; preds = %461, %468
%469 = phi i32 [ %496, %468 ], [ %464, %461 ]
%470 = phi i8* [ %495, %468 ], [ %465, %461 ]
%471 = phi i8* [ %494, %468 ], [ %466, %461 ]
%472 = bitcast i8* %471 to i32*
%473 = load i32, i32* %472
%474 = bitcast i8* %470 to i32*
%475 = load i32, i32* %474
store i32 %475, i32* %472
store i32 %473, i32* %474
%476 = getelementptr inbounds i8, i8* %471, i64 4
%477 = getelementptr inbounds i8, i8* %470, i64 4
%478 = bitcast i8* %476 to i32*
%479 = load i32, i32* %478
%480 = bitcast i8* %477 to i32*
%481 = load i32, i32* %480
store i32 %481, i32* %478
store i32 %479, i32* %480
%482 = getelementptr inbounds i8, i8* %471, i64 8
%483 = getelementptr inbounds i8, i8* %470, i64 8
%484 = bitcast i8* %482 to i32*
%485 = load i32, i32* %484
%486 = bitcast i8* %483 to i32*
%487 = load i32, i32* %486
store i32 %487, i32* %484
store i32 %485, i32* %486
%488 = getelementptr inbounds i8, i8* %471, i64 12
%489 = getelementptr inbounds i8, i8* %470, i64 12
%490 = bitcast i8* %488 to i32*
%491 = load i32, i32* %490
%492 = bitcast i8* %489 to i32*
%493 = load i32, i32* %492
store i32 %493, i32* %490
store i32 %491, i32* %492
%494 = getelementptr inbounds i8, i8* %471, i64 16
%495 = getelementptr inbounds i8, i8* %470, i64 16
%496 = add nsw i32 %469, -16
%497 = icmp eq i32 %496, 0
br i1 %497, label %520, label %468
498: ; preds = %355, %498
%499 = phi i32 [ %518, %498 ], [ %358, %355 ]
%500 = phi i8* [ %517, %498 ], [ %359, %355 ]
%501 = phi i8* [ %516, %498 ], [ %360, %355 ]
%502 = load i8, i8* %501
%503 = load i8, i8* %500
%504 = getelementptr inbounds i8, i8* %501, i64 1
store i8 %503, i8* %501
%505 = getelementptr inbounds i8, i8* %500, i64 1
store i8 %502, i8* %500
%506 = load i8, i8* %504
%507 = load i8, i8* %505
%508 = getelementptr inbounds i8, i8* %501, i64 2
store i8 %507, i8* %504
%509 = getelementptr inbounds i8, i8* %500, i64 2
store i8 %506, i8* %505
%510 = load i8, i8* %508
%511 = load i8, i8* %509
%512 = getelementptr inbounds i8, i8* %501, i64 3
store i8 %511, i8* %508
%513 = getelementptr inbounds i8, i8* %500, i64 3
store i8 %510, i8* %509
%514 = load i8, i8* %512
%515 = load i8, i8* %513
%516 = getelementptr inbounds i8, i8* %501, i64 4
store i8 %515, i8* %512
%517 = getelementptr inbounds i8, i8* %500, i64 4
store i8 %514, i8* %513
%518 = add nsw i32 %499, -4
%519 = icmp eq i32 %518, 0
br i1 %519, label %520, label %498
520: ; preds = %355, %498, %461, %468, %335, %437
%521 = phi i8* [ %371, %437 ], [ %275, %335 ], [ %463, %461 ], [ %495, %468 ], [ %357, %355 ], [ %517, %498 ]
%522 = phi i8* [ %372, %437 ], [ %276, %335 ], [ %462, %461 ], [ %494, %468 ], [ %356, %355 ], [ %516, %498 ]
%523 = getelementptr inbounds i8, i8* %522, i64 %13
%524 = getelementptr inbounds i8, i8* %521, i64 %13
br label %525
525: ; preds = %520, %246
%526 = phi i8* [ %524, %520 ], [ %252, %246 ]
%527 = phi i8* [ %523, %520 ], [ %248, %246 ]
%528 = tail call i32 %3(i8* %526, i8* %258)
%529 = icmp sgt i32 %528, 0
br i1 %529, label %530, label %1063
530: ; preds = %525
%531 = tail call i32 %3(i8* %527, i8* %258)
%532 = icmp sgt i32 %531, 0
br i1 %532, label %533, label %799
533: ; preds = %530
%534 = ptrtoint i8* %527 to i64
%535 = or i64 %534, %2
%536 = and i64 %535, 3
%537 = icmp eq i64 %536, 0
br i1 %537, label %635, label %538
538: ; preds = %533
br i1 %127, label %609, label %539
539: ; preds = %538
%540 = getelementptr i8, i8* %527, i64 %79
%541 = getelementptr i8, i8* %248, i64 %79
%542 = add nsw i64 %251, %257
%543 = getelementptr i8, i8* %541, i64 %542
%544 = icmp ult i8* %527, %543
%545 = icmp ult i8* %258, %540
%546 = and i1 %544, %545
br i1 %546, label %609, label %547
547: ; preds = %539
%548 = getelementptr i8, i8* %258, i64 %128
%549 = getelementptr i8, i8* %527, i64 %128
br i1 %132, label %589, label %550
550: ; preds = %547, %550
%551 = phi i64 [ %586, %550 ], [ 0, %547 ]
%552 = phi i64 [ %587, %550 ], [ 0, %547 ]
%553 = getelementptr i8, i8* %258, i64 %551
%554 = getelementptr i8, i8* %527, i64 %551
%555 = bitcast i8* %554 to <16 x i8>*
%556 = load <16 x i8>, <16 x i8>* %555
%557 = getelementptr i8, i8* %554, i64 16
%558 = bitcast i8* %557 to <16 x i8>*
%559 = load <16 x i8>, <16 x i8>* %558
%560 = bitcast i8* %553 to <16 x i8>*
%561 = load <16 x i8>, <16 x i8>* %560
%562 = getelementptr i8, i8* %553, i64 16
%563 = bitcast i8* %562 to <16 x i8>*
%564 = load <16 x i8>, <16 x i8>* %563
%565 = bitcast i8* %554 to <16 x i8>*
store <16 x i8> %561, <16 x i8>* %565
%566 = bitcast i8* %557 to <16 x i8>*
store <16 x i8> %564, <16 x i8>* %566
%567 = bitcast i8* %553 to <16 x i8>*
store <16 x i8> %556, <16 x i8>* %567
%568 = bitcast i8* %562 to <16 x i8>*
store <16 x i8> %559, <16 x i8>* %568
%569 = or i64 %551, 32
%570 = getelementptr i8, i8* %258, i64 %569
%571 = getelementptr i8, i8* %527, i64 %569
%572 = bitcast i8* %571 to <16 x i8>*
%573 = load <16 x i8>, <16 x i8>* %572
%574 = getelementptr i8, i8* %571, i64 16
%575 = bitcast i8* %574 to <16 x i8>*
%576 = load <16 x i8>, <16 x i8>* %575
%577 = bitcast i8* %570 to <16 x i8>*
%578 = load <16 x i8>, <16 x i8>* %577
%579 = getelementptr i8, i8* %570, i64 16
%580 = bitcast i8* %579 to <16 x i8>*
%581 = load <16 x i8>, <16 x i8>* %580
%582 = bitcast i8* %571 to <16 x i8>*
store <16 x i8> %578, <16 x i8>* %582
%583 = bitcast i8* %574 to <16 x i8>*
store <16 x i8> %581, <16 x i8>* %583
%584 = bitcast i8* %570 to <16 x i8>*
store <16 x i8> %573, <16 x i8>* %584
%585 = bitcast i8* %579 to <16 x i8>*
store <16 x i8> %576, <16 x i8>* %585
%586 = add nuw i64 %551, 64
%587 = add i64 %552, 2
%588 = icmp eq i64 %587, %133
br i1 %588, label %589, label %550
589: ; preds = %550, %547
%590 = phi i64 [ 0, %547 ], [ %586, %550 ]
br i1 %134, label %608, label %591
591: ; preds = %589
%592 = getelementptr i8, i8* %258, i64 %590
%593 = getelementptr i8, i8* %527, i64 %590
%594 = bitcast i8* %593 to <16 x i8>*
%595 = load <16 x i8>, <16 x i8>* %594
%596 = getelementptr i8, i8* %593, i64 16
%597 = bitcast i8* %596 to <16 x i8>*
%598 = load <16 x i8>, <16 x i8>* %597
%599 = bitcast i8* %592 to <16 x i8>*
%600 = load <16 x i8>, <16 x i8>* %599
%601 = getelementptr i8, i8* %592, i64 16
%602 = bitcast i8* %601 to <16 x i8>*
%603 = load <16 x i8>, <16 x i8>* %602
%604 = bitcast i8* %593 to <16 x i8>*
store <16 x i8> %600, <16 x i8>* %604
%605 = bitcast i8* %596 to <16 x i8>*
store <16 x i8> %603, <16 x i8>* %605
%606 = bitcast i8* %592 to <16 x i8>*
store <16 x i8> %595, <16 x i8>* %606
%607 = bitcast i8* %601 to <16 x i8>*
store <16 x i8> %598, <16 x i8>* %607
br label %608
608: ; preds = %589, %591
br i1 %135, label %794, label %609
609: ; preds = %539, %538, %608
%610 = phi i32 [ %12, %539 ], [ %12, %538 ], [ %130, %608 ]
%611 = phi i8* [ %258, %539 ], [ %258, %538 ], [ %548, %608 ]
%612 = phi i8* [ %527, %539 ], [ %527, %538 ], [ %549, %608 ]
%613 = add i32 %610, -1
%614 = and i32 %610, 3
%615 = icmp eq i32 %614, 0
br i1 %615, label %628, label %616
616: ; preds = %609, %616
%617 = phi i32 [ %625, %616 ], [ %610, %609 ]
%618 = phi i8* [ %624, %616 ], [ %611, %609 ]
%619 = phi i8* [ %623, %616 ], [ %612, %609 ]
%620 = phi i32 [ %626, %616 ], [ 0, %609 ]
%621 = load i8, i8* %619
%622 = load i8, i8* %618
%623 = getelementptr inbounds i8, i8* %619, i64 1
store i8 %622, i8* %619
%624 = getelementptr inbounds i8, i8* %618, i64 1
store i8 %621, i8* %618
%625 = add nsw i32 %617, -1
%626 = add i32 %620, 1
%627 = icmp eq i32 %626, %614
br i1 %627, label %628, label %616
628: ; preds = %616, %609
%629 = phi i8* [ undef, %609 ], [ %623, %616 ]
%630 = phi i8* [ undef, %609 ], [ %624, %616 ]
%631 = phi i32 [ %610, %609 ], [ %625, %616 ]
%632 = phi i8* [ %611, %609 ], [ %624, %616 ]
%633 = phi i8* [ %612, %609 ], [ %623, %616 ]
%634 = icmp ult i32 %613, 3
br i1 %634, label %794, label %772
635: ; preds = %533
br i1 %136, label %712, label %636
636: ; preds = %635
%637 = getelementptr i8, i8* %527, i64 %73
%638 = getelementptr i8, i8* %248, i64 %73
%639 = add nsw i64 %251, %257
%640 = getelementptr i8, i8* %638, i64 %639
%641 = icmp ult i8* %527, %640
%642 = icmp ult i8* %258, %637
%643 = and i1 %641, %642
br i1 %643, label %712, label %644
644: ; preds = %636
%645 = getelementptr i8, i8* %258, i64 %141
%646 = getelementptr i8, i8* %527, i64 %142
br i1 %144, label %690, label %647
647: ; preds = %644, %647
%648 = phi i64 [ %687, %647 ], [ 0, %644 ]
%649 = phi i64 [ %688, %647 ], [ 0, %644 ]
%650 = shl i64 %648, 2
%651 = getelementptr i8, i8* %258, i64 %650
%652 = shl i64 %648, 2
%653 = getelementptr i8, i8* %527, i64 %652
%654 = bitcast i8* %653 to <4 x i32>*
%655 = load <4 x i32>, <4 x i32>* %654
%656 = getelementptr i8, i8* %653, i64 16
%657 = bitcast i8* %656 to <4 x i32>*
%658 = load <4 x i32>, <4 x i32>* %657
%659 = bitcast i8* %651 to <4 x i32>*
%660 = load <4 x i32>, <4 x i32>* %659
%661 = getelementptr i8, i8* %651, i64 16
%662 = bitcast i8* %661 to <4 x i32>*
%663 = load <4 x i32>, <4 x i32>* %662
%664 = bitcast i8* %653 to <4 x i32>*
store <4 x i32> %660, <4 x i32>* %664
%665 = bitcast i8* %656 to <4 x i32>*
store <4 x i32> %663, <4 x i32>* %665
%666 = bitcast i8* %651 to <4 x i32>*
store <4 x i32> %655, <4 x i32>* %666
%667 = bitcast i8* %661 to <4 x i32>*
store <4 x i32> %658, <4 x i32>* %667
%668 = or i64 %648, 8
%669 = shl i64 %668, 2
%670 = getelementptr i8, i8* %258, i64 %669
%671 = shl i64 %668, 2
%672 = getelementptr i8, i8* %527, i64 %671
%673 = bitcast i8* %672 to <4 x i32>*
%674 = load <4 x i32>, <4 x i32>* %673
%675 = getelementptr i8, i8* %672, i64 16
%676 = bitcast i8* %675 to <4 x i32>*
%677 = load <4 x i32>, <4 x i32>* %676
%678 = bitcast i8* %670 to <4 x i32>*
%679 = load <4 x i32>, <4 x i32>* %678
%680 = getelementptr i8, i8* %670, i64 16
%681 = bitcast i8* %680 to <4 x i32>*
%682 = load <4 x i32>, <4 x i32>* %681
%683 = bitcast i8* %672 to <4 x i32>*
store <4 x i32> %679, <4 x i32>* %683
%684 = bitcast i8* %675 to <4 x i32>*
store <4 x i32> %682, <4 x i32>* %684
%685 = bitcast i8* %670 to <4 x i32>*
store <4 x i32> %674, <4 x i32>* %685
%686 = bitcast i8* %680 to <4 x i32>*
store <4 x i32> %677, <4 x i32>* %686
%687 = add nuw i64 %648, 16
%688 = add i64 %649, 2
%689 = icmp eq i64 %688, %145
br i1 %689, label %690, label %647
690: ; preds = %647, %644
%691 = phi i64 [ 0, %644 ], [ %687, %647 ]
br i1 %146, label %711, label %692
692: ; preds = %690
%693 = shl i64 %691, 2
%694 = getelementptr i8, i8* %258, i64 %693
%695 = shl i64 %691, 2
%696 = getelementptr i8, i8* %527, i64 %695
%697 = bitcast i8* %696 to <4 x i32>*
%698 = load <4 x i32>, <4 x i32>* %697
%699 = getelementptr i8, i8* %696, i64 16
%700 = bitcast i8* %699 to <4 x i32>*
%701 = load <4 x i32>, <4 x i32>* %700
%702 = bitcast i8* %694 to <4 x i32>*
%703 = load <4 x i32>, <4 x i32>* %702
%704 = getelementptr i8, i8* %694, i64 16
%705 = bitcast i8* %704 to <4 x i32>*
%706 = load <4 x i32>, <4 x i32>* %705
%707 = bitcast i8* %696 to <4 x i32>*
store <4 x i32> %703, <4 x i32>* %707
%708 = bitcast i8* %699 to <4 x i32>*
store <4 x i32> %706, <4 x i32>* %708
%709 = bitcast i8* %694 to <4 x i32>*
store <4 x i32> %698, <4 x i32>* %709
%710 = bitcast i8* %704 to <4 x i32>*
store <4 x i32> %701, <4 x i32>* %710
br label %711
711: ; preds = %690, %692
br i1 %147, label %794, label %712
712: ; preds = %636, %635, %711
%713 = phi i32 [ %12, %636 ], [ %12, %635 ], [ %140, %711 ]
%714 = phi i8* [ %258, %636 ], [ %258, %635 ], [ %645, %711 ]
%715 = phi i8* [ %527, %636 ], [ %527, %635 ], [ %646, %711 ]
%716 = add i32 %713, -4
%717 = lshr i32 %716, 2
%718 = add nuw nsw i32 %717, 1
%719 = and i32 %718, 3
%720 = icmp eq i32 %719, 0
br i1 %720, label %735, label %721
721: ; preds = %712, %721
%722 = phi i32 [ %732, %721 ], [ %713, %712 ]
%723 = phi i8* [ %731, %721 ], [ %714, %712 ]
%724 = phi i8* [ %730, %721 ], [ %715, %712 ]
%725 = phi i32 [ %733, %721 ], [ 0, %712 ]
%726 = bitcast i8* %724 to i32*
%727 = load i32, i32* %726
%728 = bitcast i8* %723 to i32*
%729 = load i32, i32* %728
store i32 %729, i32* %726
store i32 %727, i32* %728
%730 = getelementptr inbounds i8, i8* %724, i64 4
%731 = getelementptr inbounds i8, i8* %723, i64 4
%732 = add nsw i32 %722, -4
%733 = add i32 %725, 1
%734 = icmp eq i32 %733, %719
br i1 %734, label %735, label %721
735: ; preds = %721, %712
%736 = phi i8* [ undef, %712 ], [ %730, %721 ]
%737 = phi i8* [ undef, %712 ], [ %731, %721 ]
%738 = phi i32 [ %713, %712 ], [ %732, %721 ]
%739 = phi i8* [ %714, %712 ], [ %731, %721 ]
%740 = phi i8* [ %715, %712 ], [ %730, %721 ]
%741 = icmp ult i32 %716, 12
br i1 %741, label %794, label %742
742: ; preds = %735, %742
%743 = phi i32 [ %770, %742 ], [ %738, %735 ]
%744 = phi i8* [ %769, %742 ], [ %739, %735 ]
%745 = phi i8* [ %768, %742 ], [ %740, %735 ]
%746 = bitcast i8* %745 to i32*
%747 = load i32, i32* %746
%748 = bitcast i8* %744 to i32*
%749 = load i32, i32* %748
store i32 %749, i32* %746
store i32 %747, i32* %748
%750 = getelementptr inbounds i8, i8* %745, i64 4
%751 = getelementptr inbounds i8, i8* %744, i64 4
%752 = bitcast i8* %750 to i32*
%753 = load i32, i32* %752
%754 = bitcast i8* %751 to i32*
%755 = load i32, i32* %754
store i32 %755, i32* %752
store i32 %753, i32* %754
%756 = getelementptr inbounds i8, i8* %745, i64 8
%757 = getelementptr inbounds i8, i8* %744, i64 8
%758 = bitcast i8* %756 to i32*
%759 = load i32, i32* %758
%760 = bitcast i8* %757 to i32*
%761 = load i32, i32* %760
store i32 %761, i32* %758
store i32 %759, i32* %760
%762 = getelementptr inbounds i8, i8* %745, i64 12
%763 = getelementptr inbounds i8, i8* %744, i64 12
%764 = bitcast i8* %762 to i32*
%765 = load i32, i32* %764
%766 = bitcast i8* %763 to i32*
%767 = load i32, i32* %766
store i32 %767, i32* %764
store i32 %765, i32* %766
%768 = getelementptr inbounds i8, i8* %745, i64 16
%769 = getelementptr inbounds i8, i8* %744, i64 16
%770 = add nsw i32 %743, -16
%771 = icmp eq i32 %770, 0
br i1 %771, label %794, label %742
772: ; preds = %628, %772
%773 = phi i32 [ %792, %772 ], [ %631, %628 ]
%774 = phi i8* [ %791, %772 ], [ %632, %628 ]
%775 = phi i8* [ %790, %772 ], [ %633, %628 ]
%776 = load i8, i8* %775
%777 = load i8, i8* %774
%778 = getelementptr inbounds i8, i8* %775, i64 1
store i8 %777, i8* %775
%779 = getelementptr inbounds i8, i8* %774, i64 1
store i8 %776, i8* %774
%780 = load i8, i8* %778
%781 = load i8, i8* %779
%782 = getelementptr inbounds i8, i8* %775, i64 2
store i8 %781, i8* %778
%783 = getelementptr inbounds i8, i8* %774, i64 2
store i8 %780, i8* %779
%784 = load i8, i8* %782
%785 = load i8, i8* %783
%786 = getelementptr inbounds i8, i8* %775, i64 3
store i8 %785, i8* %782
%787 = getelementptr inbounds i8, i8* %774, i64 3
store i8 %784, i8* %783
%788 = load i8, i8* %786
%789 = load i8, i8* %787
%790 = getelementptr inbounds i8, i8* %775, i64 4
store i8 %789, i8* %786
%791 = getelementptr inbounds i8, i8* %774, i64 4
store i8 %788, i8* %787
%792 = add nsw i32 %773, -4
%793 = icmp eq i32 %792, 0
br i1 %793, label %794, label %772
794: ; preds = %628, %772, %735, %742, %608, %711
%795 = phi i8* [ %645, %711 ], [ %548, %608 ], [ %737, %735 ], [ %769, %742 ], [ %630, %628 ], [ %791, %772 ]
%796 = phi i8* [ %646, %711 ], [ %549, %608 ], [ %736, %735 ], [ %768, %742 ], [ %629, %628 ], [ %790, %772 ]
%797 = getelementptr inbounds i8, i8* %796, i64 %13
%798 = getelementptr inbounds i8, i8* %795, i64 %13
br label %799
799: ; preds = %794, %530
%800 = phi i8* [ %798, %794 ], [ %258, %530 ]
%801 = phi i8* [ %797, %794 ], [ %527, %530 ]
%802 = ptrtoint i8* %526 to i64
%803 = or i64 %802, %2
%804 = and i64 %803, 3
%805 = icmp eq i64 %804, 0
br i1 %805, label %901, label %806
806: ; preds = %799
br i1 %148, label %875, label %807
807: ; preds = %806
%808 = getelementptr i8, i8* %526, i64 %67
%809 = getelementptr i8, i8* %800, i64 %67
%810 = icmp ult i8* %526, %809
%811 = icmp ult i8* %800, %808
%812 = and i1 %810, %811
br i1 %812, label %875, label %813
813: ; preds = %807
%814 = getelementptr i8, i8* %800, i64 %149
%815 = getelementptr i8, i8* %526, i64 %149
br i1 %153, label %855, label %816
816: ; preds = %813, %816
%817 = phi i64 [ %852, %816 ], [ 0, %813 ]
%818 = phi i64 [ %853, %816 ], [ 0, %813 ]
%819 = getelementptr i8, i8* %800, i64 %817
%820 = getelementptr i8, i8* %526, i64 %817
%821 = bitcast i8* %820 to <16 x i8>*
%822 = load <16 x i8>, <16 x i8>* %821
%823 = getelementptr i8, i8* %820, i64 16
%824 = bitcast i8* %823 to <16 x i8>*
%825 = load <16 x i8>, <16 x i8>* %824
%826 = bitcast i8* %819 to <16 x i8>*
%827 = load <16 x i8>, <16 x i8>* %826
%828 = getelementptr i8, i8* %819, i64 16
%829 = bitcast i8* %828 to <16 x i8>*
%830 = load <16 x i8>, <16 x i8>* %829
%831 = bitcast i8* %820 to <16 x i8>*
store <16 x i8> %827, <16 x i8>* %831
%832 = bitcast i8* %823 to <16 x i8>*
store <16 x i8> %830, <16 x i8>* %832
%833 = bitcast i8* %819 to <16 x i8>*
store <16 x i8> %822, <16 x i8>* %833
%834 = bitcast i8* %828 to <16 x i8>*
store <16 x i8> %825, <16 x i8>* %834
%835 = or i64 %817, 32
%836 = getelementptr i8, i8* %800, i64 %835
%837 = getelementptr i8, i8* %526, i64 %835
%838 = bitcast i8* %837 to <16 x i8>*
%839 = load <16 x i8>, <16 x i8>* %838
%840 = getelementptr i8, i8* %837, i64 16
%841 = bitcast i8* %840 to <16 x i8>*
%842 = load <16 x i8>, <16 x i8>* %841
%843 = bitcast i8* %836 to <16 x i8>*
%844 = load <16 x i8>, <16 x i8>* %843
%845 = getelementptr i8, i8* %836, i64 16
%846 = bitcast i8* %845 to <16 x i8>*
%847 = load <16 x i8>, <16 x i8>* %846
%848 = bitcast i8* %837 to <16 x i8>*
store <16 x i8> %844, <16 x i8>* %848
%849 = bitcast i8* %840 to <16 x i8>*
store <16 x i8> %847, <16 x i8>* %849
%850 = bitcast i8* %836 to <16 x i8>*
store <16 x i8> %839, <16 x i8>* %850
%851 = bitcast i8* %845 to <16 x i8>*
store <16 x i8> %842, <16 x i8>* %851
%852 = add nuw i64 %817, 64
%853 = add i64 %818, 2
%854 = icmp eq i64 %853, %154
br i1 %854, label %855, label %816
855: ; preds = %816, %813
%856 = phi i64 [ 0, %813 ], [ %852, %816 ]
br i1 %155, label %874, label %857
857: ; preds = %855
%858 = getelementptr i8, i8* %800, i64 %856
%859 = getelementptr i8, i8* %526, i64 %856
%860 = bitcast i8* %859 to <16 x i8>*
%861 = load <16 x i8>, <16 x i8>* %860
%862 = getelementptr i8, i8* %859, i64 16
%863 = bitcast i8* %862 to <16 x i8>*
%864 = load <16 x i8>, <16 x i8>* %863
%865 = bitcast i8* %858 to <16 x i8>*
%866 = load <16 x i8>, <16 x i8>* %865
%867 = getelementptr i8, i8* %858, i64 16
%868 = bitcast i8* %867 to <16 x i8>*
%869 = load <16 x i8>, <16 x i8>* %868
%870 = bitcast i8* %859 to <16 x i8>*
store <16 x i8> %866, <16 x i8>* %870
%871 = bitcast i8* %862 to <16 x i8>*
store <16 x i8> %869, <16 x i8>* %871
%872 = bitcast i8* %858 to <16 x i8>*
store <16 x i8> %861, <16 x i8>* %872
%873 = bitcast i8* %867 to <16 x i8>*
store <16 x i8> %864, <16 x i8>* %873
br label %874
874: ; preds = %855, %857
br i1 %156, label %1058, label %875
875: ; preds = %807, %806, %874
%876 = phi i32 [ %12, %807 ], [ %12, %806 ], [ %151, %874 ]
%877 = phi i8* [ %800, %807 ], [ %800, %806 ], [ %814, %874 ]
%878 = phi i8* [ %526, %807 ], [ %526, %806 ], [ %815, %874 ]
%879 = add i32 %876, -1
%880 = and i32 %876, 3
%881 = icmp eq i32 %880, 0
br i1 %881, label %894, label %882
882: ; preds = %875, %882
%883 = phi i32 [ %891, %882 ], [ %876, %875 ]
%884 = phi i8* [ %890, %882 ], [ %877, %875 ]
%885 = phi i8* [ %889, %882 ], [ %878, %875 ]
%886 = phi i32 [ %892, %882 ], [ 0, %875 ]
%887 = load i8, i8* %885
%888 = load i8, i8* %884
%889 = getelementptr inbounds i8, i8* %885, i64 1
store i8 %888, i8* %885
%890 = getelementptr inbounds i8, i8* %884, i64 1
store i8 %887, i8* %884
%891 = add nsw i32 %883, -1
%892 = add i32 %886, 1
%893 = icmp eq i32 %892, %880
br i1 %893, label %894, label %882
894: ; preds = %882, %875
%895 = phi i8* [ undef, %875 ], [ %889, %882 ]
%896 = phi i8* [ undef, %875 ], [ %890, %882 ]
%897 = phi i32 [ %876, %875 ], [ %891, %882 ]
%898 = phi i8* [ %877, %875 ], [ %890, %882 ]
%899 = phi i8* [ %878, %875 ], [ %889, %882 ]
%900 = icmp ult i32 %879, 3
br i1 %900, label %1058, label %1036
901: ; preds = %799
br i1 %157, label %976, label %902
902: ; preds = %901
%903 = getelementptr i8, i8* %526, i64 %61
%904 = getelementptr i8, i8* %800, i64 %61
%905 = icmp ult i8* %526, %904
%906 = icmp ult i8* %800, %903
%907 = and i1 %905, %906
br i1 %907, label %976, label %908
908: ; preds = %902
%909 = getelementptr i8, i8* %800, i64 %162
%910 = getelementptr i8, i8* %526, i64 %163
br i1 %165, label %954, label %911
911: ; preds = %908, %911
%912 = phi i64 [ %951, %911 ], [ 0, %908 ]
%913 = phi i64 [ %952, %911 ], [ 0, %908 ]
%914 = shl i64 %912, 2
%915 = getelementptr i8, i8* %800, i64 %914
%916 = shl i64 %912, 2
%917 = getelementptr i8, i8* %526, i64 %916
%918 = bitcast i8* %917 to <4 x i32>*
%919 = load <4 x i32>, <4 x i32>* %918
%920 = getelementptr i8, i8* %917, i64 16
%921 = bitcast i8* %920 to <4 x i32>*
%922 = load <4 x i32>, <4 x i32>* %921
%923 = bitcast i8* %915 to <4 x i32>*
%924 = load <4 x i32>, <4 x i32>* %923
%925 = getelementptr i8, i8* %915, i64 16
%926 = bitcast i8* %925 to <4 x i32>*
%927 = load <4 x i32>, <4 x i32>* %926
%928 = bitcast i8* %917 to <4 x i32>*
store <4 x i32> %924, <4 x i32>* %928
%929 = bitcast i8* %920 to <4 x i32>*
store <4 x i32> %927, <4 x i32>* %929
%930 = bitcast i8* %915 to <4 x i32>*
store <4 x i32> %919, <4 x i32>* %930
%931 = bitcast i8* %925 to <4 x i32>*
store <4 x i32> %922, <4 x i32>* %931
%932 = or i64 %912, 8
%933 = shl i64 %932, 2
%934 = getelementptr i8, i8* %800, i64 %933
%935 = shl i64 %932, 2
%936 = getelementptr i8, i8* %526, i64 %935
%937 = bitcast i8* %936 to <4 x i32>*
%938 = load <4 x i32>, <4 x i32>* %937
%939 = getelementptr i8, i8* %936, i64 16
%940 = bitcast i8* %939 to <4 x i32>*
%941 = load <4 x i32>, <4 x i32>* %940
%942 = bitcast i8* %934 to <4 x i32>*
%943 = load <4 x i32>, <4 x i32>* %942
%944 = getelementptr i8, i8* %934, i64 16
%945 = bitcast i8* %944 to <4 x i32>*
%946 = load <4 x i32>, <4 x i32>* %945
%947 = bitcast i8* %936 to <4 x i32>*
store <4 x i32> %943, <4 x i32>* %947
%948 = bitcast i8* %939 to <4 x i32>*
store <4 x i32> %946, <4 x i32>* %948
%949 = bitcast i8* %934 to <4 x i32>*
store <4 x i32> %938, <4 x i32>* %949
%950 = bitcast i8* %944 to <4 x i32>*
store <4 x i32> %941, <4 x i32>* %950
%951 = add nuw i64 %912, 16
%952 = add i64 %913, 2
%953 = icmp eq i64 %952, %166
br i1 %953, label %954, label %911
954: ; preds = %911, %908
%955 = phi i64 [ 0, %908 ], [ %951, %911 ]
br i1 %167, label %975, label %956
956: ; preds = %954
%957 = shl i64 %955, 2
%958 = getelementptr i8, i8* %800, i64 %957
%959 = shl i64 %955, 2
%960 = getelementptr i8, i8* %526, i64 %959
%961 = bitcast i8* %960 to <4 x i32>*
%962 = load <4 x i32>, <4 x i32>* %961
%963 = getelementptr i8, i8* %960, i64 16
%964 = bitcast i8* %963 to <4 x i32>*
%965 = load <4 x i32>, <4 x i32>* %964
%966 = bitcast i8* %958 to <4 x i32>*
%967 = load <4 x i32>, <4 x i32>* %966
%968 = getelementptr i8, i8* %958, i64 16
%969 = bitcast i8* %968 to <4 x i32>*
%970 = load <4 x i32>, <4 x i32>* %969
%971 = bitcast i8* %960 to <4 x i32>*
store <4 x i32> %967, <4 x i32>* %971
%972 = bitcast i8* %963 to <4 x i32>*
store <4 x i32> %970, <4 x i32>* %972
%973 = bitcast i8* %958 to <4 x i32>*
store <4 x i32> %962, <4 x i32>* %973
%974 = bitcast i8* %968 to <4 x i32>*
store <4 x i32> %965, <4 x i32>* %974
br label %975
975: ; preds = %954, %956
br i1 %168, label %1058, label %976
976: ; preds = %902, %901, %975
%977 = phi i32 [ %12, %902 ], [ %12, %901 ], [ %161, %975 ]
%978 = phi i8* [ %800, %902 ], [ %800, %901 ], [ %909, %975 ]
%979 = phi i8* [ %526, %902 ], [ %526, %901 ], [ %910, %975 ]
%980 = add i32 %977, -4
%981 = lshr i32 %980, 2
%982 = add nuw nsw i32 %981, 1
%983 = and i32 %982, 3
%984 = icmp eq i32 %983, 0
br i1 %984, label %999, label %985
985: ; preds = %976, %985
%986 = phi i32 [ %996, %985 ], [ %977, %976 ]
%987 = phi i8* [ %995, %985 ], [ %978, %976 ]
%988 = phi i8* [ %994, %985 ], [ %979, %976 ]
%989 = phi i32 [ %997, %985 ], [ 0, %976 ]
%990 = bitcast i8* %988 to i32*
%991 = load i32, i32* %990
%992 = bitcast i8* %987 to i32*
%993 = load i32, i32* %992
store i32 %993, i32* %990
store i32 %991, i32* %992
%994 = getelementptr inbounds i8, i8* %988, i64 4
%995 = getelementptr inbounds i8, i8* %987, i64 4
%996 = add nsw i32 %986, -4
%997 = add i32 %989, 1
%998 = icmp eq i32 %997, %983
br i1 %998, label %999, label %985
999: ; preds = %985, %976
%1000 = phi i8* [ undef, %976 ], [ %994, %985 ]
%1001 = phi i8* [ undef, %976 ], [ %995, %985 ]
%1002 = phi i32 [ %977, %976 ], [ %996, %985 ]
%1003 = phi i8* [ %978, %976 ], [ %995, %985 ]
%1004 = phi i8* [ %979, %976 ], [ %994, %985 ]
%1005 = icmp ult i32 %980, 12
br i1 %1005, label %1058, label %1006
1006: ; preds = %999, %1006
%1007 = phi i32 [ %1034, %1006 ], [ %1002, %999 ]
%1008 = phi i8* [ %1033, %1006 ], [ %1003, %999 ]
%1009 = phi i8* [ %1032, %1006 ], [ %1004, %999 ]
%1010 = bitcast i8* %1009 to i32*
%1011 = load i32, i32* %1010
%1012 = bitcast i8* %1008 to i32*
%1013 = load i32, i32* %1012
store i32 %1013, i32* %1010
store i32 %1011, i32* %1012
%1014 = getelementptr inbounds i8, i8* %1009, i64 4
%1015 = getelementptr inbounds i8, i8* %1008, i64 4
%1016 = bitcast i8* %1014 to i32*
%1017 = load i32, i32* %1016
%1018 = bitcast i8* %1015 to i32*
%1019 = load i32, i32* %1018
store i32 %1019, i32* %1016
store i32 %1017, i32* %1018
%1020 = getelementptr inbounds i8, i8* %1009, i64 8
%1021 = getelementptr inbounds i8, i8* %1008, i64 8
%1022 = bitcast i8* %1020 to i32*
%1023 = load i32, i32* %1022
%1024 = bitcast i8* %1021 to i32*
%1025 = load i32, i32* %1024
store i32 %1025, i32* %1022
store i32 %1023, i32* %1024
%1026 = getelementptr inbounds i8, i8* %1009, i64 12
%1027 = getelementptr inbounds i8, i8* %1008, i64 12
%1028 = bitcast i8* %1026 to i32*
%1029 = load i32, i32* %1028
%1030 = bitcast i8* %1027 to i32*
%1031 = load i32, i32* %1030
store i32 %1031, i32* %1028
store i32 %1029, i32* %1030
%1032 = getelementptr inbounds i8, i8* %1009, i64 16
%1033 = getelementptr inbounds i8, i8* %1008, i64 16
%1034 = add nsw i32 %1007, -16
%1035 = icmp eq i32 %1034, 0
br i1 %1035, label %1058, label %1006
1036: ; preds = %894, %1036
%1037 = phi i32 [ %1056, %1036 ], [ %897, %894 ]
%1038 = phi i8* [ %1055, %1036 ], [ %898, %894 ]
%1039 = phi i8* [ %1054, %1036 ], [ %899, %894 ]
%1040 = load i8, i8* %1039
%1041 = load i8, i8* %1038
%1042 = getelementptr inbounds i8, i8* %1039, i64 1
store i8 %1041, i8* %1039
%1043 = getelementptr inbounds i8, i8* %1038, i64 1
store i8 %1040, i8* %1038
%1044 = load i8, i8* %1042
%1045 = load i8, i8* %1043
%1046 = getelementptr inbounds i8, i8* %1039, i64 2
store i8 %1045, i8* %1042
%1047 = getelementptr inbounds i8, i8* %1038, i64 2
store i8 %1044, i8* %1043
%1048 = load i8, i8* %1046
%1049 = load i8, i8* %1047
%1050 = getelementptr inbounds i8, i8* %1039, i64 3
store i8 %1049, i8* %1046
%1051 = getelementptr inbounds i8, i8* %1038, i64 3
store i8 %1048, i8* %1047
%1052 = load i8, i8* %1050
%1053 = load i8, i8* %1051
%1054 = getelementptr inbounds i8, i8* %1039, i64 4
store i8 %1053, i8* %1050
%1055 = getelementptr inbounds i8, i8* %1038, i64 4
store i8 %1052, i8* %1051
%1056 = add nsw i32 %1037, -4
%1057 = icmp eq i32 %1056, 0
br i1 %1057, label %1058, label %1036
1058: ; preds = %894, %1036, %999, %1006, %874, %975
%1059 = phi i8* [ %909, %975 ], [ %814, %874 ], [ %1001, %999 ], [ %1033, %1006 ], [ %896, %894 ], [ %1055, %1036 ]
%1060 = phi i8* [ %910, %975 ], [ %815, %874 ], [ %1000, %999 ], [ %1032, %1006 ], [ %895, %894 ], [ %1054, %1036 ]
%1061 = getelementptr inbounds i8, i8* %1060, i64 %13
%1062 = getelementptr inbounds i8, i8* %1059, i64 %13
br label %1063
1063: ; preds = %1058, %525
%1064 = phi i8* [ %1062, %1058 ], [ %258, %525 ]
%1065 = phi i8* [ %1061, %1058 ], [ %526, %525 ]
%1066 = phi i8* [ %801, %1058 ], [ %527, %525 ]
%1067 = getelementptr i8, i8* %1064, i64 %13
%1068 = ptrtoint i8* %1065 to i64
%1069 = or i64 %1068, %2
%1070 = and i64 %1069, 3
%1071 = icmp eq i64 %1070, 0
br i1 %1071, label %1166, label %1072
1072: ; preds = %1063
br i1 %169, label %1141, label %1073
1073: ; preds = %1072
%1074 = getelementptr i8, i8* %1065, i64 %53
%1075 = getelementptr i8, i8* %1064, i64 %55
%1076 = icmp ult i8* %1065, %1075
%1077 = icmp ult i8* %1067, %1074
%1078 = and i1 %1076, %1077
br i1 %1078, label %1141, label %1079
1079: ; preds = %1073
%1080 = getelementptr i8, i8* %1067, i64 %170
%1081 = getelementptr i8, i8* %1065, i64 %170
br i1 %174, label %1121, label %1082
1082: ; preds = %1079, %1082
%1083 = phi i64 [ %1118, %1082 ], [ 0, %1079 ]
%1084 = phi i64 [ %1119, %1082 ], [ 0, %1079 ]
%1085 = getelementptr i8, i8* %1067, i64 %1083
%1086 = getelementptr i8, i8* %1065, i64 %1083
%1087 = bitcast i8* %1086 to <16 x i8>*
%1088 = load <16 x i8>, <16 x i8>* %1087
%1089 = getelementptr i8, i8* %1086, i64 16
%1090 = bitcast i8* %1089 to <16 x i8>*
%1091 = load <16 x i8>, <16 x i8>* %1090
%1092 = bitcast i8* %1085 to <16 x i8>*
%1093 = load <16 x i8>, <16 x i8>* %1092
%1094 = getelementptr i8, i8* %1085, i64 16
%1095 = bitcast i8* %1094 to <16 x i8>*
%1096 = load <16 x i8>, <16 x i8>* %1095
%1097 = bitcast i8* %1086 to <16 x i8>*
store <16 x i8> %1093, <16 x i8>* %1097
%1098 = bitcast i8* %1089 to <16 x i8>*
store <16 x i8> %1096, <16 x i8>* %1098
%1099 = bitcast i8* %1085 to <16 x i8>*
store <16 x i8> %1088, <16 x i8>* %1099
%1100 = bitcast i8* %1094 to <16 x i8>*
store <16 x i8> %1091, <16 x i8>* %1100
%1101 = or i64 %1083, 32
%1102 = getelementptr i8, i8* %1067, i64 %1101
%1103 = getelementptr i8, i8* %1065, i64 %1101
%1104 = bitcast i8* %1103 to <16 x i8>*
%1105 = load <16 x i8>, <16 x i8>* %1104
%1106 = getelementptr i8, i8* %1103, i64 16
%1107 = bitcast i8* %1106 to <16 x i8>*
%1108 = load <16 x i8>, <16 x i8>* %1107
%1109 = bitcast i8* %1102 to <16 x i8>*
%1110 = load <16 x i8>, <16 x i8>* %1109
%1111 = getelementptr i8, i8* %1102, i64 16
%1112 = bitcast i8* %1111 to <16 x i8>*
%1113 = load <16 x i8>, <16 x i8>* %1112
%1114 = bitcast i8* %1103 to <16 x i8>*
store <16 x i8> %1110, <16 x i8>* %1114
%1115 = bitcast i8* %1106 to <16 x i8>*
store <16 x i8> %1113, <16 x i8>* %1115
%1116 = bitcast i8* %1102 to <16 x i8>*
store <16 x i8> %1105, <16 x i8>* %1116
%1117 = bitcast i8* %1111 to <16 x i8>*
store <16 x i8> %1108, <16 x i8>* %1117
%1118 = add nuw i64 %1083, 64
%1119 = add i64 %1084, 2
%1120 = icmp eq i64 %1119, %175
br i1 %1120, label %1121, label %1082
1121: ; preds = %1082, %1079
%1122 = phi i64 [ 0, %1079 ], [ %1118, %1082 ]
br i1 %176, label %1140, label %1123
1123: ; preds = %1121
%1124 = getelementptr i8, i8* %1067, i64 %1122
%1125 = getelementptr i8, i8* %1065, i64 %1122
%1126 = bitcast i8* %1125 to <16 x i8>*
%1127 = load <16 x i8>, <16 x i8>* %1126
%1128 = getelementptr i8, i8* %1125, i64 16
%1129 = bitcast i8* %1128 to <16 x i8>*
%1130 = load <16 x i8>, <16 x i8>* %1129
%1131 = bitcast i8* %1124 to <16 x i8>*
%1132 = load <16 x i8>, <16 x i8>* %1131
%1133 = getelementptr i8, i8* %1124, i64 16
%1134 = bitcast i8* %1133 to <16 x i8>*
%1135 = load <16 x i8>, <16 x i8>* %1134
%1136 = bitcast i8* %1125 to <16 x i8>*
store <16 x i8> %1132, <16 x i8>* %1136
%1137 = bitcast i8* %1128 to <16 x i8>*
store <16 x i8> %1135, <16 x i8>* %1137
%1138 = bitcast i8* %1124 to <16 x i8>*
store <16 x i8> %1127, <16 x i8>* %1138
%1139 = bitcast i8* %1133 to <16 x i8>*
store <16 x i8> %1130, <16 x i8>* %1139
br label %1140
1140: ; preds = %1121, %1123
br i1 %177, label %1322, label %1141
1141: ; preds = %1073, %1072, %1140
%1142 = phi i8* [ %1067, %1073 ], [ %1067, %1072 ], [ %1080, %1140 ]
%1143 = phi i32 [ %12, %1073 ], [ %12, %1072 ], [ %172, %1140 ]
%1144 = phi i8* [ %1065, %1073 ], [ %1065, %1072 ], [ %1081, %1140 ]
%1145 = add i32 %1143, -1
%1146 = and i32 %1143, 3
%1147 = icmp eq i32 %1146, 0
br i1 %1147, label %1160, label %1148
1148: ; preds = %1141, %1148
%1149 = phi i8* [ %1156, %1148 ], [ %1142, %1141 ]
%1150 = phi i32 [ %1157, %1148 ], [ %1143, %1141 ]
%1151 = phi i8* [ %1155, %1148 ], [ %1144, %1141 ]
%1152 = phi i32 [ %1158, %1148 ], [ 0, %1141 ]
%1153 = load i8, i8* %1151
%1154 = load i8, i8* %1149
%1155 = getelementptr inbounds i8, i8* %1151, i64 1
store i8 %1154, i8* %1151
%1156 = getelementptr inbounds i8, i8* %1149, i64 1
store i8 %1153, i8* %1149
%1157 = add nsw i32 %1150, -1
%1158 = add i32 %1152, 1
%1159 = icmp eq i32 %1158, %1146
br i1 %1159, label %1160, label %1148
1160: ; preds = %1148, %1141
%1161 = phi i8* [ undef, %1141 ], [ %1156, %1148 ]
%1162 = phi i8* [ %1142, %1141 ], [ %1156, %1148 ]
%1163 = phi i32 [ %1143, %1141 ], [ %1157, %1148 ]
%1164 = phi i8* [ %1144, %1141 ], [ %1155, %1148 ]
%1165 = icmp ult i32 %1145, 3
br i1 %1165, label %1322, label %1300
1166: ; preds = %1063
br i1 %178, label %1241, label %1167
1167: ; preds = %1166
%1168 = getelementptr i8, i8* %1065, i64 %44
%1169 = getelementptr i8, i8* %1064, i64 %46
%1170 = icmp ult i8* %1065, %1169
%1171 = icmp ult i8* %1067, %1168
%1172 = and i1 %1170, %1171
br i1 %1172, label %1241, label %1173
1173: ; preds = %1167
%1174 = getelementptr i8, i8* %1067, i64 %180
%1175 = getelementptr i8, i8* %1065, i64 %184
br i1 %186, label %1219, label %1176
1176: ; preds = %1173, %1176
%1177 = phi i64 [ %1216, %1176 ], [ 0, %1173 ]
%1178 = phi i64 [ %1217, %1176 ], [ 0, %1173 ]
%1179 = shl i64 %1177, 2
%1180 = getelementptr i8, i8* %1067, i64 %1179
%1181 = shl i64 %1177, 2
%1182 = getelementptr i8, i8* %1065, i64 %1181
%1183 = bitcast i8* %1182 to <4 x i32>*
%1184 = load <4 x i32>, <4 x i32>* %1183
%1185 = getelementptr i8, i8* %1182, i64 16
%1186 = bitcast i8* %1185 to <4 x i32>*
%1187 = load <4 x i32>, <4 x i32>* %1186
%1188 = bitcast i8* %1180 to <4 x i32>*
%1189 = load <4 x i32>, <4 x i32>* %1188
%1190 = getelementptr i8, i8* %1180, i64 16
%1191 = bitcast i8* %1190 to <4 x i32>*
%1192 = load <4 x i32>, <4 x i32>* %1191
%1193 = bitcast i8* %1182 to <4 x i32>*
store <4 x i32> %1189, <4 x i32>* %1193
%1194 = bitcast i8* %1185 to <4 x i32>*
store <4 x i32> %1192, <4 x i32>* %1194
%1195 = bitcast i8* %1180 to <4 x i32>*
store <4 x i32> %1184, <4 x i32>* %1195
%1196 = bitcast i8* %1190 to <4 x i32>*
store <4 x i32> %1187, <4 x i32>* %1196
%1197 = or i64 %1177, 8
%1198 = shl i64 %1197, 2
%1199 = getelementptr i8, i8* %1067, i64 %1198
%1200 = shl i64 %1197, 2
%1201 = getelementptr i8, i8* %1065, i64 %1200
%1202 = bitcast i8* %1201 to <4 x i32>*
%1203 = load <4 x i32>, <4 x i32>* %1202
%1204 = getelementptr i8, i8* %1201, i64 16
%1205 = bitcast i8* %1204 to <4 x i32>*
%1206 = load <4 x i32>, <4 x i32>* %1205
%1207 = bitcast i8* %1199 to <4 x i32>*
%1208 = load <4 x i32>, <4 x i32>* %1207
%1209 = getelementptr i8, i8* %1199, i64 16
%1210 = bitcast i8* %1209 to <4 x i32>*
%1211 = load <4 x i32>, <4 x i32>* %1210
%1212 = bitcast i8* %1201 to <4 x i32>*
store <4 x i32> %1208, <4 x i32>* %1212
%1213 = bitcast i8* %1204 to <4 x i32>*
store <4 x i32> %1211, <4 x i32>* %1213
%1214 = bitcast i8* %1199 to <4 x i32>*
store <4 x i32> %1203, <4 x i32>* %1214
%1215 = bitcast i8* %1209 to <4 x i32>*
store <4 x i32> %1206, <4 x i32>* %1215
%1216 = add nuw i64 %1177, 16
%1217 = add i64 %1178, 2
%1218 = icmp eq i64 %1217, %187
br i1 %1218, label %1219, label %1176
1219: ; preds = %1176, %1173
%1220 = phi i64 [ 0, %1173 ], [ %1216, %1176 ]
br i1 %188, label %1240, label %1221
1221: ; preds = %1219
%1222 = shl i64 %1220, 2
%1223 = getelementptr i8, i8* %1067, i64 %1222
%1224 = shl i64 %1220, 2
%1225 = getelementptr i8, i8* %1065, i64 %1224
%1226 = bitcast i8* %1225 to <4 x i32>*
%1227 = load <4 x i32>, <4 x i32>* %1226
%1228 = getelementptr i8, i8* %1225, i64 16
%1229 = bitcast i8* %1228 to <4 x i32>*
%1230 = load <4 x i32>, <4 x i32>* %1229
%1231 = bitcast i8* %1223 to <4 x i32>*
%1232 = load <4 x i32>, <4 x i32>* %1231
%1233 = getelementptr i8, i8* %1223, i64 16
%1234 = bitcast i8* %1233 to <4 x i32>*
%1235 = load <4 x i32>, <4 x i32>* %1234
%1236 = bitcast i8* %1225 to <4 x i32>*
store <4 x i32> %1232, <4 x i32>* %1236
%1237 = bitcast i8* %1228 to <4 x i32>*
store <4 x i32> %1235, <4 x i32>* %1237
%1238 = bitcast i8* %1223 to <4 x i32>*
store <4 x i32> %1227, <4 x i32>* %1238
%1239 = bitcast i8* %1233 to <4 x i32>*
store <4 x i32> %1230, <4 x i32>* %1239
br label %1240
1240: ; preds = %1219, %1221
br i1 %189, label %1322, label %1241
1241: ; preds = %1167, %1166, %1240
%1242 = phi i8* [ %1067, %1167 ], [ %1067, %1166 ], [ %1174, %1240 ]
%1243 = phi i32 [ %12, %1167 ], [ %12, %1166 ], [ %183, %1240 ]
%1244 = phi i8* [ %1065, %1167 ], [ %1065, %1166 ], [ %1175, %1240 ]
%1245 = add i32 %1243, -4
%1246 = lshr i32 %1245, 2
%1247 = add nuw nsw i32 %1246, 1
%1248 = and i32 %1247, 3
%1249 = icmp eq i32 %1248, 0
br i1 %1249, label %1264, label %1250
1250: ; preds = %1241, %1250
%1251 = phi i8* [ %1260, %1250 ], [ %1242, %1241 ]
%1252 = phi i32 [ %1261, %1250 ], [ %1243, %1241 ]
%1253 = phi i8* [ %1259, %1250 ], [ %1244, %1241 ]
%1254 = phi i32 [ %1262, %1250 ], [ 0, %1241 ]
%1255 = bitcast i8* %1253 to i32*
%1256 = load i32, i32* %1255
%1257 = bitcast i8* %1251 to i32*
%1258 = load i32, i32* %1257
store i32 %1258, i32* %1255
store i32 %1256, i32* %1257
%1259 = getelementptr inbounds i8, i8* %1253, i64 4
%1260 = getelementptr inbounds i8, i8* %1251, i64 4
%1261 = add nsw i32 %1252, -4
%1262 = add i32 %1254, 1
%1263 = icmp eq i32 %1262, %1248
br i1 %1263, label %1264, label %1250
1264: ; preds = %1250, %1241
%1265 = phi i8* [ undef, %1241 ], [ %1260, %1250 ]
%1266 = phi i8* [ %1242, %1241 ], [ %1260, %1250 ]
%1267 = phi i32 [ %1243, %1241 ], [ %1261, %1250 ]
%1268 = phi i8* [ %1244, %1241 ], [ %1259, %1250 ]
%1269 = icmp ult i32 %1245, 12
br i1 %1269, label %1322, label %1270
1270: ; preds = %1264, %1270
%1271 = phi i8* [ %1297, %1270 ], [ %1266, %1264 ]
%1272 = phi i32 [ %1298, %1270 ], [ %1267, %1264 ]
%1273 = phi i8* [ %1296, %1270 ], [ %1268, %1264 ]
%1274 = bitcast i8* %1273 to i32*
%1275 = load i32, i32* %1274
%1276 = bitcast i8* %1271 to i32*
%1277 = load i32, i32* %1276
store i32 %1277, i32* %1274
store i32 %1275, i32* %1276
%1278 = getelementptr inbounds i8, i8* %1273, i64 4
%1279 = getelementptr inbounds i8, i8* %1271, i64 4
%1280 = bitcast i8* %1278 to i32*
%1281 = load i32, i32* %1280
%1282 = bitcast i8* %1279 to i32*
%1283 = load i32, i32* %1282
store i32 %1283, i32* %1280
store i32 %1281, i32* %1282
%1284 = getelementptr inbounds i8, i8* %1273, i64 8
%1285 = getelementptr inbounds i8, i8* %1271, i64 8
%1286 = bitcast i8* %1284 to i32*
%1287 = load i32, i32* %1286
%1288 = bitcast i8* %1285 to i32*
%1289 = load i32, i32* %1288
store i32 %1289, i32* %1286
store i32 %1287, i32* %1288
%1290 = getelementptr inbounds i8, i8* %1273, i64 12
%1291 = getelementptr inbounds i8, i8* %1271, i64 12
%1292 = bitcast i8* %1290 to i32*
%1293 = load i32, i32* %1292
%1294 = bitcast i8* %1291 to i32*
%1295 = load i32, i32* %1294
store i32 %1295, i32* %1292
store i32 %1293, i32* %1294
%1296 = getelementptr inbounds i8, i8* %1273, i64 16
%1297 = getelementptr inbounds i8, i8* %1271, i64 16
%1298 = add nsw i32 %1272, -16
%1299 = icmp eq i32 %1298, 0
br i1 %1299, label %1322, label %1270
1300: ; preds = %1160, %1300
%1301 = phi i8* [ %1319, %1300 ], [ %1162, %1160 ]
%1302 = phi i32 [ %1320, %1300 ], [ %1163, %1160 ]
%1303 = phi i8* [ %1318, %1300 ], [ %1164, %1160 ]
%1304 = load i8, i8* %1303
%1305 = load i8, i8* %1301
%1306 = getelementptr inbounds i8, i8* %1303, i64 1
store i8 %1305, i8* %1303
%1307 = getelementptr inbounds i8, i8* %1301, i64 1
store i8 %1304, i8* %1301
%1308 = load i8, i8* %1306
%1309 = load i8, i8* %1307
%1310 = getelementptr inbounds i8, i8* %1303, i64 2
store i8 %1309, i8* %1306
%1311 = getelementptr inbounds i8, i8* %1301, i64 2
store i8 %1308, i8* %1307
%1312 = load i8, i8* %1310
%1313 = load i8, i8* %1311
%1314 = getelementptr inbounds i8, i8* %1303, i64 3
store i8 %1313, i8* %1310
%1315 = getelementptr inbounds i8, i8* %1301, i64 3
store i8 %1312, i8* %1311
%1316 = load i8, i8* %1314
%1317 = load i8, i8* %1315
%1318 = getelementptr inbounds i8, i8* %1303, i64 4
store i8 %1317, i8* %1314
%1319 = getelementptr inbounds i8, i8* %1301, i64 4
store i8 %1316, i8* %1315
%1320 = add nsw i32 %1302, -4
%1321 = icmp eq i32 %1320, 0
br i1 %1321, label %1322, label %1300
1322: ; preds = %1160, %1300, %1264, %1270, %1140, %1240
%1323 = phi i8* [ %1174, %1240 ], [ %1080, %1140 ], [ %1265, %1264 ], [ %1297, %1270 ], [ %1161, %1160 ], [ %1319, %1300 ]
%1324 = getelementptr inbounds i8, i8* %1323, i64 %13
br label %1325
1325: ; preds = %1597, %1322
%1326 = phi i8* [ %1066, %1322 ], [ %1600, %1597 ]
%1327 = phi i8* [ %1324, %1322 ], [ %1601, %1597 ]
br label %1328
1328: ; preds = %1328, %1325
%1329 = phi i8* [ %1326, %1325 ], [ %1330, %1328 ]
%1330 = getelementptr inbounds i8, i8* %1329, i64 %2
%1331 = tail call i32 %3(i8* %1330, i8* %1324)
%1332 = icmp slt i32 %1331, 0
br i1 %1332, label %1328, label %1333
1333: ; preds = %1328, %1333
%1334 = phi i8* [ %1335, %1333 ], [ %1327, %1328 ]
%1335 = getelementptr inbounds i8, i8* %1334, i64 %13
%1336 = tail call i32 %3(i8* %1335, i8* %1324)
%1337 = icmp sgt i32 %1336, 0
br i1 %1337, label %1333, label %1338
1338: ; preds = %1333
%1339 = icmp ugt i8* %1335, %1330
%1340 = ptrtoint i8* %1330 to i64
%1341 = or i64 %1340, %2
%1342 = and i64 %1341, 3
%1343 = icmp eq i64 %1342, 0
br i1 %1339, label %1344, label %1602
1344: ; preds = %1338
br i1 %1343, label %1440, label %1345
1345: ; preds = %1344
br i1 %190, label %1414, label %1346
1346: ; preds = %1345
%1347 = getelementptr i8, i8* %1330, i64 %39
%1348 = getelementptr i8, i8* %1335, i64 %39
%1349 = icmp ult i8* %1330, %1348
%1350 = icmp ult i8* %1335, %1347
%1351 = and i1 %1349, %1350
br i1 %1351, label %1414, label %1352
1352: ; preds = %1346
%1353 = getelementptr i8, i8* %1330, i64 %191
%1354 = getelementptr i8, i8* %1335, i64 %191
br i1 %195, label %1394, label %1355
1355: ; preds = %1352, %1355
%1356 = phi i64 [ %1391, %1355 ], [ 0, %1352 ]
%1357 = phi i64 [ %1392, %1355 ], [ 0, %1352 ]
%1358 = getelementptr i8, i8* %1330, i64 %1356
%1359 = getelementptr i8, i8* %1335, i64 %1356
%1360 = bitcast i8* %1358 to <16 x i8>*
%1361 = load <16 x i8>, <16 x i8>* %1360
%1362 = getelementptr i8, i8* %1358, i64 16
%1363 = bitcast i8* %1362 to <16 x i8>*
%1364 = load <16 x i8>, <16 x i8>* %1363
%1365 = bitcast i8* %1359 to <16 x i8>*
%1366 = load <16 x i8>, <16 x i8>* %1365
%1367 = getelementptr i8, i8* %1359, i64 16
%1368 = bitcast i8* %1367 to <16 x i8>*
%1369 = load <16 x i8>, <16 x i8>* %1368
%1370 = bitcast i8* %1358 to <16 x i8>*
store <16 x i8> %1366, <16 x i8>* %1370
%1371 = bitcast i8* %1362 to <16 x i8>*
store <16 x i8> %1369, <16 x i8>* %1371
%1372 = bitcast i8* %1359 to <16 x i8>*
store <16 x i8> %1361, <16 x i8>* %1372
%1373 = bitcast i8* %1367 to <16 x i8>*
store <16 x i8> %1364, <16 x i8>* %1373
%1374 = or i64 %1356, 32
%1375 = getelementptr i8, i8* %1330, i64 %1374
%1376 = getelementptr i8, i8* %1335, i64 %1374
%1377 = bitcast i8* %1375 to <16 x i8>*
%1378 = load <16 x i8>, <16 x i8>* %1377
%1379 = getelementptr i8, i8* %1375, i64 16
%1380 = bitcast i8* %1379 to <16 x i8>*
%1381 = load <16 x i8>, <16 x i8>* %1380
%1382 = bitcast i8* %1376 to <16 x i8>*
%1383 = load <16 x i8>, <16 x i8>* %1382
%1384 = getelementptr i8, i8* %1376, i64 16
%1385 = bitcast i8* %1384 to <16 x i8>*
%1386 = load <16 x i8>, <16 x i8>* %1385
%1387 = bitcast i8* %1375 to <16 x i8>*
store <16 x i8> %1383, <16 x i8>* %1387
%1388 = bitcast i8* %1379 to <16 x i8>*
store <16 x i8> %1386, <16 x i8>* %1388
%1389 = bitcast i8* %1376 to <16 x i8>*
store <16 x i8> %1378, <16 x i8>* %1389
%1390 = bitcast i8* %1384 to <16 x i8>*
store <16 x i8> %1381, <16 x i8>* %1390
%1391 = add nuw i64 %1356, 64
%1392 = add i64 %1357, 2
%1393 = icmp eq i64 %1392, %196
br i1 %1393, label %1394, label %1355
1394: ; preds = %1355, %1352
%1395 = phi i64 [ 0, %1352 ], [ %1391, %1355 ]
br i1 %197, label %1413, label %1396
1396: ; preds = %1394
%1397 = getelementptr i8, i8* %1330, i64 %1395
%1398 = getelementptr i8, i8* %1335, i64 %1395
%1399 = bitcast i8* %1397 to <16 x i8>*
%1400 = load <16 x i8>, <16 x i8>* %1399
%1401 = getelementptr i8, i8* %1397, i64 16
%1402 = bitcast i8* %1401 to <16 x i8>*
%1403 = load <16 x i8>, <16 x i8>* %1402
%1404 = bitcast i8* %1398 to <16 x i8>*
%1405 = load <16 x i8>, <16 x i8>* %1404
%1406 = getelementptr i8, i8* %1398, i64 16
%1407 = bitcast i8* %1406 to <16 x i8>*
%1408 = load <16 x i8>, <16 x i8>* %1407
%1409 = bitcast i8* %1397 to <16 x i8>*
store <16 x i8> %1405, <16 x i8>* %1409
%1410 = bitcast i8* %1401 to <16 x i8>*
store <16 x i8> %1408, <16 x i8>* %1410
%1411 = bitcast i8* %1398 to <16 x i8>*
store <16 x i8> %1400, <16 x i8>* %1411
%1412 = bitcast i8* %1406 to <16 x i8>*
store <16 x i8> %1403, <16 x i8>* %1412
br label %1413
1413: ; preds = %1394, %1396
br i1 %198, label %1597, label %1414
1414: ; preds = %1346, %1345, %1413
%1415 = phi i8* [ %1330, %1346 ], [ %1330, %1345 ], [ %1353, %1413 ]
%1416 = phi i8* [ %1335, %1346 ], [ %1335, %1345 ], [ %1354, %1413 ]
%1417 = phi i32 [ %12, %1346 ], [ %12, %1345 ], [ %193, %1413 ]
%1418 = add i32 %1417, -1
%1419 = and i32 %1417, 3
%1420 = icmp eq i32 %1419, 0
br i1 %1420, label %1433, label %1421
1421: ; preds = %1414, %1421
%1422 = phi i8* [ %1428, %1421 ], [ %1415, %1414 ]
%1423 = phi i8* [ %1429, %1421 ], [ %1416, %1414 ]
%1424 = phi i32 [ %1430, %1421 ], [ %1417, %1414 ]
%1425 = phi i32 [ %1431, %1421 ], [ 0, %1414 ]
%1426 = load i8, i8* %1422
%1427 = load i8, i8* %1423
%1428 = getelementptr inbounds i8, i8* %1422, i64 1
store i8 %1427, i8* %1422
%1429 = getelementptr inbounds i8, i8* %1423, i64 1
store i8 %1426, i8* %1423
%1430 = add nsw i32 %1424, -1
%1431 = add i32 %1425, 1
%1432 = icmp eq i32 %1431, %1419
br i1 %1432, label %1433, label %1421
1433: ; preds = %1421, %1414
%1434 = phi i8* [ undef, %1414 ], [ %1428, %1421 ]
%1435 = phi i8* [ undef, %1414 ], [ %1429, %1421 ]
%1436 = phi i8* [ %1415, %1414 ], [ %1428, %1421 ]
%1437 = phi i8* [ %1416, %1414 ], [ %1429, %1421 ]
%1438 = phi i32 [ %1417, %1414 ], [ %1430, %1421 ]
%1439 = icmp ult i32 %1418, 3
br i1 %1439, label %1597, label %1575
1440: ; preds = %1344
br i1 %199, label %1515, label %1441
1441: ; preds = %1440
%1442 = getelementptr i8, i8* %1330, i64 %33
%1443 = getelementptr i8, i8* %1335, i64 %33
%1444 = icmp ult i8* %1330, %1443
%1445 = icmp ult i8* %1335, %1442
%1446 = and i1 %1444, %1445
br i1 %1446, label %1515, label %1447
1447: ; preds = %1441
%1448 = getelementptr i8, i8* %1330, i64 %201
%1449 = getelementptr i8, i8* %1335, i64 %202
br i1 %207, label %1493, label %1450
1450: ; preds = %1447, %1450
%1451 = phi i64 [ %1490, %1450 ], [ 0, %1447 ]
%1452 = phi i64 [ %1491, %1450 ], [ 0, %1447 ]
%1453 = shl i64 %1451, 2
%1454 = getelementptr i8, i8* %1330, i64 %1453
%1455 = shl i64 %1451, 2
%1456 = getelementptr i8, i8* %1335, i64 %1455
%1457 = bitcast i8* %1454 to <4 x i32>*
%1458 = load <4 x i32>, <4 x i32>* %1457
%1459 = getelementptr i8, i8* %1454, i64 16
%1460 = bitcast i8* %1459 to <4 x i32>*
%1461 = load <4 x i32>, <4 x i32>* %1460
%1462 = bitcast i8* %1456 to <4 x i32>*
%1463 = load <4 x i32>, <4 x i32>* %1462
%1464 = getelementptr i8, i8* %1456, i64 16
%1465 = bitcast i8* %1464 to <4 x i32>*
%1466 = load <4 x i32>, <4 x i32>* %1465
%1467 = bitcast i8* %1454 to <4 x i32>*
store <4 x i32> %1463, <4 x i32>* %1467
%1468 = bitcast i8* %1459 to <4 x i32>*
store <4 x i32> %1466, <4 x i32>* %1468
%1469 = bitcast i8* %1456 to <4 x i32>*
store <4 x i32> %1458, <4 x i32>* %1469
%1470 = bitcast i8* %1464 to <4 x i32>*
store <4 x i32> %1461, <4 x i32>* %1470
%1471 = or i64 %1451, 8
%1472 = shl i64 %1471, 2
%1473 = getelementptr i8, i8* %1330, i64 %1472
%1474 = shl i64 %1471, 2
%1475 = getelementptr i8, i8* %1335, i64 %1474
%1476 = bitcast i8* %1473 to <4 x i32>*
%1477 = load <4 x i32>, <4 x i32>* %1476
%1478 = getelementptr i8, i8* %1473, i64 16
%1479 = bitcast i8* %1478 to <4 x i32>*
%1480 = load <4 x i32>, <4 x i32>* %1479
%1481 = bitcast i8* %1475 to <4 x i32>*
%1482 = load <4 x i32>, <4 x i32>* %1481
%1483 = getelementptr i8, i8* %1475, i64 16
%1484 = bitcast i8* %1483 to <4 x i32>*
%1485 = load <4 x i32>, <4 x i32>* %1484
%1486 = bitcast i8* %1473 to <4 x i32>*
store <4 x i32> %1482, <4 x i32>* %1486
%1487 = bitcast i8* %1478 to <4 x i32>*
store <4 x i32> %1485, <4 x i32>* %1487
%1488 = bitcast i8* %1475 to <4 x i32>*
store <4 x i32> %1477, <4 x i32>* %1488
%1489 = bitcast i8* %1483 to <4 x i32>*
store <4 x i32> %1480, <4 x i32>* %1489
%1490 = add nuw i64 %1451, 16
%1491 = add i64 %1452, 2
%1492 = icmp eq i64 %1491, %208
br i1 %1492, label %1493, label %1450
1493: ; preds = %1450, %1447
%1494 = phi i64 [ 0, %1447 ], [ %1490, %1450 ]
br i1 %209, label %1514, label %1495
1495: ; preds = %1493
%1496 = shl i64 %1494, 2
%1497 = getelementptr i8, i8* %1330, i64 %1496
%1498 = shl i64 %1494, 2
%1499 = getelementptr i8, i8* %1335, i64 %1498
%1500 = bitcast i8* %1497 to <4 x i32>*
%1501 = load <4 x i32>, <4 x i32>* %1500
%1502 = getelementptr i8, i8* %1497, i64 16
%1503 = bitcast i8* %1502 to <4 x i32>*
%1504 = load <4 x i32>, <4 x i32>* %1503
%1505 = bitcast i8* %1499 to <4 x i32>*
%1506 = load <4 x i32>, <4 x i32>* %1505
%1507 = getelementptr i8, i8* %1499, i64 16
%1508 = bitcast i8* %1507 to <4 x i32>*
%1509 = load <4 x i32>, <4 x i32>* %1508
%1510 = bitcast i8* %1497 to <4 x i32>*
store <4 x i32> %1506, <4 x i32>* %1510
%1511 = bitcast i8* %1502 to <4 x i32>*
store <4 x i32> %1509, <4 x i32>* %1511
%1512 = bitcast i8* %1499 to <4 x i32>*
store <4 x i32> %1501, <4 x i32>* %1512
%1513 = bitcast i8* %1507 to <4 x i32>*
store <4 x i32> %1504, <4 x i32>* %1513
br label %1514
1514: ; preds = %1493, %1495
br i1 %210, label %1597, label %1515
1515: ; preds = %1441, %1440, %1514
%1516 = phi i8* [ %1330, %1441 ], [ %1330, %1440 ], [ %1448, %1514 ]
%1517 = phi i8* [ %1335, %1441 ], [ %1335, %1440 ], [ %1449, %1514 ]
%1518 = phi i32 [ %12, %1441 ], [ %12, %1440 ], [ %205, %1514 ]
%1519 = add i32 %1518, -4
%1520 = lshr i32 %1519, 2
%1521 = add nuw nsw i32 %1520, 1
%1522 = and i32 %1521, 3
%1523 = icmp eq i32 %1522, 0
br i1 %1523, label %1538, label %1524
1524: ; preds = %1515, %1524
%1525 = phi i8* [ %1533, %1524 ], [ %1516, %1515 ]
%1526 = phi i8* [ %1534, %1524 ], [ %1517, %1515 ]
%1527 = phi i32 [ %1535, %1524 ], [ %1518, %1515 ]
%1528 = phi i32 [ %1536, %1524 ], [ 0, %1515 ]
%1529 = bitcast i8* %1525 to i32*
%1530 = load i32, i32* %1529
%1531 = bitcast i8* %1526 to i32*
%1532 = load i32, i32* %1531
store i32 %1532, i32* %1529
store i32 %1530, i32* %1531
%1533 = getelementptr inbounds i8, i8* %1525, i64 4
%1534 = getelementptr inbounds i8, i8* %1526, i64 4
%1535 = add nsw i32 %1527, -4
%1536 = add i32 %1528, 1
%1537 = icmp eq i32 %1536, %1522
br i1 %1537, label %1538, label %1524
1538: ; preds = %1524, %1515
%1539 = phi i8* [ undef, %1515 ], [ %1533, %1524 ]
%1540 = phi i8* [ undef, %1515 ], [ %1534, %1524 ]
%1541 = phi i8* [ %1516, %1515 ], [ %1533, %1524 ]
%1542 = phi i8* [ %1517, %1515 ], [ %1534, %1524 ]
%1543 = phi i32 [ %1518, %1515 ], [ %1535, %1524 ]
%1544 = icmp ult i32 %1519, 12
br i1 %1544, label %1597, label %1545
1545: ; preds = %1538, %1545
%1546 = phi i8* [ %1571, %1545 ], [ %1541, %1538 ]
%1547 = phi i8* [ %1572, %1545 ], [ %1542, %1538 ]
%1548 = phi i32 [ %1573, %1545 ], [ %1543, %1538 ]
%1549 = bitcast i8* %1546 to i32*
%1550 = load i32, i32* %1549
%1551 = bitcast i8* %1547 to i32*
%1552 = load i32, i32* %1551
store i32 %1552, i32* %1549
store i32 %1550, i32* %1551
%1553 = getelementptr inbounds i8, i8* %1546, i64 4
%1554 = getelementptr inbounds i8, i8* %1547, i64 4
%1555 = bitcast i8* %1553 to i32*
%1556 = load i32, i32* %1555
%1557 = bitcast i8* %1554 to i32*
%1558 = load i32, i32* %1557
store i32 %1558, i32* %1555
store i32 %1556, i32* %1557
%1559 = getelementptr inbounds i8, i8* %1546, i64 8
%1560 = getelementptr inbounds i8, i8* %1547, i64 8
%1561 = bitcast i8* %1559 to i32*
%1562 = load i32, i32* %1561
%1563 = bitcast i8* %1560 to i32*
%1564 = load i32, i32* %1563
store i32 %1564, i32* %1561
store i32 %1562, i32* %1563
%1565 = getelementptr inbounds i8, i8* %1546, i64 12
%1566 = getelementptr inbounds i8, i8* %1547, i64 12
%1567 = bitcast i8* %1565 to i32*
%1568 = load i32, i32* %1567
%1569 = bitcast i8* %1566 to i32*
%1570 = load i32, i32* %1569
store i32 %1570, i32* %1567
store i32 %1568, i32* %1569
%1571 = getelementptr inbounds i8, i8* %1546, i64 16
%1572 = getelementptr inbounds i8, i8* %1547, i64 16
%1573 = add nsw i32 %1548, -16
%1574 = icmp eq i32 %1573, 0
br i1 %1574, label %1597, label %1545
1575: ; preds = %1433, %1575
%1576 = phi i8* [ %1593, %1575 ], [ %1436, %1433 ]
%1577 = phi i8* [ %1594, %1575 ], [ %1437, %1433 ]
%1578 = phi i32 [ %1595, %1575 ], [ %1438, %1433 ]
%1579 = load i8, i8* %1576
%1580 = load i8, i8* %1577
%1581 = getelementptr inbounds i8, i8* %1576, i64 1
store i8 %1580, i8* %1576
%1582 = getelementptr inbounds i8, i8* %1577, i64 1
store i8 %1579, i8* %1577
%1583 = load i8, i8* %1581
%1584 = load i8, i8* %1582
%1585 = getelementptr inbounds i8, i8* %1576, i64 2
store i8 %1584, i8* %1581
%1586 = getelementptr inbounds i8, i8* %1577, i64 2
store i8 %1583, i8* %1582
%1587 = load i8, i8* %1585
%1588 = load i8, i8* %1586
%1589 = getelementptr inbounds i8, i8* %1576, i64 3
store i8 %1588, i8* %1585
%1590 = getelementptr inbounds i8, i8* %1577, i64 3
store i8 %1587, i8* %1586
%1591 = load i8, i8* %1589
%1592 = load i8, i8* %1590
%1593 = getelementptr inbounds i8, i8* %1576, i64 4
store i8 %1592, i8* %1589
%1594 = getelementptr inbounds i8, i8* %1577, i64 4
store i8 %1591, i8* %1590
%1595 = add nsw i32 %1578, -4
%1596 = icmp eq i32 %1595, 0
br i1 %1596, label %1597, label %1575
1597: ; preds = %1433, %1575, %1538, %1545, %1413, %1514
%1598 = phi i8* [ %1448, %1514 ], [ %1353, %1413 ], [ %1539, %1538 ], [ %1571, %1545 ], [ %1434, %1433 ], [ %1593, %1575 ]
%1599 = phi i8* [ %1449, %1514 ], [ %1354, %1413 ], [ %1540, %1538 ], [ %1572, %1545 ], [ %1435, %1433 ], [ %1594, %1575 ]
%1600 = getelementptr inbounds i8, i8* %1598, i64 %13
%1601 = getelementptr inbounds i8, i8* %1599, i64 %13
br label %1325
1602: ; preds = %1338
br i1 %1343, label %1697, label %1603
1603: ; preds = %1602
br i1 %211, label %1672, label %1604
1604: ; preds = %1603
%1605 = getelementptr i8, i8* %1330, i64 %25
%1606 = getelementptr i8, i8* %1323, i64 %27
%1607 = icmp ult i8* %1330, %1606
%1608 = icmp ult i8* %1324, %1605
%1609 = and i1 %1607, %1608
br i1 %1609, label %1672, label %1610
1610: ; preds = %1604
%1611 = getelementptr i8, i8* %1330, i64 %212
%1612 = getelementptr i8, i8* %1324, i64 %212
br i1 %216, label %1652, label %1613
1613: ; preds = %1610, %1613
%1614 = phi i64 [ %1649, %1613 ], [ 0, %1610 ]
%1615 = phi i64 [ %1650, %1613 ], [ 0, %1610 ]
%1616 = getelementptr i8, i8* %1330, i64 %1614
%1617 = getelementptr i8, i8* %1324, i64 %1614
%1618 = bitcast i8* %1616 to <16 x i8>*
%1619 = load <16 x i8>, <16 x i8>* %1618
%1620 = getelementptr i8, i8* %1616, i64 16
%1621 = bitcast i8* %1620 to <16 x i8>*
%1622 = load <16 x i8>, <16 x i8>* %1621
%1623 = bitcast i8* %1617 to <16 x i8>*
%1624 = load <16 x i8>, <16 x i8>* %1623
%1625 = getelementptr i8, i8* %1617, i64 16
%1626 = bitcast i8* %1625 to <16 x i8>*
%1627 = load <16 x i8>, <16 x i8>* %1626
%1628 = bitcast i8* %1616 to <16 x i8>*
store <16 x i8> %1624, <16 x i8>* %1628
%1629 = bitcast i8* %1620 to <16 x i8>*
store <16 x i8> %1627, <16 x i8>* %1629
%1630 = bitcast i8* %1617 to <16 x i8>*
store <16 x i8> %1619, <16 x i8>* %1630
%1631 = bitcast i8* %1625 to <16 x i8>*
store <16 x i8> %1622, <16 x i8>* %1631
%1632 = or i64 %1614, 32
%1633 = getelementptr i8, i8* %1330, i64 %1632
%1634 = getelementptr i8, i8* %1324, i64 %1632
%1635 = bitcast i8* %1633 to <16 x i8>*
%1636 = load <16 x i8>, <16 x i8>* %1635
%1637 = getelementptr i8, i8* %1633, i64 16
%1638 = bitcast i8* %1637 to <16 x i8>*
%1639 = load <16 x i8>, <16 x i8>* %1638
%1640 = bitcast i8* %1634 to <16 x i8>*
%1641 = load <16 x i8>, <16 x i8>* %1640
%1642 = getelementptr i8, i8* %1634, i64 16
%1643 = bitcast i8* %1642 to <16 x i8>*
%1644 = load <16 x i8>, <16 x i8>* %1643
%1645 = bitcast i8* %1633 to <16 x i8>*
store <16 x i8> %1641, <16 x i8>* %1645
%1646 = bitcast i8* %1637 to <16 x i8>*
store <16 x i8> %1644, <16 x i8>* %1646
%1647 = bitcast i8* %1634 to <16 x i8>*
store <16 x i8> %1636, <16 x i8>* %1647
%1648 = bitcast i8* %1642 to <16 x i8>*
store <16 x i8> %1639, <16 x i8>* %1648
%1649 = add nuw i64 %1614, 64
%1650 = add i64 %1615, 2
%1651 = icmp eq i64 %1650, %217
br i1 %1651, label %1652, label %1613
1652: ; preds = %1613, %1610
%1653 = phi i64 [ 0, %1610 ], [ %1649, %1613 ]
br i1 %218, label %1671, label %1654
1654: ; preds = %1652
%1655 = getelementptr i8, i8* %1330, i64 %1653
%1656 = getelementptr i8, i8* %1324, i64 %1653
%1657 = bitcast i8* %1655 to <16 x i8>*
%1658 = load <16 x i8>, <16 x i8>* %1657
%1659 = getelementptr i8, i8* %1655, i64 16
%1660 = bitcast i8* %1659 to <16 x i8>*
%1661 = load <16 x i8>, <16 x i8>* %1660
%1662 = bitcast i8* %1656 to <16 x i8>*
%1663 = load <16 x i8>, <16 x i8>* %1662
%1664 = getelementptr i8, i8* %1656, i64 16
%1665 = bitcast i8* %1664 to <16 x i8>*
%1666 = load <16 x i8>, <16 x i8>* %1665
%1667 = bitcast i8* %1655 to <16 x i8>*
store <16 x i8> %1663, <16 x i8>* %1667
%1668 = bitcast i8* %1659 to <16 x i8>*
store <16 x i8> %1666, <16 x i8>* %1668
%1669 = bitcast i8* %1656 to <16 x i8>*
store <16 x i8> %1658, <16 x i8>* %1669
%1670 = bitcast i8* %1664 to <16 x i8>*
store <16 x i8> %1661, <16 x i8>* %1670
br label %1671
1671: ; preds = %1652, %1654
br i1 %219, label %1853, label %1672
1672: ; preds = %1604, %1603, %1671
%1673 = phi i8* [ %1330, %1604 ], [ %1330, %1603 ], [ %1611, %1671 ]
%1674 = phi i8* [ %1324, %1604 ], [ %1324, %1603 ], [ %1612, %1671 ]
%1675 = phi i32 [ %12, %1604 ], [ %12, %1603 ], [ %214, %1671 ]
%1676 = add i32 %1675, -1
%1677 = and i32 %1675, 3
%1678 = icmp eq i32 %1677, 0
br i1 %1678, label %1691, label %1679
1679: ; preds = %1672, %1679
%1680 = phi i8* [ %1686, %1679 ], [ %1673, %1672 ]
%1681 = phi i8* [ %1687, %1679 ], [ %1674, %1672 ]
%1682 = phi i32 [ %1688, %1679 ], [ %1675, %1672 ]
%1683 = phi i32 [ %1689, %1679 ], [ 0, %1672 ]
%1684 = load i8, i8* %1680
%1685 = load i8, i8* %1681
%1686 = getelementptr inbounds i8, i8* %1680, i64 1
store i8 %1685, i8* %1680
%1687 = getelementptr inbounds i8, i8* %1681, i64 1
store i8 %1684, i8* %1681
%1688 = add nsw i32 %1682, -1
%1689 = add i32 %1683, 1
%1690 = icmp eq i32 %1689, %1677
br i1 %1690, label %1691, label %1679
1691: ; preds = %1679, %1672
%1692 = phi i8* [ undef, %1672 ], [ %1686, %1679 ]
%1693 = phi i8* [ %1673, %1672 ], [ %1686, %1679 ]
%1694 = phi i8* [ %1674, %1672 ], [ %1687, %1679 ]
%1695 = phi i32 [ %1675, %1672 ], [ %1688, %1679 ]
%1696 = icmp ult i32 %1676, 3
br i1 %1696, label %1853, label %1831
1697: ; preds = %1602
br i1 %220, label %1772, label %1698
1698: ; preds = %1697
%1699 = getelementptr i8, i8* %1330, i64 %16
%1700 = getelementptr i8, i8* %1323, i64 %18
%1701 = icmp ult i8* %1330, %1700
%1702 = icmp ult i8* %1324, %1699
%1703 = and i1 %1701, %1702
br i1 %1703, label %1772, label %1704
1704: ; preds = %1698
%1705 = getelementptr i8, i8* %1330, i64 %222
%1706 = getelementptr i8, i8* %1324, i64 %223
br i1 %228, label %1750, label %1707
1707: ; preds = %1704, %1707
%1708 = phi i64 [ %1747, %1707 ], [ 0, %1704 ]
%1709 = phi i64 [ %1748, %1707 ], [ 0, %1704 ]
%1710 = shl i64 %1708, 2
%1711 = getelementptr i8, i8* %1330, i64 %1710
%1712 = shl i64 %1708, 2
%1713 = getelementptr i8, i8* %1324, i64 %1712
%1714 = bitcast i8* %1711 to <4 x i32>*
%1715 = load <4 x i32>, <4 x i32>* %1714
%1716 = getelementptr i8, i8* %1711, i64 16
%1717 = bitcast i8* %1716 to <4 x i32>*
%1718 = load <4 x i32>, <4 x i32>* %1717
%1719 = bitcast i8* %1713 to <4 x i32>*
%1720 = load <4 x i32>, <4 x i32>* %1719
%1721 = getelementptr i8, i8* %1713, i64 16
%1722 = bitcast i8* %1721 to <4 x i32>*
%1723 = load <4 x i32>, <4 x i32>* %1722
%1724 = bitcast i8* %1711 to <4 x i32>*
store <4 x i32> %1720, <4 x i32>* %1724
%1725 = bitcast i8* %1716 to <4 x i32>*
store <4 x i32> %1723, <4 x i32>* %1725
%1726 = bitcast i8* %1713 to <4 x i32>*
store <4 x i32> %1715, <4 x i32>* %1726
%1727 = bitcast i8* %1721 to <4 x i32>*
store <4 x i32> %1718, <4 x i32>* %1727
%1728 = or i64 %1708, 8
%1729 = shl i64 %1728, 2
%1730 = getelementptr i8, i8* %1330, i64 %1729
%1731 = shl i64 %1728, 2
%1732 = getelementptr i8, i8* %1324, i64 %1731
%1733 = bitcast i8* %1730 to <4 x i32>*
%1734 = load <4 x i32>, <4 x i32>* %1733
%1735 = getelementptr i8, i8* %1730, i64 16
%1736 = bitcast i8* %1735 to <4 x i32>*
%1737 = load <4 x i32>, <4 x i32>* %1736
%1738 = bitcast i8* %1732 to <4 x i32>*
%1739 = load <4 x i32>, <4 x i32>* %1738
%1740 = getelementptr i8, i8* %1732, i64 16
%1741 = bitcast i8* %1740 to <4 x i32>*
%1742 = load <4 x i32>, <4 x i32>* %1741
%1743 = bitcast i8* %1730 to <4 x i32>*
store <4 x i32> %1739, <4 x i32>* %1743
%1744 = bitcast i8* %1735 to <4 x i32>*
store <4 x i32> %1742, <4 x i32>* %1744
%1745 = bitcast i8* %1732 to <4 x i32>*
store <4 x i32> %1734, <4 x i32>* %1745
%1746 = bitcast i8* %1740 to <4 x i32>*
store <4 x i32> %1737, <4 x i32>* %1746
%1747 = add nuw i64 %1708, 16
%1748 = add i64 %1709, 2
%1749 = icmp eq i64 %1748, %229
br i1 %1749, label %1750, label %1707
1750: ; preds = %1707, %1704
%1751 = phi i64 [ 0, %1704 ], [ %1747, %1707 ]
br i1 %230, label %1771, label %1752
1752: ; preds = %1750
%1753 = shl i64 %1751, 2
%1754 = getelementptr i8, i8* %1330, i64 %1753
%1755 = shl i64 %1751, 2
%1756 = getelementptr i8, i8* %1324, i64 %1755
%1757 = bitcast i8* %1754 to <4 x i32>*
%1758 = load <4 x i32>, <4 x i32>* %1757
%1759 = getelementptr i8, i8* %1754, i64 16
%1760 = bitcast i8* %1759 to <4 x i32>*
%1761 = load <4 x i32>, <4 x i32>* %1760
%1762 = bitcast i8* %1756 to <4 x i32>*
%1763 = load <4 x i32>, <4 x i32>* %1762
%1764 = getelementptr i8, i8* %1756, i64 16
%1765 = bitcast i8* %1764 to <4 x i32>*
%1766 = load <4 x i32>, <4 x i32>* %1765
%1767 = bitcast i8* %1754 to <4 x i32>*
store <4 x i32> %1763, <4 x i32>* %1767
%1768 = bitcast i8* %1759 to <4 x i32>*
store <4 x i32> %1766, <4 x i32>* %1768
%1769 = bitcast i8* %1756 to <4 x i32>*
store <4 x i32> %1758, <4 x i32>* %1769
%1770 = bitcast i8* %1764 to <4 x i32>*
store <4 x i32> %1761, <4 x i32>* %1770
br label %1771
1771: ; preds = %1750, %1752
br i1 %231, label %1853, label %1772
1772: ; preds = %1698, %1697, %1771
%1773 = phi i8* [ %1330, %1698 ], [ %1330, %1697 ], [ %1705, %1771 ]
%1774 = phi i8* [ %1324, %1698 ], [ %1324, %1697 ], [ %1706, %1771 ]
%1775 = phi i32 [ %12, %1698 ], [ %12, %1697 ], [ %226, %1771 ]
%1776 = add i32 %1775, -4
%1777 = lshr i32 %1776, 2
%1778 = add nuw nsw i32 %1777, 1
%1779 = and i32 %1778, 3
%1780 = icmp eq i32 %1779, 0
br i1 %1780, label %1795, label %1781
1781: ; preds = %1772, %1781
%1782 = phi i8* [ %1790, %1781 ], [ %1773, %1772 ]
%1783 = phi i8* [ %1791, %1781 ], [ %1774, %1772 ]
%1784 = phi i32 [ %1792, %1781 ], [ %1775, %1772 ]
%1785 = phi i32 [ %1793, %1781 ], [ 0, %1772 ]
%1786 = bitcast i8* %1782 to i32*
%1787 = load i32, i32* %1786
%1788 = bitcast i8* %1783 to i32*
%1789 = load i32, i32* %1788
store i32 %1789, i32* %1786
store i32 %1787, i32* %1788
%1790 = getelementptr inbounds i8, i8* %1782, i64 4
%1791 = getelementptr inbounds i8, i8* %1783, i64 4
%1792 = add nsw i32 %1784, -4
%1793 = add i32 %1785, 1
%1794 = icmp eq i32 %1793, %1779
br i1 %1794, label %1795, label %1781
1795: ; preds = %1781, %1772
%1796 = phi i8* [ undef, %1772 ], [ %1790, %1781 ]
%1797 = phi i8* [ %1773, %1772 ], [ %1790, %1781 ]
%1798 = phi i8* [ %1774, %1772 ], [ %1791, %1781 ]
%1799 = phi i32 [ %1775, %1772 ], [ %1792, %1781 ]
%1800 = icmp ult i32 %1776, 12
br i1 %1800, label %1853, label %1801
1801: ; preds = %1795, %1801
%1802 = phi i8* [ %1827, %1801 ], [ %1797, %1795 ]
%1803 = phi i8* [ %1828, %1801 ], [ %1798, %1795 ]
%1804 = phi i32 [ %1829, %1801 ], [ %1799, %1795 ]
%1805 = bitcast i8* %1802 to i32*
%1806 = load i32, i32* %1805
%1807 = bitcast i8* %1803 to i32*
%1808 = load i32, i32* %1807
store i32 %1808, i32* %1805
store i32 %1806, i32* %1807
%1809 = getelementptr inbounds i8, i8* %1802, i64 4
%1810 = getelementptr inbounds i8, i8* %1803, i64 4
%1811 = bitcast i8* %1809 to i32*
%1812 = load i32, i32* %1811
%1813 = bitcast i8* %1810 to i32*
%1814 = load i32, i32* %1813
store i32 %1814, i32* %1811
store i32 %1812, i32* %1813
%1815 = getelementptr inbounds i8, i8* %1802, i64 8
%1816 = getelementptr inbounds i8, i8* %1803, i64 8
%1817 = bitcast i8* %1815 to i32*
%1818 = load i32, i32* %1817
%1819 = bitcast i8* %1816 to i32*
%1820 = load i32, i32* %1819
store i32 %1820, i32* %1817
store i32 %1818, i32* %1819
%1821 = getelementptr inbounds i8, i8* %1802, i64 12
%1822 = getelementptr inbounds i8, i8* %1803, i64 12
%1823 = bitcast i8* %1821 to i32*
%1824 = load i32, i32* %1823
%1825 = bitcast i8* %1822 to i32*
%1826 = load i32, i32* %1825
store i32 %1826, i32* %1823
store i32 %1824, i32* %1825
%1827 = getelementptr inbounds i8, i8* %1802, i64 16
%1828 = getelementptr inbounds i8, i8* %1803, i64 16
%1829 = add nsw i32 %1804, -16
%1830 = icmp eq i32 %1829, 0
br i1 %1830, label %1853, label %1801
1831: ; preds = %1691, %1831
%1832 = phi i8* [ %1849, %1831 ], [ %1693, %1691 ]
%1833 = phi i8* [ %1850, %1831 ], [ %1694, %1691 ]
%1834 = phi i32 [ %1851, %1831 ], [ %1695, %1691 ]
%1835 = load i8, i8* %1832
%1836 = load i8, i8* %1833
%1837 = getelementptr inbounds i8, i8* %1832, i64 1
store i8 %1836, i8* %1832
%1838 = getelementptr inbounds i8, i8* %1833, i64 1
store i8 %1835, i8* %1833
%1839 = load i8, i8* %1837
%1840 = load i8, i8* %1838
%1841 = getelementptr inbounds i8, i8* %1832, i64 2
store i8 %1840, i8* %1837
%1842 = getelementptr inbounds i8, i8* %1833, i64 2
store i8 %1839, i8* %1838
%1843 = load i8, i8* %1841
%1844 = load i8, i8* %1842
%1845 = getelementptr inbounds i8, i8* %1832, i64 3
store i8 %1844, i8* %1841
%1846 = getelementptr inbounds i8, i8* %1833, i64 3
store i8 %1843, i8* %1842
%1847 = load i8, i8* %1845
%1848 = load i8, i8* %1846
%1849 = getelementptr inbounds i8, i8* %1832, i64 4
store i8 %1848, i8* %1845
%1850 = getelementptr inbounds i8, i8* %1833, i64 4
store i8 %1847, i8* %1846
%1851 = add nsw i32 %1834, -4
%1852 = icmp eq i32 %1851, 0
br i1 %1852, label %1853, label %1831
1853: ; preds = %1691, %1831, %1795, %1801, %1671, %1771
%1854 = phi i8* [ %1705, %1771 ], [ %1611, %1671 ], [ %1796, %1795 ], [ %1827, %1801 ], [ %1692, %1691 ], [ %1849, %1831 ]
%1855 = getelementptr inbounds i8, i8* %1854, i64 %13
%1856 = ptrtoint i8* %1855 to i64
%1857 = ptrtoint i8* %1066 to i64
%1858 = sub i64 %1856, %1857
%1859 = udiv i64 %1858, %2
%1860 = trunc i64 %1859 to i32
%1861 = add i32 %1860, -1
%1862 = sub i32 %247, %1860
%1863 = icmp sgt i32 %1861, %1862
br i1 %1863, label %1864, label %1871
1864: ; preds = %1853
%1865 = icmp sgt i32 %1862, 10
br i1 %1865, label %1875, label %1866
1866: ; preds = %1864
%1867 = icmp sgt i32 %1861, 10
br i1 %1867, label %1868, label %232
1868: ; preds = %1866, %1873
%1869 = phi i32 [ %1861, %1866 ], [ %1862, %1873 ]
%1870 = phi i8* [ %1066, %1866 ], [ %1855, %1873 ]
br label %246
1871: ; preds = %1853
%1872 = icmp sgt i32 %1861, 10
br i1 %1872, label %1875, label %1873
1873: ; preds = %1871
%1874 = icmp sgt i32 %1862, 10
br i1 %1874, label %1868, label %232
1875: ; preds = %1871, %1864
%1876 = phi i8* [ %1066, %1864 ], [ %1855, %1871 ]
%1877 = phi i32 [ %1861, %1864 ], [ %1862, %1871 ]
%1878 = phi i32 [ %1862, %1864 ], [ %1861, %1871 ]
%1879 = phi i8* [ %1855, %1864 ], [ %1066, %1871 ]
%1880 = sext i32 %245 to i64
%1881 = getelementptr inbounds [32 x i8*], [32 x i8*]* %5, i64 0, i64 %1880
store i8* %1876, i8** %1881
%1882 = add nsw i32 %245, 1
%1883 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %1880
store i32 %1877, i32* %1883
br label %242
1884: ; preds = %232
ret void
}