LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::~TPoro()
TPoro::~TPoro() {
	x = y = volumen = 0;
	if(color != NULL){
		delete color;	//Se libera la memoria
		color = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x373b
pushq $0x1
popq %rsi
callq 0x10f0
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::operator=(TPoro const&)
TPoro& TPoro::operator =(const TPoro &p) {
	if(this != &p)
	{
		(*this).~TPoro();
		Copy(p);
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x3767
movq %rsi, %r14
movq %rbx, %rdi
callq 0x3716
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36c0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::operator==(TPoro const&) const
bool TPoro::operator ==(const TPoro &p) const {
	bool temp = false;
	if((*this).EsVacio() && p.EsVacio())
		temp = true;
	else if(!(*this).EsVacio() && !p.EsVacio())
	{
		if(color==NULL && p.color==NULL && x==p.x && y==p.y && volumen==p.volumen)
			temp = true;
		else if(color!=NULL && p.color!=NULL && x==p.x && y==p.y && volumen==p.volumen)
		{
			if(!strcmp(color, p.color))
				temp = true;
		}
	}
	return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x381e
movl %eax, %r15d
movq %rbx, %rdi
callq 0x381e
movl %r15d, %ecx
orb %al, %cl
je 0x379c
andb %al, %r15b
jmp 0x380f
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
movq %rdi, %rax
orq %rsi, %rax
jne 0x37d0
movl (%r14), %eax
cmpl (%rbx), %eax
jne 0x380c
movl 0x4(%r14), %eax
cmpl 0x4(%rbx), %eax
jne 0x380c
movsd 0x8(%r14), %xmm0
movb $0x1, %r15b
ucomisd 0x8(%rbx), %xmm0
jne 0x380c
jnp 0x380f
jmp 0x380c
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x380c
movl (%r14), %eax
cmpl (%rbx), %eax
jne 0x380c
movl 0x4(%r14), %eax
cmpl 0x4(%rbx), %eax
jne 0x380c
movsd 0x8(%r14), %xmm0
ucomisd 0x8(%rbx), %xmm0
jne 0x380c
jp 0x380c
callq 0x1100
testl %eax, %eax
sete %r15b
jmp 0x380f
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::Color(char*)
void TPoro::Color(char *newColor) {
	VerifyLowerCase(newColor);
	if(newColor == NULL)
		color = NULL;
	else
	{
		color = new char[strlen(newColor) + 1];
		strcpy(color, newColor);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq %rsi, (%r14)
movq %r14, %rsi
callq 0x362e
movq (%r14), %r14
testq %r14, %r14
je 0x38bd
movq %r14, %rdi
callq 0x1070
leaq 0x1(%rax), %rdi
callq 0x1030
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x10c0
andq $0x0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tporo.cpp
// Function: operator<<(std::ostream&, TPoro const&)
ostream& operator<<(ostream &os, const TPoro &p){
	if(!p.EsVacio()){
		os.setf(ios::fixed);
		os.precision(2);
		os << "(" << p.x << ", " << p.y << ") " << p.volumen << " ";
		if(p.color != NULL)
			os << p.color;
		else
			os << "-";
	}
	else
		os << "()";

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x381e
testb %al, %al
je 0x3919
leaq 0x3926(%rip), %rsi      # 0x723a
jmp 0x39a5
movq (%rbx), %rax
movq -0x18(%rax), %rcx
orl $0x4, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0x2, 0x8(%rbx,%rax)
leaq 0x38c6(%rip), %rsi      # 0x71ff
movq %rbx, %rdi
callq 0x10d0
movl (%r14), %esi
movq %rax, %rdi
callq 0x1180
leaq 0x38ae(%rip), %rsi      # 0x7201
movq %rax, %rdi
callq 0x10d0
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x1180
leaq 0x3896(%rip), %rsi      # 0x7204
movq %rax, %rdi
callq 0x10d0
movsd 0x8(%r14), %xmm0
movq %rax, %rdi
callq 0x1140
leaq 0x387a(%rip), %rsi      # 0x7205
movq %rax, %rdi
callq 0x10d0
movq 0x10(%r14), %rax
testq %rax, %rax
leaq 0x3866(%rip), %rsi      # 0x7207
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0x10d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/jespinosa94[P]PED16/lib/tvectorporo.cpp
// Function: TVectorPoro::TVectorPoro(int)
TVectorPoro::TVectorPoro(int creaDim) {
	if(creaDim <= 0)
	{
		dimension = 0;
		datos = NULL;
	}
	else
	{
		dimension = creaDim;
		datos = new TPoro[dimension];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x3580
testl %r14d, %r14d
jle 0x3a48
movq %rbx, -0x40(%rbp)
movl %r14d, (%r15)
movl %r14d, %ebx
imulq $0x18, %rbx, %rdi
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x1030
movq %rbx, (%rax)
movq %rax, -0x30(%rbp)
leaq 0x8(%rax), %r12
imulq $-0x18, %rbx, %r14
xorl %ebx, %ebx
movq %r12, %r13
movq %r13, %rdi
callq 0x3580
addq $-0x18, %rbx
addq $0x18, %r13
cmpq %rbx, %r14
jne 0x3a31
jmp 0x3a4f
andl $0x0, (%r15)
xorl %r12d, %r12d
movq %r12, 0x8(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x3a96
movq %rax, %r15
testq %rbx, %rbx
je 0x3a89
negq %rbx
movq -0x30(%rbp), %r14
addq $-0x10, %r14
leaq (%r14,%rbx), %rdi
callq 0x3716
addq $-0x18, %rbx
jne 0x3a7a
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11a0
movq -0x40(%rbp), %rdi
callq 0x3716
movq %r15, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3580
movslq (%r14), %rbx
pushq $0x18
popq %rcx
movq %rbx, %rax
mulq %rcx
movq %rax, %rdi
seto %al
addq $0x8, %rdi
pushq $-0x1
popq %rcx
cmovbq %rcx, %rdi
movl %ebx, (%r15)
testb %al, %al
cmovneq %rcx, %rdi
movq %rdi, -0x40(%rbp)
callq 0x1030
movq %rbx, (%rax)
movq %rax, -0x30(%rbp)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
testl %ebx, %ebx
je 0x3b2e
imulq $-0x18, %rbx, %r12
xorl %r13d, %r13d
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x3580
addq $-0x18, %r13
addq $0x18, %rbx
cmpq %r13, %r12
jne 0x3b19
movq -0x38(%rbp), %rax
movq %rax, 0x8(%r15)
xorl %ebx, %ebx
xorl %r12d, %r12d
movslq (%r15), %rax
cmpq %rax, %r12
jge 0x3b5f
movq 0x8(%r14), %rsi
addq %rbx, %rsi
movq 0x8(%r15), %rdi
addq %rbx, %rdi
callq 0x3742
incq %r12
addq $0x18, %rbx
jmp 0x3b3b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ba1
movq %rax, %r14
testq %r13, %r13
je 0x3b92
negq %r13
movq -0x30(%rbp), %rbx
addq $-0x10, %rbx
leaq (%rbx,%r13), %rdi
callq 0x3716
addq $-0x18, %r13
jne 0x3b83
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x11a0
jmp 0x3ba4
movq %rax, %r14
movq -0x48(%rbp), %rdi
callq 0x3716
movq %r14, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x3bd5
callq 0x3716
andq $0x0, 0x8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3716
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3cb2
movq %rsi, %r14
movl (%rsi), %eax
cmpl %eax, (%rbx)
je 0x3c88
movl %eax, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3c20
callq 0x3716
movl (%rbx), %eax
movslq %eax, %r13
pushq $0x18
popq %rcx
movq %r13, %rax
mulq %rcx
movq %rax, %rdi
seto %al
addq $0x8, %rdi
pushq $-0x1
popq %rcx
cmovbq %rcx, %rdi
testb %al, %al
cmovneq %rcx, %rdi
movq %rdi, -0x40(%rbp)
callq 0x1030
movq %r13, (%rax)
movq %rax, -0x30(%rbp)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
testl %r13d, %r13d
je 0x3c80
imulq $-0x18, %r13, %r15
xorl %r12d, %r12d
movq -0x38(%rbp), %r13
movq %r13, %rdi
callq 0x3580
addq $-0x18, %r12
addq $0x18, %r13
cmpq %r12, %r15
jne 0x3c6b
movq -0x38(%rbp), %rax
movq %rax, 0x8(%rbx)
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x3cb2
movq 0x8(%r14), %rsi
addq %r15, %rsi
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0x3742
incq %r12
addq $0x18, %r15
jmp 0x3c8e
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 0x3ce6
negq %r12
movq -0x30(%rbp), %r14
addq $-0x10, %r14
leaq (%r14,%r12), %rdi
callq 0x3716
addq $-0x18, %r12
jne 0x3cd7
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x11a0
movq %rbx, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3d48
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %r12
xorl %esi, %esi
movslq (%r14), %rax
incq %r12
cmpq %rax, %r12
setge %r15b
jge 0x3d4b
leaq 0x18(%rsi), %r13
movq 0x8(%r14), %rdi
addq %rsi, %rdi
addq 0x8(%rbx), %rsi
callq 0x384a
movq %r13, %rsi
testb %al, %al
je 0x3d1c
jmp 0x3d4b
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_O2/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 0x3d91
cmpl %esi, (%rbx)
jl 0x3d91
movq 0x8(%rbx), %rax
movl %esi, %ecx
imulq $0x18, %rcx, %rcx
leaq (%rax,%rcx), %rbx
addq $-0x18, %rbx
jmp 0x3d9d
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x3716
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3dd2
cmpl %edx, (%r14)
jl 0x3dd2
movq 0x8(%r14), %rax
movl %edx, %ecx
imulq $0x18, %rcx, %rcx
leaq (%rax,%rcx), %r14
addq $-0x18, %r14
jmp 0x3dde
addq $0x10, %r14
movq %r14, %rdi
callq 0x3716
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36b6
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x3e36
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0x381e
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %r14d
incq %r12
addq $0x18, %r15
jmp 0x3e11
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e63
movl %esi, %r15d
movq %rdi, %rbx
movl (%rdi), %eax
cmpl %esi, %eax
jne 0x3e6a
xorl %eax, %eax
jmp 0x3f93
movl %r15d, %r14d
imulq $0x18, %r14, %r13
leaq 0x8(%r13), %r12
cmpl %r15d, %eax
movq %r12, -0x40(%rbp)
jge 0x3ef2
leaq -0x68(%rbp), %r13
movq %r13, %rdi
callq 0x39b8
movl %r15d, (%r13)
movq %r12, %rdi
callq 0x1030
movq %r14, (%rax)
movq %rax, -0x30(%rbp)
leaq 0x8(%rax), %r15
imulq $-0x18, %r14, %r14
xorl %r13d, %r13d
movq %r15, %r12
movq %r12, %rdi
callq 0x3580
addq $-0x18, %r13
addq $0x18, %r12
cmpq %r13, %r14
jne 0x3eab
movq %r15, -0x60(%rbp)
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x3f5e
movq 0x8(%rbx), %rsi
addq %r14, %rsi
movq -0x60(%rbp), %rdi
addq %r14, %rdi
callq 0x3742
incq %r15
addq $0x18, %r14
jmp 0x3eca
leaq -0x68(%rbp), %rdi
callq 0x39b8
leaq -0x68(%rbp), %rax
movl %r15d, (%rax)
movq %r12, %rdi
callq 0x1030
movq %r14, (%rax)
movq %rax, -0x38(%rbp)
leaq 0x8(%rax), %r12
imulq $-0x18, %r14, %r15
xorl %r14d, %r14d
movq %r12, -0x30(%rbp)
movq %r12, %rdi
callq 0x3580
addq $-0x18, %r14
addq $0x18, %r12
cmpq %r14, %r15
jne 0x3f20
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x3f74
movq 0x8(%rbx), %rsi
addq %r14, %rsi
movq -0x60(%rbp), %rdi
addq %r14, %rdi
callq 0x3742
addq $0x18, %r14
jmp 0x3f40
movq %rbx, %rdi
callq 0x3bb6
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x3be8
jmp 0x3f88
movq %rbx, %rdi
callq 0x3bb6
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x3be8
leaq -0x68(%rbp), %rdi
callq 0x3bb6
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3fa8
jmp 0x3fa8
jmp 0x3fa8
movq %rax, %rbx
jmp 0x4004
movq %rax, %rbx
testq %r14, %r14
je 0x3fcf
negq %r14
movq -0x38(%rbp), %r15
addq $-0x10, %r15
leaq (%r15,%r14), %rdi
callq 0x3716
addq $-0x18, %r14
jne 0x3fc0
movq -0x38(%rbp), %rdi
jmp 0x3ffb
movq %rax, %rbx
testq %r13, %r13
je 0x3ff7
negq %r13
movq -0x30(%rbp), %r14
addq $-0x10, %r14
leaq (%r14,%r13), %rdi
callq 0x3716
addq $-0x18, %r13
jne 0x3fe8
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x11a0
leaq -0x68(%rbp), %rdi
callq 0x3bb6
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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 0x31d9(%rip), %rsi      # 0x7209
movq %rdi, -0x30(%rbp)
callq 0x10d0
cmpl $0x0, (%r14)
jle 0x40e9
pushq $0x1
popq %r15
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1180
leaq 0x31a8(%rip), %rsi      # 0x7205
movq %rax, %rdi
callq 0x10d0
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x3da8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x38f4
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x3716
pushq $0x2
popq %r12
leaq 0x316c(%rip), %r13      # 0x7205
cmpl (%r14), %r12d
jg 0x40e9
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x10d0
movq %rax, %rdi
movl %r12d, %esi
callq 0x1180
movq %rax, %rdi
movq %r13, %rsi
callq 0x10d0
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x3da8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38f4
movq %r15, %rdi
callq 0x3716
incl %r12d
jmp 0x4099
leaq 0x311b(%rip), %rsi      # 0x720b
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x10d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4110
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3716
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3716
cmpq $0x0, 0x18(%rbx)
je 0x4176
andq $0x0, 0x18(%rbx)
cmpq $0x0, 0x20(%rbx)
je 0x4182
andq $0x0, 0x20(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3716
// File: /workspace/github_cpp_makefile_star2_O2/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 0x41c4
movq %rsi, %r14
movq %rbx, %rdi
callq 0x3742
movq 0x18(%r14), %rsi
movq 0x18(%rbx), %rdi
callq 0x3742
movq 0x20(%r14), %rsi
movq 0x20(%rbx), %rdi
callq 0x3742
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x428e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42a4
addq $0x20, %rbx
jmp 0x4275
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
orq (%rdi), %rax
jne 0x42cd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x44ec
movb $0x1, %al
jmp 0x42de
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4688
testb %al, %al
je 0x42e7
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x38de
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x38de
ucomisd -0x18(%rbp), %xmm0
ja 0x42be
movq %rbx, %rdi
callq 0x38de
movsd %xmm0, -0x18(%rbp)
movq 0x8(%r14), %rdi
callq 0x38de
movsd -0x18(%rbp), %xmm1
movq %r14, %rdi
movq %rbx, %rsi
ucomisd %xmm0, %xmm1
jae 0x4331
callq 0x4616
jmp 0x42c9
callq 0x455c
jmp 0x42c9
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
pushq $0x28
popq %r14
testq %r15, %r15
je 0x436e
movq 0x20(%r15), %r12
movq %r15, %rdi
callq 0x415c
movq %r15, %rdi
movq %r14, %rsi
callq 0x10f0
movq %r12, %r15
jmp 0x434d
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
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 %r15b
testb %sil, %sil
je 0x43e0
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testq %rbx, %rbx
sete %r15b
je 0x43d2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x384a
testb %al, %al
jne 0x43d2
movq 0x20(%rbx), %rbx
movq 0x20(%r14), %r14
jmp 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x4258
movq (%r14), %r14
testq %r14, %r14
je 0x443d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42a4
addq $0x20, %r14
jmp 0x4424
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4338
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x4258
movq (%r14), %r14
testq %r14, %r14
je 0x4483
movq %rbx, %rdi
movq %r14, %rsi
callq 0x449e
addq $0x20, %r14
jmp 0x446a
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4338
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x4688
movl %eax, %r14d
testb %al, %al
je 0x44dc
leaq -0x28(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x46b8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x47f4
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
pushq $0x28
popq %rdi
callq 0x10e0
movq %rax, %r14
movq %rax, %rdi
callq 0x4124
movq %r14, %rdi
movq %r15, %rsi
callq 0x3742
leaq 0x8(%rbx), %rax
movq (%rbx), %rcx
leaq 0x18(%rcx), %rdx
movq 0x8(%rbx), %rsi
orq %rcx, %rsi
cmoveq %rax, %rdx
movq %r14, (%rdx)
movq %rcx, 0x20(%r14)
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
pushq $0x28
popq %rdi
callq 0x10e0
movq %rax, %r14
movq %rax, %rdi
callq 0x4124
movq %r14, %rdi
movq %r15, %rsi
callq 0x3742
movq 0x8(%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, 0x20(%rax)
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x45f9
callq 0x38de
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
callq 0x38de
leaq 0x20(%r15), %rsi
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jb 0x45cc
movq %r15, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
andq $0x0, (%rbx)
movq %rax, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %rsi
leaq -0x18(%rbp), %rdi
movq %rbx, %rdx
callq 0x45bc
pushq $0x28
popq %rdi
callq 0x10e0
movq %rax, %r14
movq %rax, %rdi
callq 0x4124
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3742
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%r14)
movq %r14, 0x18(%rcx)
movq %r14, 0x20(%rax)
movq %rax, 0x18(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x46ad
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3770
leaq 0x20(%r14), %rdi
testb %al, %al
je 0x4692
testq %r14, %r14
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %r15
cmpq $0x0, 0x20(%r15)
je 0x46e5
movq %r15, %rdi
movq %r14, %rsi
callq 0x3770
leaq 0x20(%r15), %rsi
testb %al, %al
je 0x46c8
movq %r15, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
andq $0x0, (%rbx)
movq %rax, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4756
cmpl $0x1, %eax
jne 0x4725
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4338
movq (%r14), %rax
movq 0x20(%rax), %rax
movq %rax, (%r14)
movq (%rbx), %rdi
callq 0x415c
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x4747
movq %rbx, %rdi
callq 0x415c
pushq $0x28
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x476c
addq $0x20, %rdi
incl %eax
jmp 0x475c
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x415c
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x479f
movq %rbx, %rdi
callq 0x415c
pushq $0x28
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x20(%rax)
movq (%rsi), %rdi
callq 0x415c
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x47e2
movq %rbx, %rdi
callq 0x415c
pushq $0x28
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rsi
callq 0x4688
movl %eax, %ebx
testb %al, %al
je 0x4842
movq (%r14), %rax
cmpq (%r15), %rax
je 0x482a
cmpq 0x8(%r15), %rax
je 0x4837
movq %r14, %rsi
callq 0x476e
jmp 0x4842
movq %r15, %rdi
movq %r14, %rsi
callq 0x4702
jmp 0x4842
movq %r15, %rdi
movq %r14, %rsi
callq 0x47b0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rax
movq (%rsi), %rsi
cmpl %edx, %eax
jge 0x4897
addq $0x20, %rsi
incl %eax
jmp 0x4888
movq %rbx, %rdi
callq 0x36b6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebx
movq %rsi, %r14
xorps %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
leaq -0x60(%rbp), %rdi
callq 0x3580
cmpl %r15d, %ebx
jg 0x498d
jne 0x4917
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x487c
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3742
leaq -0x48(%rbp), %rdi
callq 0x3716
leaq -0x60(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x42a4
jmp 0x4985
cmpl $0x2, %ebx
pushq $0x1
popq %r12
cmovgel %ebx, %r12d
movq %r14, %rdi
callq 0x4756
cmpl %r15d, %eax
cmovll %eax, %r15d
leaq -0x48(%rbp), %r13
leaq -0x60(%rbp), %rbx
cmpl %r15d, %r12d
jg 0x4970
movq %r13, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x487c
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3742
movq %r13, %rdi
callq 0x3716
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x42a4
incl %r12d
jmp 0x4939
movq -0x30(%rbp), %rbx
jmp 0x4985
movq %r14, %rdi
movq %rbx, %rsi
callq 0x449e
addq $0x20, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x4976
leaq -0x60(%rbp), %rdi
callq 0x3716
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49c6
jmp 0x49b6
jmp 0x49c6
movq %rax, %r14
jmp 0x49d2
jmp 0x49c6
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x3716
jmp 0x49c9
jmp 0x49c6
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x3716
movq -0x30(%rbp), %rdi
callq 0x4338
movq %r14, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27fd(%rip), %rsi      # 0x71ff
callq 0x10d0
movq 0x8(%r15), %rax
orq (%r15), %rax
jne 0x4a2f
leaq 0x2824(%rip), %rsi      # 0x723b
movq %rbx, %rdi
callq 0x10d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x36b6
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x38f4
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x3716
leaq 0x27ab(%rip), %r12      # 0x7205
movq 0x20(%r14), %r14
testq %r14, %r14
je 0x4a10
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10d0
movq %r15, %rdi
movq %r14, %rsi
callq 0x36b6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38f4
movq %r15, %rdi
callq 0x3716
jmp 0x4a5a
jmp 0x4a97
jmp 0x4a92
movq %rax, %rbx
jmp 0x4aa3
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3716
movq %rbx, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3742
cmpq $0x0, 0x38(%rbx)
je 0x4b94
leaq 0x38(%rbx), %rsi
leaq 0x38(%r14), %rdi
callq 0x4bf0
cmpq $0x0, 0x18(%rbx)
je 0x4bb2
addq $0x18, %rbx
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x4bf0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4c15
movq %rsi, %r14
movq %rbx, %rdi
callq 0x4ef8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e76
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4c43
movq %rsi, %r14
movq %rbx, %rdi
callq 0x4bb8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b6e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4c9a
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4c4c
movq (%r15), %r12
movl (%rbx), %esi
movq %r14, %rdi
callq 0x3d6c
movq %rax, %rdi
movq %r12, %rsi
callq 0x3742
incl (%rbx)
movq (%r15), %r15
addq $0x38, %r15
jmp 0x4c60
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4cf2
movl (%rbx), %esi
movq %r14, %rdi
callq 0x3d6c
movq %rax, %rdi
movq %r12, %rsi
callq 0x3742
incl (%rbx)
movq (%r15), %rdi
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4ca4
movq (%r15), %r15
addq $0x38, %r15
jmp 0x4cb8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4d4c
movq %rdx, %rbx
movq %rsi, %r14
addq $0x18, %rdi
callq 0x4cfc
movq (%r15), %rdi
addq $0x38, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4cfc
movq (%r15), %r15
movl (%rbx), %esi
movq %r14, %rdi
callq 0x3d6c
movq %rax, %rdi
movq %r15, %rsi
callq 0x3742
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x70(%rbp), %r12
movq %r12, %rdi
callq 0x576a
movq %r12, %rdi
movq %r15, %rsi
callq 0x59fe
leaq -0x70(%rbp), %r15
movq -0x60(%rbp), %rax
cmpq %rax, -0x40(%rbp)
je 0x4de5
movq (%rax), %r12
movl (%rbx), %esi
movq %r14, %rdi
callq 0x3d6c
movq %rax, %rdi
movq %r12, %rsi
callq 0x3742
incl (%rbx)
movq %r15, %rdi
callq 0x5c56
cmpq $0x0, 0x18(%r12)
je 0x4dcc
leaq 0x18(%r12), %rsi
movq %r15, %rdi
callq 0x59fe
cmpq $0x0, 0x38(%r12)
je 0x4d8b
addq $0x38, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x59fe
jmp 0x4d8b
leaq -0x70(%rbp), %rdi
callq 0x5798
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4dfd
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x5798
movq %rbx, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x58
popq %r15
cmpq $0x0, (%r14)
je 0x4ed5
movq %r15, %rdi
callq 0x10e0
movq %rax, %r12
movq %rax, %rdi
callq 0x4aac
movq (%r14), %rsi
movq %r12, %rdi
callq 0x3742
movq %r12, (%rbx)
addq $0x18, %r12
movq (%r14), %rsi
addq $0x18, %rsi
movq %r12, %rdi
callq 0x4e76
movq (%rbx), %rbx
addq $0x38, %rbx
movq (%r14), %r14
addq $0x38, %r14
jmp 0x4e8b
andq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r12, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %r15
testq %r15, %r15
je 0x4f53
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f64
testb %al, %al
je 0x4f53
movq (%r14), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
callq 0x4f10
testb %al, %al
je 0x4f53
movq (%r14), %r14
addq $0x38, %r14
jmp 0x4f20
testq %r15, %r15
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f74
popq %rbp
jmp 0x52f2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38de
cvtsi2sdl (%rbx), %xmm1
ucomisd %xmm1, %xmm0
jne 0x500d
jnp 0x505d
movsd %xmm0, -0x28(%rbp)
movq (%r14), %rdi
movsd %xmm1, -0x18(%rbp)
callq 0x38de
ucomisd -0x18(%rbp), %xmm0
movq (%r14), %rdi
jbe 0x5030
cmpq $0x0, 0x18(%rdi)
jne 0x5073
cvtsi2sdl (%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x38de
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
jbe 0x505d
movq (%r14), %rdi
cmpq $0x0, 0x38(%rdi)
jne 0x5079
cmpneqsd %xmm1, %xmm0
movq %xmm0, %rax
andl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0x18, %rdi
jmp 0x507d
addq $0x38, %rdi
movq %rbx, %rsi
callq 0x4fe8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38de
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x38de
ucomisd -0x18(%rbp), %xmm0
jbe 0x50c3
movq (%r14), %rax
leaq 0x18(%rax), %r14
cmpq $0x0, 0x18(%rax)
jne 0x5097
jmp 0x50f1
movq %rbx, %rdi
callq 0x38de
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rdi
callq 0x38de
movsd -0x18(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x50f4
movq (%r14), %rax
leaq 0x38(%rax), %r14
cmpq $0x0, 0x38(%rax)
jne 0x5097
movq %rbx, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop