LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::updateDeg()
void HyperGraph::updateDeg(){
	unsigned int num=edge_node.size();
	for (unsigned int i = curEdge; i < num; ++i){
		unsigned int num2 = edge_node[i].size();
		for (unsigned int j=0;j<num2;++j){
			node_edge[edge_node[i][j]].push_back(i);
		}
	}
	curEdge = edge_node.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
subq 0x18(%rdi), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movl 0x30(%rdi), %r15d
cmpl %eax, %r15d
jae 0xf099
movl %eax, %eax
movq %rax, 0x10(%rsp)
leaq 0xc(%rsp), %r14
movq 0x18(%rbx), %rcx
leaq (%r15,%r15,2), %r13
movq 0x8(%rcx,%r13,8), %rax
subq (%rcx,%r13,8), %rax
shrq $0x2, %rax
testl %eax, %eax
je 0xf07d
movl %eax, %ebp
xorl %r12d, %r12d
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movslq (%rcx,%r12,4), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movl %r15d, 0xc(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xf06d
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xf075
movq %r14, %rdx
callq 0xbb1e
incq %r12
cmpq %r12, %rbp
jne 0xf03a
incq %r15
cmpq 0x10(%rsp), %r15
jne 0xf01c
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::addEdge(std::vector<int, std::allocator<int>>&)
void HyperGraph::addEdge(vector<int> & edge)
{
	edge_node.push_back(edge);
	unsigned int ind = edge_node.size() - 1;
	for (unsigned int i = 0; i < edge.size(); ++i)
		node_edge[edge[i]].push_back(ind);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0x1291a
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0xf151
movq 0x20(%r14), %rcx
subq 0x18(%r14), %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ebp # imm = 0xAAAAAAAB
decl %ebp
movl $0x1, %r12d
xorl %ecx, %ecx
leaq 0xc(%rsp), %r15
movslq (%rax,%rcx,4), %rcx
movq (%r14), %rdx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdx,%rcx,8), %rdi
movl %ebp, 0xc(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xf130
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xf13b
movq %r15, %rdx
callq 0xbb1e
movq (%rbx), %rax
movl %r12d, %ecx
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0xf107
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::addEdgeD(std::vector<int, std::allocator<int>>&)
void HyperGraph::addEdgeD(vector<int> & edge)
{
    edge_node.push_back(edge);
    int ind = edge_node.size() - 1;
    for (unsigned int i = 0; i < edge.size(); ++i){
        node_edge[edge[i]].push_back(ind);
    	if (node_edge[edge[i]].size() > maxDegree)
    		maxDegree = node_edge[edge[i]].size();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0x1291a
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
decl %eax
movl %eax, 0xc(%rsp)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0xf215
movq (%r14), %rcx
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
movslq (%rax,%r12,4), %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (%rcx,%rdx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xf1d0
movl 0xc(%rsp), %edx
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xf1de
movq %r15, %rdx
callq 0xd306
movq (%rbx), %rax
movq (%r14), %rcx
movslq (%rax,%r12,4), %rdx
leaq (%rdx,%rdx,2), %rsi
movq 0x8(%rcx,%rsi,8), %rdx
subq (%rcx,%rsi,8), %rdx
sarq $0x2, %rdx
movl 0x34(%r14), %esi
cmpq %rsi, %rdx
jbe 0xf200
movl %edx, 0x34(%r14)
movl %ebp, %r12d
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
cmpq %r12, %rdx
ja 0xf1aa
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::clearEdges()
void HyperGraph::clearEdges()
{
    edge_node.clear();
    node_edge.clear();
    cout << "clear edges!" << endl;
    maxDegree = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x12946
movq %rbx, %rdi
callq 0x12946
movq 0xed37(%rip), %r14      # 0x1dfd0
leaq 0x8490(%rip), %rsi      # 0x17730
movl $0xc, %edx
movq %r14, %rdi
callq 0x33b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3240
movl $0x0, 0x34(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r13d
leaq (,%r13,8), %rdi
testl %esi, %esi
movq $-0x1, %r15
cmovsq %r15, %rdi
callq 0x3030
movq %rax, %rbx
testl %ebp, %ebp
jle 0x10fe9
movl %ebp, 0x14(%rsp)
movl 0x9c8(%r14), %ebp
leal 0x1(%rbp), %eax
movslq %eax, %r12
shlq $0x2, %r12
cmpl $-0x1, %ebp
cmovlq %r15, %r12
shlq $0x2, %rax
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
movq %r12, %rdi
callq 0x3030
movq %rax, (%rbx,%r15,8)
testl %ebp, %ebp
js 0x10f9e
movq %rax, %rdi
xorl %esi, %esi
movq 0x8(%rsp), %rdx
callq 0x31c0
incq %r15
cmpq %r15, %r13
jne 0x10f7f
movl 0x14(%rsp), %ebp
testl %ebp, %ebp
jle 0x10fe9
xorl %r15d, %r15d
cmpl $0x0, 0xa60(%r14)
je 0x10fcb
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x10660
jmp 0x10fe1
movq %r14, %rdi
callq 0x105e0
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x10a02
incl %r15d
cmpl %r15d, %ebp
jne 0x10fb1
movl 0x9c8(%r14), %eax
testl %eax, %eax
jle 0x11056
movq 0xae0(%r14), %rcx
incq %rax
xorpd %xmm3, %xmm3
movl $0x1, %edx
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
testl %ebp, %ebp
jle 0x11048
leaq (%rdx,%rdx,2), %rsi
leaq (%rcx,%rsi,8), %rsi
xorl %edi, %edi
movq (%rbx,%rdi,8), %r8
movss (%r8,%rdx,4), %xmm2
ucomiss %xmm0, %xmm2
jne 0x1102d
jnp 0x11040
movq (%rsi), %r8
movsd (%r8,%rdi,8), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x11040
movapd %xmm2, %xmm1
incq %rdi
cmpq %rdi, %r13
jne 0x1101c
addsd %xmm1, %xmm3
incq %rdx
cmpq %rax, %rdx
jne 0x1100a
jmp 0x1105a
xorpd %xmm3, %xmm3
movsd %xmm3, 0x8(%rsp)
testl %ebp, %ebp
jle 0x1107d
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x11075
callq 0x3410
incq %r14
cmpq %r14, %r13
jne 0x11067
movq %rbx, %rdi
callq 0x3410
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movb $0x1, %al
cmpl $0x2, %esi
jl 0x14665
movq %rdx, %r14
movl %esi, %ebp
leaq 0x30(%rsp), %r13
movl $0x1, %r15d
leaq 0x20(%rsp), %r12
movq (%r14,%r15,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x14663
movq %rsp, %rdi
movq %r12, %rdx
callq 0x3140
movq %r13, 0x20(%rsp)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0xb15c
movq 0x8(%r14,%r15,8), %rax
movq %rax, 0x40(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x15e0a
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x14643
callq 0x3340
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x14656
callq 0x3340
addq $0x2, %r15
cmpl %ebp, %r15d
jl 0x145f2
movb $0x1, %al
jmp 0x14665
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
jmp 0x146a6
movq %rax, %r14
jmp 0x14693
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x14693
callq 0x3340
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x146a6
callq 0x3340
movq %rbx, %rdi
callq 0xb100
movq %r14, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15fe8
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x146ec
movq 0x40(%rax), %rbx
jmp 0x146ee
xorl %ebx, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14701
callq 0x3340
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14722
callq 0x3340
movq %rbx, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4f9d(%rip), %rsi      # 0x7536
movl $0x1, %edx
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rbx,%rax)
movzbl 0x2(%r14), %ebp
cmpl $0x64, %ebp
movl $0x3, %eax
sbbl $0x0, %eax
cmpl $0xa, %ebp
movl $0x1, %r15d
cmovael %eax, %r15d
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x2d, %edx
callq 0x2260
movq (%r12), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x5df6
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2250
movq %rax, %r15
leaq 0x4a11(%rip), %rsi      # 0x7028
movl $0x2, %edx
movq %rax, %rdi
callq 0x2250
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r15,%rax)
movzbl 0x1(%r14), %ebp
cmpl $0x64, %ebp
movl $0x3, %eax
sbbl $0x0, %eax
cmpl $0xa, %ebp
movl $0x1, %r12d
cmovael %eax, %r12d
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
movl $0x2d, %edx
callq 0x2260
movq 0x28(%rsp), %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x5df6
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x2250
movq %rax, %r15
leaq 0x4991(%rip), %rsi      # 0x7028
movl $0x2, %edx
movq %rax, %rdi
callq 0x2250
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r15,%rax)
movzbl (%r14), %ebp
cmpl $0x64, %ebp
movl $0x3, %eax
sbbl $0x0, %eax
cmpl $0xa, %ebp
movl $0x1, %r14d
cmovael %eax, %r14d
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x2d, %edx
callq 0x2260
movq 0x8(%rsp), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x5df6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x2250
leaq 0x4917(%rip), %rsi      # 0x702b
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2738
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2220
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x274f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2220
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x276b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2220
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x279d
jmp 0x27b9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x27a0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2220
jmp 0x27a0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x27bc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2220
jmp 0x27bc
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x27d8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2220
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq 0x74b3(%rip), %rbx      # 0x9fc8
leaq 0x4511(%rip), %rsi      # 0x702d
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
testq %r14, %r14
je 0x2b71
movq %r14, %rdi
callq 0x20e0
movq 0x7464(%rip), %rdi      # 0x9fc8
movq %r14, %rsi
movq %rax, %rdx
callq 0x2250
jmp 0x2b88
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2350
leaq 0x44a5(%rip), %rsi      # 0x7034
movl $0x23, %edx
movq %rbx, %rdi
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
leaq 0x448e(%rip), %rsi      # 0x7058
movl $0x38e, %edx            # imm = 0x38E
movq %rbx, %rdi
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpq %rcx, %rax
je 0x3cb4
xorps %xmm0, %xmm0
movss (%rax), %xmm1
maxss %xmm0, %xmm1
addq $0x4, %rax
movaps %xmm1, %xmm0
cmpq %rcx, %rax
jne 0x3c9e
jmp 0x3cb7
xorps %xmm1, %xmm1
movq 0x18(%rsp), %rax
movl 0x12(%rax), %ebx
xorps %xmm0, %xmm0
cvtsi2ss %rbx, %xmm0
movl 0x16(%rax), %ebp
movss %xmm0, 0x14(%rsp)
mulss %xmm0, %xmm1
movaps %xmm1, 0x20(%rsp)
cvttss2si %xmm1, %esi
movq 0x8(%rsp), %rdi
movl %ebp, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %r8d
callq 0x5792
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 0x3dad
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 0x20c0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movapd 0x40(%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd 0x32b3(%rip), %xmm0     # 0x7020
callq 0x2340
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 0x377e
movl %r12d, %r13d
movq %rbx, %rax
jmp 0x3d10
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 0x593c
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rsi, 0x10(%rsp)
movl 0x16(%rsi), %r12d
mulss 0x320c(%rip), %xmm0     # 0x7010
callq 0x20c0
movss %xmm0, 0x8(%rsp)
movq %r14, %rbx
movq %r14, %rdi
movl %ebp, %r15d
movl %ebp, %esi
movl %r12d, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %r8d
callq 0x5792
movl %r12d, 0xc(%rsp)
testl %r12d, %r12d
je 0x3e82
cvttss2si 0x8(%rsp), %r14
xorl %r12d, %r12d
testl %r15d, %r15d
je 0x3e78
xorl %r13d, %r13d
leal (%r14,%r13), %esi
movq 0x10(%rsp), %rdi
movl %r12d, %edx
callq 0x4f24
movq %rax, %rbp
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x53ea
movl (%rbp), %ecx
movl %ecx, (%rax)
incl %r13d
cmpl %r13d, %r15d
jne 0x3e49
incl %r12d
cmpl 0xc(%rsp), %r12d
jne 0x3e41
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 0x593c
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x56f6
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 0x660e
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_O3/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 0x5c2c
movzwl 0x1c(%rbx), %eax
cmpl $0x18, %eax
je 0x5bd4
cmpl $0x20, %eax
jne 0x5c74
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6290
leaq 0x8(%rsp), %rdi
callq 0x22d0
movq 0x43c6(%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 0x43b5(%rip), %rdi      # 0x9fe8
leaq 0x1897(%rip), %rsi      # 0x74d1
movl $0x19, %edx
callq 0x2250
movq 0x439d(%rip), %rdi      # 0x9fe8
movq %r14, %rsi
callq 0x2200
movq %rax, %rbx
leaq 0x183a(%rip), %rsi      # 0x7497
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x2100
jmp 0x5cbb
movq 0x436d(%rip), %rdi      # 0x9fe8
leaq 0x194f(%rip), %rsi      # 0x75d1
movl $0x37, %edx
callq 0x2250
movzwl 0x1c(%rbx), %esi
movq 0x4351(%rip), %rdi      # 0x9fe8
callq 0x2160
movq %rax, %rbx
leaq 0x1385(%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_O3/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 0x62a7
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
movl 0x16(%r14), %eax
cmpb $0x1, 0x64(%r14)
jne 0x62d9
negl %eax
movl %eax, 0x16(%r14)
testl %eax, %eax
jle 0x632d
xorl %ebp, %ebp
leaq 0xd2e(%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 0x62e6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x39ec
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rsi), %rdi
leaq 0x10(%rsi), %rcx
cmpq %rcx, %rdi
je 0x39fb
movq %rdi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x3a01
movq %rdx, %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3220
jmp 0x3a14
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_O3/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 0x6f64
leaq 0x78(%r15), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x7378
movq %r12, %rdi
movq %r14, %rsi
callq 0x71c4
leaq 0x60(%rsp), %rdi
callq 0x5e12
leaq 0x90(%r15), %rsi
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x7378
movq %r12, %rdi
movq %r14, %rsi
callq 0x71c4
leaq 0x48(%rsp), %rdi
callq 0x5e12
leaq 0xa8(%r15), %rsi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x7378
movq %r12, %rdi
movq %r14, %rsi
callq 0x71c4
leaq 0x30(%rsp), %rdi
callq 0x5e12
leaq 0x30(%r15), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x7378
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e5a
leaq 0x18(%rsp), %rdi
callq 0x5e12
addq $0x48, %r15
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x7378
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ebc
movq %rsp, %rdi
callq 0x5e12
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x417a
jmp 0x417a
jmp 0x417a
jmp 0x417a
movq %rax, %rbx
movq %r14, %rdi
callq 0x5e12
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7556
cmpq %r12, %r15
je 0x5e9e
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x5eaa
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x75d4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x434f(%rip), %rdi      # 0xa200
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7556
cmpq %r12, %r15
je 0x5f00
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x5f0c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x75d4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x42ed(%rip), %rdi      # 0xa200
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/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)
movaps %xmm2, 0x20(%rdx)
movaps (%rdx), %xmm0
movaps 0x40d5(%rip), %xmm1     # 0xa030
andps %xmm0, %xmm1
orps 0x40db(%rip), %xmm0     # 0xa040
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
xorl %edi, %edi
movl $0x2, %esi
callq 0x3280
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8e30(%rip), %rdi      # 0xefd0
movq %rax, %rsi
callq 0x3240
cmpq $0x0, 0x10(%rbx)
je 0x61ba
movq %rbx, %rdi
callq *0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x30b0
movq %rax, %rdi
movl %edx, %esi
callq 0x34a1
jmp 0x61b5
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movb $0x0, 0xf(%rsp)
testb %bl, %bl
je 0x6b9c
movq %rdi, %r14
movq 0x84aa(%rip), %r15      # 0xefe0
leaq 0xf(%rsp), %r12
leaq 0x37c1(%rip), %r13      # 0xa303
movq %r15, %rdi
callq 0x3250
movb %al, 0xf(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x8c8a
testq %rax, %rax
je 0x6b77
cmpq $0x0, 0x20(%rax)
je 0x6b81
movq %rax, %rdi
addq $0x10, %rdi
callq *0x28(%rax)
cmpb %bl, 0xf(%rsp)
jne 0x6b42
jmp 0x6b9c
movq %r13, %rdi
callq 0x32d0
jmp 0x6baa
callq 0x30b0
jmp 0x6baa
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x6baa
callq 0x30d0
callq 0x3370
jmp 0x6b6f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6bd5
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 0x83f4(%rip), %rdi      # 0xefe0
callq 0x3250
movsbl %al, %r12d
cmpb $0x7f, %r12b
je 0x6c12
cmpl $0xd, %r12d
je 0x6cba
movsbl %al, %esi
movq %r14, %rdi
callq 0x31c0
jmp 0x6c21
cmpq $0x0, 0x10(%rbx)
je 0x6c21
movq %r14, %rdi
callq 0x3260
movq %r13, %rdi
movq %rbx, %rsi
callq 0x8ce8
cmpq $0x0, 0x58(%rbx)
je 0x6c62
movq %r15, %rdi
movq %r13, %rsi
callq *0x60(%rbx)
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x6c58
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3200
cmpl %ebp, %r12d
jne 0x6be5
jmp 0x6bc6
callq 0x30b0
jmp 0x6d0c
movq %rdx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x6c9e
movq %rdx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x6c9e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3200
cmpl $0x1, 0x10(%rsp)
jne 0x6d5b
movq 0x8(%rsp), %rdi
callq 0x30d0
callq 0x3370
jmp 0x6c58
movq 0x10(%rbx), %rcx
leaq 0x38(%rsp), %rdi
movl $0x1, %edx
movq %r14, %rsi
callq 0x3220
cmpq $0x0, 0x38(%rbx)
je 0x6d07
leaq 0x28(%rbx), %rdi
leaq 0x38(%rsp), %rsi
callq *0x40(%rbx)
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bc6
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0x6bc6
callq 0x30b0
movq %rdx, %rbx
movq %rax, 0x8(%rsp)
jmp 0x6d39
movq %rdx, %rbx
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d39
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3200
cmpl $0x1, %ebx
jne 0x6d5b
movq 0x8(%rsp), %rdi
callq 0x30d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
callq 0x3370
jmp 0x6bc6
movq 0x8(%rsp), %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x10(%rsp)
movq $0x0, 0x10(%rbx)
movq (%r15), %rcx
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x7d2d
movq 0x72ae(%rip), %rax      # 0xefc8
cmpb $0x0, (%rax)
je 0x7d3c
incl 0x8(%rdi)
movq %rcx, (%rsp)
movq %rdi, 0x8(%rsp)
jmp 0x7d56
movq %rcx, (%rsp)
movq $0x0, 0x8(%rsp)
jmp 0x7d69
lock
incl 0x8(%rdi)
movq %rcx, (%rsp)
movq %rdi, 0x8(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, %rdi
testq %rcx, %rcx
je 0x7d69
cmpb $0x0, (%rax)
je 0x7d60
incl 0x8(%rdi)
jmp 0x7d64
lock
incl 0x8(%rdi)
callq 0x8176
leaq 0x30(%rsp), %r14
movq %rsp, %r15
leaq 0x50(%rsp), %r12
leaq 0x20(%rsp), %r13
cmpq $0x0, 0x8(%rsp)
je 0x7e66
movq %r15, %rdi
callq 0x33d0
movq %rax, %rbp
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x7df2
movq 0x20(%rbp), %rax
movl %eax, %edx
notb %dl
movq %rbp, %rsi
testb $0x3, %dl
je 0x7de8
movl %eax, %edx
andl $0x3, %edx
jne 0x7df2
movq (%rbp), %rdx
cmpb $0x2f, -0x1(%rdx,%rcx)
je 0x7df2
movq %rbp, %rsi
testb $0x3, %al
jne 0x7de2
leaq 0x20(%rbp), %rdi
callq 0x3150
movq %rax, %rsi
movq 0x20(%rbp), %rax
addq $-0x30, %rsi
testb $0x3, %al
cmovneq %rbp, %rsi
movq 0x20(%rsi), %rax
notl %eax
testb $0x3, %al
jne 0x7df2
movq %r12, %rdi
callq 0x74c8
jmp 0x7dfa
movq %r12, %rdi
callq 0x77ae
movq 0x50(%rsp), %rsi
movq %r14, 0x20(%rsp)
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x81e6
cmpq $0x0, 0x28(%rsp)
je 0x7e89
movq 0x20(%rsp), %rdi
movb (%rdi), %bl
cmpq %r14, %rdi
je 0x7e35
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
movq %r12, %rdi
callq 0x751e
cmpb $0x2e, %bl
jne 0x7e4c
movq 0x18(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x7e59
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x75d4
movq %r15, %rdi
callq 0x3090
jmp 0x7d7b
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x7e75
callq 0x8176
movq 0x10(%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23e4(%rip), %rdi      # 0xa274
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3310
jmp 0x7e9f
jmp 0x7e9f
movq %rax, %r15
jmp 0x7ecd
movq %rax, %r15
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x7ec3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0x7ec3
movq %rax, %r15
leaq 0x50(%rsp), %rdi
callq 0x751e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7edc
callq 0x8176
movq 0x10(%rsp), %rdi
callq 0x5e12
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x7ef5
callq 0x8176
movq %r15, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %r15
cmpq 0x38(%rdi), %r15
je 0x7f90
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x74c8
movb 0x28(%r15), %al
movb %al, 0x28(%r14)
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
movq %r14, %rdx
callq 0x82cf
movq %rax, %r15
movq 0x98(%rbx), %r14
leaq 0x30(%rsp), %rdi
callq 0x751e
movq 0x30(%rbx), %r12
movq 0x38(%rbx), %r13
cmpq %r14, %r15
jne 0x7f8b
cmpq %r12, %r13
je 0x7f90
movq %r12, %r14
movq %r14, %rdi
callq 0x751e
addq $0x30, %r14
cmpq %r13, %r14
jne 0x7f6f
movq %r12, 0x38(%rbx)
movq %r12, %r13
movq 0x30(%rbx), %r12
cmpq %r13, %r12
jne 0x7fc9
movq 0x90(%rbx), %r15
cmpq 0x98(%rbx), %r15
je 0x7fc9
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x74c8
movb 0x28(%r15), %al
movb %al, 0x28(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x827c
movq %rsp, %rdi
callq 0x751e
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7fd9
movq %rax, %rbx
movq %r14, %rdi
callq 0x751e
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x807b
leaq 0x78(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x7378
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x80a9
movq 0x28(%rbx), %rcx
movl %ecx, %edx
notb %dl
testb $0x3, %dl
je 0x806c
movl %ecx, %edx
andl $0x3, %edx
jne 0x80a9
movq (%r14), %rdx
cmpb $0x2f, -0x1(%rdx,%rax)
je 0x80a9
testb $0x3, %cl
jne 0x8062
leaq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x3150
movq (%r15), %rcx
addq $-0x30, %rax
testb $0x3, %cl
cmoveq %rax, %r14
movl 0x20(%r14), %eax
notl %eax
testb $0x3, %al
jne 0x80a9
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x74c8
jmp 0x80b3
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r15, %r12
je 0x8137
movq %r15, %r14
movq %r14, %rdi
callq 0x751e
addq $0x30, %r14
cmpq %r12, %r14
jne 0x808f
movq %r15, 0x50(%rbx)
jmp 0x8137
leaq 0x20(%rsp), %rdi
callq 0x77ae
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x85cb
movq %rax, %r14
cmpq 0x10(%rsp), %rax
je 0x80fe
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x74c8
movb 0x28(%r14), %al
leaq 0x48(%rsp), %rsi
movb %al, 0x28(%rsi)
movq %rbx, %rdi
callq 0x8578
leaq 0x48(%rsp), %rdi
callq 0x751e
jmp 0x8123
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r15, %r12
je 0x8123
movq %r15, %r14
movq %r14, %rdi
callq 0x751e
addq $0x30, %r14
cmpq %r12, %r14
jne 0x810e
movq %r15, 0x50(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x751e
leaq 0x8(%rsp), %rdi
callq 0x5e12
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x8164
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x751e
jmp 0x815a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x751e
leaq 0x8(%rsp), %rdi
callq 0x5e12
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x38ec
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x3240
movq %rax, %r15
leaq 0x15e0(%rip), %rsi      # 0xa311
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 0x8d69
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x3350
movq 0x6243(%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 0x8da6
movq %rax, %rbx
jmp 0x8dc9
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8dc9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
movq 0x61f0(%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_O3/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 0x969c
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x74c8
movb 0x28(%r14), %al
movb %al, 0x28(%r15)
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x74c8
movb 0x88(%rsp), %al
leaq 0x30(%rsp), %rdx
movb %al, 0x28(%rdx)
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
callq 0x82cf
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x751e
leaq 0x30(%r14), %rsi
cmpq 0x98(%rbx), %rsi
je 0x9692
movq %rsp, %rdi
callq 0x74c8
movb 0x58(%r14), %al
movq %rsp, %rsi
movb %al, 0x28(%rsi)
movq %rbx, %rdi
callq 0x827c
movq %rsp, %rdi
callq 0x751e
leaq 0x60(%rsp), %rdi
callq 0x751e
movq %rbx, %rdi
callq 0x79be
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x96c1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x751e
jmp 0x96cb
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x751e
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9765
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x74c8
movb 0x28(%r15), %al
movb %al, 0x28(%r14)
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
movq %r14, %rdx
callq 0x82cf
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0x751e
cmpq 0x90(%rbx), %r15
je 0x9765
movq %r15, %rsi
addq $-0x30, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x74c8
movb -0x8(%r15), %al
movb %al, 0x28(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x827c
movq %rsp, %rdi
callq 0x751e
movq %rbx, %rdi
callq 0x79be
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x9779
movq %rax, %rbx
movq %r14, %rdi
callq 0x751e
movq %rbx, %rdi
callq 0x33b0