#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 creaTorre(float h, float a, float b, int n) {
  float x, y, z, a2, b2;
  int i;
  float m, e, da, db;
  if (n < 1) {
    printf("\n Error: Numero de segmentos en torre menor que 1\n");
    return;
  }
  m = h;
  glPushMatrix();
  e = m / n;
  da = a / (2.0 * n);
  db = b / (2.0 * 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 - da, y + e, -b2 + db, 0.1, 0.1);
      paralelepipedo(a2, y, -b2, a2 - da, y + e, b2 - db, 0.1, 0.1);
      paralelepipedo(a2, y, b2, -a2 + da, y + e, b2 - db, 0.1, 0.1);
      paralelepipedo(-a2, y, b2, -a2 + da, y + e, -b2 + db, 0.1, 0.1);
    } else {
      paralelepipedo(a2, y, -b2, -a2 + da, y + e, -b2 + db, 0.1, 0.1);
      paralelepipedo(a2, y, b2, a2 - da, y + e, -b2 + db, 0.1, 0.1);
      paralelepipedo(-a2, y, b2, a2 - da, y + e, b2 - db, 0.1, 0.1);
      paralelepipedo(-a2, y, -b2, -a2 + da, y + e, b2 - db, 0.1, 0.1);
    }
    paralelepipedo(-a2, y, -b2, -a2 + da, y + e, -b2 + db, 0.1, 0.1);
    paralelepipedo(a2, y, -b2, a2 - da, y + e, -b2 + db, 0.1, 0.1);
    paralelepipedo(-a2, y, b2, -a2 + da, y + e, b2 - db, 0.1, 0.1);
    paralelepipedo(a2, y, b2, a2 - da, y + e, b2 - db, 0.1, 0.1);
    y = y + e;
    a2 = a2 - da;
    b2 = b2 - db;
  }
  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):
