void b_medfilt2(unsigned char *in, unsigned char *out, int *Nwin, int *Ns,
                int flag) {
  int nx, ny, hN[2];
  int pre_x, pre_y, pos_x, pos_y;
  int subx, suby, k, totN;
  unsigned char *myvals, *fptr1, *fptr2, *ptr1, *ptr2, minval = 0, maxval = 0;
  totN = Nwin[0] * Nwin[1];
  myvals = (unsigned char *)check_malloc(totN * sizeof(unsigned char));
  hN[0] = Nwin[0] >> 1;
  hN[1] = Nwin[1] >> 1;
  ptr1 = in;
  fptr1 = out;
  for (ny = 0; ny < Ns[0]; ny++)
    for (nx = 0; nx < Ns[1]; nx++) {
      pre_x = hN[1];
      pre_y = hN[0];
      pos_x = hN[1];
      pos_y = hN[0];
      if (nx < hN[1])
        pre_x = nx;
      if (nx >= Ns[1] - hN[1])
        pos_x = Ns[1] - nx - 1;
      if (ny < hN[0])
        pre_y = ny;
      if (ny >= Ns[0] - hN[0])
        pos_y = Ns[0] - ny - 1;
      fptr2 = myvals;
      ptr2 = ptr1 - pre_x - pre_y * Ns[1];
      if (flag) {
        minval = maxval = *ptr1;
        for (suby = -pre_y; suby <= pos_y; suby++) {
          for (subx = -pre_x; subx <= pos_x; subx++) {
            minval = (*ptr2 < minval) ? *ptr2 : minval;
            maxval = (*ptr2 > maxval) ? *ptr2 : maxval;
            *fptr2++ = *ptr2++;
          }
          ptr2 += Ns[1] - (pre_x + pos_x + 1);
        }
      } else {
        for (suby = -pre_y; suby <= pos_y; suby++) {
          for (subx = -pre_x; subx <= pos_x; subx++)
            *fptr2++ = *ptr2++;
          ptr2 += Ns[1] - (pre_x + pos_x + 1);
        }
      }
      if ((flag == 0) || (*ptr1 == minval) || (*ptr1 == maxval)) {
        ptr1++;
        k = (pre_x + pos_x + 1) * (pre_y + pos_y + 1);
        if (k > totN) {
          k = totN;
        }
        *fptr1++ = b_quick_select(myvals, k);
      } else {
        *fptr1++ = *ptr1++;
      }
    }
  free(myvals);
}


x86 assembly (clang, -O0):
<b_medfilt2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movb   $0x0,-0x81(%rbp)
movb   $0x0,-0x82(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    -0x18(%rbp),%rcx
imul   0x4(%rcx),%eax
mov    %eax,-0x54(%rbp)
movslq -0x54(%rbp),%rdi
shl    $0x0,%rdi
mov    $0x0,%al
call   1050 <check_malloc@plt>
cltq
mov    %rax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
sar    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%eax
sar    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    151d <b_medfilt2+0x3ed>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    150a <b_medfilt2+0x3da>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1203 <b_medfilt2+0xd3>
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    -0x30(%rbp),%ecx
cmp    %ecx,%eax
jl     1228 <b_medfilt2+0xf8>
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%eax
sub    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    123a <b_medfilt2+0x10a>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jl     125d <b_medfilt2+0x12d>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
sub    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x3c(%rbp),%ecx
mov    -0x20(%rbp),%rdx
imul   0x4(%rdx),%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     13b8 <b_medfilt2+0x288>
mov    -0x78(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x82(%rbp)
mov    %al,-0x81(%rbp)
xor    %eax,%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     13b3 <b_medfilt2+0x283>
xor    %eax,%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1385 <b_medfilt2+0x255>
mov    -0x80(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x81(%rbp),%ecx
cmp    %ecx,%eax
jge    12fb <b_medfilt2+0x1cb>
mov    -0x80(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x88(%rbp)
jmp    1308 <b_medfilt2+0x1d8>
movzbl -0x81(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %al,-0x81(%rbp)
mov    -0x80(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x82(%rbp),%ecx
cmp    %ecx,%eax
jle    133c <b_medfilt2+0x20c>
mov    -0x80(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x8c(%rbp)
jmp    1349 <b_medfilt2+0x219>
movzbl -0x82(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %al,-0x82(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x80(%rbp)
mov    (%rax),%cl
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12c7 <b_medfilt2+0x197>
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x38(%rbp),%eax
add    -0x40(%rbp),%eax
add    $0x1,%eax
sub    %eax,%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12b3 <b_medfilt2+0x183>
jmp    1443 <b_medfilt2+0x313>
xor    %eax,%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     143e <b_medfilt2+0x30e>
xor    %eax,%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1410 <b_medfilt2+0x2e0>
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x80(%rbp)
mov    (%rax),%cl
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13d4 <b_medfilt2+0x2a4>
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x38(%rbp),%eax
add    -0x40(%rbp),%eax
add    $0x1,%eax
sub    %eax,%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13c0 <b_medfilt2+0x290>
jmp    1443 <b_medfilt2+0x313>
cmpl   $0x0,-0x24(%rbp)
je     1479 <b_medfilt2+0x349>
mov    -0x78(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x81(%rbp),%ecx
cmp    %ecx,%eax
je     1479 <b_medfilt2+0x349>
mov    -0x78(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x82(%rbp),%ecx
cmp    %ecx,%eax
jne    14d5 <b_medfilt2+0x3a5>
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x38(%rbp),%eax
add    -0x40(%rbp),%eax
add    $0x1,%eax
mov    -0x3c(%rbp),%ecx
add    -0x44(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x54(%rbp),%eax
jle    14af <b_medfilt2+0x37f>
mov    -0x54(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x60(%rbp),%rdi
mov    -0x50(%rbp),%esi
mov    $0x0,%al
call   1040 <b_quick_select@plt>
mov    %al,%cl
mov    -0x68(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x68(%rbp)
mov    %cl,(%rax)
jmp    14f7 <b_medfilt2+0x3c7>
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x78(%rbp)
mov    (%rax),%cl
mov    -0x68(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x68(%rbp)
mov    %cl,(%rax)
jmp    14fc <b_medfilt2+0x3cc>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11c9 <b_medfilt2+0x99>
jmp    150f <b_medfilt2+0x3df>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11b3 <b_medfilt2+0x83>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<b_medfilt2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r8d,%r12d
mov    %rcx,%rbp
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%r15
movslq (%rdx),%rax
movslq 0x4(%rdx),%rdi
imul   %rax,%rdi
mov    %rdi,0x80(%rsp)
xor    %eax,%eax
call   1050 <check_malloc@plt>
cltq
mov    %rax,0x10(%rsp)
mov    %rbp,0x28(%rsp)
mov    0x0(%rbp),%esi
test   %esi,%esi
jle    18cd <b_medfilt2+0x79d>
mov    %r12d,%edi
mov    %r15,%rdx
mov    %r14,%r9
mov    (%rbx),%eax
mov    0x4(%rbx),%ecx
sar    %eax
mov    %eax,0x8(%rsp)
sar    %ecx
mov    %ecx,0x58(%rsp)
mov    0x28(%rsp),%rax
mov    0x4(%rax),%r15d
xor    %r12d,%r12d
xor    %r13d,%r13d
movl   $0x0,(%rsp)
mov    %edi,0x4c(%rsp)
jmp    11d1 <b_medfilt2+0xa1>
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%eax
add    $0x1,%eax
mov    %eax,(%rsp)
cmp    %esi,%eax
jge    18cd <b_medfilt2+0x79d>
test   %r15d,%r15d
jle    11c0 <b_medfilt2+0x90>
mov    0x8(%rsp),%eax
mov    (%rsp),%ecx
cmp    %eax,%ecx
cmovl  %ecx,%eax
not    %ecx
mov    %ecx,0x5c(%rsp)
mov    %eax,%r8d
neg    %r8d
mov    %rax,0x90(%rsp)
add    $0x1,%eax
mov    %eax,0x50(%rsp)
xor    %ebp,%ebp
mov    %r8d,0xc(%rsp)
jmp    1270 <b_medfilt2+0x140>
cs nopw 0x0(%rax,%rax,1)
lea    (%r14,%rbx,1),%eax
add    $0x1,%eax
add    0x50(%rsp),%esi
imul   %eax,%esi
mov    0x80(%rsp),%rax
cmp    %eax,%esi
cmovg  %eax,%esi
mov    %edi,%r14d
mov    0x10(%rsp),%rdi
xor    %eax,%eax
mov    %rdx,%rbx
mov    %r9,%r15
call   1040 <b_quick_select@plt>
mov    %r15,%r9
mov    %r14d,%edi
mov    0xc(%rsp),%r8d
mov    %rbx,%rdx
add    $0x1,%rdx
mov    %al,(%r9)
add    $0x1,%r9
add    $0x1,%ebp
mov    0x28(%rsp),%rax
mov    (%rax),%esi
mov    0x4(%rax),%r15d
cmp    %r15d,%ebp
jge    11c0 <b_medfilt2+0x90>
mov    0x58(%rsp),%ecx
cmp    %ebp,%ecx
mov    %ebp,%r10d
cmovl  %ecx,%r10d
mov    %ecx,%ebx
cmovg  %ebp,%ebx
mov    %r15d,%eax
sub    %ecx,%eax
mov    %ebp,%r14d
not    %r14d
add    %r15d,%r14d
cmp    %eax,%ebp
cmovl  %ecx,%r14d
mov    %esi,%eax
mov    0x8(%rsp),%ecx
sub    %ecx,%eax
add    0x5c(%rsp),%esi
cmp    %eax,(%rsp)
cmovl  %ecx,%esi
movslq %ebx,%rcx
mov    %rdx,%rax
sub    %rcx,%rax
mov    %r15d,%ecx
imul   0x90(%rsp),%ecx
movslq %ecx,%rcx
sub    %rcx,%rax
test   %edi,%edi
je     12e0 <b_medfilt2+0x1b0>
mov    (%rdx),%r12b
cmp    %r8d,%esi
jge    1590 <b_medfilt2+0x460>
mov    %r12d,%r13d
jmp    18b4 <b_medfilt2+0x784>
nopw   0x0(%rax,%rax,1)
cmp    %r8d,%esi
jl     1210 <b_medfilt2+0xe0>
mov    %ebp,0x4(%rsp)
mov    %rdx,0x68(%rsp)
mov    %r9,0x70(%rsp)
mov    %ebx,%r9d
neg    %r9d
lea    (%r14,%rbx,1),%edx
mov    %edx,%ebp
not    %ebp
lea    0x1(%rdx),%rcx
mov    %rcx,0x40(%rsp)
mov    %rcx,%rdi
movabs $0x1ffffffe0,%rcx
and    %rcx,%rdi
lea    -0x20(%rdi),%rcx
mov    %rcx,0x30(%rsp)
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %rcx,0x88(%rsp)
lea    0x1(%r14),%ecx
mov    %ecx,0x20(%rsp)
mov    %rdi,0x38(%rsp)
mov    %edi,%ecx
mov    %rbx,0x60(%rsp)
sub    %ebx,%ecx
mov    %ecx,0x54(%rsp)
add    %r14d,%r10d
lea    0x1(%r10),%rcx
and    $0xffffffffffffffe0,%rcx
add    $0xffffffffffffffe0,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x78(%rsp)
add    $0x1,%r10b
and    $0x60,%r10b
add    $0xe0,%r10b
shr    $0x5,%r10b
add    $0x1,%r10b
mov    %r8d,%ecx
movzbl %r10b,%r8d
and    $0x3,%r8d
shl    $0x5,%r8
mov    0x10(%rsp),%r11
mov    %ecx,%r10d
mov    %rdx,0x18(%rsp)
jmp    13d3 <b_medfilt2+0x2a3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x28(%rsp),%rcx
mov    0x4(%rcx),%r15d
lea    (%r15,%rbp,1),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
lea    0x1(%r10),%ecx
cmp    %esi,%r10d
mov    %ecx,%r10d
je     1890 <b_medfilt2+0x760>
cmp    %r9d,%r14d
jl     13b9 <b_medfilt2+0x289>
cmp    $0x1f,%edx
jb     13ff <b_medfilt2+0x2cf>
lea    (%rax,%rdx,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%r11
jae    14a0 <b_medfilt2+0x370>
lea    (%r11,%rdx,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jae    14a0 <b_medfilt2+0x370>
mov    %r9d,%edi
mov    %rbp,%r15
mov    0x20(%rsp),%ecx
mov    %ecx,%ebp
sub    %edi,%ebp
mov    %r14d,%ebx
sub    %edi,%ebx
and    $0x7,%ebp
je     143d <b_medfilt2+0x30d>
neg    %ebp
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movzbl (%rax),%ecx
add    $0x1,%rax
mov    %cl,(%r11)
add    $0x1,%r11
add    $0xffffffffffffffff,%rdx
cmp    %edx,%ebp
jne    1420 <b_medfilt2+0x2f0>
sub    %edx,%edi
mov    0x18(%rsp),%rdx
mov    %r15,%rbp
cmp    $0x7,%ebx
jb     13b0 <b_medfilt2+0x280>
mov    0x20(%rsp),%ebx
sub    %edi,%ebx
nop
movzbl (%rax),%ecx
mov    %cl,(%r11)
movzbl 0x1(%rax),%ecx
mov    %cl,0x1(%r11)
movzbl 0x2(%rax),%ecx
mov    %cl,0x2(%r11)
movzbl 0x3(%rax),%ecx
mov    %cl,0x3(%r11)
movzbl 0x4(%rax),%ecx
mov    %cl,0x4(%r11)
movzbl 0x5(%rax),%ecx
mov    %cl,0x5(%r11)
movzbl 0x6(%rax),%ecx
mov    %cl,0x6(%r11)
movzbl 0x7(%rax),%ecx
add    $0x8,%rax
mov    %cl,0x7(%r11)
add    $0x8,%r11
add    $0xfffffff8,%ebx
jne    1450 <b_medfilt2+0x320>
jmp    13b0 <b_medfilt2+0x280>
cmpq   $0x60,0x30(%rsp)
jae    14ac <b_medfilt2+0x37c>
xor    %ecx,%ecx
jmp    1524 <b_medfilt2+0x3f4>
mov    0x78(%rsp),%rbx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rax,%rcx,1),%xmm0
movups 0x10(%rax,%rcx,1),%xmm1
movups %xmm0,(%r11,%rcx,1)
movups %xmm1,0x10(%r11,%rcx,1)
movups 0x20(%rax,%rcx,1),%xmm0
movups 0x30(%rax,%rcx,1),%xmm1
movups %xmm0,0x20(%r11,%rcx,1)
movups %xmm1,0x30(%r11,%rcx,1)
movups 0x40(%rax,%rcx,1),%xmm0
movups 0x50(%rax,%rcx,1),%xmm1
movups %xmm0,0x40(%r11,%rcx,1)
movups %xmm1,0x50(%r11,%rcx,1)
movdqu 0x60(%rax,%rcx,1),%xmm0
movdqu 0x70(%rax,%rcx,1),%xmm1
movdqu %xmm0,0x60(%r11,%rcx,1)
movdqu %xmm1,0x70(%r11,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rbx
jne    14c0 <b_medfilt2+0x390>
testb  $0x3,0x88(%rsp)
03
je     155f <b_medfilt2+0x42f>
lea    (%r11,%rcx,1),%rdx
add    $0x10,%rdx
add    %rax,%rcx
add    $0x10,%rcx
xor    %ebx,%ebx
nop
movdqu -0x10(%rcx,%rbx,1),%xmm0
movdqu (%rcx,%rbx,1),%xmm1
movdqu %xmm0,-0x10(%rdx,%rbx,1)
movdqu %xmm1,(%rdx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1540 <b_medfilt2+0x410>
mov    0x38(%rsp),%rcx
add    %rcx,%rax
add    %rcx,%r11
mov    0x54(%rsp),%edi
cmp    %rcx,0x40(%rsp)
mov    0x18(%rsp),%rdx
je     13b0 <b_medfilt2+0x280>
jmp    1402 <b_medfilt2+0x2d2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebp,0x4(%rsp)
mov    %rdx,0x68(%rsp)
mov    %r9,0x70(%rsp)
mov    %ebx,%ecx
neg    %ecx
lea    (%r14,%rbx,1),%r9d
mov    %r9d,%ebp
not    %ebp
lea    0x1(%r9),%rdi
mov    %rdi,0x20(%rsp)
mov    %rdi,%rdx
movabs $0x1ffffffe0,%rdi
and    %rdi,%rdx
lea    -0x20(%rdx),%rdi
mov    %rdi,0x40(%rsp)
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %rdi,0x38(%rsp)
lea    0x1(%r14),%r11d
mov    %rdx,0x18(%rsp)
mov    %edx,%edi
mov    %r11d,%edx
mov    %rbx,0x60(%rsp)
sub    %ebx,%edi
mov    %edi,0x30(%rsp)
add    %r14d,%r10d
add    $0x1,%r10
and    $0xffffffffffffffe0,%r10
add    $0xffffffffffffffe0,%r10
shr    $0x5,%r10
add    $0x1,%r10
and    $0xfffffffffffffffe,%r10
mov    %r12d,%r13d
mov    0x10(%rsp),%r11
jmp    1643 <b_medfilt2+0x513>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rdi
mov    0x4(%rdi),%r15d
lea    (%r15,%rbp,1),%edi
movslq %edi,%rdi
add    %rdi,%rax
lea    0x1(%r8),%edi
cmp    %esi,%r8d
mov    %edi,%r8d
je     1890 <b_medfilt2+0x760>
cmp    %ecx,%r14d
jl     1629 <b_medfilt2+0x4f9>
cmp    $0x1f,%r9d
jb     1670 <b_medfilt2+0x540>
lea    (%rax,%r9,1),%rdi
add    $0x1,%rdi
cmp    %rdi,%r11
jae    1714 <b_medfilt2+0x5e4>
lea    (%r11,%r9,1),%rdi
add    $0x1,%rdi
cmp    %rdi,%rax
jae    1714 <b_medfilt2+0x5e4>
mov    %ecx,%edi
mov    %edx,%ebx
sub    %edi,%ebx
test   $0x1,%bl
jne    1690 <b_medfilt2+0x560>
mov    %edi,%ebx
cmp    %edi,%r14d
je     1620 <b_medfilt2+0x4f0>
jmp    16c0 <b_medfilt2+0x590>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rax),%ebx
cmp    %r13b,%bl
movzbl %r13b,%r13d
cmovb  %ebx,%r13d
cmp    %r12b,%bl
movzbl %r12b,%r12d
cmova  %ebx,%r12d
add    $0x1,%rax
mov    %bl,(%r11)
add    $0x1,%r11
lea    0x1(%rdi),%ebx
cmp    %edi,%r14d
je     1620 <b_medfilt2+0x4f0>
mov    %edx,%edi
sub    %ebx,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rax),%ebx
cmp    %r13b,%bl
movzbl %r13b,%r13d
cmovb  %ebx,%r13d
cmp    %r12b,%bl
movzbl %r12b,%r12d
cmova  %ebx,%r12d
mov    %bl,(%r11)
movzbl 0x1(%rax),%ebx
cmp    %r13b,%bl
cmovb  %ebx,%r13d
cmp    %r12b,%bl
cmova  %ebx,%r12d
add    $0x2,%rax
mov    %bl,0x1(%r11)
add    $0x2,%r11
add    $0xfffffffe,%edi
jne    16d0 <b_medfilt2+0x5a0>
jmp    1620 <b_medfilt2+0x4f0>
movzbl %r12b,%edi
movd   %edi,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
movzbl %r13b,%edi
movd   %edi,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
pshufd $0x0,%xmm1,%xmm1
cmpq   $0x0,0x40(%rsp)
je     17be <b_medfilt2+0x68e>
mov    %r10,%rbx
xor    %edi,%edi
movdqa %xmm0,%xmm2
movdqa %xmm1,%xmm3
cs nopw 0x0(%rax,%rax,1)
nop
movdqu (%rax,%rdi,1),%xmm4
movdqu 0x10(%rax,%rdi,1),%xmm5
pminub %xmm4,%xmm1
pminub %xmm5,%xmm3
pmaxub %xmm4,%xmm0
pmaxub %xmm5,%xmm2
movdqu %xmm4,(%r11,%rdi,1)
movdqu %xmm5,0x10(%r11,%rdi,1)
movdqu 0x20(%rax,%rdi,1),%xmm4
movdqu 0x30(%rax,%rdi,1),%xmm5
pminub %xmm4,%xmm1
pminub %xmm5,%xmm3
pmaxub %xmm4,%xmm0
pmaxub %xmm5,%xmm2
movdqu %xmm4,0x20(%r11,%rdi,1)
movdqu %xmm5,0x30(%r11,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1760 <b_medfilt2+0x630>
jmp    17c8 <b_medfilt2+0x698>
xor    %edi,%edi
movdqa %xmm0,%xmm2
movdqa %xmm1,%xmm3
mov    %edx,%ebx
testb  $0x1,0x38(%rsp)
je     17f9 <b_medfilt2+0x6c9>
movdqu (%rax,%rdi,1),%xmm4
movdqu 0x10(%rax,%rdi,1),%xmm5
pminub %xmm4,%xmm1
pminub %xmm5,%xmm3
pmaxub %xmm4,%xmm0
pmaxub %xmm5,%xmm2
movdqu %xmm4,(%r11,%rdi,1)
movdqu %xmm5,0x10(%r11,%rdi,1)
pmaxub %xmm2,%xmm0
pminub %xmm3,%xmm1
mov    0x18(%rsp),%rdx
add    %rdx,%rax
add    %rdx,%r11
pshufd $0xee,%xmm1,%xmm2
pminub %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm1
pminub %xmm2,%xmm1
movdqa %xmm1,%xmm2
psrld  $0x10,%xmm2
pminub %xmm1,%xmm2
movdqa %xmm2,%xmm1
psrlw  $0x8,%xmm1
pminub %xmm2,%xmm1
movd   %xmm1,%r13d
pshufd $0xee,%xmm0,%xmm1
pmaxub %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pmaxub %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x10,%xmm1
pmaxub %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrlw  $0x8,%xmm0
pmaxub %xmm1,%xmm0
movd   %xmm0,%r12d
mov    0x30(%rsp),%edi
cmp    %rdx,0x20(%rsp)
mov    %ebx,%edx
je     1620 <b_medfilt2+0x4f0>
jmp    1672 <b_medfilt2+0x542>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x4c(%rsp),%edi
test   %edi,%edi
mov    0x70(%rsp),%r9
mov    0x68(%rsp),%rdx
mov    0xc(%rsp),%r8d
mov    0x4(%rsp),%ebp
mov    0x60(%rsp),%rbx
je     1210 <b_medfilt2+0xe0>
mov    (%rdx),%al
cmp    %r13b,%al
je     1210 <b_medfilt2+0xe0>
cmp    %r12b,%al
jne    124e <b_medfilt2+0x11e>
jmp    1210 <b_medfilt2+0xe0>
mov    0x10(%rsp),%rdi
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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