LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/gen-fib.c
// Function: header
void
header (int numb_bits)
{
  printf ("/* This file generated by gen-fib.c - DO NOT EDIT. */\n");
  printf ("\n");
  printf ("#if GMP_NUMB_BITS != %d\n", numb_bits);
  printf ("Error, error, this data is for %d bits\n", numb_bits);
  printf ("#endif\n");
  printf ("\n");
  printf ("#define FIB_TABLE_LIMIT         %d\n", fib_limit);
  printf ("#define FIB_TABLE_LUCNUM_LIMIT  %d\n", luc_limit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x27f6(%rip), %rdi      # 0xb463
callq 0x1060
movl $0xa, %edi
callq 0x1040
leaq 0x1e88(%rip), %rdi      # 0xab0b
movl %ebx, %esi
xorl %eax, %eax
callq 0x1080
leaq 0x1e91(%rip), %rdi      # 0xab24
movl %ebx, %esi
xorl %eax, %eax
callq 0x1080
leaq 0x281d(%rip), %rdi      # 0xb4c0
callq 0x1060
movl $0xa, %edi
callq 0x1040
movl 0x641c(%rip), %esi      # 0xf0d4
leaq 0x1e8d(%rip), %rdi      # 0xab4c
xorl %eax, %eax
callq 0x1080
movl 0x640c(%rip), %esi      # 0xf0d8
leaq 0x1e9d(%rip), %rdi      # 0xab70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/gen-fib.c
// Function: table
void
table (int numb_bits)
{
  int  i;

  printf ("/* This file generated by gen-fib.c - DO NOT EDIT. */\n");
  printf ("\n");
  printf ("#include \"gmp.h\"\n");
  printf ("#include \"gmp-impl.h\"\n");
  printf ("\n");
  printf ("#if GMP_NUMB_BITS != %d\n", numb_bits);
  printf ("Error, error, this data is for %d bits\n", numb_bits);
  printf ("#endif\n");
  printf ("\n");
  printf ("const mp_limb_t\n");
  printf ("__gmp_fib_table[FIB_TABLE_LIMIT+2] = {\n");

  for (i = 0; i < fnum; i++)
    {
      printf ("  CNST_LIMB (0x");
      mpz_out_str (stdout, 16, f[i]);
      printf ("),  /* %d */\n", i-1);
    }
  printf ("};\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x276c(%rip), %rdi      # 0xb463
callq 0x1060
movl $0xa, %edi
callq 0x1040
leaq 0x278c(%rip), %rdi      # 0xb499
callq 0x1060
leaq 0x2791(%rip), %rdi      # 0xb4aa
callq 0x1060
movl $0xa, %edi
callq 0x1040
leaq 0x1ddc(%rip), %rdi      # 0xab0b
movl %ebx, %esi
xorl %eax, %eax
callq 0x1080
leaq 0x1de5(%rip), %rdi      # 0xab24
movl %ebx, %esi
xorl %eax, %eax
callq 0x1080
leaq 0x2771(%rip), %rdi      # 0xb4c0
callq 0x1060
movl $0xa, %edi
callq 0x1040
leaq 0x2762(%rip), %rdi      # 0xb4c7
callq 0x1060
leaq 0x2766(%rip), %rdi      # 0xb4d7
callq 0x1060
cmpl $0x0, 0x6353(%rip)      # 0xf0d0
jle 0x8ddc
leaq 0x1e0e(%rip), %rbx      # 0xab94
movq 0x624b(%rip), %r15      # 0xefd8
leaq 0x1e10(%rip), %r14      # 0xaba4
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1080
movq (%r15), %rdi
movq 0x631a(%rip), %rdx      # 0xf0c8
addq %r12, %rdx
movl $0x10, %esi
callq 0x8196
leal -0x1(%r13), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1080
incq %r13
movslq 0x62fd(%rip), %rax      # 0xf0d0
addq $0x10, %r12
cmpq %rax, %r13
jl 0x8d9a
leaq 0x271b(%rip), %rdi      # 0xb4fe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/gen-fib.c
// Function: main
int
main (int argc, char *argv[])
{
  int  limb_bits, nail_bits, numb_bits;

  if (argc != 4)
    {
      fprintf (stderr, "Usage: gen-fib <header|table> <limbbits> <nailbits>\n");
      exit (1);
    }

  limb_bits = atoi (argv[2]);
  nail_bits = atoi (argv[3]);

  if (limb_bits <= 0
      || nail_bits < 0
      || nail_bits >= limb_bits)
    {
      fprintf (stderr, "Invalid limb/nail bits: %d %d\n",
               limb_bits, nail_bits);
      exit (1);
    }
  numb_bits = limb_bits - nail_bits;

  generate (numb_bits);

  if (strcmp (argv[1], "header") == 0)
    header (numb_bits);
  else if (strcmp (argv[1], "table") == 0)
    table (numb_bits);
  else
    {
      fprintf (stderr, "Invalid header/table choice: %s\n", argv[1]);
      exit (1);
    }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %edi
jne 0x8e7b
movq %rsi, %r14
movq 0x10(%rsi), %rdi
callq 0x10f0
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x10f0
testl %r15d, %r15d
jle 0x8e80
testl %eax, %eax
js 0x8e80
movl %r15d, %ebx
subl %eax, %ebx
jle 0x8e80
movl %ebx, %edi
callq 0x8a70
movq 0x8(%r14), %r14
leaq 0x1dc7(%rip), %rsi      # 0xac06
movq %r14, %rdi
callq 0x10b0
testl %eax, %eax
je 0x8e67
leaq 0x1dbb(%rip), %rsi      # 0xac0d
movq %r14, %rdi
callq 0x10b0
testl %eax, %eax
jne 0x8e8a
movl %ebx, %edi
callq 0x8ce0
jmp 0x8e6e
movl %ebx, %edi
callq 0x8c5e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x12a8
movl %r15d, %edi
movl %eax, %esi
callq 0x12d0
movq %r14, %rdi
callq 0x12f8
// File: /workspace/github_cpp_makefile_star2_O1/snesic[P]stochastic_thin_films/film.cpp
// Function: film::film(int, double, double, double, int, double)
film::film(int L, double dx, double dt, double b, int ugao, double sigma): L(L), dx(dx), dt(dt), b(b), angle(ugao), sigma(sigma)
{
    h     = new double [L];
    y     = new double [L];
    q     = new double [L];
    r     = new double [L];
    r_fix = new double [L];
    
    noise = new double [L+2];
    ind   = new int    [L+4];     // Determines boundary conditions
    
    h2    = new double [L];       // To make calculations faster -> h2 = h^2, h3=h^3, ...
    h3    = new double [L];
    y2    = new double [L];
    y3    = new double [L];
    old_sol = new double [L];
    
    a = new double *[L];
    for(int i=0;i<L;i++)
        a[i]=new double [5];

    
    double a_min = 1.0;
    
    A     = 2*(1-cos(PI*ugao/180))*(a_min*b);
    B     = A*(a_min*b); // vdW: The min of vdW potential determins B..
    tol   = 1e-10;
    theta = 0.5;
    create_boundary_conditions(ind, L); // ind - index for h, includes zero-der. boundary conditions
    
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x10(%rsp)
movsd %xmm2, 0x18(%rdi)
movl %esi, 0x20(%rdi)
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x88(%rdi)
movsd %xmm3, 0xa0(%rdi)
movabsq $0x3ddb7cdfd9d7bdbb, %rax # imm = 0x3DDB7CDFD9D7BDBB
movq %rax, 0xa8(%rdi)
movabsq $0x3fe0000000000000, %r13 # imm = 0x3FE0000000000000
movq %r13, 0xb0(%rdi)
movslq %esi, %rbp
leaq (,%rbp,8), %r15
testl %ebp, %ebp
movq $-0x1, %r12
cmovsq %r12, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, (%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x30(%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x38(%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x40(%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x48(%r14)
leaq 0x10(,%rbp,8), %rdi
cmpl $-0x2, %ebp
cmovlq %r12, %rdi
callq 0x2030
movq %rax, 0x70(%r14)
leaq 0x10(,%rbp,4), %rdi
cmpl $-0x4, %ebp
cmovlq %r12, %rdi
callq 0x2030
movq %rax, 0x80(%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x50(%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x58(%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x60(%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x68(%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x78(%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x28(%r14)
testl %ebp, %ebp
jle 0x2e48
movl %ebx, %r15d
xorl %r12d, %r12d
movl $0x28, %edi
callq 0x2030
movq 0x28(%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x2e2e
movsd 0x8(%rsp), %xmm0
mulsd 0x42ea(%rip), %xmm0     # 0x7140
divsd 0x42ea(%rip), %xmm0     # 0x7148
callq 0x2360
movsd 0x41b5(%rip), %xmm1     # 0x7020
subsd %xmm0, %xmm1
addsd %xmm1, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm1
movsd %xmm1, 0x90(%r14)
mulsd %xmm0, %xmm1
movsd %xmm1, 0x98(%r14)
movabsq $0x3ddb7cdfd9d7bdbb, %rax # imm = 0x3DDB7CDFD9D7BDBB
movq %rax, 0xa8(%r14)
movq %r13, 0xb0(%r14)
movq 0x80(%r14), %rdi
movl %ebx, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4388
nop
// File: /workspace/github_cpp_makefile_star2_O1/snesic[P]stochastic_thin_films/film.cpp
// Function: film::set_h2_3()
void film::set_h2_3()
{
    for(int i=0;i<L;i++)
    {
        y[i]=h[i];
        h2[i]=h[i]*h[i];
        h3[i]=h[i]*h2[i];
    }
    
}

// Assembly:
movslq 0x20(%rdi), %rax
testq %rax, %rax
jle 0x2f13
movq (%rdi), %rcx
movq 0x30(%rdi), %rdx
movq 0x50(%rdi), %rsi
movq 0x58(%rdi), %rdi
xorl %r8d, %r8d
movsd (%rcx,%r8,8), %xmm0
movsd %xmm0, (%rdx,%r8,8)
movsd (%rcx,%r8,8), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, (%rsi,%r8,8)
mulsd (%rcx,%r8,8), %xmm0
movsd %xmm0, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0x2ee3
retq
// File: /workspace/github_cpp_makefile_star2_O1/snesic[P]stochastic_thin_films/film.cpp
// Function: film::create_noise(long*)
void film::create_noise(long *inic)
{
    double dht=sqrt(dt*sigma);
    static boost::variate_generator<boost::mt19937, boost::normal_distribution<> >
    generator(boost::mt19937(time(0)),boost::normal_distribution<>());

    
    for(int i=0;i<L;i++)
        noise[i+1]=dht/dx * sqrt(h3[i]/dx) * generator();
    
    // Boundary conditions for the noise:
    noise[0]=0;
    noise[1]=0;
    noise[2]=0;
    noise[L+1]=0;
    noise[L]=0;
    noise[L-1]=0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x9e8, %rsp            # imm = 0x9E8
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm0
mulsd 0xa0(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2f7a
sqrtsd %xmm0, %xmm0
jmp 0x2f7f
callq 0x2150
movsd %xmm0, 0x18(%rsp)
movb 0x8c35(%rip), %al       # 0xbbc0
testb %al, %al
je 0x305b
movl 0x20(%rbx), %eax
testl %eax, %eax
jle 0x302d
xorl %r12d, %r12d
leaq 0x8240(%rip), %r14      # 0xb1e8
leaq 0x14(%rsp), %r15
movsd 0x8(%rbx), %xmm1
movq 0x58(%rbx), %rax
movsd (%rax,%r12,8), %xmm0
divsd %xmm1, %xmm0
ucomisd 0x4188(%rip), %xmm0     # 0x7150
jb 0x2fd0
sqrtsd %xmm0, %xmm0
jmp 0x2fe1
movsd %xmm1, 0x8(%rsp)
callq 0x2150
movsd 0x8(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
divsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x36a8
mulsd 0x8bb0(%rip), %xmm0     # 0xbbb8
addsd 0x8ba0(%rip), %xmm0     # 0xbbb0
mulsd 0x8(%rsp), %xmm0
movq 0x70(%rbx), %rax
movsd %xmm0, 0x8(%rax,%r12,8)
incq %r12
movslq 0x20(%rbx), %rax
cmpq %rax, %r12
jl 0x2fad
movq 0x70(%rbx), %rcx
cltq
xorl %edx, %edx
movq %rdx, 0x10(%rcx)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rcx)
movq %rdx, 0x8(%rcx,%rax,8)
movupd %xmm0, -0x8(%rcx,%rax,8)
addq $0x9e8, %rsp            # imm = 0x9E8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8b5e(%rip), %rdi      # 0xbbc0
callq 0x2340
testl %eax, %eax
je 0x2f93
xorl %edi, %edi
callq 0x21a0
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x362a
leaq 0x815a(%rip), %rdi      # 0xb1e8
leaq 0x20(%rsp), %rsi
movl $0x9c8, %edx            # imm = 0x9C8
callq 0x2160
movq $0x0, 0x8b08(%rip) # 0xbbb0
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x8aff(%rip)      # 0xbbb8
leaq 0x8b00(%rip), %rdi      # 0xbbc0
callq 0x20f0
jmp 0x2f93
movq %rax, %rbx
leaq 0x8aec(%rip), %rdi      # 0xbbc0
callq 0x20e0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/snesic[P]stochastic_thin_films/film.cpp
// Function: film::create_funcional_st(double*, double*, double*, double)
void film::create_funcional_st(double *r1, double *h1, double *h13, double theta1)
{
    double dx4dt=dt/(dx*dx*dx*dx);
    
    for(int i=0;i<L;i++)
    {
        r1[i]=h1[i] - dx4dt*theta1*(
                       0.5*( h13[i]+h13[ind[i+3]] ) * (h1[ind[i+4]]-3*h1[ind[i+3]]+3*h1[i]-h1[ind[i+1]])
                      -0.5*( h13[ind[i+1]]+h13[i] ) * (h1[ind[i+3]]-3*h1[i]+3*h1[ind[i+1]]-h1[ind[i]]  )
                       );
    }
}

// Assembly:
movslq 0x20(%rdi), %rax
testq %rax, %rax
jle 0x31f1
movsd 0x8(%rdi), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
movsd 0x10(%rdi), %xmm1
xorpd 0x40bf(%rip), %xmm1     # 0x71d0
movq 0x80(%rdi), %rdi
divsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
xorl %r8d, %r8d
movsd 0x402d(%rip), %xmm0     # 0x7158
movsd 0x402d(%rip), %xmm2     # 0x7160
movsd 0x402d(%rip), %xmm3     # 0x7168
movsd 0x402d(%rip), %xmm4     # 0x7170
movsd (%rdx,%r8,8), %xmm5
movsd (%rcx,%r8,8), %xmm6
movslq 0xc(%rdi,%r8,4), %r9
movsd (%rcx,%r9,8), %xmm7
addsd %xmm6, %xmm7
movslq 0x10(%rdi,%r8,4), %r10
movsd (%rdx,%r9,8), %xmm8
movapd %xmm5, %xmm9
mulsd %xmm2, %xmm9
addsd %xmm8, %xmm9
mulsd %xmm2, %xmm8
addsd (%rdx,%r10,8), %xmm8
mulsd %xmm0, %xmm7
movapd %xmm5, %xmm10
mulsd %xmm3, %xmm10
addsd %xmm8, %xmm10
movslq 0x4(%rdi,%r8,4), %r9
movsd (%rdx,%r9,8), %xmm8
subsd %xmm8, %xmm10
mulsd %xmm7, %xmm10
addsd (%rcx,%r9,8), %xmm6
mulsd %xmm3, %xmm8
addsd %xmm9, %xmm8
movslq (%rdi,%r8,4), %r9
subsd (%rdx,%r9,8), %xmm8
mulsd %xmm4, %xmm6
mulsd %xmm8, %xmm6
addsd %xmm10, %xmm6
mulsd %xmm1, %xmm6
addsd %xmm5, %xmm6
movsd %xmm6, (%rsi,%r8,8)
leaq 0x1(%r8), %r9
movq %r9, %r8
cmpq %r9, %rax
jne 0x3143
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x20(%rdi), %rax
testq %rax, %rax
jle 0x32e8
movsd 0x8(%rdi), %xmm1
movsd 0x10(%rdi), %xmm0
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm0
movq (%rdi), %rcx
movq 0x48(%rdi), %rdx
movq 0x80(%rdi), %rsi
movq 0x70(%rdi), %r8
shlq $0x2, %rax
xorl %r9d, %r9d
movsd 0x3f46(%rip), %xmm1     # 0x7178
movsd 0x3f46(%rip), %xmm2     # 0x7180
movsd 0x3f16(%rip), %xmm3     # 0x7158
movsd 0x98(%rdi), %xmm5
mulsd %xmm1, %xmm5
movslq 0xc(%rsi,%r9), %r10
movsd (%rcx,%r10,8), %xmm4
movsd (%rcx,%r9,2), %xmm6
movapd %xmm4, %xmm7
addsd %xmm6, %xmm7
movapd %xmm5, %xmm8
divsd %xmm7, %xmm8
movsd 0x90(%rdi), %xmm7
mulsd %xmm2, %xmm7
addsd %xmm7, %xmm8
subsd %xmm6, %xmm4
mulsd %xmm8, %xmm4
movslq 0x4(%rsi,%r9), %r10
movsd (%rcx,%r10,8), %xmm8
movapd %xmm6, %xmm9
addsd %xmm8, %xmm9
divsd %xmm9, %xmm5
addsd %xmm7, %xmm5
subsd %xmm8, %xmm6
mulsd %xmm5, %xmm6
subsd %xmm6, %xmm4
mulsd %xmm0, %xmm4
addsd (%rdx,%r9,2), %xmm4
movsd 0x10(%r8,%r9,2), %xmm5
subsd (%r8,%r9,2), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm4, %xmm5
movsd %xmm5, (%rdx,%r9,2)
addq $0x4, %r9
cmpq %r9, %rax
jne 0x3242
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
testl %esi, %esi
jle 0x3d50
movq %rdi, %rbx
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
sarl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movl %esi, %r14d
xorl %r15d, %r15d
movsd %xmm1, 0x18(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
mulsd 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
movsd 0x4d12(%rip), %xmm1     # 0x8a38
callq 0x2300
xorpd 0x349d(%rip), %xmm0     # 0x71d0
callq 0x2320
movsd 0x18(%rsp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x3d0a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %esi, %esi
jle 0x3dc8
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movapd %xmm0, %xmm1
movq %rdi, %rbx
movl %esi, %r14d
xorl %r15d, %r15d
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
mulsd 0x4cb6(%rip), %xmm0     # 0x8a40
mulsd %xmm1, %xmm0
divsd 0x4cb2(%rip), %xmm0     # 0x8a48
callq 0x2360
movsd 0x8(%rsp), %xmm1
mulsd 0x3267(%rip), %xmm0     # 0x7010
addsd 0x4c9f(%rip), %xmm0     # 0x8a50
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x3d7a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %esi, %esi
jle 0x439c
movl %esi, %eax
xorl %ecx, %ecx
movl %ecx, 0x8(%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x4390
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rax, (%rdi)
leal -0x2(%rsi), %eax
movslq %esi, %rcx
movl %eax, 0x8(%rdi,%rcx,4)
addl $-0x3, %esi
movl %esi, 0xc(%rdi,%rcx,4)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/snesic[P]stochastic_thin_films/newton-raphson_tools.cpp
// Function: elimination(double**, double*, double*, int const&)
void elimination(double ** a, double *r, double *q, const int& L)    // Gaussan elimination of 5 diagonal matrix, gives q out of Aq=r
{
  int i,j,l; double c;

  for(l=0;l<L-2;l++)
    for(j=0;j<2;j++)
     {
   	c=a[j+1+l][1-j]/a[l][2]; 
	a[j+1+l][1-j]=0;
   	for(i=1;i<4;i++)
      	    a[j+1+l][i-j]=a[j+1+l][i-j]-c*a[l][1+i];
    	    r[j+1+l]=r[j+1+l]-r[l]*c;
      }

  c=a[L-1][1] / a[L-2][2];
  a[L-1][1]=0;
  a[L-1][2]=a[L-1][2]-a[L-2][3]*c;

  r[L-1]=r[L-1]-r[L-2]*c;

  // calculating solution reverse 

   q[L-1]=r[L-1]/a[L-1][2];
   q[L-2]=(r[L-2] - q[L-1]*a[L-2][3])/a[L-2][2];

   for(i=L-3;i>=0;i--)
       q[i]=(r[i] - q[i+1]*a[i][3] - q[i+2]*a[i][4])/a[i][2];

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rcx), %rax
leal -0x2(%rax), %ecx
cmpq $0x3, %rax
jl 0x450b
movl %ecx, %r8d
xorl %r9d, %r9d
movapd 0x2d5d(%rip), %xmm0     # 0x71d0
movq (%rdi,%r9,8), %r10
movl $0x8, %r11d
xorl %ebx, %ebx
leaq 0x1(%rbx), %r14
leaq (%rbx,%r9), %r15
incq %r15
movq (%rdi,%r15,8), %r12
movl $0x1, %r13d
subl %ebx, %r13d
shll $0x3, %r13d
movsd (%r12,%r13), %xmm1
divsd 0x10(%r10), %xmm1
movq $0x0, (%r12,%r13)
movapd %xmm1, %xmm2
xorpd %xmm0, %xmm2
addq %r11, %r12
xorl %r13d, %r13d
movsd 0x10(%r10,%r13,8), %xmm3
mulsd %xmm2, %xmm3
addsd (%r12,%r13,8), %xmm3
movsd %xmm3, (%r12,%r13,8)
incq %r13
cmpq $0x3, %r13
jne 0x44bd
movsd (%rsi,%r15,8), %xmm2
mulsd (%rsi,%r9,8), %xmm1
subsd %xmm1, %xmm2
movsd %xmm2, (%rsi,%r15,8)
addq $-0x8, %r11
testq %rbx, %rbx
movq %r14, %rbx
je 0x447f
incq %r9
cmpq %r8, %r9
jne 0x4473
movq -0x8(%rdi,%rax,8), %r9
movslq %ecx, %rcx
movq (%rdi,%rcx,8), %r8
movsd 0x8(%r9), %xmm0
movsd 0x10(%r9), %xmm1
divsd 0x10(%r8), %xmm0
movq $0x0, 0x8(%r9)
movq -0x10(%rdi,%rax,8), %r10
movsd 0x18(%r10), %xmm2
mulsd %xmm0, %xmm2
subsd %xmm2, %xmm1
movsd %xmm1, 0x10(%r9)
movsd -0x8(%rsi,%rax,8), %xmm1
mulsd -0x10(%rsi,%rax,8), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, -0x8(%rsi,%rax,8)
movsd -0x8(%rsi,%rax,8), %xmm0
movq -0x8(%rdi,%rax,8), %r9
divsd 0x10(%r9), %xmm0
movsd %xmm0, -0x8(%rdx,%rax,8)
movsd (%rsi,%rcx,8), %xmm0
movsd -0x8(%rdx,%rax,8), %xmm1
mulsd 0x18(%r8), %xmm1
subsd %xmm1, %xmm0
divsd 0x10(%r8), %xmm0
movsd %xmm0, (%rdx,%rcx,8)
cmpl $0x3, %eax
jl 0x45da
addl $-0x3, %eax
incq %rax
movsd -0x8(%rsi,%rax,8), %xmm0
movq -0x8(%rdi,%rax,8), %rcx
movsd (%rdx,%rax,8), %xmm1
movsd 0x8(%rdx,%rax,8), %xmm2
mulsd 0x18(%rcx), %xmm1
subsd %xmm1, %xmm0
mulsd 0x20(%rcx), %xmm2
subsd %xmm2, %xmm0
divsd 0x10(%rcx), %xmm0
movsd %xmm0, -0x8(%rdx,%rax,8)
decq %rax
jg 0x45a2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq (%rdi), %rax
xorpd %xmm0, %xmm0
testq %rax, %rax
jle 0x4cda
xorl %ecx, %ecx
addsd (%rsi,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x4ccd
mulsd (%rdx), %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movslq (%rdi), %rax
xorpd %xmm2, %xmm2
testq %rax, %rax
jle 0x4d15
xorl %ecx, %ecx
addsd (%r14,%rcx,8), %xmm2
incq %rcx
cmpq %rcx, %rax
jne 0x4d07
mulsd (%r8), %xmm2
movsd (%r13), %xmm0
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
andpd 0x3d70(%rip), %xmm1     # 0x8aa0
divsd %xmm0, %xmm1
ucomisd 0x3d94(%rip), %xmm1     # 0x8ad0
jbe 0x4e43
movq 0x628f(%rip), %rbp      # 0xafd8
leaq 0x3d88(%rip), %rsi      # 0x8ad8
movl $0x26, %edx
movq %rbp, %rdi
movsd %xmm2, (%rsp)
callq 0x2200
movsd (%rbx), %xmm0
movq %rbp, %rdi
callq 0x22d0
movq %rax, %rbp
leaq 0x3d87(%rip), %rsi      # 0x8aff
movl $0x11, %edx
movq %rax, %rdi
callq 0x2200
movsd (%r13), %xmm0
movq %rbp, %rdi
callq 0x22d0
movq %rax, %rbp
leaq 0x3d74(%rip), %rsi      # 0x8b11
movl $0xc, %edx
movq %rax, %rdi
callq 0x2200
movq %rbp, %rdi
movsd (%rsp), %xmm0
callq 0x22d0
movq %rax, %rbp
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbp, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movsd (%rsp), %xmm0
movsd %xmm0, (%r13)
movslq (%r12), %rax
testq %rax, %rax
jle 0x4e52
xorl %ecx, %ecx
xorpd %xmm2, %xmm2
movapd 0x3c9d(%rip), %xmm1     # 0x8aa0
xorl %ebp, %ebp
movapd %xmm2, %xmm0
movsd (%r15,%rcx,8), %xmm3
subsd (%r14,%rcx,8), %xmm3
movapd %xmm3, %xmm4
andpd %xmm1, %xmm4
ucomisd %xmm2, %xmm4
cmoval %ecx, %ebp
cmpltsd %xmm4, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
incq %rcx
movapd %xmm0, %xmm2
cmpq %rcx, %rax
jne 0x4e09
jmp 0x4e58
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movq 0x6179(%rip), %rdi      # 0xafd8
callq 0x22d0
movq %rax, %r14
leaq 0x3cb0(%rip), %rsi      # 0x8b1e
movl $0x22, %edx
movq %rax, %rdi
callq 0x2200
movq %r14, %rdi
movl %ebp, %esi
callq 0x22f0
movq %rax, %r14
leaq 0x3cb2(%rip), %rsi      # 0x8b41
movl $0xd, %edx
movq %rax, %rdi
callq 0x2200
movsd (%rbx), %xmm0
movq %r14, %rdi
callq 0x22d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2110
// File: /workspace/github_cpp_makefile_star2_O1/snesic[P]stochastic_thin_films/newton-raphson_tools.cpp
// Function: check_second_time_derivative(int const&, double*, double*, double*, double&, double, int&)
int check_second_time_derivative(const int& L, double *h, double *y, double *old_sol, double& dtt, double dt_old, int& no_good_solutions)
{ double maxq, t_err, dt=dtt;
    int i;

    maxq = (2*dt/dt_old)*(y[0]*dt_old+old_sol[0]*dt-(dt_old+dt)*h[0])/(h[0]*(dt+dt_old));

    for(i=0;i<L;i++)
    {   t_err = (2*dt/dt_old)*(y[i]*dt_old+old_sol[i]*dt-(dt_old+dt)*h[i])/(h[i]*(dt+dt_old));
        if(t_err>maxq) maxq=t_err;
    }
    
    if (maxq<0.01)
    {   no_good_solutions++;
        return 0;
    }
    else{ if(maxq>0.1)
            {   no_good_solutions=0;
                dtt=dt-pow(10,-fabs(round(log10(dt)))-2);
                //dtt=floorf(dt * pow(10,fabs(round(log10(dt)))+1) *100 ) / (100*pow(10,fabs(round(log10(dt)))+1));
                cout << "Time derivative error, repeat iteration for smaller dt " << dtt << endl;
                return 1;
            }
        }
    
return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movsd (%r8), %xmm9
movapd %xmm9, %xmm1
addsd %xmm9, %xmm1
divsd %xmm0, %xmm1
movsd (%rcx), %xmm3
mulsd %xmm9, %xmm3
movsd (%rdx), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
movapd %xmm9, %xmm3
addsd %xmm0, %xmm3
movsd (%rsi), %xmm4
mulsd %xmm3, %xmm4
subsd %xmm4, %xmm2
mulsd %xmm1, %xmm2
divsd %xmm4, %xmm2
movslq (%rdi), %rax
testq %rax, %rax
jle 0x4f8c
movapd 0x2294(%rip), %xmm4     # 0x71d0
xorpd %xmm3, %xmm4
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm6
mulsd %xmm9, %xmm6
movsd (%rdx,%rdi,8), %xmm7
mulsd %xmm0, %xmm7
movsd (%rsi,%rdi,8), %xmm8
movapd %xmm4, %xmm5
mulsd %xmm8, %xmm5
addsd %xmm6, %xmm7
addsd %xmm7, %xmm5
mulsd %xmm1, %xmm5
mulsd %xmm3, %xmm8
divsd %xmm8, %xmm5
maxsd %xmm2, %xmm5
incq %rdi
movapd %xmm5, %xmm2
cmpq %rdi, %rax
jne 0x4f42
jmp 0x4f90
movapd %xmm2, %xmm5
movsd 0x2078(%rip), %xmm0     # 0x7010
ucomisd %xmm5, %xmm0
jbe 0x4fa8
incl (%r9)
xorl %eax, %eax
jmp 0x5058
xorl %eax, %eax
ucomisd 0x3a9e(%rip), %xmm5     # 0x8a50
jbe 0x5058
movl $0x0, (%r9)
movapd %xmm9, %xmm0
movsd %xmm9, (%rsp)
callq 0x20c0
callq 0x20a0
andpd 0x3ac4(%rip), %xmm0     # 0x8aa0
movsd 0x219c(%rip), %xmm1     # 0x7180
subsd %xmm0, %xmm1
movsd 0x2038(%rip), %xmm0     # 0x7028
callq 0x2300
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movq 0x5fcf(%rip), %r14      # 0xafd8
leaq 0x3b3f(%rip), %rsi      # 0x8b4f
movl $0x37, %edx
movq %r14, %rdi
callq 0x2200
movsd (%rbx), %xmm0
movq %r14, %rdi
callq 0x22d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/snesic[P]stochastic_thin_films/newton-raphson_tools.cpp
// Function: check_newton_convergence(int const&, double*, double*, double*, double&, double const&, int&, int&, int const&, double&)
int check_newton_convergence(const int& L, double *h, double *y, double *q, double& dt, const double& jdt, int& no_good_solutions, int& no_consecutive_neg, const int& no_newton_it, double& mq)
{   double maxq=0;
    int i;
    
    for(i=0;i<L;i++)
    {   if(maxq<fabs(q[i])) maxq=fabs(q[i]);
        
        if(y[i]+q[i]<0)
            {
            cout<< h[i] << "  at " << jdt << " , on the position " <<  i   << "  is negative!" << endl;
            no_consecutive_neg++;
            if(no_consecutive_neg>10) {cout << "Wrong parameters -> Simulation breaks!" << endl; return 2;}
            return 1;
            }
        else
        y[i]=y[i]+q[i];
    }
    
    if(no_newton_it>10)
        {   no_good_solutions=0;
            dt=dt-pow(10,-fabs(round(log10(dt)))-2);
            return 1;
        }
    
    mq=maxq;
    
return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movslq (%rdi), %rax
testq %rax, %rax
jle 0x50c9
movq %r9, %r15
movq 0x48(%rsp), %r13
xorpd %xmm1, %xmm1
xorl %r14d, %r14d
movapd 0x3a11(%rip), %xmm2     # 0x8aa0
xorpd %xmm3, %xmm3
movsd (%rcx,%r14,8), %xmm0
movsd (%rdx,%r14,8), %xmm4
addsd %xmm0, %xmm4
ucomisd %xmm4, %xmm1
ja 0x513f
andpd %xmm2, %xmm0
maxsd %xmm3, %xmm0
movsd %xmm4, (%rdx,%r14,8)
incq %r14
movapd %xmm0, %xmm3
cmpq %r14, %rax
jne 0x5093
jmp 0x50cd
xorpd %xmm0, %xmm0
movq 0x50(%rsp), %rax
cmpl $0xb, (%rax)
jl 0x512f
movq 0x40(%rsp), %rax
movl $0x0, (%rax)
movsd (%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x20c0
callq 0x20a0
andpd 0x39a2(%rip), %xmm0     # 0x8aa0
movsd 0x207a(%rip), %xmm1     # 0x7180
subsd %xmm0, %xmm1
movsd 0x1f16(%rip), %xmm0     # 0x7028
callq 0x2300
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movl $0x1, %eax
jmp 0x522d
movq 0x58(%rsp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
jmp 0x522d
movsd (%rsi,%r14,8), %xmm0
movq 0x5e8c(%rip), %rbx      # 0xafd8
movq %rbx, %rdi
callq 0x22d0
movq %rax, %r12
leaq 0x3a29(%rip), %rsi      # 0x8b87
movl $0x5, %edx
movq %rax, %rdi
callq 0x2200
movsd (%r15), %xmm0
movq %r12, %rdi
callq 0x22d0
movq %rax, %r15
leaq 0x3a0b(%rip), %rsi      # 0x8b8d
movl $0x13, %edx
movq %rax, %rdi
callq 0x2200
movq %r15, %rdi
movl %r14d, %esi
callq 0x22f0
movq %rax, %r14
leaq 0x39fd(%rip), %rsi      # 0x8ba1
movl $0xe, %edx
movq %rax, %rdi
callq 0x2200
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movl (%r13), %ecx
leal 0x1(%rcx), %eax
movl %eax, (%r13)
movl $0x1, %eax
cmpl $0xa, %ecx
jl 0x522d
leaq 0x39bc(%rip), %rsi      # 0x8bb0
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2200
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq (%rdx), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl $0x8, %edx
callq 0x2350
movq (%r12), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x30(%rsp,%rax)
je 0x6051
movq 0x5006(%rip), %rdi      # 0xafd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x4feb(%rip), %rdi      # 0xafd8
callq 0x2040
movq %rax, %rdi
callq 0x2110
movq %rax, %rbx
leaq 0x2dd1(%rip), %rsi      # 0x8dd5
movl $0x14, %edx
movq %rax, %rdi
callq 0x2200
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x2200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movl $0x1, %ebp
movq %rax, %rdi
callq 0x2110
jmp 0x60c2
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
movb 0x30(%rsp,%rax), %al
andb $0x2, %al
shrb %al
testl %ebx, %ebx
setle %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x60c2
movq %r14, %r15
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
xorl %r14d, %r14d
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x2100
cmpl $0x1, %r14d
je 0x6098
movl $0x1, %r14d
jmp 0x60ad
movsd 0x8(%rsp), %xmm0
movslq %r13d, %r13
movsd %xmm0, (%r15,%r13,8)
incl %r13d
xorl %r14d, %r14d
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x30(%rsp,%rax)
jne 0x60c2
cmpl %ebx, %r13d
jl 0x607d
leaq 0x10(%rsp), %rdi
callq 0x2060
movl %ebp, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x60e2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq 0x20(%rsi), %r14
leaq 0x7934(%rip), %rdi      # 0xb004
movq %r14, %rsi
callq 0x3370
testl %eax, %eax
je 0x3707
leaq 0x7b67(%rip), %rdi      # 0xb24a
movq %r14, %rsi
callq 0x3370
testl %eax, %eax
je 0x3707
leaq 0x7910(%rip), %rdi      # 0xb006
callq 0xa236
movl %ebp, %edi
movq %rbx, %rsi
callq 0x55d3
jmp 0x371d
leaq 0x78f8(%rip), %rdi      # 0xb006
callq 0xa236
movl %ebp, %edi
movq %rbx, %rsi
callq 0x8514
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9bca
xorl %ecx, %ecx
jmp 0x9be6
movb $0x1, %cl
je 0x9be6
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
testb $0x1, %bl
jne 0x9be9
xorl %ecx, %ecx
addq $0x38, %rsp
popq %rbx
popq %r14
movl %ecx, %eax
retq
movq %rbx, %xmm0
punpckldq 0x147a(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1482(%rip), %xmm0     # 0xb080
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
movapd %xmm2, 0x10(%rsp)
jb 0x9c23
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x9c32
movapd %xmm2, %xmm0
callq 0x31c0
movapd 0x10(%rsp), %xmm2
addsd 0x19ce(%rip), %xmm0     # 0xb608
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq %rbx, %rax
mulq %rcx
ucomisd 0x19be(%rip), %xmm0     # 0xb610
setbe %cl
jbe 0x9bdf
shrq %rdx
leaq (%rdx,%rdx,2), %rax
movq %rbx, %rdx
subq %rax, %rdx
je 0x9bdf
movl $0x5, %r14d
movq 0x13f8(%rip), %xmm3     # 0xb070
movapd 0x1400(%rip), %xmm4     # 0xb080
sqrtsd %xmm2, %xmm5
xorpd %xmm6, %xmm6
movsd 0x1978(%rip), %xmm7     # 0xb608
movsd %xmm5, 0x8(%rsp)
movq %r14, %xmm8
punpckldq %xmm3, %xmm8    # xmm8 = xmm8[0],xmm3[0],xmm8[1],xmm3[1]
subpd %xmm4, %xmm8
ucomisd %xmm6, %xmm2
movapd %xmm5, %xmm0
jae 0x9cee
movapd %xmm2, %xmm0
movapd %xmm8, 0x20(%rsp)
callq 0x31c0
movapd 0x20(%rsp), %xmm8
movsd 0x193a(%rip), %xmm7     # 0xb608
xorpd %xmm6, %xmm6
movsd 0x8(%rsp), %xmm5
movapd 0x13a0(%rip), %xmm4     # 0xb080
movq 0x1388(%rip), %xmm3     # 0xb070
movapd 0x10(%rsp), %xmm2
movapd %xmm8, %xmm1
unpckhpd %xmm8, %xmm1            # xmm1 = xmm1[1],xmm8[1]
addsd %xmm8, %xmm1
addsd %xmm7, %xmm0
ucomisd %xmm1, %xmm0
setbe %cl
jbe 0x9bdf
movq %rbx, %rax
xorl %edx, %edx
divq %r14
addq $0x2, %r14
testq %rdx, %rdx
jne 0x9c96
jmp 0x9bdf
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9bc0
testb %al, %al
jne 0x9d5e
movl %ebx, %r14d
andl $0x1, %r14d
addq %rbx, %r14
incq %r14
je 0x9d5e
movq %r14, %rdi
callq 0x9bc0
testb %al, %al
jne 0x9d5b
addq $0x2, %r14
jne 0x9d47
jmp 0x9d5e
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xa8, %rsp
xorl %edi, %edi
callq 0x3210
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x31a0
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 0x1877(%rip), %rdx      # 0xb628
leaq 0x50(%rsp), %rbx
movl $0x50, %esi
movq %rbx, %rdi
callq 0x31d0
movq 0x420e(%rip), %r14      # 0xdfd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
movq %rax, %r14
leaq 0x1839(%rip), %rsi      # 0xb634
movl $0xf, %edx
movq %rax, %rdi
callq 0x32d0
movq %rbx, %rdi
callq 0x30c0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x32d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %eax
leaq 0x445a(%rip), %rcx      # 0xe2d0
movb (%rax,%rcx), %bpl
movl $0x8, 0x4464(%rip)      # 0xe2e8
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x9f0c
movl %ebp, %eax
andb $0x3, %al
movb %al, 0x7(%rsp)
movl %ebp, %r12d
shrb $0x2, %r12b
andb $0x3, %r12b
movl %ebp, %eax
shrb $0x4, %al
andb $0x3, %al
movb %al, 0x6(%rsp)
shrb $0x6, %bpl
movq (%rdi), %r15
movl $0x1, %r13d
xorl %eax, %eax
xorl %ebx, %ebx
movsbl (%r15,%rax), %edi
callq 0x3490
cmpl $0x46, %eax
jg 0x9edd
movl %ebp, %ecx
cmpl $0x41, %eax
je 0x9eee
movb 0x7(%rsp), %cl
cmpl $0x43, %eax
je 0x9eee
jmp 0x9f02
movl %r12d, %ecx
cmpl $0x47, %eax
je 0x9eee
movb 0x6(%rsp), %cl
cmpl $0x54, %eax
jne 0x9f02
movzbl %cl, %eax
leaq (%rax,%rbx,4), %rbx
movl %r13d, %eax
incl %r13d
cmpq %rax, %r14
ja 0x9ebc
jmp 0x9f0e
movl $0x7, 0x43dc(%rip)      # 0xe2e8
xorl %ebx, %ebx
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_O1/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, 0x4398(%rip)      # 0xe2c4
jb 0x9fa9
movl %edx, %ebx
movq %rdi, %r14
movl %ebp, %eax
leaq 0x4394(%rip), %rcx      # 0xe2d0
movb (%rax,%rcx), %bpl
movl $0x8, 0x439e(%rip)      # 0xe2e8
movsbl %sil, %edi
callq 0x3490
cmpl $0x46, %eax
jg 0x9f64
cmpl $0x41, %eax
je 0x9f82
cmpl $0x43, %eax
je 0x9f8c
jmp 0x9f74
cmpl $0x47, %eax
je 0x9f88
cmpl $0x54, %eax
jne 0x9f74
shrb $0x4, %bpl
jmp 0x9f8c
movl $0x7, 0x436a(%rip)      # 0xe2e8
xorl %eax, %eax
jmp 0x9fa4
shrb $0x6, %bpl
jmp 0x9f90
shrb $0x2, %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
movq 0x4028(%rip), %rbx      # 0xdfd8
leaq 0x168d(%rip), %rsi      # 0xb644
movq %rbx, %rdi
callq 0x3240
movq %rax, %rdi
movl %ebp, %esi
callq 0x3360
movq %rax, %rdi
callq 0x30e0
leaq 0x1690(%rip), %rsi      # 0xb668
movq %rbx, %rdi
callq 0x3240
movq %rax, %rdi
callq 0x30e0
xorl %edi, %edi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x1516(%rip), %rdx      # 0xb530
movq %rdx, %rsi
callq 0x637e
testl %ebp, %ebp
je 0xa201
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r12
testw %r14w, %r14w
sete %dl
movq %r15, %rcx
andq $0x3, %rcx
sete %sil
movb $0x41, %al
testb %sil, %dl
jne 0xa11f
testw %r14w, %r14w
sete %dl
cmpq $0x1, %rcx
sete %sil
testb %sil, %dl
je 0xa06c
movb $0x54, %al
jmp 0xa11f
testw %r14w, %r14w
sete %dl
cmpq $0x2, %rcx
sete %sil
testb %sil, %dl
je 0xa087
movb $0x47, %al
jmp 0xa11f
testq %rcx, %rcx
sete %dl
cmpw $0x1, %r14w
sete %sil
testw %r14w, %r14w
sete %dil
cmpq $0x3, %rcx
sete %r8b
testb %r8b, %dil
jne 0xa11d
andb %dl, %sil
jne 0xa11d
cmpq $0x1, %rcx
sete %dl
cmpw $0x1, %r14w
sete %sil
testb %dl, %sil
jne 0xa11f
cmpq $0x2, %rcx
sete %dl
cmpw $0x1, %r14w
sete %sil
testb %dl, %sil
jne 0xa065
cmpq $0x3, %rcx
sete %dil
testq %rcx, %rcx
sete %dl
cmpw $0x2, %r14w
sete %sil
cmpw $0x1, %r14w
sete %r8b
testb %dil, %r8b
jne 0xa080
andb %dl, %sil
jne 0xa080
cmpq $0x1, %rcx
sete %dl
cmpw $0x2, %r14w
sete %sil
testb %dl, %sil
je 0xa160
movb $0x43, %al
movzbl %al, %esi
movq %r12, %rdi
movq %rbx, %rdx
callq 0xa289
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3300
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xa14f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
shrq $0x2, %r15
decl %ebp
jne 0xa034
jmp 0xa201
cmpq $0x2, %rcx
sete %dl
cmpw $0x2, %r14w
sete %sil
testb %dl, %sil
jne 0xa11f
cmpq $0x3, %rcx
sete %al
testq %rcx, %rcx
sete %dl
cmpw $0x3, %r14w
sete %sil
cmpw $0x2, %r14w
sete %dil
testb %al, %dil
jne 0xa065
movb $0x54, %al
andb %dl, %sil
jne 0xa11f
cmpq $0x1, %rcx
sete %dl
cmpw $0x3, %r14w
sete %sil
movb $0x47, %al
testb %dl, %sil
jne 0xa11f
cmpq $0x2, %rcx
sete %dl
cmpw $0x3, %r14w
sete %sil
movb $0x43, %al
testb %dl, %sil
jne 0xa11f
cmpq $0x3, %rcx
movl $0x5a, %eax
movl $0x41, %ecx
cmovel %ecx, %eax
cmpw $0x3, %r14w
movl $0x5a, %ecx
cmovnel %ecx, %eax
jmp 0xa11f
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
cmpq (%rsp), %rdi
je 0xa22e
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3270
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
movl 0x11729(%rip), %esi     # 0x15270
addl $0x4, %esi
leaq 0xd537(%rip), %rdi      # 0x11088
movl $0x14, %edx
xorl %eax, %eax
callq 0x3060
movq 0x118ec(%rip), %rbx     # 0x15450
movq 0x1145d(%rip), %rdi     # 0x14fc8
leaq 0xd51f(%rip), %rsi      # 0x11091
movl $0x9, %edx
callq 0x32c0
cmpq $0x36, %rbx
ja 0x3bb7
movq 0x118e7(%rip), %rdx     # 0x15470
leaq 0x118b8(%rip), %rsi     # 0x15448
movq %rsp, %rbx
movq %rbx, %rdi
movq $-0x1, %rcx
callq 0x3270
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x11418(%rip), %rdi     # 0x14fc8
callq 0x32c0
jmp 0x3bf7
leaq 0x1188a(%rip), %rsi     # 0x15448
movq %rsp, %rbx
movl $0x2d, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3270
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x113ea(%rip), %rdi     # 0x14fc8
callq 0x32c0
leaq 0xd4b1(%rip), %rsi      # 0x1109b
movl $0x3, %edx
movq %rax, %rdi
callq 0x32c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c12
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movl 0x11664(%rip), %eax     # 0x1527c
movl 0x11656(%rip), %ecx     # 0x15274
leal (%rax,%rcx), %esi
decl %esi
leaq 0xd45e(%rip), %rdi      # 0x11088
movl $0x1, %edx
xorl %eax, %eax
callq 0x3060
addq $0x20, %rsp
popq %rbx
retq
jmp 0x3c3e
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c5c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/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), %rdx
movl %edx, %eax
decl %edx
testl %edx, %edx
movl $0x1, %ecx
cmovlel %edx, %ecx
decq %rax
cmpl $0x2, %eax
jl 0x3c95
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq (%rsi), %rdi
cmpb $0x2f, (%rdi,%rdx)
jne 0x3c7a
movl %eax, %ecx
movslq %ecx, %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3270
movq %rbx, %rax
popq %rbx
retq