LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: snesic[P]stochastic_thin_films/film.cpp
// Function: film::create_funcional_add_vdw_noise()
void film::create_funcional_add_vdw_noise()
{
    double dx2dt=dt/(dx*dx);
    
    for(int i=0;i<L;i++)
        r_fix[i] = r_fix[i] + dx2dt*(               // Multiply this by theta if vdw treated implicitly
                             ( 6.0*B/(h[ind[i+3]]+h[i]) - 2.0*A ) * (h[ind[i+3]] - h[i])
                            -( 6.0*B/(h[ind[i+1]]+h[i]) - 2.0*A ) * (h[i] - h[ind[i+1]])
                             )
        + ( noise[i+2] - noise[i] )/2.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd 0x10(%rax), %xmm0
movsd 0x8(%rax), %xmm1
mulsd 0x8(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x4e92
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm1
movsd -0x10(%rbp), %xmm0
movsd 0x541b(%rip), %xmm2     # 0xa158
mulsd 0x98(%rax), %xmm2
movq (%rax), %rcx
movq 0x80(%rax), %rdx
movl -0x14(%rbp), %esi
addl $0x3, %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movsd (%rcx,%rdx,8), %xmm3
movq (%rax), %rcx
movslq -0x14(%rbp), %rdx
addsd (%rcx,%rdx,8), %xmm3
divsd %xmm3, %xmm2
movsd 0x90(%rax), %xmm3
addsd %xmm3, %xmm3
subsd %xmm3, %xmm2
movq (%rax), %rcx
movq 0x80(%rax), %rdx
movl -0x14(%rbp), %esi
addl $0x3, %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movsd (%rcx,%rdx,8), %xmm4
movq (%rax), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm4
movsd 0x53a7(%rip), %xmm3     # 0xa158
mulsd 0x98(%rax), %xmm3
movq (%rax), %rcx
movq 0x80(%rax), %rdx
movl -0x14(%rbp), %esi
addl $0x1, %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movsd (%rcx,%rdx,8), %xmm5
movq (%rax), %rcx
movslq -0x14(%rbp), %rdx
addsd (%rcx,%rdx,8), %xmm5
divsd %xmm5, %xmm3
movsd 0x90(%rax), %xmm5
addsd %xmm5, %xmm5
subsd %xmm5, %xmm3
movq (%rax), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm5
movq (%rax), %rcx
movq 0x80(%rax), %rdx
movl -0x14(%rbp), %esi
addl $0x1, %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
subsd (%rcx,%rdx,8), %xmm5
mulsd %xmm5, %xmm3
movq %xmm3, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x70(%rax), %rcx
movl -0x14(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm1
movq 0x70(%rax), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm1
movsd 0x52c1(%rip), %xmm2     # 0xa130
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4d0f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: snesic[P]stochastic_thin_films/initial_conditions.cpp
// Function: initial_condition(double*, int, double, double)
void initial_condition(double *h, int L, double dx, double b)   // Initial condition: Droplet as a  b + re^{(x-{x_mid})^4/r^4}
{
  int i; double height_drop, x_mid, x_pos; 

  x_mid=L/2*dx; 
  height_drop=1;  

  for(i=0;i<L;i++)
    {    x_pos=i*dx; 
	     h[i]=b + height_drop * exp(-pow((x_pos-x_mid)/height_drop,4));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x381e(%rip), %xmm0     # 0xa008
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x688a
cvtsi2sdl -0x24(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movl $0x4, %edi
callq 0x6dd0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x3440
movsd -0x50(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x48(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x67f6
addq $0x50, %rsp
popq %rbp
retq
// File: snesic[P]stochastic_thin_films/initial_conditions.cpp
// Function: initial_condition_sin(double*, int, double, double)
void initial_condition_sin(double *h, int L, double dx, double b)   // Initial condition: Droplet as a  b + re^{(x-{x_mid})^4/r^4}
{
    int i; double A, B;
    
    B=0.1; A=0.01;
    for(i=0;i<L;i++)
        h[i]= B + A*cos(2*PI*i*dx/2.66);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd 0x528f(%rip), %xmm0     # 0xbb40
movsd %xmm0, -0x38(%rbp)
movsd 0x527a(%rip), %xmm0     # 0xbb38
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x693a
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
cvtsi2sdl -0x24(%rbp), %xmm1
movsd 0x525d(%rip), %xmm0     # 0xbb50
mulsd %xmm1, %xmm0
mulsd -0x18(%rbp), %xmm0
movsd 0x5244(%rip), %xmm1     # 0xbb48
divsd %xmm1, %xmm0
callq 0x34a0
movsd -0x48(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x68ca
addq $0x50, %rsp
popq %rbp
retq
// File: snesic[P]stochastic_thin_films/initial_conditions.cpp
// Function: create_boundary_conditions(int*, int)
void create_boundary_conditions(int *ind, int L)
{ int i;
    for(i=0;i<L;i++)
        ind[i+2]=i;        //  ind[i] - to use boundary conditions, shifted for 2
    ind[0]=2; ind[1]=1; ind[L+2]=L-2; ind[L+3]=L-3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6d88
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6d62
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
movl -0xc(%rbp), %edx
subl $0x2, %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %edx
subl $0x3, %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopl (%rax,%rax)
// File: snesic[P]stochastic_thin_films/newton-raphson_tools.cpp
// Function: calculate_volume(int const&, double*, double const&)
double calculate_volume(const int& L, double *h, const double& dx)
{ int i; double vol=0;
    
for(i=0;i<L;i++)
    vol = vol + h[i];
    
return vol*dx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x83cc
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x839f
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: snesic[P]stochastic_thin_films/newton-raphson_tools.cpp
// Function: check_volume(int const&, double&, double*, double*, double const&, double const&)
void check_volume(const int& L, double& vol_0, double *h, double *y, const double& dx, const double& jdt)
{
int i, maxq;
double vol;
    
    vol=calculate_volume(L,y,dx);

    if(fabs(vol-vol_0)/vol_0>0.03)
    {   cout<< "Problem!!!! No Volume conservation at " << jdt << "!! Initial vol:  " << vol_0 << "  and now:  " << vol << endl; vol_0=vol;
        vol=0; maxq=0;
        for(i=0;i<L;i++)
            if(fabs(h[i]-y[i])>vol)
                {vol=h[i]-y[i]; maxq=i;}
        cout<< vol << "  Biggest change at the position: " << maxq << "  and time:  "<< jdt <<  endl;
        vol=fabs(vol);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x8380
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x10(%rbp), %rax
subsd (%rax), %xmm0
movaps 0x37b6(%rip), %xmm1     # 0xbbe0
pand %xmm1, %xmm0
movq -0x10(%rbp), %rax
divsd (%rax), %xmm0
movsd 0x3792(%rip), %xmm1     # 0xbbd0
ucomisd %xmm1, %xmm0
jbe 0x85af
movq 0x6b89(%rip), %rdi      # 0xefd8
leaq 0x379a(%rip), %rsi      # 0xbbf0
callq 0x3270
movq %rax, %rdi
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
callq 0x34b0
movq %rax, %rdi
leaq 0x37a2(%rip), %rsi      # 0xbc17
callq 0x3270
movq %rax, %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x34b0
movq %rax, %rdi
leaq 0x3795(%rip), %rsi      # 0xbc29
callq 0x3270
movq %rax, %rdi
movsd -0x40(%rbp), %xmm0
callq 0x34b0
movq %rax, %rdi
movq 0x6b18(%rip), %rsi      # 0xefc8
callq 0x3290
movsd -0x40(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x8541
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movaps 0x36dc(%rip), %xmm1     # 0xbbe0
pand %xmm1, %xmm0
ucomisd -0x40(%rbp), %xmm0
jbe 0x8534
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x8536
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x84d8
movsd -0x40(%rbp), %xmm0
movq 0x6a8b(%rip), %rdi      # 0xefd8
callq 0x34b0
movq %rax, %rdi
leaq 0x36da(%rip), %rsi      # 0xbc36
callq 0x3270
movq %rax, %rdi
movl -0x38(%rbp), %esi
callq 0x3400
movq %rax, %rdi
leaq 0x36e3(%rip), %rsi      # 0xbc59
callq 0x3270
movq %rax, %rdi
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
callq 0x34b0
movq %rax, %rdi
movq 0x6a33(%rip), %rsi      # 0xefc8
callq 0x3290
movsd -0x40(%rbp), %xmm0
movaps 0x363a(%rip), %xmm1     # 0xbbe0
pand %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: snesic[P]stochastic_thin_films/read_write_msg.cpp
// Function: read_position(double*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int read_position(double *poz, int L, string filename)
{
	std::ifstream inFile(filename.c_str());
	int i,j; double vst; 
	
	
	// Make sure the file stream is good
	if(!inFile) {
		cout << endl << "Failed to open file " << filename << endl;
		return 1;
	}
	i=0; j=0;
	while(!inFile.eof() && i<L) 
	{  inFile >> vst;
		if(j==1) poz[i]=vst;
	   j++; 
	   if (j==2) {j=0; i++;}	
		
	}
    
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdx, -0x260(%rbp)
movq %rdi, %rax
movq -0x260(%rbp), %rdi
movq %rdi, -0x258(%rbp)
movq %rax, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdi, -0x20(%rbp)
callq 0x30c0
movq %rax, %rsi
leaq -0x228(%rbp), %rdi
movl $0x8, %edx
callq 0x3480
movq -0x228(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x228(%rbp,%rax), %rdi
callq 0x3100
movb %al, -0x249(%rbp)
jmp 0x9727
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x9736
jmp 0x97d8
movq 0x589b(%rip), %rdi      # 0xefd8
movq 0x5884(%rip), %rsi      # 0xefc8
callq 0x3290
movq %rax, -0x268(%rbp)
jmp 0x9752
movq -0x268(%rbp), %rdi
leaq 0x278d(%rip), %rsi      # 0xbeed
callq 0x3270
movq %rax, -0x270(%rbp)
jmp 0x976e
movq -0x258(%rbp), %rsi
movq -0x270(%rbp), %rdi
callq 0x3230
movq %rax, -0x278(%rbp)
jmp 0x978a
movq -0x278(%rbp), %rdi
movq 0x5830(%rip), %rsi      # 0xefc8
callq 0x3290
jmp 0x979f
movl $0x1, -0x4(%rbp)
movl $0x1, -0x248(%rbp)
jmp 0x98bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x3070
jmp 0x98d4
movl $0x0, -0x22c(%rbp)
movl $0x0, -0x230(%rbp)
movq -0x228(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x228(%rbp,%rax), %rdi
callq 0x3490
movb %al, -0x279(%rbp)
jmp 0x980c
movb -0x279(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x27a(%rbp)
jne 0x9833
jmp 0x9821
movl -0x22c(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x27a(%rbp)
movb -0x27a(%rbp), %al
testb $0x1, %al
jne 0x983f
jmp 0x98ab
leaq -0x228(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x31f0
jmp 0x9854
cmpl $0x1, -0x230(%rbp)
jne 0x9875
movsd -0x238(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x22c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x230(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x230(%rbp)
cmpl $0x2, -0x230(%rbp)
jne 0x98a6
movl $0x0, -0x230(%rbp)
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x22c(%rbp)
jmp 0x97ec
movl $0x0, -0x4(%rbp)
movl $0x1, -0x248(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x3070
movl -0x4(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x240(%rbp), %rdi
callq 0x3420
// File: ratulSharker[P]Havec/src/main.cpp
// Function: main
int main(int argc,char **argv){
	
	bool cutOff = false;
	
	/*
	* check for the availability of the cut-off value
	*/
	if(strcmp("C",argv[4]) == 0 ||  strcmp("c",argv[4]) == 0 ){
		cutOff = true;
	}
	else{
		cutOff = false;
	}

	/*
	 * create the output directory
	 */
	 createDirectory(OUTPUT_DIRECTORY_NAME);

	//now call the 5 byte or the 6 byte functionalities :)
	if(cutOff){
		//call 6 byte code -- if valid values are given in the cutOffSection
		main6Byte(argc,argv);
	}else{
		//cutOffValue 1 assumed -- so call the 5 byte functionality
		main5Byte(argc,argv);
	}
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0xd7eb(%rip), %rdi      # 0x11004
callq 0x3470
cmpl $0x0, %eax
je 0x383c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0xdb39(%rip), %rdi      # 0x1136b
callq 0x3470
cmpl $0x0, %eax
jne 0x3842
movb $0x1, -0x11(%rbp)
jmp 0x3846
movb $0x0, -0x11(%rbp)
leaq 0xd7b9(%rip), %rdi      # 0x11006
callq 0x10760
testb $0x1, -0x11(%rbp)
je 0x3866
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xcdc0
jmp 0x3872
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x6910
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ratulSharker[P]Havec/src/vector_with_rehash_8_hash_with_N_detection_5_bytes.cpp
// Function: show_vect_status_5_byte()
void show_vect_status_5_byte()
{
	int total_vect=0,total_row=0,max_size=0;

	cout<<"calculating vector info..."<<endl;
	
	for(int i=0;i<num_of_vector;i++)
	{
		for(int j=0;j<mapPointer5Byte[i].size();j++)
		{
			//cout<<"got it "<<mapPointer5Byte[i][j]<<" i value "<<i<<" j value "<<j<<endl;
			total_vect+=mapPointer5Byte[i][j].vect.size();
			if(mapPointer5Byte[i][j].vect.size()>max_size)
			{
				max_size=mapPointer5Byte[i][j].vect.size();
			}
		}
		total_row+=mapPointer5Byte[i].size();
	}
	cout<<"vector info: :)"<<endl;
	cout<<" Maximum vector size for one hashtable index "<<max_size<<endl;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq 0x1372c(%rip), %rdi     # 0x16fd0
leaq 0xd8d5(%rip), %rsi      # 0x11180
callq 0x32f0
movq %rax, %rdi
movq 0x13706(%rip), %rsi     # 0x16fc0
callq 0x3340
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
leaq 0x13aaf(%rip), %rcx     # 0x17380
cmpq (%rcx), %rax
jae 0x39e0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x13a30(%rip), %rdi     # 0x17320
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x7370
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x39ae
movq 0x13a09(%rip), %rdi     # 0x17320
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x7390
movq %rax, %rdi
addq $0x8, %rdi
callq 0x73b0
movq %rax, %rcx
movslq -0x4(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x4(%rbp)
movq 0x139d5(%rip), %rdi     # 0x17320
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x7390
movq %rax, %rdi
addq $0x8, %rdi
callq 0x73b0
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x399e
movq 0x139a5(%rip), %rdi     # 0x17320
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x7390
movq %rax, %rdi
addq $0x8, %rdi
callq 0x73b0
movl %eax, -0xc(%rbp)
jmp 0x39a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x38e1
movq 0x1396b(%rip), %rdi     # 0x17320
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x7370
movq %rax, %rcx
movslq -0x8(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x38c6
movq 0x135e9(%rip), %rdi     # 0x16fd0
leaq 0xd7ad(%rip), %rsi      # 0x1119b
callq 0x32f0
movq %rax, %rdi
movq 0x135c3(%rip), %rsi     # 0x16fc0
callq 0x3340
movq 0x135c7(%rip), %rdi     # 0x16fd0
leaq 0xd79b(%rip), %rsi      # 0x111ab
callq 0x32f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3530
movq %rax, %rdi
movq 0x13596(%rip), %rsi     # 0x16fc0
callq 0x3340
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ratulSharker[P]Havec/src/vector_with_rehash_8_hash_with_N_detection_6_bytes.cpp
// Function: show_vect_status_6_byte()
void show_vect_status_6_byte()
{
	int total_vect=0,total_row=0,max_size=0;
	
	cout<<"calculating vector info..."<<endl;
	
	for(int i=0;i<num_of_vector;i++)
	{
		for(int j=0;j<mapPointer6Byte[i].size();j++)
		{
			//cout<<"got it "<<mapPointer6Byte[i][j]<<" i value "<<i<<" j value "<<j<<endl;
			total_vect+=mapPointer6Byte[i][j].vect.size();
			if(mapPointer6Byte[i][j].vect.size()>max_size)
			{
				max_size=mapPointer6Byte[i][j].vect.size();
			}
		}
		total_row+=mapPointer6Byte[i].size();
	}
	cout<<"vector info: :)"<<endl;
	cout<<" Maximum vector size for one hashtable index "<<max_size<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq 0xd65c(%rip), %rdi      # 0x16fd0
leaq 0x7805(%rip), %rsi      # 0x11180
callq 0x32f0
movq %rax, %rdi
movq 0xd636(%rip), %rsi      # 0x16fc0
callq 0x3340
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
leaq 0xd9df(%rip), %rcx      # 0x17380
cmpq (%rcx), %rax
jae 0x9ab0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0xd980(%rip), %rdi      # 0x17340
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0xd8a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x9a7e
movq 0xd959(%rip), %rdi      # 0x17340
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0xd8c0
movq %rax, %rdi
addq $0x8, %rdi
callq 0xd8e0
movq %rax, %rcx
movslq -0x4(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x4(%rbp)
movq 0xd925(%rip), %rdi      # 0x17340
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0xd8c0
movq %rax, %rdi
addq $0x8, %rdi
callq 0xd8e0
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x9a6e
movq 0xd8f5(%rip), %rdi      # 0x17340
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0xd8c0
movq %rax, %rdi
addq $0x8, %rdi
callq 0xd8e0
movl %eax, -0xc(%rbp)
jmp 0x9a70
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x99b1
movq 0xd8bb(%rip), %rdi      # 0x17340
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0xd8a0
movq %rax, %rcx
movslq -0x8(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9996
movq 0xd519(%rip), %rdi      # 0x16fd0
leaq 0x76dd(%rip), %rsi      # 0x1119b
callq 0x32f0
movq %rax, %rdi
movq 0xd4f3(%rip), %rsi      # 0x16fc0
callq 0x3340
movq 0xd4f7(%rip), %rdi      # 0x16fd0
leaq 0x76cb(%rip), %rsi      # 0x111ab
callq 0x32f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3530
movq %rax, %rdi
movq 0xd4c6(%rip), %rsi      # 0x16fc0
callq 0x3340
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x2, -0x10(%rbp)
jae 0xfe9c
movb $0x0, -0x1(%rbp)
jmp 0xff5a
cmpq $0x2, -0x10(%rbp)
jne 0xfeac
movb $0x1, -0x1(%rbp)
jmp 0xff5a
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xfec3
movb $0x0, -0x1(%rbp)
jmp 0xff5a
movq $0x3, -0x18(%rbp)
movq -0x18(%rbp), %xmm0
movaps 0x1289(%rip), %xmm2     # 0x11160
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x128d(%rip), %xmm1     # 0x11170
subpd %xmm1, %xmm0
movaps %xmm0, %xmm3
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm3, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x3230
movsd -0x20(%rbp), %xmm1
movsd 0x18bf(%rip), %xmm2     # 0x117e0
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xff56
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
cmpq $0x0, %rdx
jne 0xff43
movb $0x0, -0x1(%rbp)
jmp 0xff5a
jmp 0xff45
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xfecb
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfe80
testb $0x1, %al
jne 0xff8b
jmp 0xff95
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfff3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xffbb
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xffbd
cmpq $0x0, -0x18(%rbp)
jbe 0xffeb
movq -0x18(%rbp), %rdi
callq 0xfe80
testb $0x1, %al
jne 0xffd3
jmp 0xffdd
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfff3
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xffbd
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x32c0
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x3210
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movl $0x38, %edx
callq 0x3260
leaq -0x90(%rbp), %rdi
movl $0x50, %esi
leaq 0x1853(%rip), %rdx      # 0x11898
leaq -0x40(%rbp), %rcx
callq 0x3250
movq 0x6f7b(%rip), %rdi      # 0x16fd0
movq 0x6f64(%rip), %rsi      # 0x16fc0
callq 0x3340
movq %rax, %rdi
leaq 0x1839(%rip), %rsi      # 0x118a4
callq 0x32f0
movq %rax, %rdi
leaq -0x90(%rbp), %rsi
callq 0x32f0
movq %rax, %rdi
movq 0x6f37(%rip), %rsi      # 0x16fc0
callq 0x3340
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ratulSharker[P]Havec/src/common.cpp
// Function: createDirectory(char const*)
bool createDirectory(const char* directoryName)
{
	struct stat st = {0};

	if(stat(directoryName, &st) == -1){
    	return mkdir(directoryName, 0700);
	}
	else{
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x3160
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x32b0
cmpl $-0x1, %eax
jne 0x107b2
movq -0x10(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x3140
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x107b6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl 0x1369f(%rip), %esi     # 0x17320
addl $0x4, %esi
leaq 0xe3bd(%rip), %rdi      # 0x12048
movl $0x14, %edx
movb $0x0, %al
callq 0x3070
leaq 0x1385a(%rip), %rdi     # 0x174f8
callq 0x3200
cmpq $0x37, %rax
jae 0x3d21
movq 0x13318(%rip), %rdi     # 0x16fc8
leaq 0xe39a(%rip), %rsi      # 0x12051
callq 0x32e0
movq %rax, -0x60(%rbp)
leaq 0x13851(%rip), %rdi     # 0x17518
callq 0x34c0
movq %rax, %rdx
leaq 0x13822(%rip), %rsi     # 0x174f8
leaq -0x20(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq $-0x1, %rcx
callq 0x3320
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x3290
jmp 0x3cf9
leaq -0x20(%rbp), %rdi
callq 0x3628
jmp 0x3d9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3628
jmp 0x3dc7
movq 0x132a0(%rip), %rdi     # 0x16fc8
leaq 0xe322(%rip), %rsi      # 0x12051
callq 0x32e0
movq %rax, -0x78(%rbp)
leaq 0x137b9(%rip), %rsi     # 0x174f8
xorl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x2d, %ecx
callq 0x3320
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3290
movq %rax, -0x68(%rbp)
jmp 0x3d68
movq -0x68(%rbp), %rdi
leaq 0xe2e8(%rip), %rsi      # 0x1205b
callq 0x32e0
jmp 0x3d7a
leaq -0x50(%rbp), %rdi
callq 0x3628
jmp 0x3d9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3628
jmp 0x3dc7
movl 0x1358a(%rip), %esi     # 0x1732c
addl 0x1357c(%rip), %esi     # 0x17324
subl $0x1, %esi
leaq 0xe296(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3570
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3200
subq $0x1, %rax
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0x3e2a
movq -0x30(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3600
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x3e1f
jmp 0x3e2a
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3e02
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x3320
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0xe1e6(%rip), %rdi      # 0x12048
movl $0x1, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x3070
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl 0x134a0(%rip), %ecx     # 0x17320
addl $0x9, %ecx
cmpl %ecx, %eax
jg 0x3ed5
movl -0xc(%rbp), %esi
leaq 0xe1b7(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movl $0x1, -0x10(%rbp)
cmpl $0x4f, -0x10(%rbp)
jge 0x3ec8
movq 0x13117(%rip), %rdi     # 0x16fc8
leaq 0xe22a(%rip), %rsi      # 0x120e2
callq 0x32e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3ea4
jmp 0x3eca
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3e77
movl -0x4(%rbp), %edi
movl $0x1, %esi
callq 0x33e0
xorl %esi, %esi
leaq 0x13661(%rip), %rdx     # 0x1754c
movl %esi, %edi
callq 0x3440
callq 0x3f30
movq 0x1309a(%rip), %rax     # 0x16f98
movq (%rax), %rdi
callq 0x33c0
leaq 0xe13b(%rip), %rdi      # 0x12048
movl $0x1, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x3070
xorl %edi, %edi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl 0x133d8(%rip), %ecx     # 0x17320
addl $0x3, %ecx
cmpl %ecx, %eax
jge 0x3fa3
movl -0x4(%rbp), %esi
addl 0x133cc(%rip), %esi     # 0x17324
leaq 0xe0e9(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movl $0x1, -0x8(%rbp)
cmpl $0x50, -0x8(%rbp)
jge 0x3f96
movq 0x13049(%rip), %rdi     # 0x16fc8
leaq 0xe15c(%rip), %rsi      # 0x120e2
callq 0x32e0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3f72
jmp 0x3f98
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3f3f
movl 0x1337b(%rip), %esi     # 0x17324
movl 0x13379(%rip), %edx     # 0x17328
leaq 0xe092(%rip), %rdi      # 0x12048
movb $0x0, %al
callq 0x3070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe069(%rip), %rdi      # 0x12048
movl $0x1, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x3070
movl $0x1, -0x4(%rbp)
cmpl $0x4e, -0x4(%rbp)
jge 0x4018
movq 0x12fc7(%rip), %rdi     # 0x16fc8
leaq 0xe0da(%rip), %rsi      # 0x120e2
callq 0x32e0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3ff4
leaq 0xe029(%rip), %rdi      # 0x12048
movl $0x1, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x3070
movq 0x12f94(%rip), %rdi     # 0x16fc8
leaq 0xe024(%rip), %rsi      # 0x1205f
callq 0x32e0
leaq 0xe026(%rip), %rdi      # 0x1206d
movb $0x0, %al
callq 0x3070
movq 0x12f73(%rip), %rdi     # 0x16fc8
leaq 0xe019(%rip), %rsi      # 0x12075
callq 0x32e0
leaq 0xdfe0(%rip), %rdi      # 0x12048
movl $0x2, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movl $0x1, -0x8(%rbp)
cmpl $0x4e, -0x8(%rbp)
jge 0x40a4
movq 0x12f3b(%rip), %rdi     # 0x16fc8
leaq 0xdfee(%rip), %rsi      # 0x12082
callq 0x32e0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4080
movl 0x13276(%rip), %esi     # 0x17320
addl $0x3, %esi
leaq 0xdf94(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movl $0x1, -0xc(%rbp)
cmpl $0x4e, -0xc(%rbp)
jge 0x40eb
movq 0x12ef4(%rip), %rdi     # 0x16fc8
leaq 0xdfa7(%rip), %rsi      # 0x12082
callq 0x32e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x40c7
movl 0x1322f(%rip), %esi     # 0x17320
addl $0x5, %esi
leaq 0xdf4d(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movl $0x1, -0x10(%rbp)
cmpl $0x4e, -0x10(%rbp)
jge 0x4132
movq 0x12ead(%rip), %rdi     # 0x16fc8
leaq 0xdf60(%rip), %rsi      # 0x12082
callq 0x32e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x410e
movl 0x131e8(%rip), %esi     # 0x17320
addl $0x4, %esi
leaq 0xdf06(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movslq 0x134fb(%rip), %rax     # 0x17650
leaq 0x134b4(%rip), %rsi     # 0x17610
shlq $0x5, %rax
addq %rax, %rsi
movq 0x12e5e(%rip), %rdi     # 0x16fc8
callq 0x3290
movl 0x131af(%rip), %esi     # 0x17324
movl 0x131ad(%rip), %edx     # 0x17328
leaq 0xdec6(%rip), %rdi      # 0x12048
movb $0x0, %al
callq 0x3070
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movl 0x11b90(%rip), %eax     # 0x176cc
addl $0x1, %eax
movl %eax, 0x11b87(%rip)     # 0x176cc
cmpl $0x64, 0x11b80(%rip)    # 0x176cc
jle 0x5b53
jmp 0x5cfc
movq -0x98(%rbp), %rdi
callq 0x3140
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq 0x1144f(%rip), %rcx     # 0x16fc0
callq 0x3090
movl %eax, -0x14(%rbp)
movl $0x2, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5cfc
movq -0x98(%rbp), %rsi
leaq 0xc4bf(%rip), %rdx      # 0x12059
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xe2a0
movq -0xa0(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x13, %rdx
leaq -0x38(%rbp), %rdi
callq 0xe320
jmp 0x5bcc
leaq -0x58(%rbp), %rdi
callq 0x3628
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x5cbd
leaq -0x38(%rbp), %rdi
callq 0x3140
movq %rax, -0xb0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3580
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0xe090
jmp 0x5c2d
leaq -0x88(%rbp), %rdi
callq 0x5b20
jmp 0x5c3b
leaq -0x88(%rbp), %rdi
callq 0x3628
leaq -0x89(%rbp), %rdi
callq 0x3360
leaq -0x38(%rbp), %rdi
callq 0x3140
movq %rax, %rdi
callq 0x35a0
jmp 0x5ce5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3628
jmp 0x5d05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5ca6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3628
leaq -0x89(%rbp), %rdi
callq 0x3360
leaq -0x38(%rbp), %rdi
callq 0x3628
jmp 0x5d05
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x12(%rax), %eax
cmpl $0x8, %eax
jne 0x5ce3
leaq -0x38(%rbp), %rdi
callq 0x3140
movq %rax, %rdi
callq 0x35a0
jmp 0x5ce5
leaq -0x38(%rbp), %rdi
callq 0x3628
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5b80
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3570
nop
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x3140
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq 0x11278(%rip), %rcx     # 0x16fc0
callq 0x3090
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x2, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5ed2
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x5e6e
movq -0xb0(%rbp), %rsi
leaq 0xc2c1(%rip), %rdx      # 0x12059
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xe2a0
movq -0xb8(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x13, %rdx
leaq -0x50(%rbp), %rdi
callq 0xe320
jmp 0x5dca
movq -0xa8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x3150
jmp 0x5ddf
leaq -0x50(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x5d10
movl %eax, -0xbc(%rbp)
jmp 0x5df7
movl -0xbc(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3628
leaq -0x50(%rbp), %rdi
callq 0x3628
leaq -0x70(%rbp), %rdi
callq 0x3628
jmp 0x5ec2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x5e60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x5e57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3628
leaq -0x50(%rbp), %rdi
callq 0x3628
leaq -0x70(%rbp), %rdi
callq 0x3628
jmp 0x5f03
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x12(%rax), %eax
cmpl $0x8, %eax
jne 0x5ec0
movq -0xa8(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x13, %rsi
callq 0x30f0
cmpl $0x0, %eax
jne 0x5ebe
movq -0xb0(%rbp), %rsi
leaq 0x11a2e(%rip), %rdi     # 0x178e0
callq 0xe480
movl $0x1, -0x2c(%rbp)
jmp 0x5ec0
jmp 0x5ec2
jmp 0x5ec4
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x5d65
cmpl $0x1, -0x2c(%rbp)
jne 0x5ee1
movl $0x1, -0x4(%rbp)
jmp 0x5ef7
cmpl $0x1, -0x28(%rbp)
jne 0x5ef0
movl $0x1, -0x4(%rbp)
jmp 0x5ef7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3570
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3140
movq %rax, %rdi
leaq 0xbbc2(%rip), %rsi      # 0x12155
callq 0x33d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3390
movq -0x18(%rbp), %rdi
callq 0x3030
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x3390
movq -0x30(%rbp), %rdi
callq 0x3140
movq %rax, %rdi
leaq 0xbafe(%rip), %rsi      # 0x120da
callq 0x33d0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x6613
movq -0x18(%rbp), %rdi
callq 0x34f0
movl %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x3430
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x65ec
movq -0x18(%rbp), %rdi
callq 0x32f0
movq -0x20(%rbp), %rdi
callq 0x32f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb6a9(%rip), %rdi      # 0x12048
movl $0x1, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x3070
movq 0x10614(%rip), %rdi     # 0x16fc8
leaq 0xb6a4(%rip), %rsi      # 0x1205f
callq 0x32e0
leaq 0xb6a6(%rip), %rdi      # 0x1206d
movb $0x0, %al
callq 0x3070
movq 0x105f3(%rip), %rdi     # 0x16fc8
leaq 0xb708(%rip), %rsi      # 0x120e4
callq 0x32e0
leaq 0xb709(%rip), %rdi      # 0x120f1
movb $0x0, %al
callq 0x3070
movq 0x105d2(%rip), %rdi     # 0x16fc8
leaq 0xb6fc(%rip), %rsi      # 0x120f9
callq 0x32e0
leaq 0xb704(%rip), %rdi      # 0x1210d
movb $0x0, %al
callq 0x3070
movq 0x105b1(%rip), %rdi     # 0x16fc8
leaq 0xb6f7(%rip), %rsi      # 0x12115
callq 0x32e0
leaq 0xb701(%rip), %rdi      # 0x1212b
movb $0x0, %al
callq 0x3070
movq 0x10590(%rip), %rdi     # 0x16fc8
leaq 0xb6f4(%rip), %rsi      # 0x12133
callq 0x32e0
leaq 0xb5fd(%rip), %rdi      # 0x12048
movl $0x2, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movl $0x1, -0x4(%rbp)
cmpl $0x4e, -0x4(%rbp)
jge 0x6a87
movq 0x10558(%rip), %rdi     # 0x16fc8
leaq 0xb60b(%rip), %rsi      # 0x12082
callq 0x32e0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6a63
movl 0x10893(%rip), %esi     # 0x17320
addl $0x3, %esi
leaq 0xb5b1(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movl $0x1, -0x8(%rbp)
cmpl $0x4e, -0x8(%rbp)
jge 0x6ace
movq 0x10511(%rip), %rdi     # 0x16fc8
leaq 0xb5c4(%rip), %rsi      # 0x12082
callq 0x32e0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6aaa
movl 0x1084c(%rip), %esi     # 0x17320
addl $0x5, %esi
leaq 0xb56a(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movl $0x1, -0xc(%rbp)
cmpl $0x4e, -0xc(%rbp)
jge 0x6b15
movq 0x104ca(%rip), %rdi     # 0x16fc8
leaq 0xb57d(%rip), %rsi      # 0x12082
callq 0x32e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6af1
movl 0x10805(%rip), %esi     # 0x17320
addl $0x4, %esi
leaq 0xb523(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movslq 0x10b18(%rip), %rax     # 0x17650
leaq 0x10ad1(%rip), %rsi     # 0x17610
shlq $0x5, %rax
addq %rax, %rsi
movq 0x1047b(%rip), %rdi     # 0x16fc8
callq 0x3290
movl 0x107cc(%rip), %esi     # 0x17324
movl 0x107ca(%rip), %edx     # 0x17328
leaq 0xb4e3(%rip), %rdi      # 0x12048
movb $0x0, %al
callq 0x3070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl 0x1078f(%rip), %esi     # 0x17320
addl $0x6, %esi
leaq 0xb4ad(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl 0x10779(%rip), %ecx     # 0x17330
addl $0x2, %ecx
cmpl %ecx, %eax
jg 0x6c15
movl 0x1075c(%rip), %esi     # 0x17320
addl $0x6, %esi
addl -0x8(%rbp), %esi
leaq 0xb477(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
movl $0x1, -0xc(%rbp)
cmpl $0x50, -0xc(%rbp)
jge 0x6c08
movq 0x103d7(%rip), %rdi     # 0x16fc8
leaq 0xb4ea(%rip), %rsi      # 0x120e2
callq 0x32e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6be4
jmp 0x6c0a
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6bae
movl 0x10705(%rip), %esi     # 0x17320
addl $0x6, %esi
leaq 0xb423(%rip), %rdi      # 0x12048
movl $0x1, %edx
movb $0x0, %al
callq 0x3070
cmpl $0x1, -0x4(%rbp)
jne 0x6c60
leaq 0x10a52(%rip), %rdi     # 0x17690
callq 0xe1c0
movslq 0x106e6(%rip), %rcx     # 0x17330
cmpq %rcx, %rax
jbe 0x6c5e
movl 0x10a73(%rip), %eax     # 0x176c8
addl $0x2, %eax
movl %eax, 0x10a6a(%rip)     # 0x176c8
jmp 0x6c60
movl 0x10a62(%rip), %eax     # 0x176c8
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10a18(%rip), %rdi     # 0x17690
callq 0xe1c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x6d33
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x6ce1
movq 0x10324(%rip), %rdi     # 0x16fc8
leaq 0xb49e(%rip), %rsi      # 0x12149
callq 0x32e0
movq %rax, -0x20(%rbp)
movslq -0x10(%rbp), %rsi
leaq 0x109d1(%rip), %rdi     # 0x17690
callq 0xe230
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3290
movq %rax, %rdi
movq 0x102ce(%rip), %rsi     # 0x16fa8
callq 0x3330
jmp 0x6d23
movq 0x102e0(%rip), %rdi     # 0x16fc8
leaq 0xb3f2(%rip), %rsi      # 0x120e1
callq 0x32e0
movq %rax, -0x28(%rbp)
movslq -0x10(%rbp), %rsi
leaq 0x1098d(%rip), %rdi     # 0x17690
callq 0xe230
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x3290
movq %rax, %rdi
movq 0x1028a(%rip), %rsi     # 0x16fa8
callq 0x3330
jmp 0x6d25
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6c69
movq 0x1028e(%rip), %rdi     # 0x16fc8
leaq 0xb408(%rip), %rsi      # 0x12149
callq 0x32e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x2, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x1088d(%rip), %eax     # 0x17604
jge 0x6dbf
movq -0x18(%rbp), %rdi
movq 0x107b4(%rip), %rax     # 0x17538
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x13, %rsi
callq 0x30f0
cmpl $0x0, %eax
jne 0x6db2
movq 0x10797(%rip), %rax     # 0x17538
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x12(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x6dbf
jmp 0x6db4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6d6e
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)