#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 */
int /*<<< orphan*/ glPopMatrix();
int /*<<< orphan*/ glPushMatrix();
int /*<<< orphan*/ paralelepipedo(float, float, float, float, float, float,
                                  double, double);
int /*<<< orphan*/ printf(char *);
void creaEstructura(float h, float a, float b, int n) {
  float x, y, z, a2, b2;
  int i;
  float m, e;
  if (n < 1) {
    printf("\n Error: Numero de segmentos en estructura menor que 1\n");
    return;
  }
  m = h;
  glPushMatrix();
  e = m / n;
  y = 0;
  a2 = a / 2.;
  b2 = b / 2.;
  for (i = 0; i < n; ++i) {
    paralelepipedo(-a2, y, -b2, a2, y, -b2, 0.1, 0.1);
    paralelepipedo(a2, y, -b2, a2, y, b2, 0.1, 0.1);
    paralelepipedo(a2, y, b2, -a2, y, b2, 0.1, 0.1);
    paralelepipedo(-a2, y, b2, -a2, y, -b2, 0.1, 0.1);
    if (i % 2) {
      paralelepipedo(-a2, y, -b2, a2, y + e, -b2, 0.1, 0.1);
      paralelepipedo(a2, y, -b2, a2, y + e, b2, 0.1, 0.1);
      paralelepipedo(a2, y, b2, -a2, y + e, b2, 0.1, 0.1);
      paralelepipedo(-a2, y, b2, -a2, y + e, -b2, 0.1, 0.1);
    } else {
      paralelepipedo(a2, y, -b2, -a2, y + e, -b2, 0.1, 0.1);
      paralelepipedo(a2, y, b2, a2, y + e, -b2, 0.1, 0.1);
      paralelepipedo(-a2, y, b2, a2, y + e, b2, 0.1, 0.1);
      paralelepipedo(-a2, y, -b2, -a2, y + e, b2, 0.1, 0.1);
    }
    paralelepipedo(-a2, y, -b2, -a2, y + e, -b2, 0.1, 0.1);
    paralelepipedo(a2, y, -b2, a2, y + e, -b2, 0.1, 0.1);
    paralelepipedo(-a2, y, b2, -a2, y + e, b2, 0.1, 0.1);
    paralelepipedo(a2, y, b2, a2, y + e, b2, 0.1, 0.1);
    y = y + e;
  }
  paralelepipedo(-a2, y, -b2, a2, y, -b2, 0.1, 0.1);
  paralelepipedo(a2, y, -b2, a2, y, b2, 0.1, 0.1);
  paralelepipedo(a2, y, b2, -a2, y, b2, 0.1, 0.1);
  paralelepipedo(-a2, y, b2, -a2, y, -b2, 0.1, 0.1);
  glPopMatrix();
}


x86 assembly (clang, -O0):
<creaEstructura>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
mov    %edi,-0x10(%rbp)
cmpl   $0x1,-0x10(%rbp)
jge    1175 <creaEstructura+0x35>
lea    0xea5(%rip),%rdi
call   1030 <printf@plt>
jmp    1809 <creaEstructura+0x6c9>
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    $0x0,%al
call   1060 <glPushMatrix@plt>
movss  -0x2c(%rbp),%xmm0
cvtsi2ssl -0x10(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe4e(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe30(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16e2 <creaEstructura+0x5a2>
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x20(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movsd  0xdcb(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x20(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movsd  0xd90(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  -0x18(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movsd  0xd55(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  -0x18(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movsd  0xd00(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     145d <creaEstructura+0x31d>
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x20(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movsd  0xc92(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x20(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movsd  0xc52(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movsd  0xc12(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movsd  0xbb8(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
jmp    1591 <creaEstructura+0x451>
movss  -0x20(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x20(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movsd  0xb59(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movsd  0xb19(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movsd  0xad9(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x20(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movsd  0xa7f(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x20(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movsd  0xa18(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x20(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movsd  0x9cb(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movsd  0x97e(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movsd  0x94b(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x18(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e4 <creaEstructura+0xa4>
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x20(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movsd  0x8d9(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x20(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movsd  0x89e(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  -0x18(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movsd  0x863(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movss  -0x20(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movss  -0x18(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movsd  0x80e(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
mov    $0x0,%al
call   1040 <glPopMatrix@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<creaEstructura>:
push   %rbp
push   %rbx
sub    $0x68,%rsp
movaps %xmm2,0x20(%rsp)
movaps %xmm1,0x10(%rsp)
test   %edi,%edi
jle    157d <creaEstructura+0x43d>
mov    %edi,%ebx
xor    %ebp,%ebp
xor    %eax,%eax
movss  %xmm0,0x3c(%rsp)
call   1060 <glPushMatrix@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
movss  0x3c(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x3c(%rsp)
movss  0xe78(%rip),%xmm0
movaps 0x10(%rsp),%xmm2
mulss  %xmm0,%xmm2
movaps 0x20(%rsp),%xmm1
mulss  %xmm0,%xmm1
movaps 0xe6f(%rip),%xmm0
movaps %xmm2,0x10(%rsp)
xorps  %xmm0,%xmm2
movaps %xmm2,0x40(%rsp)
movaps %xmm1,0x20(%rsp)
xorps  %xmm1,%xmm0
movaps %xmm0,0x50(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rsp)
jmp    134f <creaEstructura+0x20f>
nopl   0x0(%rax)
movaps 0x10(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps 0x40(%rsp),%xmm3
movss  0xc(%rsp),%xmm4
movaps %xmm2,%xmm5
movsd  0xe2a(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x10(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
movaps %xmm0,%xmm3
movss  0xc(%rsp),%xmm4
movaps 0x50(%rsp),%xmm5
movsd  0xdfc(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x40(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
movaps 0x10(%rsp),%xmm3
movss  0xc(%rsp),%xmm4
movaps %xmm2,%xmm5
movsd  0xdce(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x40(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps %xmm0,%xmm3
movss  0xc(%rsp),%xmm4
movaps 0x20(%rsp),%xmm5
movsd  0xda0(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x40(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps %xmm0,%xmm3
movss  0xc(%rsp),%xmm4
movaps %xmm2,%xmm5
movsd  0xd74(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x10(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps %xmm0,%xmm3
movss  0xc(%rsp),%xmm4
movaps %xmm2,%xmm5
movsd  0xd48(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x40(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
movaps %xmm0,%xmm3
movss  0xc(%rsp),%xmm4
movaps %xmm2,%xmm5
movsd  0xd1c(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x10(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
movaps %xmm0,%xmm3
movss  0xc(%rsp),%xmm4
movaps %xmm2,%xmm5
movsd  0xcf0(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
add    $0x1,%ebp
movss  0xc(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
cmp    %ebp,%ebx
je     14c4 <creaEstructura+0x384>
movaps 0x40(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps 0x10(%rsp),%xmm3
movaps %xmm1,%xmm4
movaps %xmm2,%xmm5
movsd  0xcae(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x10(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps %xmm0,%xmm3
movaps %xmm1,%xmm4
movaps 0x20(%rsp),%xmm5
movsd  0xc83(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x10(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
movaps 0x40(%rsp),%xmm3
movaps %xmm1,%xmm4
movaps %xmm2,%xmm5
movsd  0xc58(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x40(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
movaps %xmm0,%xmm3
movaps %xmm1,%xmm4
movaps 0x50(%rsp),%xmm5
movsd  0xc2d(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movss  0x3c(%rsp),%xmm0
addss  0x8(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
test   $0x1,%bpl
je     11d0 <creaEstructura+0x90>
movaps 0x40(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps 0x10(%rsp),%xmm3
movss  0xc(%rsp),%xmm4
movaps %xmm2,%xmm5
movsd  0xbe3(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x10(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps %xmm0,%xmm3
movss  0xc(%rsp),%xmm4
movaps 0x20(%rsp),%xmm5
movsd  0xbb5(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x10(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
movaps 0x40(%rsp),%xmm3
movss  0xc(%rsp),%xmm4
movaps %xmm2,%xmm5
movsd  0xb87(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x40(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
movaps %xmm0,%xmm3
movss  0xc(%rsp),%xmm4
movaps 0x50(%rsp),%xmm5
jmp    1278 <creaEstructura+0x138>
movsd  0xb54(%rip),%xmm6
movaps 0x40(%rsp),%xmm0
movss  0xc(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps 0x10(%rsp),%xmm3
movaps %xmm1,%xmm4
movaps %xmm2,%xmm5
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x10(%rsp),%xmm0
movss  0xc(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps %xmm0,%xmm3
movaps %xmm1,%xmm4
movaps 0x20(%rsp),%xmm5
movsd  0xb0e(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x10(%rsp),%xmm0
movss  0xc(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
movaps 0x40(%rsp),%xmm3
movaps %xmm1,%xmm4
movaps %xmm2,%xmm5
movsd  0xae3(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x40(%rsp),%xmm0
movss  0xc(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
movaps %xmm0,%xmm3
movaps %xmm1,%xmm4
movaps 0x50(%rsp),%xmm5
movsd  0xab8(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %rbp
jmp    1040 <glPopMatrix@plt>
lea    0xaa4(%rip),%rdi
add    $0x68,%rsp
pop    %rbx
pop    %rbp
jmp    1030 <puts@plt>

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

LLVM IR (-O2):
@str = [55 x i8] c"\0A Error: Numero de segmentos en estructura menor que 1\00"
define void @creaEstructura(float %0, float %1, float %2, i32 %3) {
%5 = icmp slt i32 %3, 1
br i1 %5, label %6, label %8
6: ; preds = %4
%7 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([55 x i8], [55 x i8]* @str, i64 0, i64 0))
br label %49
8: ; preds = %4
%9 = tail call i32 (...) @glPushMatrix()
%10 = sitofp i32 %3 to float
%11 = fdiv float %0, %10
%12 = fmul float %1, 5.000000e-01
%13 = fmul float %2, 5.000000e-01
%14 = fneg float %12
%15 = fneg float %13
br label %16
16: ; preds = %8, %36
%17 = phi float [ 0.000000e+00, %8 ], [ %25, %36 ]
%18 = phi i32 [ 0, %8 ], [ %41, %36 ]
%19 = tail call i32 @paralelepipedo(float %14, float %17, float %15, float %12, float %17, float %15, double 1.000000e-01, double 1.000000e-01)
%20 = tail call i32 @paralelepipedo(float %12, float %17, float %15, float %12, float %17, float %13, double 1.000000e-01, double 1.000000e-01)
%21 = tail call i32 @paralelepipedo(float %12, float %17, float %13, float %14, float %17, float %13, double 1.000000e-01, double 1.000000e-01)
%22 = tail call i32 @paralelepipedo(float %14, float %17, float %13, float %14, float %17, float %15, double 1.000000e-01, double 1.000000e-01)
%23 = and i32 %18, 1
%24 = icmp eq i32 %23, 0
%25 = fadd float %11, %17
br i1 %24, label %31, label %26
26: ; preds = %16
%27 = tail call i32 @paralelepipedo(float %14, float %17, float %15, float %12, float %25, float %15, double 1.000000e-01, double 1.000000e-01)
%28 = tail call i32 @paralelepipedo(float %12, float %17, float %15, float %12, float %25, float %13, double 1.000000e-01, double 1.000000e-01)
%29 = tail call i32 @paralelepipedo(float %12, float %17, float %13, float %14, float %25, float %13, double 1.000000e-01, double 1.000000e-01)
%30 = tail call i32 @paralelepipedo(float %14, float %17, float %13, float %14, float %25, float %15, double 1.000000e-01, double 1.000000e-01)
br label %36
31: ; preds = %16
%32 = tail call i32 @paralelepipedo(float %12, float %17, float %15, float %14, float %25, float %15, double 1.000000e-01, double 1.000000e-01)
%33 = tail call i32 @paralelepipedo(float %12, float %17, float %13, float %12, float %25, float %15, double 1.000000e-01, double 1.000000e-01)
%34 = tail call i32 @paralelepipedo(float %14, float %17, float %13, float %12, float %25, float %13, double 1.000000e-01, double 1.000000e-01)
%35 = tail call i32 @paralelepipedo(float %14, float %17, float %15, float %14, float %25, float %13, double 1.000000e-01, double 1.000000e-01)
br label %36
36: ; preds = %31, %26
%37 = tail call i32 @paralelepipedo(float %14, float %17, float %15, float %14, float %25, float %15, double 1.000000e-01, double 1.000000e-01)
%38 = tail call i32 @paralelepipedo(float %12, float %17, float %15, float %12, float %25, float %15, double 1.000000e-01, double 1.000000e-01)
%39 = tail call i32 @paralelepipedo(float %14, float %17, float %13, float %14, float %25, float %13, double 1.000000e-01, double 1.000000e-01)
%40 = tail call i32 @paralelepipedo(float %12, float %17, float %13, float %12, float %25, float %13, double 1.000000e-01, double 1.000000e-01)
%41 = add nuw nsw i32 %18, 1
%42 = icmp eq i32 %41, %3
br i1 %42, label %43, label %16
43: ; preds = %36
%44 = tail call i32 @paralelepipedo(float %14, float %25, float %15, float %12, float %25, float %15, double 1.000000e-01, double 1.000000e-01)
%45 = tail call i32 @paralelepipedo(float %12, float %25, float %15, float %12, float %25, float %13, double 1.000000e-01, double 1.000000e-01)
%46 = tail call i32 @paralelepipedo(float %12, float %25, float %13, float %14, float %25, float %13, double 1.000000e-01, double 1.000000e-01)
%47 = tail call i32 @paralelepipedo(float %14, float %25, float %13, float %14, float %25, float %15, double 1.000000e-01, double 1.000000e-01)
%48 = tail call i32 (...) @glPopMatrix()
br label %49
49: ; preds = %43, %6
ret void
}