void RGB_to_YUV(float **R, float **G, float **B, float **Y, float **U,
                float **V, long nx, long ny) {
  long i, j;
  for (j = 0; j < ny; j++)
    for (i = 0; i < nx; i++) {
      Y[i][j] = (0.1277 * R[i][j] + 0.5212 * G[i][j] + 0.21 * B[i][j]) + 16.0;
      U[i][j] =
          ((-0.0737 * R[i][j] - 0.3007 * G[i][j] + 0.3744 * B[i][j])) + 128.0;
      V[i][j] =
          ((0.5334 * R[i][j] - 0.3802 * G[i][j] - 0.1532 * B[i][j])) + 128.0;
    }
  return;
}


x86 assembly (clang, -O0):
<RGB_to_YUV>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    0x18(%rbp),%rax
jge    1379 <RGB_to_YUV+0x279>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    0x10(%rbp),%rax
jge    1363 <RGB_to_YUV+0x263>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xec6(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0xeb2(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe81(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xe69(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xe0a(%rip),%xmm0
mulsd  %xmm2,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xddf(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdae(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xd7e(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xd3f(%rip),%xmm0
mulsd  %xmm2,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xd14(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xce3(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xccb(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1142 <RGB_to_YUV+0x42>
jmp    1368 <RGB_to_YUV+0x268>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    112c <RGB_to_YUV+0x2c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<RGB_to_YUV>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x38(%rsp),%r10
test   %r10,%r10
jle    1298 <RGB_to_YUV+0x198>
mov    0x30(%rsp),%r11
xor    %r13d,%r13d
movsd  0xed8(%rip),%xmm8
movsd  0xed7(%rip),%xmm9
movsd  0xed6(%rip),%xmm10
movsd  0xed5(%rip),%xmm11
movsd  0xed4(%rip),%xmm12
movsd  0xed4(%rip),%xmm5
movsd  0xed4(%rip),%xmm6
movsd  0xed4(%rip),%xmm7
movsd  0xed4(%rip),%xmm0
movsd  0xed4(%rip),%xmm1
movsd  0xed4(%rip),%xmm2
jmp    118d <RGB_to_YUV+0x8d>
xchg   %ax,%ax
add    $0x1,%r13
cmp    %r10,%r13
je     1298 <RGB_to_YUV+0x198>
test   %r11,%r11
jle    1180 <RGB_to_YUV+0x80>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi,%rbx,8),%r14
movss  (%r14,%r13,4),%xmm3
cvtss2sd %xmm3,%xmm3
mov    (%rsi,%rbx,8),%r15
movss  (%r15,%r13,4),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm8,%xmm4
mulsd  %xmm9,%xmm3
addsd  %xmm4,%xmm3
mov    (%rdx,%rbx,8),%r12
movss  (%r12,%r13,4),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm10,%xmm4
addsd  %xmm3,%xmm4
addsd  %xmm11,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
mov    (%rcx,%rbx,8),%rax
movss  %xmm3,(%rax,%r13,4)
movss  (%r14,%r13,4),%xmm3
cvtss2sd %xmm3,%xmm3
movss  (%r15,%r13,4),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm12,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
movss  (%r12,%r13,4),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm6,%xmm4
addsd  %xmm3,%xmm4
addsd  %xmm7,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
mov    (%r8,%rbx,8),%rax
movss  %xmm3,(%rax,%r13,4)
movss  (%r14,%r13,4),%xmm3
cvtss2sd %xmm3,%xmm3
movss  (%r15,%r13,4),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm1,%xmm3
addsd  %xmm4,%xmm3
movss  (%r12,%r13,4),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
addsd  %xmm7,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
mov    (%r9,%rbx,8),%rax
movss  %xmm3,(%rax,%r13,4)
add    $0x1,%rbx
cmp    %rbx,%r11
jne    11a0 <RGB_to_YUV+0xa0>
jmp    1180 <RGB_to_YUV+0x80>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @RGB_to_YUV(float** %0, float** %1, float** %2, float** %3, float** %4, float** %5, i64 %6, i64 %7) {
%9 = alloca float**
%10 = alloca float**
%11 = alloca float**
%12 = alloca float**
%13 = alloca float**
%14 = alloca float**
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
store float** %0, float*** %9
store float** %1, float*** %10
store float** %2, float*** %11
store float** %3, float*** %12
store float** %4, float*** %13
store float** %5, float*** %14
store i64 %6, i64* %15
store i64 %7, i64* %16
store i64 0, i64* %18
br label %19
19: ; preds = %140, %8
%20 = load i64, i64* %18
%21 = load i64, i64* %16
%22 = icmp slt i64 %20, %21
br i1 %22, label %23, label %143
23: ; preds = %19
store i64 0, i64* %17
br label %24
24: ; preds = %136, %23
%25 = load i64, i64* %17
%26 = load i64, i64* %15
%27 = icmp slt i64 %25, %26
br i1 %27, label %28, label %139
28: ; preds = %24
%29 = load float**, float*** %9
%30 = load i64, i64* %17
%31 = getelementptr inbounds float*, float** %29, i64 %30
%32 = load float*, float** %31
%33 = load i64, i64* %18
%34 = getelementptr inbounds float, float* %32, i64 %33
%35 = load float, float* %34
%36 = fpext float %35 to double
%37 = load float**, float*** %10
%38 = load i64, i64* %17
%39 = getelementptr inbounds float*, float** %37, i64 %38
%40 = load float*, float** %39
%41 = load i64, i64* %18
%42 = getelementptr inbounds float, float* %40, i64 %41
%43 = load float, float* %42
%44 = fpext float %43 to double
%45 = fmul double 5.212000e-01, %44
%46 = call double @llvm.fmuladd.f64(double 1.277000e-01, double %36, double %45)
%47 = load float**, float*** %11
%48 = load i64, i64* %17
%49 = getelementptr inbounds float*, float** %47, i64 %48
%50 = load float*, float** %49
%51 = load i64, i64* %18
%52 = getelementptr inbounds float, float* %50, i64 %51
%53 = load float, float* %52
%54 = fpext float %53 to double
%55 = call double @llvm.fmuladd.f64(double 2.100000e-01, double %54, double %46)
%56 = fadd double %55, 1.600000e+01
%57 = fptrunc double %56 to float
%58 = load float**, float*** %12
%59 = load i64, i64* %17
%60 = getelementptr inbounds float*, float** %58, i64 %59
%61 = load float*, float** %60
%62 = load i64, i64* %18
%63 = getelementptr inbounds float, float* %61, i64 %62
store float %57, float* %63
%64 = load float**, float*** %9
%65 = load i64, i64* %17
%66 = getelementptr inbounds float*, float** %64, i64 %65
%67 = load float*, float** %66
%68 = load i64, i64* %18
%69 = getelementptr inbounds float, float* %67, i64 %68
%70 = load float, float* %69
%71 = fpext float %70 to double
%72 = load float**, float*** %10
%73 = load i64, i64* %17
%74 = getelementptr inbounds float*, float** %72, i64 %73
%75 = load float*, float** %74
%76 = load i64, i64* %18
%77 = getelementptr inbounds float, float* %75, i64 %76
%78 = load float, float* %77
%79 = fpext float %78 to double
%80 = fmul double 3.007000e-01, %79
%81 = fneg double %80
%82 = call double @llvm.fmuladd.f64(double -7.370000e-02, double %71, double %81)
%83 = load float**, float*** %11
%84 = load i64, i64* %17
%85 = getelementptr inbounds float*, float** %83, i64 %84
%86 = load float*, float** %85
%87 = load i64, i64* %18
%88 = getelementptr inbounds float, float* %86, i64 %87
%89 = load float, float* %88
%90 = fpext float %89 to double
%91 = call double @llvm.fmuladd.f64(double 3.744000e-01, double %90, double %82)
%92 = fadd double %91, 1.280000e+02
%93 = fptrunc double %92 to float
%94 = load float**, float*** %13
%95 = load i64, i64* %17
%96 = getelementptr inbounds float*, float** %94, i64 %95
%97 = load float*, float** %96
%98 = load i64, i64* %18
%99 = getelementptr inbounds float, float* %97, i64 %98
store float %93, float* %99
%100 = load float**, float*** %9
%101 = load i64, i64* %17
%102 = getelementptr inbounds float*, float** %100, i64 %101
%103 = load float*, float** %102
%104 = load i64, i64* %18
%105 = getelementptr inbounds float, float* %103, i64 %104
%106 = load float, float* %105
%107 = fpext float %106 to double
%108 = load float**, float*** %10
%109 = load i64, i64* %17
%110 = getelementptr inbounds float*, float** %108, i64 %109
%111 = load float*, float** %110
%112 = load i64, i64* %18
%113 = getelementptr inbounds float, float* %111, i64 %112
%114 = load float, float* %113
%115 = fpext float %114 to double
%116 = fmul double 3.802000e-01, %115
%117 = fneg double %116
%118 = call double @llvm.fmuladd.f64(double 5.334000e-01, double %107, double %117)
%119 = load float**, float*** %11
%120 = load i64, i64* %17
%121 = getelementptr inbounds float*, float** %119, i64 %120
%122 = load float*, float** %121
%123 = load i64, i64* %18
%124 = getelementptr inbounds float, float* %122, i64 %123
%125 = load float, float* %124
%126 = fpext float %125 to double
%127 = call double @llvm.fmuladd.f64(double -1.532000e-01, double %126, double %118)
%128 = fadd double %127, 1.280000e+02
%129 = fptrunc double %128 to float
%130 = load float**, float*** %14
%131 = load i64, i64* %17
%132 = getelementptr inbounds float*, float** %130, i64 %131
%133 = load float*, float** %132
%134 = load i64, i64* %18
%135 = getelementptr inbounds float, float* %133, i64 %134
store float %129, float* %135
br label %136
136: ; preds = %28
%137 = load i64, i64* %17
%138 = add nsw i64 %137, 1
store i64 %138, i64* %17
br label %24
139: ; preds = %24
br label %140
140: ; preds = %139
%141 = load i64, i64* %18
%142 = add nsw i64 %141, 1
store i64 %142, i64* %18
br label %19
143: ; preds = %19
ret void
}

LLVM IR (-O2):
define void @RGB_to_YUV(float** nocapture %0, float** nocapture %1, float** nocapture %2, float** nocapture %3, float** nocapture %4, float** nocapture %5, i64 %6, i64 %7) {
%9 = icmp sgt i64 %7, 0
br i1 %9, label %10, label %72
10: ; preds = %8
%11 = icmp sgt i64 %6, 0
br label %12
12: ; preds = %10, %69
%13 = phi i64 [ 0, %10 ], [ %70, %69 ]
br i1 %11, label %14, label %69
14: ; preds = %12, %14
%15 = phi i64 [ %67, %14 ], [ 0, %12 ]
%16 = getelementptr inbounds float*, float** %0, i64 %15
%17 = load float*, float** %16
%18 = getelementptr inbounds float, float* %17, i64 %13
%19 = load float, float* %18
%20 = fpext float %19 to double
%21 = getelementptr inbounds float*, float** %1, i64 %15
%22 = load float*, float** %21
%23 = getelementptr inbounds float, float* %22, i64 %13
%24 = load float, float* %23
%25 = fpext float %24 to double
%26 = fmul double %25, 5.212000e-01
%27 = tail call double @llvm.fmuladd.f64(double %20, double 1.277000e-01, double %26)
%28 = getelementptr inbounds float*, float** %2, i64 %15
%29 = load float*, float** %28
%30 = getelementptr inbounds float, float* %29, i64 %13
%31 = load float, float* %30
%32 = fpext float %31 to double
%33 = tail call double @llvm.fmuladd.f64(double %32, double 2.100000e-01, double %27)
%34 = fadd double %33, 1.600000e+01
%35 = fptrunc double %34 to float
%36 = getelementptr inbounds float*, float** %3, i64 %15
%37 = load float*, float** %36
%38 = getelementptr inbounds float, float* %37, i64 %13
store float %35, float* %38
%39 = load float, float* %18
%40 = fpext float %39 to double
%41 = load float, float* %23
%42 = fpext float %41 to double
%43 = fmul double %42, -3.007000e-01
%44 = tail call double @llvm.fmuladd.f64(double %40, double -7.370000e-02, double %43)
%45 = load float, float* %30
%46 = fpext float %45 to double
%47 = tail call double @llvm.fmuladd.f64(double %46, double 3.744000e-01, double %44)
%48 = fadd double %47, 1.280000e+02
%49 = fptrunc double %48 to float
%50 = getelementptr inbounds float*, float** %4, i64 %15
%51 = load float*, float** %50
%52 = getelementptr inbounds float, float* %51, i64 %13
store float %49, float* %52
%53 = load float, float* %18
%54 = fpext float %53 to double
%55 = load float, float* %23
%56 = fpext float %55 to double
%57 = fmul double %56, -3.802000e-01
%58 = tail call double @llvm.fmuladd.f64(double %54, double 5.334000e-01, double %57)
%59 = load float, float* %30
%60 = fpext float %59 to double
%61 = tail call double @llvm.fmuladd.f64(double %60, double -1.532000e-01, double %58)
%62 = fadd double %61, 1.280000e+02
%63 = fptrunc double %62 to float
%64 = getelementptr inbounds float*, float** %5, i64 %15
%65 = load float*, float** %64
%66 = getelementptr inbounds float, float* %65, i64 %13
store float %63, float* %66
%67 = add nuw nsw i64 %15, 1
%68 = icmp eq i64 %67, %6
br i1 %68, label %69, label %14
69: ; preds = %14, %12
%70 = add nuw nsw i64 %13, 1
%71 = icmp eq i64 %70, %7
br i1 %71, label %72, label %12
72: ; preds = %69, %8
ret void
}