LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::get_inv_AP_IC(int, int, int, int)
float Graph::get_inv_AP_IC(int u, int v, int idx, int p){
    float prob = weights[u][idx]; // (u) ---probabilities[u][idx]---> (v) (idx of (v) in adjacency list of (u))
    if (sim)
        prob *= similarities[u][p]; // similarity of the node (u) for the product p
    return prob;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0xaa0, %rdi            # imm = 0xAA0
movslq 0x1c(%rsp), %rsi
callq 0x24890
movq %rax, %rdi
movslq 0x14(%rsp), %rsi
callq 0xf1a0
movq %rax, %rcx
movq (%rsp), %rax
movss (%rcx), %xmm0
movss %xmm0, 0xc(%rsp)
testb $0x1, 0xb20(%rax)
je 0x1eb59
movq (%rsp), %rdi
addq $0xae0, %rdi            # imm = 0xAE0
movslq 0x1c(%rsp), %rsi
callq 0xf180
movq %rax, %rdi
movslq 0x10(%rsp), %rsi
callq 0xeb00
movsd (%rax), %xmm1
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::get_AP_LT(float, int, int)
float Graph::get_AP_LT(float active_prob, int u, int p){
    if (sim)
        return active_prob * similarities[u][p];
    else
        return active_prob;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movss %xmm0, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0xb20(%rax)
je 0x1ebe3
movq 0x10(%rsp), %rdi
movss 0x24(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0xae0, %rdi            # imm = 0xAE0
movslq 0x20(%rsp), %rsi
callq 0xf180
movq %rax, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xeb00
movsd 0x8(%rsp), %xmm0
mulsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0x1ebef
movss 0x24(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
movss 0x34(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::find_max_dist(int, Locations*, Locations*, Utilities)
double Graph::find_max_dist(int P,  Locations* usersLocations, Locations* eventsLocations, Utilities util){
    double max_dist = 0;
    double dist;
    for (int p = 0; p < P; ++p){
        for (int v = 1; v <= getSize(); ++v){
            dist = util.computeMinimumDistance(usersLocations->locations[v][0], usersLocations->locations[v][1], eventsLocations->locations[p][0], eventsLocations->locations[p][1], 'K');
            if (dist > max_dist){
                max_dist = dist;
            }
        }
    }
    return max_dist;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x1ef51
movl $0x1, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x1db70
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jg 0x1ef3f
movq 0x38(%rsp), %rax
movq (%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movq 0x38(%rsp), %rax
movq (%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x8(%rax), %xmm1
movq 0x30(%rsp), %rax
movq (%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm2
movq 0x30(%rsp), %rax
movq (%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x8(%rax), %xmm3
leaq 0x57(%rsp), %rdi
movl $0x4b, %esi
callq 0x1a690
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
ucomisd 0x28(%rsp), %xmm0
jbe 0x1ef2d
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0x1ef2f
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1ee88
jmp 0x1ef41
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1ee72
movsd 0x28(%rsp), %xmm0
addq $0x58, %rsp
retq
nopl (%rax)
// File: dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::HyperGraph(unsigned int)
HyperGraph::HyperGraph(unsigned int n)
{
	sfmt_init_gen_rand(&sfmtSeed, rand());
	node_edge = vector<vector<int> >(n+1);
	maxDegree = 0;
	numNodes = n;
	curEdge=0;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x24460
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x20(%rsp)
callq 0x24460
movq 0x28(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x30(%rsp)
callq 0x4110
movq 0x30(%rsp), %rdi
movl %eax, %esi
callq 0x30a60
jmp 0x1f5a8
movl 0x6c(%rsp), %eax
incl %eax
movq %rax, 0x8(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x24b90
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x24ba0
jmp 0x1f5d8
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x24c20
leaq 0x40(%rsp), %rdi
callq 0x10200
leaq 0x3f(%rsp), %rdi
callq 0x10420
movq 0x18(%rsp), %rax
movl $0x0, 0x34(%rax)
movl 0x6c(%rsp), %ecx
movl %ecx, 0x38(%rax)
movl $0x0, 0x30(%rax)
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1f642
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x10420
movq 0x20(%rsp), %rdi
callq 0x10200
movq 0x28(%rsp), %rdi
callq 0x10200
movq 0x60(%rsp), %rdi
callq 0x4690
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
callq 0x24c60
movq %rax, %rcx
movq (%rsp), %rax
movl %ecx, 0x1c(%rsp)
movl 0x30(%rax), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1f72d
movq (%rsp), %rdi
addq $0x18, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x24850
movq %rax, %rdi
callq 0xe3d0
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x1f71b
movq (%rsp), %rdi
addq $0x18, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x24850
movq %rax, %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0xe3b0
movq (%rsp), %rdi
movslq (%rax), %rsi
callq 0x24850
movq %rax, %rdi
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0xc(%rsp), %rsi
callq 0xeb20
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1f6c2
jmp 0x1f71d
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1f68d
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x24c60
movq %rax, %rcx
movq (%rsp), %rax
movl %ecx, 0x30(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x18, %rdi
movq 0x28(%rsp), %rsi
callq 0x24c80
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x24c60
subq $0x1, %rax
movl %eax, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe3d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1f823
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0xe3b0
movq 0x10(%rsp), %rdi
movslq (%rax), %rsi
callq 0x24850
movq %rax, %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x1c(%rsp)
leaq 0x1c(%rsp), %rsi
callq 0xeb20
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1f7c4
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
callq 0x24c80
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x24c60
subq $0x1, %rax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0xe3d0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x1f934
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0xe3b0
movq 0x8(%rsp), %rdi
movslq (%rax), %rsi
callq 0x24850
movq %rax, %rdi
leaq 0x14(%rsp), %rsi
callq 0x1b1e0
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0xe3b0
movq 0x8(%rsp), %rdi
movslq (%rax), %rsi
callq 0x24850
movq %rax, %rdi
callq 0xe3d0
movq 0x8(%rsp), %rcx
movl 0x34(%rcx), %ecx
cmpq %rcx, %rax
jbe 0x1f922
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0xe3b0
movq 0x8(%rsp), %rdi
movslq (%rax), %rsi
callq 0x24850
movq %rax, %rdi
callq 0xe3d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl %ecx, 0x34(%rax)
jmp 0x1f924
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1f874
addq $0x28, %rsp
retq
nopl (%rax)
// File: dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::clearEdges()
void HyperGraph::clearEdges()
{
    edge_node.clear();
    node_edge.clear();
    cout << "clear edges!" << endl;
    maxDegree = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0x24cf0
movq 0x8(%rsp), %rdi
callq 0x24cf0
movq 0x21563(%rip), %rdi     # 0x40fc0
leaq 0x12bec(%rip), %rsi     # 0x32650
callq 0x43f0
movq %rax, %rdi
movq 0x2153d(%rip), %rsi     # 0x40fb0
callq 0x4430
movq 0x8(%rsp), %rax
movl $0x0, 0x34(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movl %r8d, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
movq 0x48(%rsp), %rdi
addq $0x40, %rdi
callq 0x20880
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x28(%rsp)
cmpl $0x0, 0x34(%rsp)
jbe 0x24edc
movss 0x28(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x25080
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %rdi
addq $0xae0, %rdi            # imm = 0xAE0
movslq 0x30(%rsp), %rsi
callq 0xf180
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xeb00
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
mulsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x24ee9
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x24f88
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0x24f80
movss 0x28(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x25080
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x40(%rsp), %rdi
addq $0xae0, %rdi            # imm = 0xAE0
movslq 0x30(%rsp), %rsi
callq 0xf180
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xeb00
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x24f6e
movl 0x24(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x24f88
jmp 0x24f70
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x24ef1
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x2f450
movl $0x1, 0xac(%rsp)
movl 0xac(%rsp), %eax
cmpl 0xbc(%rsp), %eax
jge 0x2d3a3
movq 0xb0(%rsp), %rax
movslq 0xac(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x2d380
movl 0xac(%rsp), %eax
addl $0x1, %eax
cmpl 0xbc(%rsp), %eax
jg 0x2d373
movq 0xb0(%rsp), %rax
movslq 0xac(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x46a0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x88(%rsp), %rdi
callq 0x4500
jmp 0x2d29a
leaq 0x87(%rsp), %rdi
callq 0x4440
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xb0(%rsp), %rax
movslq 0xac(%rsp), %rcx
leaq 0x8(%rax,%rcx,8), %rdx
leaq 0x48(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x2f4b0
jmp 0x2d2da
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2f460
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x2d2f4
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movb %al, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2f4f0
leaq 0x88(%rsp), %rdi
callq 0x4260
jmp 0x2d37e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x4440
jmp 0x2d3b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x2d364
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2f4f0
leaq 0x88(%rsp), %rdi
callq 0x4260
jmp 0x2d3b4
movq 0x30(%rsp), %rax
movb $0x0, 0x30(%rax)
jmp 0x2d3ac
jmp 0x2d38b
movq 0x30(%rsp), %rax
movb $0x0, 0x30(%rax)
jmp 0x2d3ac
jmp 0x2d38d
movl 0xac(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xac(%rsp)
jmp 0x2d20b
movq 0x30(%rsp), %rax
movb $0x1, 0x30(%rax)
addq $0xc8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x11440
movq 0x78(%rsp), %rdi
callq 0x4690
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x46a0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x4500
jmp 0x2d41a
leaq 0x4f(%rsp), %rdi
callq 0x4440
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2f500
movq %rax, (%rsp)
jmp 0x2d439
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x2f550
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2f530
testb $0x1, %al
jne 0x2d466
jmp 0x2d4b0
movq $0x0, 0x80(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0x2d4ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x4440
jmp 0x2d4e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4260
jmp 0x2d4e8
leaq 0x30(%rsp), %rdi
callq 0x2f580
movq 0x20(%rax), %rax
movq %rax, 0x80(%rsp)
movl $0x1, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4260
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x4690
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x10c0
movq -0x78(%rbp), %rdx
leaq 0xdba(%rip), %rsi       # 0x2004
leaq -0x28(%rbp), %rdi
callq 0x1090
jmp 0x1255
leaq -0x29(%rbp), %rdi
callq 0x1080
leaq 0xda9(%rip), %rsi       # 0x200e
xorl %eax, %eax
movl %eax, %edx
leaq -0x28(%rbp), %rdi
callq 0x10d0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq 0x2d57(%rip), %rdi      # 0x3fd8
callq 0x1030
jmp 0x1288
leaq -0x69(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x10c0
movq -0x80(%rbp), %rdx
leaq 0xd73(%rip), %rsi       # 0x2013
leaq -0x68(%rbp), %rdi
callq 0x1090
jmp 0x12ab
leaq -0x69(%rbp), %rdi
callq 0x1080
leaq 0xd53(%rip), %rsi       # 0x200e
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
callq 0x10d0
movq %rax, -0x48(%rbp)
movq 0x2d05(%rip), %rdi      # 0x3fd8
leaq 0xd43(%rip), %rsi       # 0x201d
callq 0x1060
movq %rax, -0x88(%rbp)
jmp 0x12e8
movq -0x88(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x1030
movq %rax, -0x90(%rbp)
jmp 0x1301
movq -0x90(%rbp), %rdi
movq 0x2cb9(%rip), %rsi      # 0x3fc8
callq 0x1070
jmp 0x1316
movq 0x2cbb(%rip), %rdi      # 0x3fd8
movq $-0x1, %rsi
callq 0x1030
movq %rax, -0x98(%rbp)
jmp 0x1332
movq -0x98(%rbp), %rdi
movq 0x2c88(%rip), %rsi      # 0x3fc8
callq 0x1070
jmp 0x1347
movl $0x0, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1040
leaq -0x28(%rbp), %rdi
callq 0x1040
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x1080
jmp 0x13c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x13bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x1080
jmp 0x13bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1040
leaq -0x28(%rbp), %rdi
callq 0x1040
movq -0x38(%rbp), %rdi
callq 0x10b0
// File: 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:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
leaq 0xae80(%rip), %rsi      # 0xe536
callq 0x3250
movq %rax, 0x48(%rsp)
movl $0x3, %edi
callq 0x6e10
movq 0x48(%rsp), %rdi
movl %eax, 0xe4(%rsp)
movl 0xe4(%rsp), %esi
callq 0x32e0
movq %rax, 0x50(%rsp)
movq 0xe8(%rsp), %rax
movzbl 0x2(%rax), %esi
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x6e30
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x3230
movq %rax, 0x60(%rsp)
jmp 0x371b
movq 0x60(%rsp), %rdi
leaq 0xa901(%rip), %rsi      # 0xe028
callq 0x3250
movq %rax, 0x40(%rsp)
jmp 0x3733
movl $0x3, %edi
callq 0x6e10
movl %eax, 0x3c(%rsp)
jmp 0x3743
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0xb0(%rsp)
movl 0xb0(%rsp), %esi
callq 0x32e0
movq %rax, 0x30(%rsp)
jmp 0x3766
movq 0xe8(%rsp), %rax
movzbl 0x1(%rax), %esi
leaq 0x90(%rsp), %rdi
callq 0x6e30
jmp 0x3781
movq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x3230
movq %rax, 0x28(%rsp)
jmp 0x379a
movq 0x28(%rsp), %rdi
leaq 0xa882(%rip), %rsi      # 0xe028
callq 0x3250
movq %rax, 0x20(%rsp)
jmp 0x37b2
movl $0x3, %edi
callq 0x6e10
movl %eax, 0x1c(%rsp)
jmp 0x37c2
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x8c(%rsp)
movl 0x8c(%rsp), %esi
callq 0x32e0
movq %rax, 0x10(%rsp)
jmp 0x37e5
movq 0xe8(%rsp), %rax
movzbl (%rax), %esi
leaq 0x68(%rsp), %rdi
callq 0x6e30
jmp 0x37fc
movq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x3230
movq %rax, 0x8(%rsp)
jmp 0x3812
movq 0x8(%rsp), %rdi
leaq 0xa80d(%rip), %rsi      # 0xe02b
callq 0x3250
jmp 0x3825
leaq 0x68(%rsp), %rdi
callq 0x3190
leaq 0x90(%rsp), %rdi
callq 0x3190
leaq 0xc0(%rsp), %rdi
callq 0x3190
movq 0xf0(%rsp), %rax
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x38b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x38a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x3190
leaq 0x90(%rsp), %rdi
callq 0x3190
leaq 0xc0(%rsp), %rdi
callq 0x3190
movq 0xb8(%rsp), %rdi
callq 0x3460
nopw (%rax,%rax)
// File: 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 %rax
movq %rdi, (%rsp)
movq 0x103ec(%rip), %rdi     # 0x13fc8
leaq 0xa44a(%rip), %rsi      # 0xe02d
callq 0x3250
movq %rax, %rdi
movq 0x103b6(%rip), %rsi     # 0x13fa8
callq 0x3280
movq (%rsp), %rsi
movq 0x103c6(%rip), %rdi     # 0x13fc8
callq 0x3250
movq %rax, %rdi
leaq 0xa423(%rip), %rsi      # 0xe034
callq 0x3250
movq %rax, %rdi
movq 0x10388(%rip), %rsi     # 0x13fa8
callq 0x3280
movq 0x1039c(%rip), %rdi     # 0x13fc8
leaq 0xa425(%rip), %rsi      # 0xe058
callq 0x3250
movq %rax, %rdi
movq 0x10366(%rip), %rsi     # 0x13fa8
callq 0x3280
popq %rax
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq 0x58(%rsp), %rax
movl 0x12(%rax), %eax
movl %eax, 0x50(%rsp)
movq 0x58(%rsp), %rax
movl 0x16(%rax), %eax
movl %eax, 0x4c(%rsp)
movl 0x50(%rsp), %eax
movl 0x54(%rsp), %ecx
subl %ecx, %eax
cvtsi2ss %rax, %xmm0
movss 0x8a32(%rip), %xmm1     # 0xe010
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3420
cvttsd2si %xmm0, %rax
movl %eax, 0x48(%rsp)
movb $0x0, 0x47(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x28(%rsp)
leaq 0x43(%rsp), %rdi
movl $0xff, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x8070
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x43(%rsp), %ecx
movl $0x1, %r8d
callq 0x80b0
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jae 0x56e3
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x54(%rsp), %eax
jae 0x56d1
movq 0x58(%rsp), %rdi
movl 0x38(%rsp), %esi
movl 0x48(%rsp), %eax
addl %eax, %esi
movl 0x3c(%rsp), %edx
callq 0x7170
movq %rax, 0x8(%rsp)
jmp 0x5685
movq 0x18(%rsp), %rdi
movl 0x38(%rsp), %esi
movl 0x3c(%rsp), %edx
callq 0x77c0
movq %rax, (%rsp)
jmp 0x569d
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x565c
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x8310
jmp 0x5703
jmp 0x56d3
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x5646
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x56f9
movq 0x18(%rsp), %rdi
callq 0x8310
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x3460
nopl (%rax)
// File: 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:
subq $0x288, %rsp            # imm = 0x288
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movl %edx, 0x274(%rsp)
movl %ecx, 0x270(%rsp)
movq 0x280(%rsp), %rsi
leaq 0x70(%rsp), %rdi
movl $0x10, %edx
callq 0x32b0
movq 0x70(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x70(%rsp,%rax), %rdi
callq 0x3130
movb %al, 0x3f(%rsp)
jmp 0x63c5
movb 0x3f(%rsp), %al
testb $0x1, %al
jne 0x63d2
jmp 0x6457
movq 0xdc0f(%rip), %rdi      # 0x13fe8
leaq 0x80f1(%rip), %rsi      # 0xe4d1
callq 0x3250
movq %rax, 0x30(%rsp)
jmp 0x63ec
movq 0x30(%rsp), %rdi
movq 0x280(%rsp), %rsi
callq 0x3250
movq %rax, 0x28(%rsp)
jmp 0x6405
movq 0x28(%rsp), %rdi
leaq 0x8086(%rip), %rsi      # 0xe497
callq 0x3250
movq %rax, 0x20(%rsp)
jmp 0x641d
movq 0x20(%rsp), %rdi
movq 0xdb7f(%rip), %rsi      # 0x13fa8
callq 0x3280
jmp 0x6430
movl $0x1, %edi
callq 0x3300
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x33b0
jmp 0x6587
movq 0x278(%rsp), %rdi
callq 0x7e60
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq 0x30a0
movq %rax, 0x18(%rsp)
jmp 0x6478
movq 0x18(%rsp), %rdi
movq 0xdb24(%rip), %rsi      # 0x13fa8
callq 0x3280
jmp 0x648b
movl 0x274(%rsp), %esi
leaq 0x70(%rsp), %rdi
callq 0x3350
movq %rax, 0x10(%rsp)
jmp 0x64a3
movq 0x10(%rsp), %rdi
movq 0xdaf9(%rip), %rsi      # 0x13fa8
callq 0x3280
jmp 0x64b6
movl 0x270(%rsp), %esi
leaq 0x70(%rsp), %rdi
callq 0x3450
movq %rax, 0x8(%rsp)
jmp 0x64ce
movq 0x8(%rsp), %rdi
movq 0xdace(%rip), %rsi      # 0x13fa8
callq 0x3280
jmp 0x64e1
movq 0x278(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x8460
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x8490
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x84c0
testb $0x1, %al
jne 0x6521
jmp 0x6569
leaq 0x50(%rsp), %rdi
callq 0x8500
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movss (%rax), %xmm0
leaq 0x70(%rsp), %rdi
callq 0x31e0
movq %rax, (%rsp)
jmp 0x6549
movq (%rsp), %rdi
movq 0xda54(%rip), %rsi      # 0x13fa8
callq 0x3280
jmp 0x655b
jmp 0x655d
leaq 0x50(%rsp), %rdi
callq 0x8510
jmp 0x650c
leaq 0x70(%rsp), %rdi
callq 0x3390
jmp 0x6575
leaq 0x70(%rsp), %rdi
callq 0x33b0
addq $0x288, %rsp            # imm = 0x288
retq
movq 0x68(%rsp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq %rdx, 0x260(%rsp)
movq %rcx, 0x258(%rsp)
movq 0x268(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movl $0x8, %edx
callq 0x3490
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x50(%rsp,%rax), %rdi
callq 0x3130
movb %al, 0x33(%rsp)
jmp 0x6604
movb 0x33(%rsp), %al
testb $0x1, %al
jne 0x660e
jmp 0x6689
movq 0xd9d3(%rip), %rdi      # 0x13fe8
leaq 0x7ecf(%rip), %rsi      # 0xe4eb
callq 0x3250
movq %rax, 0x18(%rsp)
jmp 0x6628
movq 0x18(%rsp), %rdi
movq 0x268(%rsp), %rsi
callq 0x3250
movq %rax, 0x10(%rsp)
jmp 0x6641
movq 0x10(%rsp), %rdi
leaq 0x7e4a(%rip), %rsi      # 0xe497
callq 0x3250
movq %rax, 0x8(%rsp)
jmp 0x6659
movq 0x8(%rsp), %rdi
movq 0xd943(%rip), %rsi      # 0x13fa8
callq 0x3280
jmp 0x666c
movl $0x1, %edi
callq 0x3300
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x676c
movq 0x20(%rsp), %rdi
movb $0x0, 0x43(%rsp)
callq 0x7a20
leaq 0x50(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x3180
jmp 0x66a9
movq 0x20(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0x7b40
jmp 0x66ba
movq 0x260(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x3060
jmp 0x66ce
movq 0x258(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x3180
jmp 0x66e2
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x673f
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3090
jmp 0x6705
movq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x8530
jmp 0x6716
jmp 0x6718
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x66ea
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x7ee0
jmp 0x676c
movb $0x1, 0x43(%rsp)
testb $0x1, 0x43(%rsp)
jne 0x6755
movq 0x20(%rsp), %rdi
callq 0x7ee0
leaq 0x50(%rsp), %rdi
callq 0x30c0
movq 0x28(%rsp), %rax
addq $0x278, %rsp            # imm = 0x278
retq
leaq 0x50(%rsp), %rdi
callq 0x30c0
movq 0x48(%rsp), %rdi
callq 0x3460
// File: 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:
subq $0x258, %rsp            # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq 0x250(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0x248(%rsp), %rsi
addq $0x40, %rdi
callq 0x3370
movq 0x248(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movl $0x4, %edx
callq 0x32b0
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x48(%rsp,%rax), %rdi
callq 0x3130
movb %al, 0x3b(%rsp)
jmp 0x8915
movb 0x3b(%rsp), %al
testb $0x1, %al
jne 0x8922
jmp 0x89a7
movq 0xb6bf(%rip), %rdi      # 0x13fe8
leaq 0x5ba1(%rip), %rsi      # 0xe4d1
callq 0x3250
movq %rax, 0x28(%rsp)
jmp 0x893c
movq 0x28(%rsp), %rdi
movq 0x248(%rsp), %rsi
callq 0x3250
movq %rax, 0x20(%rsp)
jmp 0x8955
movq 0x20(%rsp), %rdi
leaq 0x5b36(%rip), %rsi      # 0xe497
callq 0x3250
movq %rax, 0x18(%rsp)
jmp 0x896d
movq 0x18(%rsp), %rdi
movq 0xb62f(%rip), %rsi      # 0x13fa8
callq 0x3280
jmp 0x8980
movl $0x1, %edi
callq 0x3300
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x33b0
jmp 0x8a59
movq 0x30(%rsp), %rax
movzwl 0x1c(%rax), %eax
cmpl $0x18, %eax
je 0x8a2a
movq 0x30(%rsp), %rax
movzwl 0x1c(%rax), %eax
cmpl $0x20, %eax
je 0x8a2a
movq 0xb61e(%rip), %rdi      # 0x13fe8
leaq 0x5c00(%rip), %rsi      # 0xe5d1
callq 0x3250
movq %rax, 0x10(%rsp)
jmp 0x89dd
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rax
movzwl 0x1c(%rax), %esi
callq 0x3410
movq %rax, 0x8(%rsp)
jmp 0x89f7
movq 0x8(%rsp), %rdi
leaq 0x5628(%rip), %rsi      # 0xe02b
callq 0x3250
movq %rax, (%rsp)
jmp 0x8a0e
movq (%rsp), %rdi
movq 0xb58f(%rip), %rsi      # 0x13fa8
callq 0x3280
jmp 0x8a20
movl $0x1, %edi
callq 0x3300
movq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x9b00
jmp 0x8a3b
leaq 0x48(%rsp), %rdi
callq 0x3390
jmp 0x8a47
leaq 0x48(%rsp), %rdi
callq 0x33b0
addq $0x258, %rsp            # imm = 0x258
retq
movq 0x40(%rsp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movzbl (%rdi), %esi
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
addl %eax, %esi
callq 0x9150
movq (%rsp), %rdi
movb %al, (%rdi)
movzbl 0x1(%rdi), %esi
movq 0x8(%rsp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %esi
callq 0x9150
movq (%rsp), %rdi
movb %al, 0x1(%rdi)
movzbl 0x2(%rdi), %esi
movq 0x8(%rsp), %rax
movzbl 0x2(%rax), %eax
addl %eax, %esi
callq 0x9150
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x2(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: iibrahimli[P]adsa_project/src/../include/pixel.hpp
// Function: pixel4::clamp(int)
inline uint8_t clamp(int x){
        uint8_t ret;

        if(x > 255) ret = 255;
        else if(x < 0) ret = 0;
        else ret = x;

        return ret;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
cmpl $0xff, -0xc(%rsp)
jle 0x916a
movb $-0x1, -0xd(%rsp)
jmp 0x9182
cmpl $0x0, -0xc(%rsp)
jge 0x9178
movb $0x0, -0xd(%rsp)
jmp 0x9180
movl -0xc(%rsp), %eax
movb %al, -0xd(%rsp)
jmp 0x9182
movb -0xd(%rsp), %al
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movzbl (%rdi), %eax
cvtsi2ss %eax, %xmm0
movq 0x8(%rsp), %rax
mulss (%rax), %xmm0
cvttss2si %xmm0, %esi
callq 0x9150
movq (%rsp), %rdi
movb %al, (%rdi)
movzbl 0x1(%rdi), %eax
cvtsi2ss %eax, %xmm0
movq 0x8(%rsp), %rax
mulss (%rax), %xmm0
cvttss2si %xmm0, %esi
callq 0x9150
movq (%rsp), %rdi
movb %al, 0x1(%rdi)
movzbl 0x2(%rdi), %eax
cvtsi2ss %eax, %xmm0
movq 0x8(%rsp), %rax
mulss (%rax), %xmm0
cvttss2si %xmm0, %esi
callq 0x9150
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x2(%rax)
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x64(%rax)
je 0x9b2a
movq 0x8(%rsp), %rax
imull $-0x1, 0x16(%rax), %ecx
movl %ecx, 0x16(%rax)
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
movl $0xe, %edx
callq 0x3340
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0xe, %rsi
movl $0x28, %edx
callq 0x3340
movq 0x8(%rsp), %rax
testb $0x1, 0x64(%rax)
je 0x9b6d
movq 0x8(%rsp), %rax
imull $-0x1, 0x16(%rax), %ecx
movl %ecx, 0x16(%rax)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x16(%rcx), %eax
jge 0x9be4
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rdi
movq 0x38(%rcx), %rsi
movl 0x14(%rsp), %eax
imull 0x12(%rcx), %eax
cltq
shlq $0x2, %rax
addq %rax, %rsi
movl 0x12(%rcx), %eax
movzwl 0x1c(%rcx), %ecx
imull %ecx, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movslq %eax, %rdx
callq 0x3340
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movl 0x60(%rax), %eax
movl %eax, %edx
leaq 0x4442(%rip), %rsi      # 0xe014
callq 0x3340
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x9b75
addq $0x28, %rsp
retq
nopl (%rax)
// File: juli9797[P]ssf/src/filetype_icon.hpp
// Function: ssf::get_colorhash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int get_colorhash(std::string s){
	int sum = 0;
	for(auto c : s){
		sum += c;
	}
	return (sum % colors.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4290
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4190
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa5b0
testb $0x1, %al
jne 0x5094
jmp 0x50b7
leaq -0x20(%rbp), %rdi
callq 0xa5f0
movb (%rax), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa610
jmp 0x5081
movslq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x1e2ba(%rip), %rdi     # 0x23380
callq 0xa630
movq %rax, %rcx
movq -0x38(%rbp), %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa690
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xa6f0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0xa6c0
jmp 0x55a0
leaq -0x28(%rbp), %rdi
callq 0xa720
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa780
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xa6c0
jmp 0x55dd
leaq -0x50(%rbp), %rdi
callq 0xa720
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xa7c0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0xa6c0
jmp 0x561a
leaq -0x68(%rbp), %rdi
callq 0xa720
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xa880
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0xa800
jmp 0x5657
leaq -0x80(%rbp), %rdi
callq 0xa720
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xa930
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0xa8b0
jmp 0x5697
leaq -0x98(%rbp), %rdi
callq 0xa720
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa720
jmp 0x5720
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa720
jmp 0x5720
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa720
jmp 0x5720
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xa720
jmp 0x5720
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xa720
movq -0x30(%rbp), %rdi
callq 0x4560
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0xe130
testb $0x1, %al
jne 0xa868
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe170
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
addq $0x10, %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xe270
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xe200
jmp 0xa879
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe170
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0xe130
testb $0x1, %al
jne 0xa918
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe170
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
addq $0x28, %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xe270
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xe200
jmp 0xa929
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe170
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x50(%rbp)
xorl %edi, %edi
callq 0x4380
movq -0x50(%rbp), %rsi
leaq -0x44(%rbp), %rdi
movl $0x3c, %edx
callq 0x4250
movl -0x44(%rbp), %eax
andl $0xfffffacd, %eax       # imm = 0xFFFFFACD
movl %eax, -0x44(%rbp)
movl -0x40(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
orl $0x30, %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
andl $0xffff7ff4, %eax       # imm = 0xFFFF7FF4
movl %eax, -0x38(%rbp)
movb $0x1, -0x2d(%rbp)
movb $0x1, -0x2e(%rbp)
xorl %edi, %edi
movl $0x2, %esi
leaq -0x44(%rbp), %rdx
callq 0x43e0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x18041(%rip), %rdi     # 0x22fc0
callq 0x42b0
movq -0x38(%rbp), %rdi
callq 0x13170
jmp 0xaf8f
jmp 0xafde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xaffd
movq -0x18(%rbp), %rdi
callq 0x40e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x30(%rbp)
leaq 0x183cb(%rip), %rdi     # 0x23399
leaq -0x30(%rbp), %rsi
callq 0x131b0
jmp 0xafd9
callq 0x4500
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4500
jmp 0xaffb
jmp 0xaffd
movq -0x18(%rbp), %rdi
callq 0x4560
movq %rax, %rdi
callq 0xc060
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0xa(%rbp)
movsbl -0xa(%rbp), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0xbb26
movq 0x17563(%rip), %rdi     # 0x22fd8
callq 0x43a0
movq -0x38(%rbp), %rdi
movb %al, -0xa(%rbp)
leaq -0xa(%rbp), %rsi
callq 0x13820
movq %rax, -0x40(%rbp)
jmp 0xba90
movq -0x40(%rbp), %rdi
callq 0x13170
jmp 0xba9b
jmp 0xbb0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xbb2c
movq -0x18(%rbp), %rdi
callq 0x40e0
movq %rax, -0x28(%rbp)
leaq 0x178d0(%rip), %rdi     # 0x23399
leaq 0xb874(%rip), %rsi      # 0x17344
callq 0x13850
movq %rax, -0x48(%rbp)
jmp 0xbadb
movq -0x48(%rbp), %rdi
movsbl -0xa(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x13870
movq %rax, -0x50(%rbp)
jmp 0xbaf5
movq -0x50(%rbp), %rdi
leaq 0xb849(%rip), %rsi      # 0x17349
callq 0x13890
jmp 0xbb07
callq 0x4500
jmp 0xba5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4500
jmp 0xbb24
jmp 0xbb2c
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4560
movq %rax, %rdi
callq 0xc060
nopl (%rax)