<creaTorre>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
mov    %edi,-0x10(%rbp)
cmpl   $0x1,-0x10(%rbp)
jge    1175 <creaTorre+0x35>
lea    0xea5(%rip),%rdi
call   1030 <printf@plt>
jmp    18ed <creaTorre+0x7ad>
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)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2sdl -0x10(%rbp),%xmm2
movsd  0xe51(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2sdl -0x10(%rbp),%xmm2
movsd  0xe2a(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe00(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xde2(%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    17c6 <creaTorre+0x686>
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  0xd7d(%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  0xd42(%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  0xd07(%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  0xcb2(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     14d3 <creaTorre+0x393>
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
subss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
addss  -0x38(%rbp),%xmm5
movsd  0xc3a(%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
subss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
subss  -0x38(%rbp),%xmm5
movsd  0xbf0(%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
addss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
subss  -0x38(%rbp),%xmm5
movsd  0xba6(%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
addss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
addss  -0x38(%rbp),%xmm5
movsd  0xb42(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
jmp    162f <creaTorre+0x4ef>
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
addss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
addss  -0x38(%rbp),%xmm5
movsd  0xad9(%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
subss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
addss  -0x38(%rbp),%xmm5
movsd  0xa8f(%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
subss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
subss  -0x38(%rbp),%xmm5
movsd  0xa45(%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
addss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
subss  -0x38(%rbp),%xmm5
movsd  0x9e1(%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
addss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
addss  -0x38(%rbp),%xmm5
movsd  0x970(%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
subss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
addss  -0x38(%rbp),%xmm5
movsd  0x919(%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
addss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
subss  -0x38(%rbp),%xmm5
movsd  0x8c2(%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
subss  -0x34(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
addss  -0x30(%rbp),%xmm4
movss  -0x24(%rbp),%xmm5
subss  -0x38(%rbp),%xmm5
movsd  0x885(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
movss  -0x18(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x24(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1232 <creaTorre+0xf2>
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  0x7f5(%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  0x7ba(%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  0x77f(%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  0x72a(%rip),%xmm7
movaps %xmm7,%xmm6
call   1050 <paralelepipedo@plt>
mov    $0x0,%al
call   1040 <glPopMatrix@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<creaTorre>:
push   %rbp
push   %rbx
sub    $0xb8,%rsp
movaps %xmm1,0x20(%rsp)
test   %edi,%edi
jle    1687 <creaTorre+0x547>
mov    %edi,%ebx
xor    %ebp,%ebp
xor    %eax,%eax
movss  %xmm0,0x3c(%rsp)
movaps %xmm2,0x10(%rsp)
call   1060 <glPushMatrix@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
addsd  %xmm1,%xmm1
movaps 0x20(%rsp),%xmm3
unpcklps 0x10(%rsp),%xmm3
cvtps2pd %xmm3,%xmm2
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm2
cvtpd2ps %xmm2,%xmm1
movapd %xmm1,0xa0(%rsp)
mulps  0xe59(%rip),%xmm3
movaps %xmm3,0x20(%rsp)
movss  0x3c(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x3c(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
jmp    13c7 <creaTorre+0x287>
nopw   0x0(%rax,%rax,1)
movaps 0xa0(%rsp),%xmm3
subps  0x20(%rsp),%xmm3
movaps %xmm3,0x70(%rsp)
movss  0x3c(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
addss  %xmm1,%xmm0
movaps %xmm0,%xmm4
movss  %xmm0,0x8(%rsp)
movaps %xmm3,%xmm5
shufps $0x55,%xmm3,%xmm5
movaps %xmm5,0x90(%rsp)
movss  0xc(%rsp),%xmm0
movaps 0x40(%rsp),%xmm2
movsd  0xe03(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x20(%rsp),%xmm0
subps  0xa0(%rsp),%xmm0
movaps %xmm0,%xmm1
movaps %xmm0,%xmm3
movaps %xmm0,0x20(%rsp)
shufps $0x55,%xmm0,%xmm1
movaps %xmm1,0x80(%rsp)
movss  0xc(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movss  0x8(%rsp),%xmm4
movaps 0x90(%rsp),%xmm5
movsd  0xdb0(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x60(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps 0x20(%rsp),%xmm3
movss  0x8(%rsp),%xmm4
movaps 0x80(%rsp),%xmm5
movsd  0xd7d(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x60(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x40(%rsp),%xmm2
movaps 0x70(%rsp),%xmm3
movss  0x8(%rsp),%xmm4
movaps 0x80(%rsp),%xmm5
movsd  0xd4a(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x60(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x40(%rsp),%xmm2
movaps 0x70(%rsp),%xmm3
movss  0x8(%rsp),%xmm4
movaps 0x90(%rsp),%xmm5
movsd  0xd17(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movss  0xc(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x40(%rsp),%xmm2
movaps 0x20(%rsp),%xmm3
movss  0x8(%rsp),%xmm4
movaps 0x90(%rsp),%xmm5
movsd  0xce3(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x20(%rsp),%xmm5
shufps $0x55,%xmm5,%xmm5
movaps %xmm5,0x40(%rsp)
movaps 0x60(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps 0x70(%rsp),%xmm3
movss  0x8(%rsp),%xmm4
movsd  0xcaa(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movss  0xc(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movapd 0x50(%rsp),%xmm2
movaps 0x20(%rsp),%xmm3
movss  0x8(%rsp),%xmm4
movaps 0x40(%rsp),%xmm5
movsd  0xc78(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
add    $0x1,%ebp
movss  0x8(%rsp),%xmm0
movss  %xmm0,0x10(%rsp)
cmp    %ebp,%ebx
je     15ae <creaTorre+0x46e>
movaps 0x20(%rsp),%xmm2
movss  %xmm2,0xc(%rsp)
movaps %xmm2,%xmm1
movaps 0xc34(%rip),%xmm0
xorps  %xmm0,%xmm1
movaps %xmm1,0x60(%rsp)
movaps %xmm2,%xmm4
movaps %xmm2,%xmm3
movaps %xmm2,0x20(%rsp)
shufps $0x55,%xmm2,%xmm4
movaps %xmm4,0x50(%rsp)
movaps %xmm4,%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x40(%rsp)
movaps %xmm1,%xmm0
movss  0x10(%rsp),%xmm1
movaps %xmm1,%xmm4
movaps %xmm2,%xmm5
movsd  0xc06(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x20(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x40(%rsp),%xmm2
movaps %xmm0,%xmm3
movaps %xmm1,%xmm4
movaps 0x50(%rsp),%xmm5
movsd  0xbdb(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x20(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps 0x60(%rsp),%xmm3
movaps %xmm1,%xmm4
movaps %xmm2,%xmm5
movsd  0xbb0(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x60(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps %xmm0,%xmm3
movaps %xmm1,%xmm4
movaps 0x40(%rsp),%xmm5
movsd  0xb85(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
test   $0x1,%bpl
je     11d0 <creaTorre+0x90>
movss  0x3c(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
addss  %xmm1,%xmm0
movaps %xmm0,%xmm4
movss  %xmm0,0x8(%rsp)
movaps 0xa0(%rsp),%xmm0
movaps %xmm0,%xmm2
movaps 0x20(%rsp),%xmm3
subps  %xmm3,%xmm2
movaps %xmm2,0x70(%rsp)
shufps $0x55,%xmm2,%xmm2
movaps %xmm2,%xmm5
movaps %xmm2,0x90(%rsp)
subps  %xmm0,%xmm3
movaps %xmm3,%xmm0
movaps %xmm3,0x20(%rsp)
shufps $0x55,%xmm3,%xmm0
movaps %xmm0,0x80(%rsp)
movaps 0x60(%rsp),%xmm0
movaps 0x40(%rsp),%xmm2
movsd  0xb0a(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movss  0xc(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x40(%rsp),%xmm2
movaps 0x20(%rsp),%xmm3
movss  0x8(%rsp),%xmm4
movaps 0x80(%rsp),%xmm5
movsd  0xad6(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movss  0xc(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps 0x70(%rsp),%xmm3
movss  0x8(%rsp),%xmm4
movaps 0x80(%rsp),%xmm5
movsd  0xaa2(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x60(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps 0x70(%rsp),%xmm3
movss  0x8(%rsp),%xmm4
movaps 0x90(%rsp),%xmm5
jmp    12ce <creaTorre+0x18e>
movaps 0x20(%rsp),%xmm0
movaps %xmm0,%xmm1
movaps %xmm0,%xmm3
movaps %xmm0,0x20(%rsp)
movaps 0xa4b(%rip),%xmm2
xorps  %xmm2,%xmm1
movaps %xmm1,0x50(%rsp)
xorps  0x40(%rsp),%xmm2
movaps %xmm2,0x10(%rsp)
movsd  0xa41(%rip),%xmm6
movaps %xmm1,%xmm0
movss  0x8(%rsp),%xmm1
movaps %xmm1,%xmm4
movaps %xmm2,%xmm5
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x20(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x10(%rsp),%xmm2
movaps %xmm0,%xmm3
movaps %xmm1,%xmm4
movaps 0x40(%rsp),%xmm5
movsd  0xa07(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x20(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x40(%rsp),%xmm2
movaps 0x50(%rsp),%xmm3
movaps %xmm1,%xmm4
movaps %xmm2,%xmm5
movsd  0x9dc(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
movaps 0x50(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movaps 0x40(%rsp),%xmm2
movaps %xmm0,%xmm3
movaps %xmm1,%xmm4
movaps 0x10(%rsp),%xmm5
movsd  0x9b1(%rip),%xmm6
movaps %xmm6,%xmm7
call   1050 <paralelepipedo@plt>
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %rbp
jmp    1040 <glPopMatrix@plt>
lea    0x99a(%rip),%rdi
add    $0xb8,%rsp
pop    %rbx
pop    %rbp
jmp    1030 <puts@plt>

LLVM IR (-O0):
@.str = [51 x i8] c"\0A Error: Numero de segmentos en torre menor que 1\0A\00"
define void @creaTorre(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
%17 = alloca float
%18 = alloca float
store float %0, float* %5
store float %1, float* %6
store float %2, float* %7
store i32 %3, i32* %8
%19 = load i32, i32* %8
%20 = icmp slt i32 %19, 1
br i1 %20, label %21, label %23
21: ; preds = %4
%22 = call i32 @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0))
br label %329
23: ; preds = %4
%24 = load float, float* %5
store float %24, float* %15
%25 = call i32 (...) @glPushMatrix()
%26 = load float, float* %15
%27 = load i32, i32* %8
%28 = sitofp i32 %27 to float
%29 = fdiv float %26, %28
store float %29, float* %16
%30 = load float, float* %6
%31 = fpext float %30 to double
%32 = load i32, i32* %8
%33 = sitofp i32 %32 to double
%34 = fmul double 2.000000e+00, %33
%35 = fdiv double %31, %34
%36 = fptrunc double %35 to float
store float %36, float* %17
%37 = load float, float* %7
%38 = fpext float %37 to double
%39 = load i32, i32* %8
%40 = sitofp i32 %39 to double
%41 = fmul double 2.000000e+00, %40
%42 = fdiv double %38, %41
%43 = fptrunc double %42 to float
store float %43, float* %18
store float 0.000000e+00, float* %10
%44 = load float, float* %6
%45 = fpext float %44 to double
%46 = fdiv double %45, 2.000000e+00
%47 = fptrunc double %46 to float
store float %47, float* %12
%48 = load float, float* %7
%49 = fpext float %48 to double
%50 = fdiv double %49, 2.000000e+00
%51 = fptrunc double %50 to float
store float %51, float* %13
store i32 0, i32* %14
br label %52
52: ; preds = %288, %23
%53 = load i32, i32* %14
%54 = load i32, i32* %8
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %291
56: ; preds = %52
%57 = load float, float* %12
%58 = fneg float %57
%59 = load float, float* %10
%60 = load float, float* %13
%61 = fneg float %60
%62 = load float, float* %12
%63 = load float, float* %10
%64 = load float, float* %13
%65 = fneg float %64
%66 = call i32 @paralelepipedo(float %58, float %59, float %61, float %62, float %63, float %65, double 1.000000e-01, double 1.000000e-01)
%67 = load float, float* %12
%68 = load float, float* %10
%69 = load float, float* %13
%70 = fneg float %69
%71 = load float, float* %12
%72 = load float, float* %10
%73 = load float, float* %13
%74 = call i32 @paralelepipedo(float %67, float %68, float %70, float %71, float %72, float %73, double 1.000000e-01, double 1.000000e-01)
%75 = load float, float* %12
%76 = load float, float* %10
%77 = load float, float* %13
%78 = load float, float* %12
%79 = fneg float %78
%80 = load float, float* %10
%81 = load float, float* %13
%82 = call i32 @paralelepipedo(float %75, float %76, float %77, float %79, float %80, float %81, double 1.000000e-01, double 1.000000e-01)
%83 = load float, float* %12
%84 = fneg float %83
%85 = load float, float* %10
%86 = load float, float* %13
%87 = load float, float* %12
%88 = fneg float %87
%89 = load float, float* %10
%90 = load float, float* %13
%91 = fneg float %90
%92 = call i32 @paralelepipedo(float %84, float %85, float %86, float %88, float %89, float %91, double 1.000000e-01, double 1.000000e-01)
%93 = load i32, i32* %14
%94 = srem i32 %93, 2
%95 = icmp ne i32 %94, 0
br i1 %95, label %96, label %157
96: ; preds = %56
%97 = load float, float* %12
%98 = fneg float %97
%99 = load float, float* %10
%100 = load float, float* %13
%101 = fneg float %100
%102 = load float, float* %12
%103 = load float, float* %17
%104 = fsub float %102, %103
%105 = load float, float* %10
%106 = load float, float* %16
%107 = fadd float %105, %106
%108 = load float, float* %13
%109 = fneg float %108
%110 = load float, float* %18
%111 = fadd float %109, %110
%112 = call i32 @paralelepipedo(float %98, float %99, float %101, float %104, float %107, float %111, double 1.000000e-01, double 1.000000e-01)
%113 = load float, float* %12
%114 = load float, float* %10
%115 = load float, float* %13
%116 = fneg float %115
%117 = load float, float* %12
%118 = load float, float* %17
%119 = fsub float %117, %118
%120 = load float, float* %10
%121 = load float, float* %16
%122 = fadd float %120, %121
%123 = load float, float* %13
%124 = load float, float* %18
%125 = fsub float %123, %124
%126 = call i32 @paralelepipedo(float %113, float %114, float %116, float %119, float %122, float %125, double 1.000000e-01, double 1.000000e-01)
%127 = load float, float* %12
%128 = load float, float* %10
%129 = load float, float* %13
%130 = load float, float* %12
%131 = fneg float %130
%132 = load float, float* %17
%133 = fadd float %131, %132
%134 = load float, float* %10
%135 = load float, float* %16
%136 = fadd float %134, %135
%137 = load float, float* %13
%138 = load float, float* %18
%139 = fsub float %137, %138
%140 = call i32 @paralelepipedo(float %127, float %128, float %129, float %133, float %136, float %139, double 1.000000e-01, double 1.000000e-01)
%141 = load float, float* %12
%142 = fneg float %141
%143 = load float, float* %10
%144 = load float, float* %13
%145 = load float, float* %12
%146 = fneg float %145
%147 = load float, float* %17
%148 = fadd float %146, %147
%149 = load float, float* %10
%150 = load float, float* %16
%151 = fadd float %149, %150
%152 = load float, float* %13
%153 = fneg float %152
%154 = load float, float* %18
%155 = fadd float %153, %154
%156 = call i32 @paralelepipedo(float %142, float %143, float %144, float %148, float %151, float %155, double 1.000000e-01, double 1.000000e-01)
br label %218
157: ; preds = %56
%158 = load float, float* %12
%159 = load float, float* %10
%160 = load float, float* %13
%161 = fneg float %160
%162 = load float, float* %12
%163 = fneg float %162
%164 = load float, float* %17
%165 = fadd float %163, %164
%166 = load float, float* %10
%167 = load float, float* %16
%168 = fadd float %166, %167
%169 = load float, float* %13
%170 = fneg float %169
%171 = load float, float* %18
%172 = fadd float %170, %171
%173 = call i32 @paralelepipedo(float %158, float %159, float %161, float %165, float %168, float %172, double 1.000000e-01, double 1.000000e-01)
%174 = load float, float* %12
%175 = load float, float* %10
%176 = load float, float* %13
%177 = load float, float* %12
%178 = load float, float* %17
%179 = fsub float %177, %178
%180 = load float, float* %10
%181 = load float, float* %16
%182 = fadd float %180, %181
%183 = load float, float* %13
%184 = fneg float %183
%185 = load float, float* %18
%186 = fadd float %184, %185
%187 = call i32 @paralelepipedo(float %174, float %175, float %176, float %179, float %182, float %186, double 1.000000e-01, double 1.000000e-01)
%188 = load float, float* %12
%189 = fneg float %188
%190 = load float, float* %10
%191 = load float, float* %13
%192 = load float, float* %12
%193 = load float, float* %17
%194 = fsub float %192, %193
%195 = load float, float* %10
%196 = load float, float* %16
%197 = fadd float %195, %196
%198 = load float, float* %13
%199 = load float, float* %18
%200 = fsub float %198, %199
%201 = call i32 @paralelepipedo(float %189, float %190, float %191, float %194, float %197, float %200, double 1.000000e-01, double 1.000000e-01)
%202 = load float, float* %12
%203 = fneg float %202
%204 = load float, float* %10
%205 = load float, float* %13
%206 = fneg float %205
%207 = load float, float* %12
%208 = fneg float %207
%209 = load float, float* %17
%210 = fadd float %208, %209
%211 = load float, float* %10
%212 = load float, float* %16
%213 = fadd float %211, %212
%214 = load float, float* %13
%215 = load float, float* %18
%216 = fsub float %214, %215
%217 = call i32 @paralelepipedo(float %203, float %204, float %206, float %210, float %213, float %216, double 1.000000e-01, double 1.000000e-01)
br label %218
218: ; preds = %157, %96
%219 = load float, float* %12
%220 = fneg float %219
%221 = load float, float* %10
%222 = load float, float* %13
%223 = fneg float %222
%224 = load float, float* %12
%225 = fneg float %224
%226 = load float, float* %17
%227 = fadd float %225, %226
%228 = load float, float* %10
%229 = load float, float* %16
%230 = fadd float %228, %229
%231 = load float, float* %13
%232 = fneg float %231
%233 = load float, float* %18
%234 = fadd float %232, %233
%235 = call i32 @paralelepipedo(float %220, float %221, float %223, float %227, float %230, float %234, double 1.000000e-01, double 1.000000e-01)
%236 = load float, float* %12
%237 = load float, float* %10
%238 = load float, float* %13
%239 = fneg float %238
%240 = load float, float* %12
%241 = load float, float* %17
%242 = fsub float %240, %241
%243 = load float, float* %10
%244 = load float, float* %16
%245 = fadd float %243, %244
%246 = load float, float* %13
%247 = fneg float %246
%248 = load float, float* %18
%249 = fadd float %247, %248
%250 = call i32 @paralelepipedo(float %236, float %237, float %239, float %242, float %245, float %249, double 1.000000e-01, double 1.000000e-01)
%251 = load float, float* %12
%252 = fneg float %251
%253 = load float, float* %10
%254 = load float, float* %13
%255 = load float, float* %12
%256 = fneg float %255
%257 = load float, float* %17
%258 = fadd float %256, %257
%259 = load float, float* %10
%260 = load float, float* %16
%261 = fadd float %259, %260
%262 = load float, float* %13
%263 = load float, float* %18
%264 = fsub float %262, %263
%265 = call i32 @paralelepipedo(float %252, float %253, float %254, float %258, float %261, float %264, double 1.000000e-01, double 1.000000e-01)
%266 = load float, float* %12
%267 = load float, float* %10
%268 = load float, float* %13
%269 = load float, float* %12
%270 = load float, float* %17
%271 = fsub float %269, %270
%272 = load float, float* %10
%273 = load float, float* %16
%274 = fadd float %272, %273
%275 = load float, float* %13
%276 = load float, float* %18
%277 = fsub float %275, %276
%278 = call i32 @paralelepipedo(float %266, float %267, float %268, float %271, float %274, float %277, double 1.000000e-01, double 1.000000e-01)
%279 = load float, float* %10
%280 = load float, float* %16
%281 = fadd float %279, %280
store float %281, float* %10
%282 = load float, float* %12
%283 = load float, float* %17
%284 = fsub float %282, %283
store float %284, float* %12
%285 = load float, float* %13
%286 = load float, float* %18
%287 = fsub float %285, %286
store float %287, float* %13
br label %288
288: ; preds = %218
%289 = load i32, i32* %14
%290 = add nsw i32 %289, 1
store i32 %290, i32* %14
br label %52
291: ; preds = %52
%292 = load float, float* %12
%293 = fneg float %292
%294 = load float, float* %10
%295 = load float, float* %13
%296 = fneg float %295
%297 = load float, float* %12
%298 = load float, float* %10
%299 = load float, float* %13
%300 = fneg float %299
%301 = call i32 @paralelepipedo(float %293, float %294, float %296, float %297, float %298, float %300, double 1.000000e-01, double 1.000000e-01)
%302 = load float, float* %12
%303 = load float, float* %10
%304 = load float, float* %13
%305 = fneg float %304
%306 = load float, float* %12
%307 = load float, float* %10
%308 = load float, float* %13
%309 = call i32 @paralelepipedo(float %302, float %303, float %305, float %306, float %307, float %308, double 1.000000e-01, double 1.000000e-01)
%310 = load float, float* %12
%311 = load float, float* %10
%312 = load float, float* %13
%313 = load float, float* %12
%314 = fneg float %313
%315 = load float, float* %10
%316 = load float, float* %13
%317 = call i32 @paralelepipedo(float %310, float %311, float %312, float %314, float %315, float %316, double 1.000000e-01, double 1.000000e-01)
%318 = load float, float* %12
%319 = fneg float %318
%320 = load float, float* %10
%321 = load float, float* %13
%322 = load float, float* %12
%323 = fneg float %322
%324 = load float, float* %10
%325 = load float, float* %13
%326 = fneg float %325
%327 = call i32 @paralelepipedo(float %319, float %320, float %321, float %323, float %324, float %326, double 1.000000e-01, double 1.000000e-01)
%328 = call i32 (...) @glPopMatrix()
br label %329
329: ; preds = %291, %21
ret void
}

LLVM IR (-O2):
@str = [50 x i8] c"\0A Error: Numero de segmentos en torre menor que 1\00"
define void @creaTorre(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 ([50 x i8], [50 x i8]* @str, i64 0, i64 0))
br label %84
8: ; preds = %4
%9 = tail call i32 (...) @glPushMatrix()
%10 = sitofp i32 %3 to float
%11 = fdiv float %0, %10
%12 = sitofp i32 %3 to double
%13 = fmul double %12, 2.000000e+00
%14 = insertelement <2 x float> poison, float %1, i64 0
%15 = insertelement <2 x float> %14, float %2, i64 1
%16 = fpext <2 x float> %15 to <2 x double>
%17 = insertelement <2 x double> poison, double %13, i64 0
%18 = shufflevector <2 x double> %17, <2 x double> poison, <2 x i32> zeroinitializer
%19 = fdiv <2 x double> %16, %18
%20 = fptrunc <2 x double> %19 to <2 x float>
%21 = fmul <2 x float> %15, <float 5.000000e-01, float 5.000000e-01>
br label %22
22: ; preds = %8, %62
%23 = phi float [ %64, %62 ], [ 0.000000e+00, %8 ]
%24 = phi i32 [ %73, %62 ], [ 0, %8 ]
%25 = phi <2 x float> [ %66, %62 ], [ %21, %8 ]
%26 = extractelement <2 x float> %25, i64 0
%27 = fneg float %26
%28 = extractelement <2 x float> %25, i64 1
%29 = fneg float %28
%30 = tail call i32 @paralelepipedo(float %27, float %23, float %29, float %26, float %23, float %29, double 1.000000e-01, double 1.000000e-01)
%31 = tail call i32 @paralelepipedo(float %26, float %23, float %29, float %26, float %23, float %28, double 1.000000e-01, double 1.000000e-01)
%32 = tail call i32 @paralelepipedo(float %26, float %23, float %28, float %27, float %23, float %28, double 1.000000e-01, double 1.000000e-01)
%33 = tail call i32 @paralelepipedo(float %27, float %23, float %28, float %27, float %23, float %29, double 1.000000e-01, double 1.000000e-01)
%34 = and i32 %24, 1
%35 = icmp eq i32 %34, 0
br i1 %35, label %49, label %36
36: ; preds = %22
%37 = fadd float %11, %23
%38 = fsub <2 x float> %20, %25
%39 = extractelement <2 x float> %38, i64 1
%40 = fsub <2 x float> %25, %20
%41 = extractelement <2 x float> %40, i64 0
%42 = tail call i32 @paralelepipedo(float %27, float %23, float %29, float %41, float %37, float %39, double 1.000000e-01, double 1.000000e-01)
%43 = extractelement <2 x float> %40, i64 1
%44 = tail call i32 @paralelepipedo(float %26, float %23, float %29, float %41, float %37, float %43, double 1.000000e-01, double 1.000000e-01)
%45 = fsub <2 x float> %20, %25
%46 = extractelement <2 x float> %45, i64 0
%47 = tail call i32 @paralelepipedo(float %26, float %23, float %28, float %46, float %37, float %43, double 1.000000e-01, double 1.000000e-01)
%48 = tail call i32 @paralelepipedo(float %27, float %23, float %28, float %46, float %37, float %39, double 1.000000e-01, double 1.000000e-01)
br label %62
49: ; preds = %22
%50 = fsub <2 x float> %20, %25
%51 = extractelement <2 x float> %50, i64 0
%52 = fadd float %11, %23
%53 = fsub <2 x float> %20, %25
%54 = extractelement <2 x float> %53, i64 1
%55 = tail call i32 @paralelepipedo(float %26, float %23, float %29, float %51, float %52, float %54, double 1.000000e-01, double 1.000000e-01)
%56 = fsub <2 x float> %25, %20
%57 = extractelement <2 x float> %56, i64 0
%58 = tail call i32 @paralelepipedo(float %26, float %23, float %28, float %57, float %52, float %54, double 1.000000e-01, double 1.000000e-01)
%59 = extractelement <2 x float> %56, i64 1
%60 = tail call i32 @paralelepipedo(float %27, float %23, float %28, float %57, float %52, float %59, double 1.000000e-01, double 1.000000e-01)
%61 = tail call i32 @paralelepipedo(float %27, float %23, float %29, float %51, float %52, float %59, double 1.000000e-01, double 1.000000e-01)
br label %62
62: ; preds = %49, %36
%63 = phi float [ %54, %49 ], [ %39, %36 ]
%64 = phi float [ %52, %49 ], [ %37, %36 ]
%65 = phi float [ %51, %49 ], [ %46, %36 ]
%66 = phi <2 x float> [ %56, %49 ], [ %40, %36 ]
%67 = tail call i32 @paralelepipedo(float %27, float %23, float %29, float %65, float %64, float %63, double 1.000000e-01, double 1.000000e-01)
%68 = extractelement <2 x float> %66, i64 0
%69 = tail call i32 @paralelepipedo(float %26, float %23, float %29, float %68, float %64, float %63, double 1.000000e-01, double 1.000000e-01)
%70 = extractelement <2 x float> %66, i64 1
%71 = tail call i32 @paralelepipedo(float %27, float %23, float %28, float %65, float %64, float %70, double 1.000000e-01, double 1.000000e-01)
%72 = tail call i32 @paralelepipedo(float %26, float %23, float %28, float %68, float %64, float %70, double 1.000000e-01, double 1.000000e-01)
%73 = add nuw nsw i32 %24, 1
%74 = icmp eq i32 %73, %3
br i1 %74, label %75, label %22
75: ; preds = %62
%76 = extractelement <2 x float> %66, i64 0
%77 = fneg float %76
%78 = fneg float %70
%79 = tail call i32 @paralelepipedo(float %77, float %64, float %78, float %76, float %64, float %78, double 1.000000e-01, double 1.000000e-01)
%80 = tail call i32 @paralelepipedo(float %76, float %64, float %78, float %76, float %64, float %70, double 1.000000e-01, double 1.000000e-01)
%81 = tail call i32 @paralelepipedo(float %76, float %64, float %70, float %77, float %64, float %70, double 1.000000e-01, double 1.000000e-01)
%82 = tail call i32 @paralelepipedo(float %77, float %64, float %70, float %77, float %64, float %78, double 1.000000e-01, double 1.000000e-01)
%83 = tail call i32 (...) @glPopMatrix()
br label %84
84: ; preds = %75, %6
ret void
}