// File: /workspace/github_cpp_makefile_star2_O1/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, 0x90(%rsp)
movq %rdi, 0x88(%rsp)
leaq 0x140(%rsp), %r15
movq %r15, %rdi
callq 0x32c0
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x3140
leaq 0x60(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6d3f(%rip), %rdx      # 0xb530
leaq 0x18(%rsp), %rdi
movq %rdx, %rsi
callq 0x637e
leaq 0x9abf(%rip), %rax      # 0xe2c4
movl (%rax), %edi
incl %edi
shlq $0x3, %rdi
callq 0x3030
movq %rax, 0x38(%rsp)
movq 0x140(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x160(%rsp,%rax)
je 0x4869
movq 0x97a4(%rip), %rbx      # 0xdfd8
leaq 0x68ae(%rip), %rsi      # 0xb0e9
movl $0x11, %edx
movq %rbx, %rdi
callq 0x32d0
testq %r14, %r14
je 0x48a5
movq %r14, %rdi
callq 0x30c0
movq 0x977c(%rip), %rdi      # 0xdfd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x32d0
jmp 0x48c3
movq 0x9768(%rip), %r13      # 0xdfd8
leaq 0x691b(%rip), %rsi      # 0xb192
movl $0xe, %edx
movq %r13, %rdi
callq 0x32d0
testq %r14, %r14
je 0x48dc
movq %r14, %rdi
callq 0x30c0
movq 0x9740(%rip), %rdi      # 0xdfd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x32d0
jmp 0x48f5
movq 0x972c(%rip), %rax      # 0xdfd8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x3430
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
jmp 0x50d3
movq (%r13), %rax
movq -0x18(%rax), %rax
leaq (%rax,%r13), %rdi
movl 0x20(%r13,%rax), %esi
orl $0x1, %esi
callq 0x3430
movq (%r13), %rax
addq -0x18(%rax), %r13
movq %r13, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq 0x96c4(%rip), %rdi      # 0xdfd8
callq 0x3040
movq %rax, %rdi
callq 0x3180
movzwl %bx, %eax
movq %rax, 0x8(%rsp)
movb $0x1, %r12b
movq $0x0, 0x40(%rsp)
xorl %r15d, %r15d
movq $0x0, 0x80(%rsp)
movq $0x0, 0x70(%rsp)
movq 0x140(%rsp), %rax
movq -0x18(%rax), %rdi
leaq 0x140(%rsp), %rax
addq %rax, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %edx
leaq 0x140(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3480
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4fd2
movq 0x50(%rsp), %rax
cmpb $0x3e, (%rax)
jne 0x49c2
movb $0x1, %r12b
xorl %r15d, %r15d
movq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
leaq 0x6b78(%rip), %rcx      # 0xb530
xorl %r8d, %r8d
callq 0x33d0
jmp 0x494d
testb $0x1, %r15b
jne 0x494d
leaq 0x98(%rsp), %r13
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
leaq 0x50(%rsp), %r14
movq %r14, %rdx
callq 0x5e95
movq %r14, %rdi
movq %r13, %rsi
callq 0x3300
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x4a15
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x3270
movl 0x58(%rsp), %eax
movl %r12d, %ecx
andb $0x1, %cl
movb %cl, 0x78(%rsp)
movl %eax, 0x14(%rsp)
je 0x4ced
cmpl 0x8(%rsp), %eax
jb 0x494d
leaq 0x98(%rsp), %r14
movq %r14, %rdi
leaq 0x50(%rsp), %rsi
xorl %edx, %edx
movq 0x8(%rsp), %rcx
callq 0x3290
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x3300
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x4a85
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x3270
movl 0x14(%rsp), %eax
cmpl 0x8(%rsp), %eax
jbe 0x4cea
xorl %r14d, %r14d
xorl %ebp, %ebp
leaq 0xe8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0xd8(%rsp), %rdi
callq 0x5efa
leaq 0xd8(%rsp), %rdi
movl %r14d, %esi
callq 0x9e62
movq %rax, %r13
movq 0x38(%rsp), %rax
movq %r13, (%rax,%r14,8)
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0x4b03
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x8(%rsp), %rax
cmpq %rax, 0x58(%rsp)
jbe 0x4b3c
movq 0x50(%rsp), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3490
addl $-0x41, %eax
cmpl $0x13, %eax
ja 0x4bfa
movl $0x80045, %ecx          # imm = 0x80045
btl %eax, %ecx
jae 0x4bfa
leaq 0x97a5(%rip), %rax      # 0xe2e8
cmpl $0x7, (%rax)
je 0x4c0c
leaq 0x130(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0x120(%rsp), %rdi
callq 0x5efa
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq %r13, %rcx
movl %r14d, %r8d
callq 0x4646
movl %eax, %r13d
movq 0x120(%rsp), %rdi
leaq 0x130(%rsp), %rax
cmpq %rax, %rdi
je 0x4bb9
movq 0x130(%rsp), %rsi
incq %rsi
callq 0x3270
xorl %ebp, %ebp
cmpl $0x4, %r13d
sete %bpl
addq %rbp, 0x80(%rsp)
cmpl $0x4, %r13d
movq 0x40(%rsp), %rax
cmovel %r14d, %eax
movq %rax, 0x40(%rsp)
je 0x4c0f
leaq 0x1(%r14), %rax
leaq 0x96da(%rip), %rcx      # 0xe2c4
movl (%rcx), %ecx
cmpq %rcx, %r14
movq %rax, %r14
jb 0x4a98
jmp 0x4c0f
leaq 0x96e7(%rip), %rax      # 0xe2e8
movl $0x7, (%rax)
jmp 0x4b3c
movb $0x1, %r15b
testb $0x1, %bpl
jne 0x4cdb
testb $0x1, %r15b
leaq 0x60(%rsp), %rbp
jne 0x4ce0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x939f(%rip), %rdi      # 0xdfd8
callq 0x32d0
movq %rax, %r14
movl $0x16, %edx
movq %rax, %rdi
leaq 0x6551(%rip), %rsi      # 0xb1a1
callq 0x32d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
movl $0xa, %edx
movq 0x9350(%rip), %rdi      # 0xdfd8
leaq 0x6529(%rip), %rsi      # 0xb1b8
callq 0x32d0
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x9333(%rip), %rdi      # 0xdfd8
callq 0x32d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
incq 0x70(%rsp)
jmp 0x4ce0
leaq 0x60(%rsp), %rbp
testb $0x1, %r15b
jne 0x494d
xorl %r12d, %r12d
movl 0x14(%rsp), %eax
subl 0x8(%rsp), %eax
movl %eax, 0x4c(%rsp)
testb $0x1, %r15b
jne 0x494d
jne 0x494d
movzbl 0x78(%rsp), %ebx
cmpl %ebx, 0x4c(%rsp)
jb 0x494d
movl %ebx, %edx
leaq 0x98(%rsp), %r14
movq %r14, %rdi
leaq 0x50(%rsp), %rsi
movq 0x8(%rsp), %rcx
callq 0x3290
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x3300
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x4d66
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x8(%rsp), %rax
addl %ebx, %eax
cmpl 0x14(%rsp), %eax
jae 0x4fad
leal 0x1(%rax), %ecx
movq %rcx, 0x78(%rsp)
movl %eax, %eax
movq %rax, 0xf8(%rsp)
xorl %r14d, %r14d
xorl %ebp, %ebp
movl 0x40(%rsp), %eax
cmpq %rax, %r14
jbe 0x4e01
leaq 0xc8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0xb8(%rsp), %rdi
callq 0x5efa
leaq 0xb8(%rsp), %rdi
movl %r14d, %esi
callq 0x9e62
movq 0x38(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x4e2a
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x4e2a
movq 0x38(%rsp), %rax
movq (%rax,%r14,8), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdx
movsbl -0x1(%rax,%rdx), %esi
movl %r14d, %ecx
callq 0x9f20
movq 0x38(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
movq 0x78(%rsp), %rax
cmpq %rax, 0x58(%rsp)
jb 0x4e66
movq 0x50(%rsp), %rax
movq 0xf8(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3490
addl $-0x41, %eax
cmpl $0x13, %eax
ja 0x4f2a
movl $0x80045, %ecx          # imm = 0x80045
btl %eax, %ecx
jae 0x4f2a
leaq 0x947b(%rip), %rax      # 0xe2e8
cmpl $0x7, (%rax)
je 0x4f3c
leaq 0x110(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0x100(%rsp), %rdi
callq 0x5efa
movq 0x38(%rsp), %rax
movq (%rax,%r14,8), %rcx
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
movl %r14d, %r8d
callq 0x4646
movl %eax, %r13d
movq 0x100(%rsp), %rdi
leaq 0x110(%rsp), %rax
cmpq %rax, %rdi
je 0x4ee9
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x3270
xorl %ebp, %ebp
cmpl $0x4, %r13d
sete %bpl
addq %rbp, 0x80(%rsp)
cmpl $0x4, %r13d
movq 0x40(%rsp), %rax
cmovel %r14d, %eax
movq %rax, 0x40(%rsp)
je 0x4f3f
leaq 0x1(%r14), %rax
leaq 0x93aa(%rip), %rcx      # 0xe2c4
movl (%rcx), %ecx
cmpq %rcx, %r14
movq %rax, %r14
jb 0x4d8e
jmp 0x4f3f
leaq 0x93b7(%rip), %rax      # 0xe2e8
movl $0x7, (%rax)
jmp 0x4e66
movb $0x1, %r15b
orb %r15b, %bpl
testb $0x1, %bpl
jne 0x4fa8
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x907f(%rip), %rdi      # 0xdfd8
leaq 0x60(%rsp), %rbp
callq 0x32d0
movq %rax, %r14
movl $0xd, %edx
movq %rax, %rdi
leaq 0x624e(%rip), %rsi      # 0xb1c3
callq 0x32d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
incq 0x70(%rsp)
jmp 0x4fad
leaq 0x60(%rsp), %rbp
testb $0x1, %r15b
jne 0x494d
testb $0x1, %r15b
jne 0x494d
incl %ebx
cmpl 0x4c(%rsp), %ebx
jbe 0x4d18
jmp 0x494d
movq 0x8fff(%rip), %rbx      # 0xdfd8
leaq 0x61f1(%rip), %rsi      # 0xb1d1
movl $0x1e, %edx
movq %rbx, %rdi
leaq 0x28(%rsp), %r15
callq 0x32d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq 0x8fc8(%rip), %rdi      # 0xdfd8
callq 0x3040
movq %rax, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x61c9(%rip), %rsi      # 0xb1f0
movl $0x10, %edx
movq %rax, %rdi
callq 0x32d0
movq %rbx, %rdi
movq 0x80(%rsp), %rsi
callq 0x3170
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x6189(%rip), %rsi      # 0xb201
movl $0x13, %edx
movq %rax, %rdi
callq 0x32d0
movq %rbx, %rdi
movq 0x70(%rsp), %rsi
callq 0x3170
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
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 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x50fd
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x50(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5114
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x3270
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 0x519b
jmp 0x519b
jmp 0x519b
movq %rax, %rbx
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0x519e
movq 0xe8(%rsp), %rsi
jmp 0x518d
jmp 0x519b
jmp 0x519b
jmp 0x519b
jmp 0x519b
movq %rax, %rbx
jmp 0x51ba
movq %rax, %rbx
jmp 0x51d6
movq %rax, %rbx
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x519e
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x519e
jmp 0x519b
jmp 0x519b
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x51ba
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x51d6
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x140(%rsp), %rdi
callq 0x3070
movq %rbx, %rdi
callq 0x3450