LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/Unigrams.cc
// Function: Unigrams::resegment_sents(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, StringSet const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>&)
flt_type
Unigrams::resegment_sents(const vector<string> &sents,
                          const StringSet &vocab,
                          map<string, flt_type> &new_freqs)
{
    new_freqs.clear();
    flt_type ll = 0.0;

    for (auto sent = sents.begin(); sent != sents.end(); ++sent) {

        map<string, flt_type> stats;
        flt_type curr_ll = segf(vocab, *sent, stats, this->utf8);

        if (stats.size() == 0) {
            cerr << "warning, no segmentation for sentence: " << *sent << endl;
            continue;
        }

        ll += curr_ll;

        // Update statistics
        for (auto it = stats.begin(); it != stats.end(); ++it)
            new_freqs[it->first] += it->second;
    }

    return ll;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, -0x48(%rbp)
movq %rsi, %r14
movq %rdi, -0x40(%rbp)
movq %rcx, %rdi
callq 0x1c04a
movq (%r14), %r13
movq %r14, -0x38(%rbp)
cmpq 0x8(%r14), %r13
je 0x1e6b8
xorpd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x78(%rbp), %r15
leaq -0x80(%rbp), %r14
movl $0x0, -0x78(%rbp)
xorl %eax, %eax
movq %rax, -0x70(%rbp)
movq %r15, -0x68(%rbp)
movq %r15, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
movzbl 0x8(%rax), %ecx
movq -0x48(%rbp), %rdi
movq %r13, %rsi
movq %r14, %r12
movq %r14, %rdx
callq *(%rax)
cmpq $0x0, -0x58(%rbp)
je 0x1e643
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movq -0x68(%rbp), %r14
cmpq %r15, %r14
je 0x1e699
leaq 0x20(%r14), %rsi
movsd 0x40(%r14), %xmm0
movsd %xmm0, -0x50(%rbp)
movq %rbx, %rdi
callq 0x1b05e
movsd -0x50(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0x4280
movq %rax, %r14
cmpq %r15, %rax
jne 0x1e60d
jmp 0x1e699
movl $0x27, %edx
movq 0x15999(%rip), %rdi     # 0x33fe8
leaq 0x829e(%rip), %rsi      # 0x268f4
callq 0x4400
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq 0x1597e(%rip), %rdi     # 0x33fe8
callq 0x4400
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4370
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4260
movq %r12, %rdi
callq 0x5cea
movq %r12, %r14
addq $0x20, %r13
movq -0x38(%rbp), %rax
cmpq 0x8(%rax), %r13
jne 0x1e5bb
jmp 0x1e6c1
xorpd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e6d7
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x5cea
movq %rbx, %rdi
callq 0x4650
nop
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/Unigrams.cc
// Function: Unigrams::get_sum(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>> const&)
flt_type
Unigrams::get_sum(const map<string, flt_type> &freqs)
{
    flt_type total = 0.0;
    for (auto iter = freqs.cbegin(); iter != freqs.cend(); ++iter) {
        if (std::isinf(iter->second) || std::isnan(iter->second)) continue;
        total += iter->second;
    }
    return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq $0x8, %rbx
xorpd %xmm0, %xmm0
cmpq %rbx, %rax
je 0x1e74b
movsd %xmm0, -0x18(%rbp)
movabsq $0x7ff0000000000000, %r14 # imm = 0x7FF0000000000000
movq 0x40(%rax), %xmm0
movq %xmm0, %rcx
btrq $0x3f, %rcx
cmpq %r14, %rcx
jge 0x1e73c
movsd -0x18(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
movq %rax, %rdi
callq 0x4410
cmpq %rbx, %rax
jne 0x1e71a
jmp 0x1e750
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/Unigrams.cc
// Function: Unigrams::get_cost(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>> const&, double)
flt_type
Unigrams::get_cost(const map<string, flt_type> &freqs,
                   flt_type densum)
{
    flt_type total = 0.0;
    flt_type tmp = 0.0;
    densum = log(densum);
    for (auto iter = freqs.cbegin(); iter != freqs.cend(); ++iter) {
        tmp = iter->second * (log(iter->second)-densum);
        if (!std::isnan(tmp)) total += tmp;
    }
    return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x42f0
movq 0x18(%rbx), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x1e7e4
xorps %xmm1, %xmm1
movsd %xmm0, -0x28(%rbp)
movaps %xmm1, -0x20(%rbp)
movsd 0x40(%r14), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x42f0
subsd -0x28(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movapd -0x20(%rbp), %xmm3
movapd %xmm3, %xmm2
addsd %xmm0, %xmm2
cmpunordsd %xmm0, %xmm0
movapd %xmm0, %xmm1
andnpd %xmm2, %xmm1
andpd %xmm3, %xmm0
orpd %xmm1, %xmm0
movapd %xmm0, -0x20(%rbp)
movq %r14, %rdi
callq 0x4410
movaps -0x20(%rbp), %xmm0
movq %rax, %r14
movaps %xmm0, %xmm1
cmpq %rbx, %rax
jne 0x1e786
jmp 0x1e7e7
xorps %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/Unigrams.cc
// Function: Unigrams::cutoff(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>&, double, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, unsigned int)
int
Unigrams::cutoff(map<string, flt_type> &vocab,
                 flt_type limit,
                 const set<string> &stoplist,
                 unsigned int min_length)
{
    int nremovals = 0;
    auto iter = vocab.begin();
    while (iter != vocab.end()) {
        if (iter->second <= limit
            && get_factor_length(iter->first, this->utf8) >= min_length
            && stoplist.find(iter->first) == stoplist.end()) {
                vocab.erase(iter++);
                nremovals++;
        }
        else ++iter;
    }
    return nremovals;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, -0x50(%rbp)
movq 0x18(%rsi), %r15
movq %rsi, -0x40(%rbp)
leaq 0x8(%rsi), %r14
cmpq %r14, %r15
je 0x1e8f1
movl %ecx, %ebx
movq %rdx, %r13
movq %rdi, %r12
leaq 0x8(%rdx), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x2c(%rbp)
movq %rdi, -0x38(%rbp)
movsd -0x50(%rbp), %xmm0
ucomisd 0x40(%r15), %xmm0
jb 0x1e8ac
leaq 0x20(%r15), %rsi
movq 0x28(%r15), %rax
cmpb $0x1, 0x8(%r12)
jne 0x1e894
testq %rax, %rax
je 0x1e898
movq (%rsi), %rdx
xorl %edi, %edi
xorl %ecx, %ecx
movb (%rdx,%rdi), %r9b
movl $0x1, %r8d
testb %r9b, %r9b
jns 0x1e888
movl $0x4, %r8d
cmpb $-0x11, %r9b
ja 0x1e888
cmpb $-0x20, %r9b
movl $0x2, %r8d
sbbl $-0x1, %r8d
addl %r8d, %edi
incl %ecx
cmpq %rdi, %rax
ja 0x1e85f
jmp 0x1e89a
movl %eax, %ecx
jmp 0x1e89a
xorl %ecx, %ecx
cmpl %ebx, %ecx
jb 0x1e8ac
movq %r13, %rdi
callq 0x10d38
cmpq -0x48(%rbp), %rax
je 0x1e8c2
movq %r15, %rdi
callq 0x4280
movq %rax, %r15
cmpq %r14, %r15
jne 0x1e836
jmp 0x1e8f8
movq %r15, %rdi
callq 0x4280
movl %ebx, %r12d
movq %r13, %rbx
movq %rax, %r13
movq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x214d4
incl -0x2c(%rbp)
movq %r13, %r15
movq %rbx, %r13
movl %r12d, %ebx
movq -0x38(%rbp), %r12
jmp 0x1e8b7
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/defs.hh
// Function: sub_log_domain_probs(double, double)
static flt_type sub_log_domain_probs(flt_type a, flt_type b) {
    flt_type delta = b - a;
    if (delta > 0) {
      fprintf(stderr, "invalid call to sub_log_domain_probs, a should be bigger than b (a=%f,b=%f)\n",a,b);
      exit(1);
    }
    return a + log1p(-exp(delta));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
ja 0x1f688
callq 0x4660
xorpd 0x71a7(%rip), %xmm0     # 0x26820
callq 0x46e0
addsd 0x6e2a(%rip), %xmm0     # 0x264b0
popq %rbp
retq
callq 0x4bb6
nop
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/Bigrams.cc
// Function: Bigrams::normalize(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>>>>&)
void
Bigrams::normalize(transitions_t &trans_stats)
{
    for (auto srcit = trans_stats.begin(); srcit != trans_stats.end(); ++srcit) {
        flt_type normalizer = MIN_FLOAT;
        for (auto tgtit = srcit->second.begin(); tgtit != srcit->second.end(); ++tgtit)
            if (normalizer == MIN_FLOAT) normalizer = tgtit->second;
            else normalizer = add_log_domain_probs(normalizer, tgtit->second);
        for (auto tgtit = srcit->second.begin(); tgtit != srcit->second.end(); ++tgtit)
            tgtit->second -= normalizer;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x22410
movq 0x58(%r14), %r15
leaq 0x48(%r14), %r12
movsd 0x44bb(%rip), %xmm2     # 0x26800
cmpq %r12, %r15
je 0x223ce
movsd 0x44aa(%rip), %xmm1     # 0x26800
ucomisd 0x44a2(%rip), %xmm1     # 0x26800
movsd 0x40(%r15), %xmm3
jne 0x2236f
jp 0x2236f
movapd %xmm3, -0x30(%rbp)
jmp 0x223b5
movapd %xmm1, %xmm2
subsd %xmm3, %xmm2
movapd %xmm2, %xmm0
xorpd 0x449d(%rip), %xmm0     # 0x26820
movapd %xmm0, %xmm4
cmpltsd %xmm2, %xmm4
andpd %xmm4, %xmm1
andnpd %xmm3, %xmm4
orpd %xmm1, %xmm4
movapd %xmm4, -0x30(%rbp)
minsd %xmm2, %xmm0
callq 0x4660
callq 0x46e0
addsd -0x30(%rbp), %xmm0
movapd %xmm0, -0x30(%rbp)
movq %r15, %rdi
callq 0x4280
movq %rax, %r15
movapd -0x30(%rbp), %xmm2
movapd %xmm2, %xmm1
cmpq %r12, %rax
jne 0x22356
movq 0x58(%r14), %rax
cmpq %r12, %rax
movapd %xmm2, -0x30(%rbp)
je 0x223fc
movsd 0x40(%rax), %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, 0x40(%rax)
movq %rax, %rdi
callq 0x4280
movapd -0x30(%rbp), %xmm2
cmpq %r12, %rax
jne 0x223dc
movq %r14, %rdi
callq 0x4280
movq %rax, %r14
cmpq %rbx, %rax
jne 0x22335
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/Bigrams.cc
// Function: Bigrams::remove_transitions(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>>>>&)
void
Bigrams::remove_transitions(vector<string> &to_remove,
                            transitions_t &transitions)
{
    for (auto it = to_remove.begin(); it != to_remove.end(); ++it)
        transitions.erase(*it);

    for (auto srcit = transitions.begin(); srcit != transitions.end(); ++srcit)
        for (auto it = to_remove.begin(); it != to_remove.end(); ++it)
            srcit->second.erase(*it);

    for (auto srcit = transitions.begin(); srcit != transitions.end();)
        if (srcit->second.size() == 0) transitions.erase(srcit++);
        else ++srcit;

    normalize(transitions);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
cmpq 0x8(%rdi), %r15
je 0x229c5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x23f10
movq %rbx, %rdi
movq %rax, %rsi
callq 0x23fc2
addq $0x20, %r15
cmpq 0x8(%r14), %r15
jne 0x229a5
movq 0x18(%rbx), %r15
movq %rbx, -0x30(%rbp)
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x22a13
movq (%r14), %r12
cmpq 0x8(%r14), %r12
je 0x22a03
leaq 0x40(%r15), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x24096
movq %r13, %rdi
movq %rax, %rsi
callq 0x24148
addq $0x20, %r12
cmpq 0x8(%r14), %r12
jne 0x229e3
movq %r15, %rdi
callq 0x4280
movq %rax, %r15
cmpq %rbx, %rax
jne 0x229d6
movq -0x30(%rbp), %r13
movq 0x18(%r13), %r14
cmpq %rbx, %r14
je 0x22a47
movq 0x68(%r14), %r12
movq %r14, %rdi
callq 0x4280
movq %rax, %r15
testq %r12, %r12
jne 0x22a3f
movq %r13, %rdi
movq %r14, %rsi
callq 0x241fc
movq %r15, %r14
cmpq %rbx, %r15
jne 0x22a20
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22312
nop
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/Bigrams.cc
// Function: Bigrams::cutoff(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>> const&, double, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>>>>&, MultiStringFactorGraph&)
int
Bigrams::cutoff(const map<string, flt_type> &unigram_stats,
                flt_type cutoff,
                transitions_t &transitions,
                MultiStringFactorGraph &msfg)
{
    vector<string> to_remove;
    for (auto it = unigram_stats.begin(); it != unigram_stats.end(); ++it)
        if (it->second < cutoff && it->first.length() > 2) to_remove.push_back(it->first);

    remove_transitions(to_remove, transitions);

    for (unsigned int i=0; i<to_remove.size(); i++)
        msfg.remove_arcs(to_remove[i]);

    return to_remove.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movsd %xmm0, -0x48(%rbp)
movq %rdi, %r15
xorpd %xmm0, %xmm0
movapd %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq 0x18(%rdi), %r12
addq $0x8, %r15
cmpq %r15, %r12
je 0x22c0a
leaq -0x40(%rbp), %r13
movsd -0x48(%rbp), %xmm0
ucomisd 0x40(%r12), %xmm0
jbe 0x22bfa
cmpq $0x3, 0x28(%r12)
jb 0x22bfa
leaq 0x20(%r12), %rsi
movq %r13, %rdi
callq 0x7f8c
movq %r12, %rdi
callq 0x4410
movq %rax, %r12
cmpq %r15, %rax
jne 0x22bd7
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x22988
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %r14
subq %rax, %r14
je 0x22c56
movl $0x1, %r15d
xorl %esi, %esi
shlq $0x5, %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x12308
movl %r15d, %esi
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %r14
subq %rax, %r14
sarq $0x5, %r14
incl %r15d
cmpq %rsi, %r14
ja 0x22c2b
jmp 0x22c5a
sarq $0x5, %r14
leaq -0x40(%rbp), %rdi
callq 0x5d54
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x22c79
jmp 0x22c79
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x5d54
movq %rbx, %rdi
callq 0x4650
nop
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/Bigrams.cc
// Function: Bigrams::transition_count(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>>>> const&)
int
Bigrams::transition_count(const transitions_t &transitions)
{
    int count = 0;
    for (auto srcit = transitions.cbegin(); srcit != transitions.cend(); ++srcit)
        for (auto tgtit = srcit->second.cbegin(); tgtit != srcit->second.cend(); ++tgtit)
            count++;
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r15
addq $0x8, %rbx
xorl %r14d, %r14d
cmpq %rbx, %r15
je 0x22f46
movq 0x58(%r15), %rax
leaq 0x48(%r15), %r12
cmpq %r12, %rax
je 0x22f36
incl %r14d
movq %rax, %rdi
callq 0x4410
jmp 0x22f24
movq %r15, %rdi
callq 0x4410
movq %rax, %r15
cmpq %rbx, %rax
jne 0x22f1c
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/Bigrams.cc
// Function: Bigrams::reverse_transitions(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>>>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>>>>&)
void
Bigrams::reverse_transitions(const transitions_t &transitions,
                             transitions_t &reverse_transitions)
{
    reverse_transitions.clear();
    for (auto srcit = transitions.cbegin(); srcit != transitions.cend(); ++srcit)
        for (auto tgtit = srcit->second.cbegin(); tgtit != srcit->second.cend(); ++tgtit)
            reverse_transitions[tgtit->first][srcit->first] = tgtit->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1c532
movq 0x18(%r14), %r15
addq $0x8, %r14
movq %r14, -0x30(%rbp)
cmpq %r14, %r15
je 0x23035
movq 0x58(%r15), %r12
leaq 0x48(%r15), %r14
cmpq %r14, %r12
je 0x23024
leaq 0x20(%r15), %r13
leaq 0x20(%r12), %rsi
movsd 0x40(%r12), %xmm0
movsd %xmm0, -0x38(%rbp)
movq %rbx, %rdi
callq 0x1b3fa
movq %rax, %rdi
movq %r13, %rsi
callq 0x1b05e
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r12, %rdi
callq 0x4410
movq %rax, %r12
cmpq %r14, %rax
jne 0x22fe7
movq %r15, %rdi
callq 0x4410
movq %rax, %r15
cmpq -0x30(%rbp), %rax
jne 0x22fd6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/Bigrams.cc
// Function: Bigrams::get_backpointers(MultiStringFactorGraph const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>&, unsigned int)
void
Bigrams::get_backpointers(const MultiStringFactorGraph &msfg,
                          map<string, set<string> > &backpointers,
                          unsigned int minlen)
{
    backpointers.clear();
    for (auto it = msfg.string_end_nodes.begin(); it != msfg.string_end_nodes.end(); ++it) {
        set<string> factors;
        msfg.collect_factors(it->first, factors);
        for (auto fit = factors.begin(); fit != factors.end(); ++fit) {
            if ((*fit).length() < minlen) continue;
            backpointers[*fit].insert(it->first);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x24240
movq 0x50(%r15), %rax
movq %r15, -0x38(%rbp)
leaq 0x40(%r15), %rcx
movq %rcx, -0x30(%rbp)
cmpq %rcx, %rax
je 0x236a7
leaq -0x68(%rbp), %r12
movl %r14d, %r15d
leaq -0x70(%rbp), %r14
movl $0x0, -0x68(%rbp)
xorl %ecx, %ecx
movq %rcx, -0x60(%rbp)
movq %r12, -0x58(%rbp)
movq %r12, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
movq %rax, -0x40(%rbp)
leaq 0x20(%rax), %r13
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x13096
movq -0x58(%rbp), %r14
cmpq %r12, %r14
je 0x23688
cmpq %r15, 0x28(%r14)
jb 0x23678
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x23ca6
movq %rax, %rdi
movq %r13, %rsi
callq 0x14092
movq %r14, %rdi
callq 0x4410
movq %rax, %r14
cmpq %r12, %rax
jne 0x2365b
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x5c80
movq -0x40(%rbp), %rdi
callq 0x4410
cmpq -0x30(%rbp), %rax
jne 0x23622
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x236b8
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x5c80
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/src/Bigrams.cc
// Function: Bigrams::init_candidates_freq(unsigned int, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>>&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
int
Bigrams::init_candidates_freq(unsigned int n_candidates,
                              const map<string, flt_type> &unigram_stats,
                              map<string, flt_type> &candidates,
                              const set<string> &stoplist)
{
    vector<pair<string, flt_type> > sorted_stats;
    Unigrams::sort_vocab(unigram_stats, sorted_stats, false);

    for (auto it = sorted_stats.begin(); it != sorted_stats.end(); ++it) {
        if (stoplist.find(it->first) != stoplist.end()) continue;
        candidates[it->first] = 0.0;
        if (candidates.size() >= n_candidates) break;
    }

    return candidates.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %rax
movl %edi, %r12d
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rax, %rdi
xorl %edx, %edx
callq 0x1dd68
movq -0x40(%rbp), %r15
cmpq -0x38(%rbp), %r15
je 0x23748
leaq 0x8(%r14), %r13
movl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x10d38
cmpq %r13, %rax
jne 0x2373e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b05e
movq $0x0, (%rax)
cmpq %r12, 0x28(%rbx)
jae 0x23748
addq $0x28, %r15
cmpq -0x38(%rbp), %r15
jne 0x23716
movl 0x28(%rbx), %ebx
leaq -0x40(%rbp), %rdi
callq 0x1fd8a
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x23769
jmp 0x23769
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1fd8a
movq %rbx, %rdi
callq 0x4650
nop
// File: /workspace/github_cpp_makefile_star2_O1/ELD[P]HackAssembler/src/parser.cpp
// Function: hack::Parser::Parser(std::istream&)
Parser::Parser(std::istream& file) : _file(file)
    {
        _pc = -1;
        _mem = 16;
        _currentCommand = "";
        _fileHead = _file.tellg();
        _lCommand.assign("\\((.*)\\)", std::regex_constants::icase);
        _aCommand.assign("\\@([\\w*|\\d*]*).*", std::regex_constants::icase);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rbp
movq %rbp, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r14
movl $0x10, %r12d
movl %r12d, 0x28(%rdi)
addq $0x30, %rdi
callq 0x55d0
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r13)
leaq 0x48(%r13), %r15
movl %r12d, 0x48(%r13)
leaq 0x50(%r13), %rdi
callq 0x55d0
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r13)
leaq 0x78(%r13), %r12
movq %r12, %rdi
callq 0x17044
movabsq $0x10ffffffff, %rax     # imm = 0x10FFFFFFFF
movq %rax, 0x70(%r13)
movq 0x10(%r13), %rdx
leaq 0x107b6(%rip), %rcx     # 0x181e0
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5460
movq (%r13), %rdi
callq 0x5510
movq %rax, 0x68(%r13)
leaq 0x1071d(%rip), %rsi     # 0x18168
leaq 0x1071e(%rip), %rdx     # 0x18170
movq %r14, %rdi
movl $0x1, %ecx
callq 0x923a
leaq 0x1070b(%rip), %rsi     # 0x18171
leaq 0x10714(%rip), %rdx     # 0x18181
movq %r15, %rdi
movl $0x1, %ecx
callq 0x923a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7a90
movq %rax, %r13
jmp 0x7a9b
movq %rax, %r13
movq %r12, %rdi
callq 0x7144
movq %r15, %rdi
callq 0x7124
movq %r14, %rdi
callq 0x7124
movq (%rbx), %rdi
cmpq %rbp, %rdi
je 0x7abf
movq (%rbp), %rsi
incq %rsi
callq 0x52c0
movq %r13, %rdi
callq 0x5530
nop
// File: /workspace/github_cpp_makefile_star2_O1/ELD[P]HackAssembler/src/parser.cpp
// Function: hack::Parser::commandType() const
COMMAND_TYPE Parser::commandType() const
    {
        if (std::regex_match(_currentCommand, _lCommand)) {
            return L_COMMAND;
        } else if (std::regex_match(_currentCommand, _aCommand)) {
            return A_COMMAND;
        }

        return C_COMMAND;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %rcx
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
xorl %r8d, %r8d
callq 0x14438
movl %eax, %ebp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7d0d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
xorl %eax, %eax
testb %bpl, %bpl
jne 0x7d5a
leaq 0x48(%rbx), %rcx
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
xorl %r8d, %r8d
callq 0x14438
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7d50
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movzbl %bl, %ecx
movl $0x2, %eax
subl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x7d63
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7d7c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5530
// File: /workspace/github_cpp_makefile_star2_O1/ELD[P]HackAssembler/src/parser.cpp
// Function: hack::Parser::trimCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Parser::trimCommand(std::string& commandToTrim)
    {
        if (commandToTrim.size() > 0) {
            auto firstPos = commandToTrim.find_first_not_of(' ');
            auto lastPos = commandToTrim.find_last_not_of(' ');
            commandToTrim = commandToTrim.substr(firstPos, (lastPos - firstPos + 1));

            commandToTrim.erase(std::remove(commandToTrim.begin(), commandToTrim.end(), '\r'), commandToTrim.end());
        }
    }

// Assembly:
cmpq $0x0, 0x8(%rsi)
je 0x7e29
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x5280
movq %rax, %r14
movq %rbx, %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0x51f0
subq %r14, %rax
leaq 0x1(%rax), %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x52f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5370
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x7dfe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
movq %rsp, %rdx
movb $0xd, (%rdx)
callq 0x16b2f
movq %rax, %rcx
subq (%rbx), %rcx
movq %rcx, 0x8(%rbx)
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ELD[P]HackAssembler/src/parser.cpp
// Function: hack::Parser::getSymbol[abi:cxx11]()
std::string Parser::getSymbol()
    {
        if (commandType() == A_COMMAND) {
            auto first = _currentCommand.find_first_not_of("@");
            return _currentCommand.substr(first);
        } else if (commandType() == L_COMMAND) {
            auto first = _currentCommand.find_first_not_of("(");
            auto second = _currentCommand.find_last_not_of(")");
            return _currentCommand.substr(first, second - first + 1);
        }

        return "";
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7cc8
cmpl $0x1, %eax
jne 0x7f4c
addq $0x8, %r14
leaq 0x10262(%rip), %rsi     # 0x1818d
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x54e0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
jmp 0x7fbb
movq %r14, %rdi
callq 0x7cc8
testl %eax, %eax
je 0x7f73
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1027a(%rip), %rdx     # 0x181e0
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x72c6
jmp 0x7fc0
addq $0x8, %r14
leaq 0x10211(%rip), %rsi     # 0x1818f
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x54e0
movq %rax, %r15
leaq 0x10aab(%rip), %rsi     # 0x18a42
movl $0x1, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x5480
subq %r15, %rax
leaq 0x1(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x52f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ELD[P]HackAssembler/src/parser.cpp
// Function: hack::Parser::getDestBits[abi:cxx11]()
std::string Parser::getDestBits()
    {
        if (commandType() != C_COMMAND) {
            return "";
        }


        auto index = _currentCommand.find("=");

        if (index == std::string::npos) {
            return DestTable::lookup[""];
        }

        auto dest = _currentCommand.substr(0, index);

        return DestTable::lookup[dest];
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7cc8
cmpl $0x2, %eax
jne 0x8051
addq $0x8, %r14
leaq 0x101a0(%rip), %rsi     # 0x18191
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x5520
cmpq $-0x1, %rax
je 0x806c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x52f0
leaq 0x1a708(%rip), %rdi     # 0x22728
movq %r15, %rsi
callq 0x8e2a
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x7236
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x80b8
jmp 0x80c5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x10181(%rip), %rdx     # 0x181e0
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x72c6
jmp 0x80c5
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x10164(%rip), %rdx     # 0x181e0
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x72c6
leaq 0x1a69a(%rip), %rdi     # 0x22728
movq %rsp, %rsi
callq 0x8dae
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x7236
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x80c5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x8103
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
jne 0x80f6
jmp 0x8103
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8103
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5530
nop
// File: /workspace/github_cpp_makefile_star2_O1/ELD[P]HackAssembler/src/parser.cpp
// Function: hack::Parser::getJumpBits[abi:cxx11]()
std::string Parser::getJumpBits()
    {
        if (commandType() != C_COMMAND) {
            return "";
        }

        auto semiColonPos = _currentCommand.find(";");

        if (semiColonPos == std::string::npos) {
            return JumpTable::lookup[""];
        }

        auto jump = _currentCommand.substr(semiColonPos + 1);

        return JumpTable::lookup[jump];
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7cc8
cmpl $0x2, %eax
jne 0x83e1
addq $0x8, %r14
leaq 0xfe1a(%rip), %rsi      # 0x18193
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x5520
cmpq $-0x1, %rax
je 0x83fc
incq %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x52f0
leaq 0x1a430(%rip), %rdi     # 0x227e0
movq %r15, %rsi
callq 0x8e2a
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x7236
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x8448
jmp 0x8455
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xfdf1(%rip), %rdx      # 0x181e0
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x72c6
jmp 0x8455
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xfdd4(%rip), %rdx      # 0x181e0
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x72c6
leaq 0x1a3c2(%rip), %rdi     # 0x227e0
movq %rsp, %rsi
callq 0x8dae
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x7236
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x8455
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x8493
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
jne 0x8486
jmp 0x8493
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8493
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5530
nop
// File: /workspace/github_cpp_makefile_star2_O1/ELD[P]HackAssembler/src/parser.cpp
// Function: hack::Parser::collectLabels()
void Parser::collectLabels()
    {
        while (advance()) {
            if (commandType() == L_COMMAND) {
                if (_symbols.contains(getSymbol())) {
                    continue;
                }

                _symbols.addSymbol(getSymbol(), _pc);
            }
        }

        rewind();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x7adc
testb %al, %al
je 0x8586
leaq 0x78(%rbx), %r14
leaq 0x10(%rsp), %r12
movq %rsp, %r15
movq %rbx, %rdi
callq 0x7cc8
testl %eax, %eax
jne 0x857a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7f08
movq %r14, %rdi
movq %r15, %rsi
callq 0x173de
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8546
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x857a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7f08
movl 0x70(%rbx), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1735a
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x857a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x7adc
testb %al, %al
jne 0x850c
movq %rbx, %rdi
callq 0x84c0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x859d
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x85b6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5530
// File: /workspace/github_cpp_makefile_star2_O1/Thomas1995[P]Rentz/src/bots/bot.cpp
// Function: Bot::Init(int, int)
void Bot::Init(int index, int players) {
	debug("Getting initialized\n");

	this->index = index;
	this->playersCount = players;
	scores.resize(players, 0);

	if(games.empty())
	for(int i = 1; i <= MinigameCount; ++i)
		games.push_back(static_cast<Minigame>(i));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0xfbaa(%rip), %r15      # 0x12fd0
movq (%r15), %rcx
leaq 0x9c0a(%rip), %rdi      # 0xd03a
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x33e0
movq (%r15), %rdi
callq 0x32b0
movl %r14d, 0xc(%rbx)
movl %ebp, 0x8(%rbx)
leaq 0x38(%rbx), %rdi
movslq %ebp, %rsi
leaq 0x4(%rsp), %rdx
andl $0x0, (%rdx)
callq 0x43b2
movq 0x68(%rbx), %rax
cmpq 0x70(%rbx), %rax
jne 0x349d
leaq 0x68(%rbx), %r14
pushq $0x1
popq %rbp
movq %rsp, %r15
movl %ebp, (%rsp)
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x348b
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x70(%rbx)
jmp 0x3496
movq %r14, %rdi
movq %r15, %rdx
callq 0x4bc4
incl %ebp
cmpl $0x8, %ebp
jne 0x3472
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Thomas1995[P]Rentz/src/bots/bot.cpp
// Function: Bot::RoundStart(int)
void Bot::RoundStart(int gameIndex) {
	// Update current game and call virtual method
	currentGame = static_cast<Minigame>(gameIndex);
	
	//TODO: Remove this line
	dumpInfo();

	onRoundStart();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x30(%rdi)
callq 0x34a8
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x20(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/Thomas1995[P]Rentz/src/bots/bot.cpp
// Function: Bot::PlayCard()
Card Bot::PlayCard() {
	// Play a card and erase it from your hand

	//TODO: Remove this line
	dumpInfo();

  Card use = onPlayCard();
  hand.erase(find(hand.begin(), hand.end(), use)); //TODO: Check if card in hand
  return use;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x34a8
movq (%rbx), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq 0x50(%rbx), %rdi
movq 0x58(%rbx), %rsi
movq %r14, %rdx
callq 0x4ee6
addq $0x8, %rax
movq 0x58(%rbx), %rcx
cmpq %rcx, %rax
je 0x37ce
subq %rax, %rcx
sarq $0x3, %rcx
testq %rcx, %rcx
jle 0x37ce
incq %rcx
movb 0x4(%rax), %dl
movb %dl, -0x4(%rax)
movl (%rax), %edx
movl %edx, -0x8(%rax)
addq $0x8, %rax
decq %rcx
cmpq $0x1, %rcx
jg 0x37b6
addq $-0x8, 0x58(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Thomas1995[P]Rentz/src/bots/bot.cpp
// Function: Bot::ChooseMinigame()
Minigame Bot::ChooseMinigame() {
	// Choose a minigame
	Minigame game = onChooseMinigame();
	auto it = find(games.begin(), games.end(), game);

	assert(it != games.end());

	games.erase(it); //TODO: Check if game in games

	return game;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
movq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rsi
callq 0x4e4d
movq 0x70(%rbx), %rdx
cmpq %rdx, %rax
je 0x421e
leaq 0x4(%rax), %rsi
cmpq %rdx, %rsi
je 0x420f
subq %rsi, %rdx
movq %rax, %rdi
callq 0x3380
addq $-0x4, 0x70(%rbx)
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x8ebc(%rip), %rdi      # 0xd0e1
leaq 0x8ec7(%rip), %rsi      # 0xd0f3
leaq 0x8ec8(%rip), %rcx      # 0xd0fb
movl $0x39, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/Thomas1995[P]Rentz/src/bots/bot.cpp
// Function: Bot::RoundEnd(std::vector<int, std::allocator<int>>)
void Bot::RoundEnd(std::vector<int> scores) {
	// Round ended; empty your hand, update scores

	hand.clear();
	cardsOnTable.clear();
	this->scores = scores;

	onRoundEnd();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rax
cmpq %rax, 0x58(%rdi)
je 0x425c
movq %rax, 0x58(%rbx)
movq 0x80(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0x4273
movq %rax, 0x88(%rbx)
leaq 0x38(%rbx), %rdi
callq 0x44d0
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x38(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/Thomas1995[P]Rentz/src/util/card.cpp
// Function: Card::to_string[abi:cxx11]() const
std::string Card::to_string() const {
    std::string s;

    switch(value) {
        case 10: s += "10"; break;
        case 11: s += "J"; break;
        case 12: s += "Q"; break;
        case 13: s += "K"; break;
        case 14: s += "A"; break;
        default: s += (char)(value + '0'); break;
    }

    s += suite;

    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl (%rsi), %eax
leal -0xa(%rax), %ecx
cmpl $0x5, %ecx
jae 0x530a
movl %ecx, %eax
leaq 0x7f03(%rip), %rcx      # 0xd1fc
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x33d0
jmp 0x5317
addb $0x30, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x31d0
movsbl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x31d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x5343
movq (%r15), %rsi
incq %rsi
callq 0x3240
movq %r14, %rdi
callq 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Thomas1995[P]Rentz/src/util/card.cpp
// Function: Card::suiteIndex() const
int Card::suiteIndex() const {
  for(int i = 0; i < 4; ++i) {
    if(suites[i] == suite)
      return i;
  }
  assert(false);
}

// Assembly:
movb 0x4(%rdi), %cl
xorl %eax, %eax
movl $0x0, %edx
cmpb $0x44, %cl
je 0x54c6
xorl %edx, %edx
leaq 0x7d4c(%rip), %rsi      # 0xd1f4
cmpq $0x3, %rdx
je 0x54cb
leaq 0x1(%rdx), %rax
cmpb %cl, 0x1(%rdx,%rsi)
movq %rax, %rdx
jne 0x54a8
leaq -0x1(%rax), %rcx
cmpq $0x3, %rcx
setae %dl
testb %dl, %dl
jne 0x54cb
retq
pushq %rax
leaq 0x7cf2(%rip), %rdi      # 0xd1c5
leaq 0x7cf1(%rip), %rsi      # 0xd1cb
leaq 0x7cf3(%rip), %rcx      # 0xd1d4
movl $0x3f, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/Thomas1995[P]Rentz/src/util/card.cpp
// Function: Card::encode() const
uint8_t Card::encode() const {
  uint8_t ret = value;
  //the last 4 bits represent the value
  ret |= suiteIndex() << 4;
  //the next 2 bits represent the suite
  return ret;
}

// Assembly:
pushq %rbx
movl (%rdi), %ebx
callq 0x5490
shll $0x4, %eax
orl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Thomas1995[P]Rentz/src/util/card.cpp
// Function: Card::getAllCards()
std::vector<Card> Card::getAllCards() {
      std::vector<Card> allCards;

      for(int i=lowestCard;i<=14;++i)
          for(char j=0;j<4;++j)
            allCards.push_back(Card(i, Card::suites[(int)j]));

      return allCards;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl 0xdcf9(%rip), %ebp      # 0x13218
cmpl $0xe, %ebp
jg 0x555d
leaq 0x7cc9(%rip), %r15      # 0xd1f4
leaq 0x8(%rsp), %r14
xorl %r12d, %r12d
movsbl (%r12,%r15), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x4fd0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55fa
incq %r12
cmpq $0x4, %r12
jne 0x5533
incl %ebp
cmpl $0xf, %ebp
jne 0x5530
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5584
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3240
movq %r14, %rdi
callq 0x33a0