LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/iibrahimli[P]adsa_project/src/../include/util.hpp
// Function: write_psf(char const*, std::vector<float, std::allocator<float>> const&, unsigned int, int)
void write_psf(const char* filename, const std::vector<float>& psf, unsigned int resolution, int maxshift){
    std::ofstream out(filename);
    if(!out){
        // error opening file
        std::cerr << "Unable to write to file \'" <<filename << "\'" << std::endl;
        exit(1);
    }
    out << psf.size() << std::endl;
    out << resolution << std::endl;
    out << maxshift << std::endl;
    for(auto& p : psf) out << p << std::endl;
    out.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x10, %edx
callq 0x2230
movq (%r12), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x472c
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x2, %rsi
movq %rsp, %rdi
callq 0x2160
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
movl %r14d, %esi
movq %rsp, %rdi
callq 0x2160
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
movq %rsp, %rdi
movl %ebp, %esi
callq 0x2380
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x46e3
movq %rsp, %rbx
xorps %xmm0, %xmm0
cvtss2sd (%r15), %xmm0
movq %rbx, %rdi
callq 0x2310
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
addq $0x4, %r15
cmpq %r12, %r15
jne 0x46a0
movq %rsp, %rdi
callq 0x22d0
movq 0x58c6(%rip), %rax      # 0x9fb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x21c0
leaq 0xf8(%rsp), %rdi
callq 0x20a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x58b5(%rip), %rdi      # 0x9fe8
leaq 0x2d97(%rip), %rsi      # 0x74d1
movl $0x19, %edx
callq 0x2250
movq 0x589d(%rip), %rdi      # 0x9fe8
movq %r15, %rsi
callq 0x2200
movq %rax, %rbx
leaq 0x2d3a(%rip), %rsi      # 0x7497
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x2100
movl $0x1, %edi
callq 0x2270
jmp 0x477e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x22e0
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/iibrahimli[P]adsa_project/src/../include/util.hpp
// Function: read_psf(char const*, unsigned int*, int*)
std::vector<float> read_psf(const char* filename, unsigned int* resolution, int* maxshift){
    std::ifstream in(filename);
    if(!in){
        // error opening file
        std::cerr << "Unable to read from file \'" <<filename << "\'" << std::endl;
        exit(1);
    }
    std::vector<float> psf;
    int n_strips;
    float p;
    in >> n_strips;
    psf.reserve(n_strips);
    in >> *resolution;
    in >> *maxshift;
    for(int i=0; i<n_strips; ++i){
        in >> p;
        psf.push_back(p);
    }
    return psf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movl $0x8, %edx
callq 0x23c0
movq (%r13), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x30(%rsp,%rax)
jne 0x4885
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2150
movslq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56e4
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2390
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2150
cmpl $0x0, 0x8(%rsp)
jle 0x4866
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x23e0
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4853
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x485e
movq %rbx, %rdi
movq %r15, %rdx
callq 0x65e4
incl %ebp
cmpl 0x8(%rsp), %ebp
jl 0x482a
leaq 0x10(%rsp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x575c(%rip), %rdi      # 0x9fe8
leaq 0x2c58(%rip), %rsi      # 0x74eb
movl $0x1a, %edx
callq 0x2250
movq 0x5744(%rip), %rdi      # 0x9fe8
movq %r12, %rsi
callq 0x2200
movq %rax, %rbx
leaq 0x2be1(%rip), %rsi      # 0x7497
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x2100
movl $0x1, %edi
callq 0x2270
movq %rax, %r14
jmp 0x48f3
jmp 0x48dc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x48f3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2220
leaq 0x10(%rsp), %rdi
callq 0x2070
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/iibrahimli[P]adsa_project/src/../include/bmp.hpp
// Function: BMP_image::save_as(char const*)
void save_as(const char *filename){
        filenm = filename;

        std::ofstream out(filename, std::ios::binary);

        if(!out){
            // error opening file
            std::cerr << "Unable to write to file \'" << filename << "\'" << std::endl;
            exit(EXIT_FAILURE);
        }

        // can't work with other bits per pixel values
        if(info_h.bit_count != 24 && info_h.bit_count != 32){
            std::cerr << "Can't work with bpp values other than 32 or 24 (bpp is " << info_h.bit_count << ")" << std::endl;
            exit(EXIT_FAILURE);
        }

        write_h_p(out);
        out.close();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rdi), %r15
movq 0x48(%rdi), %r12
movq %rsi, %rdi
callq 0x20e0
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x2300
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x2230
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x5c1c
movzwl 0x1c(%rbx), %eax
cmpl $0x18, %eax
je 0x5bc4
cmpl $0x20, %eax
jne 0x5c64
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6268
leaq 0x8(%rsp), %rdi
callq 0x22d0
movq 0x43d6(%rip), %rax      # 0x9fb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x21c0
leaq 0x100(%rsp), %rdi
callq 0x20a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x43c5(%rip), %rdi      # 0x9fe8
leaq 0x18a7(%rip), %rsi      # 0x74d1
movl $0x19, %edx
callq 0x2250
movq 0x43ad(%rip), %rdi      # 0x9fe8
movq %r14, %rsi
callq 0x2200
movq %rax, %rbx
leaq 0x184a(%rip), %rsi      # 0x7497
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x2100
jmp 0x5cab
movq 0x437d(%rip), %rdi      # 0x9fe8
leaq 0x195f(%rip), %rsi      # 0x75d1
movl $0x37, %edx
callq 0x2250
movzwl 0x1c(%rbx), %esi
movq 0x4361(%rip), %rdi      # 0x9fe8
callq 0x2160
movq %rax, %rbx
leaq 0x1395(%rip), %rsi      # 0x702b
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x2100
movl $0x1, %edi
callq 0x2270
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22e0
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/iibrahimli[P]adsa_project/src/../include/bmp.hpp
// Function: BMP_image::write_h_p(std::basic_ofstream<char, std::char_traits<char>>&)
void write_h_p(std::ofstream& of){
        if(neg_height) info_h.height *= -1;
        of.write((const char*) &file_h, sizeof file_h);
        of.write((const char*) &info_h, sizeof info_h);
        if(neg_height) info_h.height *= -1;

        for(int r=0; r<info_h.height; ++r){
            of.write((const char *) &data[r * info_h.width], info_h.width * info_h.bit_count/8);
            of.write("\x00\x00\x00", padding);  // pad with null bytes
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x64(%rdi)
jne 0x627f
negl 0x16(%r14)
movl $0xe, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22a0
leaq 0xe(%r14), %rsi
movl $0x28, %edx
movq %rbx, %rdi
callq 0x22a0
cmpb $0x1, 0x64(%r14)
jne 0x62ab
negl 0x16(%r14)
cmpl $0x0, 0x16(%r14)
jle 0x6302
xorl %ebp, %ebp
leaq 0xd59(%rip), %r15       # 0x7014
movl 0x12(%r14), %eax
movzwl 0x1c(%r14), %ecx
imull %eax, %ecx
imull %ebp, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
addq 0x38(%r14), %rsi
leal 0x7(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x3, %eax
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x22a0
movl 0x60(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22a0
incl %ebp
cmpl 0x16(%r14), %ebp
jl 0x62bb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/string_util.hpp
// Function: ssf::shortened_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
auto shortened_string(std::string s, std::size_t length)
{
    if (s.length() < length)
    {
        return s;
    }
    else
    {
        return s.substr(0, length);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq %rdx, %rax
jae 0x39fc
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rsi), %rdi
leaq 0x10(%rsi), %rcx
cmpq %rcx, %rdi
je 0x3a0b
movq %rdi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x3a11
movq %rdx, %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3220
jmp 0x3a24
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, 0x8(%rbx)
movq %rcx, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/main.cpp
// Function: draw_to_page(ssf::ConsolePage&, ssf::Filetree&)
void draw_to_page(ssf::ConsolePage &page, ssf::Filetree &tree)
{
	page.clear_entries();
	page.add_col(tree.get_left());
	page.add_col(tree.get_current());
	page.add_col(tree.get_right());

	page.set_selection(tree.get_selection());
	page.set_parent_selection(tree.get_parent_selection());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x50(%rdi), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x7012
leaq 0x78(%r15), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x7430
movq %r12, %rdi
movq %r14, %rsi
callq 0x726c
leaq 0x60(%rsp), %rdi
callq 0x5e86
leaq 0x90(%r15), %rsi
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x7430
movq %r12, %rdi
movq %r14, %rsi
callq 0x726c
leaq 0x48(%rsp), %rdi
callq 0x5e86
leaq 0xa8(%r15), %rsi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x7430
movq %r12, %rdi
movq %r14, %rsi
callq 0x726c
leaq 0x30(%rsp), %rdi
callq 0x5e86
leaq 0x30(%r15), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x7430
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ec8
leaq 0x18(%rsp), %rdi
callq 0x5e86
addq $0x48, %r15
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x7430
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f3e
movq %rsp, %rdi
callq 0x5e86
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4187
jmp 0x4187
jmp 0x4187
jmp 0x4187
movq %rax, %rbx
movq %r14, %rdi
callq 0x5e86
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/console_page.hpp
// Function: ssf::ConsolePage::set_selection(std::vector<std::filesystem::__cxx11::directory_entry, std::allocator<std::filesystem::__cxx11::directory_entry>>)
void set_selection(std::vector<std::filesystem::directory_entry> s)
    {
	if(!s.empty()){
		_selection.resize(0);
       		_selection.push_back(s.at(0));

	}
	else{
		_selection.resize(0);
	}
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
addq $0x10, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x760e
cmpq %r12, %r15
je 0x5f0f
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
je 0x5f1b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x768c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
leaq 0x4294(%rip), %rdi      # 0xa1c8
xorl %esi, %esi
xorl %eax, %eax
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/console_page.hpp
// Function: ssf::ConsolePage::set_parent_selection(std::vector<std::filesystem::__cxx11::directory_entry, std::allocator<std::filesystem::__cxx11::directory_entry>>)
void set_parent_selection(std::vector<std::filesystem::directory_entry> s)
    {
	if(!s.empty()){
		_parent_selection.resize(0);
       		_parent_selection.push_back(s.at(0));

	}
	else{
		_parent_selection.resize(0);
	}
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
addq $0x28, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x760e
cmpq %r12, %r15
je 0x5f85
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
je 0x5f91
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x768c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
leaq 0x421e(%rip), %rdi      # 0xa1c8
xorl %esi, %esi
xorl %eax, %eax
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/console_settings.hpp
// Function: ssf::ConsoleSettings::ConsoleSettings()
ConsoleSettings()
    {
        tcgetattr(STDIN_FILENO, &saved_settings); // Save settings to restore later

        auto new_settings = saved_settings;

        // Flags from https://viewsourcecode.org/snaptoken/kilo/02.enteringRawMode.html
        new_settings.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
        new_settings.c_oflag &= ~(OPOST);
        new_settings.c_cflag |= (CS8);
        new_settings.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
        new_settings.c_cc[VMIN] = 1;  // 1 Byte
        new_settings.c_cc[VTIME] = 1; // 100ms

        tcsetattr(STDIN_FILENO, TCSAFLUSH, &new_settings);
    }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x3230
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x2c(%rbx), %xmm3
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm1, 0x10(%rdx)
movups %xmm3, 0x2c(%rdx)
andl $0xfffffacd, (%rdx)     # imm = 0xFFFFFACD
movaps %xmm2, 0x20(%rdx)
andb $-0x2, 0x4(%rdx)
orb $0x30, 0x8(%rdx)
andl $0xffff7ff4, 0xc(%rdx)  # imm = 0xFFFF7FF4
movw $0x101, 0x16(%rdx)      # imm = 0x101
xorl %edi, %edi
movl $0x2, %esi
callq 0x3280
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/console_screen.hpp
// Function: ssf::ConsoleScreen::operator<<(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
ConsoleScreen const &operator<<(std::string const buffer) const
    {
        std::cout << buffer;
        try
        {
            post_draw_callback();
        }
        catch (std::bad_function_call &c)
        {
            log << c.what();
        }
        return *this;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq 0x8da4(%rip), %rdi      # 0xefd0
movq %rax, %rsi
callq 0x3240
cmpq $0x0, 0x10(%rbx)
je 0x6246
movq %rbx, %rdi
callq *0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x30b0
movq %rax, %rdi
movl %edx, %esi
callq 0x34a1
jmp 0x6241
nop
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/console_input_handler.hpp
// Function: ssf::ConsoleInputHandler::loop_until(char)
void loop_until(char exit_char)
    {
        char c = '\0';
        while (c != exit_char)
        {
            c = std::cin.get();
            try
            {
                callbacks.at(c)(); // Execute callback
            }
            catch (const std::out_of_range &e)
            {
                log << "key " << (int)c << " not registered\n";
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movb $0x0, 0x7(%rsp)
testb %bl, %bl
je 0x6c47
movq %rdi, %r14
movq 0x83e5(%rip), %r15      # 0xefe0
leaq 0x7(%rsp), %r12
movq %r15, %rdi
callq 0x3250
movb %al, 0x7(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x8dc6
cmpq $0x0, 0x10(%rax)
je 0x6c2c
movq %rax, %rdi
callq *0x18(%rax)
cmpb %bl, 0x7(%rsp)
jne 0x6c00
jmp 0x6c47
callq 0x30b0
jmp 0x6c58
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x6c53
callq 0x30d0
callq 0x3370
jmp 0x6c24
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/command_line.hpp
// Function: ssf::CommandLine::loop_until(char)
void loop_until(char exit_key)
    {
        char c = '0';
        while (c != exit_key)
        {
            c = std::cin.get();
            switch (c)
            {
            case 127: // Delete
                if (_text.length())
                {
                    _text.pop_back();
                }
                break;
            case 13: // Enter
                try
                {
                    command_cb(_text.substr(1, _text.length()));
                }
                catch (std::bad_function_call &c)
                {
                    log << c.what();
                }
                return;
                break;
            default:
                _text.push_back(c);
                break;
            }
            try
            {
                draw_cb(str());
            }
            catch (std::bad_function_call &e)
            {
                log << "CommandLine Draw Callback Missing";
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
cmpb $0x30, %bpl
jne 0x6c7d
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x48(%rdi), %r15
leaq 0x18(%rsp), %r13
movq 0x834c(%rip), %rdi      # 0xefe0
callq 0x3250
movl %eax, %r12d
cmpb $0x7f, %r12b
je 0x6cbd
movsbl %r12b, %eax
cmpl $0xd, %eax
je 0x6d68
movsbl %r12b, %esi
movq %r14, %rdi
callq 0x31c0
jmp 0x6ccc
cmpq $0x0, 0x10(%rbx)
je 0x6ccc
movq %r14, %rdi
callq 0x3260
movq %r13, %rdi
movq %rbx, %rsi
callq 0x8e0a
cmpq $0x0, 0x58(%rbx)
je 0x6d10
movq %r15, %rdi
movq %r13, %rsi
callq *0x60(%rbx)
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x6d03
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3200
movsbl %r12b, %eax
cmpl %ebp, %eax
jne 0x6c8d
jmp 0x6c6e
callq 0x30b0
jmp 0x6dba
movq %rdx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x6d4c
movq %rdx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x6d4c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3200
cmpl $0x1, 0x10(%rsp)
jne 0x6e09
movq 0x8(%rsp), %rdi
callq 0x30d0
callq 0x3370
jmp 0x6d03
movq 0x10(%rbx), %rcx
leaq 0x38(%rsp), %rdi
movl $0x1, %edx
movq %r14, %rsi
callq 0x3220
cmpq $0x0, 0x38(%rbx)
je 0x6db5
leaq 0x28(%rbx), %rdi
leaq 0x38(%rsp), %rsi
callq *0x40(%rbx)
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c6e
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0x6c6e
callq 0x30b0
movq %rdx, %rbx
movq %rax, 0x8(%rsp)
jmp 0x6de7
movq %rdx, %rbx
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6de7
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3200
cmpl $0x1, %ebx
jne 0x6e09
movq 0x8(%rsp), %rdi
callq 0x30d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
callq 0x3370
jmp 0x6c6e
movq 0x8(%rsp), %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::get_directory_list(std::filesystem::__cxx11::path)
std::vector<std::filesystem::directory_entry> get_directory_list(std::filesystem::path temp)
	{
		auto di = std::filesystem::directory_iterator(temp);
		std::vector<std::filesystem::directory_entry> res;
		for (auto &d : di)
		{
			auto comp = d.path().filename().string().at(0);
			if (comp != '.' || !hide_dot_files)
			{
				res.push_back(d);
			}
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3140
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, (%rsp)
movq $0x0, 0x10(%rbx)
movq (%r15), %rax
movq 0x8(%r15), %rcx
testq %rcx, %rcx
je 0x7e43
movq 0x7193(%rip), %rdx      # 0xefc8
cmpb $0x0, (%rdx)
je 0x7e3f
incl 0x8(%rcx)
jmp 0x7e43
lock
incl 0x8(%rcx)
movq %rax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x7e76
movq 0x716a(%rip), %rax      # 0xefc8
cmpb $0x0, (%rax)
je 0x7e68
incl 0x8(%rdi)
jmp 0x7e6c
lock
incl 0x8(%rdi)
testq %rdi, %rdi
je 0x7e76
callq 0x8298
leaq 0x30(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x50(%rsp), %r12
leaq 0x20(%rsp), %r13
cmpq $0x0, 0x10(%rsp)
je 0x7f79
movq %r15, %rdi
callq 0x33d0
movq %rax, %rbp
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x7f04
movq 0x20(%rbp), %rcx
movl %ecx, %edx
notb %dl
movq %rbp, %rsi
testb $0x3, %dl
je 0x7efa
movl %ecx, %edx
andl $0x3, %edx
jne 0x7f04
movq (%rbp), %rdx
cmpb $0x2f, -0x1(%rdx,%rax)
je 0x7f04
testb $0x3, %cl
je 0x7ed5
xorl %eax, %eax
jmp 0x7ede
leaq 0x20(%rbp), %rdi
callq 0x3150
leaq -0x30(%rax), %rcx
testb $0x3, 0x20(%rbp)
cmovneq %rax, %rcx
movq %rbp, %rsi
cmoveq %rcx, %rsi
movl 0x20(%rsi), %eax
notl %eax
testb $0x3, %al
jne 0x7f04
movq %r12, %rdi
callq 0x7580
jmp 0x7f0c
movq %r12, %rdi
callq 0x7866
movq 0x50(%rsp), %rsi
movq %r14, 0x20(%rsp)
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x8308
movq 0x28(%rsp), %rdx
testq %rdx, %rdx
je 0x7faa
movq 0x20(%rsp), %rdi
movb (%rdi), %bl
cmpq %r14, %rdi
je 0x7f49
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
movq %r12, %rdi
callq 0x75d6
cmpb $0x2e, %bl
jne 0x7f60
movq 0x18(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x7f6c
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x768c
movq %r15, %rdi
callq 0x3090
jmp 0x7e8a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7f88
callq 0x8298
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x7f97
callq 0x8298
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x228b(%rip), %rdi      # 0xa23c
xorl %esi, %esi
xorl %eax, %eax
callq 0x3310
jmp 0x7fbe
jmp 0x7fbe
movq %rax, %r15
jmp 0x7fec
movq %rax, %r15
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x7fe2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0x7fe2
movq %rax, %r15
leaq 0x50(%rsp), %rdi
callq 0x75d6
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7ffb
callq 0x8298
movq (%rsp), %rdi
callq 0x5e86
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x8013
callq 0x8298
movq %r15, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::check_selection()
void check_selection(){
		//check if not valid
		if(!selection.empty()){
			if(find_element(active_col, selection.at(0)) == active_col.end()){
				selection.clear();			
			}
		}
		//default to first entry if possible
		if(selection.empty() && !active_col.empty()){
			update_selection(*active_col.begin());
		}
		
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %r15
cmpq 0x38(%rdi), %r15
je 0x80a0
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x7580
movb 0x28(%r15), %al
movb %al, 0x28(%r14)
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
movq %r14, %rdx
callq 0x83eb
movq %rax, %r15
movq 0x98(%rbx), %r14
leaq 0x38(%rsp), %rdi
callq 0x75d6
cmpq %r14, %r15
jne 0x80a0
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %r12
cmpq %r15, %r12
je 0x80a0
movq %r15, %r14
movq %r14, %rdi
callq 0x75d6
addq $0x30, %r14
cmpq %r12, %r14
jne 0x808b
movq %r15, 0x38(%rbx)
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x80e7
movq 0x90(%rbx), %r15
cmpq 0x98(%rbx), %r15
je 0x80e7
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x7580
movb 0x28(%r15), %al
movb %al, 0x28(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8398
leaq 0x8(%rsp), %rdi
callq 0x75d6
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x80f5
movq %rax, %rbx
movq %r14, %rdi
callq 0x75d6
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::check_parent_selection()
void check_parent_selection(){
		if (current_path.has_parent_path())
		{
			auto parent_dir = left_col;
			auto dir_name = current_path.filename();
			auto it = std::find_if(parent_dir.begin(), parent_dir.end(),
								   [&](std::filesystem::directory_entry &dir) {
									   return dir.path().filename() == dir_name;
								   });
			if (it != parent_dir.end())
			{
				update_parent_selection(*it);
			}
			else
			{
				//This case should not happen but whooo knows...
				parent_selection.clear();	
			}
		}
		else
		{
			parent_selection.clear();
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x30f0
testb %al, %al
je 0x816b
leaq 0x78(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x7430
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x81ca
movq 0x28(%rbx), %rax
movl %eax, %edx
notb %dl
testb $0x3, %dl
je 0x81bb
movl %eax, %edx
andl $0x3, %edx
jne 0x81ca
movq (%r14), %rdx
cmpb $0x2f, -0x1(%rdx,%rcx)
je 0x81ca
leaq 0x28(%rbx), %r15
testb $0x3, %al
je 0x8199
xorl %eax, %eax
jmp 0x81a1
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r15, %r12
je 0x8258
movq %r15, %r14
movq %r14, %rdi
callq 0x75d6
addq $0x30, %r14
cmpq %r12, %r14
jne 0x817f
movq %r15, 0x50(%rbx)
jmp 0x8258
movq %r15, %rdi
callq 0x3150
leaq -0x30(%rax), %rcx
testb $0x3, (%r15)
cmovneq %rax, %rcx
cmoveq %rcx, %r14
movl 0x20(%r14), %eax
notl %eax
testb $0x3, %al
jne 0x81ca
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x7580
jmp 0x81d4
leaq 0x20(%rsp), %rdi
callq 0x7866
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x86d3
movq %rax, %r14
cmpq 0x10(%rsp), %rax
je 0x821f
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x7580
movb 0x28(%r14), %al
leaq 0x48(%rsp), %rsi
movb %al, 0x28(%rsi)
movq %rbx, %rdi
callq 0x8680
leaq 0x48(%rsp), %rdi
callq 0x75d6
jmp 0x8244
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r15, %r12
je 0x8244
movq %r15, %r14
movq %r14, %rdi
callq 0x75d6
addq $0x30, %r14
cmpq %r12, %r14
jne 0x822f
movq %r15, 0x50(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x75d6
leaq 0x8(%rsp), %rdi
callq 0x5e86
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x8285
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x75d6
jmp 0x827b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x75d6
leaq 0x8(%rsp), %rdi
callq 0x5e86
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/command_line.hpp
// Function: ssf::CommandLine::str[abi:cxx11]() const
std::string str() const
    {
        std::ostringstream p;
        p << c_cmd::set_cursor(_row, 0)
          << c_cmd::clear_line
          << _text;
        return p.str();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x32a0
movl (%r14), %esi
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x38fc
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x3240
movq %rax, %r15
leaq 0x1486(%rip), %rsi      # 0xa2d9
movl $0x4, %edx
movq %rax, %rdi
callq 0x3240
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x3240
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e8b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x3350
movq 0x6121(%rip), %rsi      # 0xefc0
leaq 0x28(%rsp), %rdi
callq 0x3120
leaq 0x98(%rsp), %rdi
callq 0x3080
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8ec8
movq %rax, %rbx
jmp 0x8eeb
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8eeb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
movq 0x60ce(%rip), %rsi      # 0xefc0
leaq 0x28(%rsp), %rdi
callq 0x3120
leaq 0x98(%rsp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::move_down()
void move_down()
	{
		//iterate down
		if(!selection.empty()){
			auto de = *selection.begin();
			auto it = find_element(active_col,de);
			if(++it != active_col.end()){
				update_selection(*(it));
		       	}
		}
		update();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %r14
cmpq 0x38(%rdi), %r14
je 0x97b4
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7580
movb 0x28(%r14), %al
movb %al, 0x28(%r15)
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x7580
movb 0x88(%rsp), %al
leaq 0x30(%rsp), %rdx
movb %al, 0x28(%rdx)
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
callq 0x83eb
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x75d6
leaq 0x30(%r14), %rsi
cmpq 0x98(%rbx), %rsi
je 0x97aa
movq %rsp, %rdi
callq 0x7580
movb 0x58(%r14), %al
movq %rsp, %rsi
movb %al, 0x28(%rsi)
movq %rbx, %rdi
callq 0x8398
movq %rsp, %rdi
callq 0x75d6
leaq 0x60(%rsp), %rdi
callq 0x75d6
movq %rbx, %rdi
callq 0x7a76
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x97d9
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x75d6
jmp 0x97e3
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x75d6
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::move_up()
void move_up()
	{
		//iterate up
		if(!selection.empty()){
			auto it = find_element(active_col,*selection.begin());
			if(it != active_col.begin()){
				update_selection(*(--it));	
			}
		}	
		update();
			
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %r15
cmpq 0x38(%rdi), %r15
je 0x987d
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x7580
movb 0x28(%r15), %al
movb %al, 0x28(%r14)
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
movq %r14, %rdx
callq 0x83eb
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0x75d6
cmpq 0x90(%rbx), %r15
je 0x987d
movq %r15, %rsi
addq $-0x30, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x7580
movb -0x8(%r15), %al
movb %al, 0x28(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8398
movq %rsp, %rdi
callq 0x75d6
movq %rbx, %rdi
callq 0x7a76
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x9891
movq %rax, %rbx
movq %r14, %rdi
callq 0x75d6
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::move_left()
void move_left()
	{

		if (current_path.has_parent_path() &&
			current_path != current_path.root_path())
		{
			current_path = current_path.parent_path();
			if(!parent_selection.empty()){
				update_selection(parent_selection.at(0));
			}
		}
		update();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x30f0
movl %eax, %ebp
testb %al, %al
je 0x98e9
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x32c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x31e0
testl %eax, %eax
setne %r15b
jmp 0x98ec
xorl %r15d, %r15d
testb %bpl, %bpl
je 0x98fb
leaq 0x60(%rsp), %rdi
callq 0x75d6
testb %r15b, %r15b
je 0x9966
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3400
cmpq %r14, %r15
je 0x9925
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x350c
leaq 0x8(%rsp), %rdi
callq 0x75d6
movq 0x48(%rbx), %r14
cmpq 0x50(%rbx), %r14
je 0x9966
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7580
movb 0x28(%r14), %al
movb %al, 0x28(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8398
leaq 0x30(%rsp), %rdi
callq 0x75d6
movq %rbx, %rdi
callq 0x7a76
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x75d6
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::move_right()
void move_right()
	{
		try
		{
			if(!selection.empty())
			{
				auto selected = *selection.begin();
				if (selected.is_directory())
				{
					//THIS IS A DIRTY HACK AND SHOULD BE DONE PROPERLY ASAP
					auto probePerm = get_directory_list(selected.path()); //probe if filesystem throws permission error

					current_path = selected.path();
					if(!probePerm.empty()){
						update_selection(*(probePerm.begin()));
					}
				
				}
				else if (selected.is_regular_file() || selected.is_character_file())
				{
					try
					{
						move_right_on_file();
					}
					catch (std::bad_function_call &e)
					{
					}
				}
			}
		}
		catch (std::filesystem::filesystem_error &e)
		{
		}
		update();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %r14
cmpq 0x38(%rdi), %r14
je 0x9aa3
movq %rsp, %rdi
movq %r14, %rsi
callq 0x7580
movzbl 0x28(%r14), %eax
movb %al, 0x28(%rsp)
cmpl $0x3, %eax
je 0x99cc
testl %eax, %eax
jne 0x99d4
movq %rsp, %rdi
callq 0x30c0
cmpb $0x2, %al
jne 0x9a50
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
callq 0x7580
leaq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rbx, %rsi
callq 0x7de6
leaq 0x48(%rsp), %rdi
callq 0x75d6
leaq 0x8(%rbx), %rdi
movq %rsp, %rsi
callq 0x3300
movq 0x30(%rsp), %r14
cmpq 0x38(%rsp), %r14
je 0x9a44
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
callq 0x7580
movb 0x28(%r14), %al
leaq 0x70(%rsp), %rsi
movb %al, 0x28(%rsi)
movq %rbx, %rdi
callq 0x8398
leaq 0x70(%rsp), %rdi
callq 0x75d6
leaq 0x30(%rsp), %rdi
callq 0x5e86
jmp 0x9a9b
movzbl 0x28(%rsp), %eax
cmpl $0x3, %eax
je 0x9a5e
testl %eax, %eax
jne 0x9a66
movq %rsp, %rdi
callq 0x30c0
cmpb $0x1, %al
je 0x9a84
movzbl 0x28(%rsp), %eax
cmpl $0x3, %eax
je 0x9a78
testl %eax, %eax
jne 0x9a80
movq %rsp, %rdi
callq 0x30c0
cmpb $0x5, %al
jne 0x9a9b
cmpq $0x0, 0xd0(%rbx)
je 0x9ab8
leaq 0xc0(%rbx), %rdi
callq *0xd8(%rbx)
movq %rsp, %rdi
callq 0x75d6
movq %rbx, %rdi
callq 0x7a76
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x30b0
movq %rdx, %r15
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x75d6
jmp 0x9ad7
jmp 0x9ad1
movq %rdx, %r15
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x5e86
jmp 0x9b22
movq %rdx, %r15
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x75d6
jmp 0x9b22
jmp 0x9b1c
movq %rdx, %r15
movq %rax, %r14
cmpl $0x2, %r15d
jne 0x9b22
movq %r14, %rdi
callq 0x30d0
callq 0x3370
jmp 0x9a9b
jmp 0x9b1c
movq %rdx, %r15
movq %rax, %r14
jmp 0x9b2a
movq %rdx, %r15
movq %rax, %r14
movq %rsp, %rdi
callq 0x75d6
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x9b42
callq 0x30d0
callq 0x3370
jmp 0x9aa3
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/CommandLines.cpp
// Function: ha_opt_update_cov(hifiasm_opt_t*, int)
void ha_opt_update_cov(hifiasm_opt_t *opt, int hom_cov)
{
	int max_n_chain = (int)(hom_cov * opt->high_factor + .499);
	opt->hom_cov = hom_cov;
	if (opt->max_n_chain < max_n_chain)
		opt->max_n_chain = max_n_chain;
	fprintf(stderr, "[M::%s] updated max_n_chain to %d\n", __func__, opt->max_n_chain);
}

// Assembly:
cvtsi2sd %esi, %xmm0
mulsd 0xb8(%rdi), %xmm0
addsd 0x21f0a3(%rip), %xmm0   # 0x222010
cvttsd2si %xmm0, %eax
movl %esi, 0xd0(%rdi)
cmpl %eax, 0xe8(%rdi)
jge 0x2f85
movl %eax, 0xe8(%rdi)
movq 0x287054(%rip), %rax    # 0x289fe0
movq (%rax), %rax
movl 0xe8(%rdi), %ecx
leaq 0x220a2d(%rip), %rsi    # 0x2239c9
leaq 0x220a49(%rip), %rdx    # 0x2239ec
movq %rax, %rdi
xorl %eax, %eax
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/CommandLines.cpp
// Function: ha_opt_update_cov_min(hifiasm_opt_t*, int, int)
void ha_opt_update_cov_min(hifiasm_opt_t *opt, int hom_cov, int min_chain)
{
	int max_n_chain = (int)(hom_cov * opt->high_factor + .499);
	opt->hom_cov = hom_cov; opt->max_n_chain = max_n_chain;
    if(opt->max_n_chain < min_chain) opt->max_n_chain = min_chain;
	fprintf(stderr, "[M::%s] updated max_n_chain to %d\n", __func__, opt->max_n_chain);
}

// Assembly:
cvtsi2sd %esi, %xmm0
mulsd 0xb8(%rdi), %xmm0
addsd 0x21f04f(%rip), %xmm0   # 0x222010
cvttsd2si %xmm0, %ecx
movl %esi, 0xd0(%rdi)
cmpl %edx, %ecx
cmovlel %edx, %ecx
movl %ecx, 0xe8(%rdi)
movq 0x287003(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x2209e2(%rip), %rsi    # 0x2239c9
leaq 0x220a10(%rip), %rdx    # 0x2239fe
xorl %eax, %eax
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Assembly.cpp
// Function: hap_recalculate_peaks(char*)
void hap_recalculate_peaks(char* output_file_name)
{
    destory_read_bin(&R_INF);
    destory_ma_hit_t_alloc(R_INF.paf);
    destory_ma_hit_t_alloc(R_INF.reverse_paf);

    char* gfa_name = (char*)malloc(strlen(output_file_name)+25);
	sprintf(gfa_name, "%s.ec", output_file_name);

    int hom_cov, het_cov;
    // construct hash table for high occurrence k-mers
    if (!(asm_opt.flag & HA_F_NO_KMER_FLT)) {
        ha_flt_tab = ha_ft_gen(&asm_opt, &R_INF, &hom_cov, 0, 0);
        ha_opt_update_cov(&asm_opt, hom_cov);
    }
    free(R_INF.read_length);
    free(R_INF.name_index);

    load_All_reads(&R_INF, gfa_name);

    ha_idx = ha_pt_gen(&asm_opt, ha_flt_tab, 1, 0, &R_INF, &hom_cov, &het_cov); // build the index
    asm_opt.hom_cov = hom_cov;
    asm_opt.het_cov = het_cov;
    ha_pt_destroy(ha_idx);
    ha_idx = 0;

    destory_read_bin(&R_INF);
    free(gfa_name);

    load_all_data_from_disk(&R_INF.paf, &R_INF.reverse_paf, asm_opt.output_file_name); 
    fprintf(stderr, "M::%s has done.\n", __func__);   
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x286c2f(%rip), %rdi    # 0x28b230
callq 0x33322
movq 0x286c9b(%rip), %rdi    # 0x28b2a8
callq 0xa04f1
movq 0x286c97(%rip), %rdi    # 0x28b2b0
callq 0xa04f1
movq %r14, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x22084f(%rip), %rsi    # 0x224e88
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x28610b(%rip), %r14    # 0x28a758
testb $0x2, (%r14)
jne 0x468c
leaq 0x2860fe(%rip), %r15    # 0x28a758
leaq 0x286bcf(%rip), %rsi    # 0x28b230
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x14025
leaq 0x286db3(%rip), %rcx    # 0x28b430
movq %rax, (%rcx)
movl (%r12), %esi
movq %r15, %rdi
callq 0x2f59
leaq 0x286b9d(%rip), %r15    # 0x28b230
movq 0x286bae(%rip), %rdi    # 0x28b248
callq 0x2220
movq 0x286bca(%rip), %rdi    # 0x28b270
callq 0x2220
movq %r15, %rdi
movq %rbx, %rsi
callq 0x32681
leaq 0x286d73(%rip), %rax    # 0x28b430
movq (%rax), %rsi
leaq 0x14(%rsp), %r13
movq %r13, (%rsp)
pushq $0x1
popq %rdx
leaq 0x10(%rsp), %r12
movq %r14, %rdi
xorl %ecx, %ecx
movq %r15, %r8
movq %r12, %r9
callq 0x1448a
leaq 0x286d50(%rip), %rbp    # 0x28b438
movq %rax, (%rbp)
movl (%r12), %ecx
movl %ecx, 0xd0(%r14)
movl (%r13), %ecx
movl %ecx, 0xd4(%r14)
movq %rax, %rdi
callq 0x113930
andq $0x0, (%rbp)
movq %r15, %rdi
callq 0x33322
movq %rbx, %rdi
callq 0x2220
movq 0x10(%r14), %rdx
leaq 0x286b7e(%rip), %rdi    # 0x28b2a8
leaq 0x286b7f(%rip), %rsi    # 0x28b2b0
callq 0xe01d6
movq 0x2858a3(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x220747(%rip), %rsi    # 0x224e8e
leaq 0x220751(%rip), %rdx    # 0x224e9f
xorl %eax, %eax
callq 0x22b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Correct.cpp
// Function: print_graph(Graph*)
void print_graph(Graph* DAGCon)
{
    uint64_t i;
    for (i = 0; i < DAGCon->g_nodes.length; i++)
    {
        Node* currentStartNode = &(G_Node(*DAGCon, i));
        RSet iter_out;

        if(If_Node_Exist(*currentStartNode))
        {
            fprintf(stderr, "ID: %lu (%c) (w: %lu)\n", (unsigned long)(*currentStartNode).ID, (*currentStartNode).base, (unsigned long)(*currentStartNode).weight);
            clear_RSet(&iter_out);
            Edge* e;
            fprintf(stderr, "****Out-node: ");
            while(getOutputEdges(&iter_out, DAGCon, currentStartNode, &e))
            {
                //fprintf(stderr, "%d[%c], ", G_Node(*DAGCon, e->out_node).ID, G_Node(*DAGCon, e->out_node).base);
                fprintf(stderr, "%lu(w: %lu), ", (unsigned long)G_Node(*DAGCon, e->out_node).ID, (unsigned long)e->weight);
            }
            fprintf(stderr, "\n");


            // clear_RSet(&iter_out);
            // fprintf(stderr, "In-node: ");
            // while(getInputEdges(&iter_out, DAGCon, currentStartNode, &e))
            // {
            //     fprintf(stderr, "%d[%c], ", G_Node(*DAGCon, e->in_node).ID, G_Node(*DAGCon, e->in_node).base);
            // }
        }
    }

    fprintf(stderr, "*******\n");

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x60(%rdi)
jne 0x5163
movq 0x284ea0(%rip), %rax    # 0x289fe0
movq (%rax), %rcx
leaq 0x2274ae(%rip), %rdi    # 0x22c5f8
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2410
movq %rdi, %rbx
movq 0x284e73(%rip), %r15    # 0x289fe0
xorl %r12d, %r12d
movq 0x18(%rbx), %rbp
movq %r12, %rax
shlq $0x7, %rax
movsbl 0x18(%rbp,%rax), %ecx
cmpl $0x44, %ecx
jne 0x5190
incq %r12
cmpq 0x60(%rbx), %r12
jb 0x5170
jmp 0x5139
addq %rax, %rbp
movq (%r15), %rdi
movq (%rbp), %rdx
movq 0x8(%rbp), %r8
leaq 0x22076f(%rip), %rsi    # 0x225914
xorl %eax, %eax
callq 0x22b0
movq (%r15), %rcx
leaq 0x220775(%rip), %rdi    # 0x22592b
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
xorl %r14d, %r14d
movq 0x50(%rbp), %rdx
movb $0x1, %al
cmpq %rdx, %r14
jge 0x5229
movq 0x40(%rbp), %rcx
imulq $0x38, %r14, %rsi
movb $0x1, %al
cmpq $-0x1, 0x8(%rcx,%rsi)
je 0x51e5
movb $0x1, %dl
jmp 0x5209
leaq (%rcx,%rsi), %rdi
addq $0x40, %rdi
leaq -0x1(%rdx), %rsi
cmpq %r14, %rsi
je 0x5226
incq %r14
cmpq $-0x1, (%rdi)
leaq 0x38(%rdi), %rdi
je 0x51f1
cmpq %rdx, %r14
setl %dl
testb %dl, %dl
je 0x5229
imulq $0x38, %r14, %rdx
cmpq $-0x1, 0x8(%rcx,%rdx)
je 0x5229
addq %rdx, %rcx
incq %r14
xorl %eax, %eax
movq %rcx, %r13
jmp 0x5229
movq %rdx, %r14
movq (%r15), %rsi
testb %al, %al
jne 0x525a
movq 0x18(%rbx), %rax
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rcx
shlq $0x7, %rdx
movq (%rax,%rdx), %rdx
movq %rsi, %rdi
leaq 0x2206ec(%rip), %rsi    # 0x22593a
xorl %eax, %eax
callq 0x22b0
jmp 0x51c4
pushq $0xa
popq %rdi
callq 0x2270
jmp 0x5185
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Correct.cpp
// Function: prt_sub_read(char*, unsigned long, unsigned long, unsigned long)
void prt_sub_read(char *str, uint64_t str_l, uint64_t site, uint64_t win)
{
    uint64_t k, s, e;
    s = ((site >= win)?(site-win):(0)); 
    e = (((site+win+1) <= str_l)?(site+win+1):(str_l));
    fprintf(stderr, "[M::%s-site::%lu] [%lu, %lu)\n", __func__, site, s, e);

    for (k = s; k < site; k++) fprintf(stderr, "%c", str[k]);
    fprintf(stderr, "[%c]", str[k++]);
    for (; k < e; k++) fprintf(stderr, "%c", str[k]);

    fprintf(stderr, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rax
subq %rcx, %rax
movl $0x0, %r15d
cmovaeq %rax, %r15
leaq (%rdx,%rcx), %rax
incq %rax
cmpq %rsi, %rax
cmovbq %rax, %rbx
movq 0x284d3d(%rip), %rbp    # 0x289fe0
movq (%rbp), %rdi
leaq 0x2208fd(%rip), %rsi    # 0x225bab
leaq 0x220914(%rip), %rdx    # 0x225bc9
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x22b0
cmpq %r12, %r15
jae 0x52ee
cmpq %r12, %r13
cmovaeq %r12, %r13
negq %r13
leaq (%r14,%r12), %r15
movq (%rbp), %rsi
movsbl (%r15,%r13), %edi
callq 0x2270
incq %r13
jne 0x52d8
movq %r12, %r15
movq (%rbp), %rdi
movsbl (%r14,%r15), %edx
leaq 0x2208d8(%rip), %rsi    # 0x225bd6
xorl %eax, %eax
callq 0x22b0
incq %r15
cmpq %rbx, %r15
jae 0x5323
movq (%rbp), %rsi
movsbl (%r14,%r15), %edi
callq 0x2270
incq %r15
cmpq %r15, %rbx
jne 0x530d
movq (%rbp), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Correct.cpp
// Function: prt_overlap_region_stat(overlap_region*, long)
void prt_overlap_region_stat(overlap_region *z, int64_t sid)
{
    uint64_t k = 0, aln = 0, ualn = 0, err = 0;
    for (k = 0; k < z->w_list.n; k++) {
        if(is_ualn_win(z->w_list.a[k])) {
            ualn += z->w_list.a[k].x_end+1-z->w_list.a[k].x_start;
        } else {
            aln += z->w_list.a[k].x_end+1-z->w_list.a[k].x_start;
            err += z->w_list.a[k].error;
        }
    }
    fprintf(stderr, "[M::%s::utg%.6dl::%c] sid::%ld, q::[%d, %d), t::[%d, %d), aln::%lu, ualn::%lu, err::%lu\n", 
        __func__, (int32_t)z->y_id+1, "+-"[z->y_pos_strand], sid, z->x_pos_s, z->x_pos_e+1, 
        z->y_pos_s, z->y_pos_e+1, aln, ualn, err);
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r9
movq 0x48(%rdi), %rax
testq %rax, %rax
jne 0x556f
xorl %r10d, %r10d
xorl %ebx, %ebx
xorl %r11d, %r11d
movq 0x284ad5(%rip), %rax    # 0x289fe0
movq (%rax), %rax
movl 0x10(%rdi), %ecx
incl %ecx
movl 0x1c(%rdi), %edx
leaq 0x220ca6(%rip), %rsi    # 0x2261c3
movsbl (%rdx,%rsi), %r8d
movl 0x4(%rdi), %r14d
movl 0x8(%rdi), %r15d
incl %r15d
movl 0x14(%rdi), %r12d
movl 0x18(%rdi), %r13d
incl %r13d
subq $0x8, %rsp
leaq 0x222a1d(%rip), %rsi    # 0x227f60
leaq 0x222a6f(%rip), %rdx    # 0x227fb9
movq %rax, %rdi
xorl %eax, %eax
pushq %r11
pushq %rbx
pushq %r10
pushq %r13
pushq %r12
pushq %r15
pushq %r14
callq 0x22b0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x58(%rdi), %rcx
xorl %r11d, %r11d
xorl %ebx, %ebx
xorl %r10d, %r10d
movswq 0x14(%rcx), %rdx
cmpq $0x7fff, %rdx           # imm = 0x7FFF
jne 0x5596
cmpl $0x0, 0x1c(%rcx)
jne 0x5596
cmpw $0x0, 0x12(%rcx)
js 0x55b4
movl 0x4(%rcx), %esi
subl (%rcx), %esi
incl %esi
movslq %esi, %rsi
addq %rsi, %r10
addq %rdx, %r11
addq $0x20, %rcx
decq %rax
jne 0x557b
jmp 0x5504
movl 0x4(%rcx), %edx
subl (%rcx), %edx
incl %edx
movslq %edx, %rdx
addq %rdx, %rbx
jmp 0x55a6
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Correct.cpp
// Function: prt_overlap_region_phase_stat(overlap_region*, long)
void prt_overlap_region_phase_stat(overlap_region *z, int64_t sid)
{
    uint64_t k = 0;
    fprintf(stderr, "[M::%s::utg%.6dl::%c] sid::%ld, q::[%d, %d), t::[%d, %d)\n", __func__, 
        (int32_t)z->y_id+1, "+-"[z->y_pos_strand], sid, z->x_pos_s, z->x_pos_e+1, z->y_pos_s, z->y_pos_e+1);
    for (k = 0; k < z->w_list.n; k++) {
        fprintf(stderr, "[k::%lu] sid::%ld, q::[%d, %d), sec::%u\n", k, sid,
        z->w_list.a[k].x_start, z->w_list.a[k].x_end, z->w_list.a[k].clen);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x284a05(%rip), %r13    # 0x289fe0
movq (%r13), %rdi
movl 0x10(%r14), %ecx
incl %ecx
movl 0x1c(%r14), %eax
leaq 0x220bd3(%rip), %rdx    # 0x2261c3
movsbl (%rax,%rdx), %r8d
movl 0x4(%r14), %r10d
movl 0x8(%r14), %r11d
incl %r11d
movl 0x14(%r14), %r15d
movl 0x18(%r14), %r12d
incl %r12d
leaq 0x2229bf(%rip), %rsi    # 0x227fd1
leaq 0x2229f2(%rip), %rdx    # 0x22800b
movq %rbx, %r9
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r11
pushq %r10
callq 0x22b0
addq $0x20, %rsp
cmpq $0x0, 0x48(%r14)
je 0x567d
leaq 0x2229ec(%rip), %r15    # 0x228029
xorl %ebp, %ebp
xorl %r12d, %r12d
movq (%r13), %rdi
movq 0x58(%r14), %rax
movl (%rax,%rbp), %r8d
movl 0x4(%rax,%rbp), %r9d
movl 0x1c(%rax,%rbp), %r10d
subq $0x8, %rsp
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
xorl %eax, %eax
pushq %r10
callq 0x22b0
popq %rcx
popq %rdx
incq %r12
addq $0x20, %rbp
cmpq 0x48(%r14), %r12
jb 0x5642
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq