#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*/ GLuint;
typedef int /*<<< orphan*/ GLubyte;
typedef int GLsizei;
typedef int GLfloat;

/* Variables and functions */
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int);
int /*<<< orphan*/ free(int /*<<< orphan*/ *);
scalar_t__ malloc(int);
int /*<<< orphan*/ stderr;
GLuint *convert_to_luminance(GLuint *img, GLsizei w, GLsizei h) {
  GLubyte *newImg, *src, *dst;
  GLfloat val;
  int i;
  newImg = (GLubyte *)malloc(w * h);
  if (!newImg) {
    fprintf(stderr, "malloc of %d bytes failed\n", w * h);
    exit(1);
  }
  src = (GLubyte *)img;
  dst = newImg;
  for (i = 0; i < w * h; i++) {
    val = ((float)(*src++) * 0.3086 + (float)(*src++) * 0.6094 +
           (float)(*src++) * 0.0820);
    src++;
    if (val > 255)
      val = 255;
    *dst++ = val;
  }
  free(img);
  return (GLuint *)newImg;
}


x86 assembly (clang, -O0):
<convert_to_luminance>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0xc(%rbp),%edi
imul   -0x10(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1193 <convert_to_luminance+0x53>
mov    0x2e6c(%rip),%rax
mov    (%rax),%edi
mov    -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
lea    0xe94(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1060 <exit@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1276 <convert_to_luminance+0x136>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x20(%rbp)
cvtsi2ssl (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x20(%rbp)
cvtsi2ssl (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe1e(%rip),%xmm2
mulsd  %xmm2,%xmm0
movsd  0xe0a(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x20(%rbp)
cvtsi2ssl (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xddb(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
cmpl   $0xff,-0x2c(%rbp)
jle    1254 <convert_to_luminance+0x114>
movl   $0xff,-0x2c(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11aa <convert_to_luminance+0x6a>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convert_to_luminance>:
push   %r15
push   %r14
push   %rbx
mov    %esi,%ebx
mov    %rdi,%r14
imul   %edx,%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     1344 <convert_to_luminance+0x204>
mov    %rax,%r15
test   %ebx,%ebx
jle    1333 <convert_to_luminance+0x1f3>
lea    -0x1(%rbx),%esi
xor    %edx,%edx
cmp    $0x3,%esi
ja     117d <convert_to_luminance+0x3d>
mov    %r14,%rax
mov    %r15,%rcx
jmp    12b7 <convert_to_luminance+0x177>
mov    %rsi,%rax
shl    $0x4,%rax
add    %r14,%rax
add    $0xc,%rax
cmp    %rax,%r15
jae    11a7 <convert_to_luminance+0x67>
lea    (%r15,%rsi,4),%rdi
add    $0x4,%rdi
mov    %r14,%rax
mov    %r15,%rcx
cmp    %r14,%rdi
ja     12b7 <convert_to_luminance+0x177>
add    $0x1,%rsi
mov    %esi,%eax
and    $0x3,%eax
test   %rax,%rax
mov    $0x4,%ecx
cmovne %rax,%rcx
mov    %rsi,%rdx
sub    %rcx,%rdx
mov    %rdx,%rax
shl    $0x4,%rax
add    %r14,%rax
lea    (%r15,%rdx,4),%rcx
xor    %esi,%esi
movapd 0xe25(%rip),%xmm8
movapd 0xe2c(%rip),%xmm9
movapd 0xe33(%rip),%xmm10
movdqa 0xe3b(%rip),%xmm3
mov    %r14,%rdi
nopl   0x0(%rax,%rax,1)
movups (%rdi),%xmm1
movups 0x10(%rdi),%xmm6
movups 0x20(%rdi),%xmm0
movups 0x30(%rdi),%xmm5
movaps %xmm0,%xmm7
unpcklps %xmm5,%xmm7
movaps %xmm1,%xmm4
unpcklps %xmm6,%xmm4
movaps %xmm4,%xmm2
movlhps %xmm7,%xmm2
unpckhpd %xmm7,%xmm4
unpckhps %xmm5,%xmm0
cvtdq2ps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm5
unpckhps %xmm6,%xmm1
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
movlhps %xmm0,%xmm1
cvtdq2ps %xmm4,%xmm0
cvtps2pd %xmm0,%xmm4
movhlps %xmm0,%xmm0
cvtps2pd %xmm0,%xmm0
mulpd  %xmm8,%xmm0
mulpd  %xmm8,%xmm4
mulpd  %xmm9,%xmm5
addpd  %xmm4,%xmm5
mulpd  %xmm9,%xmm2
addpd  %xmm0,%xmm2
cvtdq2ps %xmm1,%xmm0
cvtps2pd %xmm0,%xmm1
movhlps %xmm0,%xmm0
cvtps2pd %xmm0,%xmm0
mulpd  %xmm10,%xmm0
mulpd  %xmm10,%xmm1
addpd  %xmm5,%xmm1
cvttpd2dq %xmm1,%xmm1
addpd  %xmm2,%xmm0
cvttpd2dq %xmm0,%xmm0
unpcklpd %xmm0,%xmm1
movdqa %xmm3,%xmm0
pcmpgtd %xmm1,%xmm0
pand   %xmm0,%xmm1
pandn  %xmm3,%xmm0
por    %xmm1,%xmm0
movdqu %xmm0,(%r15,%rsi,4)
add    $0x4,%rsi
add    $0x40,%rdi
cmp    %rsi,%rdx
jne    1200 <convert_to_luminance+0xc0>
sub    %edx,%ebx
xor    %edx,%edx
movsd  0xd7d(%rip),%xmm0
movsd  0xd7d(%rip),%xmm1
movsd  0xd7d(%rip),%xmm2
mov    $0xff,%esi
nopl   0x0(%rax,%rax,1)
xorps  %xmm3,%xmm3
cvtsi2ssl (%rax),%xmm3
cvtss2sd %xmm3,%xmm3
xorps  %xmm4,%xmm4
cvtsi2ssl 0x4(%rax),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm1,%xmm3
addsd  %xmm4,%xmm3
xorps  %xmm4,%xmm4
cvtsi2ssl 0x8(%rax),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
cvttsd2si %xmm4,%edi
cmp    $0xff,%edi
cmovge %esi,%edi
mov    %edi,(%rcx,%rdx,4)
add    $0x1,%rdx
add    $0x10,%rax
cmp    %edx,%ebx
jne    12e0 <convert_to_luminance+0x1a0>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rax
pop    %rbx
pop    %r14
pop    %r15
ret
mov    0x2c95(%rip),%rax
mov    (%rax),%edi
lea    0xd04(%rip),%rsi
mov    %ebx,%edx
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1060 <exit@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [27 x i8] c"malloc of %d bytes failed\0A\00"
define i32* @convert_to_luminance(i32* %0, i32 %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%12 = load i32, i32* %5
%13 = load i32, i32* %6
%14 = mul nsw i32 %12, %13
%15 = call i64 @malloc(i32 %14)
%16 = inttoptr i64 %15 to i32*
store i32* %16, i32** %7
%17 = load i32*, i32** %7
%18 = icmp ne i32* %17, null
br i1 %18, label %26, label %19
19: ; preds = %3
%20 = load i32, i32* @stderr
%21 = load i32, i32* %5
%22 = load i32, i32* %6
%23 = mul nsw i32 %21, %22
%24 = call i32 @fprintf(i32 %20, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i32 %23)
%25 = call i32 @exit(i32 1)
unreachable
26: ; preds = %3
%27 = load i32*, i32** %4
store i32* %27, i32** %8
%28 = load i32*, i32** %7
store i32* %28, i32** %9
store i32 0, i32* %11
br label %29
29: ; preds = %64, %26
%30 = load i32, i32* %11
%31 = load i32, i32* %5
%32 = load i32, i32* %6
%33 = mul nsw i32 %31, %32
%34 = icmp slt i32 %30, %33
br i1 %34, label %35, label %67
35: ; preds = %29
%36 = load i32*, i32** %8
%37 = getelementptr inbounds i32, i32* %36, i32 1
store i32* %37, i32** %8
%38 = load i32, i32* %36
%39 = sitofp i32 %38 to float
%40 = fpext float %39 to double
%41 = load i32*, i32** %8
%42 = getelementptr inbounds i32, i32* %41, i32 1
store i32* %42, i32** %8
%43 = load i32, i32* %41
%44 = sitofp i32 %43 to float
%45 = fpext float %44 to double
%46 = fmul double %45, 6.094000e-01
%47 = call double @llvm.fmuladd.f64(double %40, double 3.086000e-01, double %46)
%48 = load i32*, i32** %8
%49 = getelementptr inbounds i32, i32* %48, i32 1
store i32* %49, i32** %8
%50 = load i32, i32* %48
%51 = sitofp i32 %50 to float
%52 = fpext float %51 to double
%53 = call double @llvm.fmuladd.f64(double %52, double 8.200000e-02, double %47)
%54 = fptosi double %53 to i32
store i32 %54, i32* %10
%55 = load i32*, i32** %8
%56 = getelementptr inbounds i32, i32* %55, i32 1
store i32* %56, i32** %8
%57 = load i32, i32* %10
%58 = icmp sgt i32 %57, 255
br i1 %58, label %59, label %60
59: ; preds = %35
store i32 255, i32* %10
br label %60
60: ; preds = %59, %35
%61 = load i32, i32* %10
%62 = load i32*, i32** %9
%63 = getelementptr inbounds i32, i32* %62, i32 1
store i32* %63, i32** %9
store i32 %61, i32* %62
br label %64
64: ; preds = %60
%65 = load i32, i32* %11
%66 = add nsw i32 %65, 1
store i32 %66, i32* %11
br label %29
67: ; preds = %29
%68 = load i32*, i32** %4
%69 = call i32 @free(i32* %68)
%70 = load i32*, i32** %7
ret i32* %70
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [27 x i8] c"malloc of %d bytes failed\0A\00"
define i32* @convert_to_luminance(i32* nocapture %0, i32 %1, i32 %2) {
%4 = mul nsw i32 %2, %1
%5 = tail call i64 @malloc(i32 %4)
%6 = inttoptr i64 %5 to i32*
%7 = inttoptr i64 %5 to i8*
%8 = icmp eq i64 %5, 0
br i1 %8, label %66, label %9
9: ; preds = %3
%10 = icmp sgt i32 %4, 0
br i1 %10, label %11, label %95
11: ; preds = %9
%12 = add i32 %4, -1
%13 = zext i32 %12 to i64
%14 = add nuw nsw i64 %13, 1
%15 = icmp ult i32 %12, 4
br i1 %15, label %16, label %20
16: ; preds = %41, %20, %11
%17 = phi i32 [ 0, %20 ], [ 0, %11 ], [ %37, %41 ]
%18 = phi i32* [ %0, %20 ], [ %0, %11 ], [ %39, %41 ]
%19 = phi i32* [ %6, %20 ], [ %6, %11 ], [ %40, %41 ]
br label %70
20: ; preds = %11
%21 = add i32 %4, -1
%22 = zext i32 %21 to i64
%23 = add nuw nsw i64 %22, 1
%24 = getelementptr i32, i32* %6, i64 %23
%25 = shl nuw nsw i64 %22, 2
%26 = or i64 %25, 3
%27 = getelementptr i32, i32* %0, i64 %26
%28 = bitcast i32* %27 to i8*
%29 = icmp ult i8* %7, %28
%30 = icmp ugt i32* %24, %0
%31 = and i1 %29, %30
br i1 %31, label %16, label %32
32: ; preds = %20
%33 = and i64 %14, 3
%34 = icmp eq i64 %33, 0
%35 = select i1 %34, i64 4, i64 %33
%36 = sub nsw i64 %14, %35
%37 = trunc i64 %36 to i32
%38 = shl nsw i64 %36, 2
%39 = getelementptr i32, i32* %0, i64 %38
%40 = getelementptr i32, i32* %6, i64 %36
br label %41
41: ; preds = %41, %32
%42 = phi i64 [ 0, %32 ], [ %64, %41 ]
%43 = shl i64 %42, 2
%44 = getelementptr i32, i32* %0, i64 %43
%45 = getelementptr i32, i32* %6, i64 %42
%46 = bitcast i32* %44 to <16 x i32>*
%47 = load <16 x i32>, <16 x i32>* %46
%48 = shufflevector <16 x i32> %47, <16 x i32> poison, <4 x i32> <i32 0, i32 4, i32 8, i32 12>
%49 = shufflevector <16 x i32> %47, <16 x i32> poison, <4 x i32> <i32 1, i32 5, i32 9, i32 13>
%50 = shufflevector <16 x i32> %47, <16 x i32> poison, <4 x i32> <i32 2, i32 6, i32 10, i32 14>
%51 = sitofp <4 x i32> %48 to <4 x float>
%52 = fpext <4 x float> %51 to <4 x double>
%53 = sitofp <4 x i32> %49 to <4 x float>
%54 = fpext <4 x float> %53 to <4 x double>
%55 = fmul <4 x double> %54, <double 6.094000e-01, double 6.094000e-01, double 6.094000e-01, double 6.094000e-01>
%56 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %52, <4 x double> <double 3.086000e-01, double 3.086000e-01, double 3.086000e-01, double 3.086000e-01>, <4 x double> %55)
%57 = sitofp <4 x i32> %50 to <4 x float>
%58 = fpext <4 x float> %57 to <4 x double>
%59 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %58, <4 x double> <double 8.200000e-02, double 8.200000e-02, double 8.200000e-02, double 8.200000e-02>, <4 x double> %56)
%60 = fptosi <4 x double> %59 to <4 x i32>
%61 = icmp slt <4 x i32> %60, <i32 255, i32 255, i32 255, i32 255>
%62 = select <4 x i1> %61, <4 x i32> %60, <4 x i32> <i32 255, i32 255, i32 255, i32 255>
%63 = bitcast i32* %45 to <4 x i32>*
store <4 x i32> %62, <4 x i32>* %63
%64 = add nuw i64 %42, 4
%65 = icmp eq i64 %64, %36
br i1 %65, label %16, label %41
66: ; preds = %3
%67 = load i32, i32* @stderr
%68 = tail call i32 @fprintf(i32 %67, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i32 %4)
%69 = tail call i32 @exit(i32 1)
unreachable
70: ; preds = %16, %70
%71 = phi i32 [ %93, %70 ], [ %17, %16 ]
%72 = phi i32* [ %89, %70 ], [ %18, %16 ]
%73 = phi i32* [ %92, %70 ], [ %19, %16 ]
%74 = getelementptr inbounds i32, i32* %72, i64 1
%75 = load i32, i32* %72
%76 = sitofp i32 %75 to float
%77 = fpext float %76 to double
%78 = getelementptr inbounds i32, i32* %72, i64 2
%79 = load i32, i32* %74
%80 = sitofp i32 %79 to float
%81 = fpext float %80 to double
%82 = fmul double %81, 6.094000e-01
%83 = tail call double @llvm.fmuladd.f64(double %77, double 3.086000e-01, double %82)
%84 = load i32, i32* %78
%85 = sitofp i32 %84 to float
%86 = fpext float %85 to double
%87 = tail call double @llvm.fmuladd.f64(double %86, double 8.200000e-02, double %83)
%88 = fptosi double %87 to i32
%89 = getelementptr inbounds i32, i32* %72, i64 4
%90 = icmp slt i32 %88, 255
%91 = select i1 %90, i32 %88, i32 255
%92 = getelementptr inbounds i32, i32* %73, i64 1
store i32 %91, i32* %73
%93 = add nuw nsw i32 %71, 1
%94 = icmp eq i32 %93, %4
br i1 %94, label %95, label %70
95: ; preds = %70, %9
%96 = tail call i32 @free(i32* %0)
ret i32* %6
}