void MergeChannels(unsigned char *buf, unsigned char *lum, unsigned char *cb,
                   unsigned char *cr, int n_lum, int n_cb, int n_cr) {
  int lum_pkg, cb_pkg, cr_pkg;
  int lum_div, cb_div, cr_div;
  int lum_cur, cb_cur, cr_cur;
  int lum_rem, cb_rem, cr_rem;
  int lum_tr0, cb_tr0, cr_tr0;
  int lum_tr1, cb_tr1, cr_tr1;
  int i, pkg, min;
  min = (n_lum < (n_cb < n_cr ? n_cb : n_cr) ? n_lum
                                             : (n_cb < n_cr ? n_cb : n_cr));
  lum_div = n_lum / min;
  lum_cur = n_lum;
  lum_rem = 0;
  lum_tr0 = lum_div * min;
  lum_tr1 = lum_tr0 + min;
  cb_div = n_cb / min;
  cb_cur = n_cb;
  cb_rem = 0;
  cb_tr0 = cb_div * min;
  cb_tr1 = cb_tr0 + min;
  cr_div = n_cr / min;
  cr_cur = n_cr;
  cr_rem = 0;
  cr_tr0 = cr_div * min;
  cr_tr1 = cr_tr0 + min;
  for (pkg = 0; pkg < min; pkg++) {
    lum_cur = n_lum + lum_rem;
    if (lum_cur >= lum_tr1) {
      lum_pkg = lum_div + 1;
      lum_rem = lum_cur - lum_tr1;
    } else {
      lum_pkg = lum_div;
      lum_rem = lum_cur - lum_tr0;
    }
    cb_cur = n_cb + cb_rem;
    if (cb_cur >= cb_tr1) {
      cb_pkg = cb_div + 1;
      cb_rem = cb_cur - cb_tr1;
    } else {
      cb_pkg = cb_div;
      cb_rem = cb_cur - cb_tr0;
    }
    cr_cur = n_cr + cr_rem;
    if (cr_cur >= cr_tr1) {
      cr_pkg = cr_div + 1;
      cr_rem = cr_cur - cr_tr1;
    } else {
      cr_pkg = cr_div;
      cr_rem = cr_cur - cr_tr0;
    }
    for (i = 0; i < lum_pkg; i++)
      *buf++ = *lum++;
    for (i = 0; i < cb_pkg; i++)
      *buf++ = *cb++;
    for (i = 0; i < cr_pkg; i++)
      *buf++ = *cr++;
  }
}


x86 assembly (clang, -O0):
<MergeChannels>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x28(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1143 <MergeChannels+0x43>
mov    -0x28(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    114c <MergeChannels+0x4c>
mov    0x10(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x80(%rbp),%eax
mov    -0x84(%rbp),%ecx
cmp    %ecx,%eax
jge    116b <MergeChannels+0x6b>
mov    -0x24(%rbp),%eax
mov    %eax,-0x88(%rbp)
jmp    119a <MergeChannels+0x9a>
mov    -0x28(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1185 <MergeChannels+0x85>
mov    -0x28(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    118e <MergeChannels+0x8e>
mov    0x10(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x24(%rbp),%eax
cltd
idivl  -0x7c(%rbp)
mov    %eax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x7c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x7c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x28(%rbp),%eax
cltd
idivl  -0x7c(%rbp)
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
imul   -0x7c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x7c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%eax
cltd
idivl  -0x7c(%rbp)
mov    %eax,-0x40(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x40(%rbp),%eax
imul   -0x7c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
add    -0x7c(%rbp),%eax
mov    %eax,-0x70(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    13c1 <MergeChannels+0x2c1>
mov    -0x24(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x68(%rbp),%eax
jl     1260 <MergeChannels+0x160>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    126f <MergeChannels+0x16f>
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jl     129b <MergeChannels+0x19b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x48(%rbp),%eax
sub    -0x6c(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    12aa <MergeChannels+0x1aa>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x48(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    0x10(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jl     12d6 <MergeChannels+0x1d6>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x70(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    12e5 <MergeChannels+0x1e5>
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1328 <MergeChannels+0x228>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12ec <MergeChannels+0x1ec>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    136b <MergeChannels+0x26b>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    132f <MergeChannels+0x22f>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    13ae <MergeChannels+0x2ae>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1372 <MergeChannels+0x272>
jmp    13b3 <MergeChannels+0x2b3>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1228 <MergeChannels+0x128>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MergeChannels>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    0x40(%rsp),%ebp
cmp    %ebp,%r9d
mov    %ebp,%ebx
cmovl  %r9d,%ebx
mov    %r8d,%eax
cmp    %r8d,%ebx
cmovg  %r8d,%ebx
mov    %rdx,%r11
mov    %r8d,-0x48(%rsp)
cltd
idiv   %ebx
mov    %rax,-0x28(%rsp)
mov    %r9d,-0x44(%rsp)
mov    %r9d,%eax
cltd
idiv   %ebx
mov    %rax,-0x30(%rsp)
mov    %ebp,%eax
cltd
idiv   %ebx
mov    %rax,-0x38(%rsp)
mov    %rbx,-0x20(%rsp)
test   %ebx,%ebx
jle    1819 <MergeChannels+0x719>
mov    -0x28(%rsp),%r8
mov    %r8d,%edx
mov    -0x20(%rsp),%rax
imul   %eax,%edx
mov    %rdx,(%rsp)
add    %eax,%edx
mov    %edx,-0x4c(%rsp)
mov    -0x30(%rsp),%rbp
mov    %ebp,%edx
imul   %eax,%edx
mov    %rdx,-0x8(%rsp)
add    %eax,%edx
mov    %edx,-0x50(%rsp)
mov    -0x38(%rsp),%rbx
mov    %ebx,%edx
imul   %eax,%edx
mov    %rdx,-0x10(%rsp)
add    %edx,%eax
mov    %eax,-0x54(%rsp)
lea    -0x1(%rbx),%eax
mov    %eax,-0x58(%rsp)
lea    -0x1(%rbp),%eax
mov    %eax,-0x5c(%rsp)
lea    -0x1(%r8),%eax
mov    %eax,-0x60(%rsp)
xor    %r8d,%r8d
xor    %edx,%edx
xor    %r15d,%r15d
xor    %ebx,%ebx
jmp    11f0 <MergeChannels+0xf0>
nop
mov    -0x68(%rsp),%r8
mov    -0x6c(%rsp),%r15d
mov    -0x70(%rsp),%ebx
mov    -0x78(%rsp),%r13d
sub    %r12d,%ebx
sub    %r13d,%r15d
mov    -0x3c(%rsp),%edx
sub    -0x40(%rsp),%edx
add    $0x1,%r8d
cmp    -0x20(%rsp),%r8d
je     1819 <MergeChannels+0x719>
mov    %r8,-0x68(%rsp)
add    -0x48(%rsp),%ebx
xor    %r12d,%r12d
mov    -0x4c(%rsp),%eax
mov    %ebx,-0x70(%rsp)
cmp    %eax,%ebx
cmovl  (%rsp),%eax
mov    %eax,-0x74(%rsp)
setge  %r12b
mov    -0x28(%rsp),%rax
lea    (%rax,%r12,1),%ebp
add    -0x44(%rsp),%r15d
xor    %r8d,%r8d
mov    -0x50(%rsp),%eax
mov    %r15d,-0x6c(%rsp)
cmp    %eax,%r15d
setge  %r8b
cmovl  -0x8(%rsp),%eax
mov    %eax,-0x78(%rsp)
mov    -0x30(%rsp),%rax
lea    (%rax,%r8,1),%r13d
add    0x40(%rsp),%edx
xor    %r10d,%r10d
mov    -0x54(%rsp),%eax
cmp    %eax,%edx
setge  %r9b
cmovl  -0x10(%rsp),%eax
test   %ebp,%ebp
mov    %edx,-0x3c(%rsp)
mov    %eax,-0x40(%rsp)
jle    1443 <MergeChannels+0x343>
add    -0x60(%rsp),%r12d
xor    %r14d,%r14d
cmp    $0x1f,%r12d
jb     13b0 <MergeChannels+0x2b0>
lea    (%rsi,%r12,1),%rax
add    $0x1,%rax
cmp    %rax,%rdi
jae    129b <MergeChannels+0x19b>
lea    (%rdi,%r12,1),%rax
add    $0x1,%rax
cmp    %rax,%rsi
jb     13b0 <MergeChannels+0x2b0>
mov    %r9b,-0x79(%rsp)
lea    0x1(%r12),%r14
mov    %r14,-0x18(%rsp)
movabs $0x1ffffffe0,%rax
and    %rax,%r14
lea    -0x20(%r14),%rax
mov    %rax,%r9
shr    $0x5,%r9
add    $0x1,%r9
mov    %r9d,%r15d
and    $0x3,%r15d
cmp    $0x60,%rax
jae    12d7 <MergeChannels+0x1d7>
xor    %ebx,%ebx
jmp    1348 <MergeChannels+0x248>
movabs $0xffffffffffffffc,%rax
ff ff 0f
and    %rax,%r9
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movups (%rsi,%rbx,1),%xmm0
movups 0x10(%rsi,%rbx,1),%xmm1
movups %xmm0,(%rdi,%rbx,1)
movups %xmm1,0x10(%rdi,%rbx,1)
movups 0x20(%rsi,%rbx,1),%xmm0
movups 0x30(%rsi,%rbx,1),%xmm1
movups %xmm0,0x20(%rdi,%rbx,1)
movups %xmm1,0x30(%rdi,%rbx,1)
movups 0x40(%rsi,%rbx,1),%xmm0
movups 0x50(%rsi,%rbx,1),%xmm1
movups %xmm0,0x40(%rdi,%rbx,1)
movups %xmm1,0x50(%rdi,%rbx,1)
movups 0x60(%rsi,%rbx,1),%xmm0
movups 0x70(%rsi,%rbx,1),%xmm1
movups %xmm0,0x60(%rdi,%rbx,1)
movups %xmm1,0x70(%rdi,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%r9
jne    12f0 <MergeChannels+0x1f0>
test   %r15,%r15
je     138b <MergeChannels+0x28b>
lea    (%rsi,%rbx,1),%rdx
add    $0x10,%rdx
add    %rdi,%rbx
add    $0x10,%rbx
shl    $0x5,%r15
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdx,%rax,1),%xmm0
movups (%rdx,%rax,1),%xmm1
movups %xmm0,-0x10(%rbx,%rax,1)
movups %xmm1,(%rbx,%rax,1)
add    $0x20,%rax
cmp    %rax,%r15
jne    1370 <MergeChannels+0x270>
add    %r14,%rdi
add    %r14,%rsi
cmp    %r14,-0x18(%rsp)
mov    -0x79(%rsp),%r9b
je     1443 <MergeChannels+0x343>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebp,%ebx
sub    %r14d,%ebx
sub    %r14d,%r12d
and    $0x7,%ebx
je     13e8 <MergeChannels+0x2e8>
neg    %ebx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rsi),%eax
add    $0x1,%rsi
mov    %al,(%rdi)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
cmp    %edx,%ebx
jne    13d0 <MergeChannels+0x2d0>
sub    %edx,%r14d
cmp    $0x7,%r12d
jb     1443 <MergeChannels+0x343>
sub    %r14d,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rsi),%eax
mov    %al,(%rdi)
movzbl 0x1(%rsi),%eax
mov    %al,0x1(%rdi)
movzbl 0x2(%rsi),%eax
mov    %al,0x2(%rdi)
movzbl 0x3(%rsi),%eax
mov    %al,0x3(%rdi)
movzbl 0x4(%rsi),%eax
mov    %al,0x4(%rdi)
movzbl 0x5(%rsi),%eax
mov    %al,0x5(%rdi)
movzbl 0x6(%rsi),%eax
mov    %al,0x6(%rdi)
movzbl 0x7(%rsi),%eax
add    $0x8,%rsi
mov    %al,0x7(%rdi)
add    $0x8,%rdi
add    $0xfffffff8,%ebp
jne    1400 <MergeChannels+0x300>
mov    %r9b,%r10b
mov    -0x38(%rsp),%rax
lea    (%rax,%r10,1),%r9d
test   %r13d,%r13d
jle    1520 <MergeChannels+0x420>
add    -0x5c(%rsp),%r8d
xor    %r15d,%r15d
cmp    $0x1f,%r8d
jb     1488 <MergeChannels+0x388>
lea    (%r11,%r8,1),%rax
add    $0x1,%rax
cmp    %rax,%rdi
jae    1609 <MergeChannels+0x509>
lea    (%rdi,%r8,1),%rax
add    $0x1,%rax
cmp    %rax,%r11
jae    1609 <MergeChannels+0x509>
mov    -0x74(%rsp),%r12d
mov    %r13d,%edx
sub    %r15d,%edx
sub    %r15d,%r8d
and    $0x7,%edx
je     14b9 <MergeChannels+0x3b9>
neg    %edx
xor    %ebx,%ebx
nop
movzbl (%r11),%eax
add    $0x1,%r11
mov    %al,(%rdi)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbx
cmp    %ebx,%edx
jne    14a0 <MergeChannels+0x3a0>
sub    %ebx,%r15d
cmp    $0x7,%r8d
jb     1525 <MergeChannels+0x425>
sub    %r15d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r11),%eax
mov    %al,(%rdi)
movzbl 0x1(%r11),%eax
mov    %al,0x1(%rdi)
movzbl 0x2(%r11),%eax
mov    %al,0x2(%rdi)
movzbl 0x3(%r11),%eax
mov    %al,0x3(%rdi)
movzbl 0x4(%r11),%eax
mov    %al,0x4(%rdi)
movzbl 0x5(%r11),%eax
mov    %al,0x5(%rdi)
movzbl 0x6(%r11),%eax
mov    %al,0x6(%rdi)
movzbl 0x7(%r11),%eax
add    $0x8,%r11
mov    %al,0x7(%rdi)
add    $0x8,%rdi
add    $0xfffffff8,%r13d
jne    14d0 <MergeChannels+0x3d0>
jmp    1525 <MergeChannels+0x425>
xchg   %ax,%ax
mov    -0x74(%rsp),%r12d
test   %r9d,%r9d
jle    11c0 <MergeChannels+0xc0>
add    -0x58(%rsp),%r10d
xor    %r14d,%r14d
cmp    $0x1f,%r10d
jb     155e <MergeChannels+0x45e>
lea    (%rcx,%r10,1),%rax
add    $0x1,%rax
cmp    %rax,%rdi
jae    1643 <MergeChannels+0x543>
lea    (%rdi,%r10,1),%rax
add    $0x1,%rax
cmp    %rax,%rcx
jae    1643 <MergeChannels+0x543>
mov    -0x68(%rsp),%r8
mov    -0x6c(%rsp),%r15d
mov    -0x70(%rsp),%ebx
mov    -0x78(%rsp),%r13d
mov    %r9d,%edx
sub    %r14d,%edx
sub    %r14d,%r10d
and    $0x7,%edx
je     15a8 <MergeChannels+0x4a8>
neg    %edx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rcx),%eax
add    $0x1,%rcx
mov    %al,(%rdi)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbp
cmp    %ebp,%edx
jne    1590 <MergeChannels+0x490>
sub    %ebp,%r14d
cmp    $0x7,%r10d
jb     11d3 <MergeChannels+0xd3>
sub    %r14d,%r9d
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rcx),%eax
mov    %al,(%rdi)
movzbl 0x1(%rcx),%eax
mov    %al,0x1(%rdi)
movzbl 0x2(%rcx),%eax
mov    %al,0x2(%rdi)
movzbl 0x3(%rcx),%eax
mov    %al,0x3(%rdi)
movzbl 0x4(%rcx),%eax
mov    %al,0x4(%rdi)
movzbl 0x5(%rcx),%eax
mov    %al,0x5(%rdi)
movzbl 0x6(%rcx),%eax
mov    %al,0x6(%rdi)
movzbl 0x7(%rcx),%eax
add    $0x8,%rcx
mov    %al,0x7(%rdi)
add    $0x8,%rdi
add    $0xfffffff8,%r9d
jne    15c0 <MergeChannels+0x4c0>
jmp    11d3 <MergeChannels+0xd3>
lea    0x1(%r8),%r14
mov    %r14,%r15
movabs $0x1ffffffe0,%rax
and    %rax,%r15
lea    -0x20(%r15),%rax
mov    %rax,%rbp
shr    $0x5,%rbp
add    $0x1,%rbp
mov    %ebp,%ebx
and    $0x3,%ebx
cmp    $0x60,%rax
mov    -0x74(%rsp),%r12d
jae    1686 <MergeChannels+0x586>
xor    %edx,%edx
jmp    1700 <MergeChannels+0x600>
lea    0x1(%r10),%r8
mov    %r8,%r14
movabs $0x1ffffffe0,%rax
and    %rax,%r14
lea    -0x20(%r14),%rax
mov    %rax,%rbp
shr    $0x5,%rbp
add    $0x1,%rbp
mov    %ebp,%ebx
and    $0x3,%ebx
cmp    $0x60,%rax
mov    -0x6c(%rsp),%r15d
mov    -0x78(%rsp),%r13d
jae    1750 <MergeChannels+0x650>
xor    %edx,%edx
jmp    17b8 <MergeChannels+0x6b8>
movabs $0xffffffffffffffc,%rax
ff ff 0f
and    %rax,%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%r11,%rdx,1),%xmm0
movups 0x10(%r11,%rdx,1),%xmm1
movups %xmm0,(%rdi,%rdx,1)
movups %xmm1,0x10(%rdi,%rdx,1)
movups 0x20(%r11,%rdx,1),%xmm0
movups 0x30(%r11,%rdx,1),%xmm1
movups %xmm0,0x20(%rdi,%rdx,1)
movups %xmm1,0x30(%rdi,%rdx,1)
movups 0x40(%r11,%rdx,1),%xmm0
movups 0x50(%r11,%rdx,1),%xmm1
movups %xmm0,0x40(%rdi,%rdx,1)
movups %xmm1,0x50(%rdi,%rdx,1)
movups 0x60(%r11,%rdx,1),%xmm0
movups 0x70(%r11,%rdx,1),%xmm1
movups %xmm0,0x60(%rdi,%rdx,1)
movups %xmm1,0x70(%rdi,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rbp
jne    16a0 <MergeChannels+0x5a0>
test   %rbx,%rbx
je     173c <MergeChannels+0x63c>
lea    (%r11,%rdx,1),%rbp
add    $0x10,%rbp
add    %rdi,%rdx
add    $0x10,%rdx
shl    $0x5,%rbx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups -0x10(%rbp,%rax,1),%xmm0
movups 0x0(%rbp,%rax,1),%xmm1
movups %xmm0,-0x10(%rdx,%rax,1)
movups %xmm1,(%rdx,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbx
jne    1720 <MergeChannels+0x620>
add    %r15,%rdi
add    %r15,%r11
cmp    %r15,%r14
je     1525 <MergeChannels+0x425>
jmp    148d <MergeChannels+0x38d>
movabs $0xffffffffffffffc,%rax
ff ff 0f
and    %rax,%rbp
xor    %edx,%edx
nop
movups (%rcx,%rdx,1),%xmm0
movups 0x10(%rcx,%rdx,1),%xmm1
movups %xmm0,(%rdi,%rdx,1)
movups %xmm1,0x10(%rdi,%rdx,1)
movups 0x20(%rcx,%rdx,1),%xmm0
movups 0x30(%rcx,%rdx,1),%xmm1
movups %xmm0,0x20(%rdi,%rdx,1)
movups %xmm1,0x30(%rdi,%rdx,1)
movups 0x40(%rcx,%rdx,1),%xmm0
movups 0x50(%rcx,%rdx,1),%xmm1
movups %xmm0,0x40(%rdi,%rdx,1)
movups %xmm1,0x50(%rdi,%rdx,1)
movups 0x60(%rcx,%rdx,1),%xmm0
movups 0x70(%rcx,%rdx,1),%xmm1
movups %xmm0,0x60(%rdi,%rdx,1)
movups %xmm1,0x70(%rdi,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rbp
jne    1760 <MergeChannels+0x660>
test   %rbx,%rbx
je     17fc <MergeChannels+0x6fc>
lea    (%rcx,%rdx,1),%rbp
add    $0x10,%rbp
add    %rdi,%rdx
add    $0x10,%rdx
shl    $0x5,%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rbp,%rax,1),%xmm0
movups 0x0(%rbp,%rax,1),%xmm1
movups %xmm0,-0x10(%rdx,%rax,1)
movups %xmm1,(%rdx,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbx
jne    17e0 <MergeChannels+0x6e0>
add    %r14,%rdi
add    %r14,%rcx
cmp    %r14,%r8
mov    -0x68(%rsp),%r8
mov    -0x70(%rsp),%ebx
je     11d3 <MergeChannels+0xd3>
jmp    1571 <MergeChannels+0x471>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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