#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 */
int /*<<< orphan*/ YUVtoHSV(float *, float *, float *);
void YUV_to_HSVimg(float **Y, float **U, float **V, float **H, float **S,
                   float **Va, long nx, long ny) {
  float red, green, blue;
  float rgbmin, rgbmax;
  long i, j;
  float yuv[3], rgb[3], hsv[3];
  for (j = 0; j < ny; j++)
    for (i = 0; i < nx; i++) {
      yuv[0] = Y[i][j];
      yuv[1] = U[i][j];
      yuv[2] = V[i][j];
      YUVtoHSV(&(yuv[0]), &(rgb[0]), &(hsv[0]));
    }
  H[i][j] = hsv[0];
  S[i][j] = hsv[1];
  Va[i][j] = hsv[2];
}


x86 assembly (clang, -O0):
<YUV_to_HSVimg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
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,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    0x18(%rbp),%rax
jge    11ed <YUV_to_HSVimg+0xdd>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    0x10(%rbp),%rax
jge    11d7 <YUV_to_HSVimg+0xc7>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
lea    -0x64(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0x7c(%rbp),%rdx
call   1030 <YUVtoHSV@plt>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1159 <YUV_to_HSVimg+0x49>
jmp    11dc <YUV_to_HSVimg+0xcc>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1143 <YUV_to_HSVimg+0x33>
movss  -0x7c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<YUV_to_HSVimg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    0x98(%rsp),%rax
test   %rax,%rax
jle    1208 <YUV_to_HSVimg+0xf8>
mov    %rdx,%rbx
mov    %rcx,0x20(%rsp)
mov    %r8,0x28(%rsp)
mov    %r9,0x30(%rsp)
mov    0x90(%rsp),%r12
xor    %r14d,%r14d
lea    0x14(%rsp),%r13
lea    0x4c(%rsp),%rbp
lea    0x8(%rsp),%r8
mov    %rdi,0x40(%rsp)
mov    %rsi,0x38(%rsp)
jmp    1181 <YUV_to_HSVimg+0x71>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
mov    0x98(%rsp),%rdx
cmp    %rdx,%r14
je     11e8 <YUV_to_HSVimg+0xd8>
test   %r12,%r12
jle    1170 <YUV_to_HSVimg+0x60>
xor    %r15d,%r15d
nopl   0x0(%rax)
mov    (%rdi,%r15,8),%rax
movss  (%rax,%r14,4),%xmm0
movss  %xmm0,0x14(%rsp)
mov    (%rsi,%r15,8),%rax
movss  (%rax,%r14,4),%xmm0
movss  %xmm0,0x18(%rsp)
mov    (%rbx,%r15,8),%rax
movss  (%rax,%r14,4),%xmm0
movss  %xmm0,0x1c(%rsp)
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %r8,%rdx
call   1030 <YUVtoHSV@plt>
lea    0x8(%rsp),%r8
mov    0x40(%rsp),%rdi
mov    0x38(%rsp),%rsi
add    $0x1,%r15
cmp    %r15,%r12
jne    1190 <YUV_to_HSVimg+0x80>
jmp    1170 <YUV_to_HSVimg+0x60>
xor    %eax,%eax
test   %r12,%r12
cmovg  %r12,%rax
movss  0x8(%rsp),%xmm0
mov    0x30(%rsp),%r9
mov    0x28(%rsp),%r8
mov    0x20(%rsp),%rcx
jmp    120a <YUV_to_HSVimg+0xfa>
xor    %edx,%edx
mov    (%rcx,%rax,8),%rcx
movss  %xmm0,(%rcx,%rdx,4)
movss  0xc(%rsp),%xmm0
mov    (%r8,%rax,8),%rcx
movss  %xmm0,(%rcx,%rdx,4)
movss  0x10(%rsp),%xmm0
mov    (%r9,%rax,8),%rax
movss  %xmm0,(%rax,%rdx,4)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @YUV_to_HSVimg(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 float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca i64
%23 = alloca i64
%24 = alloca [3 x float]
%25 = alloca [3 x float]
%26 = alloca [3 x float]
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* %23
br label %27
27: ; preds = %69, %8
%28 = load i64, i64* %23
%29 = load i64, i64* %16
%30 = icmp slt i64 %28, %29
br i1 %30, label %31, label %72
31: ; preds = %27
store i64 0, i64* %22
br label %32
32: ; preds = %65, %31
%33 = load i64, i64* %22
%34 = load i64, i64* %15
%35 = icmp slt i64 %33, %34
br i1 %35, label %36, label %68
36: ; preds = %32
%37 = load float**, float*** %9
%38 = load i64, i64* %22
%39 = getelementptr inbounds float*, float** %37, i64 %38
%40 = load float*, float** %39
%41 = load i64, i64* %23
%42 = getelementptr inbounds float, float* %40, i64 %41
%43 = load float, float* %42
%44 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 0
store float %43, float* %44
%45 = load float**, float*** %10
%46 = load i64, i64* %22
%47 = getelementptr inbounds float*, float** %45, i64 %46
%48 = load float*, float** %47
%49 = load i64, i64* %23
%50 = getelementptr inbounds float, float* %48, i64 %49
%51 = load float, float* %50
%52 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 1
store float %51, float* %52
%53 = load float**, float*** %11
%54 = load i64, i64* %22
%55 = getelementptr inbounds float*, float** %53, i64 %54
%56 = load float*, float** %55
%57 = load i64, i64* %23
%58 = getelementptr inbounds float, float* %56, i64 %57
%59 = load float, float* %58
%60 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 2
store float %59, float* %60
%61 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 0
%62 = getelementptr inbounds [3 x float], [3 x float]* %25, i64 0, i64 0
%63 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
%64 = call i32 @YUVtoHSV(float* %61, float* %62, float* %63)
br label %65
65: ; preds = %36
%66 = load i64, i64* %22
%67 = add nsw i64 %66, 1
store i64 %67, i64* %22
br label %32
68: ; preds = %32
br label %69
69: ; preds = %68
%70 = load i64, i64* %23
%71 = add nsw i64 %70, 1
store i64 %71, i64* %23
br label %27
72: ; preds = %27
%73 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
%74 = load float, float* %73
%75 = load float**, float*** %12
%76 = load i64, i64* %22
%77 = getelementptr inbounds float*, float** %75, i64 %76
%78 = load float*, float** %77
%79 = load i64, i64* %23
%80 = getelementptr inbounds float, float* %78, i64 %79
store float %74, float* %80
%81 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 1
%82 = load float, float* %81
%83 = load float**, float*** %13
%84 = load i64, i64* %22
%85 = getelementptr inbounds float*, float** %83, i64 %84
%86 = load float*, float** %85
%87 = load i64, i64* %23
%88 = getelementptr inbounds float, float* %86, i64 %87
store float %82, float* %88
%89 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 2
%90 = load float, float* %89
%91 = load float**, float*** %14
%92 = load i64, i64* %22
%93 = getelementptr inbounds float*, float** %91, i64 %92
%94 = load float*, float** %93
%95 = load i64, i64* %23
%96 = getelementptr inbounds float, float* %94, i64 %95
store float %90, float* %96
ret void
}

LLVM IR (-O2):
define void @YUV_to_HSVimg(float** nocapture %0, float** nocapture %1, float** nocapture %2, float** nocapture %3, float** nocapture %4, float** nocapture %5, i64 %6, i64 %7) {
%9 = alloca [3 x float]
%10 = alloca [3 x float]
%11 = alloca [3 x float]
%12 = bitcast [3 x float]* %9 to i8*
%13 = bitcast [3 x float]* %10 to i8*
%14 = bitcast [3 x float]* %11 to i8*
%15 = icmp sgt i64 %7, 0
br i1 %15, label %16, label %48
16: ; preds = %8
%17 = icmp sgt i64 %6, 0
%18 = getelementptr inbounds [3 x float], [3 x float]* %9, i64 0, i64 0
%19 = getelementptr inbounds [3 x float], [3 x float]* %9, i64 0, i64 1
%20 = getelementptr inbounds [3 x float], [3 x float]* %9, i64 0, i64 2
%21 = getelementptr inbounds [3 x float], [3 x float]* %10, i64 0, i64 0
%22 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 0
br label %23
23: ; preds = %16, %42
%24 = phi i64 [ 0, %16 ], [ %43, %42 ]
br i1 %17, label %25, label %42
25: ; preds = %23, %25
%26 = phi i64 [ %40, %25 ], [ 0, %23 ]
%27 = getelementptr inbounds float*, float** %0, i64 %26
%28 = load float*, float** %27
%29 = getelementptr inbounds float, float* %28, i64 %24
%30 = load float, float* %29
store float %30, float* %18
%31 = getelementptr inbounds float*, float** %1, i64 %26
%32 = load float*, float** %31
%33 = getelementptr inbounds float, float* %32, i64 %24
%34 = load float, float* %33
store float %34, float* %19
%35 = getelementptr inbounds float*, float** %2, i64 %26
%36 = load float*, float** %35
%37 = getelementptr inbounds float, float* %36, i64 %24
%38 = load float, float* %37
store float %38, float* %20
%39 = call i32 @YUVtoHSV(float* %18, float* %21, float* %22)
%40 = add nuw nsw i64 %26, 1
%41 = icmp eq i64 %40, %6
br i1 %41, label %42, label %25
42: ; preds = %25, %23
%43 = add nuw nsw i64 %24, 1
%44 = icmp eq i64 %43, %7
br i1 %44, label %45, label %23
45: ; preds = %42
%46 = call i64 @llvm.smax.i64(i64 %6, i64 0)
%47 = load float, float* %22
br label %48
48: ; preds = %45, %8
%49 = phi float [ undef, %8 ], [ %47, %45 ]
%50 = phi i64 [ undef, %8 ], [ %46, %45 ]
%51 = phi i64 [ 0, %8 ], [ %7, %45 ]
%52 = getelementptr inbounds float*, float** %3, i64 %50
%53 = load float*, float** %52
%54 = getelementptr inbounds float, float* %53, i64 %51
store float %49, float* %54
%55 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 1
%56 = load float, float* %55
%57 = getelementptr inbounds float*, float** %4, i64 %50
%58 = load float*, float** %57
%59 = getelementptr inbounds float, float* %58, i64 %51
store float %56, float* %59
%60 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 2
%61 = load float, float* %60
%62 = getelementptr inbounds float*, float** %5, i64 %50
%63 = load float*, float** %62
%64 = getelementptr inbounds float, float* %63, i64 %51
store float %61, float* %64
ret void
}