#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*/ ptrdiff_t;

/* Variables and functions */
void copyCairoToWxWidgets(float r, float g, float b, ptrdiff_t size,
                          unsigned char *cairo, unsigned char *wx) {
  unsigned char *cairoEnd = cairo + size;
  while (cairo < cairoEnd) {
    float a = 1 - (float)cairo[3] / 255;
    wx[0] = (unsigned char)((float)cairo[2] + r * a);
    wx[1] = (unsigned char)((float)cairo[1] + g * a);
    wx[2] = (unsigned char)((float)cairo[0] + b * a);
    cairo += 4;
    wx += 3;
  }
}


x86 assembly (clang, -O0):
<copyCairoToWxWidgets>:
push   %rbp
mov    %rsp,%rbp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
mov    %edi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x10(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1200 <copyCairoToWxWidgets+0x100>
mov    -0x18(%rbp),%rax
movzbl 0x3(%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xeb1(%rip),%xmm1
divss  %xmm1,%xmm0
movss  0xea9(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
cvtsi2ss %eax,%xmm1
movss  -0x4(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
cvtsi2ss %eax,%xmm1
movss  -0x8(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
cvtsi2ss %eax,%xmm1
movss  -0xc(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x20(%rbp)
jmp    112d <copyCairoToWxWidgets+0x2d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<copyCairoToWxWidgets>:
push   %rbp
push   %r14
push   %rbx
test   %edi,%edi
jle    11f2 <copyCairoToWxWidgets+0xf2>
movslq %edi,%r10
add    %rsi,%r10
lea    0x4(%rsi),%rax
cmp    %rax,%r10
mov    %rax,%r8
cmova  %r10,%r8
mov    %rsi,%rcx
not    %rcx
add    %rcx,%r8
cmp    $0xc,%r8
jb     1169 <copyCairoToWxWidgets+0x69>
cmp    %rax,%r10
cmova  %r10,%rax
lea    (%rax,%rcx,1),%rdi
add    $0x4,%rdi
and    $0xfffffffffffffffc,%rdi
add    %rsi,%rdi
cmp    %rdx,%rdi
jbe    11f7 <copyCairoToWxWidgets+0xf7>
add    %rcx,%rax
shr    $0x2,%rax
lea    (%rax,%rax,2),%rax
add    %rdx,%rax
add    $0x3,%rax
cmp    %rsi,%rax
jbe    11f7 <copyCairoToWxWidgets+0xf7>
mov    %rsi,%rcx
mov    %rdx,%rdi
movss  0xeb9(%rip),%xmm3
movss  0xeb5(%rip),%xmm4
nop
movzbl 0x3(%rcx),%eax
xorps  %xmm5,%xmm5
cvtsi2ss %eax,%xmm5
movzbl 0x2(%rcx),%eax
xorps  %xmm6,%xmm6
cvtsi2ss %eax,%xmm6
divss  %xmm3,%xmm5
addss  %xmm4,%xmm5
movaps %xmm0,%xmm7
mulss  %xmm5,%xmm7
addss  %xmm6,%xmm7
cvttss2si %xmm7,%eax
mov    %al,(%rdi)
movzbl 0x1(%rcx),%eax
xorps  %xmm6,%xmm6
cvtsi2ss %eax,%xmm6
movaps %xmm1,%xmm7
mulss  %xmm5,%xmm7
addss  %xmm6,%xmm7
cvttss2si %xmm7,%eax
mov    %al,0x1(%rdi)
movzbl (%rcx),%eax
xorps  %xmm6,%xmm6
cvtsi2ss %eax,%xmm6
mulss  %xmm2,%xmm5
addss  %xmm6,%xmm5
cvttss2si %xmm5,%eax
mov    %al,0x2(%rdi)
add    $0x4,%rcx
add    $0x3,%rdi
cmp    %r10,%rcx
jb     1180 <copyCairoToWxWidgets+0x80>
pop    %rbx
pop    %r14
pop    %rbp
ret
shr    $0x2,%r8
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
lea    (%rsi,%r9,4),%rcx
lea    (%r9,%r9,2),%rdi
add    %rdx,%rdi
movaps %xmm0,%xmm11
shufps $0x0,%xmm0,%xmm11
movaps %xmm1,%xmm12
shufps $0x0,%xmm1,%xmm12
movaps %xmm2,%xmm13
shufps $0x0,%xmm2,%xmm13
xor    %eax,%eax
pxor   %xmm14,%xmm14
movaps 0xdc5(%rip),%xmm8
movaps 0xdcd(%rip),%xmm9
movdqa 0xdd4(%rip),%xmm10
nopl   0x0(%rax)
movzbl 0x3(%rsi,%rax,4),%r11d
movzbl 0xb(%rsi,%rax,4),%r14d
movzbl 0x7(%rsi,%rax,4),%ebp
shl    $0x8,%ebp
or     %r11d,%ebp
movzbl 0xf(%rsi,%rax,4),%ebx
shl    $0x8,%ebx
or     %r14d,%ebx
movd   %ebp,%xmm7
pinsrw $0x1,%ebx,%xmm7
punpcklbw %xmm14,%xmm7
punpcklwd %xmm14,%xmm7
cvtdq2ps %xmm7,%xmm7
divps  %xmm8,%xmm7
movzbl 0x2(%rsi,%rax,4),%r11d
movzbl 0xa(%rsi,%rax,4),%ebx
movzbl 0xe(%rsi,%rax,4),%ebp
shl    $0x8,%ebp
or     %ebx,%ebp
movzbl 0x6(%rsi,%rax,4),%ebx
shl    $0x8,%ebx
or     %r11d,%ebx
movd   %ebx,%xmm3
movzbl 0x1(%rsi,%rax,4),%r11d
movzbl 0x9(%rsi,%rax,4),%ebx
pinsrw $0x1,%ebp,%xmm3
movzbl 0xd(%rsi,%rax,4),%ebp
shl    $0x8,%ebp
or     %ebx,%ebp
punpcklbw %xmm14,%xmm3
movzbl 0x5(%rsi,%rax,4),%ebx
shl    $0x8,%ebx
or     %r11d,%ebx
punpcklwd %xmm14,%xmm3
movd   %ebx,%xmm4
pinsrw $0x1,%ebp,%xmm4
addps  %xmm9,%xmm7
cvtdq2ps %xmm3,%xmm3
movaps %xmm11,%xmm5
punpcklbw %xmm14,%xmm4
punpcklwd %xmm14,%xmm4
mulps  %xmm7,%xmm5
cvtdq2ps %xmm4,%xmm4
movaps %xmm12,%xmm6
movzbl (%rsi,%rax,4),%r11d
movzbl 0x8(%rsi,%rax,4),%ebx
mulps  %xmm7,%xmm6
movzbl 0xc(%rsi,%rax,4),%ebp
shl    $0x8,%ebp
or     %ebx,%ebp
addps  %xmm3,%xmm5
movzbl 0x4(%rsi,%rax,4),%ebx
shl    $0x8,%ebx
or     %r11d,%ebx
addps  %xmm4,%xmm6
movd   %ebx,%xmm3
pinsrw $0x1,%ebp,%xmm3
cvttps2dq %xmm5,%xmm4
cvttps2dq %xmm6,%xmm5
punpcklbw %xmm14,%xmm3
punpcklwd %xmm14,%xmm3
packuswb %xmm5,%xmm4
cvtdq2ps %xmm3,%xmm3
mulps  %xmm13,%xmm7
addps  %xmm3,%xmm7
packuswb %xmm4,%xmm4
cvttps2dq %xmm7,%xmm3
punpcklbw %xmm14,%xmm4
pshufd $0xe7,%xmm4,%xmm5
pshuflw $0xdc,%xmm5,%xmm5
pshufhw $0xc6,%xmm4,%xmm4
pshufd $0x6c,%xmm4,%xmm4
pshuflw $0x68,%xmm4,%xmm4
pshufhw $0x25,%xmm4,%xmm4
pshuflw $0xe8,%xmm3,%xmm3
pshufhw $0xe8,%xmm3,%xmm3
pshufd $0xe8,%xmm3,%xmm3
packuswb %xmm5,%xmm4
punpcklbw %xmm3,%xmm3
pshuflw $0xe0,%xmm3,%xmm3
pshufhw $0xe8,%xmm3,%xmm3
movdqa %xmm10,%xmm5
pand   %xmm10,%xmm4
pandn  %xmm3,%xmm5
por    %xmm4,%xmm5
movq   %xmm5,(%rdx)
pshufd $0xee,%xmm5,%xmm3
movd   %xmm3,0x8(%rdx)
add    $0x4,%rax
add    $0xc,%rdx
cmp    %rax,%r9
jne    1250 <copyCairoToWxWidgets+0x150>
cmp    %r9,%r8
jne    116f <copyCairoToWxWidgets+0x6f>
jmp    11f2 <copyCairoToWxWidgets+0xf2>

LLVM IR (-O0):
define void @copyCairoToWxWidgets(float %0, float %1, float %2, i32 %3, i8* %4, i8* %5) {
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca float
store float %0, float* %7
store float %1, float* %8
store float %2, float* %9
store i32 %3, i32* %10
store i8* %4, i8** %11
store i8* %5, i8** %12
%15 = load i8*, i8** %11
%16 = load i32, i32* %10
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i8, i8* %15, i64 %17
store i8* %18, i8** %13
br label %19
19: ; preds = %23, %6
%20 = load i8*, i8** %11
%21 = load i8*, i8** %13
%22 = icmp ult i8* %20, %21
br i1 %22, label %23, label %64
23: ; preds = %19
%24 = load i8*, i8** %11
%25 = getelementptr inbounds i8, i8* %24, i64 3
%26 = load i8, i8* %25
%27 = uitofp i8 %26 to float
%28 = fdiv float %27, 2.550000e+02
%29 = fsub float 1.000000e+00, %28
store float %29, float* %14
%30 = load i8*, i8** %11
%31 = getelementptr inbounds i8, i8* %30, i64 2
%32 = load i8, i8* %31
%33 = uitofp i8 %32 to float
%34 = load float, float* %7
%35 = load float, float* %14
%36 = call float @llvm.fmuladd.f32(float %34, float %35, float %33)
%37 = fptoui float %36 to i8
%38 = load i8*, i8** %12
%39 = getelementptr inbounds i8, i8* %38, i64 0
store i8 %37, i8* %39
%40 = load i8*, i8** %11
%41 = getelementptr inbounds i8, i8* %40, i64 1
%42 = load i8, i8* %41
%43 = uitofp i8 %42 to float
%44 = load float, float* %8
%45 = load float, float* %14
%46 = call float @llvm.fmuladd.f32(float %44, float %45, float %43)
%47 = fptoui float %46 to i8
%48 = load i8*, i8** %12
%49 = getelementptr inbounds i8, i8* %48, i64 1
store i8 %47, i8* %49
%50 = load i8*, i8** %11
%51 = getelementptr inbounds i8, i8* %50, i64 0
%52 = load i8, i8* %51
%53 = uitofp i8 %52 to float
%54 = load float, float* %9
%55 = load float, float* %14
%56 = call float @llvm.fmuladd.f32(float %54, float %55, float %53)
%57 = fptoui float %56 to i8
%58 = load i8*, i8** %12
%59 = getelementptr inbounds i8, i8* %58, i64 2
store i8 %57, i8* %59
%60 = load i8*, i8** %11
%61 = getelementptr inbounds i8, i8* %60, i64 4
store i8* %61, i8** %11
%62 = load i8*, i8** %12
%63 = getelementptr inbounds i8, i8* %62, i64 3
store i8* %63, i8** %12
br label %19
64: ; preds = %19
ret void
}

LLVM IR (-O2):
define void @copyCairoToWxWidgets(float %0, float %1, float %2, i32 %3, i8* %4, i8* nocapture writeonly %5) {
%7 = ptrtoint i8* %4 to i64
%8 = sext i32 %3 to i64
%9 = getelementptr inbounds i8, i8* %4, i64 %8
%10 = icmp sgt i32 %3, 0
br i1 %10, label %11, label %157
11: ; preds = %6
%12 = add i64 %7, %8
%13 = add i64 %7, 4
%14 = call i64 @llvm.umax.i64(i64 %12, i64 %13)
%15 = xor i64 %7, -1
%16 = add i64 %14, %15
%17 = lshr i64 %16, 2
%18 = add nuw nsw i64 %17, 1
%19 = icmp ult i64 %16, 12
br i1 %19, label %127, label %20
20: ; preds = %11
%21 = add i64 %7, %8
%22 = add i64 %7, 4
%23 = call i64 @llvm.umax.i64(i64 %21, i64 %22)
%24 = xor i64 %7, -1
%25 = add i64 %23, %24
%26 = lshr i64 %25, 2
%27 = mul nuw i64 %26, 3
%28 = add nuw i64 %27, 3
%29 = getelementptr i8, i8* %5, i64 %28
%30 = add i64 %25, 4
%31 = and i64 %30, -4
%32 = getelementptr i8, i8* %4, i64 %31
%33 = icmp ugt i8* %32, %5
%34 = icmp ugt i8* %29, %4
%35 = and i1 %33, %34
br i1 %35, label %127, label %36
36: ; preds = %20
%37 = and i64 %18, 9223372036854775804
%38 = shl i64 %37, 2
%39 = getelementptr i8, i8* %4, i64 %38
%40 = mul i64 %37, 3
%41 = getelementptr i8, i8* %5, i64 %40
%42 = insertelement <4 x float> poison, float %0, i64 0
%43 = shufflevector <4 x float> %42, <4 x float> poison, <4 x i32> zeroinitializer
%44 = insertelement <4 x float> poison, float %1, i64 0
%45 = shufflevector <4 x float> %44, <4 x float> poison, <4 x i32> zeroinitializer
%46 = insertelement <4 x float> poison, float %2, i64 0
%47 = shufflevector <4 x float> %46, <4 x float> poison, <4 x i32> zeroinitializer
br label %48
48: ; preds = %48, %36
%49 = phi i64 [ 0, %36 ], [ %123, %48 ]
%50 = shl i64 %49, 2
%51 = getelementptr i8, i8* %4, i64 %50
%52 = shl i64 %49, 2
%53 = or i64 %52, 4
%54 = getelementptr i8, i8* %4, i64 %53
%55 = shl i64 %49, 2
%56 = or i64 %55, 8
%57 = getelementptr i8, i8* %4, i64 %56
%58 = shl i64 %49, 2
%59 = or i64 %58, 12
%60 = getelementptr i8, i8* %4, i64 %59
%61 = mul i64 %49, 3
%62 = getelementptr inbounds i8, i8* %51, i64 3
%63 = getelementptr inbounds i8, i8* %54, i64 3
%64 = getelementptr inbounds i8, i8* %57, i64 3
%65 = getelementptr inbounds i8, i8* %60, i64 3
%66 = load i8, i8* %62
%67 = load i8, i8* %63
%68 = load i8, i8* %64
%69 = load i8, i8* %65
%70 = insertelement <4 x i8> poison, i8 %66, i64 0
%71 = insertelement <4 x i8> %70, i8 %67, i64 1
%72 = insertelement <4 x i8> %71, i8 %68, i64 2
%73 = insertelement <4 x i8> %72, i8 %69, i64 3
%74 = uitofp <4 x i8> %73 to <4 x float>
%75 = fdiv <4 x float> %74, <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>
%76 = fsub <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %75
%77 = getelementptr inbounds i8, i8* %51, i64 2
%78 = getelementptr inbounds i8, i8* %54, i64 2
%79 = getelementptr inbounds i8, i8* %57, i64 2
%80 = getelementptr inbounds i8, i8* %60, i64 2
%81 = load i8, i8* %77
%82 = load i8, i8* %78
%83 = load i8, i8* %79
%84 = load i8, i8* %80
%85 = insertelement <4 x i8> poison, i8 %81, i64 0
%86 = insertelement <4 x i8> %85, i8 %82, i64 1
%87 = insertelement <4 x i8> %86, i8 %83, i64 2
%88 = insertelement <4 x i8> %87, i8 %84, i64 3
%89 = uitofp <4 x i8> %88 to <4 x float>
%90 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %43, <4 x float> %76, <4 x float> %89)
%91 = fptoui <4 x float> %90 to <4 x i8>
%92 = getelementptr inbounds i8, i8* %51, i64 1
%93 = getelementptr inbounds i8, i8* %54, i64 1
%94 = getelementptr inbounds i8, i8* %57, i64 1
%95 = getelementptr inbounds i8, i8* %60, i64 1
%96 = load i8, i8* %92
%97 = load i8, i8* %93
%98 = load i8, i8* %94
%99 = load i8, i8* %95
%100 = insertelement <4 x i8> poison, i8 %96, i64 0
%101 = insertelement <4 x i8> %100, i8 %97, i64 1
%102 = insertelement <4 x i8> %101, i8 %98, i64 2
%103 = insertelement <4 x i8> %102, i8 %99, i64 3
%104 = uitofp <4 x i8> %103 to <4 x float>
%105 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %45, <4 x float> %76, <4 x float> %104)
%106 = fptoui <4 x float> %105 to <4 x i8>
%107 = load i8, i8* %51
%108 = load i8, i8* %54
%109 = load i8, i8* %57
%110 = load i8, i8* %60
%111 = insertelement <4 x i8> poison, i8 %107, i64 0
%112 = insertelement <4 x i8> %111, i8 %108, i64 1
%113 = insertelement <4 x i8> %112, i8 %109, i64 2
%114 = insertelement <4 x i8> %113, i8 %110, i64 3
%115 = uitofp <4 x i8> %114 to <4 x float>
%116 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %47, <4 x float> %76, <4 x float> %115)
%117 = fptoui <4 x float> %116 to <4 x i8>
%118 = getelementptr inbounds i8, i8* %5, i64 %61
%119 = bitcast i8* %118 to <12 x i8>*
%120 = shufflevector <4 x i8> %91, <4 x i8> %106, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%121 = shufflevector <4 x i8> %117, <4 x i8> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
%122 = shufflevector <8 x i8> %120, <8 x i8> %121, <12 x i32> <i32 0, i32 4, i32 8, i32 1, i32 5, i32 9, i32 2, i32 6, i32 10, i32 3, i32 7, i32 11>
store <12 x i8> %122, <12 x i8>* %119
%123 = add nuw i64 %49, 4
%124 = icmp eq i64 %123, %37
br i1 %124, label %125, label %48
125: ; preds = %48
%126 = icmp eq i64 %18, %37
br i1 %126, label %157, label %127
127: ; preds = %20, %11, %125
%128 = phi i8* [ %4, %20 ], [ %4, %11 ], [ %39, %125 ]
%129 = phi i8* [ %5, %20 ], [ %5, %11 ], [ %41, %125 ]
br label %130
130: ; preds = %127, %130
%131 = phi i8* [ %154, %130 ], [ %128, %127 ]
%132 = phi i8* [ %155, %130 ], [ %129, %127 ]
%133 = getelementptr inbounds i8, i8* %131, i64 3
%134 = load i8, i8* %133
%135 = uitofp i8 %134 to float
%136 = fdiv float %135, 2.550000e+02
%137 = fsub float 1.000000e+00, %136
%138 = getelementptr inbounds i8, i8* %131, i64 2
%139 = load i8, i8* %138
%140 = uitofp i8 %139 to float
%141 = tail call float @llvm.fmuladd.f32(float %0, float %137, float %140)
%142 = fptoui float %141 to i8
store i8 %142, i8* %132
%143 = getelementptr inbounds i8, i8* %131, i64 1
%144 = load i8, i8* %143
%145 = uitofp i8 %144 to float
%146 = tail call float @llvm.fmuladd.f32(float %1, float %137, float %145)
%147 = fptoui float %146 to i8
%148 = getelementptr inbounds i8, i8* %132, i64 1
store i8 %147, i8* %148
%149 = load i8, i8* %131
%150 = uitofp i8 %149 to float
%151 = tail call float @llvm.fmuladd.f32(float %2, float %137, float %150)
%152 = fptoui float %151 to i8
%153 = getelementptr inbounds i8, i8* %132, i64 2
store i8 %152, i8* %153
%154 = getelementptr inbounds i8, i8* %131, i64 4
%155 = getelementptr inbounds i8, i8* %132, i64 3
%156 = icmp ult i8* %154, %9
br i1 %156, label %130, label %157
157: ; preds = %130, %125, %6
ret void
}