LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jespinosa94[P]PED16/lib/tvectorporo.cpp
// Function: TVectorPoro::TVectorPoro(TVectorPoro const&)
TVectorPoro::TVectorPoro(const TVectorPoro &tvp) {
	dimension = tvp.dimension;
	datos = new TPoro[dimension];
	if(datos == NULL)
		dimension = 0;
	else
		for(int i=0; i<dimension; i++)
			datos[i] = tvp.datos[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x4e50
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movslq (%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
movq $-0x1, %rax
cmovbq %rax, %rdi
testb %cl, %cl
cmovneq %rax, %rdi
movq %rdi, -0x30(%rbp)
callq 0x1030
movq %rax, -0x28(%rbp)
jmp 0x582d
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x50(%rbp)
cmpq $0x0, %rax
je 0x5884
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4e50
jmp 0x586f
movq -0x60(%rbp), %rcx
movq -0x68(%rbp), %rax
addq $0x18, %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0x5860
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x5903
movq -0x40(%rbp), %rax
movl $0x0, (%rax)
jmp 0x594d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x5956
movq -0x50(%rbp), %rcx
movq %rax, %rsi
movq -0x68(%rbp), %rax
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0x70(%rbp)
je 0x58f4
movq -0x70(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x78(%rbp)
callq 0x50e0
movq -0x50(%rbp), %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x70(%rbp)
jne 0x58d2
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x11b0
jmp 0x5956
movl $0x0, -0x20(%rbp)
movq -0x40(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl (%rcx), %eax
jge 0x594b
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x20(%rbp), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
addq %rax, %rsi
movq 0x8(%rcx), %rdi
addq %rax, %rdi
callq 0x5150
jmp 0x593e
jmp 0x5940
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x590a
jmp 0x594d
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x50e0
movq -0x18(%rbp), %rdi
callq 0x1180
nopl (%rax,%rax)
// File: jespinosa94[P]PED16/lib/tvectorporo.cpp
// Function: TVectorPoro::~TVectorPoro()
TVectorPoro::~TVectorPoro() {
	dimension = 0;
	if(datos != NULL)
	{
		datos->~TPoro();
		datos = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x59aa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x50e0
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x50e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tvectorporo.cpp
// Function: TVectorPoro::operator=(TVectorPoro const&)
TVectorPoro& TVectorPoro::operator =(const TVectorPoro &tvp) {
	if(this != &tvp)
	{
		if(dimension != tvp.dimension)
		{
			dimension = tvp.dimension;
			if(datos != NULL)
				datos->~TPoro();
			datos = new TPoro[dimension];
			if(datos == NULL)
			{
				dimension = 0;
				return *this;
			}
		}
		for(int i=0; i<dimension; i++)
			datos[i] = tvp.datos[i];
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq -0x18(%rbp), %rax
je 0x5b68
movq -0x30(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x5b1e
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x5a17
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x50e0
movq -0x30(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x48(%rbp)
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x50(%rbp)
callq 0x1030
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
je 0x5aaa
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4e50
jmp 0x5a95
movq -0x60(%rbp), %rcx
movq -0x68(%rbp), %rax
addq $0x18, %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0x5a86
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x5b1c
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq %rax, -0x8(%rbp)
jmp 0x5b70
movq -0x38(%rbp), %rcx
movq %rax, %rsi
movq -0x68(%rbp), %rax
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
cmpq %rax, %rcx
movq %rax, -0x70(%rbp)
je 0x5b0d
movq -0x70(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x78(%rbp)
callq 0x50e0
movq -0x38(%rbp), %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x70(%rbp)
jne 0x5aeb
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x11b0
jmp 0x5b7d
jmp 0x5b1e
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl (%rcx), %eax
jge 0x5b66
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rsi
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdi
movslq -0x28(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x5150
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5b25
jmp 0x5b68
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tvectorporo.cpp
// Function: TVectorPoro::operator==(TVectorPoro const&) const
bool TVectorPoro::operator ==(const TVectorPoro &tvp) const {
	if(dimension != tvp.dimension)
		return false;
	for(int i=0; i<dimension; i++)
		if(datos[i] != tvp.datos[i])
			return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x5bb8
movb $0x0, -0x1(%rbp)
jmp 0x5c12
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x5c0e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x5320
testb $0x1, %al
jne 0x5bfb
jmp 0x5c01
movb $0x0, -0x1(%rbp)
jmp 0x5c12
jmp 0x5c03
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5bbf
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tvectorporo.cpp
// Function: TVectorPoro::operator[](int)
TPoro& TVectorPoro::operator [](int posicion) {
	if(posicion>=1 && posicion<=dimension)
		return datos[posicion-1];
	//Vaciar el TPoro error para asegurar que antes no se le ha asignado ningún TPoro
	error.~TPoro();
	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x5c96
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jg 0x5c96
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x5caf
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x50e0
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tvectorporo.cpp
// Function: TVectorPoro::operator[](int) const
TPoro TVectorPoro::operator [](int posicion) const {
	if(posicion>=1 && posicion<=dimension)
		return datos[posicion-1];
	//Vaciar el TPoro error para asegurar que antes no se le ha asignado ningún TPoro
	error.~TPoro();
	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x5d19
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jg 0x5d19
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x5020
jmp 0x5d37
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x50e0
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x10, %rsi
callq 0x5020
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tvectorporo.cpp
// Function: TVectorPoro::Cantidad() const
int TVectorPoro::Cantidad() const {
	int posOcupadas = 0;
	for(int i=0; i<dimension; i++){
		if(!datos[i].EsVacio())
			posOcupadas+=1;
	}
	return posOcupadas;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jge 0x5dbf
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x52c0
testb $0x1, %al
jne 0x5db2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5db4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5d82
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jespinosa94[P]PED16/lib/tvectorporo.cpp
// Function: operator<<(std::ostream&, TVectorPoro const&)
ostream & operator <<(ostream &os, const TVectorPoro &tvp){
	os << "[";

	if(tvp.dimension > 0)
	{
		os << 1 << " ";
		os << tvp.operator[](1);
		for(int i=2; i<=tvp.dimension; i++)
		{
			os << " " << i << " " << tvp.operator [](i);
		}
	}

	os << "]";
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x5ffb(%rip), %rsi      # 0xc209
callq 0x10d0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x6320
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl %esi, -0x64(%rbp)
callq 0x1170
movq %rax, %rdi
leaq 0x5fca(%rip), %rsi      # 0xc205
callq 0x10d0
movl -0x64(%rbp), %edx
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5cc0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x5470
jmp 0x626b
leaq -0x28(%rbp), %rdi
callq 0x50e0
movl $0x2, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x631e
movq -0x8(%rbp), %rdi
leaq 0x5f70(%rip), %rsi      # 0xc205
movq %rsi, -0x80(%rbp)
callq 0x10d0
movq %rax, %rdi
movl -0x38(%rbp), %esi
callq 0x1170
movq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x10d0
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rsi
movl -0x38(%rbp), %edx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5cc0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x5470
jmp 0x62dc
leaq -0x50(%rbp), %rdi
callq 0x50e0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x627b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x50e0
jmp 0x633d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x50e0
jmp 0x633d
jmp 0x6320
movq -0x8(%rbp), %rdi
leaq 0x5ee0(%rip), %rsi      # 0xc20b
callq 0x10d0
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaNodo::~TListaNodo()
TListaNodo::~TListaNodo() {
	e.~TPoro();
	if(anterior != NULL)
		anterior = NULL;
	if(siguiente != NULL)
		siguiente = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x50e0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6400
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6417
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x50e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaNodo::operator=(TListaNodo const&)
TListaNodo& TListaNodo::operator =(const TListaNodo &tln) {
	if(this != &tln)
	{
		e = tln.e;
		anterior->e = tln.anterior->e;
		siguiente->e = tln.siguiente->e;
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x6485
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5150
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x18(%rax), %rdi
callq 0x5150
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rsi
movq 0x20(%rax), %rdi
callq 0x5150
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPosicion::TListaPosicion(TListaPosicion const&)
TListaPosicion::TListaPosicion(const TListaPosicion &tlp) {
	if(tlp.pos != NULL)
		pos = tlp.pos;
	else
		pos = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x64de
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0x64e9
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPosicion::Anterior() const
TListaPosicion TListaPosicion::Anterior() const {
	TListaPosicion aux;
	if(pos->anterior != NULL)
		aux.pos = pos->anterior;

	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6490
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x65cc
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x65df
movq -0x30(%rbp), %rdi
callq 0x64f0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPosicion::Siguiente() const
TListaPosicion TListaPosicion::Siguiente() const {
	TListaPosicion aux;
	if(pos->siguiente != NULL)
		aux.pos = pos->siguiente;
	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6490
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x663c
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x664f
movq -0x30(%rbp), %rdi
callq 0x64f0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::Copia(TListaPoro const&)
void TListaPoro::Copia(const TListaPoro &poroLista)
{
	TListaPosicion posLista = poroLista.Primera();
	while(!posLista.EsVacia())
	{
		(*this).Insertar(posLista.pos->e);
		posLista = posLista.Siguiente();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x6780
leaq -0x18(%rbp), %rdi
callq 0x6660
xorb $-0x1, %al
testb $0x1, %al
jne 0x6716
jmp 0x6763
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x67f0
jmp 0x6725
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x65f0
jmp 0x6734
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6520
leaq -0x30(%rbp), %rdi
callq 0x64f0
jmp 0x6705
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x64f0
jmp 0x6772
leaq -0x18(%rbp), %rdi
callq 0x64f0
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1180
nopl (%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::Primera() const
TListaPosicion TListaPoro::Primera() const{
	TListaPosicion aux;
	if(primero != NULL)
		aux.pos = primero;
	else
		aux.pos = NULL;
	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6490
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x67c6
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0x67d1
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x67e4
movq -0x30(%rbp), %rdi
callq 0x64f0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::Insertar(TPoro const&)
bool TListaPoro::Insertar(const TPoro &poro) {
	if(EsVacia())
	{
		InsertaCabeza(poro);
		return true;
	}
	else if(!Buscar(poro))
	{
		if(poro.Volumen() < primero->e.Volumen())
			InsertaCabeza(poro);
		else if(poro.Volumen() >= ultimo->e.Volumen())
			InsertaCola(poro);
		else
			InsertaCentro(poro);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6bb0
testb $0x1, %al
jne 0x6813
jmp 0x6829
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6e60
movb $0x1, -0x1(%rbp)
jmp 0x68c5
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x71d0
testb $0x1, %al
jne 0x68bf
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rdi
callq 0x5430
movsd -0x28(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x6872
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6e60
jmp 0x68b9
movq -0x18(%rbp), %rdi
callq 0x5430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movq 0x8(%rax), %rdi
callq 0x5430
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x68aa
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6f30
jmp 0x68b7
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x70e0
jmp 0x68b9
movb $0x1, -0x1(%rbp)
jmp 0x68c5
jmp 0x68c1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::~TListaPoro()
TListaPoro::~TListaPoro() {
	TListaPosicion p, q;
	q = Primera();
	while(!q.EsVacia())
	{
		p = q;
		q = q.Siguiente();
		delete p.pos;
	}
	primero = NULL;
	ultimo = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6490
jmp 0x68ef
leaq -0x18(%rbp), %rdi
callq 0x6490
jmp 0x68fa
movq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x6780
jmp 0x6909
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6520
leaq -0x20(%rbp), %rdi
callq 0x64f0
leaq -0x18(%rbp), %rdi
callq 0x6660
xorb $-0x1, %al
testb $0x1, %al
jne 0x6930
jmp 0x698d
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movq %rsi, -0x38(%rbp)
callq 0x6520
movq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x65f0
jmp 0x6950
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6520
leaq -0x28(%rbp), %rdi
callq 0x64f0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x698b
movq -0x40(%rbp), %rdi
callq 0x63d0
movq -0x40(%rbp), %rdi
movl $0x28, %esi
callq 0x10f0
jmp 0x691f
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
leaq -0x18(%rbp), %rdi
callq 0x64f0
leaq -0x10(%rbp), %rdi
callq 0x64f0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7be0
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::operator==(TListaPoro const&) const
bool TListaPoro::operator ==(const TListaPoro &poroLista) const{
	TListaPosicion estaLista = Primera();
	TListaPosicion listaP = poroLista.Primera();
	if(EsVacia() && poroLista.EsVacia())
		return true;
	else if(!EsVacia() && !poroLista.EsVacia())
	{
		while(!estaLista.EsVacia())
		{
			if(estaLista.pos->e != listaP.pos->e)
				return false;
			estaLista = estaLista.Siguiente();
			listaP = listaP.Siguiente();
		}
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6780
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x6780
jmp 0x6a30
movq -0x50(%rbp), %rdi
callq 0x6bb0
movb %al, -0x51(%rbp)
jmp 0x6a3e
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x6a47
jmp 0x6a99
movq -0x18(%rbp), %rdi
callq 0x6bb0
movb %al, -0x52(%rbp)
jmp 0x6a55
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0x6a5e
jmp 0x6a99
movb $0x1, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x6b77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6b94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x64f0
jmp 0x6b94
movq -0x50(%rbp), %rdi
callq 0x6bb0
movb %al, -0x53(%rbp)
jmp 0x6aa7
movb -0x53(%rbp), %al
testb $0x1, %al
jne 0x6b6a
jmp 0x6ab4
movq -0x18(%rbp), %rdi
callq 0x6bb0
movb %al, -0x54(%rbp)
jmp 0x6ac2
movb -0x54(%rbp), %al
testb $0x1, %al
jne 0x6b6a
jmp 0x6acf
jmp 0x6ad1
leaq -0x20(%rbp), %rdi
callq 0x6660
xorb $-0x1, %al
testb $0x1, %al
jne 0x6ae2
jmp 0x6b5d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5320
movb %al, -0x55(%rbp)
jmp 0x6af4
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x6afd
jmp 0x6b0a
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x6b77
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x65f0
jmp 0x6b19
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0x60(%rbp)
callq 0x6520
movq -0x60(%rbp), %rdi
callq 0x64f0
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x65f0
jmp 0x6b42
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6520
leaq -0x48(%rbp), %rdi
callq 0x64f0
jmp 0x6ad1
movb $0x1, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x6b77
jmp 0x6b6c
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x64f0
leaq -0x20(%rbp), %rdi
callq 0x64f0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x64f0
movq -0x30(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::operator+(TListaPoro const&)
TListaPoro TListaPoro::operator +(const TListaPoro &poroLista) {
	TListaPoro nuevaLista(*this);
	TListaPosicion posLista = poroLista.Primera();
	while(!posLista.EsVacia())
	{
		nuevaLista.Insertar(posLista.pos->e);
		posLista = posLista.Siguiente();
	}
	return nuevaLista;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0x66a0
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x6780
jmp 0x6c2b
jmp 0x6c2d
leaq -0x28(%rbp), %rdi
callq 0x6660
xorb $-0x1, %al
testb $0x1, %al
jne 0x6c3e
jmp 0x6c99
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x67f0
jmp 0x6c4d
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x65f0
jmp 0x6c5c
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6520
leaq -0x40(%rbp), %rdi
callq 0x64f0
jmp 0x6c2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6cbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x64f0
jmp 0x6cbf
movb $0x1, -0x19(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x64f0
testb $0x1, -0x19(%rbp)
jne 0x6cb5
movq -0x50(%rbp), %rdi
callq 0x68d0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x68d0
movq -0x30(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::operator-(TListaPoro const&)
TListaPoro TListaPoro::operator -(const TListaPoro &poroLista) {
	TListaPoro nuevaLista(*this);
	TListaPosicion posLista = poroLista.Primera();
	while(!posLista.EsVacia())
	{
		nuevaLista.Borrar(posLista.pos->e);
		posLista = posLista.Siguiente();
	}
	return nuevaLista;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0x66a0
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x6780
jmp 0x6d1b
jmp 0x6d1d
leaq -0x28(%rbp), %rdi
callq 0x6660
xorb $-0x1, %al
testb $0x1, %al
jne 0x6d2e
jmp 0x6d89
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6dd0
jmp 0x6d3d
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x65f0
jmp 0x6d4c
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6520
leaq -0x40(%rbp), %rdi
callq 0x64f0
jmp 0x6d1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6daf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x64f0
jmp 0x6daf
movb $0x1, -0x19(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x64f0
testb $0x1, -0x19(%rbp)
jne 0x6da5
movq -0x50(%rbp), %rdi
callq 0x68d0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x68d0
movq -0x30(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::Borrar(TPoro const&)
bool TListaPoro::Borrar(const TPoro &poro) {
	if(Buscar(poro))
	{
		TListaPosicion borraPos = ObtenerPosicion(poro);
		Borrar(borraPos);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x71d0
testb $0x1, %al
jne 0x6df7
jmp 0x6e41
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x7230
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7570
jmp 0x6e1b
movb $0x1, -0x1(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x64f0
jmp 0x6e45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x64f0
jmp 0x6e50
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1180
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::InsertaCabeza(TPoro const&)
void TListaPoro::InsertaCabeza(const TPoro &poro) {
	TListaNodo *aux = new TListaNodo;
	aux->e = poro;
	if(EsVacia())
	{
		aux->siguiente = NULL;
		primero = aux;
		ultimo = aux;
	}
	else
	{
		aux->siguiente = primero;
		primero->anterior = aux;
		primero = aux;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x28, %edi
callq 0x10e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x6350
jmp 0x6e93
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x5150
movq -0x38(%rbp), %rdi
callq 0x6bb0
testb $0x1, %al
jne 0x6eb7
jmp 0x6ef4
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, 0x20(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x6f15
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x28, %esi
callq 0x10f0
jmp 0x6f1b
movq -0x38(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x20(%rcx)
movq -0x18(%rbp), %rdx
movq (%rax), %rcx
movq %rdx, 0x18(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::InsertaCola(TPoro const&)
void TListaPoro::InsertaCola(const TPoro &poro) {
	TListaNodo *aux = new TListaNodo;
	aux->e = poro;
	aux->anterior = ultimo;
	ultimo->siguiente = aux;
	ultimo = aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x28, %edi
callq 0x10e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x6350
jmp 0x6f63
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x5150
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq -0x18(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x20(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x28, %esi
callq 0x10f0
movq -0x20(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::ObtenerAnterior(TPoro const&)
TListaPosicion TListaPoro::ObtenerAnterior(const TPoro &poro) {
	TListaPosicion aux = Primera();
	while(!aux.Siguiente().EsVacia())
	{
		if(aux.pos->siguiente->e.Volumen() >= poro.Volumen())
			return aux;
		else
			aux = aux.Siguiente();
	}
	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0x6780
movq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x65f0
jmp 0x700b
leaq -0x28(%rbp), %rdi
callq 0x6660
xorb $-0x1, %al
movb %al, -0x51(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x64f0
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x702e
jmp 0x70b3
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
callq 0x5430
movsd %xmm0, -0x60(%rbp)
jmp 0x7045
movq -0x18(%rbp), %rdi
callq 0x5430
movsd %xmm0, -0x68(%rbp)
jmp 0x7055
movsd -0x60(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x7089
movb $0x1, -0x19(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x70be
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x64f0
jmp 0x70d7
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x65f0
jmp 0x7098
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6520
leaq -0x40(%rbp), %rdi
callq 0x64f0
jmp 0x6ffc
movb $0x1, -0x19(%rbp)
movl $0x1, -0x38(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x70cd
movq -0x50(%rbp), %rdi
callq 0x64f0
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1180
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::InsertaCentro(TPoro const&)
void TListaPoro::InsertaCentro(const TPoro &poro) {
	TListaPosicion poroAnterior = ObtenerAnterior(poro);
	TListaNodo *newPoro = new TListaNodo;
	newPoro->e = poro;
	newPoro->siguiente = poroAnterior.pos->siguiente;
	poroAnterior.Siguiente().pos->anterior = newPoro;
	poroAnterior.pos->siguiente = newPoro;
	newPoro->anterior = poroAnterior.pos;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0x6fd0
movl $0x28, %edi
callq 0x10e0
movq %rax, -0x40(%rbp)
jmp 0x7111
movq -0x40(%rbp), %rdi
callq 0x6350
jmp 0x711c
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x5150
jmp 0x7133
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x65f0
jmp 0x715a
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq -0x38(%rbp), %rdi
callq 0x64f0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq -0x18(%rbp), %rdi
callq 0x64f0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x71be
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0x10f0
leaq -0x18(%rbp), %rdi
callq 0x64f0
movq -0x28(%rbp), %rdi
callq 0x1180
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::Buscar(TPoro const&) const
bool TListaPoro::Buscar(const TPoro &poro) const {
	TListaNodo *aux = primero;
	while(aux)
	{
		if(aux->e == poro)
			return true;
		else
			aux = aux->siguiente;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7219
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5190
testb $0x1, %al
jne 0x7205
jmp 0x720b
movb $0x1, -0x1(%rbp)
jmp 0x721d
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x71eb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::ObtenerPosicion(TPoro const&)
TListaPosicion TListaPoro::ObtenerPosicion(const TPoro &poro)
{
	TListaPosicion aux = Primera();
	while(!aux.Siguiente().EsVacia())
	{
		if(aux.pos->e == poro)
			return aux;
		else
			aux = aux.Siguiente();
	}
	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0x6780
movq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x65f0
jmp 0x726b
leaq -0x28(%rbp), %rdi
callq 0x6660
xorb $-0x1, %al
movb %al, -0x51(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x64f0
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x728b
jmp 0x72f7
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5190
movb %al, -0x52(%rbp)
jmp 0x72a0
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0x72a9
jmp 0x72cd
movb $0x1, -0x19(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x7302
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x64f0
jmp 0x731b
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x65f0
jmp 0x72dc
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6520
leaq -0x40(%rbp), %rdi
callq 0x64f0
jmp 0x725c
movb $0x1, -0x19(%rbp)
movl $0x1, -0x38(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7311
movq -0x50(%rbp), %rdi
callq 0x64f0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::BorrarCabeza(TListaPosicion const&)
void TListaPoro::BorrarCabeza(const TListaPosicion &aux) {
	if(Longitud() == 1)
	{
		(*this).~TListaPoro();
	}
	else
	{
		primero = primero->siguiente;
		aux.pos->~TListaNodo();
		delete aux.pos;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x73b0
cmpl $0x1, %eax
jne 0x735d
movq -0x18(%rbp), %rdi
callq 0x68d0
jmp 0x73a1
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x63d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x739f
movq -0x20(%rbp), %rdi
callq 0x63d0
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0x10f0
jmp 0x73a1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::Longitud() const
int TListaPoro::Longitud() const{
	int cont = 0;
	TListaPosicion aux = Primera();
	while(!aux.EsVacia())
	{
		cont++;
		aux = aux.Siguiente();
	}

	return cont;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x0, -0xc(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6780
leaq -0x18(%rbp), %rdi
callq 0x6660
xorb $-0x1, %al
testb $0x1, %al
jne 0x73e1
jmp 0x7427
movl -0xc(%rbp), %eax
incl %eax
movl %eax, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x65f0
jmp 0x73f8
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6520
leaq -0x20(%rbp), %rdi
callq 0x64f0
jmp 0x73d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x64f0
jmp 0x743f
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x64f0
movl -0x30(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1180
nopl (%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::BorrarCentro(TListaPosicion const&)
void TListaPoro::BorrarCentro(const TListaPosicion &borraPos) {
	//La declaración de abajo es simplemente para simplificar que si a b c (queremos borrar b
	//a sería anterior y c siguiente)
	TListaNodo *anterior = borraPos.Anterior().pos;
	TListaNodo *siguiente = borraPos.Siguiente().pos;
	anterior->siguiente = siguiente;
	siguiente->anterior = anterior;
	borraPos.pos->~TListaNodo();
	delete borraPos.pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x6580
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x64f0
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x65f0
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x64f0
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x63d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x74f8
movq -0x38(%rbp), %rdi
callq 0x63d0
movq -0x38(%rbp), %rdi
movl $0x28, %esi
callq 0x10f0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::BorrarCola(TListaPosicion const&)
void TListaPoro::BorrarCola(const TListaPosicion &aux) {
	ultimo = ultimo->anterior;
	ultimo->siguiente = NULL;
	aux.pos->~TListaNodo();
	delete aux.pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x63d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x7560
movq -0x18(%rbp), %rdi
callq 0x63d0
movq -0x18(%rbp), %rdi
movl $0x28, %esi
callq 0x10f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::Borrar(TListaPosicion const&)
bool TListaPoro::Borrar(const TListaPosicion &borraPos) {
	if(Buscar(borraPos.pos->e))
	{
		if(borraPos.pos == primero)
			BorrarCabeza(borraPos);
		else if(borraPos.pos == ultimo)
			BorrarCola(borraPos);
		else
			BorrarCentro(borraPos);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x71d0
testb $0x1, %al
jne 0x759a
jmp 0x75ee
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq (%rcx), %rax
jne 0x75b9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7330
jmp 0x75e8
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq 0x8(%rcx), %rax
jne 0x75d9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7500
jmp 0x75e6
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7450
jmp 0x75e8
movb $0x1, -0x1(%rbp)
jmp 0x75f2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::Ultima() const
TListaPosicion TListaPoro::Ultima() const{
	TListaPosicion aux;
	if(ultimo != NULL)
		aux.pos = ultimo;
	else
		aux.pos = NULL;
	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6490
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7688
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
jmp 0x7693
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x76a6
movq -0x30(%rbp), %rdi
callq 0x64f0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::ObtenerPoro(int)
TPoro TListaPoro::ObtenerPoro(int n)
{
	TListaPosicion elemento = Primera();
	for(int i=1; i<n; i++)
	{
		elemento = elemento.Siguiente();
	}
	return elemento.pos->e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x6780
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7731
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x65f0
jmp 0x76f9
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6520
leaq -0x30(%rbp), %rdi
callq 0x64f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x76e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x64f0
jmp 0x7753
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5020
jmp 0x7740
leaq -0x20(%rbp), %rdi
callq 0x64f0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1180
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: operator<<(std::ostream&, TListaPoro const&)
ostream & operator<<(ostream &os, const TListaPoro &lista) {
	TListaPosicion aux;
	aux = lista.Primera();

	os << "(";
	if(!lista.EsVacia())
	{
		os << lista.Obtener(aux);
		aux = aux.Siguiente();
		while(!aux.EsVacia())
		{
			os << " ";
			os << lista.Obtener(aux);
			aux = aux.Siguiente();
		}
	}
	os << ")";
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6490
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x6780
jmp 0x7a3b
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x78(%rbp)
callq 0x6520
movq -0x78(%rbp), %rdi
callq 0x64f0
movq -0x8(%rbp), %rdi
leaq 0x479f(%rip), %rsi      # 0xc1ff
callq 0x10d0
jmp 0x7a67
movq -0x10(%rbp), %rdi
callq 0x6bb0
testb $0x1, %al
jne 0x7b97
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x7600
jmp 0x7a93
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x5470
jmp 0x7aa2
leaq -0x48(%rbp), %rdi
callq 0x50e0
leaq -0x50(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x65f0
jmp 0x7aba
leaq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6520
leaq -0x50(%rbp), %rdi
callq 0x64f0
leaq -0x18(%rbp), %rdi
callq 0x6660
xorb $-0x1, %al
testb $0x1, %al
jne 0x7ae4
jmp 0x7b95
movq -0x8(%rbp), %rdi
leaq 0x4716(%rip), %rsi      # 0xc205
callq 0x10d0
jmp 0x7af6
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x7600
jmp 0x7b14
movq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5470
jmp 0x7b26
leaq -0x68(%rbp), %rdi
callq 0x50e0
leaq -0x70(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x65f0
jmp 0x7b3e
leaq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6520
leaq -0x70(%rbp), %rdi
callq 0x64f0
jmp 0x7ad0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x7bcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x50e0
jmp 0x7bcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x50e0
jmp 0x7bcd
jmp 0x7b97
movq -0x8(%rbp), %rdi
leaq 0x4699(%rip), %rsi      # 0xc23b
callq 0x10d0
jmp 0x7ba9
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x64f0
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x64f0
movq -0x28(%rbp), %rdi
callq 0x1180
nop
// File: jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TNodoABB::Copia(TNodoABB const&)
void TNodoABB::Copia(const TNodoABB &origen){
	(this)->item = origen.item;
	if(!origen.de.EsVacio())
		(this)->de = origen.de;
	if(!origen.iz.EsVacio())
		(this)->iz = origen.iz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5150
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x7d67
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x7e00
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x7de0
testb $0x1, %al
jne 0x7d8d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x7e00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::operator=(TABBPoro const&)
TABBPoro& TABBPoro::operator =(const TABBPoro &origen) {
	if(this != &origen)
	{
		(*this).~TABBPoro();
		Copiar(origen);
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x7e34
movq -0x18(%rbp), %rdi
callq 0x8330
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8260
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TNodoABB::operator=(TNodoABB const&)
TNodoABB& TNodoABB::operator =(const TNodoABB &origen) {
	if(this != &origen)
	{
		(this)->~TNodoABB();
		Copia(origen);
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x7e74
movq -0x18(%rbp), %rdi
callq 0x7da0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7d20
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::InordenAux(TVectorPoro&, int&) const
void TABBPoro::InordenAux(TVectorPoro &vector, int &posicion) const{
	if(!EsVacio())
	{
		nodo->iz.InordenAux(vector, posicion);
		vector[posicion] = nodo->item;
		posicion++;
		nodo->de.InordenAux(vector, posicion);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7de0
testb $0x1, %al
jne 0x7f06
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7e80
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x5c50
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x5150
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edx
addl $0x1, %edx
movl %edx, (%rcx)
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7e80
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)