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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(int *);
int RGB_to_YUV420(unsigned char *rgb_input, unsigned char *y_output,
                  unsigned char *u_output, unsigned char *v_output, int width,
                  int height) {
  int R, G, B;
  int Y, U, V;
  int row;
  int col;
  int *uline;
  int *vline;
  int *ubuf;
  int *vbuf;
  int *ulineptr;
  int *vlineptr;
  int *ubufptr;
  int *vbufptr;
  int halfwidth;
  halfwidth = width >> 1;
  uline = vline = ubuf = vbuf = NULL;
  uline = (int *)calloc(width + 2, sizeof(int));
  vline = (int *)calloc(width + 2, sizeof(int));
  ubuf = (int *)calloc(halfwidth * (height + 2), sizeof(int));
  vbuf = (int *)calloc(halfwidth * (height + 2), sizeof(int));
  if (uline == NULL || vline == NULL || ubuf == NULL || vbuf == NULL) {
    free(uline);
    free(vline);
    free(ubuf);
    free(vbuf);
    return -1;
  }
  uline[0] = uline[width + 1] = 128;
  vline[0] = vline[width + 1] = 128;
  for (col = 0; col < halfwidth; col++) {
    ubuf[col] = ubuf[col + halfwidth * (height + 1)] = 128;
    vbuf[col] = ubuf[col + halfwidth * (height + 1)] = 128;
  }
  uline = uline + 1;
  vline = vline + 1;
  ubuf = ubuf + halfwidth;
  vbuf = vbuf + halfwidth;
  ubufptr = ubuf;
  vbufptr = vbuf;
  for (row = 0; row < height; row = row + 1) {
    ulineptr = uline;
    vlineptr = vline;
    for (col = 0; col < width; col++) {
      R = (int)(*(rgb_input++));
      G = (int)(*(rgb_input++));
      B = (int)(*(rgb_input++));
      Y = ((66 * R + 129 * G + 25 * B + 128) >> 8) + 16;
      U = ((-38 * R - 74 * G + 112 * B + 128) >> 8) + 128;
      V = ((112 * R - 94 * G - 18 * B + 128) >> 8) + 128;
      *(y_output++) = (unsigned char)((Y < 0) ? 0 : ((Y > 255) ? 255 : Y));
      *(ulineptr++) = U;
      *(vlineptr++) = V;
    }
    for (col = 0; col < width; col = col + 2) {
      *(ubufptr++) = (uline[col - 1] + 2 * uline[col] + uline[col + 1]) >> 2;
      *(vbufptr++) = (vline[col - 1] + 2 * vline[col] + vline[col + 1]) >> 2;
    }
  }
  ubufptr = ubuf;
  vbufptr = vbuf;
  for (row = 0; row < height; row = row + 2) {
    for (col = 0; col < halfwidth; col++) {
      U = (ubufptr[-halfwidth] + 2 * (*ubufptr) + ubufptr[+halfwidth]) >> 2;
      V = (vbufptr[-halfwidth] + 2 * (*vbufptr) + vbufptr[+halfwidth]) >> 2;
      *(u_output++) = (unsigned char)((U < 0) ? 0 : ((U > 255) ? 255 : U));
      *(v_output++) = (unsigned char)((V < 0) ? 0 : ((V > 255) ? 255 : V));
      ubufptr++;
      vbufptr++;
    }
    ubufptr += halfwidth;
    vbufptr += halfwidth;
  }
  uline = uline - 1;
  vline = vline - 1;
  ubuf = ubuf - halfwidth;
  vbuf = vbuf - halfwidth;
  free(uline);
  free(vline);
  free(ubuf);
  free(vbuf);
  return 0;
}


x86 assembly (clang, -O0):
<RGB_to_YUV420>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9d,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x94(%rbp)
movq   $0x0,-0x70(%rbp)
movq   $0x0,-0x68(%rbp)
movq   $0x0,-0x60(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x2c(%rbp),%edi
add    $0x2,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x2c(%rbp),%edi
add    $0x2,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x94(%rbp),%edi
mov    -0x30(%rbp),%eax
add    $0x2,%eax
imul   %eax,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x94(%rbp),%edi
mov    -0x30(%rbp),%eax
add    $0x2,%eax
imul   %eax,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x70(%rbp)
cmpq   $0x0,-0x58(%rbp)
je     11fd <RGB_to_YUV420+0xdd>
cmpq   $0x0,-0x60(%rbp)
je     11fd <RGB_to_YUV420+0xdd>
cmpq   $0x0,-0x68(%rbp)
je     11fd <RGB_to_YUV420+0xdd>
cmpq   $0x0,-0x70(%rbp)
jne    122d <RGB_to_YUV420+0x10d>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    17ee <RGB_to_YUV420+0x6ce>
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x80,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movl   $0x80,(%rax)
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x80,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movl   $0x80,(%rax)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x94(%rbp),%eax
jge    12ef <RGB_to_YUV420+0x1cf>
mov    -0x68(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    -0x94(%rbp),%edx
mov    -0x30(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movl   $0x80,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x50(%rbp),%rcx
movl   $0x80,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    -0x94(%rbp),%edx
mov    -0x30(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movl   $0x80,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0x50(%rbp),%rcx
movl   $0x80,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1270 <RGB_to_YUV420+0x150>
mov    -0x58(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x94(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1582 <RGB_to_YUV420+0x462>
mov    -0x58(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    14ba <RGB_to_YUV420+0x39a>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x3c(%rbp)
imul   $0x42,-0x34(%rbp),%eax
imul   $0x81,-0x38(%rbp),%ecx
add    %ecx,%eax
imul   $0x19,-0x3c(%rbp),%ecx
add    %ecx,%eax
add    $0x80,%eax
sar    $0x8,%eax
add    $0x10,%eax
mov    %eax,-0x40(%rbp)
imul   $0xffffffda,-0x34(%rbp),%eax
imul   $0x4a,-0x38(%rbp),%ecx
sub    %ecx,%eax
imul   $0x70,-0x3c(%rbp),%ecx
add    %ecx,%eax
add    $0x80,%eax
sar    $0x8,%eax
add    $0x80,%eax
mov    %eax,-0x44(%rbp)
imul   $0x70,-0x34(%rbp),%eax
imul   $0x5e,-0x38(%rbp),%ecx
sub    %ecx,%eax
imul   $0x12,-0x3c(%rbp),%ecx
sub    %ecx,%eax
add    $0x80,%eax
sar    $0x8,%eax
add    $0x80,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x40(%rbp)
jge    1439 <RGB_to_YUV420+0x319>
xor    %eax,%eax
mov    %eax,-0x98(%rbp)
jmp    146b <RGB_to_YUV420+0x34b>
cmpl   $0xff,-0x40(%rbp)
jle    1456 <RGB_to_YUV420+0x336>
mov    $0xff,%eax
mov    %eax,-0x9c(%rbp)
jmp    145f <RGB_to_YUV420+0x33f>
mov    -0x40(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x44(%rbp),%ecx
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x78(%rbp)
mov    %ecx,(%rax)
mov    -0x48(%rbp),%ecx
mov    -0x80(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x80(%rbp)
mov    %ecx,(%rax)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1373 <RGB_to_YUV420+0x253>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    156f <RGB_to_YUV420+0x44f>
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x58(%rbp),%rax
movslq -0x50(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
shl    $0x1,%eax
add    %eax,%ecx
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
add    (%rax,%rdx,4),%ecx
sar    $0x2,%ecx
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x88(%rbp)
mov    %ecx,(%rax)
mov    -0x60(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
shl    $0x1,%eax
add    %eax,%ecx
mov    -0x60(%rbp),%rax
mov    -0x50(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
add    (%rax,%rdx,4),%ecx
sar    $0x2,%ecx
mov    -0x90(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x90(%rbp)
mov    %ecx,(%rax)
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
jmp    14c1 <RGB_to_YUV420+0x3a1>
jmp    1574 <RGB_to_YUV420+0x454>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1350 <RGB_to_YUV420+0x230>
mov    -0x68(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1775 <RGB_to_YUV420+0x655>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x94(%rbp),%eax
jge    172b <RGB_to_YUV420+0x60b>
mov    -0x88(%rbp),%rax
xor    %ecx,%ecx
sub    -0x94(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x88(%rbp),%rcx
mov    (%rcx),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    -0x88(%rbp),%rcx
movslq -0x94(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
sar    $0x2,%eax
mov    %eax,-0x44(%rbp)
mov    -0x90(%rbp),%rax
xor    %ecx,%ecx
sub    -0x94(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x90(%rbp),%rcx
mov    (%rcx),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    -0x90(%rbp),%rcx
movslq -0x94(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
sar    $0x2,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x44(%rbp)
jge    164c <RGB_to_YUV420+0x52c>
xor    %eax,%eax
mov    %eax,-0xa0(%rbp)
jmp    167e <RGB_to_YUV420+0x55e>
cmpl   $0xff,-0x44(%rbp)
jle    1669 <RGB_to_YUV420+0x549>
mov    $0xff,%eax
mov    %eax,-0xa4(%rbp)
jmp    1672 <RGB_to_YUV420+0x552>
mov    -0x44(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
cmpl   $0x0,-0x48(%rbp)
jge    16ae <RGB_to_YUV420+0x58e>
xor    %eax,%eax
mov    %eax,-0xa8(%rbp)
jmp    16e0 <RGB_to_YUV420+0x5c0>
cmpl   $0xff,-0x48(%rbp)
jle    16cb <RGB_to_YUV420+0x5ab>
mov    $0xff,%eax
mov    %eax,-0xac(%rbp)
jmp    16d4 <RGB_to_YUV420+0x5b4>
mov    -0x48(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x88(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x88(%rbp)
mov    -0x90(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x90(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    15b2 <RGB_to_YUV420+0x492>
mov    -0x94(%rbp),%ecx
mov    -0x88(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x90(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x4c(%rbp)
jmp    159f <RGB_to_YUV420+0x47f>
mov    -0x58(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x94(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<RGB_to_YUV420>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r9d,%ebx
mov    %rcx,0x90(%rsp)
mov    %rdx,0x68(%rsp)
mov    %rsi,0x28(%rsp)
mov    %rdi,%r12
mov    %r8d,%ebp
sar    %ebp
mov    %r8,0x8(%rsp)
lea    0x2(%r8),%r14d
mov    %r14d,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,%r15
mov    %r14d,%edi
mov    %rbx,%r14
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,0x18(%rsp)
add    $0x2,%ebx
mov    %ebp,0x14(%rsp)
imul   %ebp,%ebx
mov    %ebx,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,%r13
mov    %ebx,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %r15,0x38(%rsp)
test   %r15,%r15
mov    %r13,0x50(%rsp)
mov    %rax,0x48(%rsp)
je     1228 <RGB_to_YUV420+0x108>
cmpq   $0x0,0x18(%rsp)
je     1228 <RGB_to_YUV420+0x108>
test   %r13,%r13
je     1228 <RGB_to_YUV420+0x108>
test   %rax,%rax
je     1228 <RGB_to_YUV420+0x108>
mov    0x8(%rsp),%rbx
movslq %ebx,%rdx
mov    0x38(%rsp),%rcx
movl   $0x80,0x4(%rcx,%rdx,4)
movl   $0x80,(%rcx)
mov    0x18(%rsp),%rcx
mov    %rdx,0x30(%rsp)
movl   $0x80,0x4(%rcx,%rdx,4)
movl   $0x80,(%rcx)
cmp    $0x2,%ebx
jl     1419 <RGB_to_YUV420+0x2f9>
lea    0x1(%r14),%ecx
mov    0x14(%rsp),%edx
imul   %edx,%ecx
movslq %ecx,%r8
cmp    $0x2,%edx
mov    $0x1,%ecx
cmovge %edx,%ecx
cmp    $0x8,%ecx
jae    1246 <RGB_to_YUV420+0x126>
xor    %esi,%esi
jmp    139b <RGB_to_YUV420+0x27b>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    $0xffffffff,%ebx
jmp    1c14 <RGB_to_YUV420+0xaf4>
lea    0x0(,%rcx,4),%rdx
add    %r13,%rdx
lea    0x0(%r13,%r8,4),%rsi
lea    (%r8,%rcx,1),%rdi
lea    0x0(,%rdi,4),%rdi
add    %r13,%rdi
lea    (%rax,%rcx,4),%rbp
cmp    %rdi,%r13
setb   %r9b
cmp    %rdx,%rsi
setb   %r10b
cmp    %rbp,%r13
setb   %bl
cmp    %rdx,%rax
setb   %r11b
cmp    %rbp,%rsi
setb   %dl
cmp    %rdi,%rax
setb   %dil
xor    %esi,%esi
test   %r10b,%r9b
jne    1396 <RGB_to_YUV420+0x276>
and    %r11b,%bl
mov    0x8(%rsp),%rbx
jne    139b <RGB_to_YUV420+0x27b>
and    %dil,%dl
jne    139b <RGB_to_YUV420+0x27b>
mov    %ecx,%esi
and    $0x7ffffff8,%esi
lea    -0x8(%rsi),%rdx
mov    %rdx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     138c <RGB_to_YUV420+0x26c>
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
lea    0x30(,%r8,4),%rbx
add    %r13,%rbx
xor    %edi,%edi
movdqa 0xd11(%rip),%xmm0
nop
movdqu %xmm0,0x0(%r13,%rdi,4)
movdqu %xmm0,0x10(%r13,%rdi,4)
movdqu %xmm0,-0x30(%rbx,%rdi,4)
movdqu %xmm0,-0x20(%rbx,%rdi,4)
movdqu %xmm0,(%rax,%rdi,4)
movdqu %xmm0,0x10(%rax,%rdi,4)
movdqu %xmm0,0x20(%r13,%rdi,4)
movdqu %xmm0,0x30(%r13,%rdi,4)
movdqu %xmm0,-0x10(%rbx,%rdi,4)
movdqu %xmm0,(%rbx,%rdi,4)
movdqu %xmm0,0x20(%rax,%rdi,4)
movdqu %xmm0,0x30(%rax,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rdx
jne    12f0 <RGB_to_YUV420+0x1d0>
test   $0x1,%bpl
je     137d <RGB_to_YUV420+0x25d>
lea    (%rdi,%r8,1),%rdx
movdqa 0xcaa(%rip),%xmm0
movdqu %xmm0,0x0(%r13,%rdi,4)
movdqu %xmm0,0x10(%r13,%rdi,4)
movdqu %xmm0,0x0(%r13,%rdx,4)
movdqu %xmm0,0x10(%r13,%rdx,4)
movdqu %xmm0,(%rax,%rdi,4)
movdqu %xmm0,0x10(%rax,%rdi,4)
cmp    %rcx,%rsi
mov    0x8(%rsp),%rbx
jne    139b <RGB_to_YUV420+0x27b>
jmp    1419 <RGB_to_YUV420+0x2f9>
xor    %edi,%edi
test   $0x1,%bpl
jne    134a <RGB_to_YUV420+0x22a>
jmp    137d <RGB_to_YUV420+0x25d>
mov    0x8(%rsp),%rbx
mov    %rsi,%rdi
not    %rdi
test   $0x1,%cl
je     13c7 <RGB_to_YUV420+0x2a7>
lea    (%rsi,%r8,1),%rdx
movl   $0x80,0x0(%r13,%rsi,4)
movl   $0x80,0x0(%r13,%rdx,4)
movl   $0x80,(%rax,%rsi,4)
or     $0x1,%rsi
add    %rcx,%rdi
je     1419 <RGB_to_YUV420+0x2f9>
lea    0x4(,%r8,4),%rdx
add    %r13,%rdx
nopw   0x0(%rax,%rax,1)
movl   $0x80,0x0(%r13,%rsi,4)
movl   $0x80,-0x4(%rdx,%rsi,4)
movl   $0x80,(%rax,%rsi,4)
movl   $0x80,0x4(%r13,%rsi,4)
movl   $0x80,(%rdx,%rsi,4)
movl   $0x80,0x4(%rax,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rcx
jne    13e0 <RGB_to_YUV420+0x2c0>
test   %r14d,%r14d
jle    1bfe <RGB_to_YUV420+0xade>
mov    0x38(%rsp),%r11
lea    0x4(%r11),%r9
mov    0x18(%rsp),%r13
lea    0x4(%r13),%r15
movslq 0x14(%rsp),%r10
mov    0x50(%rsp),%rax
lea    (%rax,%r10,4),%rax
mov    %rax,0x70(%rsp)
mov    0x30(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,%rbp
shr    %rbp
add    $0x1,%rbp
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
mov    %rcx,0xf8(%rsp)
and    %rcx,%rax
lea    -0x1(%rbx),%edi
lea    0x1(%rdi),%rdx
lea    (%r11,%rdi,4),%rsi
add    $0x8,%rsi
lea    0x8(,%rdi,4),%rcx
add    %r13,%rcx
mov    %rcx,0xd8(%rsp)
cmp    %rcx,%r9
setb   %r8b
mov    %rsi,0xe0(%rsp)
cmp    %rsi,%r15
setb   %cl
and    %r8b,%cl
mov    %cl,0x11(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x60(%rsp)
mov    %rdx,%rsi
and    $0xfffffffffffffffc,%rsi
mov    %ebp,%ecx
and    $0x3,%ecx
test   %rcx,%rcx
mov    $0x4,%edx
cmovne %rcx,%rdx
mov    %rbp,0xc8(%rsp)
sub    %rdx,%rbp
lea    (%r11,%rax,4),%rcx
add    $0xc,%rcx
mov    %rcx,0xc0(%rsp)
lea    0xc(%r13,%rax,4),%rax
mov    %rax,0xb8(%rsp)
movdqa 0xb13(%rip),%xmm0
movdqa 0xb1a(%rip),%xmm8
movdqa 0xb21(%rip),%xmm9
movdqa 0xae9(%rip),%xmm3
movdqa 0xb20(%rip),%xmm10
movdqa 0xb27(%rip),%xmm11
movdqa 0xb2e(%rip),%xmm12
movdqa 0xb35(%rip),%xmm13
movdqa 0xb3c(%rip),%xmm14
mov    0x48(%rsp),%rax
mov    %r10,0x58(%rsp)
lea    (%rax,%r10,4),%r8
mov    %rdi,0x100(%rsp)
lea    0x3(%rdi,%rdi,2),%rax
mov    %rax,0xd0(%rsp)
lea    (%r15,%rsi,4),%rax
mov    %rax,0xa8(%rsp)
lea    (%r9,%rsi,4),%rax
mov    %rax,0xa0(%rsp)
mov    %rsi,0xb0(%rsp)
lea    (%rsi,%rsi,2),%rax
mov    %rax,0x98(%rsp)
mov    %rbp,0x88(%rsp)
lea    0x0(%rbp,%rbp,1),%rax
mov    %rax,0x80(%rsp)
lea    0x8(%r13),%rax
mov    %rax,0xf0(%rsp)
lea    0x8(%r11),%rax
mov    %rax,0xe8(%rsp)
xor    %eax,%eax
mov    %r8,0x78(%rsp)
mov    0x70(%rsp),%r10
mov    %r14,0x40(%rsp)
mov    %r9,0x20(%rsp)
mov    0x28(%rsp),%r11
jmp    15f7 <RGB_to_YUV420+0x4d7>
nopl   (%rax)
mov    %r12,%r13
add    $0x1,%eax
mov    %r13,%r12
cmp    %r14d,%eax
mov    0x70(%rsp),%rsi
je     1b02 <RGB_to_YUV420+0x9e2>
test   %ebx,%ebx
jle    15e0 <RGB_to_YUV420+0x4c0>
mov    %rax,0x28(%rsp)
xor    %ecx,%ecx
cmpl   $0x3,0x100(%rsp)
03
jae    1620 <RGB_to_YUV420+0x500>
mov    %r15,%r14
mov    %r12,%r13
jmp    19c7 <RGB_to_YUV420+0x8a7>
nopw   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rax
add    %r11,%rax
mov    0xe0(%rsp),%r14
cmp    %r14,%r11
mov    %r11,%rdi
setb   %cl
cmp    %r9,%rax
seta   %dl
mov    0xd0(%rsp),%rsi
add    %r12,%rsi
and    %cl,%dl
mov    0xd8(%rsp),%rbp
cmp    %rbp,%r11
setb   %cl
cmp    %r15,%rax
seta   %bl
and    %cl,%bl
or     %dl,%bl
cmp    %rsi,%r11
setb   %cl
cmp    %rax,%r12
setb   %dl
and    %cl,%dl
or     %bl,%dl
or     0x11(%rsp),%dl
cmp    %r9,%rsi
seta   %al
cmp    %r14,%r12
setb   %bl
cmp    %r15,%rsi
seta   %cl
cmp    %rbp,%r12
setb   %sil
test   %dl,%dl
jne    19ba <RGB_to_YUV420+0x89a>
and    %bl,%al
jne    19ba <RGB_to_YUV420+0x89a>
and    %sil,%cl
jne    19ba <RGB_to_YUV420+0x89a>
mov    0x98(%rsp),%rax
lea    (%r12,%rax,1),%r13
mov    0xb0(%rsp),%rax
mov    %r11,%rcx
add    %rax,%r11
xor    %edi,%edi
mov    0x8(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movsd  (%r12),%xmm2
movss  0x8(%r12),%xmm4
shufps $0x30,%xmm2,%xmm4
shufps $0x84,%xmm4,%xmm2
movaps %xmm2,%xmm4
shufps $0x64,%xmm2,%xmm4
pshufhw $0xec,%xmm4,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpcklbw %xmm4,%xmm4
pshuflw $0xf4,%xmm4,%xmm4
pshufhw $0xd6,%xmm4,%xmm5
pand   %xmm0,%xmm5
pshuflw $0xe6,%xmm2,%xmm4
shufps $0x24,%xmm2,%xmm2
pshufhw $0xe6,%xmm2,%xmm2
pshufd $0xe6,%xmm2,%xmm2
punpcklbw %xmm2,%xmm2
pshufd $0xd8,%xmm2,%xmm2
pshuflw $0xe5,%xmm2,%xmm2
pshufhw $0xc7,%xmm2,%xmm1
pand   %xmm0,%xmm1
pshufd $0xe8,%xmm4,%xmm2
punpcklbw %xmm2,%xmm2
pshuflw $0xd6,%xmm2,%xmm2
pshufhw $0xf4,%xmm2,%xmm4
pand   %xmm0,%xmm4
pshuflw $0xe8,%xmm5,%xmm7
pmaddwd %xmm8,%xmm5
movdqa %xmm1,%xmm6
pslld  $0x7,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm4,%xmm2
pmaddwd %xmm9,%xmm2
paddd  %xmm6,%xmm2
paddd  %xmm5,%xmm2
paddd  %xmm3,%xmm2
psrld  $0x8,%xmm2
movdqa %xmm4,%xmm5
pmaddwd %xmm10,%xmm5
pshufhw $0xe8,%xmm7,%xmm6
pshufd $0xe8,%xmm6,%xmm6
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklwd %xmm1,%xmm6
movdqa %xmm6,%xmm1
pmaddwd %xmm11,%xmm1
paddd  %xmm3,%xmm5
paddd  %xmm1,%xmm5
psrad  $0x8,%xmm5
paddd  %xmm3,%xmm5
pmaddwd %xmm12,%xmm4
pmaddwd %xmm13,%xmm6
paddd  %xmm3,%xmm4
paddd  %xmm6,%xmm4
psrad  $0x8,%xmm4
paddd  %xmm3,%xmm4
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm14,%xmm2
movd   %xmm2,(%rcx,%rdi,1)
movdqu %xmm5,(%r9,%rdi,4)
movdqu %xmm4,(%r15,%rdi,4)
add    $0x4,%rdi
add    $0xc,%r12
cmp    %rdi,%rax
jne    16d0 <RGB_to_YUV420+0x5b0>
mov    0xa8(%rsp),%r14
mov    0xa0(%rsp),%r9
mov    %eax,%ecx
cmp    %rax,0x60(%rsp)
jne    19c7 <RGB_to_YUV420+0x8a7>
cs nopw 0x0(%rax,%rax,1)
nop
test   %ebx,%ebx
jle    1a5d <RGB_to_YUV420+0x93d>
cmpq   $0x7,0xf8(%rsp)
ja     1859 <RGB_to_YUV420+0x739>
xor    %eax,%eax
mov    0x40(%rsp),%r14
mov    0x30(%rsp),%rbp
mov    0x20(%rsp),%r9
jmp    1a80 <RGB_to_YUV420+0x960>
mov    0xc8(%rsp),%rax
lea    (%r10,%rax,4),%rdx
lea    (%r8,%rax,4),%rbp
cmp    %rbp,%r10
setb   0x13(%rsp)
cmp    %rdx,%r8
setb   %r12b
mov    0xc0(%rsp),%r9
cmp    %r9,%r10
setb   %al
mov    0x38(%rsp),%rbx
cmp    %rdx,%rbx
setb   %sil
mov    0xb8(%rsp),%r14
cmp    %r14,%r10
setb   %cl
mov    0x18(%rsp),%rdi
cmp    %rdx,%rdi
setb   0x12(%rsp)
cmp    %r9,%r8
setb   %dl
cmp    %rbp,%rbx
setb   %r9b
cmp    %r14,%r8
setb   %bl
cmp    %rbp,%rdi
setb   %dil
test   %r12b,0x13(%rsp)
jne    1ae5 <RGB_to_YUV420+0x9c5>
and    %sil,%al
jne    1ae5 <RGB_to_YUV420+0x9c5>
and    0x12(%rsp),%cl
mov    0x40(%rsp),%r14
mov    0x30(%rsp),%rbp
jne    1af6 <RGB_to_YUV420+0x9d6>
and    %r9b,%dl
mov    0x20(%rsp),%r9
jne    1a71 <RGB_to_YUV420+0x951>
and    %dil,%bl
jne    1a71 <RGB_to_YUV420+0x951>
mov    0x88(%rsp),%rdx
lea    (%r8,%rdx,4),%rcx
lea    (%r10,%rdx,4),%rdi
xor    %eax,%eax
mov    0x8(%rsp),%rbx
nopl   (%rax)
movups -0x4(%r9,%rax,8),%xmm1
movups (%r9,%rax,8),%xmm2
movups 0xc(%r9,%rax,8),%xmm4
shufps $0x88,%xmm4,%xmm1
movups 0x10(%r9,%rax,8),%xmm4
movaps %xmm2,%xmm5
shufps $0x88,%xmm4,%xmm5
shufps $0xdd,%xmm4,%xmm2
paddd  %xmm1,%xmm2
paddd  %xmm5,%xmm5
paddd  %xmm2,%xmm5
psrad  $0x2,%xmm5
movdqu %xmm5,(%r10,%rax,4)
movups -0x4(%r15,%rax,8),%xmm1
movups (%r15,%rax,8),%xmm2
movups 0xc(%r15,%rax,8),%xmm4
shufps $0x88,%xmm4,%xmm1
movups 0x10(%r15,%rax,8),%xmm4
movaps %xmm2,%xmm5
shufps $0x88,%xmm4,%xmm5
shufps $0xdd,%xmm4,%xmm2
paddd  %xmm1,%xmm2
paddd  %xmm5,%xmm5
paddd  %xmm2,%xmm5
psrad  $0x2,%xmm5
movdqu %xmm5,(%r8,%rax,4)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1920 <RGB_to_YUV420+0x800>
mov    0x80(%rsp),%rax
mov    %rcx,%r8
mov    %rdi,%r10
jmp    1a80 <RGB_to_YUV420+0x960>
mov    %r15,%r14
mov    %r12,%r13
mov    0x8(%rsp),%rbx
xor    %ecx,%ecx
mov    %ebx,%r12d
sub    %ecx,%r12d
xor    %ecx,%ecx
nop
movzbl 0x0(%r13),%ebp
movzbl 0x1(%r13),%edx
movzbl 0x2(%r13),%esi
add    $0x3,%r13
mov    %ebp,%ebx
shl    $0x6,%ebx
lea    (%rbx,%rbp,2),%ebx
mov    %edx,%edi
shl    $0x7,%edi
add    %edx,%edi
add    %ebx,%edi
lea    (%rsi,%rsi,4),%ebx
lea    (%rbx,%rbx,4),%ebx
add    %edi,%ebx
add    $0x80,%ebx
shr    $0x8,%ebx
imul   $0xffffffda,%ebp,%edi
imul   $0xffffffb6,%edx,%eax
add    %edi,%eax
imul   $0x70,%esi,%edi
add    %edi,%eax
add    $0x80,%eax
sar    $0x8,%eax
sub    $0xffffff80,%eax
imul   $0x70,%ebp,%edi
imul   $0xffffffa2,%edx,%edx
add    %edi,%edx
add    %esi,%esi
lea    (%rsi,%rsi,8),%esi
sub    %esi,%edx
sub    $0xffffff80,%edx
sar    $0x8,%edx
sub    $0xffffff80,%edx
add    $0x10,%bl
mov    %bl,(%r11,%rcx,1)
mov    %eax,(%r9,%rcx,4)
mov    %edx,(%r14,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%r12d
jne    19d0 <RGB_to_YUV420+0x8b0>
add    %rcx,%r11
mov    0x8(%rsp),%rbx
test   %ebx,%ebx
jg     1838 <RGB_to_YUV420+0x718>
mov    0x40(%rsp),%r14
mov    0x20(%rsp),%r9
mov    0x28(%rsp),%rax
jmp    15e3 <RGB_to_YUV420+0x4c3>
xor    %eax,%eax
mov    0x8(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
mov    0xf0(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
mov    0xe8(%rsp),%rcx
lea    (%rcx,%rax,4),%rdx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    -0x4(%rdx,%rcx,2),%edi
add    %edi,%edi
add    -0x8(%rdx,%rcx,2),%edi
add    (%rdx,%rcx,2),%edi
sar    $0x2,%edi
mov    %edi,(%r10,%rcx,1)
mov    -0x4(%rsi,%rcx,2),%edi
add    %edi,%edi
add    -0x8(%rsi,%rcx,2),%edi
add    (%rsi,%rcx,2),%edi
sar    $0x2,%edi
mov    %edi,(%r8,%rcx,1)
add    $0x2,%rax
add    $0x4,%rcx
cmp    %rbp,%rax
jl     1aa0 <RGB_to_YUV420+0x980>
add    %rcx,%r8
add    %rcx,%r10
mov    0x28(%rsp),%rax
jmp    15e3 <RGB_to_YUV420+0x4c3>
xor    %eax,%eax
mov    0x40(%rsp),%r14
mov    0x8(%rsp),%rbx
jmp    184a <RGB_to_YUV420+0x72a>
xor    %eax,%eax
mov    0x8(%rsp),%rbx
jmp    184f <RGB_to_YUV420+0x72f>
test   %r14d,%r14d
mov    0x90(%rsp),%r15
mov    0x58(%rsp),%rdx
mov    0x78(%rsp),%rdi
jle    1bfe <RGB_to_YUV420+0xade>
mov    0x14(%rsp),%ecx
mov    %ecx,%eax
neg    %eax
cltq
mov    %rax,0x28(%rsp)
cmp    $0x2,%ecx
mov    $0x1,%r8d
cmovge %ecx,%r8d
xor    %r11d,%r11d
jmp    1b73 <RGB_to_YUV420+0xa53>
xchg   %ax,%ax
mov    %r9,%rdi
sub    %rbp,%rdi
sub    %rbp,%rsi
add    %rcx,%rbx
mov    %rbx,0x68(%rsp)
add    %rcx,%r15
mov    0x8(%rsp),%rbx
mov    0x58(%rsp),%rdx
lea    (%rsi,%rdx,4),%rsi
lea    (%rdi,%rdx,4),%rdi
add    $0x2,%r11d
cmp    %r14d,%r11d
jge    1bfe <RGB_to_YUV420+0xade>
cmp    $0x2,%ebx
jl     1b5e <RGB_to_YUV420+0xa3e>
mov    0x28(%rsp),%rax
lea    (%rdi,%rax,4),%r10
mov    %rdi,%r9
lea    (%rdi,%rdx,4),%r12
lea    (%rsi,%rax,4),%r13
lea    (%rsi,%rdx,4),%rax
xor    %ebp,%ebp
xor    %ecx,%ecx
mov    0x68(%rsp),%rbx
jmp    1bb1 <RGB_to_YUV420+0xa91>
nopl   0x0(%rax,%rax,1)
mov    %dl,(%r15,%rcx,1)
add    $0x1,%rcx
add    $0xfffffffffffffffc,%rbp
cmp    %ecx,%r8d
je     1b40 <RGB_to_YUV420+0xa20>
mov    (%rsi,%rcx,4),%edi
add    %edi,%edi
add    0x0(%r13,%rcx,4),%edi
add    (%rax,%rcx,4),%edi
mov    (%r9,%rcx,4),%edx
add    %edx,%edx
add    (%r10,%rcx,4),%edx
sar    $0x2,%edi
add    (%r12,%rcx,4),%edx
cmp    $0xff,%edi
jl     1bdc <RGB_to_YUV420+0xabc>
mov    $0xff,%edi
sar    $0x2,%edx
test   %edi,%edi
jg     1be5 <RGB_to_YUV420+0xac5>
xor    %edi,%edi
mov    %dil,(%rbx,%rcx,1)
cmp    $0xff,%edx
jl     1bf6 <RGB_to_YUV420+0xad6>
mov    $0xff,%edx
test   %edx,%edx
jg     1ba0 <RGB_to_YUV420+0xa80>
xor    %edx,%edx
jmp    1ba0 <RGB_to_YUV420+0xa80>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
xor    %ebx,%ebx
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %ebx,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @RGB_to_YUV420(i8* %0, i8* %1, i8* %2, i8* %3, i32 %4, i32 %5) {
%7 = alloca i32
%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
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
%31 = load i32, i32* %12
%32 = ashr i32 %31, 1
store i32 %32, i32* %30
store i32* null, i32** %25
store i32* null, i32** %24
store i32* null, i32** %23
store i32* null, i32** %22
%33 = load i32, i32* %12
%34 = add nsw i32 %33, 2
%35 = call i64 @calloc(i32 %34, i32 4)
%36 = inttoptr i64 %35 to i32*
store i32* %36, i32** %22
%37 = load i32, i32* %12
%38 = add nsw i32 %37, 2
%39 = call i64 @calloc(i32 %38, i32 4)
%40 = inttoptr i64 %39 to i32*
store i32* %40, i32** %23
%41 = load i32, i32* %30
%42 = load i32, i32* %13
%43 = add nsw i32 %42, 2
%44 = mul nsw i32 %41, %43
%45 = call i64 @calloc(i32 %44, i32 4)
%46 = inttoptr i64 %45 to i32*
store i32* %46, i32** %24
%47 = load i32, i32* %30
%48 = load i32, i32* %13
%49 = add nsw i32 %48, 2
%50 = mul nsw i32 %47, %49
%51 = call i64 @calloc(i32 %50, i32 4)
%52 = inttoptr i64 %51 to i32*
store i32* %52, i32** %25
%53 = load i32*, i32** %22
%54 = icmp eq i32* %53, null
br i1 %54, label %64, label %55
55: ; preds = %6
%56 = load i32*, i32** %23
%57 = icmp eq i32* %56, null
br i1 %57, label %64, label %58
58: ; preds = %55
%59 = load i32*, i32** %24
%60 = icmp eq i32* %59, null
br i1 %60, label %64, label %61
61: ; preds = %58
%62 = load i32*, i32** %25
%63 = icmp eq i32* %62, null
br i1 %63, label %64, label %73
64: ; preds = %61, %58, %55, %6
%65 = load i32*, i32** %22
%66 = call i32 @free(i32* %65)
%67 = load i32*, i32** %23
%68 = call i32 @free(i32* %67)
%69 = load i32*, i32** %24
%70 = call i32 @free(i32* %69)
%71 = load i32*, i32** %25
%72 = call i32 @free(i32* %71)
store i32 -1, i32* %7
br label %399
73: ; preds = %61
%74 = load i32*, i32** %22
%75 = load i32, i32* %12
%76 = add nsw i32 %75, 1
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i32, i32* %74, i64 %77
store i32 128, i32* %78
%79 = load i32*, i32** %22
%80 = getelementptr inbounds i32, i32* %79, i64 0
store i32 128, i32* %80
%81 = load i32*, i32** %23
%82 = load i32, i32* %12
%83 = add nsw i32 %82, 1
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %81, i64 %84
store i32 128, i32* %85
%86 = load i32*, i32** %23
%87 = getelementptr inbounds i32, i32* %86, i64 0
store i32 128, i32* %87
store i32 0, i32* %21
br label %88
88: ; preds = %119, %73
%89 = load i32, i32* %21
%90 = load i32, i32* %30
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %122
92: ; preds = %88
%93 = load i32*, i32** %24
%94 = load i32, i32* %21
%95 = load i32, i32* %30
%96 = load i32, i32* %13
%97 = add nsw i32 %96, 1
%98 = mul nsw i32 %95, %97
%99 = add nsw i32 %94, %98
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i32, i32* %93, i64 %100
store i32 128, i32* %101
%102 = load i32*, i32** %24
%103 = load i32, i32* %21
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i32, i32* %102, i64 %104
store i32 128, i32* %105
%106 = load i32*, i32** %24
%107 = load i32, i32* %21
%108 = load i32, i32* %30
%109 = load i32, i32* %13
%110 = add nsw i32 %109, 1
%111 = mul nsw i32 %108, %110
%112 = add nsw i32 %107, %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %106, i64 %113
store i32 128, i32* %114
%115 = load i32*, i32** %25
%116 = load i32, i32* %21
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i32, i32* %115, i64 %117
store i32 128, i32* %118
br label %119
119: ; preds = %92
%120 = load i32, i32* %21
%121 = add nsw i32 %120, 1
store i32 %121, i32* %21
br label %88
122: ; preds = %88
%123 = load i32*, i32** %22
%124 = getelementptr inbounds i32, i32* %123, i64 1
store i32* %124, i32** %22
%125 = load i32*, i32** %23
%126 = getelementptr inbounds i32, i32* %125, i64 1
store i32* %126, i32** %23
%127 = load i32*, i32** %24
%128 = load i32, i32* %30
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i32, i32* %127, i64 %129
store i32* %130, i32** %24
%131 = load i32*, i32** %25
%132 = load i32, i32* %30
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i32, i32* %131, i64 %133
store i32* %134, i32** %25
%135 = load i32*, i32** %24
store i32* %135, i32** %28
%136 = load i32*, i32** %25
store i32* %136, i32** %29
store i32 0, i32* %20
br label %137
137: ; preds = %275, %122
%138 = load i32, i32* %20
%139 = load i32, i32* %13
%140 = icmp slt i32 %138, %139
br i1 %140, label %141, label %278
141: ; preds = %137
%142 = load i32*, i32** %22
store i32* %142, i32** %26
%143 = load i32*, i32** %23
store i32* %143, i32** %27
store i32 0, i32* %21
br label %144
144: ; preds = %216, %141
%145 = load i32, i32* %21
%146 = load i32, i32* %12
%147 = icmp slt i32 %145, %146
br i1 %147, label %148, label %219
148: ; preds = %144
%149 = load i8*, i8** %8
%150 = getelementptr inbounds i8, i8* %149, i32 1
store i8* %150, i8** %8
%151 = load i8, i8* %149
%152 = zext i8 %151 to i32
store i32 %152, i32* %14
%153 = load i8*, i8** %8
%154 = getelementptr inbounds i8, i8* %153, i32 1
store i8* %154, i8** %8
%155 = load i8, i8* %153
%156 = zext i8 %155 to i32
store i32 %156, i32* %15
%157 = load i8*, i8** %8
%158 = getelementptr inbounds i8, i8* %157, i32 1
store i8* %158, i8** %8
%159 = load i8, i8* %157
%160 = zext i8 %159 to i32
store i32 %160, i32* %16
%161 = load i32, i32* %14
%162 = mul nsw i32 66, %161
%163 = load i32, i32* %15
%164 = mul nsw i32 129, %163
%165 = add nsw i32 %162, %164
%166 = load i32, i32* %16
%167 = mul nsw i32 25, %166
%168 = add nsw i32 %165, %167
%169 = add nsw i32 %168, 128
%170 = ashr i32 %169, 8
%171 = add nsw i32 %170, 16
store i32 %171, i32* %17
%172 = load i32, i32* %14
%173 = mul nsw i32 -38, %172
%174 = load i32, i32* %15
%175 = mul nsw i32 74, %174
%176 = sub nsw i32 %173, %175
%177 = load i32, i32* %16
%178 = mul nsw i32 112, %177
%179 = add nsw i32 %176, %178
%180 = add nsw i32 %179, 128
%181 = ashr i32 %180, 8
%182 = add nsw i32 %181, 128
store i32 %182, i32* %18
%183 = load i32, i32* %14
%184 = mul nsw i32 112, %183
%185 = load i32, i32* %15
%186 = mul nsw i32 94, %185
%187 = sub nsw i32 %184, %186
%188 = load i32, i32* %16
%189 = mul nsw i32 18, %188
%190 = sub nsw i32 %187, %189
%191 = add nsw i32 %190, 128
%192 = ashr i32 %191, 8
%193 = add nsw i32 %192, 128
store i32 %193, i32* %19
%194 = load i32, i32* %17
%195 = icmp slt i32 %194, 0
br i1 %195, label %196, label %197
196: ; preds = %148
br label %205
197: ; preds = %148
%198 = load i32, i32* %17
%199 = icmp sgt i32 %198, 255
br i1 %199, label %200, label %201
200: ; preds = %197
br label %203
201: ; preds = %197
%202 = load i32, i32* %17
br label %203
203: ; preds = %201, %200
%204 = phi i32 [ 255, %200 ], [ %202, %201 ]
br label %205
205: ; preds = %203, %196
%206 = phi i32 [ 0, %196 ], [ %204, %203 ]
%207 = trunc i32 %206 to i8
%208 = load i8*, i8** %9
%209 = getelementptr inbounds i8, i8* %208, i32 1
store i8* %209, i8** %9
store i8 %207, i8* %208
%210 = load i32, i32* %18
%211 = load i32*, i32** %26
%212 = getelementptr inbounds i32, i32* %211, i32 1
store i32* %212, i32** %26
store i32 %210, i32* %211
%213 = load i32, i32* %19
%214 = load i32*, i32** %27
%215 = getelementptr inbounds i32, i32* %214, i32 1
store i32* %215, i32** %27
store i32 %213, i32* %214
br label %216
216: ; preds = %205
%217 = load i32, i32* %21
%218 = add nsw i32 %217, 1
store i32 %218, i32* %21
br label %144
219: ; preds = %144
store i32 0, i32* %21
br label %220
220: ; preds = %271, %219
%221 = load i32, i32* %21
%222 = load i32, i32* %12
%223 = icmp slt i32 %221, %222
br i1 %223, label %224, label %274
224: ; preds = %220
%225 = load i32*, i32** %22
%226 = load i32, i32* %21
%227 = sub nsw i32 %226, 1
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i32, i32* %225, i64 %228
%230 = load i32, i32* %229
%231 = load i32*, i32** %22
%232 = load i32, i32* %21
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds i32, i32* %231, i64 %233
%235 = load i32, i32* %234
%236 = mul nsw i32 2, %235
%237 = add nsw i32 %230, %236
%238 = load i32*, i32** %22
%239 = load i32, i32* %21
%240 = add nsw i32 %239, 1
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32, i32* %238, i64 %241
%243 = load i32, i32* %242
%244 = add nsw i32 %237, %243
%245 = ashr i32 %244, 2
%246 = load i32*, i32** %28
%247 = getelementptr inbounds i32, i32* %246, i32 1
store i32* %247, i32** %28
store i32 %245, i32* %246
%248 = load i32*, i32** %23
%249 = load i32, i32* %21
%250 = sub nsw i32 %249, 1
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i32, i32* %248, i64 %251
%253 = load i32, i32* %252
%254 = load i32*, i32** %23
%255 = load i32, i32* %21
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds i32, i32* %254, i64 %256
%258 = load i32, i32* %257
%259 = mul nsw i32 2, %258
%260 = add nsw i32 %253, %259
%261 = load i32*, i32** %23
%262 = load i32, i32* %21
%263 = add nsw i32 %262, 1
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i32, i32* %261, i64 %264
%266 = load i32, i32* %265
%267 = add nsw i32 %260, %266
%268 = ashr i32 %267, 2
%269 = load i32*, i32** %29
%270 = getelementptr inbounds i32, i32* %269, i32 1
store i32* %270, i32** %29
store i32 %268, i32* %269
br label %271
271: ; preds = %224
%272 = load i32, i32* %21
%273 = add nsw i32 %272, 2
store i32 %273, i32* %21
br label %220
274: ; preds = %220
br label %275
275: ; preds = %274
%276 = load i32, i32* %20
%277 = add nsw i32 %276, 1
store i32 %277, i32* %20
br label %137
278: ; preds = %137
%279 = load i32*, i32** %24
store i32* %279, i32** %28
%280 = load i32*, i32** %25
store i32* %280, i32** %29
store i32 0, i32* %20
br label %281
281: ; preds = %373, %278
%282 = load i32, i32* %20
%283 = load i32, i32* %13
%284 = icmp slt i32 %282, %283
br i1 %284, label %285, label %376
285: ; preds = %281
store i32 0, i32* %21
br label %286
286: ; preds = %361, %285
%287 = load i32, i32* %21
%288 = load i32, i32* %30
%289 = icmp slt i32 %287, %288
br i1 %289, label %290, label %364
290: ; preds = %286
%291 = load i32*, i32** %28
%292 = load i32, i32* %30
%293 = sub nsw i32 0, %292
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds i32, i32* %291, i64 %294
%296 = load i32, i32* %295
%297 = load i32*, i32** %28
%298 = load i32, i32* %297
%299 = mul nsw i32 2, %298
%300 = add nsw i32 %296, %299
%301 = load i32*, i32** %28
%302 = load i32, i32* %30
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds i32, i32* %301, i64 %303
%305 = load i32, i32* %304
%306 = add nsw i32 %300, %305
%307 = ashr i32 %306, 2
store i32 %307, i32* %18
%308 = load i32*, i32** %29
%309 = load i32, i32* %30
%310 = sub nsw i32 0, %309
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds i32, i32* %308, i64 %311
%313 = load i32, i32* %312
%314 = load i32*, i32** %29
%315 = load i32, i32* %314
%316 = mul nsw i32 2, %315
%317 = add nsw i32 %313, %316
%318 = load i32*, i32** %29
%319 = load i32, i32* %30
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds i32, i32* %318, i64 %320
%322 = load i32, i32* %321
%323 = add nsw i32 %317, %322
%324 = ashr i32 %323, 2
store i32 %324, i32* %19
%325 = load i32, i32* %18
%326 = icmp slt i32 %325, 0
br i1 %326, label %327, label %328
327: ; preds = %290
br label %336
328: ; preds = %290
%329 = load i32, i32* %18
%330 = icmp sgt i32 %329, 255
br i1 %330, label %331, label %332
331: ; preds = %328
br label %334
332: ; preds = %328
%333 = load i32, i32* %18
br label %334
334: ; preds = %332, %331
%335 = phi i32 [ 255, %331 ], [ %333, %332 ]
br label %336
336: ; preds = %334, %327
%337 = phi i32 [ 0, %327 ], [ %335, %334 ]
%338 = trunc i32 %337 to i8
%339 = load i8*, i8** %10
%340 = getelementptr inbounds i8, i8* %339, i32 1
store i8* %340, i8** %10
store i8 %338, i8* %339
%341 = load i32, i32* %19
%342 = icmp slt i32 %341, 0
br i1 %342, label %343, label %344
343: ; preds = %336
br label %352
344: ; preds = %336
%345 = load i32, i32* %19
%346 = icmp sgt i32 %345, 255
br i1 %346, label %347, label %348
347: ; preds = %344
br label %350
348: ; preds = %344
%349 = load i32, i32* %19
br label %350
350: ; preds = %348, %347
%351 = phi i32 [ 255, %347 ], [ %349, %348 ]
br label %352
352: ; preds = %350, %343
%353 = phi i32 [ 0, %343 ], [ %351, %350 ]
%354 = trunc i32 %353 to i8
%355 = load i8*, i8** %11
%356 = getelementptr inbounds i8, i8* %355, i32 1
store i8* %356, i8** %11
store i8 %354, i8* %355
%357 = load i32*, i32** %28
%358 = getelementptr inbounds i32, i32* %357, i32 1
store i32* %358, i32** %28
%359 = load i32*, i32** %29
%360 = getelementptr inbounds i32, i32* %359, i32 1
store i32* %360, i32** %29
br label %361
361: ; preds = %352
%362 = load i32, i32* %21
%363 = add nsw i32 %362, 1
store i32 %363, i32* %21
br label %286
364: ; preds = %286
%365 = load i32, i32* %30
%366 = load i32*, i32** %28
%367 = sext i32 %365 to i64
%368 = getelementptr inbounds i32, i32* %366, i64 %367
store i32* %368, i32** %28
%369 = load i32, i32* %30
%370 = load i32*, i32** %29
%371 = sext i32 %369 to i64
%372 = getelementptr inbounds i32, i32* %370, i64 %371
store i32* %372, i32** %29
br label %373
373: ; preds = %364
%374 = load i32, i32* %20
%375 = add nsw i32 %374, 2
store i32 %375, i32* %20
br label %281
376: ; preds = %281
%377 = load i32*, i32** %22
%378 = getelementptr inbounds i32, i32* %377, i64 -1
store i32* %378, i32** %22
%379 = load i32*, i32** %23
%380 = getelementptr inbounds i32, i32* %379, i64 -1
store i32* %380, i32** %23
%381 = load i32*, i32** %24
%382 = load i32, i32* %30
%383 = sext i32 %382 to i64
%384 = sub i64 0, %383
%385 = getelementptr inbounds i32, i32* %381, i64 %384
store i32* %385, i32** %24
%386 = load i32*, i32** %25
%387 = load i32, i32* %30
%388 = sext i32 %387 to i64
%389 = sub i64 0, %388
%390 = getelementptr inbounds i32, i32* %386, i64 %389
store i32* %390, i32** %25
%391 = load i32*, i32** %22
%392 = call i32 @free(i32* %391)
%393 = load i32*, i32** %23
%394 = call i32 @free(i32* %393)
%395 = load i32*, i32** %24
%396 = call i32 @free(i32* %395)
%397 = load i32*, i32** %25
%398 = call i32 @free(i32* %397)
store i32 0, i32* %7
br label %399
399: ; preds = %376, %64
%400 = load i32, i32* %7
ret i32 %400
}

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