void v4lconvert_uyvy_to_rgb24(const unsigned char *src, unsigned char *dest,
                              int width, int height) {
  int j;
  while (--height >= 0) {
    for (j = 0; j < width; j += 2) {
      int u = src[0];
      int v = src[2];
      int u1 = (((u - 128) << 7) + (u - 128)) >> 6;
      int rg = (((u - 128) << 1) + (u - 128) + ((v - 128) << 2) +
                ((v - 128) << 1)) >>
               3;
      int v1 = (((v - 128) << 1) + (v - 128)) >> 1;
      *dest++ =
          (unsigned char)(((src[1] + v1) > 0xFF)
                              ? 0xff
                              : (((src[1] + v1) < 0) ? 0 : (src[1] + v1)));
      *dest++ =
          (unsigned char)(((src[1] - rg) > 0xFF)
                              ? 0xff
                              : (((src[1] - rg) < 0) ? 0 : (src[1] - rg)));
      *dest++ =
          (unsigned char)(((src[1] + u1) > 0xFF)
                              ? 0xff
                              : (((src[1] + u1) < 0) ? 0 : (src[1] + u1)));
      *dest++ =
          (unsigned char)(((src[3] + v1) > 0xFF)
                              ? 0xff
                              : (((src[3] + v1) < 0) ? 0 : (src[3] + v1)));
      *dest++ =
          (unsigned char)(((src[3] - rg) > 0xFF)
                              ? 0xff
                              : (((src[3] - rg) < 0) ? 0 : (src[3] - rg)));
      *dest++ =
          (unsigned char)(((src[3] + u1) > 0xFF)
                              ? 0xff
                              : (((src[3] + u1) < 0) ? 0 : (src[3] + u1)));
      src += 4;
    }
  }
}


x86 assembly (clang, -O0):
<v4lconvert_uyvy_to_rgb24>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
jl     145d <v4lconvert_uyvy_to_rgb24+0x35d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1458 <v4lconvert_uyvy_to_rgb24+0x358>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
sub    $0x80,%eax
shl    $0x7,%eax
mov    -0x20(%rbp),%ecx
sub    $0x80,%ecx
add    %ecx,%eax
sar    $0x6,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
sub    $0x80,%eax
shl    $0x1,%eax
mov    -0x20(%rbp),%ecx
sub    $0x80,%ecx
add    %ecx,%eax
mov    -0x24(%rbp),%ecx
sub    $0x80,%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    -0x24(%rbp),%ecx
sub    $0x80,%ecx
shl    $0x1,%ecx
add    %ecx,%eax
sar    $0x3,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x80,%eax
shl    $0x1,%eax
mov    -0x24(%rbp),%ecx
sub    $0x80,%ecx
add    %ecx,%eax
sar    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
add    -0x30(%rbp),%eax
cmp    $0xff,%eax
jle    11df <v4lconvert_uyvy_to_rgb24+0xdf>
mov    $0xff,%eax
mov    %eax,-0x34(%rbp)
jmp    1211 <v4lconvert_uyvy_to_rgb24+0x111>
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
add    -0x30(%rbp),%eax
cmp    $0x0,%eax
jge    11fd <v4lconvert_uyvy_to_rgb24+0xfd>
xor    %eax,%eax
mov    %eax,-0x38(%rbp)
jmp    120b <v4lconvert_uyvy_to_rgb24+0x10b>
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
sub    -0x2c(%rbp),%eax
cmp    $0xff,%eax
jle    124a <v4lconvert_uyvy_to_rgb24+0x14a>
mov    $0xff,%eax
mov    %eax,-0x3c(%rbp)
jmp    127c <v4lconvert_uyvy_to_rgb24+0x17c>
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
sub    -0x2c(%rbp),%eax
cmp    $0x0,%eax
jge    1268 <v4lconvert_uyvy_to_rgb24+0x168>
xor    %eax,%eax
mov    %eax,-0x40(%rbp)
jmp    1276 <v4lconvert_uyvy_to_rgb24+0x176>
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
add    -0x28(%rbp),%eax
cmp    $0xff,%eax
jle    12b5 <v4lconvert_uyvy_to_rgb24+0x1b5>
mov    $0xff,%eax
mov    %eax,-0x44(%rbp)
jmp    12e7 <v4lconvert_uyvy_to_rgb24+0x1e7>
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
add    -0x28(%rbp),%eax
cmp    $0x0,%eax
jge    12d3 <v4lconvert_uyvy_to_rgb24+0x1d3>
xor    %eax,%eax
mov    %eax,-0x48(%rbp)
jmp    12e1 <v4lconvert_uyvy_to_rgb24+0x1e1>
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x30(%rbp),%eax
cmp    $0xff,%eax
jle    1320 <v4lconvert_uyvy_to_rgb24+0x220>
mov    $0xff,%eax
mov    %eax,-0x4c(%rbp)
jmp    1352 <v4lconvert_uyvy_to_rgb24+0x252>
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x30(%rbp),%eax
cmp    $0x0,%eax
jge    133e <v4lconvert_uyvy_to_rgb24+0x23e>
xor    %eax,%eax
mov    %eax,-0x50(%rbp)
jmp    134c <v4lconvert_uyvy_to_rgb24+0x24c>
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
sub    -0x2c(%rbp),%eax
cmp    $0xff,%eax
jle    138b <v4lconvert_uyvy_to_rgb24+0x28b>
mov    $0xff,%eax
mov    %eax,-0x54(%rbp)
jmp    13bd <v4lconvert_uyvy_to_rgb24+0x2bd>
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
sub    -0x2c(%rbp),%eax
cmp    $0x0,%eax
jge    13a9 <v4lconvert_uyvy_to_rgb24+0x2a9>
xor    %eax,%eax
mov    %eax,-0x58(%rbp)
jmp    13b7 <v4lconvert_uyvy_to_rgb24+0x2b7>
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x28(%rbp),%eax
cmp    $0xff,%eax
jle    13f6 <v4lconvert_uyvy_to_rgb24+0x2f6>
mov    $0xff,%eax
mov    %eax,-0x5c(%rbp)
jmp    1428 <v4lconvert_uyvy_to_rgb24+0x328>
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x28(%rbp),%eax
cmp    $0x0,%eax
jge    1414 <v4lconvert_uyvy_to_rgb24+0x314>
xor    %eax,%eax
mov    %eax,-0x60(%rbp)
jmp    1422 <v4lconvert_uyvy_to_rgb24+0x322>
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    112b <v4lconvert_uyvy_to_rgb24+0x2b>
jmp    1112 <v4lconvert_uyvy_to_rgb24+0x12>
pop    %rbp
ret

x86 assembly (clang, -O2):
<v4lconvert_uyvy_to_rgb24>:
push   %rbp
push   %rbx
test   %ecx,%ecx
jle    121d <v4lconvert_uyvy_to_rgb24+0x11d>
xor    %r8d,%r8d
jmp    111e <v4lconvert_uyvy_to_rgb24+0x1e>
nop
lea    -0x1(%rcx),%eax
cmp    $0x2,%ecx
mov    %eax,%ecx
jl     121d <v4lconvert_uyvy_to_rgb24+0x11d>
test   %edx,%edx
jle    1110 <v4lconvert_uyvy_to_rgb24+0x10>
xor    %r9d,%r9d
jmp    1145 <v4lconvert_uyvy_to_rgb24+0x45>
nopw   0x0(%rax,%rax,1)
mov    %r11b,0x5(%rsi)
add    $0x6,%rsi
add    $0x4,%rdi
add    $0x2,%r9d
cmp    %edx,%r9d
jge    1110 <v4lconvert_uyvy_to_rgb24+0x10>
movzbl (%rdi),%ebx
movzbl 0x2(%rdi),%r10d
mov    %ebx,%eax
add    $0xffffff80,%eax
lea    (%rax,%rax,2),%ebp
shl    $0x7,%eax
lea    (%rbx,%rax,1),%r11d
add    $0xffffff80,%r11d
sar    $0x6,%r11d
lea    (%r10,%r10,2),%eax
add    $0xfffffe80,%eax
lea    0x0(%rbp,%rax,2),%r10d
sar    $0x3,%r10d
sar    %eax
movzbl 0x1(%rdi),%ebp
add    %eax,%ebp
cmovs  %r8d,%ebp
cmp    $0xff,%ebp
mov    $0xff,%ebx
cmovae %ebx,%ebp
mov    %bpl,(%rsi)
movzbl 0x1(%rdi),%ebp
sub    %r10d,%ebp
cmovs  %r8d,%ebp
cmp    $0xff,%ebp
jb     11ab <v4lconvert_uyvy_to_rgb24+0xab>
mov    $0xff,%ebp
mov    %bpl,0x1(%rsi)
movzbl 0x1(%rdi),%ebp
add    %r11d,%ebp
cmovs  %r8d,%ebp
cmp    $0xff,%ebp
jb     11c7 <v4lconvert_uyvy_to_rgb24+0xc7>
mov    $0xff,%ebp
mov    %bpl,0x2(%rsi)
movzbl 0x3(%rdi),%ebp
add    %ebp,%eax
cmovs  %r8d,%eax
cmp    $0xff,%eax
cmovae %ebx,%eax
mov    %al,0x3(%rsi)
movzbl 0x3(%rdi),%eax
sub    %r10d,%eax
cmovs  %r8d,%eax
cmp    $0xff,%eax
jb     11f7 <v4lconvert_uyvy_to_rgb24+0xf7>
mov    $0xff,%eax
mov    %al,0x4(%rsi)
movzbl 0x3(%rdi),%eax
add    %eax,%r11d
cmovs  %r8d,%r11d
cmp    $0xff,%r11d
jb     1130 <v4lconvert_uyvy_to_rgb24+0x30>
mov    $0xff,%r11d
jmp    1130 <v4lconvert_uyvy_to_rgb24+0x30>
pop    %rbx
pop    %rbp
ret

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

LLVM IR (-O2):
define void @v4lconvert_uyvy_to_rgb24(i8* nocapture %0, i8* nocapture writeonly %1, i32 %2, i32 %3) {
%5 = icmp sgt i32 %3, 0
br i1 %5, label %6, label %95
6: ; preds = %4
%7 = icmp sgt i32 %2, 0
br label %12
8: ; preds = %17, %12
%9 = phi i8* [ %15, %12 ], [ %91, %17 ]
%10 = phi i8* [ %14, %12 ], [ %92, %17 ]
%11 = icmp sgt i32 %13, 1
br i1 %11, label %12, label %95
12: ; preds = %6, %8
%13 = phi i32 [ %3, %6 ], [ %16, %8 ]
%14 = phi i8* [ %0, %6 ], [ %10, %8 ]
%15 = phi i8* [ %1, %6 ], [ %9, %8 ]
%16 = add nsw i32 %13, -1
br i1 %7, label %17, label %8
17: ; preds = %12, %17
%18 = phi i8* [ %92, %17 ], [ %14, %12 ]
%19 = phi i8* [ %91, %17 ], [ %15, %12 ]
%20 = phi i32 [ %93, %17 ], [ 0, %12 ]
%21 = load i8, i8* %18
%22 = zext i8 %21 to i32
%23 = getelementptr inbounds i8, i8* %18, i64 2
%24 = load i8, i8* %23
%25 = zext i8 %24 to i32
%26 = add nsw i32 %22, -128
%27 = mul nsw i32 %26, 129
%28 = ashr i32 %27, 6
%29 = mul nsw i32 %26, 3
%30 = add nsw i32 %25, -128
%31 = mul nsw i32 %30, 6
%32 = add nsw i32 %31, %29
%33 = ashr i32 %32, 3
%34 = mul nsw i32 %30, 3
%35 = ashr i32 %34, 1
%36 = getelementptr inbounds i8, i8* %18, i64 1
%37 = load i8, i8* %36
%38 = zext i8 %37 to i32
%39 = add nsw i32 %35, %38
%40 = icmp sgt i32 %39, 0
%41 = select i1 %40, i32 %39, i32 0
%42 = icmp ult i32 %41, 255
%43 = select i1 %42, i32 %41, i32 255
%44 = trunc i32 %43 to i8
%45 = getelementptr inbounds i8, i8* %19, i64 1
store i8 %44, i8* %19
%46 = load i8, i8* %36
%47 = zext i8 %46 to i32
%48 = sub nsw i32 %47, %33
%49 = icmp sgt i32 %48, 0
%50 = select i1 %49, i32 %48, i32 0
%51 = icmp ult i32 %50, 255
%52 = select i1 %51, i32 %50, i32 255
%53 = trunc i32 %52 to i8
%54 = getelementptr inbounds i8, i8* %19, i64 2
store i8 %53, i8* %45
%55 = load i8, i8* %36
%56 = zext i8 %55 to i32
%57 = add nsw i32 %28, %56
%58 = icmp sgt i32 %57, 0
%59 = select i1 %58, i32 %57, i32 0
%60 = icmp ult i32 %59, 255
%61 = select i1 %60, i32 %59, i32 255
%62 = trunc i32 %61 to i8
%63 = getelementptr inbounds i8, i8* %19, i64 3
store i8 %62, i8* %54
%64 = getelementptr inbounds i8, i8* %18, i64 3
%65 = load i8, i8* %64
%66 = zext i8 %65 to i32
%67 = add nsw i32 %35, %66
%68 = icmp sgt i32 %67, 0
%69 = select i1 %68, i32 %67, i32 0
%70 = icmp ult i32 %69, 255
%71 = select i1 %70, i32 %69, i32 255
%72 = trunc i32 %71 to i8
%73 = getelementptr inbounds i8, i8* %19, i64 4
store i8 %72, i8* %63
%74 = load i8, i8* %64
%75 = zext i8 %74 to i32
%76 = sub nsw i32 %75, %33
%77 = icmp sgt i32 %76, 0
%78 = select i1 %77, i32 %76, i32 0
%79 = icmp ult i32 %78, 255
%80 = select i1 %79, i32 %78, i32 255
%81 = trunc i32 %80 to i8
%82 = getelementptr inbounds i8, i8* %19, i64 5
store i8 %81, i8* %73
%83 = load i8, i8* %64
%84 = zext i8 %83 to i32
%85 = add nsw i32 %28, %84
%86 = icmp sgt i32 %85, 0
%87 = select i1 %86, i32 %85, i32 0
%88 = icmp ult i32 %87, 255
%89 = select i1 %88, i32 %87, i32 255
%90 = trunc i32 %89 to i8
%91 = getelementptr inbounds i8, i8* %19, i64 6
store i8 %90, i8* %82
%92 = getelementptr inbounds i8, i8* %18, i64 4
%93 = add nuw nsw i32 %20, 2
%94 = icmp slt i32 %93, %2
br i1 %94, label %17, label %8
95: ; preds = %8, %4
ret void
}