#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 */
unsigned char cl255(float);
void rgb_to_yuv(unsigned char *oot, unsigned char const *d, int xs, int ys) {
  unsigned char *y = oot;
  unsigned char *u = y + xs * ys;
  unsigned char *v = u + xs * ys / 4;
  for (int r = 0; r < ys; r += 2) {
    for (int c = 0; c < xs; c += 2) {
      float y0 = d[0] * 0.299f + d[1] * 0.587f + d[2] * 0.114f;
      float u0 = 0.492f * (d[2] - y0);
      float v0 = 0.492f * (d[0] - y0);
      float y1 = d[3] * 0.299f + d[4] * 0.587f + d[5] * 0.114f;
      float u1 = 0.492f * (d[5] - y1);
      float v1 = 0.492f * (d[3] - y1);
      float y2 = d[xs * 3 + 0] * 0.299f + d[xs * 3 + 1] * 0.587f +
                 d[xs * 3 + 2] * 0.114f;
      float u2 = 0.492f * (d[xs * 3 + 2] - y2);
      float v2 = 0.492f * (d[xs * 3 + 0] - y2);
      float y3 = d[xs * 3 + 3] * 0.299f + d[xs * 3 + 4] * 0.587f +
                 d[xs * 3 + 5] * 0.114f;
      float u3 = 0.492f * (d[xs * 3 + 5] - y3);
      float v3 = 0.492f * (d[xs * 3 + 3] - y3);
      y[0] = cl255(y0);
      y[1] = cl255(y1);
      y[xs] = cl255(y2);
      y[xs + 1] = cl255(y3);
      u[0] = cl255((u0 + u1 + u2 + u3) * 0.25f + 128);
      v[0] = cl255((v0 + v1 + v2 + v3) * 0.25f + 128);
      y += 2;
      u += 1;
      v += 1;
      d += 6;
    }
    y += xs;
    d += xs * 3;
  }
}


