LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_seguranca(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_seguranca(string nivel_seg_string, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)nivel_seg_string.size(); i++){
		c = nivel_seg_string[i];
		verificacao = isdigit(c);
		if(!verificacao || (nivel_seg_string != "0" && nivel_seg_string != "1" && nivel_seg_string != "2")){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;		
	}
	if(cont == (int) nivel_seg_string.size()){
		sucesso = 's';
		return 1;
	}
	else{
		cout << "ERRO: valor inválido 2!" << endl << endl;
		sucesso = 'n';
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x3f413
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x3220
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x3f3bc
movq -0x30(%rbp), %rdi
leaq 0x1eab(%rip), %rsi      # 0x41230
callq 0x13c60
testb $0x1, %al
jne 0x3f390
jmp 0x3f3fa
movq -0x30(%rbp), %rdi
leaq 0x1d66(%rip), %rsi      # 0x41101
callq 0x13c60
testb $0x1, %al
jne 0x3f3a6
jmp 0x3f3fa
movq -0x30(%rbp), %rdi
leaq 0x25f7(%rip), %rsi      # 0x419a8
callq 0x13c60
testb $0x1, %al
jne 0x3f3bc
jmp 0x3f3fa
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x11bee(%rip), %rdi     # 0x50fb8
leaq 0x3272(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x11bc0(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x11bb1(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x3f475
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f405
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3f339
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jne 0x3f439
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f475
movq 0x11b78(%rip), %rdi     # 0x50fb8
leaq 0x3243(%rip), %rsi      # 0x4268a
callq 0x3240
movq %rax, %rdi
movq 0x11b4a(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x11b3b(%rip), %rsi     # 0x50fa0
callq 0x3280
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_nome(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char&)
bool verifica_nome(string &nome, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(nome.begin(), nome.end(), nome.begin(), ::toupper); // Converte a string nome para caracteres maiúsculos.
	for(int i = 0; i < (int)nome.size(); i++){
		c = nome[i];
		verificacao = isalpha(c);
		if(!verificacao && c != ' '){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}
	if(cont == (int) nome.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x11b08(%rip), %rcx     # 0x50fe0
callq 0x1f5a0
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x50(%rbp), %eax
cmpl %ecx, %eax
jge 0x3f589
movq -0x10(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x3390
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x3f570
movsbl -0x21(%rbp), %eax
cmpl $0x20, %eax
je 0x3f570
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x11a78(%rip), %rdi     # 0x50fb8
leaq 0x30fc(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x11a4a(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x11a3b(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x3f5b3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f57b
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x3f4e8
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jne 0x3f5af
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f5b3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_nome_cient(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char&)
bool verifica_nome_cient(string &nome, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(nome.begin(), nome.end(), nome.begin(), ::toupper); // Converte a string nome para caracteres maiúsculos.
	for(int i = 0; i < (int)nome.size(); i++){
		c = nome[i];
		verificacao = isalpha(c);
		if(!verificacao && c != ' ' && c !='-'){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}
	if(cont == (int) nome.size()){
		transform(nome.begin(), nome.end(), nome.begin(), ::tolower);
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x119c5(%rip), %rcx     # 0x50fe0
callq 0x1f5a0
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jge 0x3f6d8
movq -0x10(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x3390
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x3f6bf
movsbl -0x21(%rbp), %eax
cmpl $0x20, %eax
je 0x3f6bf
movsbl -0x21(%rbp), %eax
cmpl $0x2d, %eax
je 0x3f6bf
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x1192c(%rip), %rdi     # 0x50fb8
leaq 0x2fb0(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x118fe(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x118ef(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x3f745
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f6ca
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x3f62b
movl -0x1c(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x78(%rbp), %eax
cmpl %ecx, %eax
jne 0x3f741
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x1189d(%rip), %rcx     # 0x50fc8
callq 0x1f5a0
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f745
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_CPF(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_CPF(string cpf_string, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)cpf_string.size(); i++){
		c = cpf_string[i];
		verificacao = isdigit(c);
		if(!verificacao){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}

	if(cont == (int) cpf_string.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x3f81d
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x3220
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x3f804
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x117e4(%rip), %rdi     # 0x50fb8
leaq 0x2e68(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x117b6(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x117a7(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x3f847
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f80f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3f789
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jne 0x3f843
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f847
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_idade(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_idade(string idade_string, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)idade_string.size(); i++){
		c = idade_string[i];
		verificacao = isdigit(c);
		if(!verificacao){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;
	}

	if(cont == (int) idade_string.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x3f91d
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x3220
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x3f904
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x116e4(%rip), %rdi     # 0x50fb8
leaq 0x2d68(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x116b6(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x116a7(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x3f947
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f90f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3f889
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jne 0x3f943
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f947
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_inteiro(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_inteiro(string total_mudas_string, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)total_mudas_string.size(); i++){
		c = total_mudas_string[i];
		verificacao = isdigit(c);
		if(!verificacao){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}

	if(cont == (int) total_mudas_string.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x3fa1d
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x3220
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x3fa04
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x115e4(%rip), %rdi     # 0x50fb8
leaq 0x2c68(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x115b6(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x115a7(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x3fa47
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3fa0f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3f989
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jne 0x3fa43
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3fa47
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_tipo_sang(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char&)
bool verifica_tipo_sang(string &tipo_sang_string, char &sucesso){
	int cont = 0, cont_sangue = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(tipo_sang_string.begin(), tipo_sang_string.end(), tipo_sang_string.begin(), ::toupper); // Converte a string nome para caracteres maiúsculos.
	for(int i = 0; i < (int)tipo_sang_string.size(); i++){
		c = tipo_sang_string[i];
		verificacao = isalpha(c);
		cont_sangue++;
		if(!verificacao || cont_sangue > 2 || (tipo_sang_string != "O" && tipo_sang_string != "AB" && tipo_sang_string != "B" && tipo_sang_string != "A")){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;
	}

	if(cont == (int)tipo_sang_string.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x11521(%rip), %rcx     # 0x50fe0
callq 0x1f5a0
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x50(%rbp), %eax
cmpl %ecx, %eax
jge 0x3fbd1
movq -0x10(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %edi
callq 0x3390
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3fb7a
cmpl $0x2, -0x20(%rbp)
jg 0x3fb7a
movq -0x10(%rbp), %rdi
leaq 0x26fb(%rip), %rsi      # 0x42225
callq 0x13c60
testb $0x1, %al
jne 0x3fb38
jmp 0x3fbb8
movq -0x10(%rbp), %rdi
leaq 0x2b60(%rip), %rsi      # 0x426a3
callq 0x13c60
testb $0x1, %al
jne 0x3fb4e
jmp 0x3fbb8
movq -0x10(%rbp), %rdi
leaq 0x2b4b(%rip), %rsi      # 0x426a4
callq 0x13c60
testb $0x1, %al
jne 0x3fb64
jmp 0x3fbb8
movq -0x10(%rbp), %rdi
leaq 0x25b0(%rip), %rsi      # 0x4211f
callq 0x13c60
testb $0x1, %al
jne 0x3fb7a
jmp 0x3fbb8
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x11430(%rip), %rdi     # 0x50fb8
leaq 0x2ab4(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x11402(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x113f3(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x3fbfb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3fbc3
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x3facf
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jne 0x3fbf7
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3fbfb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_fator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_fator(string fator_rh_string, char &sucesso){
	int cont = 0, cont_carac = 0;
	char c;
	sucesso = 'n';

	for(int i = 0; i < (int) fator_rh_string.size(); i++){
		c = fator_rh_string[i];
		cont_carac++;
		if((c != '-' && c != '+') || cont_carac > 1){
			cont--;
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}

	if(cont == (int)fator_rh_string.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x3fcf0
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x2d, %eax
je 0x3fc8a
movsbl -0x21(%rbp), %eax
cmpl $0x2b, %eax
jne 0x3fc90
cmpl $0x1, -0x20(%rbp)
jle 0x3fcd7
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x11311(%rip), %rdi     # 0x50fb8
leaq 0x2995(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x112e3(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x112d4(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x3fd1a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3fce2
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3fc40
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jne 0x3fd16
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3fd1a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_especialidade(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_especialidade(string especialidade, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(especialidade.begin(), especialidade.end(), especialidade.begin(), ::toupper);
	for(int i = 0; i < (int) especialidade.size(); i++){
		c = especialidade[i];
		verificacao = isalpha(c);
		if(!verificacao && c != ' '){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}

	if(cont == (int)especialidade.size()){
		sucesso = 's';
		return 1;
	}
	else{
		sucesso = 'n';
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
callq 0x31e0
movq -0x58(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x3120
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x31e0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x11258(%rip), %rcx     # 0x50fe0
callq 0x1f5a0
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x58(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, -0x5c(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jge 0x3fe39
movq -0x58(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x3390
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x3fe20
movsbl -0x21(%rbp), %eax
cmpl $0x20, %eax
je 0x3fe20
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x111c8(%rip), %rdi     # 0x50fb8
leaq 0x284c(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x1119a(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x1118b(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x3fe6a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3fe2b
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x3fd98
movq -0x58(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x60(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x60(%rbp), %eax
cmpl %ecx, %eax
jne 0x3fe5f
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3fe6a
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_dieta(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char&)
bool verifica_dieta(string &dieta, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(dieta.begin(), dieta.end(), dieta.begin(), ::toupper); // Converte a string nome para caracteres maiúsculos.
	for(int i = 0; i < (int)dieta.size(); i++){
		c = dieta[i];
		verificacao = isalpha(c);
		if(!verificacao && c != ' ' && c != ','){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;
		
	}
	if(cont == (int) dieta.size()){
		transform(dieta.begin(), dieta.end(), dieta.begin(), ::tolower);
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x10e15(%rip), %rcx     # 0x50fe0
callq 0x1f5a0
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jge 0x40288
movq -0x10(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x3390
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x4026f
movsbl -0x21(%rbp), %eax
cmpl $0x20, %eax
je 0x4026f
movsbl -0x21(%rbp), %eax
cmpl $0x2c, %eax
je 0x4026f
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x10d7c(%rip), %rdi     # 0x50fb8
leaq 0x2400(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x10d4e(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x10d3f(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x402f5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4027a
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x401db
movl -0x1c(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x78(%rbp), %eax
cmpl %ecx, %eax
jne 0x402f1
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x10ced(%rip), %rcx     # 0x50fc8
callq 0x1f5a0
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x402f5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_tamanho(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_tamanho(string tamanho_string, char &sucesso){
	int cont = 0, cont_ponto = 0, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)tamanho_string.size(); i++){
		c = tamanho_string[i];
		verificacao = isdigit(c);
		if(c == '.'){
			cont_ponto++;
		}
		if(!verificacao && c != '.'){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;
		
	}
	if(cont == (int) tamanho_string.size() && cont_ponto == 1){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x403f3
movq -0x38(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %edi
callq 0x3220
movl %eax, -0x24(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x2e, %eax
jne 0x4038d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x403da
movsbl -0x25(%rbp), %eax
cmpl $0x2e, %eax
je 0x403da
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x10c0e(%rip), %rdi     # 0x50fb8
leaq 0x2292(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x10be0(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x10bd1(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x40423
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x403e5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x40340
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jne 0x4041f
cmpl $0x1, -0x20(%rbp)
jne 0x4041f
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x40423
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_data(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_data(string ultima_muda, char &sucesso){
	int cont = 0, cont_traco = 0, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)ultima_muda.size(); i++){
		c = ultima_muda[i];
		verificacao = isdigit(c);
		if(c == '-'){
			cont_traco++;
		}
		if(!verificacao && c != '-'){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;
		
	}
	if(cont == (int) ultima_muda.size() && cont_traco == 2){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x40513
movq -0x38(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %edi
callq 0x3220
movl %eax, -0x24(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x2d, %eax
jne 0x404ad
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x404fa
movsbl -0x25(%rbp), %eax
cmpl $0x2d, %eax
je 0x404fa
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x10aee(%rip), %rdi     # 0x50fb8
leaq 0x2172(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x10ac0(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x10ab1(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x40543
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40505
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x40460
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jne 0x4053f
cmpl $0x2, -0x20(%rbp)
jne 0x4053f
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x40543
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_autorizacao(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char&)
bool verifica_autorizacao(string &autorizacao, char &sucesso){
	int cont = 0, cont_traco = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(autorizacao.begin(), autorizacao.end(), autorizacao.begin(), ::toupper); // Converte a string nome para caracteres maiúsculos.
	for(int i = 0; i < (int)autorizacao.size(); i++){
		c = autorizacao[i];
		verificacao = isalnum(c);
		if(c == '-'){
			cont_traco++;
		}
		if(!verificacao && c != '-'){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;
		
	}
	if(cont == (int) autorizacao.size() && cont_traco == 1){
		transform(autorizacao.begin(), autorizacao.end(), autorizacao.begin(), ::tolower); // Converte a string autorizacao para valores minusculos.
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x10a2e(%rip), %rcx     # 0x50fe0
callq 0x1f5a0
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jge 0x40678
movq -0x10(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %edi
callq 0x3260
movl %eax, -0x24(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x2d, %eax
jne 0x4060f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x4065f
movsbl -0x25(%rbp), %eax
cmpl $0x2d, %eax
je 0x4065f
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x1098c(%rip), %rdi     # 0x50fb8
leaq 0x2010(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x1095e(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x1094f(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x406eb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4066a
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x405c2
movl -0x1c(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x78(%rbp), %eax
cmpl %ecx, %eax
jne 0x406e7
cmpl $0x1, -0x20(%rbp)
jne 0x406e7
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x108f7(%rip), %rcx     # 0x50fc8
callq 0x1f5a0
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x406eb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_origem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char&)
bool verifica_origem(string &origem, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(origem.begin(), origem.end(), origem.begin(), ::toupper); // Converte a string nome para caracteres maiúsculos.
	for(int i = 0; i < (int)origem.size(); i++){
		c = origem[i];
		verificacao = isalpha(c);
		if(!verificacao && c != ' '){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;
		
	}
	if(cont == (int) origem.size()){
		transform(origem.begin(), origem.end(), origem.begin(), ::tolower);
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x10885(%rip), %rcx     # 0x50fe0
callq 0x1f5a0
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jge 0x4080f
movq -0x10(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x3390
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x407f6
movsbl -0x21(%rbp), %eax
cmpl $0x20, %eax
je 0x407f6
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x107f5(%rip), %rdi     # 0x50fb8
leaq 0x1e79(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x107c7(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x107b8(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x4087c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40801
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x4076b
movl -0x1c(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x78(%rbp), %eax
cmpl %ecx, %eax
jne 0x40878
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x10766(%rip), %rcx     # 0x50fc8
callq 0x1f5a0
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4087c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_cor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char&)
bool verifica_cor(string &cor, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(cor.begin(), cor.end(), cor.begin(), ::toupper); // Converte a string cor para caracteres maiúsculos.
	for(int i = 0; i < (int)cor.size(); i++){
		c = cor[i];
		verificacao = isalpha(c);
		if(!verificacao && c != ' ' && c != '-'){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}
	if(cont == (int) cor.size()){
		transform(cor.begin(), cor.end(), cor.begin(), ::tolower); // Converte a string cor paara caracteres minusculos.
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x106f5(%rip), %rcx     # 0x50fe0
callq 0x1f5a0
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jge 0x409a8
movq -0x10(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x3390
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x4098f
movsbl -0x21(%rbp), %eax
cmpl $0x20, %eax
je 0x4098f
movsbl -0x21(%rbp), %eax
cmpl $0x2d, %eax
je 0x4098f
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x1065c(%rip), %rdi     # 0x50fb8
leaq 0x1ce0(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x1062e(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x1061f(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x40a15
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4099a
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x408fb
movl -0x1c(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movl -0x78(%rbp), %eax
cmpl %ecx, %eax
jne 0x40a11
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x105cd(%rip), %rcx     # 0x50fc8
callq 0x1f5a0
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x40a15
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_venenoso(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_venenoso(string venenoso, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)venenoso.size(); i++){
		c = venenoso[i];
		verificacao = isdigit(c);
		if(!verificacao || (venenoso != "0" && venenoso != "1")){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;		
	}
	if(cont == (int) venenoso.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x40b1d
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3430
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x3220
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x40ac6
movq -0x30(%rbp), %rdi
leaq 0x78b(%rip), %rsi       # 0x41230
callq 0x13c60
testb $0x1, %al
jne 0x40ab0
jmp 0x40b04
movq -0x30(%rbp), %rdi
leaq 0x646(%rip), %rsi       # 0x41101
callq 0x13c60
testb $0x1, %al
jne 0x40ac6
jmp 0x40b04
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movq 0x104e4(%rip), %rdi     # 0x50fb8
leaq 0x1b68(%rip), %rsi      # 0x42643
callq 0x3240
movq %rax, %rdi
movq 0x104b6(%rip), %rsi     # 0x50fa0
callq 0x3280
movq %rax, %rdi
movq 0x104a7(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x40b47
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40b0f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x40a59
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0x31a0
movq %rax, %rcx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jne 0x40b43
movq -0x18(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x40b47
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: Neuromancer2701[P]OpenTool/src/OpenTool.cpp
// Function: OpenTool::OpenTool()
OpenTool::OpenTool()
{
	ip_address = "";
	port = 0;

	timeout = 0;
	retries = 0;

	openToolHeader.SpindleID = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq 0xcc6a(%rip), %rax      # 0x17f18
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x30(%rbp)
callq 0xab90
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x20(%rbp)
callq 0xa570
jmp 0xb2d5
movq -0x28(%rbp), %rdi
addq $0x378, %rdi            # imm = 0x378
movq %rdi, -0x68(%rbp)
callq 0xae80
movq -0x28(%rbp), %rdi
addq $0x398, %rdi            # imm = 0x398
movq %rdi, -0x60(%rbp)
callq 0xae80
movq -0x28(%rbp), %rdi
addq $0x3b8, %rdi            # imm = 0x3B8
movq %rdi, -0x58(%rbp)
callq 0xae80
movq -0x28(%rbp), %rdi
addq $0x3d8, %rdi            # imm = 0x3D8
movq %rdi, -0x50(%rbp)
callq 0xae80
movq -0x28(%rbp), %rdi
addq $0x3f8, %rdi            # imm = 0x3F8
movq %rdi, -0x48(%rbp)
callq 0xae80
movq -0x28(%rbp), %rdi
addq $0x418, %rdi            # imm = 0x418
movq %rdi, -0x40(%rbp)
callq 0xae80
movq -0x28(%rbp), %rdi
addq $0x438, %rdi            # imm = 0x438
movq %rdi, -0x38(%rbp)
callq 0xa700
jmp 0xb363
movq -0x28(%rbp), %rdi
addq $0x478, %rdi            # imm = 0x478
movq %rdi, -0x70(%rbp)
callq 0xa040
jmp 0xb379
movq -0x28(%rbp), %rdi
addq $0x898, %rdi            # imm = 0x898
callq 0xafe0
jmp 0xb38b
movq -0x28(%rbp), %rdi
addq $0x8a8, %rdi            # imm = 0x8A8
movq %rdi, -0x78(%rbp)
callq 0xa2d0
jmp 0xb3a1
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7efd(%rip), %rsi      # 0x132ad
callq 0xab00
jmp 0xb3b7
movq -0x28(%rbp), %rax
movl $0x0, 0x30(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rax)
movl $0x0, 0x40(%rax)
movl $0x0, 0x374(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xb485
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xb446
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xb43d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xb434
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xae50
movq -0x70(%rbp), %rdi
callq 0xa080
movq -0x38(%rbp), %rdi
callq 0xa170
movq -0x40(%rbp), %rdi
callq 0xa420
movq -0x48(%rbp), %rdi
callq 0xa420
movq -0x50(%rbp), %rdi
callq 0xa420
movq -0x58(%rbp), %rdi
callq 0xa420
movq -0x60(%rbp), %rdi
callq 0xa420
movq -0x68(%rbp), %rdi
callq 0xa420
movq -0x20(%rbp), %rdi
callq 0xa7e0
movq -0x30(%rbp), %rdi
callq 0xa540
movq -0x10(%rbp), %rdi
callq 0xae90
nopw (%rax,%rax)
// File: Neuromancer2701[P]OpenTool/src/OpenTool.cpp
// Function: OpenTool::Connect()
Error OpenTool::Connect()
{
	 Error result = Error::UNKNOWN;
	 client.init(ip_address,port);

	 if(client.Connect() == Connection_Status::CONNECTED)
	 {
		 openToolHeader.Number = MID_Number::CommunicationStart;
		 MIDOutputAction(&openToolHeader);
	 }

	 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movl $0x0, -0xc(%rbp)
movq %rsi, %rax
addq $0x438, %rax            # imm = 0x438
movq %rax, -0x50(%rbp)
addq $0x10, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xa380
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movzwl 0x30(%rax), %edx
callq 0xa7d0
jmp 0xb940
leaq -0x30(%rbp), %rdi
callq 0xa540
movq -0x58(%rbp), %rdi
addq $0x438, %rdi            # imm = 0x438
callq 0xadd0
cmpl $0x1, %eax
jne 0xb991
movq -0x58(%rbp), %rdi
movl $0x1, 0x364(%rdi)
movq %rdi, %rsi
addq $0x48, %rsi
callq 0xaa50
jmp 0xb991
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa540
jmp 0xb99a
movl -0xc(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xae90
nopw %cs:(%rax,%rax)
// File: Neuromancer2701[P]OpenTool/src/OpenTool.cpp
// Function: OpenTool::Disconnect()
Error OpenTool::Disconnect()
{
	 Error result = Error::UNKNOWN;

	 client.Disconnect();
	 if(client.Status() == Connection_Status::DISCONNECTED)
		 result = Error::NONE;
	 else
		 result = Error::DISCONNECT;

	 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
addq $0x438, %rdi            # imm = 0x438
callq 0xaf60
movq -0x18(%rbp), %rdi
addq $0x438, %rdi            # imm = 0x438
callq 0xaf30
cmpl $-0x1, %eax
jne 0xc295
movl $0x2, -0xc(%rbp)
jmp 0xc29c
movl $0x13, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Neuromancer2701[P]OpenTool/src/OpenTool.cpp
// Function: OpenTool::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Error OpenTool::Send(string data)
{
	 Error result = Error::UNKNOWN;
	 vector<char>  buffer(data.begin(), data.end());
	 result = client.Write(buffer);

	 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, %rax
movq -0x90(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x14(%rbp)
callq 0xa780
movq -0x80(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0xa500
movq %rax, -0x40(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xaea0
movq -0x78(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xa3c0
jmp 0xc374
leaq -0x41(%rbp), %rdi
callq 0xa920
movq -0x88(%rbp), %rax
addq $0x438, %rax            # imm = 0x438
movq %rax, -0x98(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xab10
jmp 0xc3a0
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xac30
movl %eax, -0x9c(%rbp)
jmp 0xc3b8
movl -0x9c(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa690
movl -0x14(%rbp), %eax
movl %eax, -0xa0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa690
movl -0xa0(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0xa920
jmp 0xc42e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xc425
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa690
leaq -0x30(%rbp), %rdi
callq 0xa690
movq -0x50(%rbp), %rdi
callq 0xae90
nopw (%rax,%rax)
// File: Neuromancer2701[P]OpenTool/src/OpenTool.cpp
// Function: OpenTool::isTimedOut()
bool OpenTool::isTimedOut()
{
	bool timed_out = false;
	std::chrono::time_point<std::chrono::system_clock> current_time;

	if(timer_count != -1)//Server side
	{
		if(keep_alive_timer.GetCount() > timer_count)
		{
			SendKeepAlive();
			timer_count = keep_alive_timer.GetCount();
			timed_out =  false;
		}
	}
	else //Client
	{
		current_time = std::chrono::system_clock::now();

		std::chrono::duration<double> seconds = current_time - lastSentTime;

		if(seconds.count() > timeout)
			timed_out = true;
	}

	return timed_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xafe0
movq -0x38(%rbp), %rax
cmpl $-0x1, 0x8a0(%rax)
je 0xc4b5
movq -0x38(%rbp), %rdi
addq $0x8a8, %rdi            # imm = 0x8A8
callq 0xa280
movq -0x38(%rbp), %rcx
cmpl 0x8a0(%rcx), %eax
jle 0xc4b3
movq -0x38(%rbp), %rdi
callq 0xa550
movq -0x38(%rbp), %rdi
addq $0x8a8, %rdi            # imm = 0x8A8
callq 0xa280
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8a0(%rax)
movb $0x0, -0x9(%rbp)
jmp 0xc505
callq 0xa090
movq -0x38(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x898, %rsi            # imm = 0x898
leaq -0x18(%rbp), %rdi
callq 0xa520
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xabf0
leaq -0x28(%rbp), %rdi
callq 0xa460
movq -0x38(%rbp), %rax
ucomisd 0x38(%rax), %xmm0
jbe 0xc503
movb $0x1, -0x9(%rbp)
jmp 0xc505
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq