#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int LOC(int, int, int, int, int);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ free(unsigned char *);
int /*<<< orphan*/ fwrite(unsigned char *, int, int, int /*<<< orphan*/ *);
scalar_t__ malloc(int);
int /*<<< orphan*/ rgb2yuv(unsigned char *, int);
scalar_t__ round(float);
void outputimgyuv(char *fname, unsigned char *img, int ny, int nx) {
  FILE *fimg;
  int iy, ix, i, j, imagesize, loc1, loc2, loc3, loc0;
  unsigned char *tmp;
  rgb2yuv(img, ny * nx * 3);
  imagesize = ny * nx;
  tmp = (unsigned char *)malloc(imagesize * sizeof(unsigned char));
  fimg = fopen(fname, "wb");
  for (i = 0, j = 0; i < imagesize; i++, j += 3)
    tmp[i] = img[j];
  fwrite(tmp, sizeof(unsigned char), imagesize, fimg);
  i = 0;
  for (iy = 0; iy < ny; iy += 2) {
    for (ix = 0; ix < nx; ix += 2) {
      loc0 = LOC(iy, ix, 1, nx, 3);
      loc1 = loc0 + 3;
      loc2 = loc0 + 3 * nx;
      loc3 = loc2 + 3;
      tmp[i] = (unsigned char)round(
          (((float)img[loc0]) + img[loc1] + img[loc2] + img[loc3]) / 4);
      i++;
    }
  }
  fwrite(tmp, sizeof(unsigned char), imagesize / 4, fimg);
  i = 0;
  for (iy = 0; iy < ny; iy += 2) {
    for (ix = 0; ix < nx; ix += 2) {
      loc0 = LOC(iy, ix, 2, nx, 3);
      loc1 = loc0 + 3;
      loc2 = loc0 + 3 * nx;
      loc3 = loc2 + 3;
      tmp[i] = (unsigned char)round(
          (((float)img[loc0]) + img[loc1] + img[loc2] + img[loc3]) / 4);
      i++;
    }
  }
  fwrite(tmp, sizeof(unsigned char), imagesize / 4, fimg);
  free(tmp);
  fclose(fimg);
}


x86 assembly (clang, -O0):
<outputimgyuv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
imul   $0x3,%eax,%esi
call   1070 <rgb2yuv@plt>
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x34(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x0,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe33(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1221 <outputimgyuv+0xa1>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x30(%rbp)
jmp    11e8 <outputimgyuv+0x68>
mov    -0x50(%rbp),%rdi
mov    -0x34(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    $0x1,%esi
call   10a0 <fwrite@plt>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1335 <outputimgyuv+0x1b5>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1322 <outputimgyuv+0x1a2>
mov    -0x24(%rbp),%edi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%ecx
mov    $0x1,%edx
mov    $0x3,%r8d
call   1050 <LOC@plt>
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x18(%rbp),%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
addss  %xmm1,%xmm0
movss  0xd0b(%rip),%xmm1
divss  %xmm1,%xmm0
call   1090 <round@plt>
mov    %al,%dl
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    1257 <outputimgyuv+0xd7>
jmp    1327 <outputimgyuv+0x1a7>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    1244 <outputimgyuv+0xc4>
mov    -0x50(%rbp),%rdi
mov    -0x34(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x20(%rbp),%rcx
mov    $0x1,%esi
call   10a0 <fwrite@plt>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1453 <outputimgyuv+0x2d3>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1440 <outputimgyuv+0x2c0>
mov    -0x24(%rbp),%edi
mov    -0x28(%rbp),%esi
mov    -0x18(%rbp),%ecx
mov    $0x2,%edx
mov    $0x3,%r8d
call   1050 <LOC@plt>
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x18(%rbp),%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
addss  %xmm1,%xmm0
movss  0xbed(%rip),%xmm1
divss  %xmm1,%xmm0
call   1090 <round@plt>
mov    %al,%dl
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    1375 <outputimgyuv+0x1f5>
jmp    1445 <outputimgyuv+0x2c5>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    1362 <outputimgyuv+0x1e2>
mov    -0x50(%rbp),%rdi
mov    -0x34(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x20(%rbp),%rcx
mov    $0x1,%esi
call   10a0 <fwrite@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rdi
call   1040 <fclose@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<outputimgyuv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%r12
mov    %rdi,%rbx
mov    %rcx,0x8(%rsp)
mov    %ecx,%ebp
mov    %edx,0x4(%rsp)
imul   %edx,%ebp
lea    0x0(%rbp,%rbp,2),%esi
mov    %r12,%rdi
call   1070 <rgb2yuv@plt>
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
lea    0xe45(%rip),%rsi
mov    %rbx,%rdi
call   1080 <fopen@plt>
mov    %rax,%r15
test   %ebp,%ebp
jle    140f <outputimgyuv+0x28f>
mov    %ebp,%r8d
cmp    $0x9,%ebp
jb     11f3 <outputimgyuv+0x73>
lea    (%r8,%r8,2),%rcx
add    %r12,%rcx
add    $0xfffffffffffffffe,%rcx
cmp    %r14,%rcx
jbe    11fc <outputimgyuv+0x7c>
lea    (%r14,%r8,1),%rcx
cmp    %r12,%rcx
jbe    11fc <outputimgyuv+0x7c>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    13a0 <outputimgyuv+0x220>
mov    %rbp,%r11
cmp    $0x11,%ebp
jae    120b <outputimgyuv+0x8b>
xor    %ecx,%ecx
jmp    1310 <outputimgyuv+0x190>
mov    %r8d,%ecx
and    $0xf,%ecx
test   %rcx,%rcx
mov    $0x10,%edx
cmovne %rcx,%rdx
mov    %r8,%rcx
sub    %rdx,%rcx
xor    %esi,%esi
mov    %r12,%rdi
nopl   0x0(%rax,%rax,1)
movzbl 0x2d(%rdi),%ebp
movd   %ebp,%xmm0
movzbl 0x2a(%rdi),%ebp
movd   %ebp,%xmm1
punpcklbw %xmm0,%xmm1
movzbl 0x27(%rdi),%ebp
movd   %ebp,%xmm0
movzbl 0x24(%rdi),%ebp
movd   %ebp,%xmm2
punpcklbw %xmm0,%xmm2
punpcklwd %xmm1,%xmm2
movzbl 0x21(%rdi),%ebp
movd   %ebp,%xmm0
movzbl 0x1e(%rdi),%ebp
movd   %ebp,%xmm1
punpcklbw %xmm0,%xmm1
movzbl 0x1b(%rdi),%ebp
movd   %ebp,%xmm3
movzbl 0x18(%rdi),%ebp
movd   %ebp,%xmm0
punpcklbw %xmm3,%xmm0
punpcklwd %xmm1,%xmm0
punpckldq %xmm2,%xmm0
movzbl 0x15(%rdi),%ebp
movd   %ebp,%xmm1
movzbl 0x12(%rdi),%ebp
movd   %ebp,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0xf(%rdi),%ebp
movd   %ebp,%xmm1
movzbl 0xc(%rdi),%ebp
movd   %ebp,%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm2,%xmm3
movzbl 0x9(%rdi),%ebp
movd   %ebp,%xmm1
movzbl 0x6(%rdi),%ebp
movd   %ebp,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0x3(%rdi),%ebp
movd   %ebp,%xmm1
movzbl (%rdi),%ebp
movd   %ebp,%xmm4
punpcklbw %xmm1,%xmm4
punpcklwd %xmm2,%xmm4
punpckldq %xmm3,%xmm4
punpcklqdq %xmm0,%xmm4
movdqu %xmm4,(%r14,%rsi,1)
add    $0x10,%rsi
add    $0x30,%rdi
cmp    %rsi,%rcx
jne    1230 <outputimgyuv+0xb0>
cmp    $0x9,%edx
jae    1310 <outputimgyuv+0x190>
lea    (%rcx,%rcx,2),%rdx
jmp    139d <outputimgyuv+0x21d>
mov    %rcx,%rsi
mov    %r8d,%ecx
and    $0x7,%ecx
test   %rcx,%rcx
mov    $0x8,%edx
cmovne %rcx,%rdx
mov    %r8,%rcx
sub    %rdx,%rcx
lea    (%rcx,%rcx,2),%rdx
lea    (%rsi,%rsi,2),%rdi
add    %r12,%rdi
cs nopw 0x0(%rax,%rax,1)
movzbl (%rdi),%ebp
movzbl 0x6(%rdi),%ebx
movzbl 0xc(%rdi),%r10d
movzbl 0x12(%rdi),%r9d
movzbl 0x9(%rdi),%eax
shl    $0x8,%eax
or     %ebx,%eax
movzbl 0x3(%rdi),%ebx
shl    $0x8,%ebx
or     %ebp,%ebx
movd   %ebx,%xmm0
pinsrw $0x1,%eax,%xmm0
movzbl 0xf(%rdi),%eax
shl    $0x8,%eax
or     %r10d,%eax
pinsrw $0x2,%eax,%xmm0
movzbl 0x15(%rdi),%eax
shl    $0x8,%eax
or     %r9d,%eax
pinsrw $0x3,%eax,%xmm0
movq   %xmm0,(%r14,%rsi,1)
add    $0x8,%rsi
add    $0x18,%rdi
cmp    %rsi,%rcx
jne    1340 <outputimgyuv+0x1c0>
mov    %r11,%rbp
mov    %r8d,%edi
sub    %ecx,%edi
mov    %rcx,%rsi
not    %rsi
add    %r8,%rsi
and    $0x3,%rdi
je     13d7 <outputimgyuv+0x257>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r12,%rdx,1),%eax
mov    %al,(%r14,%rcx,1)
add    $0x1,%rcx
add    $0x3,%rdx
add    $0xffffffffffffffff,%rdi
jne    13c0 <outputimgyuv+0x240>
cmp    $0x3,%rsi
jb     140f <outputimgyuv+0x28f>
add    %r12,%rdx
movzbl (%rdx),%eax
mov    %al,(%r14,%rcx,1)
movzbl 0x3(%rdx),%eax
mov    %al,0x1(%r14,%rcx,1)
movzbl 0x6(%rdx),%eax
mov    %al,0x2(%r14,%rcx,1)
movzbl 0x9(%rdx),%eax
mov    %al,0x3(%r14,%rcx,1)
add    $0x4,%rcx
add    $0xc,%rdx
cmp    %rcx,%r8
jne    13e0 <outputimgyuv+0x260>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %ebp,%edx
mov    %r15,%rcx
call   10a0 <fwrite@plt>
cmpl   $0x0,0x4(%rsp)
jle    1610 <outputimgyuv+0x490>
mov    %rbp,0x18(%rsp)
mov    %r15,0x20(%rsp)
mov    %r14,0x10(%rsp)
mov    0x8(%rsp),%rcx
lea    (%rcx,%rcx,2),%ebp
xor    %r14d,%r14d
xor    %r15d,%r15d
jmp    145f <outputimgyuv+0x2df>
nopl   0x0(%rax,%rax,1)
add    $0x2,%r14d
cmp    0x4(%rsp),%r14d
jge    14fe <outputimgyuv+0x37e>
test   %ecx,%ecx
jle    1450 <outputimgyuv+0x2d0>
movslq %r15d,%r13
add    0x10(%rsp),%r13
xor    %ebx,%ebx
nopl   (%rax)
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x1,%edx
mov    0x8(%rsp),%rcx
mov    $0x3,%r8d
call   1050 <LOC@plt>
cltq
lea    (%rax,%rbp,1),%ecx
movslq %ecx,%rcx
movzbl (%r12,%rax,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
movzbl 0x3(%r12,%rax,1),%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
movzbl (%r12,%rcx,1),%eax
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
movzbl 0x3(%r12,%rcx,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
addss  %xmm1,%xmm2
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
mulss  0xb28(%rip),%xmm0
call   1090 <round@plt>
mov    0x8(%rsp),%rcx
mov    %al,0x0(%r13)
add    $0x2,%ebx
add    $0x1,%r13
add    $0x1,%r15d
cmp    %ecx,%ebx
jl     1470 <outputimgyuv+0x2f0>
jmp    1450 <outputimgyuv+0x2d0>
mov    0x18(%rsp),%rax
lea    0x3(%rax),%ebx
test   %eax,%eax
cmovns %eax,%ebx
sar    $0x2,%ebx
mov    0x10(%rsp),%r14
mov    %r14,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
mov    0x20(%rsp),%r15
mov    %r15,%rcx
call   10a0 <fwrite@plt>
cmpl   $0x0,0x4(%rsp)
jle    162d <outputimgyuv+0x4ad>
mov    %ebx,0x18(%rsp)
mov    0x8(%rsp),%rcx
lea    (%rcx,%rcx,2),%r13d
xor    %r15d,%r15d
xor    %ebx,%ebx
jmp    155f <outputimgyuv+0x3df>
nopl   0x0(%rax)
add    $0x2,%r15d
cmp    0x4(%rsp),%r15d
jge    1600 <outputimgyuv+0x480>
test   %ecx,%ecx
jle    1550 <outputimgyuv+0x3d0>
movslq %ebx,%rbp
add    0x10(%rsp),%rbp
xor    %r14d,%r14d
xchg   %ax,%ax
mov    %r15d,%edi
mov    %r14d,%esi
mov    $0x2,%edx
mov    0x8(%rsp),%rcx
mov    $0x3,%r8d
call   1050 <LOC@plt>
cltq
lea    (%rax,%r13,1),%ecx
movslq %ecx,%rcx
movzbl (%r12,%rax,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
movzbl 0x3(%r12,%rax,1),%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
movzbl (%r12,%rcx,1),%eax
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
movzbl 0x3(%r12,%rcx,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
addss  %xmm1,%xmm2
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
mulss  0xa26(%rip),%xmm0
call   1090 <round@plt>
mov    0x8(%rsp),%rcx
mov    %al,0x0(%rbp)
add    $0x2,%r14d
add    $0x1,%rbp
add    $0x1,%ebx
cmp    %ecx,%r14d
jl     1570 <outputimgyuv+0x3f0>
jmp    1550 <outputimgyuv+0x3d0>
mov    0x10(%rsp),%r14
mov    0x20(%rsp),%r15
mov    0x18(%rsp),%ebx
jmp    162d <outputimgyuv+0x4ad>
lea    0x3(%rbp),%ebx
test   %ebp,%ebp
cmovns %ebp,%ebx
sar    $0x2,%ebx
mov    %r14,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
mov    %r15,%rcx
call   10a0 <fwrite@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
mov    %r15,%rcx
call   10a0 <fwrite@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <fclose@plt>

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

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