LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rax
testl %eax, %eax
jle 0x385d6
movq (%rdi), %rcx
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
movsbl (%rcx,%r8), %r9d
addl $-0x30, %r9d
cmpl $0xa, %r9d
jae 0x385e4
incq %r8
cmpq %r8, %rdx
jne 0x385bd
jmp 0x385d8
xorl %eax, %eax
cmpl 0x8(%rdi), %eax
jne 0x38653
movb $0x73, (%rsi)
movb $0x1, %al
jmp 0x38655
movb $0x6e, (%rsi)
movq 0xf9e2(%rip), %rbx      # 0x47fd0
leaq 0x308e(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rax
testl %eax, %eax
jle 0x38694
movq (%rdi), %rcx
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
movsbl (%rcx,%r8), %r9d
addl $-0x30, %r9d
cmpl $0xa, %r9d
jae 0x386a2
incq %r8
cmpq %r8, %rdx
jne 0x3867b
jmp 0x38696
xorl %eax, %eax
cmpl 0x8(%rdi), %eax
jne 0x38711
movb $0x73, (%rsi)
movb $0x1, %al
jmp 0x38713
movb $0x6e, (%rsi)
movq 0xf924(%rip), %rbx      # 0x47fd0
leaq 0x2fd0(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rax
testl %eax, %eax
jle 0x38752
movq (%rdi), %rcx
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
movsbl (%rcx,%r8), %r9d
addl $-0x30, %r9d
cmpl $0xa, %r9d
jae 0x38760
incq %r8
cmpq %r8, %rdx
jne 0x38739
jmp 0x38754
xorl %eax, %eax
cmpl 0x8(%rdi), %eax
jne 0x387cf
movb $0x73, (%rsi)
movb $0x1, %al
jmp 0x387d1
movb $0x6e, (%rsi)
movq 0xf866(%rip), %rbx      # 0x47fd0
leaq 0x2f12(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %r14
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x38814
movq (%r14), %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
callq 0x33d0
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %rbx
jne 0x387fe
cmpl $0x0, 0x8(%r14)
jle 0x388a3
movq %r13, -0x30(%rbp)
xorl %ebx, %ebx
leaq 0x2a39(%rip), %r15      # 0x3b265
leaq 0x2eb0(%rip), %r12      # 0x3b6e3
leaq 0x2eaa(%rip), %r13      # 0x3b6e4
movq (%r14), %rax
movsbl (%rax,%rbx), %edi
callq 0x3320
testl %eax, %eax
je 0x388b4
movl %ebx, %eax
andl $-0x2, %eax
jne 0x388b4
movq %r14, %rdi
movq %r15, %rsi
callq 0x30c0
testl %eax, %eax
je 0x38891
movq %r14, %rdi
movq %r12, %rsi
callq 0x30c0
testl %eax, %eax
je 0x38891
movq %r14, %rdi
movq %r13, %rsi
callq 0x30c0
testl %eax, %eax
je 0x38891
movq %r14, %rdi
leaq 0x28d7(%rip), %rsi      # 0x3b15f
callq 0x30c0
testl %eax, %eax
jne 0x388b4
incq %rbx
movslq 0x8(%r14), %rax
cmpq %rax, %rbx
jl 0x3883a
movq -0x30(%rbp), %r13
jmp 0x388a5
xorl %ebx, %ebx
cmpl 0x8(%r14), %ebx
jne 0x38927
movb $0x73, (%r13)
movb $0x1, %al
jmp 0x38929
movq -0x30(%rbp), %rax
movb $0x6e, (%rax)
movq 0xf70e(%rip), %rbx      # 0x47fd0
leaq 0x2dba(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rax
testl %eax, %eax
setg %r12b
jle 0x38a02
movq (%r14), %rcx
movzbl (%rcx), %ecx
cmpl $0x2b, %ecx
je 0x38975
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
cmpl $0x2d, %ecx
jne 0x3898e
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
testl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
setne %r12b
xorl %r13d, %r13d
cmpl $0x1, %ecx
je 0x38a04
movb $0x6e, (%rbx)
movq 0xf638(%rip), %r15      # 0x47fd0
leaq 0x2ce4(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %r15, %rdi
callq 0x3250
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movl %r13d, %eax
jmp 0x38a04
xorl %eax, %eax
testb %r12b, %r12b
jne 0x38a16
cmpl 0x8(%r14), %eax
jne 0x38a16
movb $0x73, (%rbx)
movb $0x1, %al
jmp 0x38a18
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r13
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x38a67
movq (%r13), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x33d0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x38a51
movq 0x8(%r13), %rbx
testl %ebx, %ebx
jle 0x38ab2
movq %r12, -0x30(%rbp)
movq %r13, -0x38(%rbp)
movq (%r13), %r13
movl %ebx, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movsbl (%r13,%r14), %r15d
movl %r15d, %edi
callq 0x3320
cmpl $0x20, %r15d
je 0x38aa0
testl %eax, %eax
je 0x38aca
incq %r14
cmpq %r14, %r12
jne 0x38a88
movq -0x30(%rbp), %r12
movq -0x38(%rbp), %r13
jmp 0x38ab4
xorl %ebx, %ebx
cmpl 0x8(%r13), %ebx
jne 0x38ac3
movb $0x73, (%r12)
movb $0x1, %al
jmp 0x38b3f
movb $0x6e, (%r12)
jmp 0x38b3d
movq -0x30(%rbp), %rax
movb $0x6e, (%rax)
movq 0xf4f8(%rip), %rbx      # 0x47fd0
leaq 0x2ba4(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r13
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x38e38
movq (%r13), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x33d0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x38e22
movq 0x8(%r13), %rbx
testl %ebx, %ebx
jle 0x38e8b
movq %r12, -0x30(%rbp)
movq %r13, -0x38(%rbp)
movq (%r13), %r13
movl %ebx, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movsbl (%r13,%r14), %r15d
movl %r15d, %edi
callq 0x3320
testl %eax, %eax
jne 0x38e79
movzbl %r15b, %eax
cmpl $0x20, %eax
je 0x38e79
cmpl $0x2c, %eax
jne 0x38ec5
incq %r14
cmpq %r14, %r12
jne 0x38e59
movq -0x30(%rbp), %r12
movq -0x38(%rbp), %r13
jmp 0x38e8d
xorl %ebx, %ebx
movq 0x8(%r13), %r14
cmpl %r14d, %ebx
jne 0x38f38
testq %r14, %r14
je 0x38ebc
movq (%r13), %rbx
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0x32c0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x38ea6
movb $0x73, (%r12)
movb $0x1, %al
jmp 0x38f3a
movq -0x30(%rbp), %rax
movb $0x6e, (%rax)
movq 0xf0fd(%rip), %rbx      # 0x47fd0
leaq 0x27a9(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rcx
testl %ecx, %ecx
setg %bl
movq %rsi, -0x30(%rbp)
jle 0x3904c
movq (%r14), %rax
movsbl (%rax), %edx
xorl %r12d, %r12d
cmpl $0x2e, %edx
setne %dil
sete %r12b
addl $-0x3a, %edx
cmpl $-0xa, %edx
setb %dl
xorl %r13d, %r13d
testb %dl, %dil
jne 0x38fd8
movl %ecx, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
leaq -0x1(%rdx), %r9
xorl %r13d, %r13d
cmpq %r13, %r9
je 0x39053
movsbl 0x1(%rax,%r13), %edi
xorl %r8d, %r8d
cmpl $0x2e, %edi
sete %r8b
addl $-0x3a, %edi
cmpl $-0xa, %edi
setae %dil
addl %r8d, %r12d
incq %r13
orb %dil, %r8b
jne 0x38fa4
cmpq %rdx, %r13
setb %bl
movb $0x6e, (%rsi)
movq 0xefee(%rip), %r15      # 0x47fd0
leaq 0x269a(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %r15, %rdi
callq 0x3250
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movl %r13d, %ecx
jmp 0x3905c
xorl %ecx, %ecx
xorl %r12d, %r12d
jmp 0x3905c
incq %r13
cmpq %rdx, %r13
setb %bl
xorl %eax, %eax
testb %bl, %bl
jne 0x39077
cmpl 0x8(%r14), %ecx
jne 0x39077
cmpl $0x1, %r12d
jne 0x39077
movq -0x30(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rcx
testl %ecx, %ecx
setg %bl
movq %rsi, -0x30(%rbp)
jle 0x39189
movq (%r14), %rax
movsbl (%rax), %edx
xorl %r12d, %r12d
cmpl $0x2d, %edx
setne %dil
sete %r12b
addl $-0x3a, %edx
cmpl $-0xa, %edx
setb %dl
xorl %r13d, %r13d
testb %dl, %dil
jne 0x39115
movl %ecx, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
leaq -0x1(%rdx), %r9
xorl %r13d, %r13d
cmpq %r13, %r9
je 0x39190
movsbl 0x1(%rax,%r13), %edi
xorl %r8d, %r8d
cmpl $0x2d, %edi
sete %r8b
addl $-0x3a, %edi
cmpl $-0xa, %edi
setae %dil
addl %r8d, %r12d
incq %r13
orb %dil, %r8b
jne 0x390e1
cmpq %rdx, %r13
setb %bl
movb $0x6e, (%rsi)
movq 0xeeb1(%rip), %r15      # 0x47fd0
leaq 0x255d(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %r15, %rdi
callq 0x3250
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movl %r13d, %ecx
jmp 0x39199
xorl %ecx, %ecx
xorl %r12d, %r12d
jmp 0x39199
incq %r13
cmpq %rdx, %r13
setb %bl
xorl %eax, %eax
testb %bl, %bl
jne 0x391b4
cmpl 0x8(%r14), %ecx
jne 0x391b4
cmpl $0x2, %r12d
jne 0x391b4
movq -0x30(%rbp), %rax
movb $0x73, (%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r13
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x393c9
movq (%r13), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x33d0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x393b3
movq 0x8(%r13), %rbx
testl %ebx, %ebx
jle 0x39414
movq %r12, -0x30(%rbp)
movq %r13, -0x38(%rbp)
movq (%r13), %r13
movl %ebx, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movsbl (%r13,%r14), %r15d
movl %r15d, %edi
callq 0x3320
cmpl $0x20, %r15d
je 0x39402
testl %eax, %eax
je 0x3944e
incq %r14
cmpq %r14, %r12
jne 0x393ea
movq -0x30(%rbp), %r12
movq -0x38(%rbp), %r13
jmp 0x39416
xorl %ebx, %ebx
movq 0x8(%r13), %r15
cmpl %r15d, %ebx
jne 0x394c1
testq %r15, %r15
je 0x39445
movq (%r13), %rbx
xorl %r14d, %r14d
movsbl (%rbx,%r14), %edi
callq 0x32c0
movb %al, (%rbx,%r14)
incq %r14
cmpq %r14, %r15
jne 0x3942f
movb $0x73, (%r12)
movb $0x1, %al
jmp 0x394c3
movq -0x30(%rbp), %rax
movb $0x6e, (%rax)
movq 0xeb74(%rip), %rbx      # 0x47fd0
leaq 0x2220(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r13
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x39512
movq (%r13), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x33d0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x394fc
movq 0x8(%r13), %rbx
testl %ebx, %ebx
jle 0x39565
movq %r12, -0x30(%rbp)
movq %r13, -0x38(%rbp)
movq (%r13), %r13
movl %ebx, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movsbl (%r13,%r14), %r15d
movl %r15d, %edi
callq 0x3320
testl %eax, %eax
jne 0x39553
movzbl %r15b, %eax
cmpl $0x20, %eax
je 0x39553
cmpl $0x2d, %eax
jne 0x3959f
incq %r14
cmpq %r14, %r12
jne 0x39533
movq -0x30(%rbp), %r12
movq -0x38(%rbp), %r13
jmp 0x39567
xorl %ebx, %ebx
movq 0x8(%r13), %r14
cmpl %r14d, %ebx
jne 0x39612
testq %r14, %r14
je 0x39596
movq (%r13), %rbx
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0x32c0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x39580
movb $0x73, (%r12)
movb $0x1, %al
jmp 0x39614
movq -0x30(%rbp), %rax
movb $0x6e, (%rax)
movq 0xea23(%rip), %rbx      # 0x47fd0
leaq 0x20cf(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x6e, (%rsi)
cmpl $0x0, 0x8(%rdi)
jle 0x39702
xorl %r13d, %r13d
leaq 0xbfa(%rip), %r15       # 0x3a248
leaq 0xac4(%rip), %r12       # 0x3a119
movq (%r14), %rax
movsbl (%rax,%r13), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x39691
movq %r14, %rdi
movq %r15, %rsi
callq 0x30c0
testl %eax, %eax
je 0x39683
movq %r14, %rdi
movq %r12, %rsi
callq 0x30c0
testl %eax, %eax
jne 0x39691
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0x39655
jmp 0x39705
movb $0x6e, (%rbx)
movq 0xe935(%rip), %rbx      # 0x47fd0
leaq 0x1fe1(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
jmp 0x39712
xorl %r13d, %r13d
cmpl 0x8(%r14), %r13d
jne 0x39712
movb $0x73, (%rbx)
movb $0x1, %al
jmp 0x39714
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movq 0x85e1(%rip), %rax      # 0xef18
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
leaq 0x48(%rdi), %rbx
movq %rbx, %rdi
movq %r14, -0x30(%rbp)
movq %r12, -0x48(%rbp)
callq 0x62b0
movq %rbx, -0x40(%rbp)
leaq 0x378(%r15), %rdi
leaq 0x438(%r15), %r13
movl $0xc0, %edx
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
callq 0x6250
movq %r13, %rdi
callq 0x6340
leaq 0x478(%r15), %rbx
movq %rbx, %rdi
callq 0x6040
movq $0x0, 0x898(%r15)
leaq 0x8a8(%r15), %r14
movq %r14, %rdi
callq 0x6160
movq 0x18(%r15), %rdx
leaq 0x493d(%rip), %rcx      # 0xb305
xorl %r12d, %r12d
movq -0x30(%rbp), %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x65a0
movl %r12d, 0x30(%r15)
movq $0x0, 0x38(%r15)
movl %r12d, 0x40(%r15)
movl %r12d, 0x374(%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r14, %rdi
callq 0x6660
jmp 0x6a0f
movq %rax, %r12
movq %rbx, %rdi
callq 0x6070
jmp 0x6a1c
movq %rax, %r12
movq %r13, %rdi
callq 0x60e0
jmp 0x6a29
movq %rax, %r12
movq 0x428(%r15), %rax
testq %rax, %rax
je 0x6a46
leaq 0x418(%r15), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x408(%r15), %rax
testq %rax, %rax
je 0x6a63
leaq 0x3f8(%r15), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x3e8(%r15), %rax
testq %rax, %rax
je 0x6a80
leaq 0x3d8(%r15), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x3c8(%r15), %rax
testq %rax, %rax
je 0x6a9d
leaq 0x3b8(%r15), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x3a8(%r15), %rax
testq %rax, %rax
je 0x6aba
leaq 0x398(%r15), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x388(%r15), %rax
testq %rax, %rax
je 0x6ad4
movq -0x38(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x40(%rbp), %rdi
callq 0x63c0
jmp 0x6af4
jmp 0x6ae9
jmp 0x6ae9
jmp 0x6ae9
jmp 0x6ae9
jmp 0x6ae9
movq %rax, %rdi
callq 0x7b16
movq %rax, %r12
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x48(%rbp), %rdi
je 0x6b06
callq 0x63e0
movq %r12, %rdi
callq 0x6680
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x438(%rdi), %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x61c0
movzwl 0x30(%rbx), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x63b0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6f22
callq 0x63e0
movq %r14, %rdi
callq 0x6630
cmpl $0x1, %eax
jne 0x6f45
leaq 0x48(%rbx), %rsi
movl $0x1, 0x364(%rbx)
movq %rbx, %rdi
callq 0x64d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6f65
callq 0x63e0
movq %rbx, %rdi
callq 0x6680
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x58(%rbp), %r15
leaq -0x19(%rbp), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq 0x61f0
movq 0x8(%r15), %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
subq (%r15), %r14
je 0x7520
js 0x758f
movq %r14, %rdi
callq 0x6410
movq %rax, %r15
jmp 0x7523
xorl %r15d, %r15d
movq %r15, -0x40(%rbp)
movq %r15, -0x38(%rbp)
addq %r15, %r14
movq %r14, -0x30(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %r14
subq %rsi, %r14
je 0x754a
movq %r15, %rdi
movq %r14, %rdx
callq 0x6600
addq %r14, %r15
leaq -0x40(%rbp), %rsi
movq %r15, 0x8(%rsi)
addq $0x438, %rbx            # imm = 0x438
movq %rbx, %rdi
callq 0x6570
movl %eax, %ebx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x7574
callq 0x63e0
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x7582
callq 0x63e0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x6180
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x75aa
callq 0x63e0
jmp 0x75aa
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x75b8
callq 0x63e0
movq %rbx, %rdi
callq 0x6680
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8a0(%rdi), %eax
cmpl $-0x1, %eax
je 0x760d
movl 0xa38(%rbx), %ecx
cmpl %eax, %ecx
jle 0x7609
cmpl $0x1, 0x440(%rbx)
jne 0x75fd
leaq 0x48(%rbx), %rsi
movl $0x270f, 0x364(%rbx)    # imm = 0x270F
movq %rbx, %rdi
callq 0x64d0
movl 0xa38(%rbx), %eax
movl %eax, 0x8a0(%rbx)
xorl %eax, %eax
jmp 0x762e
callq 0x6080
subq 0x898(%rbx), %rax
cvtsi2sd %rax, %xmm0
divsd 0x3a12(%rip), %xmm0     # 0xb038
ucomisd 0x38(%rbx), %xmm0
seta %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Neuromancer2701[P]OpenTool/src/Header.cpp
// Function: Header::Unpack()
void Header::Unpack()	{

	InputStream >> std::setw(Length_Size)	>> Length;

	InputStream >> std::setw(Number_Size)	>> Number;

	InputStream >> std::setw(Revision_Size) >> Revision;

	InputStream >> std::setw(NoAckFlag_Size) >> NoAckFlag;

	InputStream >> std::setw(StationID_Size) >> StationID;

	InputStream >> std::setw(SpindleID_Size) >> SpindleID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %rax
movq -0x18(%rax), %rax
movl $0x4, %r15d
movq %r15, 0x18(%rdi,%rax)
leaq 0x318(%rdi), %rsi
movq %r14, %rdi
callq 0x6290
movq 0x8(%rbx), %rax
movq -0x18(%rax), %rax
movq %r15, 0x18(%rbx,%rax)
leaq -0x1c(%rbp), %rsi
movl $0x0, (%rsi)
movq %r14, %rdi
callq 0x6670
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x805d
movl -0x1c(%rbp), %eax
movl %eax, 0x31c(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r14,%rax)
leaq -0x20(%rbp), %rsi
movl $0x0, (%rsi)
movq %r14, %rdi
callq 0x6670
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x8096
movl -0x20(%rbp), %eax
movl %eax, 0x320(%rbx)
movq 0x8(%rbx), %rax
movq -0x18(%rax), %rax
movl $0x1, %r15d
movq %r15, 0x18(%rbx,%rax)
leaq 0x324(%rbx), %rsi
movq %r14, %rdi
callq 0x6380
movq 0x8(%rbx), %rax
movq -0x18(%rax), %rax
movq %r15, 0x18(%rbx,%rax)
leaq 0x328(%rbx), %rsi
movq %r14, %rdi
callq 0x6290
movq 0x8(%rbx), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x18(%rbx,%rax)
addq $0x32c, %rbx            # imm = 0x32C
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6290
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Neuromancer2701[P]OpenTool/src/Mid0002.cpp
// Function: Mid_0002::BuildRevision1()
void Mid_0002::BuildRevision1()
{
	OutputStream << std::setw(Index_size) << std::setfill('0') << 1;
	OutputStream << std::setw(Cell_Id_size) << std::setfill('0') << Cell_Id;
	OutputStream << std::setw(Index_size) << std::setfill('0') << 2;
	OutputStream << std::setw(Channel_Id_size) << std::setfill('0') << Channel_Id;
	OutputStream << std::setw(Index_size) << std::setfill('0') << 3;
	OutputStream << std::setw(Controller_Name_size) << std::setfill(' ') << Controller_Name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1a0(%rdi), %rbx
movq 0x1a0(%rdi), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x1b0(%rdi,%rcx)
movq -0x18(%rax), %rax
leaq (%rdi,%rax), %r15
addq $0x1a0, %r15            # imm = 0x1A0
cmpb $0x0, 0xe1(%r15)
jne 0x8424
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6640
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movq $0x4, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x8477
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movl 0x330(%r14), %esi
movq %rbx, %rdi
callq 0x6640
movq 0x1a0(%r14), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x1b0(%r14,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
cmpb $0x0, 0x281(%r14,%rax)
jne 0x84d4
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6640
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x8527
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movl 0x334(%r14), %esi
movq %rbx, %rdi
callq 0x6640
movq 0x1a0(%r14), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x1b0(%r14,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
cmpb $0x0, 0x281(%r14,%rax)
jne 0x8584
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6640
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movq $0x19, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x85d7
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x20, 0xe0(%r15)
movq 0x338(%r14), %rsi
movq 0x340(%r14), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O1/Neuromancer2701[P]OpenTool/src/Mid0002.cpp
// Function: Mid_0002::BuildRevision3()
void Mid_0002::BuildRevision3()
{
	BuildRevision2();
	OutputStream << std::setw(Index_size) << std::setfill('0') << 5;
	OutputStream << std::setw(Open_Protocol_version_size) << std::setfill('0') << Open_Protocol_version;
	OutputStream << std::setw(Index_size) << std::setfill('0') << 6;
	OutputStream << std::setw(Controller_software_version_size) << std::setfill('0') << Controller_software_version;
	OutputStream << std::setw(Index_size) << std::setfill('0') << 7;
	OutputStream << std::setw(Tool_software_version_size) << std::setfill(' ') << Tool_software_version;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6480
leaq 0x1a0(%rbx), %r14
movq 0x1a0(%rbx), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x1b0(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
addq $0x1a0, %r15            # imm = 0x1A0
cmpb $0x0, 0xe1(%r15)
jne 0x8747
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %r14, %rdi
movl $0x5, %esi
callq 0x6640
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq $0x13, 0x10(%r14,%rcx)
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r15
cmpb $0x0, 0xe1(%r14,%rax)
jne 0x879b
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq 0x378(%rbx), %rsi
movq 0x380(%rbx), %rdx
movq %r14, %rdi
callq 0x6460
movq 0x1a0(%rbx), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x1b0(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r15
cmpb $0x0, 0x281(%rbx,%rax)
jne 0x87fe
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %r14, %rdi
movl $0x6, %esi
callq 0x6640
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq $0x13, 0x10(%r14,%rcx)
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r15
cmpb $0x0, 0xe1(%r14,%rax)
jne 0x8852
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq 0x398(%rbx), %rsi
movq 0x3a0(%rbx), %rdx
movq %r14, %rdi
callq 0x6460
movq 0x1a0(%rbx), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x1b0(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r15
cmpb $0x0, 0x281(%rbx,%rax)
jne 0x88b5
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %r14, %rdi
movl $0x7, %esi
callq 0x6640
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq $0x13, 0x10(%r14,%rcx)
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r15
cmpb $0x0, 0xe1(%r14,%rax)
jne 0x8909
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x20, 0xe0(%r15)
movq 0x3b8(%rbx), %rsi
movq 0x3c0(%rbx), %rdx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O1/Neuromancer2701[P]OpenTool/src/Mid0002.cpp
// Function: Mid_0002::PackupMid0002()
void Mid_0002::PackupMid0002()
{

	switch(Revision)
	{
		default:
		case MID_Revision::Revision1:
			 Length += Rev1_size;
			 Packup();
			 BuildRevision1();
			 OutputStream << '\0';
			 break;
		case MID_Revision::Revision2:
			 Length += Rev2_size;
			 Packup();
			 BuildRevision2();
			 OutputStream << '\0';
			 break;
		case MID_Revision::Revision3:
			 Length += Rev3_size;
			 Packup();
			 BuildRevision3();
			 OutputStream << '\0';
			 break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl 0x318(%rdi), %eax
movl 0x320(%rdi), %ecx
leaq 0x1a0(%rdi), %rbx
cmpl $0x2, %ecx
je 0x897e
cmpl $0x3, %ecx
jne 0x899f
addl $0x69, %eax
movl %eax, 0x318(%r14)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %r14, %rdi
callq 0x6280
leaq -0x13(%rbp), %rsi
jmp 0x89be
addl $0x2a, %eax
movl %eax, 0x318(%r14)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %r14, %rdi
callq 0x6480
leaq -0x12(%rbp), %rsi
jmp 0x89be
addl $0x25, %eax
movl %eax, 0x318(%r14)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %r14, %rdi
callq 0x63d0
leaq -0x11(%rbp), %rsi
movb $0x0, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6460
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Neuromancer2701[P]OpenTool/src/Mid0002.cpp
// Function: Mid_0002::ParseRevision1()
void Mid_0002::ParseRevision1()
{
	int index;
	OutputStream >> std::setw(Index_size) >> index;
	OutputStream >> std::setw(Cell_Id_size) >> Cell_Id;
	OutputStream >> std::setw(Index_size) >> index;
	OutputStream >> std::setw(Channel_Id_size) >> Channel_Id;
	OutputStream >> std::setw(Index_size) >> index;
	OutputStream >> std::setw(Controller_Name_size) >> Controller_Name;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x190(%rdi), %r14
movq 0x190(%rdi), %rax
movq -0x18(%rax), %rax
movl $0x2, %r12d
movq %r12, 0x1a0(%rdi,%rax)
leaq -0x24(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6290
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movq $0x4, 0x1a0(%rbx,%rax)
leaq 0x330(%rbx), %rsi
movq %r14, %rdi
callq 0x6290
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movq %r12, 0x1a0(%rbx,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6290
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movq %r12, 0x1a0(%rbx,%rax)
leaq 0x334(%rbx), %rsi
movq %r14, %rdi
callq 0x6290
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movq %r12, 0x1a0(%rbx,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6290
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movq $0x19, 0x1a0(%rbx,%rax)
addq $0x338, %rbx            # imm = 0x338
movq %r14, %rdi
movq %rbx, %rsi
callq 0x64c0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Neuromancer2701[P]OpenTool/src/Mid0002.cpp
// Function: Mid_0002::ParseRevision2()
void Mid_0002::ParseRevision2()
{
	int index;
	ParseRevision1();
	OutputStream >> std::setw(Index_size) >> index;
	OutputStream >> std::setw(Supplier_code_size) >> Supplier_code;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x65b0
leaq 0x190(%rbx), %r14
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x1a0(%rbx,%rax)
leaq -0x14(%rbp), %rsi
movq %r14, %rdi
callq 0x6290
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x1a0(%rbx,%rax)
addq $0x358, %rbx            # imm = 0x358
movq %r14, %rdi
movq %rbx, %rsi
callq 0x64c0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Neuromancer2701[P]OpenTool/src/Mid0002.cpp
// Function: Mid_0002::ParseRevision3()
void Mid_0002::ParseRevision3()
{
	int index;
	ParseRevision2();
	OutputStream >> std::setw(Index_size) >> index;
	OutputStream >> std::setw(Open_Protocol_version_size) >> Open_Protocol_version;
	OutputStream >> std::setw(Index_size) >> index;
	OutputStream >> std::setw(Controller_software_version_size) >> Controller_software_version;
	OutputStream >> std::setw(Index_size) >> index;
	OutputStream >> std::setw(Tool_software_version_size) >> Tool_software_version;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x62d0
leaq 0x190(%rbx), %r14
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movl $0x2, %r12d
movq %r12, 0x1a0(%rbx,%rax)
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6290
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movl $0x13, %r13d
movq %r13, 0x1a0(%rbx,%rax)
leaq 0x378(%rbx), %rsi
movq %r14, %rdi
callq 0x64c0
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movq %r12, 0x1a0(%rbx,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6290
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movq %r13, 0x1a0(%rbx,%rax)
leaq 0x398(%rbx), %rsi
movq %r14, %rdi
callq 0x64c0
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movq %r12, 0x1a0(%rbx,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6290
movq 0x190(%rbx), %rax
movq -0x18(%rax), %rax
movq %r13, 0x1a0(%rbx,%rax)
addq $0x3b8, %rbx            # imm = 0x3B8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x64c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Neuromancer2701[P]OpenTool/src/Mid0002.cpp
// Function: Mid_0002::UnPackMid0002()
void Mid_0002::UnPackMid0002()
{
	Unpack();

	switch(Revision)
	{
		default:
		case MID_Revision::Revision1:
			 ParseRevision1();
			 break;
		case MID_Revision::Revision2:
			 ParseRevision2();
			 break;
		case MID_Revision::Revision3:
			 ParseRevision3();
			 break;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x320(%rbx), %eax
movq %rbx, %rdi
addq $0x8, %rsp
cmpl $0x2, %eax
je 0x8c71
cmpl $0x3, %eax
jne 0x8c78
popq %rbx
popq %rbp
jmp 0x64f0
popq %rbx
popq %rbp
jmp 0x62d0
popq %rbx
popq %rbp
jmp 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Neuromancer2701[P]OpenTool/src/Mid0004.cpp
// Function: Mid_0004::BuildMid0004()
void Mid_0004::BuildMid0004()
{
	Length += Number_Size;
	Length += Error_Size;
	Packup();

	OutputStream << std::setw(Number_Size) << std::setfill('0') << Number;
	OutputStream << std::setw(Error_Size) << std::setfill('0') << Error;
	OutputStream << '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addl $0x6, 0x318(%rdi)
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x1a0(%r14), %rbx
movq 0x1a0(%r14), %rax
movq -0x18(%rax), %rcx
movq $0x4, 0x1b0(%r14,%rcx)
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r15
addq $0x1a0, %r15            # imm = 0x1A0
cmpb $0x0, 0xe1(%r15)
jne 0x8da7
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movl 0x330(%r14), %esi
movq %rbx, %rdi
callq 0x6640
movq 0x1a0(%r14), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x1b0(%r14,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
cmpb $0x0, 0x281(%r14,%rax)
jne 0x8e04
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movl 0x334(%r14), %esi
movq %rbx, %rdi
callq 0x6640
leaq -0x19(%rbp), %rsi
movb $0x0, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6460
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Neuromancer2701[P]OpenTool/src/Mid0005.cpp
// Function: Mid_0005::BuildMid0005()
void Mid_0005::BuildMid0005()
{
	Length += Number_Size;
	Packup();

	OutputStream << std::setw(Number_Size) << std::setfill('0') << Number;
	OutputStream << '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addl $0x4, 0x318(%rdi)
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x1a0(%r14), %rbx
movq 0x1a0(%r14), %rax
movq -0x18(%rax), %rcx
movq $0x4, 0x1b0(%r14,%rcx)
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r15
addq $0x1a0, %r15            # imm = 0x1A0
cmpb $0x0, 0xe1(%r15)
jne 0x8f9b
movq %r15, %rdi
movl $0x20, %esi
callq 0x63f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movl 0x330(%r14), %esi
movq %rbx, %rdi
callq 0x6640
leaq -0x19(%rbp), %rsi
movb $0x0, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6460
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop