void SplitChannels(unsigned char *buf, unsigned char *lum, unsigned char *cb,
                   unsigned char *cr, int n_buf, int n_lum, int n_cb, int n_cr,
                   int *count_lum, int *count_cb, int *count_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;
  unsigned char *pn;
  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));
  pn = buf + n_buf;
  *count_lum = 0;
  *count_cb = 0;
  *count_cr = 0;
  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; (buf < pn) && (i < lum_pkg); i++, (*count_lum)++)
      *lum++ = *buf++;
    for (i = 0; (buf < pn) && (i < cb_pkg); i++, (*count_cb)++)
      *cb++ = *buf++;
    for (i = 0; (buf < pn) && (i < cr_pkg); i++, (*count_cr)++)
      *cr++ = *buf++;
    if (buf >= pn)
      return;
  }
}


x86 assembly (clang, -O0):
<SplitChannels>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    0x10(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1155 <SplitChannels+0x55>
mov    0x10(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    115e <SplitChannels+0x5e>
mov    0x18(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x8c(%rbp),%ecx
cmp    %ecx,%eax
jge    1180 <SplitChannels+0x80>
mov    -0x28(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    11af <SplitChannels+0xaf>
mov    0x10(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    119a <SplitChannels+0x9a>
mov    0x10(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    11a3 <SplitChannels+0xa3>
mov    0x18(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    0x30(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%eax
cltd
idivl  -0x84(%rbp)
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x84(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    0x10(%rbp),%eax
cltd
idivl  -0x84(%rbp)
mov    %eax,-0x3c(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
imul   -0x84(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    0x18(%rbp),%eax
cltd
idivl  -0x84(%rbp)
mov    %eax,-0x40(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x40(%rbp),%eax
imul   -0x84(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x70(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    14dc <SplitChannels+0x3dc>
mov    -0x28(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x68(%rbp),%eax
jl     12c3 <SplitChannels+0x1c3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    12d2 <SplitChannels+0x1d2>
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    0x10(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jl     12fe <SplitChannels+0x1fe>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x48(%rbp),%eax
sub    -0x6c(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    130d <SplitChannels+0x20d>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x48(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    0x18(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jl     1339 <SplitChannels+0x239>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x70(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    1348 <SplitChannels+0x248>
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x8(%rbp),%rcx
xor    %eax,%eax
cmp    -0x78(%rbp),%rcx
mov    %al,-0x95(%rbp)
jae    1374 <SplitChannels+0x274>
mov    -0x7c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
setl   %al
mov    %al,-0x95(%rbp)
mov    -0x95(%rbp),%al
test   $0x1,%al
jne    1387 <SplitChannels+0x287>
jmp    13c2 <SplitChannels+0x2c2>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    134f <SplitChannels+0x24f>
movl   $0x0,-0x7c(%rbp)
mov    -0x8(%rbp),%rcx
xor    %eax,%eax
cmp    -0x78(%rbp),%rcx
mov    %al,-0x96(%rbp)
jae    13ee <SplitChannels+0x2ee>
mov    -0x7c(%rbp),%eax
cmp    -0x30(%rbp),%eax
setl   %al
mov    %al,-0x96(%rbp)
mov    -0x96(%rbp),%al
test   $0x1,%al
jne    1401 <SplitChannels+0x301>
jmp    143c <SplitChannels+0x33c>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    13c9 <SplitChannels+0x2c9>
movl   $0x0,-0x7c(%rbp)
mov    -0x8(%rbp),%rcx
xor    %eax,%eax
cmp    -0x78(%rbp),%rcx
mov    %al,-0x97(%rbp)
jae    1468 <SplitChannels+0x368>
mov    -0x7c(%rbp),%eax
cmp    -0x34(%rbp),%eax
setl   %al
mov    %al,-0x97(%rbp)
mov    -0x97(%rbp),%al
test   $0x1,%al
jne    147b <SplitChannels+0x37b>
jmp    14b6 <SplitChannels+0x3b6>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    0x30(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1443 <SplitChannels+0x343>
mov    -0x8(%rbp),%rax
cmp    -0x78(%rbp),%rax
jb     14c9 <SplitChannels+0x3c9>
jmp    14dc <SplitChannels+0x3dc>
jmp    14ce <SplitChannels+0x3ce>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1288 <SplitChannels+0x188>
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SplitChannels>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9d,%eax
mov    %rdx,%rbx
mov    0x58(%rsp),%r15
mov    0x50(%rsp),%r9
mov    0x48(%rsp),%rdx
mov    0x40(%rsp),%r10d
mov    0x38(%rsp),%r11d
cmp    %r10d,%r11d
mov    %r10d,%ebp
cmovl  %r11d,%ebp
cmp    %eax,%ebp
cmovg  %eax,%ebp
mov    %rdx,%r12
movl   $0x0,(%rdx)
movl   $0x0,(%r9)
movl   $0x0,(%r15)
mov    %eax,-0x30(%rsp)
cltd
idiv   %ebp
mov    %eax,-0x44(%rsp)
mov    %r11d,%eax
cltd
idiv   %ebp
mov    %eax,-0x48(%rsp)
mov    %r10d,%eax
cltd
idiv   %ebp
mov    %eax,-0x4c(%rsp)
mov    %rbp,-0x20(%rsp)
test   %ebp,%ebp
jle    135b <SplitChannels+0x25b>
movslq %r8d,%r13
add    %rdi,%r13
mov    -0x44(%rsp),%eax
mov    %eax,%edx
mov    -0x20(%rsp),%rax
imul   %eax,%edx
mov    %rdx,-0x8(%rsp)
add    %eax,%edx
mov    %edx,-0x34(%rsp)
mov    -0x48(%rsp),%edx
imul   %eax,%edx
mov    %rdx,-0x10(%rsp)
add    %eax,%edx
mov    %edx,-0x38(%rsp)
mov    -0x4c(%rsp),%edx
imul   %eax,%edx
mov    %rdx,-0x18(%rsp)
add    %edx,%eax
mov    %eax,-0x3c(%rsp)
movl   $0x0,-0x40(%rsp)
xor    %r14d,%r14d
xor    %r9d,%r9d
xor    %r10d,%r10d
nop
mov    %r15,%rbp
add    -0x30(%rsp),%r10d
xor    %r8d,%r8d
mov    -0x34(%rsp),%edx
cmp    %edx,%r10d
setge  %al
cmovl  -0x8(%rsp),%edx
mov    %edx,-0x24(%rsp)
add    0x38(%rsp),%r9d
xor    %r15d,%r15d
mov    -0x38(%rsp),%edx
cmp    %edx,%r9d
cmovl  -0x10(%rsp),%edx
mov    %edx,-0x28(%rsp)
setge  -0x4e(%rsp)
add    0x40(%rsp),%r14d
xor    %r11d,%r11d
mov    -0x3c(%rsp),%edx
cmp    %edx,%r14d
setge  -0x4d(%rsp)
cmovl  -0x18(%rsp),%edx
mov    %edx,-0x2c(%rsp)
cmp    %r13,%rdi
jae    1261 <SplitChannels+0x161>
mov    %al,%r8b
add    -0x44(%rsp),%r8d
test   %r8d,%r8d
jle    1261 <SplitChannels+0x161>
mov    $0x1,%eax
nop
movzbl (%rdi),%edx
add    $0x1,%rdi
mov    %dl,(%rsi)
add    $0x1,%rsi
addl   $0x1,(%r12)
cmp    %r13,%rdi
jae    1261 <SplitChannels+0x161>
lea    0x1(%rax),%edx
cmp    %r8d,%eax
mov    %edx,%eax
jl     1240 <SplitChannels+0x140>
cmp    %r13,%rdi
jae    12c0 <SplitChannels+0x1c0>
mov    -0x4e(%rsp),%al
mov    %al,%r15b
add    -0x48(%rsp),%r15d
test   %r15d,%r15d
mov    %rbp,%r8
jle    12c3 <SplitChannels+0x1c3>
mov    $0x1,%eax
mov    0x50(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rdi),%edx
add    $0x1,%rdi
mov    %dl,(%rbx)
add    $0x1,%rbx
addl   $0x1,0x0(%rbp)
cmp    %r13,%rdi
jae    12c3 <SplitChannels+0x1c3>
lea    0x1(%rax),%edx
cmp    %r15d,%eax
mov    %edx,%eax
jl     1290 <SplitChannels+0x190>
jmp    12c3 <SplitChannels+0x1c3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbp,%r8
cmp    %r13,%rdi
setb   %al
jae    1320 <SplitChannels+0x220>
mov    -0x4d(%rsp),%dl
mov    %dl,%r11b
add    -0x4c(%rsp),%r11d
test   %r11d,%r11d
jle    1330 <SplitChannels+0x230>
mov    $0x1,%ebp
mov    %r8,%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rdi),%eax
mov    %al,(%rcx)
addl   $0x1,(%r15)
add    $0x1,%rdi
add    $0x1,%rcx
cmp    %r13,%rdi
setb   %al
jae    1323 <SplitChannels+0x223>
lea    0x1(%rbp),%edx
cmp    %r11d,%ebp
mov    %edx,%ebp
jl     12f0 <SplitChannels+0x1f0>
jmp    1323 <SplitChannels+0x223>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r8,%r15
test   %al,%al
jne    1337 <SplitChannels+0x237>
jmp    135b <SplitChannels+0x25b>
nopl   0x0(%rax)
mov    %r8,%r15
test   %al,%al
je     135b <SplitChannels+0x25b>
sub    -0x24(%rsp),%r10d
sub    -0x28(%rsp),%r9d
sub    -0x2c(%rsp),%r14d
mov    -0x40(%rsp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rsp)
cmp    -0x20(%rsp),%eax
jl     11d0 <SplitChannels+0xd0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @SplitChannels(i8* %0, i8* %1, i8* %2, i8* %3, i32 %4, i32 %5, i32 %6, i32 %7, i32* %8, i32* %9, i32* %10) {
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i8*
%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
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i8*
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
store i8* %0, i8** %12
store i8* %1, i8** %13
store i8* %2, i8** %14
store i8* %3, i8** %15
store i32 %4, i32* %16
store i32 %5, i32* %17
store i32 %6, i32* %18
store i32 %7, i32* %19
store i32* %8, i32** %20
store i32* %9, i32** %21
store i32* %10, i32** %22
%45 = load i32, i32* %17
%46 = load i32, i32* %18
%47 = load i32, i32* %19
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %51
49: ; preds = %11
%50 = load i32, i32* %18
br label %53
51: ; preds = %11
%52 = load i32, i32* %19
br label %53
53: ; preds = %51, %49
%54 = phi i32 [ %50, %49 ], [ %52, %51 ]
%55 = icmp slt i32 %45, %54
br i1 %55, label %56, label %58
56: ; preds = %53
%57 = load i32, i32* %17
br label %68
58: ; preds = %53
%59 = load i32, i32* %18
%60 = load i32, i32* %19
%61 = icmp slt i32 %59, %60
br i1 %61, label %62, label %64
62: ; preds = %58
%63 = load i32, i32* %18
br label %66
64: ; preds = %58
%65 = load i32, i32* %19
br label %66
66: ; preds = %64, %62
%67 = phi i32 [ %63, %62 ], [ %65, %64 ]
br label %68
68: ; preds = %66, %56
%69 = phi i32 [ %57, %56 ], [ %67, %66 ]
store i32 %69, i32* %44
%70 = load i8*, i8** %12
%71 = load i32, i32* %16
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i8, i8* %70, i64 %72
store i8* %73, i8** %41
%74 = load i32*, i32** %20
store i32 0, i32* %74
%75 = load i32*, i32** %21
store i32 0, i32* %75
%76 = load i32*, i32** %22
store i32 0, i32* %76
%77 = load i32, i32* %17
%78 = load i32, i32* %44
%79 = sdiv i32 %77, %78
store i32 %79, i32* %26
%80 = load i32, i32* %17
store i32 %80, i32* %29
store i32 0, i32* %32
%81 = load i32, i32* %26
%82 = load i32, i32* %44
%83 = mul nsw i32 %81, %82
store i32 %83, i32* %35
%84 = load i32, i32* %35
%85 = load i32, i32* %44
%86 = add nsw i32 %84, %85
store i32 %86, i32* %38
%87 = load i32, i32* %18
%88 = load i32, i32* %44
%89 = sdiv i32 %87, %88
store i32 %89, i32* %27
%90 = load i32, i32* %18
store i32 %90, i32* %30
store i32 0, i32* %33
%91 = load i32, i32* %27
%92 = load i32, i32* %44
%93 = mul nsw i32 %91, %92
store i32 %93, i32* %36
%94 = load i32, i32* %36
%95 = load i32, i32* %44
%96 = add nsw i32 %94, %95
store i32 %96, i32* %39
%97 = load i32, i32* %19
%98 = load i32, i32* %44
%99 = sdiv i32 %97, %98
store i32 %99, i32* %28
%100 = load i32, i32* %19
store i32 %100, i32* %31
store i32 0, i32* %34
%101 = load i32, i32* %28
%102 = load i32, i32* %44
%103 = mul nsw i32 %101, %102
store i32 %103, i32* %37
%104 = load i32, i32* %37
%105 = load i32, i32* %44
%106 = add nsw i32 %104, %105
store i32 %106, i32* %40
store i32 0, i32* %43
br label %107
107: ; preds = %240, %68
%108 = load i32, i32* %43
%109 = load i32, i32* %44
%110 = icmp slt i32 %108, %109
br i1 %110, label %111, label %243
111: ; preds = %107
%112 = load i32, i32* %17
%113 = load i32, i32* %32
%114 = add nsw i32 %112, %113
store i32 %114, i32* %29
%115 = load i32, i32* %29
%116 = load i32, i32* %38
%117 = icmp sge i32 %115, %116
br i1 %117, label %118, label %124
118: ; preds = %111
%119 = load i32, i32* %26
%120 = add nsw i32 %119, 1
store i32 %120, i32* %23
%121 = load i32, i32* %29
%122 = load i32, i32* %38
%123 = sub nsw i32 %121, %122
store i32 %123, i32* %32
br label %129
124: ; preds = %111
%125 = load i32, i32* %26
store i32 %125, i32* %23
%126 = load i32, i32* %29
%127 = load i32, i32* %35
%128 = sub nsw i32 %126, %127
store i32 %128, i32* %32
br label %129
129: ; preds = %124, %118
%130 = load i32, i32* %18
%131 = load i32, i32* %33
%132 = add nsw i32 %130, %131
store i32 %132, i32* %30
%133 = load i32, i32* %30
%134 = load i32, i32* %39
%135 = icmp sge i32 %133, %134
br i1 %135, label %136, label %142
136: ; preds = %129
%137 = load i32, i32* %27
%138 = add nsw i32 %137, 1
store i32 %138, i32* %24
%139 = load i32, i32* %30
%140 = load i32, i32* %39
%141 = sub nsw i32 %139, %140
store i32 %141, i32* %33
br label %147
142: ; preds = %129
%143 = load i32, i32* %27
store i32 %143, i32* %24
%144 = load i32, i32* %30
%145 = load i32, i32* %36
%146 = sub nsw i32 %144, %145
store i32 %146, i32* %33
br label %147
147: ; preds = %142, %136
%148 = load i32, i32* %19
%149 = load i32, i32* %34
%150 = add nsw i32 %148, %149
store i32 %150, i32* %31
%151 = load i32, i32* %31
%152 = load i32, i32* %40
%153 = icmp sge i32 %151, %152
br i1 %153, label %154, label %160
154: ; preds = %147
%155 = load i32, i32* %28
%156 = add nsw i32 %155, 1
store i32 %156, i32* %25
%157 = load i32, i32* %31
%158 = load i32, i32* %40
%159 = sub nsw i32 %157, %158
store i32 %159, i32* %34
br label %165
160: ; preds = %147
%161 = load i32, i32* %28
store i32 %161, i32* %25
%162 = load i32, i32* %31
%163 = load i32, i32* %37
%164 = sub nsw i32 %162, %163
store i32 %164, i32* %34
br label %165
165: ; preds = %160, %154
store i32 0, i32* %42
br label %166
166: ; preds = %182, %165
%167 = load i8*, i8** %12
%168 = load i8*, i8** %41
%169 = icmp ult i8* %167, %168
br i1 %169, label %170, label %174
170: ; preds = %166
%171 = load i32, i32* %42
%172 = load i32, i32* %23
%173 = icmp slt i32 %171, %172
br label %174
174: ; preds = %170, %166
%175 = phi i1 [ false, %166 ], [ %173, %170 ]
br i1 %175, label %176, label %188
176: ; preds = %174
%177 = load i8*, i8** %12
%178 = getelementptr inbounds i8, i8* %177, i32 1
store i8* %178, i8** %12
%179 = load i8, i8* %177
%180 = load i8*, i8** %13
%181 = getelementptr inbounds i8, i8* %180, i32 1
store i8* %181, i8** %13
store i8 %179, i8* %180
br label %182
182: ; preds = %176
%183 = load i32, i32* %42
%184 = add nsw i32 %183, 1
store i32 %184, i32* %42
%185 = load i32*, i32** %20
%186 = load i32, i32* %185
%187 = add nsw i32 %186, 1
store i32 %187, i32* %185
br label %166
188: ; preds = %174
store i32 0, i32* %42
br label %189
189: ; preds = %205, %188
%190 = load i8*, i8** %12
%191 = load i8*, i8** %41
%192 = icmp ult i8* %190, %191
br i1 %192, label %193, label %197
193: ; preds = %189
%194 = load i32, i32* %42
%195 = load i32, i32* %24
%196 = icmp slt i32 %194, %195
br label %197
197: ; preds = %193, %189
%198 = phi i1 [ false, %189 ], [ %196, %193 ]
br i1 %198, label %199, label %211
199: ; preds = %197
%200 = load i8*, i8** %12
%201 = getelementptr inbounds i8, i8* %200, i32 1
store i8* %201, i8** %12
%202 = load i8, i8* %200
%203 = load i8*, i8** %14
%204 = getelementptr inbounds i8, i8* %203, i32 1
store i8* %204, i8** %14
store i8 %202, i8* %203
br label %205
205: ; preds = %199
%206 = load i32, i32* %42
%207 = add nsw i32 %206, 1
store i32 %207, i32* %42
%208 = load i32*, i32** %21
%209 = load i32, i32* %208
%210 = add nsw i32 %209, 1
store i32 %210, i32* %208
br label %189
211: ; preds = %197
store i32 0, i32* %42
br label %212
212: ; preds = %228, %211
%213 = load i8*, i8** %12
%214 = load i8*, i8** %41
%215 = icmp ult i8* %213, %214
br i1 %215, label %216, label %220
216: ; preds = %212
%217 = load i32, i32* %42
%218 = load i32, i32* %25
%219 = icmp slt i32 %217, %218
br label %220
220: ; preds = %216, %212
%221 = phi i1 [ false, %212 ], [ %219, %216 ]
br i1 %221, label %222, label %234
222: ; preds = %220
%223 = load i8*, i8** %12
%224 = getelementptr inbounds i8, i8* %223, i32 1
store i8* %224, i8** %12
%225 = load i8, i8* %223
%226 = load i8*, i8** %15
%227 = getelementptr inbounds i8, i8* %226, i32 1
store i8* %227, i8** %15
store i8 %225, i8* %226
br label %228
228: ; preds = %222
%229 = load i32, i32* %42
%230 = add nsw i32 %229, 1
store i32 %230, i32* %42
%231 = load i32*, i32** %22
%232 = load i32, i32* %231
%233 = add nsw i32 %232, 1
store i32 %233, i32* %231
br label %212
234: ; preds = %220
%235 = load i8*, i8** %12
%236 = load i8*, i8** %41
%237 = icmp uge i8* %235, %236
br i1 %237, label %238, label %239
238: ; preds = %234
br label %243
239: ; preds = %234
br label %240
240: ; preds = %239
%241 = load i32, i32* %43
%242 = add nsw i32 %241, 1
store i32 %242, i32* %43
br label %107
243: ; preds = %238, %107
ret void
}

LLVM IR (-O2):
define void @SplitChannels(i8* %0, i8* nocapture writeonly %1, i8* nocapture writeonly %2, i8* nocapture writeonly %3, i32 %4, i32 %5, i32 %6, i32 %7, i32* nocapture %8, i32* nocapture %9, i32* nocapture %10) {
%12 = icmp slt i32 %6, %7
%13 = select i1 %12, i32 %6, i32 %7
%14 = icmp sgt i32 %13, %5
%15 = select i1 %14, i32 %5, i32 %13
%16 = sext i32 %4 to i64
%17 = getelementptr inbounds i8, i8* %0, i64 %16
store i32 0, i32* %8
store i32 0, i32* %9
store i32 0, i32* %10
%18 = sdiv i32 %5, %15
%19 = mul nsw i32 %18, %15
%20 = add nsw i32 %19, %15
%21 = sdiv i32 %6, %15
%22 = mul nsw i32 %21, %15
%23 = add nsw i32 %22, %15
%24 = sdiv i32 %7, %15
%25 = mul nsw i32 %24, %15
%26 = add nsw i32 %25, %15
%27 = icmp sgt i32 %15, 0
br i1 %27, label %28, label %119
28: ; preds = %11, %112
%29 = phi i8* [ %114, %112 ], [ %0, %11 ]
%30 = phi i32 [ %116, %112 ], [ 0, %11 ]
%31 = phi i8* [ %62, %112 ], [ %1, %11 ]
%32 = phi i8* [ %81, %112 ], [ %2, %11 ]
%33 = phi i8* [ %113, %112 ], [ %3, %11 ]
%34 = phi i32 [ %57, %112 ], [ 0, %11 ]
%35 = phi i32 [ %50, %112 ], [ 0, %11 ]
%36 = phi i32 [ %43, %112 ], [ 0, %11 ]
%37 = add nsw i32 %36, %5
%38 = icmp slt i32 %37, %20
%39 = select i1 %38, i32 %19, i32 %20
%40 = xor i1 %38, true
%41 = zext i1 %40 to i32
%42 = add nsw i32 %18, %41
%43 = sub nsw i32 %37, %39
%44 = add nsw i32 %35, %6
%45 = icmp slt i32 %44, %23
%46 = select i1 %45, i32 %22, i32 %23
%47 = xor i1 %45, true
%48 = zext i1 %47 to i32
%49 = add nsw i32 %21, %48
%50 = sub nsw i32 %44, %46
%51 = add nsw i32 %34, %7
%52 = icmp slt i32 %51, %26
%53 = select i1 %52, i32 %25, i32 %26
%54 = xor i1 %52, true
%55 = zext i1 %54 to i32
%56 = add nsw i32 %24, %55
%57 = sub nsw i32 %51, %53
%58 = icmp ult i8* %29, %17
%59 = icmp sgt i32 %42, 0
%60 = select i1 %58, i1 %59, i1 false
br i1 %60, label %67, label %61
61: ; preds = %67, %28
%62 = phi i8* [ %31, %28 ], [ %73, %67 ]
%63 = phi i8* [ %29, %28 ], [ %71, %67 ]
%64 = icmp ult i8* %63, %17
%65 = icmp sgt i32 %49, 0
%66 = select i1 %64, i1 %65, i1 false
br i1 %66, label %86, label %80
67: ; preds = %28, %67
%68 = phi i8* [ %71, %67 ], [ %29, %28 ]
%69 = phi i32 [ %74, %67 ], [ 0, %28 ]
%70 = phi i8* [ %73, %67 ], [ %31, %28 ]
%71 = getelementptr inbounds i8, i8* %68, i64 1
%72 = load i8, i8* %68
%73 = getelementptr inbounds i8, i8* %70, i64 1
store i8 %72, i8* %70
%74 = add nuw nsw i32 %69, 1
%75 = load i32, i32* %8
%76 = add nsw i32 %75, 1
store i32 %76, i32* %8
%77 = icmp ult i8* %71, %17
%78 = icmp slt i32 %74, %42
%79 = select i1 %77, i1 %78, i1 false
br i1 %79, label %67, label %61
80: ; preds = %86, %61
%81 = phi i8* [ %32, %61 ], [ %92, %86 ]
%82 = phi i8* [ %63, %61 ], [ %90, %86 ]
%83 = icmp ult i8* %82, %17
%84 = icmp sgt i32 %56, 0
%85 = select i1 %83, i1 %84, i1 false
br i1 %85, label %99, label %112
86: ; preds = %61, %86
%87 = phi i8* [ %90, %86 ], [ %63, %61 ]
%88 = phi i32 [ %93, %86 ], [ 0, %61 ]
%89 = phi i8* [ %92, %86 ], [ %32, %61 ]
%90 = getelementptr inbounds i8, i8* %87, i64 1
%91 = load i8, i8* %87
%92 = getelementptr inbounds i8, i8* %89, i64 1
store i8 %91, i8* %89
%93 = add nuw nsw i32 %88, 1
%94 = load i32, i32* %9
%95 = add nsw i32 %94, 1
store i32 %95, i32* %9
%96 = icmp ult i8* %90, %17
%97 = icmp slt i32 %93, %49
%98 = select i1 %96, i1 %97, i1 false
br i1 %98, label %86, label %80
99: ; preds = %80, %99
%100 = phi i8* [ %103, %99 ], [ %82, %80 ]
%101 = phi i32 [ %106, %99 ], [ 0, %80 ]
%102 = phi i8* [ %105, %99 ], [ %33, %80 ]
%103 = getelementptr inbounds i8, i8* %100, i64 1
%104 = load i8, i8* %100
%105 = getelementptr inbounds i8, i8* %102, i64 1
store i8 %104, i8* %102
%106 = add nuw nsw i32 %101, 1
%107 = load i32, i32* %10
%108 = add nsw i32 %107, 1
store i32 %108, i32* %10
%109 = icmp ult i8* %103, %17
%110 = icmp slt i32 %106, %56
%111 = select i1 %109, i1 %110, i1 false
br i1 %111, label %99, label %112
112: ; preds = %99, %80
%113 = phi i8* [ %33, %80 ], [ %105, %99 ]
%114 = phi i8* [ %82, %80 ], [ %103, %99 ]
%115 = phi i1 [ %83, %80 ], [ %109, %99 ]
%116 = add nuw nsw i32 %30, 1
%117 = icmp slt i32 %116, %15
%118 = select i1 %115, i1 %117, i1 false
br i1 %118, label %28, label %119
119: ; preds = %112, %11
ret void
}