void qsort(void *base, int n, int size, int (*compar)(void *, void *)) {
  register char c, *i, *j, *lo, *hi;
  char *min, *max;
  int thresh = size * 4;
  int mthresh = size * 6;
  if (n <= 1)
    return;
  max = (char *)base + n * size;
  if (n >= 4) {
    qst(base, max, compar, size, thresh, mthresh);
    hi = (char *)base + thresh;
  } else {
    hi = max;
  }
  for (j = lo = base; (lo += size) < hi;)
    if (compar(j, lo) > 0)
      j = lo;
  if (j != base) {
    for (i = (char *)base, hi = (char *)base + size; i < hi;) {
      c = *j;
      *j++ = *i;
      *i++ = c;
    }
  }
  for (min = base; (hi = min += size) < max;) {
    while (compar(hi -= size, min) > 0)
      ;
    if ((hi += size) != min) {
      for (lo = min + size; --lo >= min;) {
        c = *lo;
        for (i = j = lo; (j -= size) >= hi; i = j)
          *i = *j;
        *i = c;
      }
    }
  }
}


x86 assembly (clang, -O0):
<qsort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x10(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x54(%rbp)
imul   $0x6,-0x10(%rbp),%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x1,-0xc(%rbp)
jg     1145 <qsort+0x35>
jmp    135a <qsort+0x24a>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x10(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
cmpl   $0x4,-0xc(%rbp)
jl     1196 <qsort+0x86>
mov    -0x8(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x10(%rbp),%ecx
mov    -0x54(%rbp),%r8d
mov    -0x58(%rbp),%r9d
mov    $0x0,%al
call   1030 <qst@plt>
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    119e <qsort+0x8e>
mov    -0x50(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
cmp    -0x40(%rbp),%rax
jae    11e9 <qsort+0xd9>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jle    11e4 <qsort+0xd4>
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    11aa <qsort+0x9a>
mov    -0x30(%rbp),%rax
cmp    -0x8(%rbp),%rax
je     125a <qsort+0x14a>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    1255 <qsort+0x145>
mov    -0x30(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x19(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x19(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    120e <qsort+0xfe>
jmp    125a <qsort+0x14a>
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    %rax,-0x40(%rbp)
cmp    -0x50(%rbp),%rax
jae    135a <qsort+0x24a>
jmp    1286 <qsort+0x176>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    -0x40(%rbp),%rdi
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rdi
mov    %rdi,-0x40(%rbp)
mov    -0x48(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jle    12b4 <qsort+0x1a4>
jmp    1286 <qsort+0x176>
mov    -0x10(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
cmp    -0x48(%rbp),%rax
je     1355 <qsort+0x245>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
cmp    -0x48(%rbp),%rax
jb     1350 <qsort+0x240>
mov    -0x38(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x19(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
cmp    -0x40(%rbp),%rax
jb     1342 <qsort+0x232>
mov    -0x30(%rbp),%rax
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    1309 <qsort+0x1f9>
mov    -0x19(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
jmp    12de <qsort+0x1ce>
jmp    1355 <qsort+0x245>
jmp    1262 <qsort+0x152>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qsort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
cmp    $0x2,%esi
jl     12f2 <qsort+0x1e2>
mov    %rcx,%r13
mov    %edx,%r12d
mov    %edx,%eax
imul   %esi,%eax
mov    %eax,0x8(%rsp)
movslq %eax,%r14
add    %rdi,%r14
mov    %r14,0x18(%rsp)
cmp    $0x4,%esi
jb     1177 <qsort+0x67>
lea    0x0(,%r12,4),%ebx
lea    (%r12,%r12,1),%eax
lea    (%rax,%rax,2),%r9d
mov    0x18(%rsp),%rsi
mov    %r13,%rdx
mov    %r12d,%ecx
mov    %ebx,%r8d
xor    %eax,%eax
mov    %rdi,%rbp
call   1030 <qst@plt>
mov    %rbp,%rdi
movslq %ebx,%r14
add    %rbp,%r14
movslq %r12d,%r15
lea    (%rdi,%r15,1),%r11
cmp    %r14,%r11
jae    1239 <qsort+0x129>
mov    %r11,0x20(%rsp)
mov    %r11,%rbx
mov    %rdi,0x10(%rsp)
mov    %rdi,%rbp
jmp    11ab <qsort+0x9b>
nopl   0x0(%rax)
add    %r15,%rbx
mov    %rcx,%rbp
cmp    %r14,%rbx
jae    11c0 <qsort+0xb0>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   *%r13
mov    %rbx,%rcx
test   %eax,%eax
jg     11a0 <qsort+0x90>
mov    %rbp,%rcx
jmp    11a0 <qsort+0x90>
mov    0x10(%rsp),%rdi
cmp    %rdi,%rcx
mov    0x20(%rsp),%r11
je     1239 <qsort+0x129>
test   %r12d,%r12d
jle    1239 <qsort+0x129>
lea    (%rdi,%r15,1),%r10
lea    0x1(%rdi),%r9
cmp    %r9,%r10
mov    %r9,%rdx
cmova  %r10,%rdx
sub    %rdi,%rdx
cmp    $0x8,%rdx
jb     1211 <qsort+0x101>
cmp    %r9,%r10
mov    %r9,%rax
cmova  %r10,%rax
cmp    %rax,%rcx
jae    1301 <qsort+0x1f1>
sub    %rdi,%rax
add    %rcx,%rax
cmp    %rdi,%rax
jbe    1301 <qsort+0x1f1>
mov    %rdi,%rdx
mov    %rcx,%rbp
nopw   0x0(%rax,%rax,1)
movzbl 0x0(%rbp),%eax
movzbl (%rdx),%ecx
mov    %cl,0x0(%rbp)
add    $0x1,%rbp
mov    %al,(%rdx)
add    $0x1,%rdx
cmp    %r11,%rdx
jb     1220 <qsort+0x110>
cmp    %r12d,0x8(%rsp)
jle    12f2 <qsort+0x1e2>
mov    %r15,%rbp
neg    %rbp
lea    (%rdi,%r15,2),%r9
jmp    1261 <qsort+0x151>
add    %r15,%r9
add    %r15,%rdi
cmp    0x18(%rsp),%r11
jae    12f2 <qsort+0x1e2>
mov    %r9,0x8(%rsp)
mov    %r11,%r12
mov    %rdi,0x10(%rsp)
mov    %rdi,%rbx
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %r12,%rsi
call   *%r13
add    %r15,%r14
add    %rbp,%rbx
test   %eax,%eax
jg     1280 <qsort+0x170>
lea    (%r12,%r15,1),%r11
cmp    %r14,%r15
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%r9
je     1250 <qsort+0x140>
lea    (%r12,%r15,1),%rdx
add    $0xffffffffffffffff,%rdx
cmp    %r12,%rdx
jb     1250 <qsort+0x140>
mov    %r9,%rcx
sub    %r14,%rcx
jmp    12cc <qsort+0x1bc>
nopl   0x0(%rax,%rax,1)
mov    %r8b,(%rax)
add    $0xffffffffffffffff,%rdx
cmp    %r12,%rdx
jb     1250 <qsort+0x140>
mov    (%rdx),%r8b
lea    (%rdx,%rbp,1),%rsi
mov    %rdx,%rax
cmp    %rcx,%rsi
jb     12c0 <qsort+0x1b0>
mov    %rdx,%rax
xchg   %ax,%ax
movzbl (%rsi),%ebx
mov    %bl,(%rax)
add    %rbp,%rsi
add    %rbp,%rax
cmp    %rcx,%rsi
jae    12e0 <qsort+0x1d0>
jmp    12c0 <qsort+0x1b0>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%rdx
jae    130e <qsort+0x1fe>
xor    %esi,%esi
jmp    13d2 <qsort+0x2c2>
mov    %rdx,%rsi
and    $0xffffffffffffffe0,%rsi
lea    -0x20(%rsi),%rax
mov    %rax,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rax,%rax
je     1398 <qsort+0x288>
mov    %r8,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rcx,%rbp,1),%xmm0
movups 0x10(%rcx,%rbp,1),%xmm1
movups (%rdi,%rbp,1),%xmm2
movups 0x10(%rdi,%rbp,1),%xmm3
movups %xmm2,(%rcx,%rbp,1)
movups %xmm3,0x10(%rcx,%rbp,1)
movups %xmm0,(%rdi,%rbp,1)
movups %xmm1,0x10(%rdi,%rbp,1)
movups 0x20(%rcx,%rbp,1),%xmm0
movups 0x30(%rcx,%rbp,1),%xmm1
movups 0x20(%rdi,%rbp,1),%xmm2
movups 0x30(%rdi,%rbp,1),%xmm3
movups %xmm2,0x20(%rcx,%rbp,1)
movups %xmm3,0x30(%rcx,%rbp,1)
movups %xmm0,0x20(%rdi,%rbp,1)
movups %xmm1,0x30(%rdi,%rbp,1)
add    $0x40,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1340 <qsort+0x230>
jmp    139a <qsort+0x28a>
xor    %ebp,%ebp
test   $0x1,%r8b
je     13c4 <qsort+0x2b4>
movups (%rcx,%rbp,1),%xmm0
movups 0x10(%rcx,%rbp,1),%xmm1
movups (%rdi,%rbp,1),%xmm2
movups 0x10(%rdi,%rbp,1),%xmm3
movups %xmm2,(%rcx,%rbp,1)
movups %xmm3,0x10(%rcx,%rbp,1)
movups %xmm0,(%rdi,%rbp,1)
movups %xmm1,0x10(%rdi,%rbp,1)
cmp    %rsi,%rdx
je     1239 <qsort+0x129>
test   $0x18,%dl
je     1417 <qsort+0x307>
cmp    %r9,%r10
cmova  %r10,%r9
sub    %rdi,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    (%rdi,%r8,1),%rdx
lea    (%rcx,%r8,1),%rbp
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rsi,1),%rax
mov    (%rdi,%rsi,1),%rbx
mov    %rbx,(%rcx,%rsi,1)
mov    %rax,(%rdi,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r8
jne    13f0 <qsort+0x2e0>
cmp    %r8,%r9
jne    1220 <qsort+0x110>
jmp    1239 <qsort+0x129>
add    %rsi,%rcx
add    %rdi,%rsi
mov    %rsi,%rdx
jmp    1214 <qsort+0x104>

LLVM IR (-O0):
define void @qsort(i8* %0, i32 %1, i32 %2, i32 (i8*, i8*)* %3) {
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32 (i8*, i8*)*
%9 = alloca i8
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i8*
%16 = alloca i32
%17 = alloca i32
store i8* %0, i8** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 (i8*, i8*)* %3, i32 (i8*, i8*)** %8
%18 = load i32, i32* %7
%19 = mul nsw i32 %18, 4
store i32 %19, i32* %16
%20 = load i32, i32* %7
%21 = mul nsw i32 %20, 6
store i32 %21, i32* %17
%22 = load i32, i32* %6
%23 = icmp sle i32 %22, 1
br i1 %23, label %24, label %25
24: ; preds = %4
br label %152
25: ; preds = %4
%26 = load i8*, i8** %5
%27 = load i32, i32* %6
%28 = load i32, i32* %7
%29 = mul nsw i32 %27, %28
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i8, i8* %26, i64 %30
store i8* %31, i8** %15
%32 = load i32, i32* %6
%33 = icmp sge i32 %32, 4
br i1 %33, label %34, label %46
34: ; preds = %25
%35 = load i8*, i8** %5
%36 = load i8*, i8** %15
%37 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %8
%38 = load i32, i32* %7
%39 = load i32, i32* %16
%40 = load i32, i32* %17
%41 = call i32 (i8*, i8*, i32 (i8*, i8*)*, i32, i32, i32, ...) bitcast (i32 (...)* @qst to i32 (i8*, i8*, i32 (i8*, i8*)*, i32, i32, i32, ...)*)(i8* %35, i8* %36, i32 (i8*, i8*)* %37, i32 %38, i32 %39, i32 %40)
%42 = load i8*, i8** %5
%43 = load i32, i32* %16
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8, i8* %42, i64 %44
store i8* %45, i8** %13
br label %48
46: ; preds = %25
%47 = load i8*, i8** %15
store i8* %47, i8** %13
br label %48
48: ; preds = %46, %34
%49 = load i8*, i8** %5
store i8* %49, i8** %12
store i8* %49, i8** %11
br label %50
50: ; preds = %65, %48
%51 = load i32, i32* %7
%52 = load i8*, i8** %12
%53 = sext i32 %51 to i64
%54 = getelementptr inbounds i8, i8* %52, i64 %53
store i8* %54, i8** %12
%55 = load i8*, i8** %13
%56 = icmp ult i8* %54, %55
br i1 %56, label %57, label %66
57: ; preds = %50
%58 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %8
%59 = load i8*, i8** %11
%60 = load i8*, i8** %12
%61 = call i32 %58(i8* %59, i8* %60)
%62 = icmp sgt i32 %61, 0
br i1 %62, label %63, label %65
63: ; preds = %57
%64 = load i8*, i8** %12
store i8* %64, i8** %11
br label %65
65: ; preds = %63, %57
br label %50
66: ; preds = %50
%67 = load i8*, i8** %11
%68 = load i8*, i8** %5
%69 = icmp ne i8* %67, %68
br i1 %69, label %70, label %91
70: ; preds = %66
%71 = load i8*, i8** %5
store i8* %71, i8** %10
%72 = load i8*, i8** %5
%73 = load i32, i32* %7
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8, i8* %72, i64 %74
store i8* %75, i8** %13
br label %76
76: ; preds = %80, %70
%77 = load i8*, i8** %10
%78 = load i8*, i8** %13
%79 = icmp ult i8* %77, %78
br i1 %79, label %80, label %90
80: ; preds = %76
%81 = load i8*, i8** %11
%82 = load i8, i8* %81
store i8 %82, i8* %9
%83 = load i8*, i8** %10
%84 = load i8, i8* %83
%85 = load i8*, i8** %11
%86 = getelementptr inbounds i8, i8* %85, i32 1
store i8* %86, i8** %11
store i8 %84, i8* %85
%87 = load i8, i8* %9
%88 = load i8*, i8** %10
%89 = getelementptr inbounds i8, i8* %88, i32 1
store i8* %89, i8** %10
store i8 %87, i8* %88
br label %76
90: ; preds = %76
br label %91
91: ; preds = %90, %66
%92 = load i8*, i8** %5
store i8* %92, i8** %14
br label %93
93: ; preds = %151, %91
%94 = load i32, i32* %7
%95 = load i8*, i8** %14
%96 = sext i32 %94 to i64
%97 = getelementptr inbounds i8, i8* %95, i64 %96
store i8* %97, i8** %14
store i8* %97, i8** %13
%98 = load i8*, i8** %15
%99 = icmp ult i8* %97, %98
br i1 %99, label %100, label %152
100: ; preds = %93
br label %101
101: ; preds = %111, %100
%102 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %8
%103 = load i32, i32* %7
%104 = load i8*, i8** %13
%105 = sext i32 %103 to i64
%106 = sub i64 0, %105
%107 = getelementptr inbounds i8, i8* %104, i64 %106
store i8* %107, i8** %13
%108 = load i8*, i8** %14
%109 = call i32 %102(i8* %107, i8* %108)
%110 = icmp sgt i32 %109, 0
br i1 %110, label %111, label %112
111: ; preds = %101
br label %101
112: ; preds = %101
%113 = load i32, i32* %7
%114 = load i8*, i8** %13
%115 = sext i32 %113 to i64
%116 = getelementptr inbounds i8, i8* %114, i64 %115
store i8* %116, i8** %13
%117 = load i8*, i8** %14
%118 = icmp ne i8* %116, %117
br i1 %118, label %119, label %151
119: ; preds = %112
%120 = load i8*, i8** %14
%121 = load i32, i32* %7
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i8, i8* %120, i64 %122
store i8* %123, i8** %12
br label %124
124: ; preds = %147, %119
%125 = load i8*, i8** %12
%126 = getelementptr inbounds i8, i8* %125, i32 -1
store i8* %126, i8** %12
%127 = load i8*, i8** %14
%128 = icmp uge i8* %126, %127
br i1 %128, label %129, label %150
129: ; preds = %124
%130 = load i8*, i8** %12
%131 = load i8, i8* %130
store i8 %131, i8* %9
%132 = load i8*, i8** %12
store i8* %132, i8** %11
store i8* %132, i8** %10
br label %133
133: ; preds = %145, %129
%134 = load i32, i32* %7
%135 = load i8*, i8** %11
%136 = sext i32 %134 to i64
%137 = sub i64 0, %136
%138 = getelementptr inbounds i8, i8* %135, i64 %137
store i8* %138, i8** %11
%139 = load i8*, i8** %13
%140 = icmp uge i8* %138, %139
br i1 %140, label %141, label %147
141: ; preds = %133
%142 = load i8*, i8** %11
%143 = load i8, i8* %142
%144 = load i8*, i8** %10
store i8 %143, i8* %144
br label %145
145: ; preds = %141
%146 = load i8*, i8** %11
store i8* %146, i8** %10
br label %133
147: ; preds = %133
%148 = load i8, i8* %9
%149 = load i8*, i8** %10
store i8 %148, i8* %149
br label %124
150: ; preds = %124
br label %151
151: ; preds = %150, %112
br label %93
152: ; preds = %24, %93
ret void
}

LLVM IR (-O2):
define void @qsort(i8* %0, i32 %1, i32 %2, i32 (i8*, i8*)* %3) {
%5 = ptrtoint i8* %0 to i64
%6 = shl nsw i32 %2, 2
%7 = mul nsw i32 %2, 6
%8 = icmp slt i32 %1, 2
br i1 %8, label %196, label %9
9: ; preds = %4
%10 = mul nsw i32 %2, %1
%11 = sext i32 %10 to i64
%12 = getelementptr inbounds i8, i8* %0, i64 %11
%13 = icmp ugt i32 %1, 3
br i1 %13, label %14, label %18
14: ; preds = %9
%15 = tail call i32 (i8*, i8*, i32 (i8*, i8*)*, i32, i32, i32, ...) bitcast (i32 (...)* @qst to i32 (i8*, i8*, i32 (i8*, i8*)*, i32, i32, i32, ...)*)(i8* %0, i8* %12, i32 (i8*, i8*)* %3, i32 %2, i32 %6, i32 %7)
%16 = sext i32 %6 to i64
%17 = getelementptr inbounds i8, i8* %0, i64 %16
br label %18
18: ; preds = %9, %14
%19 = phi i8* [ %17, %14 ], [ %12, %9 ]
%20 = sext i32 %2 to i64
%21 = getelementptr inbounds i8, i8* %0, i64 %20
%22 = icmp ult i8* %21, %19
br i1 %22, label %23, label %162
23: ; preds = %18, %23
%24 = phi i8* [ %29, %23 ], [ %21, %18 ]
%25 = phi i8* [ %28, %23 ], [ %0, %18 ]
%26 = tail call i32 %3(i8* %25, i8* %24)
%27 = icmp sgt i32 %26, 0
%28 = select i1 %27, i8* %24, i8* %25
%29 = getelementptr inbounds i8, i8* %24, i64 %20
%30 = icmp ult i8* %29, %19
br i1 %30, label %23, label %31
31: ; preds = %23
%32 = icmp ne i8* %28, %0
%33 = icmp sgt i32 %2, 0
%34 = and i1 %32, %33
br i1 %34, label %35, label %162
35: ; preds = %31
%36 = add i64 %5, %20
%37 = add i64 %5, 1
%38 = call i64 @llvm.umax.i64(i64 %36, i64 %37)
%39 = sub i64 %38, %5
%40 = icmp ult i64 %39, 8
br i1 %40, label %151, label %41
41: ; preds = %35
%42 = add i64 %5, %20
%43 = add i64 %5, 1
%44 = call i64 @llvm.umax.i64(i64 %42, i64 %43)
%45 = sub i64 %44, %5
%46 = getelementptr i8, i8* %28, i64 %45
%47 = getelementptr i8, i8* %0, i64 %45
%48 = icmp ult i8* %28, %47
%49 = icmp ugt i8* %46, %0
%50 = and i1 %48, %49
br i1 %50, label %151, label %51
51: ; preds = %41
%52 = icmp ult i64 %39, 32
br i1 %52, label %128, label %53
53: ; preds = %51
%54 = and i64 %39, -32
%55 = add i64 %54, -32
%56 = lshr exact i64 %55, 5
%57 = add nuw nsw i64 %56, 1
%58 = and i64 %57, 1
%59 = icmp eq i64 %55, 0
br i1 %59, label %101, label %60
60: ; preds = %53
%61 = and i64 %57, 1152921504606846974
br label %62
62: ; preds = %62, %60
%63 = phi i64 [ 0, %60 ], [ %98, %62 ]
%64 = phi i64 [ 0, %60 ], [ %99, %62 ]
%65 = getelementptr i8, i8* %0, i64 %63
%66 = getelementptr i8, i8* %28, i64 %63
%67 = bitcast i8* %66 to <16 x i8>*
%68 = load <16 x i8>, <16 x i8>* %67
%69 = getelementptr i8, i8* %66, i64 16
%70 = bitcast i8* %69 to <16 x i8>*
%71 = load <16 x i8>, <16 x i8>* %70
%72 = bitcast i8* %65 to <16 x i8>*
%73 = load <16 x i8>, <16 x i8>* %72
%74 = getelementptr i8, i8* %65, i64 16
%75 = bitcast i8* %74 to <16 x i8>*
%76 = load <16 x i8>, <16 x i8>* %75
%77 = bitcast i8* %66 to <16 x i8>*
store <16 x i8> %73, <16 x i8>* %77
%78 = bitcast i8* %69 to <16 x i8>*
store <16 x i8> %76, <16 x i8>* %78
%79 = bitcast i8* %65 to <16 x i8>*
store <16 x i8> %68, <16 x i8>* %79
%80 = bitcast i8* %74 to <16 x i8>*
store <16 x i8> %71, <16 x i8>* %80
%81 = or i64 %63, 32
%82 = getelementptr i8, i8* %0, i64 %81
%83 = getelementptr i8, i8* %28, i64 %81
%84 = bitcast i8* %83 to <16 x i8>*
%85 = load <16 x i8>, <16 x i8>* %84
%86 = getelementptr i8, i8* %83, i64 16
%87 = bitcast i8* %86 to <16 x i8>*
%88 = load <16 x i8>, <16 x i8>* %87
%89 = bitcast i8* %82 to <16 x i8>*
%90 = load <16 x i8>, <16 x i8>* %89
%91 = getelementptr i8, i8* %82, i64 16
%92 = bitcast i8* %91 to <16 x i8>*
%93 = load <16 x i8>, <16 x i8>* %92
%94 = bitcast i8* %83 to <16 x i8>*
store <16 x i8> %90, <16 x i8>* %94
%95 = bitcast i8* %86 to <16 x i8>*
store <16 x i8> %93, <16 x i8>* %95
%96 = bitcast i8* %82 to <16 x i8>*
store <16 x i8> %85, <16 x i8>* %96
%97 = bitcast i8* %91 to <16 x i8>*
store <16 x i8> %88, <16 x i8>* %97
%98 = add nuw i64 %63, 64
%99 = add i64 %64, 2
%100 = icmp eq i64 %99, %61
br i1 %100, label %101, label %62
101: ; preds = %62, %53
%102 = phi i64 [ 0, %53 ], [ %98, %62 ]
%103 = icmp eq i64 %58, 0
br i1 %103, label %121, label %104
104: ; preds = %101
%105 = getelementptr i8, i8* %0, i64 %102
%106 = getelementptr i8, i8* %28, i64 %102
%107 = bitcast i8* %106 to <16 x i8>*
%108 = load <16 x i8>, <16 x i8>* %107
%109 = getelementptr i8, i8* %106, i64 16
%110 = bitcast i8* %109 to <16 x i8>*
%111 = load <16 x i8>, <16 x i8>* %110
%112 = bitcast i8* %105 to <16 x i8>*
%113 = load <16 x i8>, <16 x i8>* %112
%114 = getelementptr i8, i8* %105, i64 16
%115 = bitcast i8* %114 to <16 x i8>*
%116 = load <16 x i8>, <16 x i8>* %115
%117 = bitcast i8* %106 to <16 x i8>*
store <16 x i8> %113, <16 x i8>* %117
%118 = bitcast i8* %109 to <16 x i8>*
store <16 x i8> %116, <16 x i8>* %118
%119 = bitcast i8* %105 to <16 x i8>*
store <16 x i8> %108, <16 x i8>* %119
%120 = bitcast i8* %114 to <16 x i8>*
store <16 x i8> %111, <16 x i8>* %120
br label %121
121: ; preds = %101, %104
%122 = icmp eq i64 %39, %54
br i1 %122, label %162, label %123
123: ; preds = %121
%124 = getelementptr i8, i8* %28, i64 %54
%125 = getelementptr i8, i8* %0, i64 %54
%126 = and i64 %39, 24
%127 = icmp eq i64 %126, 0
br i1 %127, label %151, label %128
128: ; preds = %51, %123
%129 = phi i64 [ %54, %123 ], [ 0, %51 ]
%130 = add i64 %5, %20
%131 = add i64 %5, 1
%132 = call i64 @llvm.umax.i64(i64 %130, i64 %131)
%133 = sub i64 %132, %5
%134 = and i64 %133, -8
%135 = getelementptr i8, i8* %0, i64 %134
%136 = getelementptr i8, i8* %28, i64 %134
br label %137
137: ; preds = %137, %128
%138 = phi i64 [ %129, %128 ], [ %147, %137 ]
%139 = getelementptr i8, i8* %0, i64 %138
%140 = getelementptr i8, i8* %28, i64 %138
%141 = bitcast i8* %140 to <8 x i8>*
%142 = load <8 x i8>, <8 x i8>* %141
%143 = bitcast i8* %139 to <8 x i8>*
%144 = load <8 x i8>, <8 x i8>* %143
%145 = bitcast i8* %140 to <8 x i8>*
store <8 x i8> %144, <8 x i8>* %145
%146 = bitcast i8* %139 to <8 x i8>*
store <8 x i8> %142, <8 x i8>* %146
%147 = add nuw i64 %138, 8
%148 = icmp eq i64 %147, %134
br i1 %148, label %149, label %137
149: ; preds = %137
%150 = icmp eq i64 %133, %134
br i1 %150, label %162, label %151
151: ; preds = %41, %35, %123, %149
%152 = phi i8* [ %0, %35 ], [ %0, %41 ], [ %125, %123 ], [ %135, %149 ]
%153 = phi i8* [ %28, %35 ], [ %28, %41 ], [ %124, %123 ], [ %136, %149 ]
br label %154
154: ; preds = %151, %154
%155 = phi i8* [ %160, %154 ], [ %152, %151 ]
%156 = phi i8* [ %159, %154 ], [ %153, %151 ]
%157 = load i8, i8* %156
%158 = load i8, i8* %155
%159 = getelementptr inbounds i8, i8* %156, i64 1
store i8 %158, i8* %156
%160 = getelementptr inbounds i8, i8* %155, i64 1
store i8 %157, i8* %155
%161 = icmp ult i8* %160, %21
br i1 %161, label %154, label %162
162: ; preds = %154, %121, %149, %18, %31
%163 = icmp sgt i32 %10, %2
br i1 %163, label %164, label %196
164: ; preds = %162
%165 = sub nsw i64 0, %20
br label %166
166: ; preds = %164, %194
%167 = phi i8* [ %21, %164 ], [ %175, %194 ]
br label %168
168: ; preds = %166, %168
%169 = phi i8* [ %170, %168 ], [ %167, %166 ]
%170 = getelementptr inbounds i8, i8* %169, i64 %165
%171 = tail call i32 %3(i8* %170, i8* %167)
%172 = icmp sgt i32 %171, 0
br i1 %172, label %168, label %173
173: ; preds = %168
%174 = icmp eq i8* %169, %167
%175 = getelementptr inbounds i8, i8* %167, i64 %20
%176 = getelementptr inbounds i8, i8* %175, i64 -1
%177 = icmp ult i8* %176, %167
%178 = select i1 %174, i1 true, i1 %177
br i1 %178, label %194, label %179
179: ; preds = %173, %190
%180 = phi i8* [ %192, %190 ], [ %176, %173 ]
%181 = load i8, i8* %180
%182 = getelementptr inbounds i8, i8* %180, i64 %165
%183 = icmp ult i8* %182, %169
br i1 %183, label %190, label %184
184: ; preds = %179, %184
%185 = phi i8* [ %188, %184 ], [ %182, %179 ]
%186 = phi i8* [ %185, %184 ], [ %180, %179 ]
%187 = load i8, i8* %185
store i8 %187, i8* %186
%188 = getelementptr inbounds i8, i8* %185, i64 %165
%189 = icmp ult i8* %188, %169
br i1 %189, label %190, label %184
190: ; preds = %184, %179
%191 = phi i8* [ %180, %179 ], [ %185, %184 ]
store i8 %181, i8* %191
%192 = getelementptr inbounds i8, i8* %180, i64 -1
%193 = icmp ult i8* %192, %167
br i1 %193, label %194, label %179
194: ; preds = %190, %173
%195 = icmp ult i8* %175, %12
br i1 %195, label %166, label %196
196: ; preds = %194, %162, %4
ret void
}