#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 */
double clampf(double);
unsigned char linear_sample_to_srgb(double);
unsigned char round(double);
void strip_scale_rgba(float **in, int strip_height, int len, unsigned char *out,
                      float *coeffs) {
  int i, j;
  double sum[4], alpha;
  for (i = 0; i < len; i += 4) {
    sum[0] = sum[1] = sum[2] = sum[3] = 0;
    for (j = 0; j < strip_height; j++) {
      sum[0] += coeffs[j] * in[j][i];
      sum[1] += coeffs[j] * in[j][i + 1];
      sum[2] += coeffs[j] * in[j][i + 2];
      sum[3] += coeffs[j] * in[j][i + 3];
    }
    alpha = clampf(sum[3]);
    if (alpha != 0) {
      sum[0] /= alpha;
      sum[1] /= alpha;
      sum[2] /= alpha;
    }
    out[0] = linear_sample_to_srgb(sum[0]);
    out[1] = linear_sample_to_srgb(sum[1]);
    out[2] = linear_sample_to_srgb(sum[2]);
    out[3] = round(alpha * 255.0f);
    out += 4;
  }
}


x86 assembly (clang, -O0):
<strip_scale_rgba>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    133f <strip_scale_rgba+0x20f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    126d <strip_scale_rgba+0x13d>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1184 <strip_scale_rgba+0x54>
movsd  -0x38(%rbp),%xmm0
call   1040 <clampf@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1299 <strip_scale_rgba+0x169>
jp     1299 <strip_scale_rgba+0x169>
jmp    12d2 <strip_scale_rgba+0x1a2>
movsd  -0x58(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x50(%rbp),%xmm0
call   1030 <linear_sample_to_srgb@plt>
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
movsd  -0x48(%rbp),%xmm0
call   1030 <linear_sample_to_srgb@plt>
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
movsd  -0x40(%rbp),%xmm0
call   1030 <linear_sample_to_srgb@plt>
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x2(%rax)
movsd  0xcee(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
call   1050 <round@plt>
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
jmp    1151 <strip_scale_rgba+0x21>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strip_scale_rgba>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %edx,0xc(%rsp)
test   %edx,%edx
jle    12f6 <strip_scale_rgba+0x1c6>
mov    %r8,%rbx
mov    %rcx,%r14
mov    %esi,%r12d
mov    %rdi,%rbp
mov    %esi,%r13d
mov    %r13,0x38(%rsp)
and    $0xfffffffe,%r13d
xor    %r15d,%r15d
jmp    11ed <strip_scale_rgba+0xbd>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm2
movapd %xmm0,%xmm1
unpcklpd %xmm2,%xmm1
movapd 0x10(%rsp),%xmm0
divpd  %xmm1,%xmm0
movapd 0x20(%rsp),%xmm1
divsd  %xmm2,%xmm1
movapd %xmm1,0x20(%rsp)
movapd %xmm0,0x10(%rsp)
call   1030 <linear_sample_to_srgb@plt>
mov    %al,(%r14)
movaps 0x10(%rsp),%xmm0
movhlps %xmm0,%xmm0
call   1030 <linear_sample_to_srgb@plt>
mov    %al,0x1(%r14)
movaps 0x20(%rsp),%xmm0
call   1030 <linear_sample_to_srgb@plt>
mov    %al,0x2(%r14)
movapd 0x40(%rsp),%xmm0
mulsd  0xe2f(%rip),%xmm0
call   1050 <round@plt>
mov    %al,0x3(%r14)
add    $0x4,%r14
add    $0x4,%r15
cmp    0xc(%rsp),%r15d
jge    12f6 <strip_scale_rgba+0x1c6>
test   %r12d,%r12d
jle    12b0 <strip_scale_rgba+0x180>
mov    %r15,%rax
or     $0x2,%rax
xorpd  %xmm4,%xmm4
xor    %ecx,%ecx
xorpd  %xmm5,%xmm5
cmp    $0x1,%r12d
je     1274 <strip_scale_rgba+0x144>
nopl   (%rax)
mov    0x0(%rbp,%rcx,8),%rdx
mov    0x8(%rbp,%rcx,8),%rsi
movsd  (%rdx,%r15,4),%xmm0
movss  (%rbx,%rcx,4),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
movss  0x4(%rbx,%rcx,4),%xmm2
addpd  %xmm4,%xmm0
movsd  (%rdx,%rax,4),%xmm3
mulps  %xmm1,%xmm3
cvtps2pd %xmm3,%xmm1
addpd  %xmm5,%xmm1
movsd  (%rsi,%r15,4),%xmm3
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm3
cvtps2pd %xmm3,%xmm4
movsd  (%rsi,%rax,4),%xmm3
mulps  %xmm2,%xmm3
cvtps2pd %xmm3,%xmm5
addpd  %xmm0,%xmm4
addpd  %xmm1,%xmm5
add    $0x2,%rcx
cmp    %rcx,%r13
jne    1210 <strip_scale_rgba+0xe0>
testb  $0x1,0x38(%rsp)
je     12b8 <strip_scale_rgba+0x188>
mov    0x0(%rbp,%rcx,8),%rdx
movsd  (%rdx,%r15,4),%xmm0
movss  (%rbx,%rcx,4),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
addpd  %xmm0,%xmm4
movsd  (%rdx,%rax,4),%xmm0
mulps  %xmm1,%xmm0
cvtps2pd %xmm0,%xmm0
addpd  %xmm0,%xmm5
jmp    12b8 <strip_scale_rgba+0x188>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm4,%xmm4
xorpd  %xmm5,%xmm5
movapd %xmm5,0x20(%rsp)
movapd %xmm4,0x10(%rsp)
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
call   1040 <clampf@plt>
ucomisd 0xd2f(%rip),%xmm0
movapd %xmm0,0x40(%rsp)
jne    1170 <strip_scale_rgba+0x40>
jp     1170 <strip_scale_rgba+0x40>
movapd 0x10(%rsp),%xmm0
jmp    1196 <strip_scale_rgba+0x66>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @strip_scale_rgba(float** %0, i32 %1, i32 %2, i8* %3, float* %4) {
%6 = alloca float**
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
%10 = alloca float*
%11 = alloca i32
%12 = alloca i32
%13 = alloca [4 x double]
%14 = alloca double
store float** %0, float*** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i8* %3, i8** %9
store float* %4, float** %10
store i32 0, i32* %11
br label %15
15: ; preds = %153, %5
%16 = load i32, i32* %11
%17 = load i32, i32* %8
%18 = icmp slt i32 %16, %17
br i1 %18, label %19, label %156
19: ; preds = %15
%20 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
store double 0.000000e+00, double* %20
%21 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
store double 0.000000e+00, double* %21
%22 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
store double 0.000000e+00, double* %22
%23 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
store double 0.000000e+00, double* %23
store i32 0, i32* %12
br label %24
24: ; preds = %108, %19
%25 = load i32, i32* %12
%26 = load i32, i32* %7
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %111
28: ; preds = %24
%29 = load float*, float** %10
%30 = load i32, i32* %12
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds float, float* %29, i64 %31
%33 = load float, float* %32
%34 = load float**, float*** %6
%35 = load i32, i32* %12
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds float*, float** %34, i64 %36
%38 = load float*, float** %37
%39 = load i32, i32* %11
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds float, float* %38, i64 %40
%42 = load float, float* %41
%43 = fmul float %33, %42
%44 = fpext float %43 to double
%45 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%46 = load double, double* %45
%47 = fadd double %46, %44
store double %47, double* %45
%48 = load float*, float** %10
%49 = load i32, i32* %12
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds float, float* %48, i64 %50
%52 = load float, float* %51
%53 = load float**, float*** %6
%54 = load i32, i32* %12
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float*, float** %53, i64 %55
%57 = load float*, float** %56
%58 = load i32, i32* %11
%59 = add nsw i32 %58, 1
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds float, float* %57, i64 %60
%62 = load float, float* %61
%63 = fmul float %52, %62
%64 = fpext float %63 to double
%65 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%66 = load double, double* %65
%67 = fadd double %66, %64
store double %67, double* %65
%68 = load float*, float** %10
%69 = load i32, i32* %12
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %68, i64 %70
%72 = load float, float* %71
%73 = load float**, float*** %6
%74 = load i32, i32* %12
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds float*, float** %73, i64 %75
%77 = load float*, float** %76
%78 = load i32, i32* %11
%79 = add nsw i32 %78, 2
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float, float* %77, i64 %80
%82 = load float, float* %81
%83 = fmul float %72, %82
%84 = fpext float %83 to double
%85 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%86 = load double, double* %85
%87 = fadd double %86, %84
store double %87, double* %85
%88 = load float*, float** %10
%89 = load i32, i32* %12
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds float, float* %88, i64 %90
%92 = load float, float* %91
%93 = load float**, float*** %6
%94 = load i32, i32* %12
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float*, float** %93, i64 %95
%97 = load float*, float** %96
%98 = load i32, i32* %11
%99 = add nsw i32 %98, 3
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds float, float* %97, i64 %100
%102 = load float, float* %101
%103 = fmul float %92, %102
%104 = fpext float %103 to double
%105 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%106 = load double, double* %105
%107 = fadd double %106, %104
store double %107, double* %105
br label %108
108: ; preds = %28
%109 = load i32, i32* %12
%110 = add nsw i32 %109, 1
store i32 %110, i32* %12
br label %24
111: ; preds = %24
%112 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 3
%113 = load double, double* %112
%114 = call double @clampf(double %113)
store double %114, double* %14
%115 = load double, double* %14
%116 = fcmp une double %115, 0.000000e+00
br i1 %116, label %117, label %130
117: ; preds = %111
%118 = load double, double* %14
%119 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%120 = load double, double* %119
%121 = fdiv double %120, %118
store double %121, double* %119
%122 = load double, double* %14
%123 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%124 = load double, double* %123
%125 = fdiv double %124, %122
store double %125, double* %123
%126 = load double, double* %14
%127 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%128 = load double, double* %127
%129 = fdiv double %128, %126
store double %129, double* %127
br label %130
130: ; preds = %117, %111
%131 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 0
%132 = load double, double* %131
%133 = call zeroext i8 @linear_sample_to_srgb(double %132)
%134 = load i8*, i8** %9
%135 = getelementptr inbounds i8, i8* %134, i64 0
store i8 %133, i8* %135
%136 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 1
%137 = load double, double* %136
%138 = call zeroext i8 @linear_sample_to_srgb(double %137)
%139 = load i8*, i8** %9
%140 = getelementptr inbounds i8, i8* %139, i64 1
store i8 %138, i8* %140
%141 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0, i64 2
%142 = load double, double* %141
%143 = call zeroext i8 @linear_sample_to_srgb(double %142)
%144 = load i8*, i8** %9
%145 = getelementptr inbounds i8, i8* %144, i64 2
store i8 %143, i8* %145
%146 = load double, double* %14
%147 = fmul double %146, 2.550000e+02
%148 = call zeroext i8 @round(double %147)
%149 = load i8*, i8** %9
%150 = getelementptr inbounds i8, i8* %149, i64 3
store i8 %148, i8* %150
%151 = load i8*, i8** %9
%152 = getelementptr inbounds i8, i8* %151, i64 4
store i8* %152, i8** %9
br label %153
153: ; preds = %130
%154 = load i32, i32* %11
%155 = add nsw i32 %154, 4
store i32 %155, i32* %11
br label %15
156: ; preds = %15
ret void
}

LLVM IR (-O2):
define void @strip_scale_rgba(float** nocapture %0, i32 %1, i32 %2, i8* nocapture writeonly %3, float* nocapture %4) {
%6 = icmp sgt i32 %2, 0
br i1 %6, label %7, label %118
7: ; preds = %5
%8 = icmp sgt i32 %1, 0
%9 = zext i32 %1 to i64
%10 = and i64 %9, 1
%11 = icmp eq i32 %1, 1
%12 = and i64 %9, 4294967294
%13 = icmp eq i64 %10, 0
br label %14
14: ; preds = %7, %101
%15 = phi i64 [ 0, %7 ], [ %115, %101 ]
%16 = phi i8* [ %3, %7 ], [ %114, %101 ]
br i1 %8, label %17, label %89
17: ; preds = %14
%18 = or i64 %15, 2
br i1 %11, label %64, label %19
19: ; preds = %17, %19
%20 = phi i64 [ %61, %19 ], [ 0, %17 ]
%21 = phi <2 x double> [ %54, %19 ], [ zeroinitializer, %17 ]
%22 = phi <2 x double> [ %60, %19 ], [ zeroinitializer, %17 ]
%23 = phi i64 [ %62, %19 ], [ 0, %17 ]
%24 = getelementptr inbounds float, float* %4, i64 %20
%25 = load float, float* %24
%26 = getelementptr inbounds float*, float** %0, i64 %20
%27 = load float*, float** %26
%28 = getelementptr inbounds float, float* %27, i64 %15
%29 = bitcast float* %28 to <2 x float>*
%30 = load <2 x float>, <2 x float>* %29
%31 = insertelement <2 x float> poison, float %25, i64 0
%32 = shufflevector <2 x float> %31, <2 x float> poison, <2 x i32> zeroinitializer
%33 = fmul <2 x float> %32, %30
%34 = fpext <2 x float> %33 to <2 x double>
%35 = fadd <2 x double> %21, %34
%36 = getelementptr inbounds float, float* %27, i64 %18
%37 = bitcast float* %36 to <2 x float>*
%38 = load <2 x float>, <2 x float>* %37
%39 = fmul <2 x float> %32, %38
%40 = fpext <2 x float> %39 to <2 x double>
%41 = fadd <2 x double> %22, %40
%42 = or i64 %20, 1
%43 = getelementptr inbounds float, float* %4, i64 %42
%44 = load float, float* %43
%45 = getelementptr inbounds float*, float** %0, i64 %42
%46 = load float*, float** %45
%47 = getelementptr inbounds float, float* %46, i64 %15
%48 = bitcast float* %47 to <2 x float>*
%49 = load <2 x float>, <2 x float>* %48
%50 = insertelement <2 x float> poison, float %44, i64 0
%51 = shufflevector <2 x float> %50, <2 x float> poison, <2 x i32> zeroinitializer
%52 = fmul <2 x float> %51, %49
%53 = fpext <2 x float> %52 to <2 x double>
%54 = fadd <2 x double> %35, %53
%55 = getelementptr inbounds float, float* %46, i64 %18
%56 = bitcast float* %55 to <2 x float>*
%57 = load <2 x float>, <2 x float>* %56
%58 = fmul <2 x float> %51, %57
%59 = fpext <2 x float> %58 to <2 x double>
%60 = fadd <2 x double> %41, %59
%61 = add nuw nsw i64 %20, 2
%62 = add i64 %23, 2
%63 = icmp eq i64 %62, %12
br i1 %63, label %64, label %19
64: ; preds = %19, %17
%65 = phi <2 x double> [ undef, %17 ], [ %54, %19 ]
%66 = phi <2 x double> [ undef, %17 ], [ %60, %19 ]
%67 = phi i64 [ 0, %17 ], [ %61, %19 ]
%68 = phi <2 x double> [ zeroinitializer, %17 ], [ %54, %19 ]
%69 = phi <2 x double> [ zeroinitializer, %17 ], [ %60, %19 ]
br i1 %13, label %89, label %70
70: ; preds = %64
%71 = getelementptr inbounds float, float* %4, i64 %67
%72 = load float, float* %71
%73 = getelementptr inbounds float*, float** %0, i64 %67
%74 = load float*, float** %73
%75 = getelementptr inbounds float, float* %74, i64 %15
%76 = bitcast float* %75 to <2 x float>*
%77 = load <2 x float>, <2 x float>* %76
%78 = insertelement <2 x float> poison, float %72, i64 0
%79 = shufflevector <2 x float> %78, <2 x float> poison, <2 x i32> zeroinitializer
%80 = fmul <2 x float> %79, %77
%81 = fpext <2 x float> %80 to <2 x double>
%82 = fadd <2 x double> %68, %81
%83 = getelementptr inbounds float, float* %74, i64 %18
%84 = bitcast float* %83 to <2 x float>*
%85 = load <2 x float>, <2 x float>* %84
%86 = fmul <2 x float> %79, %85
%87 = fpext <2 x float> %86 to <2 x double>
%88 = fadd <2 x double> %69, %87
br label %89
89: ; preds = %70, %64, %14
%90 = phi <2 x double> [ zeroinitializer, %14 ], [ %65, %64 ], [ %82, %70 ]
%91 = phi <2 x double> [ zeroinitializer, %14 ], [ %66, %64 ], [ %88, %70 ]
%92 = extractelement <2 x double> %91, i64 1
%93 = tail call double @clampf(double %92)
%94 = fcmp une double %93, 0.000000e+00
%95 = extractelement <2 x double> %91, i64 0
br i1 %94, label %96, label %101
96: ; preds = %89
%97 = insertelement <2 x double> poison, double %93, i64 0
%98 = shufflevector <2 x double> %97, <2 x double> poison, <2 x i32> zeroinitializer
%99 = fdiv <2 x double> %90, %98
%100 = fdiv double %95, %93
br label %101
101: ; preds = %96, %89
%102 = phi double [ %100, %96 ], [ %95, %89 ]
%103 = phi <2 x double> [ %99, %96 ], [ %90, %89 ]
%104 = extractelement <2 x double> %103, i64 0
%105 = tail call zeroext i8 @linear_sample_to_srgb(double %104)
store i8 %105, i8* %16
%106 = extractelement <2 x double> %103, i64 1
%107 = tail call zeroext i8 @linear_sample_to_srgb(double %106)
%108 = getelementptr inbounds i8, i8* %16, i64 1
store i8 %107, i8* %108
%109 = tail call zeroext i8 @linear_sample_to_srgb(double %102)
%110 = getelementptr inbounds i8, i8* %16, i64 2
store i8 %109, i8* %110
%111 = fmul double %93, 2.550000e+02
%112 = tail call zeroext i8 @round(double %111)
%113 = getelementptr inbounds i8, i8* %16, i64 3
store i8 %112, i8* %113
%114 = getelementptr inbounds i8, i8* %16, i64 4
%115 = add nuw i64 %15, 4
%116 = trunc i64 %115 to i32
%117 = icmp slt i32 %116, %2
br i1 %117, label %14, label %118
118: ; preds = %101, %5
ret void
}