LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/Cache.hh
// Function: PerfParameters::PerfParameters()
PerfParameters() {

			costSRAM = std::vector<int>(2 ,0);
			costSRAM[READ_ACCESS] = 10;
			costSRAM[WRITE_ACCESS] = 10;

			costNVM = std::vector<int>(2 ,0);
			costNVM[READ_ACCESS] = 10;
			costNVM[WRITE_ACCESS] = 37;

			costDRAM = std::vector<int>(2 ,0);
			costDRAM[READ_ACCESS] = 100;
			costDRAM[WRITE_ACCESS] = 100;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x40(%rdi)
movl $0x8, %edi
callq 0x52f0
movq $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movq 0x18(%rbx), %rdi
movq %rax, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
testq %rdi, %rdi
je 0x334e5
callq 0x52b0
movq 0x18(%rbx), %rax
movabsq $0xa0000000a, %rcx      # imm = 0xA0000000A
movq %rcx, (%rax)
movl $0x8, %edi
callq 0x52f0
movq $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movq (%rbx), %rdi
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
testq %rdi, %rdi
je 0x33525
callq 0x52b0
movq (%rbx), %rax
movabsq $0x250000000a, %rcx     # imm = 0x250000000A
movq %rcx, (%rax)
movl $0x8, %edi
callq 0x52f0
movq $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
movq 0x30(%rbx), %rdi
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movq %rcx, 0x40(%rbx)
testq %rdi, %rdi
je 0x33568
callq 0x52b0
movq 0x30(%rbx), %rax
movabsq $0x6400000064, %rcx     # imm = 0x6400000064
movq %rcx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x33581
jmp 0x33581
movq %rax, %r14
movq %rbx, %rdi
callq 0xc792
movq %r14, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O3/asdfz1346[P]MyServer/MyServer.cpp
// Function: MyServer::link_startou(char const*, short)
void MyServer::link_startou(const char *ip,short port){
	if(!server_listen(ip,port)){
		printf("	server_listen error\n");	
	}
	struct ARG arg;
	arg.p = this;
	std::cout << "main threadid = "<<pthread_self()<<std::endl;
	pthread_create(&accept_thread,NULL,accept_thread_proc,&arg);
	
	for(int i=0;i<THREAD_NUM;i++){
		pthread_create(&worker_thread[i],NULL,worker_thread_proc,&arg);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x26f0
testb %al, %al
jne 0x265c
leaq 0x2b68(%rip), %rdi      # 0x51bf
callq 0x2330
leaq -0x20(%rbp), %r14
movq %rbx, (%r14)
movq 0x496e(%rip), %r15      # 0x6fd8
leaq 0x29af(%rip), %rsi      # 0x5020
movl $0x10, %edx
movq %r15, %rdi
callq 0x22a0
callq 0x2200
movq %r15, %rdi
movq %rax, %rsi
callq 0x2190
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x21a0
leaq 0x16f(%rip), %rdx       # 0x282e
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x23b0
addq $0x10, %rbx
leaq 0x399(%rip), %rdx       # 0x2a70
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x23b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/asdfz1346[P]MyServer/MyServer.cpp
// Function: MyServer::server_listen(char const*, short)
bool MyServer::server_listen(const char *ip,short port){
	//socket
	listenfd = socket(AF_INET,SOCK_STREAM|SOCK_NONBLOCK,0);
	if(listenfd==-1){
		printf("soket error\n");
		return false;
	}
	int on =1;
	setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
	setsockopt(listenfd,SOL_SOCKET,SO_REUSEPORT,&on,sizeof on);

	//bind
	struct sockaddr_in serveraddr;
	memset(&serveraddr,0,sizeof serveraddr);
	serveraddr.sin_family= AF_INET;
	serveraddr.sin_addr.s_addr = inet_addr(ip);//点分十进制ip转换成一个长整数
	serveraddr.sin_port = htons(port);//转换为网络字节序
	if(bind(listenfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))==-1){
		printf("bind error\n");
		return false;
	}
	//listen
	if(listen(listenfd,LISTEN_NUM)==-1){//待测试
		printf("listen() error\n");
		return false;
	}
	//epoll
	epollfd = epoll_create(1);

	struct epoll_event e;
	memset(&e,0,sizeof e);
	e.events = EPOLLIN;
	e.data.fd = listenfd;
	if(epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd,&e)==-1){
		printf("epoll_ctl error;\n");
		return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl $0x2, %edi
movl $0x801, %esi            # imm = 0x801
xorl %edx, %edx
callq 0x2090
movl %eax, 0x18(%rbx)
cmpl $-0x1, %eax
je 0x27ff
leaq -0x24(%rbp), %r12
movl $0x1, (%r12)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movq %r12, %rcx
movl $0x4, %r8d
callq 0x2390
movl 0x18(%rbx), %edi
movl $0x1, %esi
movl $0xf, %edx
movq %r12, %rcx
movl $0x4, %r8d
callq 0x2390
leaq -0x40(%rbp), %r12
movq $0x0, 0x8(%r12)
movw $0x2, (%r12)
movq %r15, %rdi
callq 0x2230
movl %eax, 0x4(%r12)
rolw $0x8, %r14w
movw %r14w, 0x2(%r12)
movl 0x18(%rbx), %edi
movq %r12, %rsi
movl $0x10, %edx
callq 0x2070
cmpl $-0x1, %eax
je 0x2808
movl 0x18(%rbx), %edi
movl $0x5, %esi
callq 0x2290
cmpl $-0x1, %eax
je 0x2811
movl $0x1, %edi
callq 0x23c0
movl %eax, 0x1c(%rbx)
leaq -0x30(%rbp), %rcx
movl $0x0, 0x8(%rcx)
movl $0x1, (%rcx)
movl 0x18(%rbx), %edx
movl %edx, 0x4(%rcx)
movl %eax, %edi
movl $0x1, %esi
callq 0x22f0
cmpl $-0x1, %eax
setne %bl
jne 0x281f
leaq 0x29dc(%rip), %rdi      # 0x51d4
callq 0x2330
jmp 0x281f
leaq 0x29f9(%rip), %rdi      # 0x51ff
jmp 0x2818
leaq 0x29e5(%rip), %rdi      # 0x51f4
jmp 0x2818
leaq 0x29cd(%rip), %rdi      # 0x51e5
callq 0x2330
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/asdfz1346[P]MyServer/MyServer.cpp
// Function: MyServer::main_loop()
void MyServer::main_loop(){	
	while(nstop){
		struct 	epoll_event ev[1024];
		int n = epoll_wait(epollfd,ev,1024,10);
		if(n<=0)
			continue;	
		int m = std::min(n,1024);
		for(int i=0;i<m;i++){
			if(ev[i].data.fd == listenfd)
				pthread_cond_signal(&accept_cond);
			else if(ev[i].events&(EPOLLIN | EPOLLERR)){
				pthread_mutex_lock(&clientset_mutex);
				if(clientset.find(ev[i].data.fd) != clientset.end()){
					pthread_mutex_unlock(&clientset_mutex);
					pthread_mutex_lock(&clientlist_mutex);
					clientlist.push_back(ev[i].data.fd);
					pthread_mutex_unlock(&clientlist_mutex);
				}else
					pthread_mutex_unlock(&clientset_mutex);	
			}
		}
	}
}

// Assembly:
cmpb $0x1, 0x118(%rdi)
jne 0x4a4c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3028, %rsp           # imm = 0x3028
movq %rdi, %rbx
leaq 0x98(%rdi), %r14
leaq 0x48(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0xc0(%rdi), %rax
movq %rax, -0x48(%rbp)
leaq 0x28(%rdi), %rax
movq %rax, -0x38(%rbp)
leaq 0xe8(%rdi), %rax
movq %rax, -0x50(%rbp)
movq %r14, -0x40(%rbp)
movl 0x1c(%rbx), %edi
leaq -0x3050(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
movl $0xa, %ecx
callq 0x2110
testl %eax, %eax
jle 0x4a2e
movl %eax, %r12d
movl $0x400, %eax            # imm = 0x400
cmpl %eax, %r12d
cmovael %eax, %r12d
xorl %r15d, %r15d
leaq (%r15,%r15,2), %rax
movl -0x304c(%rbp,%rax,4), %ecx
cmpl 0x18(%rbx), %ecx
jne 0x4991
movq -0x50(%rbp), %rdi
callq 0x2030
jmp 0x49e6
leaq -0x3050(,%rax,4), %r13
addq %rbp, %r13
testb $0x9, (%r13)
je 0x49e6
movq %r14, %rdi
callq 0x2300
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
je 0x49de
movl 0x4(%r13), %eax
movq -0x30(%rbp), %rdx
xorl %esi, %esi
cmpl %eax, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x49bc
cmpq -0x30(%rbp), %rdx
je 0x49de
cmpl 0x20(%rdx), %eax
jge 0x49f0
movq %r14, %rdi
callq 0x21d0
incq %r15
cmpq %r12, %r15
jne 0x4976
jmp 0x4a2e
movq %r14, %rdi
callq 0x21d0
movq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x2300
movl $0x18, %edi
callq 0x2220
movl 0x4(%r13), %ecx
movl %ecx, 0x10(%rax)
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x2060
incq 0x38(%rbx)
movq %r14, %rdi
movq -0x40(%rbp), %r14
jmp 0x49e1
cmpb $0x0, 0x118(%rbx)
jne 0x4943
addq $0x3028, %rsp           # imm = 0x3028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movl (%rdi), %edx
movl 0x4(%rdi), %ecx
movl %edx, %eax
orl %ecx, %eax
sete %al
movsd 0x8(%rdi), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
setnp %r8b
sete %r9b
andb %r8b, %r9b
cmpq $0x0, 0x10(%rdi)
sete %r11b
andb %al, %r11b
andb %r9b, %r11b
movl (%rsi), %r9d
movl 0x4(%rsi), %r8d
movl %r9d, %eax
orl %r8d, %eax
sete %al
movsd 0x8(%rsi), %xmm1
ucomisd %xmm2, %xmm1
setnp %r10b
sete %bl
andb %r10b, %bl
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
sete %r10b
andb %al, %r10b
andb %bl, %r10b
movl %r11d, %eax
andb %r10b, %al
testb %r11b, %r11b
jne 0x44f6
testb %r10b, %r10b
jne 0x44f6
movq 0x10(%rdi), %rdi
movq %rdi, %rax
orq %rsi, %rax
jne 0x44ce
xorl %r9d, %edx
xorl %r8d, %ecx
orl %edx, %ecx
sete %cl
ucomisd %xmm1, %xmm0
setnp %dl
sete %al
andb %dl, %al
andb %cl, %al
jmp 0x44f6
xorl %eax, %eax
cmpl %r9d, %edx
jne 0x44f6
testq %rdi, %rdi
je 0x44f6
testq %rsi, %rsi
je 0x44f6
cmpl %r8d, %ecx
jne 0x44f6
ucomisd %xmm1, %xmm0
jne 0x44f6
jp 0x44f6
callq 0x1120
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rsi)
jne 0x461c
cmpl $0x0, 0x4(%r14)
jne 0x461c
movsd 0x8(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x461c
jp 0x461c
cmpq $0x0, 0x10(%r14)
jne 0x461c
leaq 0x3c28(%rip), %rsi      # 0x823a
movl $0x2, %edx
jmp 0x46d8
movq (%rbx), %rax
movq -0x18(%rax), %rcx
orl $0x4, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0x2, 0x8(%rbx,%rax)
leaq 0x3bc3(%rip), %rsi      # 0x81ff
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1110
movl (%r14), %esi
movq %rbx, %rdi
callq 0x11a0
movq %rax, %r15
leaq 0x3ba3(%rip), %rsi      # 0x8201
movl $0x2, %edx
movq %rax, %rdi
callq 0x1110
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x11a0
movq %rax, %r15
leaq 0x3b83(%rip), %rsi      # 0x8204
movl $0x2, %edx
movq %rax, %rdi
callq 0x1110
movsd 0x8(%r14), %xmm0
movq %r15, %rdi
callq 0x1160
leaq 0x3b62(%rip), %rsi      # 0x8205
movl $0x1, %edx
movq %rax, %rdi
callq 0x1110
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x46cc
movq %r14, %rdi
callq 0x1080
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
jmp 0x46db
leaq 0x3b34(%rip), %rsi      # 0x8207
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1110
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4210
testl %r14d, %r14d
jle 0x4792
movq %rbx, -0x40(%rbp)
movl %r14d, (%r15)
movl %r14d, %r14d
leaq (%r14,%r14,2), %rax
leaq 0x8(,%rax,8), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1030
movq %r14, (%rax)
movq %rax, -0x30(%rbp)
leaq 0x8(%rax), %rbx
shlq $0x3, %r14
leaq (%r14,%r14,2), %r12
negq %r12
xorl %r14d, %r14d
movq %rbx, %r13
movq %r13, %rdi
callq 0x4210
addq $-0x18, %r14
addq $0x18, %r13
cmpq %r14, %r12
jne 0x477b
jmp 0x479b
movl $0x0, (%r15)
xorl %ebx, %ebx
movq %rbx, 0x8(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x47e2
movq %rax, %r15
testq %r14, %r14
je 0x47d5
negq %r14
movq -0x30(%rbp), %rbx
addq $-0x10, %rbx
leaq (%rbx,%r14), %rdi
callq 0x43b2
addq $-0x18, %r14
jne 0x47c6
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11c0
movq -0x40(%rbp), %rdi
callq 0x43b2
movq %r15, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %r12
movq %r12, %rdi
callq 0x4210
movslq (%r15), %rbx
movl $0x18, %ecx
movq %rbx, %rax
mulq %rcx
movq %rax, %r13
seto %al
addq $0x8, %r13
movq $-0x1, %rcx
cmovbq %rcx, %r13
movl %ebx, (%r14)
testb %al, %al
cmovneq %rcx, %r13
movq %r13, %rdi
callq 0x1030
movq %rbx, (%rax)
movq %rax, -0x38(%rbp)
addq $0x8, %rax
testl %ebx, %ebx
je 0x48c3
movq %r13, -0x40(%rbp)
movq %r12, -0x30(%rbp)
shlq $0x3, %rbx
leaq (%rbx,%rbx,2), %r12
negq %r12
xorl %r13d, %r13d
movq %rax, -0x48(%rbp)
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4210
addq $-0x18, %r13
addq $0x18, %rbx
cmpq %r13, %r12
jne 0x4877
cmpl $0x0, (%r14)
movq -0x48(%rbp), %rax
movq %rax, 0x8(%r14)
jle 0x48c7
xorl %ebx, %ebx
xorl %r12d, %r12d
movq 0x8(%r15), %rsi
addq %rbx, %rsi
movq 0x8(%r14), %rdi
addq %rbx, %rdi
callq 0x43e4
incq %r12
movslq (%r14), %rax
addq $0x18, %rbx
cmpq %rax, %r12
jl 0x489f
jmp 0x48c7
movq %rax, 0x8(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, -0x30(%rbp)
jmp 0x48dc
movq %rax, %r14
jmp 0x4910
movq %rax, %r14
testq %r13, %r13
je 0x4903
negq %r13
movq -0x38(%rbp), %rbx
addq $-0x10, %rbx
leaq (%rbx,%r13), %rdi
callq 0x43b2
addq $-0x18, %r13
jne 0x48f4
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x11c0
movq -0x30(%rbp), %rdi
callq 0x43b2
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4947
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_O3/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 0x4a48
movq %rsi, %r14
movl (%rbx), %eax
movl (%rsi), %ecx
cmpl %ecx, %eax
je 0x4a1c
movl %ecx, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4998
callq 0x43b2
movl (%rbx), %ecx
movslq %ecx, %r13
movl $0x18, %ecx
movq %r13, %rax
mulq %rcx
movq %rax, %r15
seto %al
addq $0x8, %r15
movq $-0x1, %rcx
cmovbq %rcx, %r15
testb %al, %al
cmovneq %rcx, %r15
movq %r15, %rdi
callq 0x1030
movq %r13, (%rax)
leaq 0x8(%rax), %rcx
testl %r13d, %r13d
je 0x4a16
movq %rax, -0x30(%rbp)
movq %r15, -0x38(%rbp)
shlq $0x3, %r13
leaq (,%r13,2), %r15
addq %r13, %r15
negq %r15
movq %rcx, %r13
xorl %r12d, %r12d
movq %rcx, -0x40(%rbp)
movq %r13, %rdi
callq 0x4210
addq $-0x18, %r12
addq $0x18, %r13
cmpq %r12, %r15
jne 0x49f9
movl (%rbx), %eax
movq -0x40(%rbp), %rcx
jmp 0x4a18
xorl %eax, %eax
movq %rcx, 0x8(%rbx)
testl %eax, %eax
jle 0x4a48
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 0x4a26
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 0x4a7c
negq %r12
movq -0x30(%rbp), %r14
addq $-0x10, %r14
leaq (%r14,%r12), %rdi
callq 0x43b2
addq $-0x18, %r12
jne 0x4a6d
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11c0
movq %rbx, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x4ae4
testl %eax, %eax
jle 0x4ae7
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
addq %r15, %rdi
movq 0x8(%rbx), %rsi
addq %r15, %rsi
callq 0x452a
testb %al, %al
jne 0x4ad9
incq %r12
movslq (%r14), %rcx
addq $0x18, %r15
cmpq %rcx, %r12
jl 0x4ab3
xorb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4b1d
cmpl %esi, (%rbx)
jl 0x4b1d
movq 0x8(%rbx), %rax
movl %esi, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rbx
addq $-0x18, %rbx
jmp 0x4b29
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_O3/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 0x4b5e
cmpl %edx, (%r14)
jl 0x4b5e
movq 0x8(%r14), %rax
movl %edx, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %r14
addq $-0x18, %r14
jmp 0x4b6a
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_O3/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 0x4bc7
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0x44fe
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %r14d
incq %r12
movslq (%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x4ba2
jmp 0x4bca
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4bf5
movl %esi, %r15d
movq %rdi, %rbx
cmpl %esi, (%rdi)
jne 0x4bfc
xorl %eax, %eax
jmp 0x4d57
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 0x4cba
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 0x4c5b
movq %r14, -0x60(%rbp)
cmpl $0x0, (%rbx)
jle 0x4ca1
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 0x4c7f
movq %rbx, %rdi
callq 0x4922
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x495a
jmp 0x4d4c
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 0x4cfc
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 0x4d1c
movq %rbx, %rdi
callq 0x4922
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x495a
leaq -0x68(%rbp), %rdi
callq 0x4922
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d6c
jmp 0x4d6c
jmp 0x4d6c
movq %rax, %rbx
jmp 0x4dc8
movq %rax, %rbx
testq %r14, %r14
je 0x4d93
negq %r14
movq -0x38(%rbp), %r15
addq $-0x10, %r15
leaq (%r15,%r14), %rdi
callq 0x43b2
addq $-0x18, %r14
jne 0x4d84
movq -0x38(%rbp), %rdi
jmp 0x4dbf
movq %rax, %rbx
testq %r13, %r13
je 0x4dbb
negq %r13
movq -0x30(%rbp), %r14
addq $-0x10, %r14
leaq (%r14,%r13), %rdi
callq 0x43b2
addq $-0x18, %r13
jne 0x4dac
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x11c0
leaq -0x68(%rbp), %rdi
callq 0x4922
movq %rbx, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3415(%rip), %rsi      # 0x8209
movl $0x1, %edx
movq %rdi, -0x30(%rbp)
callq 0x1110
cmpl $0x0, (%r14)
jle 0x4ed1
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x11a0
leaq 0x33e1(%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 0x4b34
movq %rbx, %rdi
movq %r15, %rsi
callq 0x45d6
leaq -0x48(%rbp), %rdi
callq 0x43b2
cmpl $0x2, (%r14)
jl 0x4ed1
movl $0x1, %r15d
leaq -0x48(%rbp), %r13
incl %r15d
movl $0x1, %edx
movq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r14, %rbx
leaq 0x3383(%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 0x4b34
movq %r12, %rdi
movq %r13, %rsi
callq 0x45d6
movq %r13, %rdi
callq 0x43b2
cmpl (%r14), %r15d
jl 0x4e69
leaq 0x3333(%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 0x4efd
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x43b2
movq %rbx, %rdi
callq 0x11b0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f69
movq $0x0, 0x18(%rbx)
cmpq $0x0, 0x20(%rbx)
je 0x4f78
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x43b2
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fba
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_O3/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 0x50ae
movq %rdi, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50c4
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x509a
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rax
orq %r15, %rax
je 0x5116
testq %r15, %r15
je 0x50fa
movq %r15, %rdi
movq %rbx, %rsi
callq 0x442a
testb %al, %al
jne 0x515c
movq 0x20(%r15), %r15
jmp 0x50e0
movq %rbx, %rdi
callq 0x45c0
movsd %xmm0, -0x20(%rbp)
movq (%r14), %rdi
callq 0x45c0
ucomisd -0x20(%rbp), %xmm0
jbe 0x512e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5382
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x45c0
movsd %xmm0, -0x20(%rbp)
movq 0x8(%r14), %rdi
callq 0x45c0
movsd -0x20(%rbp), %xmm1
movq %r14, %rdi
movq %rbx, %rsi
ucomisd %xmm0, %xmm1
jae 0x5160
callq 0x54cc
jmp 0x5121
xorl %eax, %eax
jmp 0x5123
callq 0x53fc
jmp 0x5121
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x519e
movq 0x20(%r14), %r15
movq %r14, %rdi
callq 0x4f4c
movl $0x28, %esi
movq %r14, %rdi
callq 0x1100
movq %r15, %r14
testq %r15, %r15
jne 0x517d
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_O3/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
testq %rbx, %rbx
sete %dl
movq 0x8(%rdi), %rax
orq %rbx, %rax
setne %cl
movq 0x8(%rsi), %rax
orq %r14, %rax
sete %al
orb %al, %dl
testb $0x1, %dl
je 0x521c
xorb %cl, %al
jmp 0x523a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x452a
testb %al, %al
jne 0x5238
movq 0x20(%rbx), %rbx
movq 0x20(%r14), %r14
testq %rbx, %rbx
jne 0x521c
xorb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x527f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x50c4
movq 0x20(%r15), %r15
jmp 0x5269
movq (%r14), %r14
testq %r14, %r14
je 0x5298
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50c4
movq 0x20(%r14), %r14
jmp 0x5282
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5168
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x52e9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x50c4
movq 0x20(%r15), %r15
jmp 0x52d3
movq (%r14), %r14
testq %r14, %r14
je 0x5302
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5324
movq 0x20(%r14), %r14
jmp 0x52ec
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5168
movq %r14, %rdi
callq 0x11b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq (%rdi), %r15
testq %r15, %r15
je 0x5354
movq %rsi, %r14
movq %rdi, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x442a
testb %al, %al
jne 0x5358
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x533c
xorl %eax, %eax
jmp 0x5377
leaq -0x20(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x557e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56e2
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x8(%r14), %rax
movq (%r14), %rcx
leaq 0x18(%rcx), %rdx
movq 0x8(%r14), %rsi
orq %rcx, %rsi
cmoveq %rax, %rdx
movq %rbx, (%rdx)
movq %rcx, 0x20(%rbx)
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
// File: /workspace/github_cpp_makefile_star2_O3/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 (%rsi), %r15
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x54ac
movq %rdx, %r14
callq 0x45c0
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
callq 0x45c0
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jae 0x54ac
movq 0x20(%r15), %r15
movq 0x20(%r15), %rdi
testq %rdi, %rdi
jne 0x5482
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_O3/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 0x5466
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 %rbx, 0x18(%rcx)
movq %rbx, 0x20(%rax)
movq %rax, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
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_O3/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 (%rdi), %r14
testq %r14, %r14
je 0x5576
movq %rsi, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x442a
testb %al, %al
jne 0x5578
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x555c
jmp 0x5578
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 (%rsi), %r14
cmpq $0x0, 0x20(%r14)
je 0x55b2
movq %rdx, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x442a
testb %al, %al
jne 0x55b2
movq 0x20(%r14), %r14
cmpq $0x0, 0x20(%r14)
jne 0x5598
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_O3/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 0x55fa
movl $0x1, %ecx
movq %rax, %rdx
movq 0x20(%rdx), %rdx
decl %ecx
testq %rdx, %rdx
jne 0x55eb
testl %ecx, %ecx
je 0x562c
movq 0x20(%rax), %rax
movq %rax, (%rdi)
movq (%rbx), %rdi
callq 0x4f4c
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x5619
movq %rbx, %rdi
callq 0x4f4c
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1100
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5168
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5653
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
incl %eax
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
jne 0x5646
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f4c
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x5687
movq %rbx, %rdi
callq 0x4f4c
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f4c
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x56cf
movq %rbx, %rdi
callq 0x4f4c
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x5716
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x442a
testb %al, %al
jne 0x571a
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x56fe
xorl %eax, %eax
jmp 0x574c
movq (%rbx), %rax
cmpq (%r14), %rax
je 0x5732
cmpq 0x8(%r14), %rax
je 0x573f
movq %rbx, %rsi
callq 0x5656
jmp 0x574a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x55d2
jmp 0x574a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x569a
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x57fe
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 0x5846
movq (%r14), %rsi
cmpl $0x2, %r12d
jl 0x5815
decl %r12d
movq 0x20(%rsi), %rsi
decl %r12d
jne 0x580c
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 0x50c4
jmp 0x58df
cmpl $0x2, %r12d
movl $0x1, %ebx
cmovgel %r12d, %ebx
movq (%r14), %rax
testq %rax, %rax
je 0x5881
xorl %ecx, %ecx
movq %rax, %rdx
incl %ecx
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
jne 0x5860
cmpl %r15d, %ecx
jge 0x588a
xorl %r15d, %r15d
incl %r15d
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x5873
jmp 0x588a
movl %r15d, %eax
sarl $0x1f, %eax
andl %eax, %r15d
cmpl %r15d, %ebx
jg 0x58df
leaq -0x48(%rbp), %r12
leaq -0x60(%rbp), %r13
movq (%r14), %rsi
cmpl $0x2, %ebx
jb 0x58ae
movl $0x1, %eax
incl %eax
movq 0x20(%rsi), %rsi
cmpl %eax, %ebx
jne 0x58a4
movq %r12, %rdi
callq 0x434e
movq %r13, %rdi
movq %r12, %rsi
callq 0x43e4
movq %r12, %rdi
callq 0x43b2
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x50c4
leal 0x1(%rbx), %eax
cmpl %r15d, %ebx
movl %eax, %ebx
jne 0x5897
movq -0x30(%rbp), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x57e2
movq %r14, %rdi
movq %r15, %rsi
callq 0x5324
movq 0x20(%r15), %r15
jmp 0x58e6
jmp 0x591d
jmp 0x590d
jmp 0x591d
movq %rax, %r14
jmp 0x5929
jmp 0x591d
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x43b2
jmp 0x5920
jmp 0x591d
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x43b2
movq -0x30(%rbp), %rdi
callq 0x5168
movq %r14, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28a6(%rip), %rsi      # 0x81ff
movl $0x1, %edx
callq 0x1110
movq 0x8(%r15), %rax
orq (%r15), %rax
je 0x59d8
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x434e
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x45d6
leaq -0x38(%rbp), %rdi
callq 0x43b2
movq 0x20(%r14), %r14
testq %r14, %r14
je 0x59d8
leaq 0x2868(%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 0x45d6
movq %r12, %rdi
callq 0x43b2
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x59a1
leaq 0x285c(%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 0x5a05
jmp 0x5a00
movq %rax, %rbx
jmp 0x5a11
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x43b2
movq %rbx, %rdi
callq 0x11b0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5b52
leaq 0x38(%rbx), %rsi
leaq 0x38(%r14), %rdi
callq 0x5bcc
cmpq $0x0, 0x18(%rbx)
je 0x5b70
addq $0x18, %rbx
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5bcc
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5bff
movq %rsi, %r14
cmpq $0x0, (%rbx)
je 0x5beb
movq $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
callq 0x43b2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f56
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5c2d
movq %rsi, %r14
movq %rbx, %rdi
callq 0x5b76
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b2c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5c8b
movq %rdx, %rbx
movq %rsi, %r14
addq $0x18, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5c36
movq (%r15), %r12
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4af8
movq %rax, %rdi
movq %r12, %rsi
callq 0x43e4
incl (%rbx)
movq (%r15), %r15
movq 0x38(%r15), %rdi
addq $0x38, %r15
testq %rdi, %rdi
jne 0x5c52
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq