#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 */
scalar_t__ fabs(float);
double sqrt(float);
void PolygonF_QuadForPlane(float *outpoints, float planenormalx,
                           float planenormaly, float planenormalz,
                           float planedist, float quadsize) {
  float d, quadright[3], quadup[3];
  if (fabs(planenormalz) > fabs(planenormalx) &&
      fabs(planenormalz) > fabs(planenormaly)) {
    quadup[0] = 1;
    quadup[1] = 0;
    quadup[2] = 0;
  } else {
    quadup[0] = 0;
    quadup[1] = 0;
    quadup[2] = 1;
  }
  d = -(quadup[0] * planenormalx + quadup[1] * planenormaly +
        quadup[2] * planenormalz);
  quadup[0] += d * planenormalx;
  quadup[1] += d * planenormaly;
  quadup[2] += d * planenormalz;
  d = (float)(1.0 / sqrt(quadup[0] * quadup[0] + quadup[1] * quadup[1] +
                         quadup[2] * quadup[2]));
  quadup[0] *= d;
  quadup[1] *= d;
  quadup[2] *= d;
  quadright[0] = quadup[1] * planenormalz - quadup[2] * planenormaly;
  quadright[1] = quadup[2] * planenormalx - quadup[0] * planenormalz;
  quadright[2] = quadup[0] * planenormaly - quadup[1] * planenormalx;
  outpoints[0] =
      planedist * planenormalx - quadsize * quadright[0] + quadsize * quadup[0];
  outpoints[1] =
      planedist * planenormaly - quadsize * quadright[1] + quadsize * quadup[1];
  outpoints[2] =
      planedist * planenormalz - quadsize * quadright[2] + quadsize * quadup[2];
  outpoints[3] =
      planedist * planenormalx + quadsize * quadright[0] + quadsize * quadup[0];
  outpoints[4] =
      planedist * planenormaly + quadsize * quadright[1] + quadsize * quadup[1];
  outpoints[5] =
      planedist * planenormalz + quadsize * quadright[2] + quadsize * quadup[2];
  outpoints[6] =
      planedist * planenormalx + quadsize * quadright[0] - quadsize * quadup[0];
  outpoints[7] =
      planedist * planenormaly + quadsize * quadright[1] - quadsize * quadup[1];
  outpoints[8] =
      planedist * planenormalz + quadsize * quadright[2] - quadsize * quadup[2];
  outpoints[9] =
      planedist * planenormalx - quadsize * quadright[0] - quadsize * quadup[0];
  outpoints[10] =
      planedist * planenormaly - quadsize * quadright[1] - quadsize * quadup[1];
  outpoints[11] =
      planedist * planenormalz - quadsize * quadright[2] - quadsize * quadup[2];
}


x86 assembly (clang, -O0):
<PolygonF_QuadForPlane>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
movss  %xmm2,-0x14(%rbp)
movss  %xmm3,-0x18(%rbp)
movss  %xmm4,-0x1c(%rbp)
movss  -0x14(%rbp),%xmm0
call   1030 <fabs@plt>
mov    %rax,-0x40(%rbp)
movss  -0xc(%rbp),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0x40(%rbp),%rax
cmp    %rcx,%rax
jle    11b7 <PolygonF_QuadForPlane+0x97>
movss  -0x14(%rbp),%xmm0
call   1030 <fabs@plt>
mov    %rax,-0x48(%rbp)
movss  -0x10(%rbp),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0x48(%rbp),%rax
cmp    %rcx,%rax
jle    11b7 <PolygonF_QuadForPlane+0x97>
movss  0xe63(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
jmp    11d4 <PolygonF_QuadForPlane+0xb4>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  0xe31(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0xc(%rbp),%xmm2
movss  -0x34(%rbp),%xmm0
mulss  -0x10(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x20(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x20(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x20(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0x38(%rbp),%xmm2
movss  -0x34(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xd62(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  -0x10(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0xc(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x18(%rbp),%xmm1
movss  -0xc(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0x14(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0xc(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0x14(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0xc(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0x14(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0xc(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0x14(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<PolygonF_QuadForPlane>:
push   %r14
push   %rbx
sub    $0x88,%rsp
movaps %xmm4,0x70(%rsp)
movaps %xmm3,0x60(%rsp)
movaps %xmm1,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
mov    %rdi,%r14
movaps %xmm2,(%rsp)
movaps %xmm2,%xmm0
call   1030 <fabs@plt>
mov    %rax,%rbx
movaps 0x20(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %rax,%rbx
jle    1183 <PolygonF_QuadForPlane+0x63>
movaps (%rsp),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rbx
movaps 0x10(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %rax,%rbx
jle    1183 <PolygonF_QuadForPlane+0x63>
movaps 0xe7f(%rip),%xmm3
jmp    118b <PolygonF_QuadForPlane+0x6b>
movss  0xe95(%rip),%xmm3
xorps  %xmm4,%xmm4
movaps 0x10(%rsp),%xmm1
movaps %xmm1,%xmm0
movaps %xmm1,%xmm2
mulss  %xmm4,%xmm0
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
movaps %xmm3,%xmm5
movaps 0x20(%rsp),%xmm3
mulss  %xmm3,%xmm1
movaps %xmm3,%xmm4
addss  %xmm0,%xmm1
movaps %xmm5,%xmm0
movaps (%rsp),%xmm3
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm2,%xmm1
xorps  %xmm2,%xmm2
subss  %xmm1,%xmm2
movaps %xmm2,0x40(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm3,%xmm1
unpcklps %xmm4,%xmm1
movaps %xmm1,0x50(%rsp)
mulps  %xmm1,%xmm0
subps  %xmm0,%xmm5
movaps %xmm5,0x30(%rsp)
movaps %xmm2,%xmm0
mulss  %xmm2,%xmm0
movaps %xmm5,%xmm1
shufps $0x55,%xmm5,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movaps %xmm5,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  0xe07(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movaps 0x40(%rsp),%xmm1
mulss  %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  0x30(%rsp),%xmm0
movaps %xmm0,%xmm2
movaps 0x10(%rsp),%xmm12
mulss  %xmm12,%xmm2
movaps %xmm1,%xmm9
movaps (%rsp),%xmm13
mulss  %xmm13,%xmm9
subss  %xmm2,%xmm9
movaps %xmm1,%xmm2
movaps %xmm1,%xmm10
shufps $0xd4,%xmm0,%xmm2
movaps %xmm0,%xmm8
movlhps %xmm1,%xmm8
movlhps %xmm0,%xmm10
shufps $0x28,%xmm2,%xmm10
shufps $0x52,%xmm0,%xmm2
movaps 0x50(%rsp),%xmm14
movaps %xmm14,%xmm4
mulps  %xmm2,%xmm4
movaps 0x20(%rsp),%xmm1
unpcklps %xmm12,%xmm1
movaps %xmm0,%xmm5
mulps  %xmm1,%xmm5
subps  %xmm4,%xmm5
movaps 0x70(%rsp),%xmm7
mulss  %xmm7,%xmm9
movaps 0xd61(%rip),%xmm4
movaps %xmm9,%xmm6
xorps  %xmm4,%xmm6
movaps %xmm7,%xmm11
shufps $0x0,%xmm7,%xmm11
mulps  %xmm11,%xmm5
movaps 0x60(%rsp),%xmm3
shufps $0x0,%xmm3,%xmm3
unpcklps %xmm13,%xmm12
mulps  %xmm3,%xmm12
addps  %xmm5,%xmm12
xorps  %xmm4,%xmm5
movlhps %xmm14,%xmm1
movlhps %xmm5,%xmm6
shufps $0xd4,%xmm5,%xmm9
shufps $0x28,%xmm9,%xmm6
mulps  %xmm3,%xmm1
addps  %xmm6,%xmm1
movlhps %xmm0,%xmm2
mulps  %xmm11,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%r14)
xorps  %xmm7,%xmm4
shufps $0x0,%xmm4,%xmm7
mulps  %xmm7,%xmm10
movaps %xmm1,%xmm3
movaps %xmm12,%xmm4
shufps $0x3,%xmm12,%xmm3
movaps %xmm12,%xmm2
shufps $0x84,%xmm3,%xmm2
addps  %xmm10,%xmm2
movups %xmm2,0x10(%r14)
shufps $0x24,%xmm8,%xmm0
shufps $0x1,%xmm1,%xmm4
shufps $0x98,%xmm1,%xmm4
mulps  %xmm11,%xmm0
subps  %xmm0,%xmm4
movups %xmm4,0x20(%r14)
add    $0x88,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @PolygonF_QuadForPlane(float* %0, float %1, float %2, float %3, float %4, float %5) {
%7 = alloca float*
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca [3 x float]
%15 = alloca [3 x float]
store float* %0, float** %7
store float %1, float* %8
store float %2, float* %9
store float %3, float* %10
store float %4, float* %11
store float %5, float* %12
%16 = load float, float* %10
%17 = call i64 @fabs(float %16)
%18 = load float, float* %8
%19 = call i64 @fabs(float %18)
%20 = icmp sgt i64 %17, %19
br i1 %20, label %21, label %31
21: ; preds = %6
%22 = load float, float* %10
%23 = call i64 @fabs(float %22)
%24 = load float, float* %9
%25 = call i64 @fabs(float %24)
%26 = icmp sgt i64 %23, %25
br i1 %26, label %27, label %31
27: ; preds = %21
%28 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
store float 1.000000e+00, float* %28
%29 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
store float 0.000000e+00, float* %29
%30 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
store float 0.000000e+00, float* %30
br label %35
31: ; preds = %21, %6
%32 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
store float 0.000000e+00, float* %32
%33 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
store float 0.000000e+00, float* %33
%34 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
store float 1.000000e+00, float* %34
br label %35
35: ; preds = %31, %27
%36 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%37 = load float, float* %36
%38 = load float, float* %8
%39 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%40 = load float, float* %39
%41 = load float, float* %9
%42 = fmul float %40, %41
%43 = call float @llvm.fmuladd.f32(float %37, float %38, float %42)
%44 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%45 = load float, float* %44
%46 = load float, float* %10
%47 = call float @llvm.fmuladd.f32(float %45, float %46, float %43)
%48 = fneg float %47
store float %48, float* %13
%49 = load float, float* %13
%50 = load float, float* %8
%51 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%52 = load float, float* %51
%53 = call float @llvm.fmuladd.f32(float %49, float %50, float %52)
store float %53, float* %51
%54 = load float, float* %13
%55 = load float, float* %9
%56 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%57 = load float, float* %56
%58 = call float @llvm.fmuladd.f32(float %54, float %55, float %57)
store float %58, float* %56
%59 = load float, float* %13
%60 = load float, float* %10
%61 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%62 = load float, float* %61
%63 = call float @llvm.fmuladd.f32(float %59, float %60, float %62)
store float %63, float* %61
%64 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%65 = load float, float* %64
%66 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%67 = load float, float* %66
%68 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%69 = load float, float* %68
%70 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%71 = load float, float* %70
%72 = fmul float %69, %71
%73 = call float @llvm.fmuladd.f32(float %65, float %67, float %72)
%74 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%75 = load float, float* %74
%76 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%77 = load float, float* %76
%78 = call float @llvm.fmuladd.f32(float %75, float %77, float %73)
%79 = call double @sqrt(float %78)
%80 = fdiv double 1.000000e+00, %79
%81 = fptrunc double %80 to float
store float %81, float* %13
%82 = load float, float* %13
%83 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%84 = load float, float* %83
%85 = fmul float %84, %82
store float %85, float* %83
%86 = load float, float* %13
%87 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%88 = load float, float* %87
%89 = fmul float %88, %86
store float %89, float* %87
%90 = load float, float* %13
%91 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%92 = load float, float* %91
%93 = fmul float %92, %90
store float %93, float* %91
%94 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%95 = load float, float* %94
%96 = load float, float* %10
%97 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%98 = load float, float* %97
%99 = load float, float* %9
%100 = fmul float %98, %99
%101 = fneg float %100
%102 = call float @llvm.fmuladd.f32(float %95, float %96, float %101)
%103 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
store float %102, float* %103
%104 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%105 = load float, float* %104
%106 = load float, float* %8
%107 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%108 = load float, float* %107
%109 = load float, float* %10
%110 = fmul float %108, %109
%111 = fneg float %110
%112 = call float @llvm.fmuladd.f32(float %105, float %106, float %111)
%113 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
store float %112, float* %113
%114 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%115 = load float, float* %114
%116 = load float, float* %9
%117 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%118 = load float, float* %117
%119 = load float, float* %8
%120 = fmul float %118, %119
%121 = fneg float %120
%122 = call float @llvm.fmuladd.f32(float %115, float %116, float %121)
%123 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
store float %122, float* %123
%124 = load float, float* %11
%125 = load float, float* %8
%126 = load float, float* %12
%127 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%128 = load float, float* %127
%129 = fmul float %126, %128
%130 = fneg float %129
%131 = call float @llvm.fmuladd.f32(float %124, float %125, float %130)
%132 = load float, float* %12
%133 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%134 = load float, float* %133
%135 = call float @llvm.fmuladd.f32(float %132, float %134, float %131)
%136 = load float*, float** %7
%137 = getelementptr inbounds float, float* %136, i64 0
store float %135, float* %137
%138 = load float, float* %11
%139 = load float, float* %9
%140 = load float, float* %12
%141 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
%142 = load float, float* %141
%143 = fmul float %140, %142
%144 = fneg float %143
%145 = call float @llvm.fmuladd.f32(float %138, float %139, float %144)
%146 = load float, float* %12
%147 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%148 = load float, float* %147
%149 = call float @llvm.fmuladd.f32(float %146, float %148, float %145)
%150 = load float*, float** %7
%151 = getelementptr inbounds float, float* %150, i64 1
store float %149, float* %151
%152 = load float, float* %11
%153 = load float, float* %10
%154 = load float, float* %12
%155 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%156 = load float, float* %155
%157 = fmul float %154, %156
%158 = fneg float %157
%159 = call float @llvm.fmuladd.f32(float %152, float %153, float %158)
%160 = load float, float* %12
%161 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%162 = load float, float* %161
%163 = call float @llvm.fmuladd.f32(float %160, float %162, float %159)
%164 = load float*, float** %7
%165 = getelementptr inbounds float, float* %164, i64 2
store float %163, float* %165
%166 = load float, float* %11
%167 = load float, float* %8
%168 = load float, float* %12
%169 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%170 = load float, float* %169
%171 = fmul float %168, %170
%172 = call float @llvm.fmuladd.f32(float %166, float %167, float %171)
%173 = load float, float* %12
%174 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%175 = load float, float* %174
%176 = call float @llvm.fmuladd.f32(float %173, float %175, float %172)
%177 = load float*, float** %7
%178 = getelementptr inbounds float, float* %177, i64 3
store float %176, float* %178
%179 = load float, float* %11
%180 = load float, float* %9
%181 = load float, float* %12
%182 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
%183 = load float, float* %182
%184 = fmul float %181, %183
%185 = call float @llvm.fmuladd.f32(float %179, float %180, float %184)
%186 = load float, float* %12
%187 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%188 = load float, float* %187
%189 = call float @llvm.fmuladd.f32(float %186, float %188, float %185)
%190 = load float*, float** %7
%191 = getelementptr inbounds float, float* %190, i64 4
store float %189, float* %191
%192 = load float, float* %11
%193 = load float, float* %10
%194 = load float, float* %12
%195 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%196 = load float, float* %195
%197 = fmul float %194, %196
%198 = call float @llvm.fmuladd.f32(float %192, float %193, float %197)
%199 = load float, float* %12
%200 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%201 = load float, float* %200
%202 = call float @llvm.fmuladd.f32(float %199, float %201, float %198)
%203 = load float*, float** %7
%204 = getelementptr inbounds float, float* %203, i64 5
store float %202, float* %204
%205 = load float, float* %11
%206 = load float, float* %8
%207 = load float, float* %12
%208 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%209 = load float, float* %208
%210 = fmul float %207, %209
%211 = call float @llvm.fmuladd.f32(float %205, float %206, float %210)
%212 = load float, float* %12
%213 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%214 = load float, float* %213
%215 = fneg float %212
%216 = call float @llvm.fmuladd.f32(float %215, float %214, float %211)
%217 = load float*, float** %7
%218 = getelementptr inbounds float, float* %217, i64 6
store float %216, float* %218
%219 = load float, float* %11
%220 = load float, float* %9
%221 = load float, float* %12
%222 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
%223 = load float, float* %222
%224 = fmul float %221, %223
%225 = call float @llvm.fmuladd.f32(float %219, float %220, float %224)
%226 = load float, float* %12
%227 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%228 = load float, float* %227
%229 = fneg float %226
%230 = call float @llvm.fmuladd.f32(float %229, float %228, float %225)
%231 = load float*, float** %7
%232 = getelementptr inbounds float, float* %231, i64 7
store float %230, float* %232
%233 = load float, float* %11
%234 = load float, float* %10
%235 = load float, float* %12
%236 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%237 = load float, float* %236
%238 = fmul float %235, %237
%239 = call float @llvm.fmuladd.f32(float %233, float %234, float %238)
%240 = load float, float* %12
%241 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%242 = load float, float* %241
%243 = fneg float %240
%244 = call float @llvm.fmuladd.f32(float %243, float %242, float %239)
%245 = load float*, float** %7
%246 = getelementptr inbounds float, float* %245, i64 8
store float %244, float* %246
%247 = load float, float* %11
%248 = load float, float* %8
%249 = load float, float* %12
%250 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%251 = load float, float* %250
%252 = fmul float %249, %251
%253 = fneg float %252
%254 = call float @llvm.fmuladd.f32(float %247, float %248, float %253)
%255 = load float, float* %12
%256 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%257 = load float, float* %256
%258 = fneg float %255
%259 = call float @llvm.fmuladd.f32(float %258, float %257, float %254)
%260 = load float*, float** %7
%261 = getelementptr inbounds float, float* %260, i64 9
store float %259, float* %261
%262 = load float, float* %11
%263 = load float, float* %9
%264 = load float, float* %12
%265 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
%266 = load float, float* %265
%267 = fmul float %264, %266
%268 = fneg float %267
%269 = call float @llvm.fmuladd.f32(float %262, float %263, float %268)
%270 = load float, float* %12
%271 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%272 = load float, float* %271
%273 = fneg float %270
%274 = call float @llvm.fmuladd.f32(float %273, float %272, float %269)
%275 = load float*, float** %7
%276 = getelementptr inbounds float, float* %275, i64 10
store float %274, float* %276
%277 = load float, float* %11
%278 = load float, float* %10
%279 = load float, float* %12
%280 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%281 = load float, float* %280
%282 = fmul float %279, %281
%283 = fneg float %282
%284 = call float @llvm.fmuladd.f32(float %277, float %278, float %283)
%285 = load float, float* %12
%286 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%287 = load float, float* %286
%288 = fneg float %285
%289 = call float @llvm.fmuladd.f32(float %288, float %287, float %284)
%290 = load float*, float** %7
%291 = getelementptr inbounds float, float* %290, i64 11
store float %289, float* %291
ret void
}

LLVM IR (-O2):
define void @PolygonF_QuadForPlane(float* nocapture writeonly %0, float %1, float %2, float %3, float %4, float %5) {
%7 = tail call i64 @fabs(float %3)
%8 = tail call i64 @fabs(float %1)
%9 = icmp sgt i64 %7, %8
br i1 %9, label %10, label %14
10: ; preds = %6
%11 = tail call i64 @fabs(float %3)
%12 = tail call i64 @fabs(float %2)
%13 = icmp sgt i64 %11, %12
br i1 %13, label %15, label %14
14: ; preds = %10, %6
br label %15
15: ; preds = %10, %14
%16 = phi <2 x float> [ <float 1.000000e+00, float 0.000000e+00>, %14 ], [ <float 0.000000e+00, float 1.000000e+00>, %10 ]
%17 = fmul float %2, 0.000000e+00
%18 = extractelement <2 x float> %16, i64 1
%19 = tail call float @llvm.fmuladd.f32(float %18, float %1, float %17)
%20 = extractelement <2 x float> %16, i64 0
%21 = tail call float @llvm.fmuladd.f32(float %20, float %3, float %19)
%22 = fneg float %21
%23 = tail call float @llvm.fmuladd.f32(float %22, float %2, float 0.000000e+00)
%24 = insertelement <2 x float> poison, float %22, i64 0
%25 = shufflevector <2 x float> %24, <2 x float> poison, <2 x i32> zeroinitializer
%26 = insertelement <2 x float> poison, float %3, i64 0
%27 = insertelement <2 x float> %26, float %1, i64 1
%28 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %25, <2 x float> %27, <2 x float> %16)
%29 = fmul float %23, %23
%30 = extractelement <2 x float> %28, i64 1
%31 = tail call float @llvm.fmuladd.f32(float %30, float %30, float %29)
%32 = extractelement <2 x float> %28, i64 0
%33 = tail call float @llvm.fmuladd.f32(float %32, float %32, float %31)
%34 = tail call double @sqrt(float %33)
%35 = fdiv double 1.000000e+00, %34
%36 = fptrunc double %35 to float
%37 = fmul float %23, %36
%38 = insertelement <2 x float> poison, float %36, i64 0
%39 = shufflevector <2 x float> %38, <2 x float> poison, <2 x i32> zeroinitializer
%40 = fmul <2 x float> %28, %39
%41 = shufflevector <2 x float> %40, <2 x float> poison, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
%42 = shufflevector <2 x float> %40, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%43 = extractelement <2 x float> %40, i64 0
%44 = fneg float %43
%45 = fmul float %44, %2
%46 = tail call float @llvm.fmuladd.f32(float %37, float %3, float %45)
%47 = extractelement <2 x float> %40, i64 1
%48 = insertelement <2 x float> poison, float %47, i64 0
%49 = insertelement <2 x float> %48, float %37, i64 1
%50 = fneg <2 x float> %49
%51 = fmul <2 x float> %27, %50
%52 = insertelement <2 x float> poison, float %1, i64 0
%53 = insertelement <2 x float> %52, float %2, i64 1
%54 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %40, <2 x float> %53, <2 x float> %51)
%55 = fmul float %46, %5
%56 = fneg float %55
%57 = insertelement <2 x float> poison, float %5, i64 0
%58 = shufflevector <2 x float> %57, <2 x float> poison, <2 x i32> zeroinitializer
%59 = fmul <2 x float> %54, %58
%60 = fneg <2 x float> %59
%61 = insertelement <4 x float> poison, float %4, i64 0
%62 = shufflevector <4 x float> %61, <4 x float> poison, <4 x i32> zeroinitializer
%63 = insertelement <4 x float> poison, float %1, i64 0
%64 = insertelement <4 x float> %63, float %2, i64 1
%65 = insertelement <4 x float> %64, float %3, i64 2
%66 = insertelement <4 x float> %65, float %1, i64 3
%67 = insertelement <4 x float> poison, float %56, i64 0
%68 = shufflevector <2 x float> %60, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%69 = shufflevector <4 x float> %67, <4 x float> %68, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
%70 = insertelement <4 x float> %69, float %55, i64 3
%71 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %62, <4 x float> %66, <4 x float> %70)
%72 = insertelement <4 x float> poison, float %5, i64 0
%73 = shufflevector <4 x float> %72, <4 x float> poison, <4 x i32> zeroinitializer
%74 = insertelement <4 x float> poison, float %47, i64 0
%75 = insertelement <4 x float> %74, float %37, i64 1
%76 = shufflevector <2 x float> %40, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%77 = shufflevector <4 x float> %75, <4 x float> %76, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%78 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %73, <4 x float> %77, <4 x float> %71)
%79 = bitcast float* %0 to <4 x float>*
store <4 x float> %78, <4 x float>* %79
%80 = getelementptr inbounds float, float* %0, i64 4
%81 = insertelement <2 x float> poison, float %4, i64 0
%82 = shufflevector <2 x float> %81, <2 x float> poison, <2 x i32> zeroinitializer
%83 = insertelement <2 x float> poison, float %2, i64 0
%84 = insertelement <2 x float> %83, float %3, i64 1
%85 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %82, <2 x float> %84, <2 x float> %59)
%86 = shufflevector <2 x float> %85, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%87 = fneg float %5
%88 = insertelement <4 x float> %72, float %87, i64 1
%89 = shufflevector <4 x float> %88, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%90 = insertelement <4 x float> poison, float %37, i64 0
%91 = shufflevector <4 x float> %90, <4 x float> %76, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
%92 = insertelement <4 x float> %91, float %37, i64 3
%93 = shufflevector <2 x float> %85, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%94 = shufflevector <4 x float> %93, <4 x float> %71, <4 x i32> <i32 0, i32 1, i32 7, i32 undef>
%95 = shufflevector <4 x float> %94, <4 x float> %86, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
%96 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %89, <4 x float> %92, <4 x float> %95)
%97 = bitcast float* %80 to <4 x float>*
store <4 x float> %96, <4 x float>* %97
%98 = getelementptr inbounds float, float* %0, i64 8
%99 = insertelement <4 x float> poison, float %87, i64 0
%100 = shufflevector <4 x float> %99, <4 x float> poison, <4 x i32> zeroinitializer
%101 = insertelement <4 x float> %42, float %37, i64 2
%102 = shufflevector <4 x float> %101, <4 x float> %41, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
%103 = shufflevector <4 x float> %86, <4 x float> %71, <4 x i32> <i32 1, i32 4, i32 5, i32 6>
%104 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %100, <4 x float> %102, <4 x float> %103)
%105 = bitcast float* %98 to <4 x float>*
store <4 x float> %104, <4 x float>* %105
ret void
}