LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: millanek[P]evo/./process_vcf_stats_utils.h
// Function: pearson_chi_sq_indep(int, int, int, int)
inline double pearson_chi_sq_indep(int a, int b, int c, int d) {
    // Expected values for a,b,c,and d: (RowTotal*ColTotal)/GridTotal
    double n = (double)a+b+c+d;
    double exp_a = (double)((a+b)*(a+c))/n;
    double exp_b = (double)((a+b)*(b+d))/n;
    double exp_c = (double)((c+d)*(a+c))/n;
    double exp_d = (double)((c+d)*(b+d))/n;
    //std::cerr << "exp_a: " << exp_a << "exp_b: " << exp_b << "exp_c: " << exp_c << "exp_d: " << exp_d << std::endl;
    double chi_sq = pow((a-exp_a),2.0)/exp_a + pow((b-exp_b),2.0)/exp_b + pow((c-exp_c),2.0)/exp_c + pow((d-exp_d),2.0)/exp_d;
    //std::cerr << "Chisq stat: " << chi_sq << std::endl;
    double df = 1.0;
    double p = (1-chisq_cdf(df, chi_sq));
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
cvtsi2sdl -0x8(%rbp), %xmm1
addsd %xmm1, %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
addsd %xmm1, %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
addl -0xc(%rbp), %ecx
imull %ecx, %eax
cvtsi2sd %eax, %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
movl -0x8(%rbp), %ecx
addl -0x10(%rbp), %ecx
imull %ecx, %eax
cvtsi2sd %eax, %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl -0x4(%rbp), %ecx
addl -0xc(%rbp), %ecx
imull %ecx, %eax
cvtsi2sd %eax, %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl -0x8(%rbp), %ecx
addl -0x10(%rbp), %ecx
imull %ecx, %eax
cvtsi2sd %eax, %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd 0x4f409(%rip), %xmm1    # 0x1336c8
callq 0xab30
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
cvtsi2sdl -0x8(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd 0x4f3e8(%rip), %xmm1    # 0x1336c8
callq 0xab30
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
divsd -0x28(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd 0x4f3bb(%rip), %xmm1    # 0x1336c8
callq 0xab30
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
divsd -0x30(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
cvtsi2sdl -0x10(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movsd 0x4f38e(%rip), %xmm1    # 0x1336c8
callq 0xab30
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
divsd -0x38(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x4df5b(%rip), %xmm0    # 0x1322b8
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
callq 0x84860
movaps %xmm0, %xmm1
movsd 0x4df3c(%rip), %xmm0    # 0x1322b8
subsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
// File: millanek[P]evo/./process_vcf_stats_utils.h
// Function: fisher_exactTable(int, int, int, int)
inline double fisher_exactTable(int a, int b, int c, int d) {
    
    long double numerator = factorial(a+b) * factorial(c+d) * factorial(a+c) * factorial(b+d);
    long double denominator = factorial(a) * factorial(b) * factorial(c) * factorial(d) * factorial(a+b+c+d);
    
    double p = numerator/denominator;
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
callq 0x70380
movsd %xmm0, -0x88(%rbp)
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
callq 0x70380
movaps %xmm0, %xmm1
movsd -0x88(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x80(%rbp)
movl -0x4(%rbp), %eax
movl -0xc(%rbp), %ecx
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
callq 0x70380
movaps %xmm0, %xmm1
movsd -0x80(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x78(%rbp)
movl -0x8(%rbp), %eax
movl -0x10(%rbp), %ecx
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
callq 0x70380
movaps %xmm0, %xmm1
movsd -0x78(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
fldl -0x40(%rbp)
fstpt -0x20(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
callq 0x70380
movsd %xmm0, -0x70(%rbp)
cvtsi2sdl -0x8(%rbp), %xmm0
callq 0x70380
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
callq 0x70380
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
cvtsi2sdl -0x10(%rbp), %xmm0
callq 0x70380
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
addl %ecx, %eax
movl -0xc(%rbp), %ecx
addl %ecx, %eax
movl -0x10(%rbp), %ecx
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
callq 0x70380
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
fldl -0x48(%rbp)
fstpt -0x30(%rbp)
fldt -0x20(%rbp)
fldt -0x30(%rbp)
fdivrp %st, %st(1)
fstpl -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: millanek[P]evo/process_vcf_linkGeneNames.cpp
// Function: getSpeciesColumn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline int getSpeciesColumn(const string& species) {
    if (species == "mz") { return 0; }
    if (species == "pn") { return 1; }
    if (species == "ab") { return 2; }
    if (species == "nb") { return 3; }
    if (species == "on") { return 4; }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5a41b(%rip), %rsi     # 0x149482
callq 0x2d770
testb $0x1, %al
jne 0xef072
jmp 0xef07e
movl $0x0, -0x4(%rbp)
jmp 0xef101
movq -0x10(%rbp), %rdi
leaq 0x5a655(%rip), %rsi     # 0x1496de
callq 0x2d770
testb $0x1, %al
jne 0xef094
jmp 0xef09d
movl $0x1, -0x4(%rbp)
jmp 0xef101
movq -0x10(%rbp), %rdi
leaq 0x5a639(%rip), %rsi     # 0x1496e1
callq 0x2d770
testb $0x1, %al
jne 0xef0b3
jmp 0xef0bc
movl $0x2, -0x4(%rbp)
jmp 0xef101
movq -0x10(%rbp), %rdi
leaq 0x5a61d(%rip), %rsi     # 0x1496e4
callq 0x2d770
testb $0x1, %al
jne 0xef0d2
jmp 0xef0db
movl $0x3, -0x4(%rbp)
jmp 0xef101
movq -0x10(%rbp), %rdi
leaq 0x5ad84(%rip), %rsi     # 0x149e6a
callq 0x2d770
testb $0x1, %al
jne 0xef0f1
jmp 0xef0fa
movl $0x4, -0x4(%rbp)
jmp 0xef101
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: millanek[P]evo/remove_lowercase.cpp
// Function: removeLcLetters[abi:cxx11](std::basic_ifstream<char, std::char_traits<char>>&, int)
std::string removeLcLetters(std::ifstream& fastaFile, int bytes) {
    std::string filteredSeq; filteredSeq.reserve(bytes); filteredSeq = "";
    string line;
    while (getline(fastaFile, line)) {
        for (int i = 0; i != line.length(); i++) {
            if (isupper(line[i])) {
                filteredSeq += line[i];
            }
        }
    }
    return filteredSeq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0xa820
movq -0x58(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xa980
jmp 0xefe79
movq -0x58(%rbp), %rdi
leaq 0x4605b(%rip), %rsi     # 0x135edf
callq 0xa810
jmp 0xefe8b
leaq -0x48(%rbp), %rdi
callq 0xa820
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x68(%rbp)
jmp 0xefea7
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x69(%rbp)
jmp 0xefebf
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xefecb
jmp 0xeff7e
movl $0x0, -0x4c(%rbp)
movslq -0x4c(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa930
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
je 0xeff79
movslq -0x4c(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xac60
movq %rax, -0x80(%rbp)
jmp 0xeff06
movq -0x80(%rbp), %rax
movsbl (%rax), %edi
callq 0xa440
cmpl $0x0, %eax
je 0xeff69
movslq -0x4c(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xac60
movq %rax, -0x88(%rbp)
jmp 0xeff2d
movq -0x58(%rbp), %rdi
movq -0x88(%rbp), %rax
movsbl (%rax), %esi
callq 0xa380
jmp 0xeff42
jmp 0xeff69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xeffa7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xac88
jmp 0xeffa7
jmp 0xeff6b
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xefed2
jmp 0xefe94
movb $0x1, -0x15(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xac88
testb $0x1, -0x15(%rbp)
jne 0xeff9a
movq -0x58(%rbp), %rdi
callq 0xac88
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xac88
movq -0x20(%rbp), %rdi
callq 0xab50
nopl (%rax)
// File: millanek[P]evo/evo_Dmin.cpp
// Function: nChoosek(unsigned int, unsigned int)
inline unsigned nChoosek( unsigned n, unsigned k )
{
    if (k > n) return 0;
    if (k * 2 > n) k = n-k;
    if (k == 0) return 1;
    
    int result = n;
    for( int i = 2; i <= k; ++i ) {
        result *= (n-i+1);
        result /= i;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jbe 0xf55db
movl $0x0, -0x4(%rbp)
jmp 0xf563f
movl -0xc(%rbp), %eax
shll %eax
cmpl -0x8(%rbp), %eax
jbe 0xf55ee
movl -0x8(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xf55fd
movl $0x1, -0x4(%rbp)
jmp 0xf563f
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
ja 0xf5639
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
addl $0x1, %eax
imull -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %ecx
movl -0x10(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf560a
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: millanek[P]evo/evo_agpToNewFasta.cpp
// Function: readAGPstructureToMap[abi:cxx11](std::istream*)
std::map<string, std::vector<std::vector<string> > > readAGPstructureToMap(std::istream* agpFile) {
    std::map<string, std::vector<std::vector<string> > > newAgpStructure;
    string line;
    while (getline(*agpFile, line)) {
        if (line[0] == '#') { continue; } // Skip over any comment lines
        else {
            std::vector<std::string> fields = split(line, '\t');
            string currentScaffold = fields[0];
            newAgpStructure[currentScaffold].push_back(fields);
        }
    }
    return newAgpStructure;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3f5d0
leaq -0x38(%rbp), %rdi
callq 0xa820
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x98(%rbp)
jmp 0x11221c
movq -0x98(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x99(%rbp)
jmp 0x11223a
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x112249
jmp 0x112322
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0xac60
movq %rax, -0xa8(%rbp)
jmp 0x11225f
movq -0xa8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x112281
jmp 0x112206
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x112337
leaq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x9, %edx
callq 0x7bbe0
jmp 0x112295
xorl %eax, %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
callq 0x3d940
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0xa250
jmp 0x1122b0
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3f760
movq %rax, -0xb0(%rbp)
jmp 0x1122c9
movq -0xb0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3f610
jmp 0x1122db
leaq -0x80(%rbp), %rdi
callq 0xac88
leaq -0x60(%rbp), %rdi
callq 0x3dfa0
jmp 0x11231d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x112312
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xac88
leaq -0x60(%rbp), %rdi
callq 0x3dfa0
jmp 0x112337
jmp 0x112206
movb $0x1, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xac88
testb $0x1, -0x11(%rbp)
jne 0x11235a
jmp 0x11234e
leaq -0x38(%rbp), %rdi
callq 0xac88
movq -0x90(%rbp), %rdi
callq 0x3f5b0
jmp 0x11236a
movq -0x90(%rbp), %rdi
callq 0x3f5b0
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/./process_vcf_utils.h
// Function: MultiallelicCounts::MultiallelicCounts(int, int)
MultiallelicCounts(int nSamples, int starPosInput) : inbreedingCoefficient(0), chiSqPvalForInbreeding(1), bPhased(false) {
        individualsHets.assign(nSamples, -1);
        missingIndividualsDot.assign(nSamples, 0);
        missingIndividualsAny.assign(nSamples, 0);
        missingHaplotypesDot.assign(2*nSamples, 0);
        
        missingHaplotypesStar.assign(2*nSamples, 0);
        haplotypeVariants.assign(2*nSamples, -1);
        starPos = starPosInput;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq $0x0, 0x8(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
callq 0x46270
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x70(%rbp)
callq 0x46270
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x68(%rbp)
callq 0x46270
movq -0x50(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x60(%rbp)
callq 0x46270
movq -0x50(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x58(%rbp)
callq 0x46270
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0x48(%rbp)
callq 0x46270
movq -0x40(%rbp), %rdi
movslq -0xc(%rbp), %rsi
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
leaq -0x14(%rbp), %rdx
callq 0x838d0
jmp 0x1177c3
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
movslq -0xc(%rbp), %rsi
movl $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x838d0
jmp 0x1177e1
movq -0x50(%rbp), %rdi
addq $0x68, %rdi
movslq -0xc(%rbp), %rsi
movl $0x0, -0x2c(%rbp)
leaq -0x2c(%rbp), %rdx
callq 0x838d0
jmp 0x1177ff
movq -0x50(%rbp), %rdi
subq $-0x80, %rdi
movl -0xc(%rbp), %eax
addl %eax, %eax
movslq %eax, %rsi
movl $0x0, -0x30(%rbp)
leaq -0x30(%rbp), %rdx
callq 0x838d0
jmp 0x117821
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
movl -0xc(%rbp), %eax
addl %eax, %eax
movslq %eax, %rsi
movl $0x0, -0x34(%rbp)
leaq -0x34(%rbp), %rdx
callq 0x838d0
jmp 0x117846
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movl -0xc(%rbp), %eax
addl %eax, %eax
movslq %eax, %rsi
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
leaq -0x38(%rbp), %rdx
callq 0x838d0
jmp 0x117868
movq -0x50(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x48290
movq -0x58(%rbp), %rdi
callq 0x48290
movq -0x60(%rbp), %rdi
callq 0x48290
movq -0x68(%rbp), %rdi
callq 0x48290
movq -0x70(%rbp), %rdi
callq 0x48290
movq -0x40(%rbp), %rdi
callq 0x48290
movq -0x20(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: millanek[P]evo/./evo_recombUtils.h
// Function: PhaseInfo::PhaseInfo(int, double, int, std::vector<char, std::allocator<char>>&, int)
PhaseInfo(int position, double qual, int cov, std::vector<char>& phasedVarsIn, int blockNumIn) {
        pos = position; quality = qual;
        coverage = cov;
        phasedVars = phasedVarsIn;
        blockNum = blockNumIn;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0xad970
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x20(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x28(%rax)
movq -0x28(%rbp), %rsi
callq 0x11dd50
jmp 0x11cd0c
movq -0x50(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0x2c(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xae570
movq -0x38(%rbp), %rdi
callq 0xab50
nopw (%rax,%rax)
// File: millanek[P]evo/./evo_recombUtils.h
// Function: RecombReadPair::RecombReadPair(RecombRead*, RecombRead*)
RecombReadPair(RecombRead* r1, RecombRead* r2) {
        if (r1 < r2) {
            read1 = r1;
            read2 = r2;
        } else {
            read1 = r2;
            read2 = r1;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x18, %rdi
callq 0x11e780
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x11d5b4
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x11d5c7
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: millanek[P]evo/./evo_recombUtils.h
// Function: PhaseSwitch::PhaseSwitch(int, int, double, double)
PhaseSwitch(int left, int right, double qLeft, double qRight) {
        posLeft = left;
        posRight = right;
        phaseQualLeft = qLeft;
        phaseQualRight = qRight;
        dist = abs(right - left);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
movl %ecx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: millanek[P]evo/evo_recombUtils.cpp
// Function: RecombRead::assignStrandFromFlag[abi:cxx11]()
string RecombRead::assignStrandFromFlag() {
    string strand = "?";
    if (flag == 81 || flag == 113 || flag == 145 || flag == 177 || flag == 185 || flag == 121) {
        strand = "-";
    } else if (flag == 65 || flag == 73 || flag == 97 || flag == 129 || flag == 161 || flag == 137) {
        strand = "+";
    } else {
        std::cerr << "Unexpected read flag: " << flag << std::endl;
        exit(1);
    }
    return strand;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xab60
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x20410(%rip), %rsi     # 0x146af3
callq 0x2d6c0
jmp 0x1266ea
leaq -0x12(%rbp), %rdi
callq 0xa640
movq -0x40(%rbp), %rax
cmpl $0x51, (%rax)
je 0x126732
movq -0x40(%rbp), %rax
cmpl $0x71, (%rax)
je 0x126732
movq -0x40(%rbp), %rax
cmpl $0x91, (%rax)
je 0x126732
movq -0x40(%rbp), %rax
cmpl $0xb1, (%rax)
je 0x126732
movq -0x40(%rbp), %rax
cmpl $0xb9, (%rax)
je 0x126732
movq -0x40(%rbp), %rax
cmpl $0x79, (%rax)
jne 0x12677d
movq -0x38(%rbp), %rdi
leaq 0xe3d3(%rip), %rsi      # 0x134b10
callq 0xa810
jmp 0x126744
jmp 0x12681c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0xa640
jmp 0x126839
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xac88
jmp 0x126839
movq -0x40(%rbp), %rax
cmpl $0x41, (%rax)
je 0x1267bc
movq -0x40(%rbp), %rax
cmpl $0x49, (%rax)
je 0x1267bc
movq -0x40(%rbp), %rax
cmpl $0x61, (%rax)
je 0x1267bc
movq -0x40(%rbp), %rax
cmpl $0x81, (%rax)
je 0x1267bc
movq -0x40(%rbp), %rax
cmpl $0xa1, (%rax)
je 0x1267bc
movq -0x40(%rbp), %rax
cmpl $0x89, (%rax)
jne 0x1267d0
movq -0x38(%rbp), %rdi
leaq 0xe33c(%rip), %rsi      # 0x134b03
callq 0xa810
jmp 0x1267ce
jmp 0x12681a
movq 0x72819(%rip), %rdi     # 0x198ff0
leaq 0x284ca(%rip), %rsi     # 0x14eca8
callq 0xa5c0
movq %rax, -0x50(%rbp)
jmp 0x1267e9
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movl (%rax), %esi
callq 0xab20
movq %rax, -0x58(%rbp)
jmp 0x1267fe
movq -0x58(%rbp), %rdi
movq 0x7277f(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x126810
movl $0x1, %edi
callq 0xa700
jmp 0x12681c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x12682f
movq -0x38(%rbp), %rdi
callq 0xac88
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
// File: millanek[P]evo/evo_recombUtils.cpp
// Function: RecombReadPair::findAndCombinePairHets(std::map<int, PhaseInfo*, std::less<int>, std::allocator<std::pair<int const, PhaseInfo*>>> const&)
void RecombReadPair::findAndCombinePairHets(const std::map<int,PhaseInfo*> & positionToPhase) {
    read1->findHetsInRead(positionToPhase);
    read2->findHetsInRead(positionToPhase);
    
    if (read1->hetSites.size() > 0) hetSites = read1->hetSites;
    
    if (read2->hetSites.size() > 0) {
        if (hetSites.size() == 0) hetSites = read2->hetSites;
        else hetSites.insert(hetSites.end(), read2->hetSites.begin(), read2->hetSites.end());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x126170
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x126170
movq -0x40(%rbp), %rax
movq (%rax), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x11d780
cmpq $0x0, %rax
jbe 0x126ad5
movq -0x40(%rbp), %rdi
movq (%rdi), %rsi
addq $0x108, %rsi            # imm = 0x108
addq $0x18, %rdi
callq 0x1272d0
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x11d780
cmpq $0x0, %rax
jbe 0x126b97
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x11d780
cmpq $0x0, %rax
jne 0x126b20
movq -0x40(%rbp), %rdi
movq 0x8(%rdi), %rsi
addq $0x108, %rsi            # imm = 0x108
addq $0x18, %rdi
callq 0x1272d0
jmp 0x126b95
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x48(%rbp)
addq $0x18, %rdi
callq 0x1275d0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x127600
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x127640
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x1275d0
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x127520
movq %rax, -0x38(%rbp)
jmp 0x126b97
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: millanek[P]evo/evo_recombUtils.cpp
// Function: RecombReadPair::filterHetsByQuality(int)
void RecombReadPair::filterHetsByQuality(int minQuality) {
    
    std::vector<HetInfo*> goodHets;
    for (std::vector<HetInfo*>::iterator it = hetSites.begin(); it != hetSites.end(); it++) {
        if ((*it)->thisBaseQuality >= minQuality) {
            goodHets.push_back((*it));
        }
    }
    hetSites = goodHets;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x11e780
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
callq 0x127640
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
callq 0x1275d0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x127670
testb $0x1, %al
jne 0x126bf5
jmp 0x126c4c
leaq -0x30(%rbp), %rdi
callq 0x1276b0
movq (%rax), %rax
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0x126c39
leaq -0x30(%rbp), %rdi
callq 0x1276b0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x127040
jmp 0x126c20
jmp 0x126c39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x11e7a0
jmp 0x126c6e
jmp 0x126c3b
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x1276d0
movq %rax, -0x50(%rbp)
jmp 0x126bd1
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1272d0
jmp 0x126c5f
leaq -0x28(%rbp), %rdi
callq 0x11e7a0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xab50
nopw (%rax,%rax)
// File: millanek[P]evo/evo_recombUtils.cpp
// Function: RecombReadPair::filterHetsByBlock(int)
void RecombReadPair::filterHetsByBlock(int blockNum) {
    
    std::vector<HetInfo*> goodHets;
    for (std::vector<HetInfo*>::iterator it = hetSites.begin(); it != hetSites.end(); it++) {
        if ((*it)->phaseBlock == blockNum) {
            goodHets.push_back((*it));
        }
    }
    hetSites = goodHets;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x11e780
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
callq 0x127640
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
callq 0x1275d0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x127670
testb $0x1, %al
jne 0x126cd5
jmp 0x126d2c
leaq -0x30(%rbp), %rdi
callq 0x1276b0
movq (%rax), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x126d19
leaq -0x30(%rbp), %rdi
callq 0x1276b0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x127040
jmp 0x126d00
jmp 0x126d19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x11e7a0
jmp 0x126d4e
jmp 0x126d1b
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x1276d0
movq %rax, -0x50(%rbp)
jmp 0x126cb1
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1272d0
jmp 0x126d3f
leaq -0x28(%rbp), %rdi
callq 0x11e7a0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xab50
nopw (%rax,%rax)
// File: millanek[P]evo/./evo_recombUtils.h
// Function: HetInfo::HetInfo(int, char, int, char, char, double, int)
HetInfo(int position, char readBase, int readBaseQuality, char phase0, char phase1, double phaseQuality, int phaseBlockIn) {
        pos = position;
        thisBase = readBase; thisBaseQuality = readBaseQuality;
        thisHetPhase0 = phase0; thisHetPhase1 = phase1;
        thisPhaseQuality = phaseQuality;
        phaseBlock = phaseBlockIn;
        
        if (thisBase != thisHetPhase0 && thisBase != thisHetPhase1) {
            readPhaseBaseMismatch = true;
        } else {
            readPhaseBaseMismatch = false;
        }
        
        if (thisBase == thisHetPhase0) {
            thisHetPhase01 = 0;
        } else if (thisBase == thisHetPhase1) {
            thisHetPhase01 = 1;
        }
        
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %r8d, -0x38(%rbp)
movl %ecx, %eax
movl -0x38(%rbp), %ecx
movl %eax, -0x34(%rbp)
movl %edx, %eax
movl -0x34(%rbp), %edx
movl %eax, -0x30(%rbp)
movl %esi, %eax
movl -0x30(%rbp), %esi
movl %eax, -0x2c(%rbp)
movq %rdi, %r8
movl -0x2c(%rbp), %edi
movb %r9b, %al
movl 0x10(%rbp), %r9d
movq %r8, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movb %sil, -0xd(%rbp)
movl %edx, -0x14(%rbp)
movb %cl, -0x15(%rbp)
movb %al, -0x16(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rcx)
movb -0xd(%rbp), %al
movb %al, 0x8(%rcx)
movl -0x14(%rbp), %eax
movl %eax, 0xc(%rcx)
movb -0x15(%rbp), %al
movb %al, 0x10(%rcx)
movb -0x16(%rbp), %al
movb %al, 0x11(%rcx)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x18(%rcx)
movl 0x10(%rbp), %eax
movl %eax, 0x4(%rcx)
movsbl 0x8(%rcx), %eax
movsbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
je 0x126ff1
movq -0x28(%rbp), %rcx
movsbl 0x8(%rcx), %eax
movsbl 0x11(%rcx), %ecx
cmpl %ecx, %eax
je 0x126ff1
movq -0x28(%rbp), %rax
movb $0x1, 0x24(%rax)
jmp 0x126ff9
movq -0x28(%rbp), %rax
movb $0x0, 0x24(%rax)
movq -0x28(%rbp), %rcx
movsbl 0x8(%rcx), %eax
movsbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jne 0x127016
movq -0x28(%rbp), %rax
movl $0x0, 0x20(%rax)
jmp 0x127033
movq -0x28(%rbp), %rcx
movsbl 0x8(%rcx), %eax
movsbl 0x11(%rcx), %ecx
cmpl %ecx, %eax
jne 0x127031
movq -0x28(%rbp), %rax
movl $0x1, 0x20(%rax)
jmp 0x127033
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ColinHarker[P]ltsim/src/test.cpp
// Function: TEST_1()
void TEST_1()
{
   std::cout << "Testing system processes"
             << "\n";
   System ps = parseSystemInformation();
   ps.print();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x11769(%rip), %rdi     # 0x14fc8
leaq 0xa79e(%rip), %rsi      # 0xe004
callq 0x32a0
movq %rax, %rdi
leaq 0xa7a8(%rip), %rsi      # 0xe01d
callq 0x32a0
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xcfb0
movq -0x30(%rbp), %rdi
callq 0x9b80
jmp 0x3892
leaq -0x18(%rbp), %rdi
callq 0x3b90
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3b90
movq -0x20(%rbp), %rdi
callq 0x3510
nop
// File: ColinHarker[P]ltsim/src/test.cpp
// Function: TEST_2()
void TEST_2()
{
   std::cout << "Testing cpu core utilization"
             << "\n";
   Cpu cpu;
   cpu.run();
   std::vector<CpuReader> cores = cpu.getCores();
   for(auto core : cores)
   {
      std::cout << core.getUtilization() << "\n";
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq 0x116f6(%rip), %rdi     # 0x14fc8
leaq 0xa746(%rip), %rsi      # 0xe01f
callq 0x32a0
movq %rax, %rdi
leaq 0xa735(%rip), %rsi      # 0xe01d
callq 0x32a0
leaq -0x88(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x53f0
movq -0x138(%rbp), %rdi
callq 0x59e0
jmp 0x390e
leaq -0xb0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5a40
jmp 0x3923
leaq -0xb0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x3bb0
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x3be0
movq %rax, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x3c10
testb $0x1, %al
jne 0x3973
jmp 0x3a3d
leaq -0xc0(%rbp), %rdi
callq 0x3c50
movq %rax, %rsi
leaq -0x130(%rbp), %rdi
callq 0x3c70
jmp 0x3990
leaq -0x130(%rbp), %rdi
callq 0x4380
movss %xmm0, -0x13c(%rbp)
jmp 0x39a6
movss -0x13c(%rbp), %xmm0
movq 0x11613(%rip), %rdi     # 0x14fc8
callq 0x3230
movq %rax, -0x148(%rbp)
jmp 0x39c3
movq -0x148(%rbp), %rdi
leaq 0xa64c(%rip), %rsi      # 0xe01d
callq 0x32a0
jmp 0x39d8
leaq -0x130(%rbp), %rdi
callq 0x3cf0
leaq -0xc0(%rbp), %rdi
callq 0x3d20
jmp 0x3957
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x3a6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x3a5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x3cf0
jmp 0x3a5e
leaq -0xb0(%rbp), %rdi
callq 0x3d40
leaq -0x88(%rbp), %rdi
callq 0x3da0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
leaq -0xb0(%rbp), %rdi
callq 0x3d40
leaq -0x88(%rbp), %rdi
callq 0x3da0
movq -0x90(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: ColinHarker[P]ltsim/src/test.cpp
// Function: TEST_3()
void TEST_3()
{
   std::cout << "Testing memory usage"
             << "\n";
   RandomAccessMemory ram;
   ram.run();
   std::cout << "Mem: " << ram.getMemUsage() << "\n"
             << "Swap: " << ram.getSwapUsage() << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x11529(%rip), %rdi     # 0x14fc8
leaq 0xa596(%rip), %rsi      # 0xe03c
callq 0x32a0
movq %rax, %rdi
leaq 0xa568(%rip), %rsi      # 0xe01d
callq 0x32a0
leaq -0x28(%rbp), %rdi
callq 0x6ee0
leaq -0x28(%rbp), %rdi
callq 0x6f40
movq 0x114f5(%rip), %rdi     # 0x14fc8
leaq 0xa577(%rip), %rsi      # 0xe051
callq 0x32a0
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7550
movq -0x38(%rbp), %rdi
callq 0x3230
movq %rax, %rdi
leaq 0xa51e(%rip), %rsi      # 0xe01d
callq 0x32a0
movq %rax, %rdi
leaq 0xa549(%rip), %rsi      # 0xe057
callq 0x32a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7570
movq -0x30(%rbp), %rdi
callq 0x3230
movq %rax, %rdi
leaq 0xa4ea(%rip), %rsi      # 0xe01d
callq 0x32a0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: ColinHarker[P]ltsim/src/test.cpp
// Function: main
int main()
{
   std::cout << "Starting tests..." << std::endl;
   TEST_1();
   TEST_2();
   TEST_3();

   return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x11472(%rip), %rdi     # 0x14fc8
leaq 0xa501(%rip), %rsi      # 0xe05e
callq 0x32a0
movq %rax, %rdi
movq 0x11444(%rip), %rsi     # 0x14fb0
callq 0x3300
callq 0x3850
callq 0x38c0
callq 0x3a90
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ColinHarker[P]ltsim/src/cpu-reader.cpp
// Function: CpuReader::retrieveCpuTimes(int) const
vector<size_t> CpuReader::retrieveCpuTimes(int lineNumberTarget) const
{
   std::ifstream proc_stat("/proc/stat");  // opening a filestream at /proc/stat

   proc_stat.seekg(std::ios::beg);

   // skip the first 4 lines of /cpuinfo
   for(int j = 0; j < lineNumberTarget; ++j)
   {
      proc_stat.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
   }

   proc_stat.ignore(5, ' ');  // Skip the 'cpu' prefix.
   vector<size_t> times;

   for(size_t time; proc_stat >> time; times.push_back(time))
      ;

   return times;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x260(%rbp)
movq %rdi, %rax
movq %rax, -0x258(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x9cba(%rip), %rsi      # 0xe088
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x3540
xorl %eax, %eax
movl %eax, %esi
leaq -0x230(%rbp), %rdi
callq 0x4780
jmp 0x43f1
movq -0x230(%rbp), %rsi
movq -0x228(%rbp), %rdx
leaq -0x220(%rbp), %rdi
callq 0x33c0
jmp 0x440d
movl $0x0, -0x240(%rbp)
movl -0x240(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4467
callq 0x47c0
movq %rax, %rsi
leaq -0x220(%rbp), %rdi
movl $0xa, %edx
callq 0x31e0
jmp 0x443d
jmp 0x443f
movl -0x240(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x240(%rbp)
jmp 0x4417
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
jmp 0x4549
leaq -0x220(%rbp), %rdi
movl $0x5, %esi
movl $0x20, %edx
callq 0x31e0
jmp 0x447f
movq -0x260(%rbp), %rdi
movb $0x0, -0x241(%rbp)
callq 0x47d0
leaq -0x220(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x3440
movq %rax, -0x268(%rbp)
jmp 0x44ae
movq -0x268(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x33b0
movb %al, -0x269(%rbp)
jmp 0x44cc
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x44d8
jmp 0x4511
jmp 0x44da
movq -0x260(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x47f0
jmp 0x44ef
jmp 0x4492
movq -0x260(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
callq 0x4860
jmp 0x4549
movb $0x1, -0x241(%rbp)
testb $0x1, -0x241(%rbp)
jne 0x452d
movq -0x260(%rbp), %rdi
callq 0x4860
leaq -0x220(%rbp), %rdi
callq 0x30b0
movq -0x258(%rbp), %rax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x30b0
movq -0x238(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: ColinHarker[P]ltsim/src/cpu-reader.cpp
// Function: CpuReader::getCpuTimes(int)
bool CpuReader::getCpuTimes(int lineNumberTarget)
{
   const vector<size_t> cpu_times = retrieveCpuTimes(lineNumberTarget);

   if(cpu_times.size() < 4)
      return false;

   m_idleTime  = cpu_times[3];
   m_totalTime = std::accumulate(cpu_times.begin(), cpu_times.end(), 0);

   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movl -0x14(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0x43a0
leaq -0x30(%rbp), %rdi
callq 0x48c0
cmpq $0x4, %rax
jae 0x45b2
movb $0x0, -0x1(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x4632
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x3, %esi
callq 0x48e0
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x50(%rax)
callq 0x4960
movq -0x70(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x4990
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x4900
movl %eax, -0x64(%rbp)
jmp 0x4600
movq -0x60(%rbp), %rax
movl -0x64(%rbp), %ecx
movslq %ecx, %rcx
movq %rcx, 0x58(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x4632
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4860
jmp 0x4646
leaq -0x30(%rbp), %rdi
callq 0x4860
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3510
nop
// File: ColinHarker[P]ltsim/src/cpu-reader.cpp
// Function: CpuReader::run(int)
void CpuReader::run(int lineNumberTarget)
{
   if(getCpuTimes(lineNumberTarget))
   {
      const float idle_time_delta  = m_idleTime - m_previousIdleTime;
      const float total_time_delta = m_totalTime - m_previousTotalTime;
      const float util             = 100.0 * (1.0 - idle_time_delta / total_time_delta);

      m_previousIdleTime  = m_idleTime;
      m_previousTotalTime = m_totalTime;
      m_utilization       = util;
   }
   else
   {
      m_utilization = -1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %esi
callq 0x4570
testb $0x1, %al
jne 0x4678
jmp 0x4763
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x50(%rax), %rax
subq %rcx, %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x28(%rbp)
testq %rax, %rax
movss %xmm0, -0x24(%rbp)
js 0x46bc
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movq 0x48(%rax), %rcx
movq 0x58(%rax), %rax
subq %rcx, %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x30(%rbp)
testq %rax, %rax
movss %xmm0, -0x2c(%rbp)
js 0x470a
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x10(%rbp), %xmm0
divss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x9952(%rip), %xmm1     # 0xe080
subsd %xmm0, %xmm1
movsd 0x993e(%rip), %xmm0     # 0xe078
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movq 0x50(%rax), %rcx
movq %rcx, 0x40(%rax)
movq 0x58(%rax), %rcx
movq %rcx, 0x48(%rax)
movss -0x18(%rbp), %xmm0
movss %xmm0, 0x60(%rax)
jmp 0x4774
movq -0x20(%rbp), %rax
movss 0x9901(%rip), %xmm0     # 0xe070
movss %xmm0, 0x60(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ColinHarker[P]ltsim/src/cpu.cpp
// Function: Cpu::Cpu()
Cpu::Cpu()
{
   parseModelName();
   parseVersion();
   m_NumCores = getNumberCores();
   addCores();
   parseCores();
   run();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x5ad0
movq -0x20(%rbp), %rdi
movl $0xffffffff, 0x68(%rdi) # imm = 0xFFFFFFFF
addq $0x70, %rdi
movq %rdi, -0x28(%rbp)
callq 0x5b10
movq -0x20(%rbp), %rdi
callq 0x54a0
jmp 0x5433
movq -0x30(%rbp), %rdi
callq 0x5600
jmp 0x543e
movq -0x30(%rbp), %rdi
callq 0x5720
movl %eax, -0x34(%rbp)
jmp 0x544c
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, 0x68(%rdi)
callq 0x58b0
jmp 0x545d
movq -0x30(%rbp), %rdi
callq 0x5960
jmp 0x5468
movq -0x30(%rbp), %rdi
callq 0x59e0
jmp 0x5473
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3d40
movq -0x20(%rbp), %rdi
callq 0x3cf0
movq -0x10(%rbp), %rdi
callq 0x3510
// File: ColinHarker[P]ltsim/src/cpu.cpp
// Function: Cpu::parseModelName()
void Cpu::parseModelName()
{
   std::ifstream proc_cpuinfo("/proc/cpuinfo");
   proc_cpuinfo.seekg(std::ios::beg);
   for(int i = 0; i < 4; ++i)  // skip the first 4 lines of /cpuinfo
   {
      proc_cpuinfo.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
   }
   string mn;

   // skip the first 13 characters of the cpu model name
   proc_cpuinfo.ignore(13);
   std::getline(proc_cpuinfo, mn);

   m_CpuReader.setModelName(mn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x258(%rbp)
leaq 0x8bec(%rip), %rsi      # 0xe0ad
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x3540
xorl %eax, %eax
movl %eax, %esi
leaq -0x220(%rbp), %rdi
callq 0x4780
jmp 0x54e4
movq -0x220(%rbp), %rsi
movq -0x218(%rbp), %rdx
leaq -0x210(%rbp), %rdi
callq 0x33c0
jmp 0x5500
movl $0x0, -0x230(%rbp)
cmpl $0x4, -0x230(%rbp)
jge 0x5558
callq 0x47c0
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movl $0xa, %edx
callq 0x31e0
jmp 0x552e
jmp 0x5530
movl -0x230(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x230(%rbp)
jmp 0x550a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x55e0
leaq -0x250(%rbp), %rdi
callq 0x3430
leaq -0x210(%rbp), %rdi
movl $0xd, %esi
callq 0x3050
jmp 0x5577
leaq -0x210(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x3070
jmp 0x558c
movq -0x258(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x4350
jmp 0x55a1
leaq -0x250(%rbp), %rdi
callq 0x31d0
leaq -0x210(%rbp), %rdi
callq 0x30b0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x31d0
leaq -0x210(%rbp), %rdi
callq 0x30b0
movq -0x228(%rbp), %rdi
callq 0x3510
nopl (%rax,%rax)
// File: ColinHarker[P]ltsim/src/cpu.cpp
// Function: Cpu::parseVersion()
void Cpu::parseVersion()
{
   std::ifstream proc_cpuinfo("/proc/version");
   string        ret;
   std::getline(proc_cpuinfo, ret);

   // only grabbing the information wanted from /version
   string vers           = ret.substr(0, COLS);
   m_CpuReader.m_version = vers;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x278(%rbp)
leaq 0x8ab0(%rip), %rsi      # 0xe0d1
leaq -0x210(%rbp), %rdi
movq %rdi, -0x270(%rbp)
movl $0x8, %edx
callq 0x3540
leaq -0x230(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x3430
movq -0x270(%rbp), %rdi
movq -0x268(%rbp), %rsi
callq 0x3070
jmp 0x5661
movq 0xf938(%rip), %rax      # 0x14fa0
movslq (%rax), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x260(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x32e0
jmp 0x5684
movq -0x278(%rbp), %rdi
addq $0x20, %rdi
leaq -0x260(%rbp), %rsi
callq 0x3030
jmp 0x569d
leaq -0x260(%rbp), %rdi
callq 0x31d0
leaq -0x230(%rbp), %rdi
callq 0x31d0
leaq -0x210(%rbp), %rdi
callq 0x30b0
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
jmp 0x56fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x31d0
leaq -0x230(%rbp), %rdi
callq 0x31d0
leaq -0x210(%rbp), %rdi
callq 0x30b0
movq -0x238(%rbp), %rdi
callq 0x3510
// File: ColinHarker[P]ltsim/src/cpu.cpp
// Function: Cpu::getNumberCores()
int Cpu::getNumberCores()
{
   std::array<char, 4>                      buffer;
   string                                   result;
   std::unique_ptr<FILE, decltype(&pclose)> pipe(popen("nproc", "r"), pclose);
   if(!pipe)
   {
      throw std::runtime_error("popen() failed!");
   }
   if(fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr)
   {
      return std::atoi(buffer.data());
   }
   else
      return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3430
leaq 0x897c(%rip), %rdi      # 0xe0bb
leaq 0x8c01(%rip), %rsi      # 0xe347
callq 0x30d0
movq %rax, -0x70(%rbp)
jmp 0x5751
movq -0x70(%rbp), %rsi
movq 0xf874(%rip), %rax      # 0x14fd0
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x5c20
leaq -0x48(%rbp), %rdi
callq 0x5c60
testb $0x1, %al
jne 0x57f4
movl $0x10, %edi
callq 0x3180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
leaq 0x892c(%rip), %rsi      # 0xe0c1
callq 0x3100
jmp 0x579c
movq -0x78(%rbp), %rdi
movq 0xf849(%rip), %rsi      # 0x14ff0
movq 0xf812(%rip), %rdx      # 0x14fc0
callq 0x3500
jmp 0x58af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x589d
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x3220
jmp 0x5894
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5894
leaq -0x14(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x5c90
movq -0x98(%rbp), %rdi
movq %rax, -0x90(%rbp)
callq 0x5cb0
movl %eax, -0x84(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5cc0
movq -0x90(%rbp), %rdi
movl -0x84(%rbp), %esi
movq %rax, %rdx
callq 0x34b0
movq %rax, -0x80(%rbp)
jmp 0x5841
movq -0x80(%rbp), %rax
cmpq $0x0, %rax
je 0x5868
leaq -0x14(%rbp), %rdi
callq 0x5c90
movq %rax, %rdi
callq 0x34a0
movl %eax, -0x4(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0x5876
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x64(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5cf0
leaq -0x38(%rbp), %rdi
callq 0x31d0
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x5cf0
leaq -0x38(%rbp), %rdi
callq 0x31d0
movq -0x50(%rbp), %rdi
callq 0x3510
nop
// File: ColinHarker[P]ltsim/src/cpu.cpp
// Function: Cpu::addCores()
void Cpu::addCores()
{
   for(int i = 1; i <= m_NumCores; i++)
   {
      CpuReader cpr;
      cpr.run(i);
      m_Cores.emplace_back(cpr);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x90(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x68(%rcx), %eax
jg 0x5945
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x5ad0
movq -0x98(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4650
jmp 0x5901
movq -0x90(%rbp), %rdi
addq $0x70, %rdi
leaq -0x78(%rbp), %rsi
callq 0x5d60
jmp 0x5917
leaq -0x78(%rbp), %rdi
callq 0x3cf0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x58d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3cf0
jmp 0x594e
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3510
nopw (%rax,%rax)