#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 unsigned int uint;

/* Variables and functions */
uint p_env_cube_threw_qube(float *vector_cube, float *input, float *output,
                           unsigned int size, unsigned int pos) {
  unsigned int i, j;
  float x, y, z, r, g, b, a;
  for (i = pos; i < size * size * 6 && i < pos + 2; i++) {
    x = vector_cube[i * 3];
    y = vector_cube[i * 3 + 1];
    z = vector_cube[i * 3 + 2];
    r = input[i * 3] / (size * size * 3);
    g = input[i * 3 + 1] / (size * size * 3);
    b = input[i * 3 + 2] / (size * size * 3);
    if (r + g + b > 0) {
      for (j = 0; j < size * size * 6; j++) {
        a = x * vector_cube[j * 3] + y * vector_cube[j * 3 + 1] +
            z * vector_cube[j * 3 + 2];
        if (a > 0) {
          output[j * 3] += r * a;
          output[j * 3 + 1] += g * a;
          output[j * 3 + 2] += b * a;
        }
      }
    }
  }
  return i;
}


x86 assembly (clang, -O0):
<p_env_cube_threw_qube>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
imul   $0x6,%eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x45(%rbp)
jae    1148 <p_env_cube_threw_qube+0x48>
mov    -0x24(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
setb   %al
mov    %al,-0x45(%rbp)
mov    -0x45(%rbp),%al
test   $0x1,%al
jne    1158 <p_env_cube_threw_qube+0x58>
jmp    135e <p_env_cube_threw_qube+0x25e>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%edx
mov    %edx,%ecx
lea    0x1(%rcx,%rcx,2),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%edx
mov    %edx,%ecx
lea    0x2(%rcx,%rcx,2),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x1c(%rbp),%ecx
imul   %ecx,%ecx
mov    %ecx,%eax
lea    (%rax,%rax,2),%eax
cvtsi2ss %rax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%edx
mov    %edx,%ecx
lea    0x1(%rcx,%rcx,2),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x1c(%rbp),%ecx
imul   %ecx,%ecx
mov    %ecx,%eax
lea    (%rax,%rax,2),%eax
cvtsi2ss %rax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%edx
mov    %edx,%ecx
lea    0x2(%rcx,%rcx,2),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x1c(%rbp),%ecx
imul   %ecx,%ecx
mov    %ecx,%eax
lea    (%rax,%rax,2),%eax
cvtsi2ss %rax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x38(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    134b <p_env_cube_threw_qube+0x24b>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
imul   $0x6,%ecx,%ecx
cmp    %ecx,%eax
jae    1346 <p_env_cube_threw_qube+0x246>
movss  -0x2c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
imul   $0x3,-0x28(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0x28(%rbp),%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1333 <p_env_cube_threw_qube+0x233>
movss  -0x38(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mov    -0x18(%rbp),%rax
imul   $0x3,-0x28(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mov    -0x18(%rbp),%rax
imul   $0x3,-0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mov    -0x18(%rbp),%rax
imul   $0x3,-0x28(%rbp),%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1338 <p_env_cube_threw_qube+0x238>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    123e <p_env_cube_threw_qube+0x13e>
jmp    134b <p_env_cube_threw_qube+0x24b>
jmp    1350 <p_env_cube_threw_qube+0x250>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111d <p_env_cube_threw_qube+0x1d>
mov    -0x24(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<p_env_cube_threw_qube>:
push   %r14
push   %rbx
mov    %r8d,%eax
imul   %ecx,%ecx
lea    (%rcx,%rcx,1),%ebx
lea    (%rbx,%rbx,2),%ebx
cmp    %r8d,%ebx
jbe    1242 <p_env_cube_threw_qube+0x142>
cmp    $0xfffffffd,%eax
ja     1242 <p_env_cube_threw_qube+0x142>
lea    (%rcx,%rcx,2),%ecx
cvtsi2ss %rcx,%xmm8
mov    %eax,%r8d
mov    %eax,%eax
add    $0x2,%r8d
mov    %ebx,%r9d
movaps %xmm8,%xmm9
shufps $0x0,%xmm8,%xmm9
lea    (%r9,%r9,2),%r10
xorps  %xmm10,%xmm10
cs nopw 0x0(%rax,%rax,1)
lea    (%rax,%rax,2),%r11d
lea    (%rax,%rax,2),%ebx
add    $0x1,%ebx
lea    0x2(%rax,%rax,2),%ecx
movss  (%rsi,%rbx,4),%xmm3
divss  %xmm8,%xmm3
movss  (%rsi,%rcx,4),%xmm0
movss  (%rsi,%r11,4),%xmm4
unpcklps %xmm0,%xmm4
divps  %xmm9,%xmm4
movaps %xmm4,%xmm0
addss  %xmm3,%xmm0
movaps %xmm4,%xmm5
shufps $0x55,%xmm4,%xmm5
addss  %xmm5,%xmm0
ucomiss %xmm10,%xmm0
jbe    1230 <p_env_cube_threw_qube+0x130>
movss  (%rdi,%r11,4),%xmm6
movss  (%rdi,%rbx,4),%xmm7
movss  (%rdi,%rcx,4),%xmm0
xor    %ecx,%ecx
jmp    11b9 <p_env_cube_threw_qube+0xb9>
nopw   0x0(%rax,%rax,1)
add    $0x3,%rcx
cmp    %rcx,%r10
je     1230 <p_env_cube_threw_qube+0x130>
mov    %ecx,%r14d
lea    0x1(%rcx),%r11d
movss  (%rdi,%r11,4),%xmm1
mulss  %xmm7,%xmm1
movss  (%rdi,%r14,4),%xmm2
mulss  %xmm6,%xmm2
addss  %xmm1,%xmm2
lea    0x2(%rcx),%ebx
movss  (%rdi,%rbx,4),%xmm1
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
ucomiss %xmm10,%xmm1
jbe    11b0 <p_env_cube_threw_qube+0xb0>
movaps %xmm4,%xmm2
mulss  %xmm1,%xmm2
addss  (%rdx,%r14,4),%xmm2
movss  %xmm2,(%rdx,%r14,4)
movaps %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  (%rdx,%r11,4),%xmm2
movss  %xmm2,(%rdx,%r11,4)
mulss  %xmm5,%xmm1
addss  (%rdx,%rbx,4),%xmm1
movss  %xmm1,(%rdx,%rbx,4)
jmp    11b0 <p_env_cube_threw_qube+0xb0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    %r9,%rax
jae    1242 <p_env_cube_threw_qube+0x142>
cmp    %r8,%rax
jb     1150 <p_env_cube_threw_qube+0x50>
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define i32 @p_env_cube_threw_qube(float* nocapture %0, float* nocapture %1, float* nocapture %2, i32 %3, i32 %4) {
%6 = mul i32 %3, %3
%7 = mul i32 %6, 6
%8 = icmp ugt i32 %7, %4
%9 = icmp ult i32 %4, -2
%10 = and i1 %8, %9
br i1 %10, label %11, label %89
11: ; preds = %5
%12 = add nuw i32 %4, 2
%13 = mul i32 %6, 3
%14 = uitofp i32 %13 to float
%15 = zext i32 %4 to i64
%16 = zext i32 %12 to i64
%17 = zext i32 %7 to i64
%18 = insertelement <2 x float> poison, float %14, i64 0
%19 = shufflevector <2 x float> %18, <2 x float> poison, <2 x i32> zeroinitializer
br label %20
20: ; preds = %11, %82
%21 = phi i64 [ %15, %11 ], [ %83, %82 ]
%22 = trunc i64 %21 to i32
%23 = mul i32 %22, 3
%24 = zext i32 %23 to i64
%25 = getelementptr inbounds float, float* %0, i64 %24
%26 = load float, float* %25
%27 = add i32 %23, 1
%28 = zext i32 %27 to i64
%29 = getelementptr inbounds float, float* %0, i64 %28
%30 = load float, float* %29
%31 = add i32 %23, 2
%32 = zext i32 %31 to i64
%33 = getelementptr inbounds float, float* %0, i64 %32
%34 = load float, float* %33
%35 = getelementptr inbounds float, float* %1, i64 %24
%36 = load float, float* %35
%37 = getelementptr inbounds float, float* %1, i64 %28
%38 = load float, float* %37
%39 = fdiv float %38, %14
%40 = getelementptr inbounds float, float* %1, i64 %32
%41 = load float, float* %40
%42 = insertelement <2 x float> poison, float %36, i64 0
%43 = insertelement <2 x float> %42, float %41, i64 1
%44 = fdiv <2 x float> %43, %19
%45 = extractelement <2 x float> %44, i64 0
%46 = fadd float %45, %39
%47 = extractelement <2 x float> %44, i64 1
%48 = fadd float %46, %47
%49 = fcmp ogt float %48, 0.000000e+00
br i1 %49, label %50, label %82
50: ; preds = %20, %79
%51 = phi i64 [ %80, %79 ], [ 0, %20 ]
%52 = trunc i64 %51 to i32
%53 = mul i32 %52, 3
%54 = zext i32 %53 to i64
%55 = getelementptr inbounds float, float* %0, i64 %54
%56 = load float, float* %55
%57 = add i32 %53, 1
%58 = zext i32 %57 to i64
%59 = getelementptr inbounds float, float* %0, i64 %58
%60 = load float, float* %59
%61 = fmul float %30, %60
%62 = tail call float @llvm.fmuladd.f32(float %26, float %56, float %61)
%63 = add i32 %53, 2
%64 = zext i32 %63 to i64
%65 = getelementptr inbounds float, float* %0, i64 %64
%66 = load float, float* %65
%67 = tail call float @llvm.fmuladd.f32(float %34, float %66, float %62)
%68 = fcmp ogt float %67, 0.000000e+00
br i1 %68, label %69, label %79
69: ; preds = %50
%70 = getelementptr inbounds float, float* %2, i64 %54
%71 = load float, float* %70
%72 = tail call float @llvm.fmuladd.f32(float %45, float %67, float %71)
store float %72, float* %70
%73 = getelementptr inbounds float, float* %2, i64 %58
%74 = load float, float* %73
%75 = tail call float @llvm.fmuladd.f32(float %39, float %67, float %74)
store float %75, float* %73
%76 = getelementptr inbounds float, float* %2, i64 %64
%77 = load float, float* %76
%78 = tail call float @llvm.fmuladd.f32(float %47, float %67, float %77)
store float %78, float* %76
br label %79
79: ; preds = %50, %69
%80 = add nuw nsw i64 %51, 1
%81 = icmp eq i64 %80, %17
br i1 %81, label %82, label %50
82: ; preds = %79, %20
%83 = add nuw nsw i64 %21, 1
%84 = icmp ult i64 %83, %17
%85 = icmp ult i64 %83, %16
%86 = and i1 %84, %85
br i1 %86, label %20, label %87
87: ; preds = %82
%88 = trunc i64 %83 to i32
br label %89
89: ; preds = %87, %5
%90 = phi i32 [ %4, %5 ], [ %88, %87 ]
ret i32 %90
}