#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 */
float fabsf(float);
int GetPyramid(float *xyz) {
  int next, p;
  next = 1;
  if ((fabsf(xyz[0]) < xyz[2]) && (fabsf(xyz[1]) < xyz[2])) {
    p = 1;
    next = 0;
  }
  if (next == 1) {
    if ((fabsf(xyz[0]) < -xyz[2]) && (fabsf(xyz[1]) < -xyz[2])) {
      p = 2;
      next = 0;
    }
  }
  if (next == 1) {
    if ((fabsf(xyz[2]) < xyz[0]) && (fabsf(xyz[1]) < xyz[0])) {
      p = 3;
      next = 0;
    }
  }
  if (next == 1) {
    if ((fabsf(xyz[2]) < -xyz[0]) && (fabsf(xyz[1]) < -xyz[0])) {
      p = 4;
      next = 0;
    }
  }
  if (next == 1) {
    if ((fabsf(xyz[0]) < xyz[1]) && (fabsf(xyz[2]) < xyz[1])) {
      p = 5;
      next = 0;
    }
  }
  if (next == 1) {
    if ((fabsf(xyz[0]) < -xyz[1]) && (fabsf(xyz[2]) < -xyz[1])) {
      p = 6;
      next = 0;
    }
  }
  return p;
}


x86 assembly (clang, -O0):
<GetPyramid>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x1,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
movaps 0xee2(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
ucomiss %xmm1,%xmm0
jbe    1168 <GetPyramid+0x68>
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
movaps 0xebc(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
ucomiss %xmm1,%xmm0
jbe    1168 <GetPyramid+0x68>
movl   $0x1,-0x10(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x1,-0xc(%rbp)
jne    11ea <GetPyramid+0xea>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
movaps 0xe7f(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    11e5 <GetPyramid+0xe5>
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
movaps 0xe4c(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    11e5 <GetPyramid+0xe5>
movl   $0x2,-0x10(%rbp)
movl   $0x0,-0xc(%rbp)
jmp    11ea <GetPyramid+0xea>
cmpl   $0x1,-0xc(%rbp)
jne    1251 <GetPyramid+0x151>
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
movaps 0xdfc(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
ucomiss %xmm1,%xmm0
jbe    124c <GetPyramid+0x14c>
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
movaps 0xdd7(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
ucomiss %xmm1,%xmm0
jbe    124c <GetPyramid+0x14c>
movl   $0x3,-0x10(%rbp)
movl   $0x0,-0xc(%rbp)
jmp    1251 <GetPyramid+0x151>
cmpl   $0x1,-0xc(%rbp)
jne    12d2 <GetPyramid+0x1d2>
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
movaps 0xd95(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    12cd <GetPyramid+0x1cd>
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
movaps 0xd63(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    12cd <GetPyramid+0x1cd>
movl   $0x4,-0x10(%rbp)
movl   $0x0,-0xc(%rbp)
jmp    12d2 <GetPyramid+0x1d2>
cmpl   $0x1,-0xc(%rbp)
jne    133a <GetPyramid+0x23a>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
movaps 0xd15(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
ucomiss %xmm1,%xmm0
jbe    1335 <GetPyramid+0x235>
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
movaps 0xcef(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
ucomiss %xmm1,%xmm0
jbe    1335 <GetPyramid+0x235>
movl   $0x5,-0x10(%rbp)
movl   $0x0,-0xc(%rbp)
jmp    133a <GetPyramid+0x23a>
cmpl   $0x1,-0xc(%rbp)
jne    13bc <GetPyramid+0x2bc>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
movaps 0xcad(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    13b7 <GetPyramid+0x2b7>
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
movaps 0xc7a(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    13b7 <GetPyramid+0x2b7>
movl   $0x6,-0x10(%rbp)
movl   $0x0,-0xc(%rbp)
jmp    13bc <GetPyramid+0x2bc>
mov    -0x10(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<GetPyramid>:
movss  (%rdi),%xmm2
movss  0x8(%rdi),%xmm0
movaps 0xef0(%rip),%xmm1
andps  %xmm2,%xmm1
ucomiss %xmm1,%xmm0
jbe    112e <GetPyramid+0x2e>
movss  0x4(%rdi),%xmm3
andps  0xedc(%rip),%xmm3
mov    $0x1,%eax
ucomiss %xmm3,%xmm0
ja     119a <GetPyramid+0x9a>
movaps 0xedb(%rip),%xmm3
xorps  %xmm0,%xmm3
ucomiss %xmm1,%xmm3
jbe    1153 <GetPyramid+0x53>
movss  0x4(%rdi),%xmm4
andps  0xeb7(%rip),%xmm4
mov    $0x2,%eax
ucomiss %xmm4,%xmm3
ja     119a <GetPyramid+0x9a>
andps  0xea6(%rip),%xmm0
ucomiss %xmm0,%xmm2
jbe    1175 <GetPyramid+0x75>
movss  0x4(%rdi),%xmm3
andps  0xe95(%rip),%xmm3
mov    $0x3,%eax
ucomiss %xmm3,%xmm2
ja     119a <GetPyramid+0x9a>
xorps  0xe94(%rip),%xmm2
ucomiss %xmm0,%xmm2
movss  0x4(%rdi),%xmm3
jbe    119b <GetPyramid+0x9b>
movaps 0xe73(%rip),%xmm4
andps  %xmm3,%xmm4
mov    $0x4,%eax
ucomiss %xmm4,%xmm2
jbe    119b <GetPyramid+0x9b>
ret
ucomiss %xmm1,%xmm3
jbe    11aa <GetPyramid+0xaa>
mov    $0x5,%eax
ucomiss %xmm0,%xmm3
ja     119a <GetPyramid+0x9a>
xorps  0xe5f(%rip),%xmm3
ucomiss %xmm1,%xmm3
seta   %al
ucomiss %xmm0,%xmm3
seta   %cl
and    %al,%cl
movzbl %cl,%eax
lea    (%rax,%rax,4),%eax
add    $0x1,%eax
ret

LLVM IR (-O0):
define i32 @GetPyramid(float* %0) {
%2 = alloca float*
%3 = alloca i32
%4 = alloca i32
store float* %0, float** %2
store i32 1, i32* %3
%5 = load float*, float** %2
%6 = getelementptr inbounds float, float* %5, i64 0
%7 = load float, float* %6
%8 = call float @llvm.fabs.f32(float %7)
%9 = load float*, float** %2
%10 = getelementptr inbounds float, float* %9, i64 2
%11 = load float, float* %10
%12 = fcmp olt float %8, %11
br i1 %12, label %13, label %23
13: ; preds = %1
%14 = load float*, float** %2
%15 = getelementptr inbounds float, float* %14, i64 1
%16 = load float, float* %15
%17 = call float @llvm.fabs.f32(float %16)
%18 = load float*, float** %2
%19 = getelementptr inbounds float, float* %18, i64 2
%20 = load float, float* %19
%21 = fcmp olt float %17, %20
br i1 %21, label %22, label %23
22: ; preds = %13
store i32 1, i32* %4
store i32 0, i32* %3
br label %23
23: ; preds = %22, %13, %1
%24 = load i32, i32* %3
%25 = icmp eq i32 %24, 1
br i1 %25, label %26, label %48
26: ; preds = %23
%27 = load float*, float** %2
%28 = getelementptr inbounds float, float* %27, i64 0
%29 = load float, float* %28
%30 = call float @llvm.fabs.f32(float %29)
%31 = load float*, float** %2
%32 = getelementptr inbounds float, float* %31, i64 2
%33 = load float, float* %32
%34 = fneg float %33
%35 = fcmp olt float %30, %34
br i1 %35, label %36, label %47
36: ; preds = %26
%37 = load float*, float** %2
%38 = getelementptr inbounds float, float* %37, i64 1
%39 = load float, float* %38
%40 = call float @llvm.fabs.f32(float %39)
%41 = load float*, float** %2
%42 = getelementptr inbounds float, float* %41, i64 2
%43 = load float, float* %42
%44 = fneg float %43
%45 = fcmp olt float %40, %44
br i1 %45, label %46, label %47
46: ; preds = %36
store i32 2, i32* %4
store i32 0, i32* %3
br label %47
47: ; preds = %46, %36, %26
br label %48
48: ; preds = %47, %23
%49 = load i32, i32* %3
%50 = icmp eq i32 %49, 1
br i1 %50, label %51, label %71
51: ; preds = %48
%52 = load float*, float** %2
%53 = getelementptr inbounds float, float* %52, i64 2
%54 = load float, float* %53
%55 = call float @llvm.fabs.f32(float %54)
%56 = load float*, float** %2
%57 = getelementptr inbounds float, float* %56, i64 0
%58 = load float, float* %57
%59 = fcmp olt float %55, %58
br i1 %59, label %60, label %70
60: ; preds = %51
%61 = load float*, float** %2
%62 = getelementptr inbounds float, float* %61, i64 1
%63 = load float, float* %62
%64 = call float @llvm.fabs.f32(float %63)
%65 = load float*, float** %2
%66 = getelementptr inbounds float, float* %65, i64 0
%67 = load float, float* %66
%68 = fcmp olt float %64, %67
br i1 %68, label %69, label %70
69: ; preds = %60
store i32 3, i32* %4
store i32 0, i32* %3
br label %70
70: ; preds = %69, %60, %51
br label %71
71: ; preds = %70, %48
%72 = load i32, i32* %3
%73 = icmp eq i32 %72, 1
br i1 %73, label %74, label %96
74: ; preds = %71
%75 = load float*, float** %2
%76 = getelementptr inbounds float, float* %75, i64 2
%77 = load float, float* %76
%78 = call float @llvm.fabs.f32(float %77)
%79 = load float*, float** %2
%80 = getelementptr inbounds float, float* %79, i64 0
%81 = load float, float* %80
%82 = fneg float %81
%83 = fcmp olt float %78, %82
br i1 %83, label %84, label %95
84: ; preds = %74
%85 = load float*, float** %2
%86 = getelementptr inbounds float, float* %85, i64 1
%87 = load float, float* %86
%88 = call float @llvm.fabs.f32(float %87)
%89 = load float*, float** %2
%90 = getelementptr inbounds float, float* %89, i64 0
%91 = load float, float* %90
%92 = fneg float %91
%93 = fcmp olt float %88, %92
br i1 %93, label %94, label %95
94: ; preds = %84
store i32 4, i32* %4
store i32 0, i32* %3
br label %95
95: ; preds = %94, %84, %74
br label %96
96: ; preds = %95, %71
%97 = load i32, i32* %3
%98 = icmp eq i32 %97, 1
br i1 %98, label %99, label %119
99: ; preds = %96
%100 = load float*, float** %2
%101 = getelementptr inbounds float, float* %100, i64 0
%102 = load float, float* %101
%103 = call float @llvm.fabs.f32(float %102)
%104 = load float*, float** %2
%105 = getelementptr inbounds float, float* %104, i64 1
%106 = load float, float* %105
%107 = fcmp olt float %103, %106
br i1 %107, label %108, label %118
108: ; preds = %99
%109 = load float*, float** %2
%110 = getelementptr inbounds float, float* %109, i64 2
%111 = load float, float* %110
%112 = call float @llvm.fabs.f32(float %111)
%113 = load float*, float** %2
%114 = getelementptr inbounds float, float* %113, i64 1
%115 = load float, float* %114
%116 = fcmp olt float %112, %115
br i1 %116, label %117, label %118
117: ; preds = %108
store i32 5, i32* %4
store i32 0, i32* %3
br label %118
118: ; preds = %117, %108, %99
br label %119
119: ; preds = %118, %96
%120 = load i32, i32* %3
%121 = icmp eq i32 %120, 1
br i1 %121, label %122, label %144
122: ; preds = %119
%123 = load float*, float** %2
%124 = getelementptr inbounds float, float* %123, i64 0
%125 = load float, float* %124
%126 = call float @llvm.fabs.f32(float %125)
%127 = load float*, float** %2
%128 = getelementptr inbounds float, float* %127, i64 1
%129 = load float, float* %128
%130 = fneg float %129
%131 = fcmp olt float %126, %130
br i1 %131, label %132, label %143
132: ; preds = %122
%133 = load float*, float** %2
%134 = getelementptr inbounds float, float* %133, i64 2
%135 = load float, float* %134
%136 = call float @llvm.fabs.f32(float %135)
%137 = load float*, float** %2
%138 = getelementptr inbounds float, float* %137, i64 1
%139 = load float, float* %138
%140 = fneg float %139
%141 = fcmp olt float %136, %140
br i1 %141, label %142, label %143
142: ; preds = %132
store i32 6, i32* %4
store i32 0, i32* %3
br label %143
143: ; preds = %142, %132, %122
br label %144
144: ; preds = %143, %119
%145 = load i32, i32* %4
ret i32 %145
}

LLVM IR (-O2):
define i32 @GetPyramid(float* nocapture %0) {
%2 = load float, float* %0
%3 = tail call float @llvm.fabs.f32(float %2)
%4 = getelementptr inbounds float, float* %0, i64 2
%5 = load float, float* %4
%6 = fcmp olt float %3, %5
br i1 %6, label %7, label %12
7: ; preds = %1
%8 = getelementptr inbounds float, float* %0, i64 1
%9 = load float, float* %8
%10 = tail call float @llvm.fabs.f32(float %9)
%11 = fcmp olt float %10, %5
br i1 %11, label %46, label %12
12: ; preds = %1, %7
%13 = fneg float %5
%14 = fcmp olt float %3, %13
br i1 %14, label %15, label %20
15: ; preds = %12
%16 = getelementptr inbounds float, float* %0, i64 1
%17 = load float, float* %16
%18 = tail call float @llvm.fabs.f32(float %17)
%19 = fcmp olt float %18, %13
br i1 %19, label %46, label %20
20: ; preds = %12, %15
%21 = tail call float @llvm.fabs.f32(float %5)
%22 = fcmp olt float %21, %2
br i1 %22, label %23, label %28
23: ; preds = %20
%24 = getelementptr inbounds float, float* %0, i64 1
%25 = load float, float* %24
%26 = tail call float @llvm.fabs.f32(float %25)
%27 = fcmp olt float %26, %2
br i1 %27, label %46, label %28
28: ; preds = %23, %20
%29 = fneg float %2
%30 = fcmp olt float %21, %29
%31 = getelementptr inbounds float, float* %0, i64 1
%32 = load float, float* %31
%33 = tail call float @llvm.fabs.f32(float %32)
%34 = fcmp olt float %33, %29
%35 = select i1 %30, i1 %34, i1 false
br i1 %35, label %46, label %36
36: ; preds = %28
%37 = fcmp olt float %3, %32
%38 = fcmp olt float %21, %32
%39 = select i1 %37, i1 %38, i1 false
br i1 %39, label %46, label %40
40: ; preds = %36
%41 = fneg float %32
%42 = fcmp olt float %3, %41
%43 = fcmp olt float %21, %41
%44 = select i1 %42, i1 %43, i1 false
%45 = select i1 %44, i32 6, i32 1
br label %46
46: ; preds = %28, %40, %36, %23, %15, %7
%47 = phi i32 [ 1, %7 ], [ 2, %15 ], [ 3, %23 ], [ 5, %36 ], [ %45, %40 ], [ 4, %28 ]
ret i32 %47
}