LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ratulSharker[P]Havec/src/common.cpp
// Function: is_prime(unsigned long long)
bool is_prime(unsigned long long n)
{
 //checks if a number is prime

   if (n < 2)
      return false;
   if (n == 2)
	   return true;
   if (n % 2 == 0)
      return false;
   for (unsigned long long x =  3 ; x < sqrt((double)n)+1; x+= 2)
   {
      if ( n % x == 0)
         return false;
   }
   return true;
}

// Assembly:
cmpq $0x2, %rdi
jae 0x754d
xorl %ecx, %ecx
jmp 0x7551
movb $0x1, %cl
jne 0x7554
movl %ecx, %eax
retq
testb $0x1, %dil
je 0x7549
movq %rdi, %xmm0
punpckldq 0xb09(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xb11(%rip), %xmm0      # 0x8080
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm0
addsd 0x1119(%rip), %xmm0     # 0x86a0
pushq $0x3
popq %rsi
movq 0xade(%rip), %xmm1      # 0x8070
movapd 0xae6(%rip), %xmm2      # 0x8080
movq %rsi, %xmm3
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm0
setbe %cl
jbe 0x7551
movq %rdi, %rax
xorl %edx, %edx
divq %rsi
addq $0x2, %rsi
testq %rdx, %rdx
jne 0x759a
jmp 0x7551
// File: /workspace/github_cpp_makefile_star2_O2/ratulSharker[P]Havec/src/common.cpp
// Function: get_a_prime_above_x(unsigned long long)
unsigned long long get_a_prime_above_x(unsigned long long x)
{

  // steps backward until n primes (other than 2) have been
  // found that are smaller than x.
	  if(is_prime(x)){
		return x;
	  }
   unsigned long long i = x+1;
   if (i % 2 == 0)
      i += 1;
   while ( i > 0)
   {
      if (is_prime(i))
		  return i;
      i += 2;
   }
   return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7543
testb %al, %al
jne 0x7605
movl %ebx, %eax
andl $0x1, %eax
leaq (%rax,%rbx), %r14
incq %r14
testq %r14, %r14
je 0x7605
movq %r14, %rdi
callq 0x7543
testb %al, %al
jne 0x7602
addq $0x2, %r14
jmp 0x75eb
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ratulSharker[P]Havec/src/common.cpp
// Function: currentDateTime()
void currentDateTime() {
    time_t     now = time(0);
    struct tm  tstruct;
    char       buf[80];
    tstruct = *localtime(&now);
    // Visit http://en.cppreference.com/w/cpp/chrono/c/strftime
    // for more information about date/time format
    strftime(buf, sizeof(buf), "%Y-%m-%d.%X", &tstruct);

    cout<<std::endl<<"current time ::"<<buf<<endl;
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
xorl %edi, %edi
callq 0x2200
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x2190
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rcx)
leaq 0x1062(%rip), %rdx      # 0x86b8
leaq 0x50(%rsp), %rbx
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x21b0
movq 0x3963(%rip), %rdi      # 0xafd0
callq 0x20e0
leaq 0x104b(%rip), %rsi      # 0x86c4
movq %rax, %rdi
callq 0x2220
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2220
movq %rax, %rdi
callq 0x20e0
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ratulSharker[P]Havec/src/common.cpp
// Function: fullHasher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
unsigned long long fullHasher(std::string khmer,unsigned int whichHashFunc){

	unsigned char map_byte = two_bit_repr[whichHashFunc]; // A T G C
	unsigned long long hashed_val = 0;
	
	//decide the hash values
	unsigned char hashA = ((map_byte & 0XC0)>>6),
				  hashT = ((map_byte & 0X30)>>4),
				  hashG = ((map_byte & 0X0C)>>2),
				  hashC = ((map_byte & 0X03));
	
	neucleotide_status = NEUCLEOTIDE_CHAIN_IS_OK;//at first assume every neucleotide is ok
	
	for(unsigned int i=0;i < khmer.length() &&
						(neucleotide_status != N_FOUND_IN_NEUCLEOTIDE);i++){
		//iterate through each & every char
		switch(toupper(khmer[i])){
			case 'A': //A = whichHashFunc % 4
				hashed_val = (hashed_val << 2) | hashA;
				break;

			case 'T'://T = (whichHashFunc + 1) % 4
				hashed_val = (hashed_val << 2) | hashT;
				break;

			case 'G'://G = (whichHashFunc + 2) % 4
				hashed_val = (hashed_val << 2) | hashG;
				break;

			case 'C'://C = (whichHashFunc + 3) % 4
				hashed_val = (hashed_val << 2) | hashC;
				break;
			
			default://N found no need to compute further
				neucleotide_status = N_FOUND_IN_NEUCLEOTIDE;
				return 0; //now check at the call side of full hasher
				break;
				
		}
	}
	
	return hashed_val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %eax
leaq 0x3bda(%rip), %rcx      # 0xb2a0
movb (%rax,%rcx), %bpl
movl %ebp, %r15d
shrb $0x6, %r15b
movl %ebp, %eax
shrb $0x4, %al
andb $0x3, %al
movb %al, 0x6(%rsp)
movl %ebp, %eax
shrb $0x2, %al
andb $0x3, %al
movb %al, 0x7(%rsp)
andb $0x3, %bpl
movl $0x8, 0x3bc3(%rip)      # 0xb2b8
movq 0x8(%rdi), %r12
xorl %r14d, %r14d
xorl %r13d, %r13d
movl %r13d, %r13d
cmpq %r13, %r12
jbe 0x774e
movq (%rbx), %rax
movsbl (%rax,%r13), %edi
callq 0x2430
movl %r15d, %ecx
cmpl $0x41, %eax
je 0x7735
movl %ebp, %ecx
cmpl $0x43, %eax
je 0x7735
movb 0x7(%rsp), %cl
cmpl $0x47, %eax
je 0x7735
movb 0x6(%rsp), %cl
cmpl $0x54, %eax
jne 0x7741
movzbl %cl, %eax
leaq (%rax,%r14,4), %r14
incl %r13d
jmp 0x76ff
movl $0x7, 0x3b6d(%rip)      # 0xb2b8
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ratulSharker[P]Havec/src/common.cpp
// Function: partialHasher(unsigned long long, char, unsigned short, unsigned int)
unsigned long long partialHasher(unsigned long long hashVal, char lastNeucleotide, unsigned short int kSize,unsigned int whichHashFunc){
	
	//security checking -- can be stopped when releasing
	if(whichHashFunc > LAST_HASH_FUNC){ //|| whichHashFunc < 0){ // un-necessay checking is removed because whichHashFunc is unsigned which value would never be negative, caught by osx g++.
		std::cout<<"invalid hash function requested :: "<<whichHashFunc<<std::endl;
		std::cout<<"Exiting..."<<std::endl;
		exit(0);
	}
	
	unsigned char map_byte = two_bit_repr[whichHashFunc]; // A T G C
	//decide the hash values
	unsigned char hashA = ((map_byte & 0XC0)>>6),
				  hashT = ((map_byte & 0X30)>>4),
				  hashG = ((map_byte & 0X0C)>>2),
				  hashC = ((map_byte & 0X03));
	//unsigned int hByte = whichHashFunc;
	unsigned int hByte;
	
	neucleotide_status = NEUCLEOTIDE_CHAIN_IS_OK;//at first assume every neucleotide is ok
	
	switch(toupper(lastNeucleotide)){
				case 'A': //A = whichHashFunc % 4
					hByte = hashA;
					break;

				case 'T'://T (whichHashFunc + 1)  % 4
					hByte = hashT;
					break;

				case 'G'://G (whichHashFunc + 2)  % 4
					hByte = hashG;
					break;

				case 'C'://C (whichHashFunc + 3)  % 4
					hByte = hashC;
					break;
				
				default://N found no need to compute further
					neucleotide_status = N_FOUND_IN_NEUCLEOTIDE;
					return 0;
					
					break;
					
	}

	hashVal = (hashVal << 2) | hByte; //actual hashing
	
	//if the khmer size is less than 32 bit -> then the hash bit at the index > 2k is invalid -- clean them man :P
	unsigned long long bitmusk = 0xFFFFFFFFFFFFFFFF; //here assumed that unsigned long long is 64 bit long
	bitmusk = bitmusk >> ((sizeof(unsigned long long) * 8 )- (2 * kSize));

	hashVal = hashVal & bitmusk;

	return hashVal ;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
cmpl %ecx, 0x3b28(%rip)      # 0xb294
jb 0x77e2
movl %edx, %ebx
movq %rdi, %r14
movl %ebp, %eax
leaq 0x3b24(%rip), %rcx      # 0xb2a0
movb (%rax,%rcx), %bpl
movl $0x8, 0x3b2e(%rip)      # 0xb2b8
movsbl %sil, %edi
callq 0x2430
cmpl $0x54, %eax
je 0x77b3
cmpl $0x43, %eax
je 0x77b7
cmpl $0x47, %eax
je 0x77ad
cmpl $0x41, %eax
jne 0x77d4
shrb $0x6, %bpl
jmp 0x77bb
shrb $0x2, %bpl
jmp 0x77b7
shrb $0x4, %bpl
andb $0x3, %bpl
movzbl %bpl, %eax
leaq (%rax,%r14,4), %rax
addl %ebx, %ebx
negb %bl
movl %ebx, %ecx
shlq %cl, %rax
shrq %cl, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x7, 0x3ada(%rip)      # 0xb2b8
xorl %eax, %eax
jmp 0x77cf
movq 0x37e7(%rip), %rbx      # 0xafd0
leaq 0xee4(%rip), %rsi       # 0x86d4
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
movl %ebp, %esi
callq 0x2330
movq %rax, %rdi
callq 0x20e0
leaq 0xee7(%rip), %rsi       # 0x86f8
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x20e0
xorl %edi, %edi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/ratulSharker[P]Havec/src/common.cpp
// Function: revhash[abi:cxx11](unsigned long long, unsigned short, unsigned int)
string _revhash(unsigned long long hashed,unsigned short hashFunc, unsigned int kSize){
	string ans="";
	for(int i=0;i< kSize ;i++){
		ans = rev_two_bit_repr((hashed) & 3,(hashFunc)) + ans;
		hashed = hashed >> 2;
	}
	return ans;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xd80(%rip), %rsi       # 0x85c8
leaq 0x8(%rsp), %r12
movq %r12, %rdx
callq 0x421e
pushq $0x5a
popq %r13
subl $0x1, %ebp
jb 0x7a0c
testw %r14w, %r14w
sete %dl
movq %r15, %rcx
andq $0x3, %rcx
sete %sil
movb $0x41, %al
testb %sil, %dl
jne 0x794d
testw %r14w, %r14w
sete %dl
cmpq $0x1, %rcx
sete %sil
testb %sil, %dl
je 0x789a
movb $0x54, %al
jmp 0x794d
testw %r14w, %r14w
sete %dl
cmpq $0x2, %rcx
sete %sil
testb %sil, %dl
je 0x78b5
movb $0x47, %al
jmp 0x794d
testq %rcx, %rcx
sete %dl
cmpw $0x1, %r14w
sete %sil
testw %r14w, %r14w
sete %dil
cmpq $0x3, %rcx
sete %r8b
testb %r8b, %dil
jne 0x794b
andb %dl, %sil
jne 0x794b
cmpq $0x1, %rcx
sete %dl
cmpw $0x1, %r14w
sete %sil
testb %dl, %sil
jne 0x794d
cmpq $0x2, %rcx
sete %dl
cmpw $0x1, %r14w
sete %sil
testb %dl, %sil
jne 0x7893
cmpq $0x3, %rcx
sete %dil
testq %rcx, %rcx
sete %dl
cmpw $0x2, %r14w
sete %sil
cmpw $0x1, %r14w
sete %r8b
testb %dil, %r8b
jne 0x78ae
andb %dl, %sil
jne 0x78ae
cmpq $0x1, %rcx
sete %dl
cmpw $0x2, %r14w
sete %sil
testb %dl, %sil
je 0x7977
movb $0x43, %al
movzbl %al, %esi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x7a84
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22e0
movq %r12, %rdi
callq 0x20c0
shrq $0x2, %r15
jmp 0x7859
cmpq $0x2, %rcx
sete %dl
cmpw $0x2, %r14w
sete %sil
testb %dl, %sil
jne 0x794d
cmpq $0x3, %rcx
sete %al
testq %rcx, %rcx
sete %dl
cmpw $0x3, %r14w
sete %sil
cmpw $0x2, %r14w
sete %dil
testb %al, %dil
jne 0x7893
movb $0x54, %al
andb %dl, %sil
jne 0x794d
cmpq $0x1, %rcx
sete %dl
cmpw $0x3, %r14w
sete %sil
movb $0x47, %al
testb %dl, %sil
jne 0x794d
cmpq $0x2, %rcx
sete %dl
cmpw $0x3, %r14w
sete %sil
movb $0x43, %al
testb %dl, %sil
jne 0x794d
cmpq $0x3, %rcx
movl %r13d, %eax
pushq $0x41
popq %rcx
cmovel %ecx, %eax
cmpw $0x3, %r14w
cmovnel %r13d, %eax
jmp 0x794d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: pathshow()
void pathshow(){
	gotoxy(height+4,20);
	if(pathdup.size()<55){
		cout<<"Path : ./"<<pathdup.substr(home.length());
	}
	else{ 
		cout<<"Path : ./"<<pathdup.substr(0,45)<<" ..";
	}
	gotoxy(y+start_x-1,1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0xb99f(%rip), %esi      # 0xf278
addl $0x4, %esi
leaq 0x77a5(%rip), %rdi      # 0xb088
pushq $0x14
popq %rdx
xorl %eax, %eax
callq 0x3050
movq 0xbb6c(%rip), %r14      # 0xf460
movq 0xb6cd(%rip), %rdi      # 0xefc8
leaq 0x778f(%rip), %rsi      # 0xb091
callq 0x3230
movq %rax, %rbx
cmpq $0x36, %r14
ja 0x393b
movq 0xbb69(%rip), %rdx      # 0xf480
leaq 0xbb3a(%rip), %rsi      # 0xf458
leaq 0x8(%rsp), %r14
pushq $-0x1
popq %rcx
movq %r14, %rdi
callq 0x3270
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31f0
jmp 0x396e
leaq 0xbb16(%rip), %rsi      # 0xf458
leaq 0x8(%rsp), %r14
pushq $0x2d
popq %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3270
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31f0
leaq 0x7735(%rip), %rsi      # 0xb09b
movq %rax, %rdi
callq 0x3230
leaq 0x8(%rsp), %rdi
callq 0x34d8
movl 0xb906(%rip), %eax      # 0xf284
movl 0xb8f8(%rip), %ecx      # 0xf27c
leal (%rax,%rcx), %esi
decl %esi
leaq 0x76f8(%rip), %rdi      # 0xb088
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0x3050
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x39a4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x34d8
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: getactualpath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string getactualpath(string pathx){

	int i = pathx.size()-1;
	while(i>1){
	
		if(pathx[i]=='/'){
		break;
		}
	i--;
	}
	return pathx.substr(0,i);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
movl %ecx, %eax
decl %ecx
movslq %ecx, %rdx
movq %rdx, %rcx
decq %rax
cmpl $0x2, %eax
jl 0x39e9
movl %eax, %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movq (%rsi), %r8
leaq -0x1(%rcx), %rdx
cmpb $0x2f, (%r8,%rdi)
jne 0x39c8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3270
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: INThandler(int)
void  INThandler(int sig)
{
	char  c;
	gotoxy(1,1);

	for(int j = 1;j<=height+9;j++){
		gotoxy(j,1);

		for(int j = 1;j<79;j++){

			cout<<" ";
		}
     	}
	signal(sig, SIG_IGN);

	tcsetattr(0, TCSANOW, &initial_settings); 

	real_clean();
	fflush(stdout);	
	gotoxy(1,1);

	exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, 0x4(%rsp)
leaq 0x767a(%rip), %rdi      # 0xb088
pushq $0x1
popq %r13
movl %r13d, %esi
movl %r13d, %edx
xorl %eax, %eax
callq 0x3050
pushq $0x4e
popq %r14
movq 0xb59e(%rip), %r15      # 0xefc8
leaq 0x76f1(%rip), %r12      # 0xb122
movl %r13d, %ebp
movl 0xb83e(%rip), %eax      # 0xf278
addl $0x9, %eax
cmpl %eax, %r13d
jg 0x3a6f
leaq 0x763f(%rip), %rdi      # 0xb088
movl %r13d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3050
movl %r14d, %ebx
subl $0x1, %ebx
jb 0x3a6a
movq %r15, %rdi
movq %r12, %rsi
callq 0x3230
jmp 0x3a58
incl %r13d
jmp 0x3a34
pushq $0x1
popq %rsi
movl 0x4(%rsp), %edi
callq 0x32e0
leaq 0xba2a(%rip), %rdx      # 0xf4ac
xorl %edi, %edi
xorl %esi, %esi
callq 0x3330
callq 0x3ab9
movq 0xb509(%rip), %rax      # 0xefa0
movq (%rax), %rdi
callq 0x32c0
leaq 0x75e2(%rip), %rdi      # 0xb088
pushq $0x1
popq %rdx
movl %edx, %esi
xorl %eax, %eax
callq 0x3050
xorl %edi, %edi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: real_clean()
void real_clean(){

	for(int i=0;i<height+3;i++){ 
		gotoxy(i+start_x,1);
		for(int j = 1;j<80;j++){
			cout<<" ";
		}

	}
	gotoxy(start_x,start_y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbp
pushq $0x4f
popq %rbx
movq 0xb4f7(%rip), %r14      # 0xefc8
leaq 0x764a(%rip), %r15      # 0xb122
xorl %r13d, %r13d
movl 0xb797(%rip), %eax      # 0xf278
addl $0x3, %eax
movl 0xb792(%rip), %esi      # 0xf27c
cmpl %eax, %r13d
jge 0x3b1d
addl %r13d, %esi
leaq 0x758f(%rip), %rdi      # 0xb088
movl %ebp, %edx
xorl %eax, %eax
callq 0x3050
movl %ebx, %r12d
subl $0x1, %r12d
jb 0x3b18
movq %r14, %rdi
movq %r15, %rsi
callq 0x3230
jmp 0x3b05
incl %r13d
jmp 0x3adb
movl 0xb75d(%rip), %edx      # 0xf280
leaq 0x755e(%rip), %rdi      # 0xb088
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3050
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: init_Search_Screen()
void init_Search_Screen(){
	gotoxy(1,1);
	for(int j = 1;j<78;j++){
		cout<<" ";
	}
	gotoxy(1,1);
	cout << "\e[1m\tName\e[0m" ;
	printf("\033[1;28H");
	cout << "\e[1mPath\e[0m" ;
	
	gotoxy(2,1);
	for(int j = 1;j<78;j++){
		cout<<"=";
	}
	gotoxy(height+3,1);
	for(int i =1;i<78;i++){
		cout<<"=";
	}
	gotoxy(height+5,1);
	for(int i =1;i<78;i++){
		cout<<"=";
	}
	gotoxy(height+4,1);

	cout<<mode_name[mode_num];
	gotoxy(start_x,start_y);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x753e(%rip), %rdi      # 0xb088
pushq $0x1
popq %rdx
movl %edx, %esi
xorl %eax, %eax
callq 0x3050
pushq $0x4d
popq %rbp
movq 0xb468(%rip), %rbx      # 0xefc8
leaq 0x75bb(%rip), %r14      # 0xb122
subl $0x1, %ebp
jb 0x3b79
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3230
jmp 0x3b67
leaq 0x7508(%rip), %r14      # 0xb088
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3050
movq 0xb430(%rip), %rbx      # 0xefc8
leaq 0x7500(%rip), %rsi      # 0xb09f
movq %rbx, %rdi
callq 0x3230
leaq 0x74ff(%rip), %rdi      # 0xb0ad
xorl %eax, %eax
callq 0x3050
leaq 0x74f9(%rip), %rsi      # 0xb0b5
movq %rbx, %rdi
callq 0x3230
pushq $0x2
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3050
pushq $0x4d
popq %rbp
leaq 0x74e5(%rip), %r14      # 0xb0c2
subl $0x1, %ebp
jb 0x3bef
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3230
jmp 0x3bdd
movl 0xb683(%rip), %esi      # 0xf278
addl $0x3, %esi
leaq 0x7489(%rip), %rdi      # 0xb088
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0x3050
pushq $0x4d
popq %rbp
movq 0xb3b5(%rip), %rbx      # 0xefc8
leaq 0x74a8(%rip), %r14      # 0xb0c2
subl $0x1, %ebp
jb 0x3c2c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3230
jmp 0x3c1a
movl 0xb646(%rip), %esi      # 0xf278
addl $0x5, %esi
leaq 0x744c(%rip), %rdi      # 0xb088
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0x3050
pushq $0x4d
popq %rbp
movq 0xb378(%rip), %rbx      # 0xefc8
leaq 0x746b(%rip), %r14      # 0xb0c2
subl $0x1, %ebp
jb 0x3c69
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3230
jmp 0x3c57
movl 0xb609(%rip), %esi      # 0xf278
addl $0x4, %esi
leaq 0x740f(%rip), %rbx      # 0xb088
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3050
movslq 0xb923(%rip), %rax      # 0xf5b0
shlq $0x5, %rax
leaq 0xb8d8(%rip), %rsi      # 0xf570
addq %rax, %rsi
movq 0xb326(%rip), %rdi      # 0xefc8
callq 0x31f0
movl 0xb5cf(%rip), %esi      # 0xf27c
movl 0xb5cd(%rip), %edx      # 0xf280
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3050
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: removeDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void removeDirectory(string dirname){
	infinite_loop++;
	if(infinite_loop>100){
		return;		
	}

	struct dirent ** list;
	int nn=scandir(dirname.c_str(),&list,NULL,alphasort);
	
	for(int i = 2;i<nn;i++){
		string ss  =dirname+"/"+list[i]->d_name;
		if((int)list[i]->d_type==4){
			removeDirectory(ss.c_str());
			remove(ss.c_str());		
		}
		else if((int)list[i]->d_type==8){
			
			remove(ss.c_str());	
		}
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl 0xa9a5(%rip), %eax      # 0xf62c
leal 0x1(%rax), %ecx
movl %ecx, 0xa99c(%rip)      # 0xf62c
cmpl $0x63, %eax
jle 0x4ca4
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0xa30f(%rip), %rcx      # 0xefc0
movq %rsp, %rsi
xorl %edx, %edx
callq 0x3070
movslq %eax, %rbp
pushq $0x2
popq %r14
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
cmpq %rbp, %r14
jge 0x4c95
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x63b6(%rip), %rdx      # 0xb099
callq 0xa27a
movq (%rsp), %rax
movq (%rax,%r14,8), %rdx
addq $0x13, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xa2b2
movq %r15, %rdi
callq 0x34d8
movq (%rsp), %rax
movq (%rax,%r14,8), %rax
movzbl 0x12(%rax), %eax
cmpl $0x8, %eax
je 0x4d3d
cmpl $0x4, %eax
jne 0x4d47
movq 0x8(%rsp), %rsi
movq %r13, %rdi
movq %r15, %rdx
callq 0xa1da
movq %r13, %rdi
callq 0x4c73
movq %r13, %rdi
callq 0x34d8
movq 0x8(%rsp), %rdi
callq 0x3450
movq %r12, %rdi
callq 0x34d8
incq %r14
jmp 0x4cd1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x34d8
jmp 0x4d69
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x4d78
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x34d8
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: searchfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int searchfile(string pathx,string filename){
	

	struct dirent ** list;
	int nn=scandir(pathx.c_str(),&list,NULL,alphasort);
	int resuld=0,resulf = 0;
	for(int i = 2;i<nn;i++){
		if((int)list[i]->d_type==4){
			resuld = searchfile(pathx+"/"+list[i]->d_name,filename);
				
		}
		else if((int)list[i]->d_type==8){
			if(filename.compare(list[i]->d_name)==0){
				search_path.push_back(pathx);
				
				resulf=1;			
			}
		}
	}
	if(resulf==1){return 1;}
		if(resuld==1){return 1;}
		
	return 0; 
		
	 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq (%rdi), %rdi
movq 0xa21b(%rip), %rcx      # 0xefc0
xorl %r12d, %r12d
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x3070
movslq %eax, %r14
pushq $0x2
popq %r13
leaq 0x58(%rsp), %rbp
leaq 0x38(%rsp), %r15
movl $0x0, 0x4(%rsp)
cmpq %r14, %r13
jge 0x4e87
movq 0x10(%rsp), %rax
movq (%rax,%r13,8), %rsi
movzbl 0x12(%rsi), %eax
cmpl $0x8, %eax
je 0x4e57
cmpl $0x4, %eax
jne 0x4e7f
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq 0x8(%rsp), %rsi
leaq 0x6294(%rip), %rdx      # 0xb099
callq 0xa27a
movq 0x10(%rsp), %rax
movq (%rax,%r13,8), %rdx
addq $0x13, %rdx
movq %rbp, %rdi
movq %r12, %rsi
callq 0xa2b2
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3350
movq %rbp, %rdi
movq %r15, %rsi
callq 0x4d85
movl %eax, %r12d
movq %r15, %rdi
callq 0x34d8
movq %rbp, %rdi
callq 0x34d8
leaq 0x18(%rsp), %rdi
callq 0x34d8
jmp 0x4e7f
addq $0x13, %rsi
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
jne 0x4e7f
leaq 0xa9d2(%rip), %rdi      # 0xf840
movq 0x8(%rsp), %rsi
callq 0xa348
pushq $0x1
popq %rax
movl %eax, 0x4(%rsp)
incq %r13
jmp 0x4dcd
cmpl $0x1, 0x4(%rsp)
sete %al
cmpl $0x1, %r12d
sete %cl
orb %al, %cl
movzbl %cl, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x34d8
jmp 0x4ebc
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x34d8
jmp 0x4ecb
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x34d8
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: copy_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void copy_file(string sr,string dt){

	FILE *source, *target;
	int i;
 
	source = fopen(sr.c_str(), "r"); 



	fseek(source, 0, SEEK_END);
	int length = ftell(source);

	fseek(source, 0, SEEK_SET);
	target = fopen(dt.c_str(), "w"); 


	for(i = 0; i < length; i++){
    		fputc(fgetc(source), target);
	}

	 
	fclose(source); 
	fclose(target);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rdi
leaq 0x5eb6(%rip), %rsi      # 0xb195
callq 0x32d0
movq %rax, %rbx
xorl %r12d, %r12d
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x3290
movq %rbx, %rdi
callq 0x3030
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3290
movq (%r14), %rdi
leaq 0x5e02(%rip), %rsi      # 0xb11a
callq 0x32d0
movq %rax, %r14
testl %r15d, %r15d
cmovgl %r15d, %r12d
subl $0x1, %r12d
jb 0x5341
movq %rbx, %rdi
callq 0x33c0
movl %eax, %edi
movq %r14, %rsi
callq 0x3320
jmp 0x5327
movq %rbx, %rdi
callq 0x3240
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, char)
int split(string &txt, vector<string> &strs, char ch)
{
	strs.clear();
	int i = 0;
	int ip=0,which;
	while(i<txt.size()){

		if(txt[i]=='\''){
			i++;
			ip=i;
			while(txt[i]!='\''){
				if(txt[i]=='\\'){
					txt.erase(i,1);			
				}			
			i++;
			}
	
			strs.push_back(txt.substr(ip,i-ip));
			i=i+2;
			ip=i;
			which=1;
		}
	
		else if(txt[i]==' '){

			strs.push_back(txt.substr(ip,i-ip));
			i++;	
			ip=i;
			which=2;
		}else{
			i++;	
			which=3;
		}
	}
	if(which==3){
		strs.push_back(txt.substr(ip,i-ip));
	}


	return strs.size();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xa374
xorl %ebp, %ebp
pushq $0x1
popq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
movslq %ebp, %rdx
leaq (%rax,%rdx), %rsi
leal 0x3(%rdx), %r15d
xorl %r13d, %r13d
xorl %edi, %edi
leaq (%rdx,%r13), %r8
cmpq %r8, %rcx
jbe 0x54b0
movzbl (%rsi,%r13), %edi
cmpl $0x20, %edi
je 0x5412
cmpl $0x27, %edi
je 0x543f
incq %r13
incl %r15d
movb $0x1, %dil
jmp 0x53eb
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rcx
callq 0x3270
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaac0
movq %r15, %rdi
callq 0x34d8
addl %r13d, %ebp
incl %ebp
jmp 0x53d4
movq %rbx, (%rsp)
leal 0x1(%rbp,%r13), %ecx
movslq %ecx, %r13
xorl %ebx, %ebx
movq %r13, %rbp
movzbl (%rax,%rbp), %ecx
cmpl $0x5c, %ecx
je 0x5460
cmpl $0x27, %ecx
jne 0x5471
jmp 0x547b
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x3080
movq (%r14), %rax
incq %rbp
incl %r15d
incl %ebx
jmp 0x5450
movslq %ebx, %rcx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x3270
movq (%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xaac0
movq %rbp, %rdi
callq 0x34d8
movl %r15d, %ebp
jmp 0x53d4
testb $0x1, %dil
je 0x54de
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rcx
callq 0x3270
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaac0
leaq 0x8(%rsp), %rdi
callq 0x34d8
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x5, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54fc
jmp 0x54fc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x34d8
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: init_Screen()
void init_Screen(){
	gotoxy(1,1);
	cout << "\e[1m\tName\e[0m" ;
	printf("\033[1;28H");
	cout << "\e[1mSize\e[0m" ;
	printf("\033[1;36H");
	cout << "\e[1mPermissions\e[0m" ;
	printf("\033[1;50H");
	cout << "\e[1mOwner & Group\e[0m" ;
	printf("\033[1;66H");
	cout << "\e[1mLast Modified\e[0m" ;
	gotoxy(2,1);
	for(int j = 1;j<78;j++){
		cout<<"=";
	}
	gotoxy(height+3,1);
	for(int i =1;i<78;i++){
		cout<<"=";
	}
	gotoxy(height+5,1);
	for(int i =1;i<78;i++){
		cout<<"=";
	}
	gotoxy(height+4,1);

	cout<<mode_name[mode_num];
	gotoxy(start_x,start_y);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x5b6c(%rip), %r14      # 0xb088
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3050
movq 0x9a94(%rip), %rbx      # 0xefc8
leaq 0x5b64(%rip), %rsi      # 0xb09f
movq %rbx, %rdi
callq 0x3230
leaq 0x5b63(%rip), %rdi      # 0xb0ad
xorl %eax, %eax
callq 0x3050
leaq 0x5bcc(%rip), %rsi      # 0xb124
movq %rbx, %rdi
callq 0x3230
leaq 0x5bca(%rip), %rdi      # 0xb131
xorl %eax, %eax
callq 0x3050
leaq 0x5bc4(%rip), %rsi      # 0xb139
movq %rbx, %rdi
callq 0x3230
leaq 0x5bc9(%rip), %rdi      # 0xb14d
xorl %eax, %eax
callq 0x3050
leaq 0x5bc3(%rip), %rsi      # 0xb155
movq %rbx, %rdi
callq 0x3230
leaq 0x5bca(%rip), %rdi      # 0xb16b
xorl %eax, %eax
callq 0x3050
leaq 0x5bc4(%rip), %rsi      # 0xb173
movq %rbx, %rdi
callq 0x3230
pushq $0x2
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3050
pushq $0x4d
popq %rbp
leaq 0x5af2(%rip), %r14      # 0xb0c2
subl $0x1, %ebp
jb 0x55e2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3230
jmp 0x55d0
movl 0x9c90(%rip), %esi      # 0xf278
addl $0x3, %esi
leaq 0x5a96(%rip), %rdi      # 0xb088
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0x3050
pushq $0x4d
popq %rbp
movq 0x99c2(%rip), %rbx      # 0xefc8
leaq 0x5ab5(%rip), %r14      # 0xb0c2
subl $0x1, %ebp
jb 0x561f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3230
jmp 0x560d
movl 0x9c53(%rip), %esi      # 0xf278
addl $0x5, %esi
leaq 0x5a59(%rip), %rdi      # 0xb088
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0x3050
pushq $0x4d
popq %rbp
movq 0x9985(%rip), %rbx      # 0xefc8
leaq 0x5a78(%rip), %r14      # 0xb0c2
subl $0x1, %ebp
jb 0x565c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3230
jmp 0x564a
movl 0x9c16(%rip), %esi      # 0xf278
addl $0x4, %esi
leaq 0x5a1c(%rip), %rbx      # 0xb088
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3050
movslq 0x9f30(%rip), %rax      # 0xf5b0
shlq $0x5, %rax
leaq 0x9ee5(%rip), %rsi      # 0xf570
addq %rax, %rsi
movq 0x9933(%rip), %rdi      # 0xefc8
callq 0x31f0
movl 0x9bdc(%rip), %esi      # 0xf27c
movl 0x9bda(%rip), %edx      # 0xf280
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3050
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: print_command_mode_Scroll(int)
void print_command_mode_Scroll(int p){
	gotoxy(height+6,1);
	for(int i = 0;i<=command_mode_height+2;i++){
		gotoxy(height+6+i,1);
		for(int j=1;j<80;j++){
			cout<<" ";
		}
	}
	gotoxy(height+6,1);
	if(p==1){
		if(display_commands.size()>command_mode_height){
			scroll_command_position+=2;
		}
	}
	for(int i = scroll_command_position;i<display_commands.size();i++){
		if(i%2==0){
			cout<<"> "<<display_commands[i]<<endl;
		}else{
			cout<<"  "<<display_commands[i]<<endl;
		}
		
	}
	cout<<"> ";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, 0x4(%rsp)
movl 0x9baf(%rip), %esi      # 0xf278
addl $0x6, %esi
leaq 0x59b5(%rip), %rdi      # 0xb088
pushq $0x1
popq %rbp
movl %ebp, %edx
xorl %eax, %eax
callq 0x3050
pushq $0x4f
popq %r14
movq 0x98de(%rip), %r15      # 0xefc8
leaq 0x5a31(%rip), %r12      # 0xb122
xorl %ebx, %ebx
movl 0x9b8f(%rip), %eax      # 0xf288
addl $0x2, %eax
movl 0x9b76(%rip), %esi      # 0xf278
cmpl %eax, %ebx
jg 0x5735
addl %ebx, %esi
addl $0x6, %esi
leaq 0x5976(%rip), %rdi      # 0xb088
movl %ebp, %edx
xorl %eax, %eax
callq 0x3050
movl %r14d, %r13d
subl $0x1, %r13d
jb 0x5731
movq %r15, %rdi
movq %r12, %rsi
callq 0x3230
jmp 0x571e
incl %ebx
jmp 0x56f3
addl $0x6, %esi
leaq 0x5949(%rip), %rdi      # 0xb088
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0x3050
cmpl $0x1, 0x4(%rsp)
jne 0x577f
movq 0x9ea1(%rip), %rcx      # 0xf5f8
subq 0x9e92(%rip), %rcx      # 0xf5f0
sarq $0x5, %rcx
movslq 0x9b1f(%rip), %rdx      # 0xf288
movl 0x9eb9(%rip), %eax      # 0xf628
cmpq %rdx, %rcx
jbe 0x5785
addl $0x2, %eax
movl %eax, 0x9eab(%rip)      # 0xf628
jmp 0x5785
movl 0x9ea3(%rip), %eax      # 0xf628
movslq %eax, %r14
movq %r14, %r15
shlq $0x5, %r15
leaq 0x59f3(%rip), %r12      # 0xb189
leaq 0x5984(%rip), %r13      # 0xb121
movq 0x9824(%rip), %rbx      # 0xefc8
movq 0x9e4d(%rip), %rax      # 0xf5f8
subq 0x9e3e(%rip), %rax      # 0xf5f0
sarq $0x5, %rax
cmpq %r14, %rax
jbe 0x57f1
testb $0x1, %r14b
movq %r13, %rsi
cmoveq %r12, %rsi
movq %rbx, %rdi
callq 0x3230
movq 0x9e1b(%rip), %rsi      # 0xf5f0
addq %r15, %rsi
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3130
incq %r14
addq $0x20, %r15
jmp 0x57a4
movq 0x97d0(%rip), %rdi      # 0xefc8
leaq 0x598a(%rip), %rsi      # 0xb189
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O2/danish241194[P]Linux-Terminal-Based-File-Explorer/start_page.cpp
// Function: check_file_exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int check_file_exists(string file_name){
int flag = 0;
for(int i=2;i<n;i++){
	if(file_name.compare(namelist[i]->d_name)==0){
			flag=namelist[i]->d_type;	
			break;		
		}
}
return flag;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %r14
movslq 0x9d40(%rip), %rax      # 0xf564
cmpq %rax, %r14
jge 0x5859
movq 0x9c68(%rip), %rax      # 0xf498
movq (%rax,%r14,8), %rsi
addq $0x13, %rsi
movq %rbx, %rdi
callq 0x30c0
incq %r14
testl %eax, %eax
jne 0x581d
movq 0x9c4a(%rip), %rax      # 0xf498
movq -0x8(%rax,%r14,8), %rax
movzbl 0x12(%rax), %eax
jmp 0x585b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: init_genrand(unsigned long)
void init_genrand(unsigned long s)
{
    mt[0]= s & 0xffffffffUL;
    for (mti=1; mti<N; mti++) {
        mt[mti] =
            (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
        /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
        /* In the previous versions, MSBs of the seed affect   */
        /* only MSBs of the array mt[].                        */
        /* 2002/01/09 modified by Makoto Matsumoto             */
        mt[mti] &= 0xffffffffUL;
        /* for >32 bit machines */
    }
}

// Assembly:
movl %edi, %eax
movq %rax, 0x18b3b(%rip)     # 0x1c2e0
pushq $0x1
popq %rcx
leaq 0x18b31(%rip), %rdx     # 0x1c2e0
cmpq $0x270, %rcx            # imm = 0x270
je 0x37d2
movq %rax, %rsi
shrq $0x1e, %rsi
xorl %eax, %esi
imull $0x6c078965, %esi, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, (%rdx,%rcx,8)
incq %rcx
jmp 0x37af
movl $0x270, 0x18ad4(%rip)   # imm = 0x270
retq
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: init_by_array(unsigned long*, int)
void init_by_array(unsigned long init_key[], int key_length)
{
    int i, j, k;
    init_genrand(19650218UL);
    i=1; j=0;
    k = (N>key_length ? N : key_length);
    for (; k; k--) {
        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL))
          + init_key[j] + j; /* non linear */
        mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
        i++; j++;
        if (i>=N) { mt[0] = mt[N-1]; i=1; }
        if (j>=key_length) j=0;
    }
    for (k=N-1; k; k--) {
        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL))
          - i; /* non linear */
        mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
        i++;
        if (i>=N) { mt[0] = mt[N-1]; i=1; }
    }

    mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x12bd6aa, %edi        # imm = 0x12BD6AA
callq 0x379c
cmpl $0x271, %ebx            # imm = 0x271
movl $0x270, %edx            # imm = 0x270
cmovgel %ebx, %edx
xorl %esi, %esi
pushq $0x1
popq %rdi
leaq 0x18ad5(%rip), %rax     # 0x1c2e0
movl %edi, %ecx
xorl %r8d, %r8d
subl $0x1, %edx
jb 0x386b
movslq %ecx, %r9
movq -0x8(%rax,%r9,8), %r10
movq %r10, %r11
shrq $0x1e, %r11
xorl %r10d, %r11d
imull $0x19660d, %r11d, %r10d # imm = 0x19660D
xorl (%rax,%r9,8), %r10d
movslq %r8d, %r11
movl (%r14,%r11,8), %r15d
addl %r11d, %r15d
addl %r10d, %r15d
movq %r15, (%rax,%r9,8)
cmpl $0x26f, %ecx            # imm = 0x26F
jge 0x384f
incl %ecx
jmp 0x385f
movq 0x19e02(%rip), %rcx     # 0x1d658
movq %rcx, 0x18a83(%rip)     # 0x1c2e0
movl %edi, %ecx
incl %r8d
cmpl %ebx, %r8d
cmovgel %esi, %r8d
jmp 0x3810
movl $0xfffffd91, %edx       # imm = 0xFFFFFD91
pushq $0x1
popq %rsi
testl %edx, %edx
je 0x38bb
movslq %ecx, %rdi
movq -0x8(%rax,%rdi,8), %r8
movq %r8, %r9
shrq $0x1e, %r9
xorl %r8d, %r9d
imull $0x5d588b65, %r9d, %r8d # imm = 0x5D588B65
xorl (%rax,%rdi,8), %r8d
subl %edi, %r8d
movq %r8, (%rax,%rdi,8)
cmpl $0x26f, %ecx            # imm = 0x26F
jge 0x38a7
incl %ecx
jmp 0x38b7
movq 0x19daa(%rip), %rcx     # 0x1d658
movq %rcx, 0x18a2b(%rip)     # 0x1c2e0
movl %esi, %ecx
incl %edx
jmp 0x3873
movl $0x80000000, %eax       # imm = 0x80000000
movq %rax, 0x18a19(%rip)     # 0x1c2e0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: genrand_int32()
unsigned long genrand_int32(void)
{
    unsigned long y;
    static unsigned long mag01[2]={0x0UL, MATRIX_A};
    /* mag01[x] = x * MATRIX_A  for x=0,1 */

    if (mti >= N) { /* generate N words at one time */
        int kk;

        if (mti == N+1)   /* if init_genrand() has not been called, */
            init_genrand(5489UL); /* a default initial seed is used */

        for (kk=0;kk<N-M;kk++) {
            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
            mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1UL];
        }
        for (;kk<N-1;kk++) {
            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
            mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
        }
        y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
        mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];

        mti = 0;
    }

    y = mt[mti++];

    /* Tempering */
    y ^= (y >> 11);
    y ^= (y << 7) & 0x9d2c5680UL;
    y ^= (y << 15) & 0xefc60000UL;
    y ^= (y >> 18);

    return y;
}

// Assembly:
movslq 0x189dc(%rip), %rax     # 0x1c2b0
cmpq $0x26f, %rax            # imm = 0x26F
jle 0x3946
cmpl $0x271, %eax            # imm = 0x271
jne 0x38f2
pushq %rax
movl $0x1571, %edi           # imm = 0x1571
callq 0x379c
addq $0x8, %rsp
xorl %edx, %edx
leaq 0x189e5(%rip), %rcx     # 0x1c2e0
movl $0x80000000, %esi       # imm = 0x80000000
leaq 0xe769(%rip), %rax      # 0x12070
cmpq $0xe3, %rdx
je 0x3958
movl (%rcx,%rdx,8), %edi
andl %esi, %edi
movl 0x8(%rcx,%rdx,8), %r8d
movl %r8d, %r9d
andl $0x7ffffffe, %r9d       # imm = 0x7FFFFFFE
orl %edi, %r9d
shrl %r9d
andl $0x1, %r8d
movq (%rax,%r8,8), %rdi
xorq 0xc68(%rcx,%rdx,8), %rdi
xorq %r9, %rdi
movq %rdi, (%rcx,%rdx,8)
incq %rdx
jmp 0x3907
leaq 0x18993(%rip), %rcx     # 0x1c2e0
movq (%rcx,%rax,8), %rcx
incl %eax
jmp 0x39e0
xorl %edx, %edx
movl $0x80000000, %esi       # imm = 0x80000000
cmpq $0x18c, %rdx            # imm = 0x18C
je 0x39a5
movl 0x718(%rcx,%rdx,8), %edi
andl %esi, %edi
movl 0x720(%rcx,%rdx,8), %r8d
movl %r8d, %r9d
andl $0x7ffffffe, %r9d       # imm = 0x7FFFFFFE
orl %edi, %r9d
andl $0x1, %r8d
movq (%rax,%r8,8), %rdi
xorq (%rcx,%rdx,8), %rdi
shrl %r9d
xorq %r9, %rdi
movq %rdi, 0x718(%rcx,%rdx,8)
incq %rdx
jmp 0x395f
movl $0x80000000, %edx       # imm = 0x80000000
andl 0x19ca8(%rip), %edx     # 0x1d658
movq 0x18929(%rip), %rcx     # 0x1c2e0
movl %ecx, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
orl %edx, %esi
movl %ecx, %edx
andl $0x1, %edx
movq (%rax,%rdx,8), %rax
xorq 0x1956f(%rip), %rax     # 0x1cf40
shrl %esi
xorq %rsi, %rax
movq %rax, 0x19c7b(%rip)     # 0x1d658
pushq $0x1
popq %rax
movl %eax, 0x188ca(%rip)     # 0x1c2b0
movq %rcx, %rax
shrq $0xb, %rax
xorq %rcx, %rax
movl %eax, %ecx
shll $0x7, %ecx
andl $0x9d2c5680, %ecx       # imm = 0x9D2C5680
xorq %rax, %rcx
movl %ecx, %edx
shll $0xf, %edx
andl $0xefc60000, %edx       # imm = 0xEFC60000
xorq %rcx, %rdx
movq %rdx, %rax
shrq $0x12, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: operator<<(std::ostream&, unit const&)
ostream &operator<<(ostream &os, const unit &u)
{
  os << "{ " << u.pivot << ", [";
  for (auto &i: u.members)
    os << i << ", ";
  os << "] }";
  return os;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xe7ff(%rip), %rsi      # 0x12320
callq 0x32f0
leaq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x93ad
leaq 0xe7ea(%rip), %rsi      # 0x12323
movq %rax, %rdi
callq 0x32f0
movq (%r15), %r14
movq 0x8(%r15), %r12
leaq 0xe7d8(%rip), %r15      # 0x12327
cmpq %r12, %r14
je 0x3b70
movq %rbx, %rdi
movq %r14, %rsi
callq 0x93ad
movq %rax, %rdi
movq %r15, %rsi
callq 0x32f0
addq $0x8, %r14
jmp 0x3b4f
leaq 0xe7b3(%rip), %rsi      # 0x1232a
movq %rbx, %rdi
callq 0x32f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: operator<<(std::ostream&, problem const&)
ostream &operator<<(ostream &os, const problem &p)
{
  os << "id: " << p.id << endl;
  os << "units:" << endl;
  for (auto &u: p.units)
    os << "  " << u << endl;
  os << "width: " << p.width << endl;
  os << "height: " << p.height << endl;
  os << "filled: ";
  for (auto &q: p.filled)
    os << q << ", ";
  os << endl;
  os << "sourceLength: " << p.source_length << endl;
  os << "sourceSeeds: ";
  for (auto &s: p.source_seeds)
    os << s << ", ";
  os << endl;
  return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xe788(%rip), %rsi      # 0x1232e
callq 0x32f0
movl (%r14), %esi
movq %rax, %rdi
callq 0x3490
movq %rax, %rdi
callq 0x3130
leaq 0xe76e(%rip), %rsi      # 0x12333
movq %rbx, %rdi
callq 0x32f0
movq %rax, %rdi
callq 0x3130
movq 0x8(%r14), %r15
movq 0x10(%r14), %rbp
leaq 0xe95d(%rip), %r12      # 0x12541
cmpq %rbp, %r15
je 0x3c10
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32f0
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x3b0c
movq %r13, %rdi
callq 0x3130
addq $0x28, %r15
jmp 0x3be4
leaq 0xe723(%rip), %rsi      # 0x1233a
movq %rbx, %rdi
callq 0x32f0
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x3490
movq %rax, %rdi
callq 0x3130
leaq 0xe708(%rip), %rsi      # 0x12342
movq %rbx, %rdi
callq 0x32f0
movl 0x24(%r14), %esi
movq %rax, %rdi
callq 0x3490
movq %rax, %rdi
callq 0x3130
leaq 0xe6ee(%rip), %rsi      # 0x1234b
movq %rbx, %rdi
callq 0x32f0
movq 0x28(%r14), %r15
movq 0x30(%r14), %r13
leaq 0xe6b3(%rip), %r12      # 0x12327
movq %rbx, %rdi
cmpq %r13, %r15
je 0x3c95
movq %r15, %rsi
callq 0x93ad
movq %rax, %rdi
movq %r12, %rsi
callq 0x32f0
addq $0x8, %r15
jmp 0x3c74
callq 0x3130
leaq 0xe6b3(%rip), %rsi      # 0x12354
movq %rbx, %rdi
callq 0x32f0
movl 0x40(%r14), %esi
movq %rax, %rdi
callq 0x3490
movq %rax, %rdi
callq 0x3130
leaq 0xe69f(%rip), %rsi      # 0x12363
movq %rbx, %rdi
callq 0x32f0
movq 0x48(%r14), %r15
movq 0x50(%r14), %r12
leaq 0xe64c(%rip), %r14      # 0x12327
cmpq %r12, %r15
je 0x3cfc
movl (%r15), %esi
movq %rbx, %rdi
callq 0x3490
movq %rax, %rdi
movq %r14, %rsi
callq 0x32f0
addq $0x4, %r15
jmp 0x3cdb
movq %rbx, %rdi
callq 0x3130
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: read_problem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
problem read_problem(const string &file)
{
  ifstream ifs(file.c_str());
  value v;
  parse(v, ifs);
  return to_problem(v);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x30(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x34f0
movq %rsp, %rsi
andl $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0x96f1
leaq 0x10(%rsp), %rdi
callq 0x3550
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4022
movq %rsp, %rdi
callq 0x9760
leaq 0x30(%rsp), %rdi
callq 0x3080
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9760
leaq 0x30(%rsp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: to_char(command)
char to_char(command m) {
  switch (m) {
  case W:   return "p'!.03"[genrand_int31()%1];
  case E:   return "bcefy2"[genrand_int31()%5];
  case SW:  return "aghij4"[genrand_int31()%5];
  case SE:  return "lmno 5"[genrand_int31()%4];
  case CW:  return "dqrvz1"[genrand_int31()%5];
  case CCW: return "kstuwx"[genrand_int31()%6];
  }
}

// Assembly:
pushq %rbx
movl %edi, %ebx
callq 0x3a17
movl %ebx, %ecx
leaq 0xdd14(%rip), %rdx      # 0x120e0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb $0x70, %al
jmp 0x442f
pushq $0x5
popq %rcx
xorl %edx, %edx
divq %rcx
leaq 0xdfdf(%rip), %rcx      # 0x123c7
jmp 0x442a
pushq $0x5
popq %rcx
xorl %edx, %edx
divq %rcx
leaq 0xdfc0(%rip), %rcx      # 0x123b9
jmp 0x442a
andl $0x3, %eax
leaq 0xdfbb(%rip), %rcx      # 0x123c0
addq %rax, %rcx
jmp 0x442d
pushq $0x5
popq %rcx
xorl %edx, %edx
divq %rcx
leaq 0xdf99(%rip), %rcx      # 0x123b2
jmp 0x442a
pushq $0x6
popq %rcx
xorl %edx, %edx
divq %rcx
leaq 0xdfa4(%rip), %rcx      # 0x123ce
addq %rdx, %rcx
movb (%rcx), %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: show_command[abi:cxx11](command)
string show_command(command m) {
  switch (m) {
  case W:   return "W";
  case E:   return "E";
  case SW:  return "SW";
  case SE:  return "SE";
  case CW:  return "CW";
  case CCW: return "CCW";
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, %eax
leaq 0xdcb6(%rip), %rcx      # 0x120f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xdf8b(%rip), %rsi      # 0x123dd
leaq 0xf(%rsp), %rdx
jmp 0x449d
leaq 0xdf7c(%rip), %rsi      # 0x123dc
leaq 0xb(%rsp), %rdx
jmp 0x449d
leaq 0xdf67(%rip), %rsi      # 0x123d5
leaq 0xd(%rsp), %rdx
jmp 0x449d
leaq 0xdf5c(%rip), %rsi      # 0x123d8
leaq 0xc(%rsp), %rdx
jmp 0x449d
leaq 0xdf4f(%rip), %rsi      # 0x123d9
leaq 0xe(%rsp), %rdx
jmp 0x449d
leaq 0xdf43(%rip), %rsi      # 0x123db
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0x30e0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: check(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&, std::complex<int> const&, unit const&, int)
bool check(const vector<vector<int>> &bd, const pt &pos, const unit &u, int rot)
{
  for (auto &c: u.members)
    if (!check_one(bd, pos, u.pivot, c, rot))
      return false;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdx), %rcx
movq 0x8(%rdx), %rbp
addq $0x18, %r14
movq %rcx, %r13
cmpq %rbp, %rcx
je 0x485f
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
movl %ebx, %r8d
callq 0x9856
leaq 0x8(%r13), %rcx
testb %al, %al
jne 0x483b
cmpq %rbp, %r13
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq