// File: /workspace/github_cpp_makefile_star2_O3/ratulSharker[P]Havec/src/vector_with_rehash_8_hash_with_N_detection_5_bytes.cpp
// Function: reCheckTheKhmerExistence5Byte(khmerInfo5Byte*, unsigned long long, char*, unsigned short)
void reCheckTheKhmerExistence5Byte(struct khmerInfo5Byte * memBlock, unsigned long long blockSize, char *fileName,unsigned short int khmerSize){
	//opening the given file
		std::ifstream inputFile;
		inputFile.open(fileName,std::fstream::in);
		std::string buf,temp="";
		bool isFirstKhmer = true;
		unsigned long long *lastFoundKHashVal;
		lastFoundKHashVal=new unsigned long long[LAST_HASH_FUNC+1];		
		unsigned long long consumedRead = 0;
		unsigned int lastHashFuncUsed = 0;//containe the value that is last used to store last khmers
		unsigned long mem_block_occupied_stat = 0;
		unsigned long list_occupied_stat = 0;
		
		bool n_found = false;//added for the purpose of detecting N in the khmer
		
		//for stat purpose use only:)
		unsigned long found_khmer = 0,not_found=0;

		//error log if can't be opened
		if(inputFile.fail() == true){
			/*
			 * if fail to load the file -- return
			 */
			std::cout<<"Fail to open the "<<fileName << std::endl;
			return;
		}


		//if successfull then log it !!!
		std::cout<<"Rechecking... "<<fileName<<std::endl;

		//parsing the fasta file
		while(getline(inputFile,buf)){//reading a line

				if(buf[0] == '>'){
					//its a sequence name -- omit it !!! -- before omit clear the temp
					n_found = false;//new sequence so assign false to the N found tag
					temp = ""; //cleaning the old remaining khmer
					isFirstKhmer = true;
					continue;
				}
				else if (n_found == false){
					//here come the one sequnece of read
					buf = temp + buf;//no new read sequnence is found so the next line of read must be appended to the last
					unsigned int i;
					unsigned int bufSize = buf.size();//for optimization purpose only
					unsigned int loopTime = bufSize - khmerSize;//for optimization purpose only
					unsigned int addResult; //for optimization only

					if(isFirstKhmer == true){
						//its the first read line of the multiple read lines
						i = 1;
					}
					else{
						//its not the first line of the multiple read line
						i= 0;
					}

					//if it the first line then consume it explicitly by using fullHasher
					if(isFirstKhmer == true){
						if(bufSize < khmerSize){
						/*cout<<"**************************************************"<<endl;						
						cout<<"Problem detected !!!"<<endl;
						cout<<"read sequence size is less then the khmer size -- processing next read :("<<endl;
						cout<<"seq :: "<<buf<<endl;
						cout<<"**************************************************"<<endl;
						*/
						continue;						
					}
						//start of a new read detected
						temp = buf.substr(0,khmerSize); //here temp denote the string khmer
						
						//lastFoundKHashVal = fullHasher(temp); //saving the hash value
						//std::cout<<"recheck khmer's in the read (first) :: "<<temp<<std::endl;

						
						
						if(bufSize > khmerSize){
							
							bool found = false;
							
							for(int ii=0;ii<=LAST_HASH_FUNC;ii++){
							
							
								lastFoundKHashVal[ii] = fullHasher(temp,ii); 
									
								if(buf.length() > khmerSize ){//checking that next khmer is not invalid
									switch(toupper(buf[khmerSize])){
										case 'A':
										case 'T':
										case 'G':
										case 'C':
										break;
										
										default:
										neucleotide_status = N_FOUND_IN_NEUCLEOTIDE;
										break;
									}
								}
							
								if(neucleotide_status == N_FOUND_IN_NEUCLEOTIDE){
									n_found = true;
									break;//breaking the hash loop !!!!
								}
								
								//std::cout<<"try to find("<<ii<<")"<<endl;
								
								//khmer has a neighbour :) -- so put the khmer in the blockArray
								//cout<<"trying to find "<<termp<<endl;
								switch(findGivenKhmer5Byte(temp,memBlock,blockSize,lastFoundKHashVal[ii],ii)){

								case FOUND:
									found_khmer++;
									//std::cout<<temp<< " -- found"<<std::endl;
									found = true;
									lastHashFuncUsed=ii;
									break;
								case NOT_FOUND:
									//std::cout<<temp<< " -- not found"<<std::endl;
									found = false;
									break;
								}
								if(found){
								break; //break out from the for loop
							}
						}
						
						if(n_found == true){ //main while loop continues -- allowing to consume the line of read
							continue ;
						}
						else if(n_found  == false && found == false){//error reporting that -- the khmer is not found
							not_found++;
							std::cout<<temp<< "at first -- not found "<<std::endl;
							std::cout<<"buffer :: " <<buf<<std::endl;
						}
						
						//for debug purpose
						//std::cout<<"inside firstkhmer "<<std::endl;
						//std::cout<<temp<<std::endl;
					}
					isFirstKhmer = false;
				}

				if(n_found == true){ //main while loop continues -- allowing to consume the line of read
					continue ;
				}
				
				for( ; i <= loopTime && n_found == false; i++){
					temp = buf.substr(i,khmerSize);

					//std::cout<<"recheck khmer's in the read (intermediate) :: "<<temp<<std::endl;
					
					addResult = i + khmerSize;
					
					if(bufSize > addResult){
						
						bool found = false;
						for(int ii=0;ii<=LAST_HASH_FUNC;ii++){
						
							if(ii<=lastHashFuncUsed){
								//last used hash func & current hashfunc is same -- so partial hasher would do the job
								
								//neighbour left so put it into the memBlock
								lastFoundKHashVal[ii] = partialHasher(lastFoundKHashVal[ii],temp[khmerSize - 1],khmerSize,ii);
								//lastFoundKHashVal = fullHasher(temp,ii);
							}
							else{
								lastFoundKHashVal[ii] = fullHasher(temp,ii); //saving the hash
								
							}
							
							if(buf.length() >= addResult + 1){//checking that next khmer is not invalid
								switch(toupper(buf[addResult])){
									case 'A':
									case 'T':
									case 'G':
									case 'C':
									break;
									
									default:
									neucleotide_status = N_FOUND_IN_NEUCLEOTIDE;
									break;
								}
							}
							
							if(neucleotide_status == N_FOUND_IN_NEUCLEOTIDE){
								n_found = true;
								break;
							}
							
							//std::cout<<"try to find("<<ii<<")"<<endl;
							
							//neighbour left so put it into the memBlock
							//lastFoundKHashVal[ii] = partialHasher(lastFoundKHashVal,temp[khmerSize - 1],khmerSize,ii);
							switch(findGivenKhmer5Byte(temp,memBlock,blockSize,lastFoundKHashVal[ii],ii)){
								case FOUND:
									found_khmer++;
									//std::cout<<temp<< " -- found"<<std::endl;
									lastHashFuncUsed = ii;
									found = true;
									break;
								case NOT_FOUND:
									//cout<<temp<< " -- not found"<<std::endl;
									found = false;
									break;
							}

							//for debug purpose
							//std::cout<<"\tinside loop "<<std::endl;
							//std::cout<<"\t\t"<<temp<<std::endl;
							if(found){								
								break; //break out from the for loop
							}
						}
						
						if(n_found == false && found == false){//error reporting that -- the khmer is not found
							not_found++;
							std::cout<<temp<< " -- not found"<<std::endl;
						}

					}
					
					if(n_found == true){
						break;
					}
					
				}
				//temp = temp.substr(1,khmerSize-1);//advance to next khmer one time of ahead

				//std::cout<<"one line of read consumed" <<std::endl;
			}
		}

		//spit out the stats
		std::cout<<"stat from recheck function :: "<<endl
				<<"\tkhmer found :: "<<found_khmer<<endl<<"\tkhmer not found:: "<<not_found<<endl<<endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, 0x88(%rsp)
movq %rdi, 0x80(%rsp)
leaq 0x140(%rsp), %r15
movq %r15, %rdi
callq 0x32b0
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x3140
leaq 0x48(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x6e2e(%rip), %rdx      # 0xb5c8
leaq 0x18(%rsp), %rdi
movq %rdx, %rsi
callq 0x6334
leaq 0x9b06(%rip), %rax      # 0xe2b4
movl (%rax), %edi
incl %edi
shlq $0x3, %rdi
callq 0x3030
movq %rax, 0x58(%rsp)
movq 0x140(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x160(%rsp,%rax)
je 0x4812
movq 0x97fb(%rip), %rbx      # 0xdfd8
leaq 0x6905(%rip), %rsi      # 0xb0e9
movl $0x11, %edx
movq %rbx, %rdi
callq 0x32c0
testq %r14, %r14
je 0x484e
movq %r14, %rdi
callq 0x30c0
movq 0x97d3(%rip), %rdi      # 0xdfd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x32c0
jmp 0x486c
movq 0x97bf(%rip), %r12      # 0xdfd8
leaq 0x6972(%rip), %rsi      # 0xb192
movl $0xe, %edx
movq %r12, %rdi
callq 0x32c0
testq %r14, %r14
je 0x4885
movq %r14, %rdi
callq 0x30c0
movq 0x9797(%rip), %rdi      # 0xdfd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x32c0
jmp 0x489e
movq 0x9783(%rip), %rax      # 0xdfd8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x3410
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3220
jmp 0x50aa
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x3410
movq (%r12), %rax
addq -0x18(%rax), %r12
movq %r12, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %esi
movq 0x971b(%rip), %rdi      # 0xdfd8
callq 0x3040
movq %rax, %rdi
callq 0x3180
movzwl %bx, %eax
movq %rax, 0x10(%rsp)
movb $0x1, %r12b
movq $0x0, 0x8(%rsp)
leaq 0x38(%rsp), %rbx
xorl %r14d, %r14d
movq $0x0, 0x68(%rsp)
movq $0x0, 0x60(%rsp)
movq 0x140(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3460
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4fb1
movq 0x38(%rsp), %rax
cmpb $0x3e, (%rax)
jne 0x495e
movb $0x1, %r12b
xorl %r14d, %r14d
movq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
leaq 0x6c74(%rip), %rcx      # 0xb5c8
xorl %r8d, %r8d
callq 0x33b0
jmp 0x48f8
testb $0x1, %r14b
jne 0x4bae
leaq 0x90(%rsp), %r13
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
movq %rbx, %rdx
callq 0x5e8f
movq %rbx, %rdi
movq %r13, %rsi
callq 0x32f0
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x49b0
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x3260
movl 0x40(%rsp), %eax
testb $0x1, %r12b
je 0x4bb3
cmpl 0x10(%rsp), %eax
jb 0x48f8
movl %eax, 0x4(%rsp)
leaq 0x90(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq 0x10(%rsp), %rcx
callq 0x3280
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x32f0
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x4a18
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x3260
movl 0x4(%rsp), %eax
cmpl 0x10(%rsp), %eax
jbe 0x4fa5
xorl %r13d, %r13d
movq 0x8(%rsp), %rax
movl %eax, %ecx
movl %ecx, %eax
movq %rax, 0x8(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0xd0(%rsp), %rdi
callq 0x5ef4
leaq 0xd0(%rsp), %rdi
movl %r13d, %esi
callq 0xa251
movq %rax, %rbp
movq 0x58(%rsp), %rax
movq %rbp, (%rax,%r13,8)
movq 0xd0(%rsp), %rdi
leaq 0xe0(%rsp), %rax
cmpq %rax, %rdi
je 0x4aa2
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x3260
movq 0x10(%rsp), %rax
cmpq %rax, 0x40(%rsp)
jbe 0x4adb
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3470
addl $-0x41, %eax
cmpl $0x13, %eax
ja 0x4b94
movl $0x80045, %ecx          # imm = 0x80045
btl %eax, %ecx
jae 0x4b94
leaq 0x97f6(%rip), %rax      # 0xe2d8
cmpl $0x7, (%rax)
je 0x4ba1
leaq 0x130(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0x120(%rsp), %rdi
callq 0x5ef4
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq %rbp, %rcx
movl %r13d, %r8d
callq 0x45ec
movl %eax, %ebp
movq 0x120(%rsp), %rdi
leaq 0x130(%rsp), %rax
cmpq %rax, %rdi
je 0x4b57
movq 0x130(%rsp), %rsi
incq %rsi
callq 0x3260
xorl %eax, %eax
cmpl $0x4, %ebp
sete %al
addq %rax, 0x68(%rsp)
leaq 0x1(%r13), %rax
movq 0x8(%rsp), %rcx
cmpl $0x4, %ebp
cmovel %r13d, %ecx
je 0x4eaa
leaq 0x9733(%rip), %rdx      # 0xe2b4
movl (%rdx), %edx
cmpq %rdx, %r13
movq %rax, %r13
jb 0x4a30
jmp 0x4eaa
leaq 0x973d(%rip), %rax      # 0xe2d8
movl $0x7, (%rax)
movb $0x1, %r14b
leaq 0x48(%rsp), %rbp
jmp 0x48f8
jmp 0x48f8
movl %eax, 0x4(%rsp)
movl %r12d, %eax
movl %eax, (%rsp)
andb $0x1, %r12b
movzbl %r12b, %edx
movl 0x4(%rsp), %eax
movl %eax, %esi
subl 0x10(%rsp), %esi
movl %esi, 0x74(%rsp)
cmpl %edx, %esi
movl (%rsp), %r12d
jb 0x48f8
movq %rdx, %rcx
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl %eax, %r12d
movq %rcx, 0x78(%rsp)
movl %ecx, %edx
leaq 0x90(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rcx
callq 0x3280
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x32f0
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x4c3f
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x3260
movq 0x10(%rsp), %rax
movq 0x78(%rsp), %rcx
addl %ecx, %eax
cmpl 0x4(%rsp), %eax
jae 0x4e88
leal 0x1(%rax), %ecx
movq %rcx, 0xf8(%rsp)
movl %eax, %eax
movq %rax, 0xf0(%rsp)
xorl %r13d, %r13d
movl %r12d, %eax
movq %rax, 0x8(%rsp)
movl %eax, %eax
cmpq %rax, %r13
jbe 0x4ced
leaq 0xc0(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0xb0(%rsp), %rdi
callq 0x5ef4
movl (%rsp), %r12d
leaq 0xb0(%rsp), %rdi
movl %r13d, %esi
callq 0xa251
movq %rax, %rbp
movq 0x58(%rsp), %rax
movq %rbp, (%rax,%r13,8)
movq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
cmpq %rax, %rdi
je 0x4d1d
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x4d1d
movq 0x58(%rsp), %rax
movq (%rax,%r13,8), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdx
movsbl -0x1(%rax,%rdx), %esi
movl %r13d, %ecx
callq 0xa30f
movl (%rsp), %r12d
movq %rax, %rbp
movq 0x58(%rsp), %rax
movq %rbp, (%rax,%r13,8)
movq 0xf8(%rsp), %rax
cmpq %rax, 0x40(%rsp)
jb 0x4d5c
movq 0x38(%rsp), %rax
movq 0xf0(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3470
addl $-0x41, %eax
cmpl $0x13, %eax
ja 0x4f8b
movl $0x80045, %ecx          # imm = 0x80045
btl %eax, %ecx
jae 0x4f8b
leaq 0x9575(%rip), %rax      # 0xe2d8
cmpl $0x7, (%rax)
je 0x4f98
leaq 0x110(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0x100(%rsp), %rdi
callq 0x5ef4
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq %rbp, %rcx
movl %r13d, %r8d
callq 0x45ec
movl %eax, %ebp
movq 0x100(%rsp), %rdi
leaq 0x110(%rsp), %rax
cmpq %rax, %rdi
je 0x4dd8
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x3260
xorl %eax, %eax
cmpl $0x4, %ebp
sete %al
addq %rax, 0x68(%rsp)
leaq 0x1(%r13), %rax
movq 0x8(%rsp), %rcx
movl %ecx, %r12d
cmpl $0x4, %ebp
cmovel %r13d, %r12d
je 0x4e0f
leaq 0x94b3(%rip), %rcx      # 0xe2b4
movl (%rcx), %ecx
cmpq %rcx, %r13
movq %rax, %r13
jb 0x4c6d
cmpl $0x4, %ebp
jne 0x4e21
decq %rax
movl %eax, %r12d
leaq 0x48(%rsp), %rbp
jmp 0x4e88
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x91a6(%rip), %rdi      # 0xdfd8
leaq 0x48(%rsp), %rbp
callq 0x32c0
movq %rax, %r13
movl $0xd, %edx
movq %rax, %rdi
leaq 0x6375(%rip), %rsi      # 0xb1c3
callq 0x32c0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
incq 0x60(%rsp)
movq 0x8(%rsp), %rax
movl %eax, %r12d
movq 0x78(%rsp), %rcx
incl %ecx
cmpl 0x74(%rsp), %ecx
jbe 0x4bee
movl %r12d, %eax
movq %rax, 0x8(%rsp)
movl (%rsp), %r12d
jmp 0x48f8
cmpl $0x4, %ebp
jne 0x4ec8
decq %rax
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rbp
jmp 0x4bbd
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x90ff(%rip), %rdi      # 0xdfd8
leaq 0x48(%rsp), %rbp
callq 0x32c0
movq %rax, %r13
movl $0x16, %edx
movq %rax, %rdi
leaq 0x62ac(%rip), %rsi      # 0xb1a1
callq 0x32c0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
movl $0xa, %edx
movq 0x90aa(%rip), %rdi      # 0xdfd8
leaq 0x6283(%rip), %rsi      # 0xb1b8
callq 0x32c0
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x908d(%rip), %rdi      # 0xdfd8
callq 0x32c0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
incq 0x60(%rsp)
movl $0x0, (%rsp)
jmp 0x4bbd
leaq 0x9346(%rip), %rax      # 0xe2d8
movl $0x7, (%rax)
movb $0x1, %r14b
leaq 0x48(%rsp), %rbp
jmp 0x48f8
movl $0x0, (%rsp)
jmp 0x4ebe
movq 0x9020(%rip), %rbx      # 0xdfd8
leaq 0x6212(%rip), %rsi      # 0xb1d1
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x32c0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %esi
movq 0x8fee(%rip), %rdi      # 0xdfd8
callq 0x3040
movq %rax, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x61ef(%rip), %rsi      # 0xb1f0
movl $0x10, %edx
movq %rax, %rdi
callq 0x32c0
movq %rbx, %rdi
movq 0x68(%rsp), %rsi
callq 0x3170
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x61b2(%rip), %rsi      # 0xb201
movl $0x13, %edx
movq %rax, %rdi
callq 0x32c0
movq %rbx, %rdi
movq 0x60(%rsp), %rsi
callq 0x3170
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x50d9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3260
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x50f0
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x140(%rsp), %rdi
callq 0x3070
addq $0x348, %rsp            # imm = 0x348
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5177
jmp 0x5177
jmp 0x5177
jmp 0x5177
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
cmpq %rax, %rdi
je 0x517a
movq 0xc0(%rsp), %rsi
jmp 0x5159
movq %rax, %rbx
movq 0xd0(%rsp), %rdi
leaq 0xe0(%rsp), %rax
cmpq %rax, %rdi
je 0x517a
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x517a
jmp 0x5177
jmp 0x5177
jmp 0x5177
jmp 0x5177
movq %rax, %rbx
jmp 0x5196
movq %rax, %rbx
jmp 0x51b2
jmp 0x5177
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x5196
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3260
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x51b2
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x140(%rsp), %rdi
callq 0x3070
movq %rbx, %rdi
callq 0x3430