LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x498b
callq 0x43b2
movq $0x0, 0x8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x43b2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x4a81
movq %rsi, %r14
movl (%rsi), %eax
cmpl %eax, (%rbx)
je 0x4a54
movl %eax, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x49d8
callq 0x43b2
movslq (%rbx), %r13
movl $0x18, %ecx
movq %r13, %rax
mulq %rcx
movq %rax, %rdi
seto %al
addq $0x8, %rdi
movq $-0x1, %rcx
cmovbq %rcx, %rdi
testb %al, %al
cmovneq %rcx, %rdi
movq %rdi, -0x40(%rbp)
callq 0x1030
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq %r13, (%rax)
testq %r13, %r13
je 0x4a4c
shlq $0x3, %r13
leaq (,%r13,2), %r15
addq %r13, %r15
negq %r15
xorl %r12d, %r12d
movq -0x38(%rbp), %r13
movq %r13, %rdi
callq 0x4210
addq $-0x18, %r12
addq $0x18, %r13
cmpq %r12, %r15
jne 0x4a37
movq -0x38(%rbp), %rax
movq %rax, 0x8(%rbx)
cmpl $0x0, (%rbx)
jle 0x4a81
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rsi
addq %r15, %rsi
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0x43e4
incq %r12
movslq (%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x4a5f
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r12, %r12
je 0x4ab5
negq %r12
movq -0x30(%rbp), %r14
addq $-0x10, %r14
leaq (%r14,%r12), %rdi
callq 0x43b2
addq $-0x18, %r12
jne 0x4aa6
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x11c0
movq %rbx, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x4b32
movq %rdi, %r14
cmpl $0x0, (%rdi)
setle %r15b
jle 0x4b35
movq %rsi, %rbx
movq 0x8(%r14), %rdi
movq 0x8(%rsi), %rsi
callq 0x457e
testb %al, %al
jne 0x4b35
movl $0x18, %esi
xorl %r12d, %r12d
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
setge %r15b
jge 0x4b35
leaq 0x18(%rsi), %r13
movq 0x8(%r14), %rdi
addq %rsi, %rdi
addq 0x8(%rbx), %rsi
callq 0x457e
movq %r13, %rsi
testb %al, %al
je 0x4b06
jmp 0x4b35
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x4b7b
cmpl %esi, (%rbx)
jl 0x4b7b
movq 0x8(%rbx), %rax
movl %esi, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rbx
addq $-0x18, %rbx
jmp 0x4b87
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x43b2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
jle 0x4bbc
cmpl %edx, (%r14)
jl 0x4bbc
movq 0x8(%r14), %rax
movl %edx, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %r14
addq $-0x18, %r14
jmp 0x4bc8
addq $0x10, %r14
movq %r14, %rdi
callq 0x43b2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x434e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x0, (%rdi)
jle 0x4c25
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0x4552
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %r14d
incq %r12
movslq (%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x4c00
jmp 0x4c28
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tvectorporo.cpp
// Function: TVectorPoro::Redimensionar(int)
bool TVectorPoro::Redimensionar(const int newSize) {
	if(newSize<=0 || dimension==newSize)
		return false;
	else if(dimension<newSize)
	{
		TVectorPoro aux;
		aux.dimension = newSize;
		aux.datos = new TPoro[aux.dimension];
		for(int i=0; i<dimension; i++)
			aux.datos[i] = datos[i];
		(*this).~TVectorPoro();
		(*this) = aux;
	}
	/*
	 *la nueva longitud es menor que la actual y se eliminan los elementos de la derecha
	 */
	else
	{
		TVectorPoro aux;
		aux.dimension = newSize;
		aux.datos = new TPoro[aux.dimension];
		for(int i=0; i<newSize; i++)
			aux.datos[i] = datos[i];
		(*this).~TVectorPoro();
		(*this) = aux;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testl %esi, %esi
jle 0x4c53
movl %esi, %r15d
movq %rdi, %rbx
cmpl %esi, (%rdi)
jne 0x4c5a
xorl %eax, %eax
jmp 0x4db5
movl %r15d, %r13d
leaq (%r13,%r13,2), %rax
leaq 0x8(,%rax,8), %r14
movq %r14, -0x40(%rbp)
leaq -0x58(%rbp), %r12
movq %r12, %rdi
jge 0x4d18
callq 0x4210
movq $0x0, -0x8(%r12)
movl %r15d, -0x10(%r12)
movq %r14, %rdi
callq 0x1030
movq %r13, (%rax)
movq %rax, -0x30(%rbp)
leaq 0x8(%rax), %r14
shlq $0x3, %r13
leaq (,%r13,2), %r15
addq %r13, %r15
negq %r15
xorl %r13d, %r13d
movq %r14, %r12
movq %r12, %rdi
callq 0x4210
addq $-0x18, %r13
addq $0x18, %r12
cmpq %r13, %r15
jne 0x4cb9
movq %r14, -0x60(%rbp)
cmpl $0x0, (%rbx)
jle 0x4cff
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rsi
addq %r14, %rsi
movq -0x60(%rbp), %rdi
addq %r14, %rdi
callq 0x43e4
incq %r15
movslq (%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0x4cdd
movq %rbx, %rdi
callq 0x4966
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x499e
jmp 0x4daa
callq 0x4210
movq $0x0, -0x8(%r12)
movl %r15d, -0x10(%r12)
movq %r14, %rdi
callq 0x1030
movq %r13, (%rax)
movq %rax, -0x38(%rbp)
leaq 0x8(%rax), %r12
shlq $0x3, %r13
leaq (,%r13,2), %r15
addq %r13, %r15
movq %r15, %r13
negq %r13
xorl %r14d, %r14d
movq %r12, -0x30(%rbp)
movq %r12, %rdi
callq 0x4210
addq $-0x18, %r14
addq $0x18, %r12
cmpq %r14, %r13
jne 0x4d5a
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
xorl %r14d, %r14d
movq 0x8(%rbx), %rsi
addq %r14, %rsi
movq -0x60(%rbp), %rdi
addq %r14, %rdi
callq 0x43e4
addq $0x18, %r14
cmpq %r14, %r15
jne 0x4d7a
movq %rbx, %rdi
callq 0x4966
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x499e
leaq -0x68(%rbp), %rdi
callq 0x4966
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4dca
jmp 0x4dca
jmp 0x4dca
movq %rax, %rbx
jmp 0x4e26
movq %rax, %rbx
testq %r14, %r14
je 0x4df1
negq %r14
movq -0x38(%rbp), %r15
addq $-0x10, %r15
leaq (%r15,%r14), %rdi
callq 0x43b2
addq $-0x18, %r14
jne 0x4de2
movq -0x38(%rbp), %rdi
jmp 0x4e1d
movq %rax, %rbx
testq %r13, %r13
je 0x4e19
negq %r13
movq -0x30(%rbp), %r14
addq $-0x10, %r14
leaq (%r14,%r13), %rdi
callq 0x43b2
addq $-0x18, %r13
jne 0x4e0a
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x11c0
leaq -0x68(%rbp), %rdi
callq 0x4966
movq %rbx, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
leaq 0x33b7(%rip), %rsi      # 0x8209
movl $0x1, %edx
movq %rdi, -0x30(%rbp)
callq 0x1110
cmpl $0x0, (%r14)
jle 0x4f2f
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x11a0
leaq 0x3383(%rip), %rsi      # 0x8205
movl $0x1, %edx
movq %rax, %rdi
callq 0x1110
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x4b92
movq %rbx, %rdi
movq %r15, %rsi
callq 0x462a
leaq -0x48(%rbp), %rdi
callq 0x43b2
cmpl $0x2, (%r14)
jl 0x4f2f
movl $0x1, %r15d
leaq -0x48(%rbp), %r13
incl %r15d
movl $0x1, %edx
movq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r14, %rbx
leaq 0x3325(%rip), %r14      # 0x8205
movq %r14, %rsi
callq 0x1110
movq %r12, %rdi
movl %r15d, %esi
callq 0x11a0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %r14
callq 0x1110
movq %r13, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x4b92
movq %r12, %rdi
movq %r13, %rsi
callq 0x462a
movq %r13, %rdi
callq 0x43b2
cmpl (%r14), %r15d
jl 0x4ec7
leaq 0x32d5(%rip), %rsi      # 0x820b
movl $0x1, %edx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x1110
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f5b
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x43b2
movq %rbx, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x43b2
cmpq $0x0, 0x18(%rbx)
je 0x4fc5
movq $0x0, 0x18(%rbx)
cmpq $0x0, 0x20(%rbx)
je 0x4fd4
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x43b2
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x5016
movq %rsi, %r14
movq %rbx, %rdi
callq 0x43e4
movq 0x18(%r14), %rsi
movq 0x18(%rbx), %rdi
callq 0x43e4
movq 0x20(%r14), %rsi
movq 0x20(%rbx), %rdi
callq 0x43e4
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x5116
movq %rdi, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5132
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x5102
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rax
orq %r15, %rax
jne 0x5162
movq %r14, %rdi
movq %rbx, %rsi
callq 0x541c
movb $0x1, %al
jmp 0x5187
testq %r15, %r15
setne %r12b
je 0x5180
movq %r15, %rdi
movq %rbx, %rsi
callq 0x442a
testb %al, %al
jne 0x5180
movq 0x20(%r15), %r15
jmp 0x5162
testb %r12b, %r12b
je 0x5194
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x4614
movsd %xmm0, -0x28(%rbp)
movq (%r14), %rdi
callq 0x4614
ucomisd -0x28(%rbp), %xmm0
ja 0x5153
movq %rbx, %rdi
callq 0x4614
movsd %xmm0, -0x28(%rbp)
movq 0x8(%r14), %rdi
callq 0x4614
movsd -0x28(%rbp), %xmm1
movq %r14, %rdi
movq %rbx, %rsi
ucomisd %xmm0, %xmm1
jae 0x51de
callq 0x557c
jmp 0x515e
callq 0x54a2
jmp 0x515e
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x521e
movq 0x20(%r14), %r15
movq %r14, %rdi
callq 0x4fa8
movl $0x28, %esi
movq %r14, %rdi
callq 0x1100
movq %r15, %r14
testq %r15, %r15
jne 0x51fd
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movq (%rsi), %r14
movq 0x8(%rdi), %rax
orq %rbx, %rax
sete %cl
movq 0x8(%rsi), %rdx
orq %r14, %rdx
sete %sil
orb %cl, %sil
orq %rax, %rdx
sete %al
testb %sil, %sil
jne 0x52c1
testq %rbx, %rbx
je 0x52bf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x457e
testb %al, %al
jne 0x52bb
movq 0x20(%rbx), %rbx
movq 0x20(%r14), %r14
testq %rbx, %rbx
jne 0x529f
xorb $0x1, %al
jmp 0x52c1
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %r15
testq %r15, %r15
je 0x5305
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5132
movq 0x20(%r15), %r15
jmp 0x52ef
movq (%r14), %r14
testq %r14, %r14
je 0x531e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5132
movq 0x20(%r14), %r14
jmp 0x5308
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x51e8
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %r15
testq %r15, %r15
je 0x536f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5132
movq 0x20(%r15), %r15
jmp 0x5359
movq (%r14), %r14
testq %r14, %r14
je 0x5388
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53aa
movq 0x20(%r14), %r14
jmp 0x5372
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x51e8
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r12
testq %r12, %r12
setne %r14b
je 0x53e1
movq %r12, %rdi
movq %r15, %rsi
callq 0x442a
testb %al, %al
jne 0x53e1
movq 0x20(%r12), %r12
jmp 0x53c2
testb %r14b, %r14b
je 0x5403
leaq -0x28(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5654
movq %rbx, %rdi
movq %r12, %rsi
callq 0x57d8
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x28, %edi
callq 0x10f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x4210
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43e4
movq (%r14), %rax
movq 0x8(%r14), %rcx
orq %rax, %rcx
jne 0x5470
movq %r14, %rax
addq $0x8, %r14
movq $0x0, 0x20(%rbx)
jmp 0x5478
movq %rax, 0x20(%rbx)
addq $0x18, %rax
movq %rbx, (%rax)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x1100
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x28, %edi
callq 0x10f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x4210
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43e4
movq 0x8(%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, 0x20(%rax)
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x1100
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rdi)
movq (%rsi), %r15
movq %r15, (%rdi)
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x555c
movq %rdx, %r14
callq 0x4614
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
callq 0x4614
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jae 0x555c
movq 0x20(%r15), %r15
movq 0x20(%r15), %rdi
testq %rdi, %rdi
jne 0x5532
movq %r15, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, (%rbx)
movq %rax, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rsi
leaq -0x18(%rbp), %rdi
movq %r14, %rdx
callq 0x550c
movl $0x28, %edi
callq 0x10f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x4210
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43e4
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rbx)
movq 0x20(%rax), %rcx
movq %rbx, 0x18(%rcx)
movq %rbx, 0x20(%rax)
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x55e9
movq $0x0, -0x18(%rbp)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x1100
jmp 0x5607
movq %rax, %r14
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
setne %r15b
je 0x5645
movq %rsi, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x442a
testb %al, %al
jne 0x5645
movq 0x20(%r14), %r14
testq %r14, %r14
setne %r15b
jne 0x5629
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rdi)
movq (%rsi), %r14
movq %r14, (%rdi)
cmpq $0x0, 0x20(%r14)
je 0x5692
movq %rdx, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x442a
testb %al, %al
jne 0x5692
movq 0x20(%r14), %r14
cmpq $0x0, 0x20(%r14)
jne 0x5678
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, (%rbx)
movq %rax, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x56da
movl $0x1, %ecx
movq %rax, %rdx
movq 0x20(%rdx), %rdx
decl %ecx
testq %rdx, %rdx
jne 0x56cb
testl %ecx, %ecx
je 0x5713
movq 0x20(%rax), %rax
movq %rax, (%rdi)
movq (%rbx), %rdi
callq 0x4fa8
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x570c
movq %rbx, %rdi
callq 0x4fa8
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1100
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x51e8
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x5739
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
incl %eax
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
jne 0x572c
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rdi
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movq %rcx, 0x20(%rax)
movq %rax, 0x18(%rcx)
callq 0x4fa8
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x5780
movq %rbx, %rdi
callq 0x4fa8
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1100
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rdi)
movq $0x0, 0x20(%rax)
movq (%rsi), %rdi
callq 0x4fa8
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x57d0
movq %rbx, %rdi
callq 0x4fa8
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1100
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %r12
testq %r12, %r12
setne %bl
je 0x5816
movq (%r14), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x442a
testb %al, %al
jne 0x5816
movq 0x20(%r12), %r12
testq %r12, %r12
setne %bl
jne 0x57fa
testb %bl, %bl
je 0x584a
movq (%r14), %rax
cmpq (%r15), %rax
je 0x5832
cmpq 0x8(%r15), %rax
je 0x583f
movq %r14, %rsi
callq 0x573c
jmp 0x584a
movq %r15, %rdi
movq %r14, %rsi
callq 0x56b2
jmp 0x584a
movq %r15, %rdi
movq %r14, %rsi
callq 0x5788
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tlistaporo.cpp
// Function: TListaPoro::ExtraerRango(int, int)
TListaPoro TListaPoro::ExtraerRango(int n1, int n2) {
	TListaPoro nuevaLista;
	TPoro aux;

	if(n1>n2)
		return nuevaLista;
	else if(n1==n2)
	{
		aux = ObtenerPoro(n1);
		nuevaLista.Insertar(aux);
	}
	else
	{
		if(n1<=0)
			n1 = 1;
		if(n2>Longitud())
			n2 = Longitud();
		for(int i=n1; i<=n2; i++)
		{
			aux = ObtenerPoro(i);
			nuevaLista.Insertar(aux);
		}
	}
	/*
	 * No me deja utilizar el operador - dentro de un módulo de la clase
	 */
	TListaPosicion posLista = nuevaLista.Primera();
	while(!posLista.EsVacia())
	{
		(*this).Borrar(posLista.pos->e);
		posLista = posLista.Siguiente();
	}

	return nuevaLista;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r14
xorps %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
leaq -0x60(%rbp), %rdi
callq 0x4210
cmpl %r15d, %r12d
jle 0x590c
leaq -0x60(%rbp), %rdi
callq 0x43b2
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jne 0x5954
movq (%r14), %rsi
cmpl $0x2, %r12d
jl 0x5923
decl %r12d
movq 0x20(%rsi), %rsi
decl %r12d
jne 0x591a
leaq -0x48(%rbp), %rdi
callq 0x434e
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x43e4
leaq -0x48(%rbp), %rdi
callq 0x43b2
leaq -0x60(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x5132
jmp 0x59fb
cmpl $0x2, %r12d
movl $0x1, %r13d
cmovgel %r12d, %r13d
movq (%r14), %rax
xorl %ebx, %ebx
movl $0x0, %ecx
testq %rax, %rax
je 0x5981
xorl %ecx, %ecx
movq %rax, %rdx
incl %ecx
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
jne 0x5976
testq %rax, %rax
sete %dl
cmpl %r15d, %ecx
setge %cl
cmovgel %r15d, %ebx
orb %dl, %cl
jne 0x59a2
xorl %ebx, %ebx
incl %ebx
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x5997
cmpl %ebx, %r13d
jg 0x59fb
leaq -0x48(%rbp), %r15
leaq -0x60(%rbp), %r12
movq (%r14), %rsi
cmpl $0x2, %r13d
jb 0x59c8
movl $0x1, %eax
incl %eax
movq 0x20(%rsi), %rsi
cmpl %eax, %r13d
jne 0x59bd
movq %r15, %rdi
callq 0x434e
movq %r12, %rdi
movq %r15, %rsi
callq 0x43e4
movq %r15, %rdi
callq 0x43b2
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x5132
leal 0x1(%r13), %eax
cmpl %ebx, %r13d
movl %eax, %r13d
jne 0x59af
movq -0x30(%rbp), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x58f0
movq %r14, %rdi
movq %r15, %rsi
callq 0x53aa
movq 0x20(%r15), %r15
jmp 0x5a02
jmp 0x5a39
jmp 0x5a29
jmp 0x5a39
movq %rax, %r14
jmp 0x5a45
jmp 0x5a39
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x43b2
jmp 0x5a3c
jmp 0x5a39
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x43b2
movq -0x30(%rbp), %rdi
callq 0x51e8
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r14
leaq 0x278a(%rip), %rsi      # 0x81ff
movl $0x1, %edx
callq 0x1110
movq 0x8(%r15), %rax
orq (%r15), %rax
je 0x5af4
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x434e
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x462a
leaq -0x38(%rbp), %rdi
callq 0x43b2
movq 0x20(%r14), %r14
testq %r14, %r14
je 0x5af4
leaq 0x274c(%rip), %r15      # 0x8205
leaq -0x38(%rbp), %r12
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1110
movq %r12, %rdi
movq %r14, %rsi
callq 0x434e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x462a
movq %r12, %rdi
callq 0x43b2
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x5abd
leaq 0x2740(%rip), %rsi      # 0x823b
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1110
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b21
jmp 0x5b1c
movq %rax, %rbx
jmp 0x5b2d
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x43b2
movq %rbx, %rdi
callq 0x11b0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x43e4
cmpq $0x0, 0x38(%rbx)
je 0x5c6e
leaq 0x38(%rbx), %rsi
leaq 0x38(%r14), %rdi
callq 0x5ce8
cmpq $0x0, 0x18(%rbx)
je 0x5c8c
addq $0x18, %rbx
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5ce8
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x5d1b
movq %rsi, %r14
cmpq $0x0, (%rbx)
je 0x5d07
movq $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
callq 0x43b2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x604a
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x5d49
movq %rsi, %r14
movq %rbx, %rdi
callq 0x5c92
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5c48
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x5da0
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5d52
movq (%r15), %r12
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4b56
movq %rax, %rdi
movq %r12, %rsi
callq 0x43e4
incl (%rbx)
movq (%r15), %r15
addq $0x38, %r15
jmp 0x5d66
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::PreordenAux(TVectorPoro&, int&) const
void TABBPoro::PreordenAux(TVectorPoro &vector, int &posicion) const {
	if(!EsVacio())
	{
		vector[posicion] = nodo->item;
		posicion++;
		nodo->iz.PreordenAux(vector, posicion);
		nodo->de.PreordenAux(vector, posicion);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%r15), %r12
testq %r12, %r12
je 0x5df8
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4b56
movq %rax, %rdi
movq %r12, %rsi
callq 0x43e4
incl (%rbx)
movq (%r15), %rdi
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5daa
movq (%r15), %r15
addq $0x38, %r15
jmp 0x5dbe
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::PostordenAux(TVectorPoro&, int&) const
void TABBPoro::PostordenAux(TVectorPoro &vector, int &posicion) const {
	if(!EsVacio())
	{
		nodo->iz.PostordenAux(vector, posicion);
		nodo->de.PostordenAux(vector, posicion);
		vector[posicion] = nodo->item;
		posicion++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5e52
movq %rdx, %rbx
movq %rsi, %r14
addq $0x18, %rdi
callq 0x5e02
movq (%r15), %rdi
addq $0x38, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5e02
movq (%r15), %r15
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4b56
movq %rax, %rdi
movq %r15, %rsi
callq 0x43e4
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::NivelesAux(TVectorPoro&, int&) const
void TABBPoro::NivelesAux(TVectorPoro &vector, int &posicion) const {
	TNodoABB *aux;
	queue<TNodoABB *> cola;
	cola.push((*this).nodo);
	while(!cola.empty())
	{
		aux = cola.front();
		vector[posicion] = cola.front()->item;
		posicion++;
		cola.pop();
		if(!aux->iz.EsVacio())
			cola.push(aux->iz.nodo);
		if(!aux->de.EsVacio())
			cola.push(aux->de.nodo);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %r12
movaps %xmm0, 0x40(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq %r12, %rdi
xorl %esi, %esi
callq 0x6a42
movq 0x30(%r12), %rax
movq 0x40(%r12), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5ec4
movq (%r15), %rcx
movq %rcx, (%rax)
addq $0x8, -0x40(%rbp)
jmp 0x5ed0
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
callq 0x6bca
movq -0x60(%rbp), %rax
cmpq %rax, -0x40(%rbp)
je 0x5fb8
leaq -0x70(%rbp), %r15
movq (%rax), %r12
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4b56
movq %rax, %rdi
movq %r12, %rsi
callq 0x43e4
incl (%rbx)
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5f13
addq $0x8, %rax
jmp 0x5f40
movq -0x58(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x1100
movq -0x48(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
leaq 0x200(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x60(%rbp)
movq 0x18(%r12), %rax
testq %rax, %rax
je 0x5f76
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x5f69
movq %rax, (%rcx)
addq $0x8, -0x40(%rbp)
jmp 0x5f76
leaq 0x18(%r12), %rsi
movq %r15, %rdi
callq 0x6bca
movq 0x38(%r12), %rax
testq %rax, %rax
je 0x5faa
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x5f9b
movq %rax, (%rcx)
addq $0x8, -0x40(%rbp)
jmp 0x5faa
addq $0x38, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6bca
movq -0x60(%rbp), %rax
cmpq %rax, -0x40(%rbp)
jne 0x5ee2
leaq -0x70(%rbp), %rdi
callq 0x69e8
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5fd0
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x69e8
movq %rbx, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Copiar(TABBPoro const&)
void TABBPoro::Copiar(const TABBPoro &origen){
	if(origen.nodo != NULL)
	{
		TNodoABB *aux = new TNodoABB();
		aux->item = origen.nodo->item;
		nodo = aux;
		nodo->iz.Copiar(origen.nodo->iz);
		nodo->de.Copiar(origen.nodo->de);
	}
	else
		nodo = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%r14)
je 0x60a6
movl $0x58, %edi
callq 0x10f0
movq %rax, %r15
movq %rax, %rdi
callq 0x5b38
movq (%r14), %rsi
movq %r15, %rdi
callq 0x43e4
movq %r15, (%rbx)
addq $0x18, %r15
movq (%r14), %rsi
addq $0x18, %rsi
movq %r15, %rdi
callq 0x604a
movq (%rbx), %rbx
addq $0x38, %rbx
movq (%r14), %r14
addq $0x38, %r14
jmp 0x605a
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r15, %rdi
callq 0x1100
movq %rbx, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::CompruebaNodos(TABBPoro const&) const
bool TABBPoro::CompruebaNodos(const TABBPoro &otroArbol) const {
	if(EsVacio())
		return true;
	else
	{
		return (otroArbol.Buscar(nodo->item) && nodo->iz.CompruebaNodos(otroArbol) && nodo->de.CompruebaNodos(otroArbol));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %rsi
testq %rsi, %rsi
je 0x6133
cmpq $0x0, (%rbx)
je 0x612f
movq %rbx, %rdi
callq 0x651c
testb %al, %al
je 0x612f
movq (%r14), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
callq 0x60ec
testb %al, %al
je 0x612f
movq (%r14), %r14
addq $0x38, %r14
jmp 0x60f9
xorl %eax, %eax
jmp 0x6135
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Buscar(TPoro const&) const
bool TABBPoro::Buscar(const TPoro &poro) const {
	if(EsVacio())
		return false;
	else
		return BuscarAux(poro);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, (%rdi)
je 0x614a
popq %rbp
jmp 0x651c
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::operator==(TABBPoro const&) const
bool TABBPoro::operator ==(const TABBPoro &otroArbol) const {
	if(Nodos() == otroArbol.Nodos())
		return CompruebaNodos(otroArbol);
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x660c
movl %eax, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x660c
cmpl %eax, %r15d
jne 0x618c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x60ec
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::FiltraVolumen(int const&)
bool TABBPoro::FiltraVolumen(const int &volumen) {
	if(nodo->item.Volumen() == volumen)
		return false;
	else if(volumen < nodo->item.Volumen() && !nodo->iz.EsVacio())
		nodo->iz.FiltraVolumen(volumen);
	else if(volumen > nodo->item.Volumen() && !nodo->de.EsVacio())
		nodo->de.FiltraVolumen(volumen);
	else
		return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x4614
cvtsi2sdl (%rbx), %xmm1
ucomisd %xmm1, %xmm0
jne 0x61e7
jnp 0x623d
movsd %xmm0, -0x28(%rbp)
movq (%r14), %rdi
movsd %xmm1, -0x18(%rbp)
callq 0x4614
ucomisd -0x18(%rbp), %xmm0
jbe 0x620a
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x6253
xorps %xmm0, %xmm0
cvtsi2sdl (%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x4614
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
jbe 0x623d
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x6259
cmpneqsd %xmm1, %xmm0
movq %xmm0, %rax
andl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0x18, %rdi
jmp 0x625d
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x61c2
nop
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::BuscaInserta(TNodoABB*)
void TABBPoro::BuscaInserta(TNodoABB *nuevo){
	//Comprobar recursivamente que sea menor o mayor que el elemento nodo de la raiz e introducir donde quepa
	if(nuevo->item.Volumen() < nodo->item.Volumen())
	{
		//recursión hacia la izquierda del árbol
		if(!nodo->iz.EsVacio())
			nodo->iz.BuscaInserta(nuevo);
		else
			nodo->iz.nodo = nuevo;
	}
	else if(nuevo->item.Volumen() > nodo->item.Volumen())
	{
		//recursión hacia la derecha del árbol
		if(!nodo->de.EsVacio())
			nodo->de.BuscaInserta(nuevo);
		else
			nodo->de.nodo = nuevo;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rbx, %rdi
callq 0x4614
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x4614
ucomisd -0x18(%rbp), %xmm0
jbe 0x62a3
movq (%r14), %rax
leaq 0x18(%rax), %r14
cmpq $0x0, 0x18(%rax)
jne 0x6277
jmp 0x62d1
movq %rbx, %rdi
callq 0x4614
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x4614
movsd -0x18(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x62d4
movq (%r14), %rax
leaq 0x38(%rax), %r14
cmpq $0x0, 0x38(%rax)
jne 0x6277
movq %rbx, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Insertar(TPoro const&)
bool TABBPoro::Insertar(const TPoro &poro) {
	//se crea el nodo a insertar
	TNodoABB *aux = new TNodoABB;;
	aux->item = poro;
	if(EsVacio())
	{
		nodo = aux;
		return true;
	}
	else if(FiltraVolumen(poro.Volumen()))
	{
		BuscaInserta(aux);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x58, %edi
callq 0x10f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x5b38
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43e4
cmpq $0x0, (%r14)
je 0x633f
movq %r15, %rdi
callq 0x4614
cvttsd2si %xmm0, %eax
leaq -0x1c(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x61c2
testb %al, %al
je 0x6346
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6266
jmp 0x6342
movq %rbx, (%r14)
movb $0x1, %al
jmp 0x6348
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x1100
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::Borrar(TPoro const&)
bool TABBPoro::Borrar(const TPoro &poro) {
	if(!EsVacio() && Buscar(poro))
	{
		if(nodo->item == poro)
		{
			if(EsHoja() || nodo->iz.EsVacio() || nodo->de.EsVacio())
			{
				//El nodo es sustituido por el hijo
				SustituyePorHijo();
				return true;
			}
			else
			{
				SustituyeMayorIzq();
				return true;
			}
		}
		else if(poro.Volumen() < nodo->item.Volumen() && !nodo->iz.EsVacio())
		nodo->iz.Borrar(poro);
		else if(poro.Volumen() > nodo->item.Volumen() && !nodo->de.EsVacio())
		nodo->de.Borrar(poro);
	}
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, (%rdi)
je 0x63c4
movq %rsi, %r14
movq %rdi, %rbx
callq 0x651c
testb %al, %al
je 0x63c4
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x442a
testb %al, %al
je 0x63db
movq (%rbx), %rax
movq 0x38(%rax), %rcx
testq %rcx, %rcx
jne 0x63ae
cmpq $0x0, 0x18(%rax)
je 0x63c8
testq %rcx, %rcx
je 0x63c8
cmpq $0x0, 0x18(%rax)
je 0x63c8
movq %rbx, %rdi
callq 0x64d6
jmp 0x63d0
xorl %eax, %eax
jmp 0x63d2
movq %rbx, %rdi
callq 0x6418
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x4614
movsd %xmm0, -0x18(%rbp)
movq (%rbx), %rdi
callq 0x4614
ucomisd -0x18(%rbp), %xmm0
jbe 0x6401
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x640c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11e0
addq $0x18, %rdi
movq %r14, %rsi
callq 0x636c
// File: /workspace/github_cpp_makefile_star2_O1/jespinosa94[P]PED16/lib/tabbporo.cpp
// Function: TABBPoro::SustituyePorHijo()
void TABBPoro::SustituyePorHijo()
{
	TABBPoro aux;
	if(EsHoja())
		(*this).~TABBPoro();
	else if(!nodo->iz.EsVacio())
	{
		//sustituir por el hijo izquierdo
		aux = nodo->iz;
		(*this) = aux;
	}
	else if(!nodo->de.EsVacio())
	{
		//sustituir por el hijo derecho
		aux = nodo->de;
		(*this) = aux;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x4210
movq $0x0, -0x8(%rbx)
movq (%r14), %rsi
movq 0x38(%rsi), %rax
testq %rax, %rax
jne 0x644d
cmpq $0x0, 0x18(%rsi)
je 0x647c
movq 0x18(%rsi), %rcx
orq %rcx, %rax
je 0x6494
leaq 0x38(%rsi), %rax
addq $0x18, %rsi
testq %rcx, %rcx
cmoveq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x5ce8
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x5ce8
jmp 0x6494
testq %rsi, %rsi
je 0x6488
movq $0x0, (%r14)
addq $0x8, %r14
movq %r14, %rdi
callq 0x43b2
cmpq $0x0, -0x30(%rbp)
je 0x64a3
movq $0x0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x43b2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
cmpq $0x0, -0x30(%rbp)
je 0x64c6
movq $0x0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x43b2
movq %r14, %rdi
callq 0x11b0