// File: /workspace/github_cpp_makefile_star2_O1/ratulSharker[P]Havec/src/vector_with_rehash_8_hash_with_N_detection_6_bytes.cpp
// Function: populateBlock6Byte(khmerInfo6Byte*, unsigned long long, char*, unsigned short)
void populateBlock6Byte(struct khmerInfo6Byte * 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];
	
	bool n_found = false;//if n found in the read, then the read processing is left inactive 
						 // till the next new read sequence is found !!!
	
	unsigned long long consumedRead = 0;
	unsigned int lastHashFuncUsed = 0;//containe the value that is last used to store last khmer
	
	//for stat purpose use only:)
	unsigned long mem_block_occupied_stat = 0,mem_block_found_stat=0;
	unsigned long list_occupied_stat = 0,list_occupied_found=0;
	unsigned long mem_block_total_number_of_occupied = 0; //exact number of khmer stored in the memblock
	unsigned long vector_total_number_of_occupied = 0; //exact number of khmer stored in the vector 
	
	//ofstream myfile;
	//myfile.open("firstKmers.txt");
	//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<<"Consuming... "<<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 found so i can't tell that exactly that, this new read sequence is bad or not -- time to consume
				
				temp = ""; //cleaning the old remaining khmer
				
				isFirstKhmer = true;
				consumedRead++;
				if(consumedRead%1000000==0){
					std::cout<<consumedRead/1000000<<" million read consumed..."<<std::endl;
					currentDateTime();
					/*show_vect_status_6_byte();
						std::cout<<"stat from consume function :: "<<std::endl
							<<"khmer in memBlock :: "<<mem_block_occupied_stat<<std::endl
							<<"khmer in list :: "<<list_occupied_stat<<std::endl<<std::endl;
							cout<<"*********************************"<<endl;
					*/	double vm, rss;
						process_mem_usage(vm, rss);
						cout << "Memory used (GB):  " << ((vm)/1024)/1024 <<endl;
				}
				//std::cout<<buf<<std::endl;
				continue;
			}
			else if(n_found == false){//if read sequence is not bad, consume it
									//if it is bad, then just omit consuming :) till a new read sequence found
									
				//here come the one sequnece of read
				buf = temp.append(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
					
					//std::cout<<"khmer's in the read (first):: "<<temp<<std::endl;
					
					if(bufSize > khmerSize){
						//khmer has a neighbour :) -- so put the khmer in the blockArray
						
						//saving the first khmer
						//myfile<<temp<<endl;//_revhash(lastFoundKHashVal,khmerSize)<<endl; //saving the first khmer -- revhash isn't working right now
						
						// hash function trying formation 0th->1th->2th->3th
						bool stored = false;
						for(int ii=0;ii<=LAST_HASH_FUNC;ii++){
						
							//for the first khmer all the 
							//saving signature that which hash function is being used for the first khmer
							lastFoundKHashVal[ii] = fullHasher(temp,ii); //saving the hash
							
							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;
							}
							
							//std::cout<<"store try ("<<ii<<")"<<endl;
							
							//cout<<"trying to store-"<<temp<<" hashfunc-"<<ii<<" hashed value-"<<lastFoundKHashVal[ii]<<" neighbour "<<buf[khmerSize]<<endl;
							switch(storeKhmerInMemBlock6Byte(temp,memBlock,blockSize,lastFoundKHashVal[ii],buf[khmerSize],ii)){
							
							case MEM_BLOCK:
								mem_block_occupied_stat++;
								mem_block_total_number_of_occupied++;
								lastHashFuncUsed = ii;
								stored = true;
								break;
							case MEM_BLOCK_FOUND:
								//cout<<"mem_block_found :: "<<temp<<endl;
								mem_block_found_stat++;
								mem_block_total_number_of_occupied++;
								lastHashFuncUsed = ii;
								stored=true;
								break;
							case LIST:
								list_occupied_stat++; //this will happen only for the las time (hash Func 3)
								lastHashFuncUsed = ii;
								vector_total_number_of_occupied++;
								stored = true;
								break;
							case LIST_FOUND:
								//cout<<"list_found :: "<<temp<<endl;
								list_occupied_found++;
								vector_total_number_of_occupied++;
								lastHashFuncUsed = ii;
								stored=true;
								break;
							case ERROR:
								//std::cout<<"ERROR OCCURED"<<std::endl;
								//return;
								break;
							}
							if(stored){
								break; //break out from the for loop
							}
						}
						//for debug purpose
						//std::cout<<"inside firstkhmer "<<std::endl;
						//std::cout<<temp<<std::endl;
					}

					isFirstKhmer = false;
				}
				
				if(n_found == true){ //in the first khmer N found so abort consuming using continue statement
					continue;
				}
				
				
				
				for( ; i <= loopTime && n_found == false; i++){
					temp = buf.substr(i,khmerSize);

					//std::cout<<"khmer's in the read (intermediate) :: "<<temp<<std::endl;

					addResult = i + khmerSize;

					if(bufSize > addResult){
						
						bool stored = 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
								//cout<<"using partial hash func with last hash func value "<<lastFoundKHashVal[ii]<<" and next neighbour "<<temp[khmerSize - 1]<<endl;
								lastFoundKHashVal[ii] = partialHasher(lastFoundKHashVal[ii],temp[khmerSize - 1],khmerSize,ii);
								//lastFoundKHashVal = fullHasher(temp,ii); //saving the hash
							}  
							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 in the middle of consuming
								n_found = true;
								break;
							}
							
							//std::cout<<"store try ("<<ii<<")"<<endl;
							
							//cout<<"trying to store-"<<temp<<" neighbour "<<buf[addResult]<<" hashfunc-"<<ii<<" last found hashed value "<<lastFoundKHashVal[ii]<<endl;
							//cout<<"Hash "<<temp<<" "<<buf[addResult]<<endl;
							
							switch(storeKhmerInMemBlock6Byte(temp,memBlock, blockSize, lastFoundKHashVal[ii], buf[addResult],ii)){

								case MEM_BLOCK:
									mem_block_occupied_stat++;
									mem_block_total_number_of_occupied++;
									lastHashFuncUsed = ii;
									stored = true;
									break;
								case MEM_BLOCK_FOUND:
									//cout<<"mem_block_found:: "<<temp<<endl;
									mem_block_found_stat++;
									mem_block_total_number_of_occupied++;
									lastHashFuncUsed = ii;
									stored=true;
									break;
								case LIST:
									list_occupied_stat++;
									vector_total_number_of_occupied++;
									lastHashFuncUsed = ii;
									stored = true;
									break;
								case LIST_FOUND:
									//cout<<"list_found:: "<<temp<<endl;
									list_occupied_found++;
									vector_total_number_of_occupied++;
									lastHashFuncUsed = ii;
									stored=true;
									break;
								case ERROR:
									//std::cout<<"ERROR OCCURED"<<std::endl;
									break;
								
							}

							if(stored == true){
								//if stored then just end the loop
								break;
							}
							
							//for debug purpose
							//std::cout<<"\tinside loop "<<std::endl;
							//std::cout<<"\t\t"<<temp<<std::endl;
						}
					}

				}

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

	//myfile.close();

	//spit out the stats
	std::cout<<"stat from consume function :: "<<std::endl
			<<"khmer in memBlock (distinct):: "<<mem_block_occupied_stat<<std::endl
			<<"khmer in list (distinct):: "<<list_occupied_stat<<std::endl<<std::endl;
			/*<<"khmer in memBlock (found):: "<<mem_block_found_stat<<std::endl
			<<"khmer in list (found):: "<<list_occupied_found<<std::endl<<std::endl
			<<"Khmer in memBlock(total) "<<mem_block_total_number_of_occupied<<std::endl
			<<"khmer in vector(total) "<<vector_total_number_of_occupied<<endl;*/
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, 0xb0(%rsp)
movq %rdi, 0xa8(%rsp)
leaq 0x140(%rsp), %rbx
movq %rbx, %rdi
callq 0x32c0
movq %rbx, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x3140
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x4a02(%rip), %rdx      # 0xb530
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x637e
leaq 0x7782(%rip), %rax      # 0xe2c4
movl (%rax), %edi
incl %edi
shlq $0x3, %rdi
callq 0x3030
movq %rax, 0x40(%rsp)
movq 0x140(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x160(%rsp,%rax)
je 0x6ba6
movq 0x7467(%rip), %rbx      # 0xdfd8
leaq 0x4571(%rip), %rsi      # 0xb0e9
movl $0x11, %edx
movq %rbx, %rdi
callq 0x32d0
testq %r15, %r15
je 0x6be2
movq %r15, %rdi
callq 0x30c0
movq 0x743f(%rip), %rdi      # 0xdfd8
movq %r15, %rsi
movq %rax, %rdx
callq 0x32d0
jmp 0x6c00
movq 0x742b(%rip), %r13      # 0xdfd8
leaq 0x4547(%rip), %rsi      # 0xb0fb
movl $0xd, %edx
movq %r13, %rdi
callq 0x32d0
testq %r15, %r15
je 0x6c19
movq %r15, %rdi
callq 0x30c0
movq 0x7403(%rip), %rdi      # 0xdfd8
movq %r15, %rsi
movq %rax, %rdx
callq 0x32d0
jmp 0x6c32
movq 0x73ef(%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 0x73ee
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 0x7387(%rip), %rdi      # 0xdfd8
callq 0x3040
movq %rax, %rdi
callq 0x3180
movzwl %bp, %eax
movq %rax, 0x10(%rsp)
leaq 0x88(%rsp), %r15
movq $0x0, 0xa0(%rsp)
leaq 0x48(%rsp), %r12
leaq 0x20(%rsp), %r14
leaq 0x78(%rsp), %rbp
movl $0x0, 0x8(%rsp)
movq $0x0, 0x68(%rsp)
movq $0x0, 0x70(%rsp)
movb $0x1, %al
movl %eax, 0x18(%rsp)
movl $0x0, 0xc(%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
movq %r12, %rsi
callq 0x3480
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x72f5
movq 0x48(%rsp), %rsi
cmpb $0x3e, (%rsi)
je 0x71c1
testb $0x1, 0xc(%rsp)
jne 0x6cb1
movq 0x50(%rsp), %rdx
movq %r14, %rdi
callq 0x3090
movq %r12, %rdi
movq %rax, %rsi
callq 0x3100
movl 0x50(%rsp), %eax
movl 0x18(%rsp), %ecx
movl %ecx, %ebx
andb $0x1, %bl
movl %eax, 0x1c(%rsp)
je 0x6f47
cmpl 0x10(%rsp), %eax
jb 0x6cb1
movq %rbp, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq 0x10(%rsp), %rcx
callq 0x3290
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3300
movq 0x78(%rsp), %rdi
cmpq %r15, %rdi
je 0x6d7c
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3270
movl 0x1c(%rsp), %eax
cmpl 0x10(%rsp), %eax
jbe 0x6f25
xorl %ebp, %ebp
xorl %r14d, %r14d
leaq 0xe8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0xd8(%rsp), %rdi
callq 0x5efa
leaq 0xd8(%rsp), %rdi
movl %ebp, %esi
callq 0x9e62
movq %rax, %r13
movq 0x40(%rsp), %rax
movq %r13, (%rax,%rbp,8)
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0x6df9
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x10(%rsp), %rax
cmpq %rax, 0x50(%rsp)
jbe 0x6e32
movq 0x48(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3490
addl $-0x41, %eax
cmpl $0x13, %eax
ja 0x6f13
movl $0x80045, %ecx          # imm = 0x80045
btl %eax, %ecx
jae 0x6f13
leaq 0x74af(%rip), %rax      # 0xe2e8
cmpl $0x7, (%rax)
je 0x6f2f
leaq 0x128(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0x118(%rsp), %rdi
callq 0x5efa
movq 0x48(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %r8d
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movq %r13, %rcx
movl %ebp, %r9d
callq 0x6772
movl %eax, %r13d
movq 0x118(%rsp), %rdi
leaq 0x128(%rsp), %rax
cmpq %rax, %rdi
je 0x6ebe
movq 0x128(%rsp), %rsi
incq %rsi
callq 0x3270
cmpl $0x6, %r13d
ja 0x6eea
movl %r13d, %eax
leaq 0x4592(%rip), %rcx      # 0xb460
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incq 0x70(%rsp)
jmp 0x6ee3
incq 0x68(%rsp)
movb $0x1, %r14b
movl %ebp, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
testb $0x1, %r14b
jne 0x6f3d
leaq 0x1(%rbp), %rax
leaq 0x73c1(%rip), %rcx      # 0xe2c4
movl (%rcx), %ecx
cmpq %rcx, %rbp
movq %rax, %rbp
jb 0x6d8f
jmp 0x6f3d
leaq 0x73ce(%rip), %rax      # 0xe2e8
movl $0x7, (%rax)
jmp 0x6e32
movl $0x0, 0x18(%rsp)
jmp 0x6f47
movb $0x1, %al
movl %eax, 0xc(%rsp)
movl $0x0, 0x18(%rsp)
leaq 0x20(%rsp), %r14
leaq 0x78(%rsp), %rbp
testb $0x1, 0xc(%rsp)
jne 0x6cb1
movl 0x1c(%rsp), %eax
subl 0x10(%rsp), %eax
movzbl %bl, %ebx
movl %eax, 0x9c(%rsp)
cmpl %ebx, %eax
jb 0x6cb1
movl 0xc(%rsp), %eax
andb $0x1, %al
jne 0x6cb1
movl %ebx, %edx
movq %rbp, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rcx
callq 0x3290
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3300
movq 0x78(%rsp), %rdi
cmpq %r15, %rdi
je 0x6faf
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x10(%rsp), %rax
addl %ebx, %eax
cmpl 0x1c(%rsp), %eax
jae 0x719f
leal 0x1(%rax), %r15d
movl %eax, %r14d
xorl %ebp, %ebp
xorl %r12d, %r12d
movl 0x8(%rsp), %eax
cmpq %rax, %rbp
jbe 0x703e
leaq 0xc8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0xb8(%rsp), %rdi
callq 0x5efa
leaq 0xb8(%rsp), %rdi
movl %ebp, %esi
callq 0x9e62
movq 0x40(%rsp), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x7066
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x7066
movq 0x40(%rsp), %rax
movq (%rax,%rbp,8), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rdx
movsbl -0x1(%rax,%rdx), %esi
movl %ebp, %ecx
callq 0x9f20
movq 0x40(%rsp), %rcx
movq %rax, (%rcx,%rbp,8)
cmpq %r15, 0x50(%rsp)
jb 0x7096
movq 0x48(%rsp), %rax
movsbl (%rax,%r14), %edi
callq 0x3490
addl $-0x41, %eax
cmpl $0x13, %eax
ja 0x7170
movl $0x80045, %ecx          # imm = 0x80045
btl %eax, %ecx
jae 0x7170
leaq 0x724b(%rip), %rax      # 0xe2e8
cmpl $0x7, (%rax)
je 0x7182
leaq 0x108(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0xf8(%rsp), %rdi
callq 0x5efa
movq 0x40(%rsp), %rax
movq (%rax,%rbp,8), %rcx
movq 0x48(%rsp), %rax
movsbl (%rax,%r14), %r8d
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movl %ebp, %r9d
callq 0x6772
movl %eax, %r13d
movq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
cmpq %rax, %rdi
je 0x7123
movq 0x108(%rsp), %rsi
incq %rsi
callq 0x3270
cmpl $0x6, %r13d
ja 0x714f
movl %r13d, %eax
leaq 0x4349(%rip), %rcx      # 0xb47c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incq 0x70(%rsp)
jmp 0x7148
incq 0x68(%rsp)
movb $0x1, %r12b
movl %ebp, 0x8(%rsp)
testb $0x1, %r12b
jne 0x7188
leaq 0x1(%rbp), %rax
leaq 0x7164(%rip), %rcx      # 0xe2c4
movl (%rcx), %ecx
cmpq %rcx, %rbp
movq %rax, %rbp
jb 0x6fcc
jmp 0x7188
leaq 0x7171(%rip), %rax      # 0xe2e8
movl $0x7, (%rax)
jmp 0x7096
movb $0x1, %al
movl %eax, 0xc(%rsp)
leaq 0x88(%rsp), %r15
leaq 0x48(%rsp), %r12
leaq 0x20(%rsp), %r14
leaq 0x78(%rsp), %rbp
incl %ebx
movl 0xc(%rsp), %eax
andb $0x1, %al
cmpl 0x9c(%rsp), %ebx
ja 0x6cb1
testb %al, %al
je 0x6f78
jmp 0x6cb1
movq 0x28(%rsp), %rdx
movq %r14, %rdi
xorl %esi, %esi
leaq 0x435e(%rip), %rcx      # 0xb530
xorl %r8d, %r8d
callq 0x33d0
movq 0xa0(%rsp), %rcx
incq %rcx
movq %rcx, %rax
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
mulq %rdx
movq %rcx, %rax
movq %rcx, 0xa0(%rsp)
movabsq $0x790fb65668c26139, %rcx # imm = 0x790FB65668C26139
imulq %rcx, %rax
rorq $0x6, %rax
movabsq $0x10c6f7a0b5ed, %rcx   # imm = 0x10C6F7A0B5ED
cmpq %rcx, %rax
ja 0x6ca3
shrq $0x12, %rdx
movq 0x6da8(%rip), %rdi      # 0xdfd8
movq %rdx, %rsi
callq 0x3160
movq %rax, %r13
movl $0x19, %edx
movq %rax, %rdi
leaq 0x3ebf(%rip), %rsi      # 0xb109
callq 0x32d0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
callq 0x9d69
movq %rbp, %rdi
leaq 0x138(%rsp), %rsi
callq 0x91dc
movl $0x13, %edx
movq 0x6d40(%rip), %rdi      # 0xdfd8
leaq 0x3e84(%rip), %rsi      # 0xb123
callq 0x32d0
movsd 0x78(%rsp), %xmm0
movsd 0x3d5e(%rip), %xmm1     # 0xb010
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movq 0x6d17(%rip), %rdi      # 0xdfd8
callq 0x3400
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
jmp 0x6ca3
movq 0x6cdc(%rip), %rbx      # 0xdfd8
leaq 0x3e34(%rip), %rsi      # 0xb137
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x32d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq 0x6caa(%rip), %rdi      # 0xdfd8
callq 0x3040
movq %rax, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x3e11(%rip), %rsi      # 0xb156
movl $0x1f, %edx
movq %rax, %rdi
callq 0x32d0
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 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x3de3(%rip), %rsi      # 0xb176
movl $0x1b, %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 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x741d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x7439
movq 0x58(%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 0x7518
jmp 0x7518
movq %rax, %r14
jmp 0x7537
movq %rax, %r14
jmp 0x7553
jmp 0x7518
jmp 0x7518
movq %rax, %r14
movq 0x118(%rsp), %rdi
leaq 0x128(%rsp), %rax
cmpq %rax, %rdi
je 0x751b
movq 0x128(%rsp), %rsi
jmp 0x750e
jmp 0x7518
movq %rax, %r14
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0x751b
movq 0xe8(%rsp), %rsi
jmp 0x750e
jmp 0x7518
jmp 0x7518
jmp 0x7518
movq %rax, %r14
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x751b
movq 0xc8(%rsp), %rsi
jmp 0x750e
movq %rax, %r14
movq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
cmpq %rax, %rdi
je 0x751b
movq 0x108(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x751b
movq %rax, %r14
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x7537
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x7553
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x140(%rsp), %rdi
callq 0x3070
movq %r14, %rdi
callq 0x3450