x86 assembly (clang, -O0):
<rgb_to_yuv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    158f <rgb_to_yuv+0x47f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    155e <rgb_to_yuv+0x44e>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cvtsi2ss %eax,%xmm1
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xe65(%rip),%xmm2
mulss  %xmm2,%xmm0
movss  0xe55(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xe35(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
cvtsi2ss %eax,%xmm1
subss  -0x3c(%rbp),%xmm1
movss  0xe0b(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cvtsi2ss %eax,%xmm1
subss  -0x3c(%rbp),%xmm1
movss  0xdea(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
cvtsi2ss %eax,%xmm1
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xdcd(%rip),%xmm2
mulss  %xmm2,%xmm0
movss  0xdbd(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xd9d(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
cvtsi2ss %eax,%xmm1
subss  -0x48(%rbp),%xmm1
movss  0xd73(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
cvtsi2ss %eax,%xmm1
subss  -0x48(%rbp),%xmm1
movss  0xd51(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
mov    -0x10(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movss  0xd20(%rip),%xmm2
mulss  %xmm2,%xmm0
movss  0xd10(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movss  0xce6(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
subss  -0x54(%rbp),%xmm1
movss  0xcb2(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
subss  -0x54(%rbp),%xmm1
movss  0xc86(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
mov    -0x10(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movss  0xc55(%rip),%xmm2
mulss  %xmm2,%xmm0
movss  0xc45(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
movss  0xc1b(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
subss  -0x60(%rbp),%xmm1
movss  0xbe7(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm1
subss  -0x60(%rbp),%xmm1
movss  0xbbb(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x3c(%rbp),%xmm0
call   1030 <cl255@plt>
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
movss  -0x48(%rbp),%xmm0
call   1030 <cl255@plt>
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x1(%rax)
movss  -0x54(%rbp),%xmm0
call   1030 <cl255@plt>
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
movss  -0x60(%rbp),%xmm0
call   1030 <cl255@plt>
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movss  -0x40(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
movss  0xb36(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0xb2e(%rip),%xmm1
addss  %xmm1,%xmm0
call   1030 <cl255@plt>
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
movss  -0x44(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  0xafd(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0xaf5(%rip),%xmm1
addss  %xmm1,%xmm0
call   1030 <cl255@plt>
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    $0x6,%rax
mov    %rax,-0x10(%rbp)
mov    -0x38(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x38(%rbp)
jmp    1184 <rgb_to_yuv+0x74>
mov    -0x14(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
imul   $0x3,-0x14(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1171 <rgb_to_yuv+0x61>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rgb_to_yuv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %ecx,0xc(%rsp)
test   %ecx,%ecx
jle    1415 <rgb_to_yuv+0x305>
mov    %rsi,%rbx
mov    %rdi,%r12
mov    0xc(%rsp),%eax
imul   %edx,%eax
cltq
lea    (%rdi,%rax,1),%r13
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
sar    $0x2,%ecx
movslq %ecx,%r15
add    %r13,%r15
movslq %edx,%rax
lea    (%rax,%rax,2),%rcx
xor    %edi,%edi
movss  0xea1(%rip),%xmm7
movss  0xe9c(%rip),%xmm8
movss  0xe97(%rip),%xmm9
movss  0xe92(%rip),%xmm10
mov    %edx,0x20(%rsp)
mov    %rax,0x38(%rsp)
mov    %rcx,0x40(%rsp)
mov    0x38(%rsp),%rbp
jmp    11b1 <rgb_to_yuv+0xa1>
nop
mov    0x38(%rsp),%rax
add    %rax,%r12
add    %rcx,%rbx
mov    0x1c(%rsp),%edi
add    $0x2,%edi
cmp    0xc(%rsp),%edi
mov    0x10(%rsp),%r13
jge    1415 <rgb_to_yuv+0x305>
test   %edx,%edx
mov    %edi,0x1c(%rsp)
mov    %r13,0x10(%rsp)
jle    1190 <rgb_to_yuv+0x80>
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rbx),%eax
cvtsi2ss %eax,%xmm2
movzbl 0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm7,%xmm0
movaps %xmm2,%xmm1
mulss  %xmm8,%xmm1
movzbl 0x2(%rbx),%eax
cvtsi2ss %eax,%xmm3
addss  %xmm0,%xmm1
movaps %xmm3,%xmm0
mulss  %xmm9,%xmm0
addss  %xmm1,%xmm0
subss  %xmm0,%xmm3
mulss  %xmm10,%xmm3
subss  %xmm0,%xmm2
mulss  %xmm10,%xmm2
movzbl 0x3(%rbx),%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movzbl 0x4(%rbx),%eax
xorps  %xmm5,%xmm5
cvtsi2ss %eax,%xmm5
mulss  %xmm7,%xmm5
movaps %xmm1,%xmm6
movzbl 0x5(%rbx),%eax
cvtsi2ss %eax,%xmm4
mulss  %xmm8,%xmm6
addss  %xmm5,%xmm6
movaps %xmm4,%xmm5
mulss  %xmm9,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,0x34(%rsp)
subss  %xmm5,%xmm4
mulss  %xmm10,%xmm4
addss  %xmm3,%xmm4
subss  %xmm5,%xmm1
movzbl (%rbx,%rcx,1),%eax
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
movzbl 0x1(%rbx,%rcx,1),%eax
xorps  %xmm5,%xmm5
cvtsi2ss %eax,%xmm5
mulss  %xmm10,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm7,%xmm5
movaps %xmm3,%xmm6
mulss  %xmm8,%xmm6
movzbl 0x2(%rbx,%rcx,1),%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
addss  %xmm5,%xmm6
movaps %xmm2,%xmm5
mulss  %xmm9,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,0x30(%rsp)
subss  %xmm5,%xmm2
mulss  %xmm10,%xmm2
addss  %xmm4,%xmm2
subss  %xmm5,%xmm3
mulss  %xmm10,%xmm3
movzbl 0x3(%rbx,%rcx,1),%eax
xorps  %xmm5,%xmm5
cvtsi2ss %eax,%xmm5
movzbl 0x4(%rbx,%rcx,1),%eax
xorps  %xmm4,%xmm4
cvtsi2ss %eax,%xmm4
addss  %xmm1,%xmm3
mulss  %xmm7,%xmm4
movaps %xmm5,%xmm1
mulss  %xmm8,%xmm1
addss  %xmm4,%xmm1
movzbl 0x5(%rbx,%rcx,1),%eax
xorps  %xmm4,%xmm4
cvtsi2ss %eax,%xmm4
movaps %xmm4,%xmm6
mulss  %xmm9,%xmm6
addss  %xmm1,%xmm6
movss  %xmm6,0x24(%rsp)
subss  %xmm6,%xmm4
mulss  %xmm10,%xmm4
addss  %xmm2,%xmm4
movss  %xmm4,0x28(%rsp)
subss  %xmm6,%xmm5
mulss  %xmm10,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,0x2c(%rsp)
call   1030 <cl255@plt>
mov    %al,(%r12)
movss  0x34(%rsp),%xmm0
call   1030 <cl255@plt>
mov    %al,0x1(%r12)
movss  0x30(%rsp),%xmm0
call   1030 <cl255@plt>
mov    %al,(%r12,%rbp,1)
movss  0x24(%rsp),%xmm0
call   1030 <cl255@plt>
mov    %al,0x1(%r12,%rbp,1)
movss  0xc93(%rip),%xmm0
movss  0x28(%rsp),%xmm1
mulss  %xmm0,%xmm1
movss  0xc85(%rip),%xmm0
addss  %xmm0,%xmm1
movaps %xmm1,%xmm0
call   1030 <cl255@plt>
mov    0x10(%rsp),%r13
mov    %al,0x0(%r13)
movss  0x2c(%rsp),%xmm0
mulss  0xc5e(%rip),%xmm0
addss  0xc5a(%rip),%xmm0
call   1030 <cl255@plt>
movss  0xc44(%rip),%xmm10
movss  0xc37(%rip),%xmm9
movss  0xc2a(%rip),%xmm8
movss  0xc1e(%rip),%xmm7
mov    0x40(%rsp),%rcx
mov    0x20(%rsp),%edx
mov    %al,(%r15)
add    $0x2,%r12
add    $0x1,%r13
mov    %r13,0x10(%rsp)
add    $0x1,%r15
add    $0x6,%rbx
add    $0x2,%r14d
cmp    %edx,%r14d
jl     11d0 <rgb_to_yuv+0xc0>
jmp    1190 <rgb_to_yuv+0x80>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @rgb_to_yuv(i8* nocapture writeonly %0, i8* nocapture %1, i32 %2, i32 %3) {
%5 = mul nsw i32 %3, %2
%6 = sext i32 %5 to i64
%7 = getelementptr inbounds i8, i8* %0, i64 %6
%8 = icmp sgt i32 %3, 0
br i1 %8, label %9, label %35
9: ; preds = %4
%10 = sdiv i32 %5, 4
%11 = sext i32 %10 to i64
%12 = getelementptr inbounds i8, i8* %7, i64 %11
%13 = icmp sgt i32 %2, 0
%14 = mul nsw i32 %2, 3
%15 = sext i32 %14 to i64
%16 = add nsw i32 %14, 1
%17 = sext i32 %16 to i64
%18 = add nsw i32 %14, 2
%19 = sext i32 %18 to i64
%20 = add nsw i32 %14, 3
%21 = sext i32 %20 to i64
%22 = add nsw i32 %14, 4
%23 = sext i32 %22 to i64
%24 = add nsw i32 %14, 5
%25 = sext i32 %24 to i64
%26 = sext i32 %2 to i64
%27 = add nsw i32 %2, 1
%28 = sext i32 %27 to i64
br label %29
29: ; preds = %9, %36
%30 = phi i8* [ %1, %9 ], [ %42, %36 ]
%31 = phi i8* [ %0, %9 ], [ %41, %36 ]
%32 = phi i8* [ %7, %9 ], [ %38, %36 ]
%33 = phi i8* [ %12, %9 ], [ %37, %36 ]
%34 = phi i32 [ 0, %9 ], [ %43, %36 ]
br i1 %13, label %45, label %36
35: ; preds = %36, %4
ret void
36: ; preds = %45, %29
%37 = phi i8* [ %33, %29 ], [ %133, %45 ]
%38 = phi i8* [ %32, %29 ], [ %132, %45 ]
%39 = phi i8* [ %31, %29 ], [ %131, %45 ]
%40 = phi i8* [ %30, %29 ], [ %134, %45 ]
%41 = getelementptr inbounds i8, i8* %39, i64 %26
%42 = getelementptr inbounds i8, i8* %40, i64 %15
%43 = add nuw nsw i32 %34, 2
%44 = icmp slt i32 %43, %3
br i1 %44, label %29, label %35
45: ; preds = %29, %45
%46 = phi i8* [ %134, %45 ], [ %30, %29 ]
%47 = phi i8* [ %131, %45 ], [ %31, %29 ]
%48 = phi i8* [ %132, %45 ], [ %32, %29 ]
%49 = phi i8* [ %133, %45 ], [ %33, %29 ]
%50 = phi i32 [ %135, %45 ], [ 0, %29 ]
%51 = load i8, i8* %46
%52 = uitofp i8 %51 to float
%53 = getelementptr inbounds i8, i8* %46, i64 1
%54 = load i8, i8* %53
%55 = uitofp i8 %54 to float
%56 = fmul float %55, 0x3FE2C8B440000000
%57 = tail call float @llvm.fmuladd.f32(float %52, float 0x3FD322D0E0000000, float %56)
%58 = getelementptr inbounds i8, i8* %46, i64 2
%59 = load i8, i8* %58
%60 = uitofp i8 %59 to float
%61 = tail call float @llvm.fmuladd.f32(float %60, float 0x3FBD2F1AA0000000, float %57)
%62 = fsub float %60, %61
%63 = fmul float %62, 0x3FDF7CEDA0000000
%64 = fsub float %52, %61
%65 = fmul float %64, 0x3FDF7CEDA0000000
%66 = getelementptr inbounds i8, i8* %46, i64 3
%67 = load i8, i8* %66
%68 = uitofp i8 %67 to float
%69 = getelementptr inbounds i8, i8* %46, i64 4
%70 = load i8, i8* %69
%71 = uitofp i8 %70 to float
%72 = fmul float %71, 0x3FE2C8B440000000
%73 = tail call float @llvm.fmuladd.f32(float %68, float 0x3FD322D0E0000000, float %72)
%74 = getelementptr inbounds i8, i8* %46, i64 5
%75 = load i8, i8* %74
%76 = uitofp i8 %75 to float
%77 = tail call float @llvm.fmuladd.f32(float %76, float 0x3FBD2F1AA0000000, float %73)
%78 = fsub float %76, %77
%79 = fmul float %78, 0x3FDF7CEDA0000000
%80 = fsub float %68, %77
%81 = fmul float %80, 0x3FDF7CEDA0000000
%82 = getelementptr inbounds i8, i8* %46, i64 %15
%83 = load i8, i8* %82
%84 = uitofp i8 %83 to float
%85 = getelementptr inbounds i8, i8* %46, i64 %17
%86 = load i8, i8* %85
%87 = uitofp i8 %86 to float
%88 = fmul float %87, 0x3FE2C8B440000000
%89 = tail call float @llvm.fmuladd.f32(float %84, float 0x3FD322D0E0000000, float %88)
%90 = getelementptr inbounds i8, i8* %46, i64 %19
%91 = load i8, i8* %90
%92 = uitofp i8 %91 to float
%93 = tail call float @llvm.fmuladd.f32(float %92, float 0x3FBD2F1AA0000000, float %89)
%94 = fsub float %92, %93
%95 = fmul float %94, 0x3FDF7CEDA0000000
%96 = fsub float %84, %93
%97 = fmul float %96, 0x3FDF7CEDA0000000
%98 = getelementptr inbounds i8, i8* %46, i64 %21
%99 = load i8, i8* %98
%100 = uitofp i8 %99 to float
%101 = getelementptr inbounds i8, i8* %46, i64 %23
%102 = load i8, i8* %101
%103 = uitofp i8 %102 to float
%104 = fmul float %103, 0x3FE2C8B440000000
%105 = tail call float @llvm.fmuladd.f32(float %100, float 0x3FD322D0E0000000, float %104)
%106 = getelementptr inbounds i8, i8* %46, i64 %25
%107 = load i8, i8* %106
%108 = uitofp i8 %107 to float
%109 = tail call float @llvm.fmuladd.f32(float %108, float 0x3FBD2F1AA0000000, float %105)
%110 = fsub float %108, %109
%111 = fmul float %110, 0x3FDF7CEDA0000000
%112 = fsub float %100, %109
%113 = fmul float %112, 0x3FDF7CEDA0000000
%114 = tail call zeroext i8 @cl255(float %61)
store i8 %114, i8* %47
%115 = tail call zeroext i8 @cl255(float %77)
%116 = getelementptr inbounds i8, i8* %47, i64 1
store i8 %115, i8* %116
%117 = tail call zeroext i8 @cl255(float %93)
%118 = getelementptr inbounds i8, i8* %47, i64 %26
store i8 %117, i8* %118
%119 = tail call zeroext i8 @cl255(float %109)
%120 = getelementptr inbounds i8, i8* %47, i64 %28
store i8 %119, i8* %120
%121 = fadd float %63, %79
%122 = fadd float %121, %95
%123 = fadd float %122, %111
%124 = tail call float @llvm.fmuladd.f32(float %123, float 2.500000e-01, float 1.280000e+02)
%125 = tail call zeroext i8 @cl255(float %124)
store i8 %125, i8* %48
%126 = fadd float %65, %81
%127 = fadd float %126, %97
%128 = fadd float %127, %113
%129 = tail call float @llvm.fmuladd.f32(float %128, float 2.500000e-01, float 1.280000e+02)
%130 = tail call zeroext i8 @cl255(float %129)
store i8 %130, i8* %49
%131 = getelementptr inbounds i8, i8* %47, i64 2
%132 = getelementptr inbounds i8, i8* %48, i64 1
%133 = getelementptr inbounds i8, i8* %49, i64 1
%134 = getelementptr inbounds i8, i8* %46, i64 6
%135 = add nuw nsw i32 %50, 2
%136 = icmp slt i32 %135, %2
br i1 %136, label %45, label %36
}