LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::calculate_tsim(int)
double Graph::calculate_tsim(int P){
    float** aware_all_ev = new float*[P];
    for (int p = 0; p < P; ++p){
        aware_all_ev[p] = new float[getSize() + 1];
        for(int v = 0; v <= getSize(); v++){
            aware_all_ev[p][v] = 0;
        }
    }
    
    for (int ev = 0; ev < P; ev++){
        if (model == 0){
            rand_LT();
            BFS_LT(ev, aware_all_ev);
        }
        else{
            BFS_IC(ev, aware_all_ev);
        }
    }

    double total_sim = 0;
    double max_weight;
    for (int v = 1; v <= getSize(); ++v){
        max_weight = 0;
        for (int p = 0; p < P; ++p){
            if (aware_all_ev[p][v] != 0 && similarities[v][p] > max_weight){
                max_weight = similarities[v][p];
            }
        }
        total_sim += max_weight;
    }

    for (int p = 0; p < P; ++p){
        delete [] aware_all_ev[p];
    }
    delete [] aware_all_ev;

    return total_sim;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl %esi, %edi
shlq $0x3, %rdi
xorl %r13d, %r13d
testl %esi, %esi
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
cmovlel %r13d, %ebx
callq 0x3030
movq %rax, %r14
movslq 0x9c8(%r15), %rbp
cmpq $-0x1, %rbp
leaq 0x4(,%rbp,4), %r12
pushq $-0x1
popq %rax
cmovlq %rax, %r12
cmpq %rbx, %r13
je 0xdc54
movq %r12, %rdi
callq 0x3030
movq %rax, (%r14,%r13,8)
xorl %ecx, %ecx
cmpq %rbp, %rcx
jg 0xdc4f
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0xdc41
incq %r13
jmp 0xdc2e
xorl %ebp, %ebp
cmpl %ebp, %ebx
je 0xdc8c
cmpl $0x0, 0xa60(%r15)
je 0xdc73
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0xd716
jmp 0xdc88
movq %r15, %rdi
callq 0xd6da
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0xd8f2
incl %ebp
jmp 0xdc56
movl 0x9c8(%r15), %eax
movq 0xae0(%r15), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
incl %eax
xorpd %xmm3, %xmm3
pushq $0x1
popq %rdx
xorps %xmm0, %xmm0
cmpq %rax, %rdx
je 0xdcf6
imulq $0x18, %rdx, %rsi
addq %rcx, %rsi
xorpd %xmm1, %xmm1
xorl %edi, %edi
cmpq %rdi, %rbx
je 0xdced
movq (%r14,%rdi,8), %r8
movss (%r8,%rdx,4), %xmm2
ucomiss %xmm0, %xmm2
jne 0xdcd5
jnp 0xdce8
movq (%rsi), %r8
movsd (%r8,%rdi,8), %xmm2
ucomisd %xmm1, %xmm2
jbe 0xdce8
movapd %xmm2, %xmm1
incq %rdi
jmp 0xdcbf
addsd %xmm1, %xmm3
incq %rdx
jmp 0xdcad
xorl %r15d, %r15d
movsd %xmm3, (%rsp)
cmpq %r15, %rbx
je 0xdd16
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0xdd11
callq 0x33f0
incq %r15
jmp 0xdcfe
movq %r14, %rdi
callq 0x33f0
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::randIndex_lin(Graph&, std::vector<float, std::allocator<float>> const&, unsigned int, int, int)
inline int HyperGraph::randIndex_lin(Graph &g, const vector<float> &w, unsigned int si, int cur, int p)
{
    // UI ranNum = g.LT_node[cur]; 
    // float ranNum = g.LT_node[cur];
    float ranNum = sfmt_genrand_real1(&sfmtSeed);
    // UI ranNum = sfmt_genrand_uint32(&sfmtSeed);
    // if (si <= 1 || ranNum > w[si - 1] * g.similarities[cur][p])
    if (si <= 0 || ranNum > w[si - 1] * g.similarities[cur][p]){
        return -1;
    }

    for (unsigned int i = 0; i < si; ++i){
        if (ranNum <= w[i] * g.similarities[cur][p])
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r15
addq $0x40, %rdi
callq 0xd09d
pushq $-0x1
popq %rax
testl %ebx, %ebx
je 0xee19
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
leal -0x1(%rbx), %edx
movq (%r12), %rcx
cvtss2sd (%rcx,%rdx,4), %xmm2
movslq %r14d, %rdx
movq 0xae0(%r15), %rsi
imulq $0x18, %rdx, %rdx
movslq %ebp, %rdi
movq (%rsi,%rdx), %rdx
movsd (%rdx,%rdi,8), %xmm1
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
ja 0xee19
movl %ebx, %esi
xorl %edx, %edx
cmpq %rdx, %rsi
je 0xee19
cvtss2sd (%rcx,%rdx,4), %xmm2
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jae 0xee17
incq %rdx
jmp 0xedfe
movl %edx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/option.cpp
// Function: OptionParser::OptionParser(int, char**)
OptionParser::OptionParser(int argc, char ** argv){
	for (int i = 1; i < argc; i += 2){
		if (argv[i][0] == '-'){
			if (i + 1 <= argc){
				std::string tmp(argv[i]);
				paras.insert(std::make_pair(tmp, argv[i + 1]));
			}else{
				isValid = false;
				return;
			}
		} else {
			isValid = false;
			return;
		}
	}
	isValid = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
movq %rdx, %r14
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movslq %esi, %r13
addq $0x10, %r14
pushq $0x1
popq %rbp
movq %rsp, %r15
leaq 0x20(%rsp), %r12
cmpq %r13, %rbp
jge 0x10a20
movq -0x8(%r14), %rsi
cmpb $0x2d, (%rsi)
jne 0x10a24
movq %r15, %rdi
movq %r12, %rdx
callq 0x3130
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x11bbe
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11c92
movq %r12, %rdi
callq 0x3160
movq %r15, %rdi
callq 0x3160
addq $0x2, %rbp
addq $0x10, %r14
jmp 0x109d4
movb $0x1, %al
jmp 0x10a26
xorl %eax, %eax
movb %al, 0x30(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x3160
jmp 0x10a4a
movq %rax, %r14
movq %rsp, %rdi
callq 0x3160
jmp 0x10a57
movq %rax, %r14
movq %rbx, %rdi
callq 0x9006
movq %r14, %rdi
callq 0x3590
nop
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/option.cpp
// Function: OptionParser::getPara(char const*)
char * OptionParser::getPara(const char * str){
	std::string tmp(str);
	std::map<std::string, char *>::iterator it = paras.find(tmp);
	if (it == paras.end())
		return NULL;
	else
		return it->second;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x3130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11e80
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x10a9e
movq 0x40(%rax), %rbx
jmp 0x10aa0
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x3160
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3160
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH09_SequentialContainers/examples/find-str.cc
// Function: main
int main()
{
    string name("AnnaBelle");
    auto pos1 = name.find("Anna"); // pos1 == 0
    cout << pos1 ;
    string lowercase("annabelle");
    pos1 = lowercase.find("Anna");   // pos1 == npos
    cout << " " << pos1 << endl;
    cout << string::npos << endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
leaq 0xdf8(%rip), %rsi       # 0x2004
leaq -0x50(%rbp), %rbx
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x1030
leaq 0xdeb(%rip), %rsi       # 0x200e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10b0
movq 0x2da4(%rip), %rdi      # 0x3fd8
movq %rax, %rsi
callq 0x1060
leaq 0xdd0(%rip), %rsi       # 0x2013
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1030
leaq 0xdb7(%rip), %rsi       # 0x200e
leaq -0x30(%rbp), %rdi
xorl %edx, %edx
callq 0x10b0
movq %rax, %rbx
movq 0x2d6c(%rip), %rdi      # 0x3fd8
leaq 0xdaa(%rip), %rsi       # 0x201d
callq 0x1080
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1060
movq %rax, %rdi
callq 0x1050
movq 0x2d46(%rip), %rdi      # 0x3fd8
pushq $-0x1
popq %rsi
callq 0x1060
movq %rax, %rdi
callq 0x1050
leaq -0x30(%rbp), %rdi
callq 0x1040
leaq -0x50(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x12bf
movq %rax, %rbx
jmp 0x12d0
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1040
leaq -0x50(%rbp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/iibrahimli[P]adsa_project/src/../include/pixel.hpp
// Function: operator<<(std::ostream&, pixel3 const&)
std::ostream& operator << (std::ostream& out, const pixel3& p){
    out << "("
        << std::setw(3) << std::to_string(p.r) << ", "
        << std::setw(3) << std::to_string(p.g) << ", "
        << std::setw(3) << std::to_string(p.b) << ")";
    
    return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3fca(%rip), %rsi      # 0x6536
callq 0x21e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r15,%rax)
movzbl 0x2(%r14), %esi
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x4166
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
leaq 0x3a80(%rip), %rsi      # 0x6028
movq %rax, %rdi
callq 0x21e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r15,%rax)
movzbl 0x1(%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0x4166
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x21c0
leaq 0x3a42(%rip), %rsi      # 0x6028
movq %rax, %rdi
callq 0x21e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r15,%rax)
movzbl (%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x4166
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x21c0
leaq 0x3a08(%rip), %rsi      # 0x602b
movq %rax, %rdi
callq 0x21e0
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
callq 0x20e0
leaq 0x48(%rsp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x266b
jmp 0x267a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
jmp 0x266e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e0
jmp 0x267d
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/iibrahimli[P]adsa_project/src/../include/pixel.hpp
// Function: operator<<(std::ostream&, pixel4 const&)
std::ostream& operator << (std::ostream& out, const pixel4& p){
    out << "("
        << std::setw(3) << std::to_string(p.r) << ", "
        << std::setw(3) << std::to_string(p.g) << ", "
        << std::setw(3) << std::to_string(p.b) << ", "
        << std::setw(3) << std::to_string(p.a) << ")";

    return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3e8c(%rip), %rsi      # 0x6536
callq 0x21e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r15,%rax)
movzbl 0x2(%r14), %esi
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x4166
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
leaq 0x3942(%rip), %rsi      # 0x6028
movq %rax, %rdi
callq 0x21e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r15,%rax)
movzbl 0x1(%r14), %esi
leaq 0x48(%rsp), %rdi
callq 0x4166
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x21c0
leaq 0x3904(%rip), %rsi      # 0x6028
movq %rax, %rdi
callq 0x21e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r15,%rax)
movzbl (%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0x4166
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x21c0
leaq 0x38c7(%rip), %rsi      # 0x6028
movq %rax, %rdi
callq 0x21e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r15,%rax)
movzbl 0x3(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x4166
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x21c0
leaq 0x388c(%rip), %rsi      # 0x602b
movq %rax, %rdi
callq 0x21e0
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
callq 0x20e0
leaq 0x48(%rsp), %rdi
callq 0x20e0
leaq 0x68(%rsp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x27f6
jmp 0x2805
jmp 0x2814
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
jmp 0x27f9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e0
jmp 0x2808
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20e0
jmp 0x2817
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/iibrahimli[P]adsa_project/src/../include/util.hpp
// Function: print_help(char const*)
void print_help(const char* progname){
    std::cout << "Usage:" << std::endl;
    std::cout << progname << " <option> [ <extra1> <extra2> ... ]" << std::endl;
    std::cout << R"(
Options must be provided in the given order.
Options are mutually exclusive.
Possible options:

    --psf <img1> <img2> <psf_file>          :  calculate psfs for two images and store in <out>
                                               * img1 and img2 - images to calculate shift between
                                               * psf_file - output file with psf profile
    
    --scale <img> <psf_file> <out_img>      :  scale image according to its
                                               corresponding psf profile in psf_file and cuts
                                               a strip of given width from their center
    
    --merge <out_img> <img_1> ... <img_N>   :  merge images from left to right in given order
                                               and saves the result with name <out_img>
    
    --help                                  :  display this help text
    )" << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7791(%rip), %r14      # 0x9fc8
leaq 0x37ef(%rip), %rsi      # 0x602d
movq %r14, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21e0
leaq 0x37d4(%rip), %rsi      # 0x6034
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
leaq 0x37e1(%rip), %rsi      # 0x6058
movq %r14, %rdi
callq 0x21e0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/iibrahimli[P]adsa_project/src/../include/util.hpp
// Function: psf_resize(BMP_image, std::vector<float, std::allocator<float>>, unsigned int)
BMP_image psf_resize(const BMP_image img, std::vector<float> psf, unsigned int th){
    // max psf
    float max_psf = 0;
    for(auto& p : psf) if(p > max_psf) max_psf = p;

    unsigned int width = img.info_h.width;
    unsigned int height = img.info_h.height;
    int new_w = width * max_psf;
    
    BMP_image res(new_w, height);

    // resize each strip and write centered
    for(int i=0; i<psf.size(); ++i){
        x_enlarge_region(img, {0, i*th}, {width-1, std::min((i+1)*th, height)}, res, {(int) floor((new_w - floor(width*psf[i]))/2), i*th}, psf[i]);
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x38(%rsp)
movq %rdx, %r15
movq %rsi, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
xorps %xmm1, %xmm1
cmpq %rcx, %rax
je 0x34f5
movss (%rax), %xmm0
maxss %xmm1, %xmm0
addq $0x4, %rax
movaps %xmm0, %xmm1
jmp 0x34df
movq 0x18(%rsp), %rax
movl 0x12(%rax), %ebx
cvtsi2ss %rbx, %xmm0
movl 0x16(%rax), %ebp
movss %xmm0, 0x14(%rsp)
mulss %xmm0, %xmm1
movaps %xmm1, 0x20(%rsp)
cvttss2si %xmm1, %esi
pushq $-0x1
popq %rcx
pushq $0x1
popq %r8
movq 0x8(%rsp), %rdi
movl %ebp, %edx
callq 0x48b2
cvttps2dq 0x20(%rsp), %xmm0
cvtdq2pd %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
leal -0x1(%rbx), %eax
movq %rax, 0x30(%rsp)
xorl %r13d, %r13d
xorl %eax, %eax
movq (%r15), %rcx
movq 0x8(%r15), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x35e1
movq 0x38(%rsp), %rdx
leal (%rdx,%r13), %r12d
cmpl %r12d, %ebp
movl %r12d, %r14d
cmovbl %ebp, %r14d
leaq 0x1(%rax), %rbx
movss (%rcx,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp)
mulss 0x14(%rsp), %xmm0
callq 0x20a0
cvtss2sd %xmm0, %xmm1
movapd 0x40(%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd 0x2a7f(%rip), %xmm0     # 0x6020
callq 0x2330
cvttsd2si %xmm0, %r8d
shlq $0x20, %r13
shlq $0x20, %r14
addq 0x30(%rsp), %r14
orq %r13, %r8
movq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movq 0x8(%rsp), %rcx
movss 0x20(%rsp), %xmm0
callq 0x30de
movl %r12d, %r13d
movq %rbx, %rax
jmp 0x3547
movq 0x8(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x4a1a
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/iibrahimli[P]adsa_project/src/../include/util.hpp
// Function: cut_strip(BMP_image const&, unsigned int)
BMP_image cut_strip(const BMP_image& img, unsigned int strip_width){
    unsigned int width = img.info_h.width;
    unsigned int height = img.info_h.height;
    unsigned int strip_start = (unsigned int) floor((float) (width - strip_width)/2);

    BMP_image res(strip_width, height);

    for(int j=0; j<height; ++j){
        for(int i=0; i<strip_width; ++i){
            res(i, j) = img.ploc(i+strip_start, j);
        }
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl 0x12(%rsi), %eax
subl %edx, %eax
cvtsi2ss %rax, %xmm0
movq %rdi, %r15
movq %rsi, 0x10(%rsp)
movl 0x16(%rsi), %r12d
mulss 0x29d8(%rip), %xmm0     # 0x6010
callq 0x20a0
cvttss2si %xmm0, %r14
pushq $-0x1
popq %rcx
pushq $0x1
popq %r8
movq %r15, %rbx
movq %r15, %rdi
movl %ebp, %r15d
movl %ebp, %esi
movl %r12d, 0xc(%rsp)
movl %r12d, %edx
callq 0x48b2
xorl %r12d, %r12d
cmpl 0xc(%rsp), %r12d
je 0x36a4
xorl %r13d, %r13d
cmpl %r13d, %r15d
je 0x369f
leal (%r14,%r13), %esi
movq 0x10(%rsp), %rdi
movl %r12d, %edx
callq 0x42be
movq %rax, %rbp
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x4602
movl (%rbp), %ecx
movl %ecx, (%rax)
incl %r13d
jmp 0x366e
incl %r12d
jmp 0x3664
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4a1a
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x10
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2210
movq (%r12), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x3c1f
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x2, %rsi
movq %rsp, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2100
movl %r14d, %esi
movq %rsp, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2100
movq %rsp, %rdi
movl %ebp, %esi
callq 0x2360
movq %rax, %rdi
callq 0x2100
movq (%rbx), %r14
movq 0x8(%rbx), %r15
movq %rsp, %rbx
cmpq %r15, %r14
je 0x3bff
movss (%r14), %xmm0
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x2100
addq $0x4, %r14
jmp 0x3bdf
movq %rsp, %rdi
callq 0x22b0
movq %rsp, %rdi
callq 0x22c0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x63c2(%rip), %rdi      # 0x9fe8
leaq 0x28a4(%rip), %rsi      # 0x64d1
callq 0x21e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
leaq 0x2853(%rip), %rsi      # 0x6497
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
pushq $0x1
popq %rdi
callq 0x2230
jmp 0x3c5e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x22c0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rdx
movq %r13, %rdi
callq 0x23a0
movq (%r13), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x30(%rsp,%rax)
jne 0x3d3d
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2140
movslq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x47fe
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2370
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2140
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
cmpl 0x8(%rsp), %ebp
jge 0x3d1e
movq %r14, %rdi
movq %r15, %rsi
callq 0x23e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4a3a
incl %ebp
jmp 0x3cfe
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 0x62a4(%rip), %rdi      # 0x9fe8
leaq 0x27a0(%rip), %rsi      # 0x64eb
callq 0x21e0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21e0
leaq 0x2735(%rip), %rsi      # 0x6497
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
pushq $0x1
popq %rdi
callq 0x2230
movq %rax, %r14
jmp 0x3d8c
jmp 0x3d81
movq %rax, %r14
movq %rbx, %rdi
callq 0x5680
leaq 0x10(%rsp), %rdi
callq 0x2070
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/iibrahimli[P]adsa_project/src/../include/bmp.hpp
// Function: BMP_image::BMP_image(unsigned int, unsigned int, pixel4, bool)
BMP_image(unsigned int width, unsigned int height, pixel fill_color = WHITE, bool has_alpha = true){

        if (width <= 0 || height <= 0) {
            throw std::runtime_error("The image width and height must be positive numbers");
        }

        info_h.width = width;
        info_h.height = height;

        neg_height = true;

        // don't hold padding bytes
        data = new pixel[width * height];

        // fill pixels array
        for(int i=0; i<width*height; ++i) data[i] = fill_color;

        info_h.size = sizeof(BMP_info_header);
        file_h.pxl_offset = sizeof(BMP_file_header) + sizeof(BMP_info_header);

        if (has_alpha) {
            info_h.bit_count = 32;
            file_h.file_size = file_h.pxl_offset + width * height * info_h.bit_count/8;
        }
        else {
            info_h.bit_count = 24;
            padding = 4 - ((info_h.width * info_h.bit_count/8) % 4);
            file_h.file_size = file_h.pxl_offset + (width * info_h.bit_count/8 + padding) * height;
        }

    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movw $0x4d42, (%rdi)         # imm = 0x4D42
xorps %xmm0, %xmm0
andq $0x0, 0x12(%rdi)
movups %xmm0, 0x2(%rdi)
movw $0x1, 0x1a(%rdi)
movups %xmm0, 0x1c(%rdi)
movups %xmm0, 0x26(%rdi)
andq $0x0, 0x38(%rdi)
addq $0x40, %rdi
leaq 0x1c3c(%rip), %rsi      # 0x6538
leaq 0xf(%rsp), %rdx
movq %rdi, 0x10(%rsp)
callq 0x4f42
andl $0x0, 0x60(%r15)
movb $0x0, 0x64(%r15)
testl %ebp, %ebp
je 0x49c7
testl %ebx, %ebx
je 0x49c7
movl %ebp, 0x12(%r15)
movl %ebx, 0x16(%r15)
movb $0x1, 0x64(%r15)
movl %ebx, %r14d
imull %ebp, %r14d
leaq (,%r14,4), %rdi
callq 0x2030
leaq 0x2(%r15), %rcx
leaq 0x1c(%r15), %rsi
movq %rax, 0x38(%r15)
xorl %eax, %eax
cmpq %rax, %r14
je 0x4966
movq 0x38(%r15), %rdx
movl %r13d, (%rdx,%rax,4)
incq %rax
jmp 0x4954
movabsq $0x2800000036, %rax     # imm = 0x2800000036
movq %rax, 0xa(%r15)
testb %r12b, %r12b
je 0x498a
shll $0x2, %r14d
andl $0x1ffffffc, %r14d      # imm = 0x1FFFFFFC
movw $0x20, %ax
jmp 0x49ae
imull $0x3, 0x12(%r15), %eax
pushq $0x4
popq %rdi
cltd
idivl %edi
subl %edx, %edi
movl %edi, 0x60(%r15)
imull $0x18, %ebp, %r14d
shrl $0x3, %r14d
addl %edi, %r14d
imull %ebx, %r14d
movw $0x18, %ax
movw %ax, (%rsi)
addl $0x36, %r14d
movl %r14d, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x2110
movq %rax, %rbx
leaq 0x1b69(%rip), %rsi      # 0x6542
movq %rax, %rdi
callq 0x20b0
movq 0x5608(%rip), %rsi      # 0x9ff0
movq 0x55d1(%rip), %rdx      # 0x9fc0
movq %rbx, %rdi
callq 0x2350
movq %rax, %r15
movq %rbx, %rdi
callq 0x2170
jmp 0x4a07
movq %rax, %r15
movq 0x10(%rsp), %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r14
movq %rdi, %rbx
addq $0x40, %rdi
callq 0x23c0
movq %rsp, %r15
pushq $0x4
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2210
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x4c5c
movzwl 0x1c(%rbx), %eax
cmpl $0x18, %eax
je 0x4c34
cmpl $0x20, %eax
jne 0x4c93
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5226
movq %rsp, %rdi
callq 0x22b0
movq %rsp, %rdi
callq 0x22c0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq 0x5385(%rip), %rdi      # 0x9fe8
leaq 0x1867(%rip), %rsi      # 0x64d1
callq 0x21e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x1816(%rip), %rsi      # 0x6497
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
jmp 0x4cc9
movq 0x534e(%rip), %rdi      # 0x9fe8
leaq 0x1930(%rip), %rsi      # 0x65d1
callq 0x21e0
movzwl 0x1c(%rbx), %esi
movq %rax, %rdi
callq 0x2320
leaq 0x1372(%rip), %rsi      # 0x602b
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
pushq $0x1
popq %rdi
callq 0x2230
movq %rax, %rbx
movq %rsp, %rdi
callq 0x22c0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/iibrahimli[P]adsa_project/src/../include/pixel.hpp
// Function: pixel4::operator+=(pixel4 const&)
pixel4& operator+=(const pixel4& rhs){
        this->b = clamp((int) this->b + rhs.b);
        this->g = clamp((int) this->g + rhs.g);
        this->r = clamp((int) this->r + rhs.r);
        return *this;
    }

// Assembly:
movq %rdi, %rax
movzbl (%rdi), %ecx
movzbl (%rsi), %edx
addl %ecx, %edx
movl $0xff, %ecx
cmpl %ecx, %edx
cmovael %ecx, %edx
movb %dl, (%rdi)
movzbl 0x1(%rdi), %edx
movzbl 0x1(%rsi), %edi
addl %edx, %edi
cmpl %ecx, %edi
cmovael %ecx, %edi
movb %dil, 0x1(%rax)
movzbl 0x2(%rax), %edx
movzbl 0x2(%rsi), %esi
addl %edx, %esi
cmpl %ecx, %esi
cmovael %ecx, %esi
movb %sil, 0x2(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/iibrahimli[P]adsa_project/src/../include/pixel.hpp
// Function: pixel4::operator*=(float const&)
pixel4& operator*=(const float& scl){
        this->b = clamp((int) (this->b * scl));
        this->g = clamp((int) (this->g * scl));
        this->r = clamp((int) (this->r * scl));
        return *this;
    }

// Assembly:
movq %rdi, %rax
movzbl (%rdi), %ecx
cvtsi2ss %ecx, %xmm0
movss (%rsi), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %edx
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
movl $0xff, %esi
cmpl %esi, %edx
cmovgel %esi, %edx
movb %dl, (%rdi)
movzbl 0x1(%rdi), %edx
cvtsi2ss %edx, %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %edx
testl %edx, %edx
cmovlel %ecx, %edx
cmpl %esi, %edx
cmovgel %esi, %edx
movb %dl, 0x1(%rdi)
movzbl 0x2(%rdi), %edx
cvtsi2ss %edx, %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %edx
testl %edx, %edx
cmovgl %edx, %ecx
cmpl %esi, %ecx
cmovgel %esi, %ecx
movb %cl, 0x2(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x64(%rdi)
jne 0x523e
negl 0x16(%r14)
pushq $0xe
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2270
leaq 0xe(%r14), %rsi
pushq $0x28
popq %rdx
movq %rbx, %rdi
callq 0x2270
cmpb $0x1, 0x64(%r14)
jne 0x5266
negl 0x16(%r14)
xorl %ebp, %ebp
pushq $0x8
popq %r12
leaq 0xda1(%rip), %r15       # 0x6014
cmpl 0x16(%r14), %ebp
jge 0x52b5
movl 0x12(%r14), %ecx
movzwl 0x1c(%r14), %eax
imull %ecx, %eax
imull %ebp, %ecx
movslq %ecx, %rsi
shlq $0x2, %rsi
addq 0x38(%r14), %rsi
cltd
idivl %r12d
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x2270
movl 0x60(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2270
incl %ebp
jmp 0x5273
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/juli9797[P]ssf/src/filetype_icon.hpp
// Function: ssf::get_icon(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string get_icon(std::string file)
{
    std::ostringstream oss;
    auto index = file.find_last_of(".");
    if (index != std::string::npos)
    {
        auto filetype = to_lower(file.substr(index + 1));
	
	oss << colors.at(get_colorhash(filetype));
        auto icon_text = shortened_string(filetype, 3);
        while (icon_text.length() < 3)
        {
            icon_text.push_back(' ');
        }
        oss << to_upper(icon_text)
            << c_cmd::color::reset;
    }
    else
    {
        oss << c_cmd::color::foreground::bright_cyan
            << "---"
            << c_cmd::color::reset;
    }
    return oss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x32c0
leaq 0x57ff(%rip), %rsi      # 0x91b3
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x3200
cmpq $-0x1, %rax
je 0x3afa
incq %rax
leaq 0xc0(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
movq %rax, %rdx
callq 0x3240
leaq 0x80(%rsp), %r14
leaq 0xc0(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x390b
movq %r15, %rdi
callq 0x30f0
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x32d0
leaq 0x60(%rsp), %rdi
callq 0x3954
movslq %eax, %rsi
leaq 0xa8a2(%rip), %rdi      # 0xe2c8
callq 0x5042
leaq 0xe0(%rsp), %rdi
movq %rax, %rsi
callq 0x31e0
leaq 0x60(%rsp), %rdi
callq 0x30f0
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x32d0
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
pushq $0x3
popq %rdx
callq 0x389c
leaq 0x40(%rsp), %rdi
callq 0x30f0
movq %rsp, %r14
pushq $0x20
popq %rbp
cmpq $0x2, 0x8(%rsp)
ja 0x3a8b
movq %r14, %rdi
movl %ebp, %esi
callq 0x31c0
jmp 0x3a77
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x32d0
leaq 0xa0(%rsp), %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x38c2
leaq 0xe0(%rsp), %rdi
movq %r14, %rsi
callq 0x31e0
leaq 0x56f1(%rip), %rsi      # 0x91b5
movq %rax, %rdi
callq 0x3210
leaq 0xa0(%rsp), %rdi
callq 0x30f0
leaq 0x20(%rsp), %rdi
callq 0x30f0
movq %rsp, %rdi
callq 0x30f0
leaq 0x80(%rsp), %rdi
callq 0x30f0
jmp 0x3b2c
leaq 0x56a6(%rip), %rsi      # 0x91a7
leaq 0xe0(%rsp), %rdi
callq 0x3210
leaq 0x56a5(%rip), %rsi      # 0x91ba
movq %rax, %rdi
callq 0x3210
leaq 0x5691(%rip), %rsi      # 0x91b5
movq %rax, %rdi
callq 0x3210
leaq 0xe8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3370
leaq 0xe0(%rsp), %rdi
callq 0x3040
movq %rbx, %rax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b9a
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x3ba0
jmp 0x3b68
movq %rax, %rbx
jmp 0x3ba5
jmp 0x3b95
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x30f0
leaq 0x20(%rsp), %rdi
callq 0x30f0
jmp 0x3b9d
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
jmp 0x3ba0
movq %rax, %rbx
jmp 0x3bb2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30f0
leaq 0x80(%rsp), %rdi
callq 0x30f0
leaq 0xe0(%rsp), %rdi
callq 0x3040
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
callq 0x5064
leaq 0x78(%r15), %rsi
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x6116
leaq 0x50(%r14), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5fd6
leaq 0x60(%rsp), %rdi
callq 0x5070
leaq 0x90(%r15), %rsi
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x6116
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5fd6
leaq 0x48(%rsp), %rdi
callq 0x5070
leaq 0xa8(%r15), %rsi
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x6116
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5fd6
leaq 0x30(%rsp), %rdi
callq 0x5070
leaq 0x30(%r15), %rsi
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x6116
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5092
leaq 0x18(%rsp), %rdi
callq 0x5070
addq $0x48, %r15
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6116
movq %r14, %rdi
movq %rbx, %rsi
callq 0x50e6
movq %rsp, %rdi
callq 0x5070
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3d12
jmp 0x3d12
jmp 0x3d12
jmp 0x3d12
movq %rax, %r14
movq %rbx, %rdi
callq 0x5070
movq %r14, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x633a
cmpq %r12, %r15
je 0x50da
movq %r14, %rdi
xorl %esi, %esi
callq 0x639c
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6370
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x633a
cmpq %r12, %r15
je 0x512e
movq %r14, %rdi
xorl %esi, %esi
callq 0x639c
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6370
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3250
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)
movaps %xmm2, 0x20(%rdx)
movaps (%rdx), %xmm0
movaps 0x3ec9(%rip), %xmm1     # 0x9040
andps %xmm0, %xmm1
orps 0x3ecf(%rip), %xmm0     # 0x9050
shufps $0x32, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[3,0]
shufps $0x84, %xmm0, %xmm1     # xmm1 = xmm1[0,1],xmm0[0,2]
movaps %xmm1, (%rdx)
movw $0x101, 0x16(%rdx)      # imm = 0x101
pushq $0x2
popq %rsi
xorl %edi, %edi
callq 0x3290
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8c1f(%rip), %rdi      # 0xdfd0
callq 0x31e0
movq %rbx, %rdi
callq 0x7848
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rdi
callq 0x30c0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
callq 0x3390
jmp 0x53be
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %r14
leaq 0x7(%rsp), %r15
movb $0x0, (%r15)
xorl %eax, %eax
movq 0x8651(%rip), %r12      # 0xdfe0
cmpb %bl, %al
je 0x59cc
movq %r12, %rdi
callq 0x3260
movb %al, 0x7(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7a02
movq %rax, %rdi
callq 0x7848
movb 0x7(%rsp), %al
jmp 0x598f
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x59d8
callq 0x30c0
callq 0x3390
jmp 0x59b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x48(%rdi), %r15
pushq $0x30
popq %r12
leaq 0x38(%rsp), %r13
movsbl %r12b, %eax
cmpl %ebp, %eax
je 0x5ad5
movq 0x85cb(%rip), %rdi      # 0xdfe0
callq 0x3260
movl %eax, %r12d
cmpb $0x7f, %r12b
je 0x5a3a
movsbl %r12b, %eax
cmpl $0xd, %eax
je 0x5aa6
movsbl %r12b, %esi
movq %r14, %rdi
callq 0x31c0
jmp 0x5a49
cmpq $0x0, 0x10(%rbx)
je 0x5a49
movq %r14, %rdi
callq 0x3270
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7a52
movq %r15, %rdi
movq %r13, %rsi
callq 0x7a3e
movq %r13, %rdi
callq 0x30f0
jmp 0x5a02
movq %rdx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq %r13, %rdi
callq 0x30f0
jmp 0x5a87
movq %rdx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
cmpl $0x1, 0x10(%rsp)
jne 0x5b1f
movq 0x8(%rsp), %rdi
callq 0x30c0
callq 0x3390
jmp 0x5a02
movq 0x10(%rbx), %rcx
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x3240
addq $0x28, %rbx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7a3e
leaq 0x18(%rsp), %rdi
callq 0x30f0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x30f0
jmp 0x5b00
movq %rdx, %rbx
movq %rax, 0x8(%rsp)
cmpl $0x1, %ebx
jne 0x5b1f
movq 0x8(%rsp), %rdi
callq 0x30c0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
callq 0x3390
jmp 0x5ad5
movq 0x8(%rsp), %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::update()
void update(){
		//reset
		active_col.clear();
		left_col.clear();
		right_col.clear();
		//active Column
		active_col = get_directory_list(current_path);
		check_selection();
		//left Column
		if (current_path.has_relative_path())
		{
			left_col = get_directory_list(current_path.parent_path());
		}
		check_parent_selection();
		//right Column
		try
		{
			if (active_col.size() != 0 && !selection.empty())
			{
				auto selected = *selection.begin();
				if (selected.is_directory() && !std::filesystem::is_empty(selected))
				{
					right_col = get_directory_list(get_selected_path());
				}
			}
		}
		catch (std::filesystem::filesystem_error &e)
		{
		}		
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x90(%rdi), %r13
movq %r13, %rdi
callq 0x69e6
leaq 0x78(%rbx), %r15
movq %r15, %rdi
callq 0x69e6
leaq 0xa8(%rbx), %r14
movq %r14, %rdi
callq 0x69e6
leaq 0x8(%rbx), %r12
leaq 0xa0(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x6294
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x69ee
leaq 0x8(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x6f7c
movq %rbp, %rdi
callq 0x5070
leaq 0xa0(%rsp), %rdi
callq 0x62f4
movq %rbx, %rdi
callq 0x6b78
movq %r12, %rdi
callq 0x33a0
testb %al, %al
je 0x68b2
leaq 0x78(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x3420
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x69ee
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6f7c
movq %r12, %rdi
callq 0x5070
leaq 0x78(%rsp), %rdi
callq 0x62f4
movq %rbx, %rdi
callq 0x6c42
movq 0x98(%rbx), %rax
cmpq 0x90(%rbx), %rax
je 0x6945
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0x6945
leaq 0x8(%rsp), %rdi
callq 0x6276
leaq 0x8(%rsp), %rdi
callq 0x6d26
testb %al, %al
je 0x693b
leaq 0x8(%rsp), %rdi
callq 0x3410
testb %al, %al
jne 0x693b
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x6d34
leaq 0x60(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %rbx, %rsi
callq 0x69ee
leaq 0x60(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6f7c
movq %rbx, %rdi
callq 0x5070
leaq 0x38(%rsp), %rdi
callq 0x62f4
leaq 0x8(%rsp), %rdi
callq 0x62f4
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x62f4
jmp 0x6983
jmp 0x697d
movq %rdx, %r14
movq %rax, %rbx
jmp 0x698d
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
jmp 0x69ad
movq %rdx, %r14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62f4
cmpl $0x1, %r14d
jne 0x69b2
movq %rbx, %rdi
callq 0x30c0
callq 0x3390
jmp 0x6945
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x62f4
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xa8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x6d46
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x6dde
leaq 0x8(%rsp), %rax
leaq 0x48(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
movaps %xmm0, -0x8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rdi)
callq 0x6e12
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x6dde
leaq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rax)
leaq 0x58(%rsp), %rdi
callq 0x6e12
movq %rsp, %r13
leaq 0x80(%rsp), %rbp
leaq 0x60(%rsp), %r14
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x6aef
movq %r13, %rdi
callq 0x33f0
movq %rax, %r15
movq %rbp, %rdi
movq %rax, %rsi
callq 0x6d50
movq %r14, %rdi
movq %rbp, %rsi
callq 0x6dc2
movq %r14, %rdi
xorl %esi, %esi
callq 0x3450
movb (%rax), %r12b
movq %r14, %rdi
callq 0x30f0
movq %rbp, %rdi
callq 0x62f4
cmpb $0x2e, %r12b
jne 0x6ada
movq 0x28(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x6ae5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6370
movq %r13, %rdi
callq 0x3080
jmp 0x6a80
leaq 0x18(%rsp), %rdi
callq 0x6e12
leaq 0x8(%rsp), %rdi
callq 0x6e12
leaq 0x38(%rsp), %rdi
callq 0x6e12
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6b26
jmp 0x6b26
movq %rax, %r14
jmp 0x6b4a
movq %rax, %r14
jmp 0x6b3d
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x30f0
leaq 0x80(%rsp), %rdi
callq 0x62f4
leaq 0x18(%rsp), %rdi
callq 0x6e12
leaq 0x8(%rsp), %rdi
callq 0x6e12
movq %rbx, %rdi
callq 0x5070
leaq 0x38(%rsp), %rdi
callq 0x6e12
movq %r14, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
cmpq 0x38(%rdi), %rax
je 0x6be4
leaq 0x30(%rbx), %r15
leaq 0x90(%rbx), %r12
movq %r15, %rdi
xorl %esi, %esi
callq 0x639c
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x6276
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x6fce
movq %rax, %r12
movq 0x98(%rbx), %r14
leaq 0x38(%rsp), %rdi
callq 0x62f4
cmpq %r14, %r12
jne 0x6be4
movq %r15, %rdi
callq 0x69e6
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x6c20
movq 0x90(%rbx), %rsi
cmpq 0x98(%rbx), %rsi
je 0x6c20
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6276
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6fda
leaq 0x8(%rsp), %rdi
callq 0x62f4
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x6c2e
movq %rax, %rbx
movq %r14, %rdi
callq 0x62f4
movq %rbx, %rdi
callq 0x33d0
nop