LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: aalto-speech[P]ftk/util/Ngram.cc
// Function: Ngram::score(int, int, double&)
int
Ngram::score(int node_idx, int word, double &score)
{
    while (true) {
        int tmp = find_node(node_idx, word);
        if (tmp != -1) {
            node_idx = tmp;
            score += nodes[node_idx].prob;
            if (nodes[node_idx].first_arc == -1)
                return nodes[node_idx].backoff_node;
            else
                return node_idx;
        }
        else {
            score += nodes[node_idx].backoff_prob;
            node_idx = nodes[node_idx].backoff_node;
        }
    }

    throw string("Problem in assigning an n-gram score.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x11fd0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0x11f79
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
movq -0x30(%rbp), %rdi
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x20(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
cmpl $-0x1, 0xc(%rax)
jne 0x11f71
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x11fbb
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11fbb
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
movq -0x30(%rbp), %rdi
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x20(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x11efe
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aalto-speech[P]ftk/util/Ngram.cc
// Function: Ngram::find_node(int, int)
int
Ngram::find_node(int node_idx, int word)
{
    int first_arc = nodes[node_idx].first_arc;
    if (first_arc == -1) return -1;
    int last_arc = nodes[node_idx].last_arc+1;

    auto lower_b=lower_bound(arc_words.begin()+first_arc, arc_words.begin()+last_arc, word);
    int arc_idx = lower_b-arc_words.begin();
    if (arc_idx == last_arc || *lower_b != word) return -1;
    return arc_target_nodes[arc_idx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x1200f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x120e6
movq -0x60(%rbp), %rdi
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
movq -0x60(%rbp), %rdi
movl 0x10(%rax), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
addq $0x90, %rdi
callq 0x13750
movq %rax, -0x38(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x13780
movq -0x60(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x90, %rdi
callq 0x13750
movq %rax, -0x48(%rbp)
movslq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x13780
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x13700
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x90, %rdi
callq 0x13750
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x137c0
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x120c4
leaq -0x28(%rbp), %rdi
callq 0x13800
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
je 0x120cd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x120e6
movq -0x60(%rbp), %rdi
addq $0xa8, %rdi
movslq -0x4c(%rbp), %rsi
callq 0x13820
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: aalto-speech[P]ftk/util/Ngram.cc
// Function: Ngram::score(int, int, float&)
int
Ngram::score(int node_idx, int word, float &score)
{
    while (true) {
        int tmp = find_node(node_idx, word);
        if (tmp != -1) {
            node_idx = tmp;
            score += nodes[node_idx].prob;
            if (nodes[node_idx].first_arc == -1)
                return nodes[node_idx].backoff_node;
            else
                return node_idx;
        }
        else {
            score += nodes[node_idx].backoff_prob;
            node_idx = nodes[node_idx].backoff_node;
        }
    }

    throw string("Problem in assigning an n-gram score.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x11fd0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0x12185
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
movq -0x30(%rbp), %rdi
movss (%rax), %xmm0
movq -0x20(%rbp), %rax
addss (%rax), %xmm0
movss %xmm0, (%rax)
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
cmpl $-0x1, 0xc(%rax)
jne 0x1217d
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x121c3
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x121c3
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
movq -0x30(%rbp), %rdi
movss 0x4(%rax), %xmm0
movq -0x20(%rbp), %rax
addss (%rax), %xmm0
movss %xmm0, (%rax)
addq $0x78, %rdi
movslq -0x14(%rbp), %rsi
callq 0x136e0
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x1210e
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: aalto-speech[P]ftk/util/str.hh
// Function: str::clean(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*)
inline void clean(std::string &str, const char *chars = " \n\t")
{
    int i;

    // Clean trailing chars
    //
    for (i = str.length(); i > 0; i--)
        if (!strchr(chars, str[i - 1]))
            break;
    str.erase(i);

    // Clean leading chars
    //
    for (i = 0; i < (int)str.length(); i++)
        if (!strchr(chars, str[i]))
            break;
    str.erase(0, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45e0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x13d6d
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x47f0
movq -0x20(%rbp), %rdi
movsbl (%rax), %esi
callq 0x4150
cmpq $0x0, %rax
jne 0x13d60
jmp 0x13d6d
jmp 0x13d62
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13d2c
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movq $-0x1, %rdx
callq 0x40e0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45e0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x13dd7
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x47f0
movq -0x30(%rbp), %rdi
movsbl (%rax), %esi
callq 0x4150
cmpq $0x0, %rax
jne 0x13dca
jmp 0x13dd7
jmp 0x13dcc
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13d88
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x40e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: aalto-speech[P]ftk/util/Ngram.hh
// Function: Ngram::NgramInfo::operator<(Ngram::NgramInfo const&) const
bool operator<(const NgramInfo &ngri) const
        {
            if (ngram.size() != ngri.ngram.size())
                throw std::string("Comparing ngrams of different order");
            for (unsigned int i=0; i<ngram.size(); i++)
                if (ngram[i] < ngri.ngram[i]) return true;
                else if (ngri.ngram[i] < ngram[i]) return false;
            std::cerr << "Warning, comparing same n-grams" << std::endl;
            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x14210
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14210
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x1808e
movb $0x1, -0x2d(%rbp)
movl $0x20, %edi
callq 0x41e0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x46f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x4e510(%rip), %rsi     # 0x6654c
callq 0x4550
jmp 0x18043
movq -0x60(%rbp), %rdi
movb $0x0, -0x2d(%rbp)
leaq 0x7bcfe(%rip), %rsi     # 0x93d50
movq 0x7bf47(%rip), %rdx     # 0x93fa0
callq 0x46b0
jmp 0x1815f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x4420
testb $0x1, -0x2d(%rbp)
jne 0x18080
jmp 0x18089
movq -0x60(%rbp), %rdi
callq 0x42f0
jmp 0x18156
movl $0x0, -0x34(%rbp)
movq -0x48(%rbp), %rdi
movl -0x34(%rbp), %eax
movq %rax, -0x68(%rbp)
callq 0x14210
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x18125
movq -0x48(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x18160
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x18160
movq %rax, %rcx
movl -0x6c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x180e2
movb $0x1, -0x1(%rbp)
jmp 0x1814b
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x18160
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x18160
movq %rax, %rcx
movl -0x70(%rbp), %eax
cmpl (%rcx), %eax
jge 0x18113
movb $0x0, -0x1(%rbp)
jmp 0x1814b
jmp 0x18115
jmp 0x18117
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x18095
movq 0x7bebc(%rip), %rdi     # 0x93fe8
leaq 0x4e43d(%rip), %rsi     # 0x66570
callq 0x43c0
movq %rax, %rdi
movq 0x7be56(%rip), %rsi     # 0x93f98
callq 0x4400
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x46e0
nop
// File: aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::StringSet(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&)
StringSet::StringSet(const std::map<std::string, flt_type> &vocab)
{
    max_factor_length = 0;
    learn_map(vocab);
    root_node.arcs.resize(character_count, nullptr);
    for (auto it = vocab.cbegin(); it !=vocab.cend(); ++it)
        add(it->first, it->second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
xorl %esi, %esi
callq 0x1b150
movq -0x40(%rbp), %rdi
movl $0x0, 0x18(%rdi)
movq -0x10(%rbp), %rsi
callq 0x19f60
jmp 0x19eac
movq -0x48(%rbp), %rdi
movslq 0x11c(%rdi), %rsi
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x1b1b0
jmp 0x19eca
movq -0x10(%rbp), %rdi
callq 0x1b260
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b2c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1b290
testb $0x1, %al
jne 0x19ef7
jmp 0x19f49
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1b2f0
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x1b2f0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movsd 0x20(%rax), %xmm0
callq 0x1a2a0
jmp 0x19f25
jmp 0x19f27
leaq -0x30(%rbp), %rdi
callq 0x1b320
jmp 0x19ed7
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1b350
jmp 0x19f4f
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x46e0
nopl (%rax,%rax)
// File: aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
void
StringSet::add(const string &factor, flt_type cost)
{
    Node *node = &root_node;
    int i=0;
    for (; i < (int)factor.length()-1; i++)
        node = insert(factor[i], "" , 0.0, node);
    insert(factor[i], factor, cost, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45e0
movq %rax, %rcx
movl -0x6c(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1a39c
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x4430
movb (%rax), %al
movb %al, -0x79(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x46f0
movq -0x78(%rbp), %rdx
leaq 0x4c1e2(%rip), %rsi     # 0x664f7
leaq -0x48(%rbp), %rdi
callq 0x4550
jmp 0x1a320
movq -0x68(%rbp), %rdi
movb -0x79(%rbp), %al
movq -0x20(%rbp), %rcx
movsbl %al, %esi
leaq -0x48(%rbp), %rdx
xorps %xmm0, %xmm0
callq 0x1a500
movq %rax, -0x88(%rbp)
jmp 0x1a343
movq -0x88(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4828
leaq -0x49(%rbp), %rdi
callq 0x4420
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1a2cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1a391
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4828
leaq -0x49(%rbp), %rdi
callq 0x4420
jmp 0x1a3cd
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x4430
movq -0x68(%rbp), %rdi
movb (%rax), %al
movq -0x10(%rbp), %rdx
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rcx
movsbl %al, %esi
callq 0x1a500
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x46e0
nopw %cs:(%rax,%rax)
// File: aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::clear(StringSet::Node*)
void
StringSet::clear(Node *node)
{
    for (auto ait = node->arcs.begin(); ait != node->arcs.end(); ++ait) {
        if (*ait != nullptr) {
            clear((*ait)->target_node);
            delete (*ait)->target_node;
            delete *ait;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b4d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b540
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1b500
testb $0x1, %al
jne 0x1a468
jmp 0x1a4f6
leaq -0x18(%rbp), %rdi
callq 0x1b5d0
cmpq $0x0, (%rax)
je 0x1a4e6
leaq -0x18(%rbp), %rdi
callq 0x1b5d0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movq 0x28(%rax), %rsi
callq 0x1a420
leaq -0x18(%rbp), %rdi
callq 0x1b5d0
movq (%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1a4bc
movq -0x30(%rbp), %rdi
callq 0x1b350
movq -0x30(%rbp), %rdi
callq 0x43a0
leaq -0x18(%rbp), %rdi
callq 0x1b5d0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1a4e4
movq -0x38(%rbp), %rdi
callq 0x1b670
movq -0x38(%rbp), %rdi
callq 0x43a0
jmp 0x1a4e6
jmp 0x1a4e8
leaq -0x18(%rbp), %rdi
callq 0x1b5f0
jmp 0x1a445
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::find_arc(char, StringSet::Node const*) const
StringSet::Arc*
StringSet::find_arc(char letter,
                    const StringSet::Node *node) const
{
    unsigned char remapped = remap_char(letter);
    if (remapped < node->arcs.size())
        return node->arcs[remapped];
    else
        return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x1b370
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b390
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1a78b
movq -0x20(%rbp), %rdi
movzbl -0x21(%rbp), %eax
movl %eax, %esi
callq 0x1b430
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a793
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::includes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool
StringSet::includes(const string &factor) const
{
    const StringSet::Node *node = &root_node;
    StringSet::Arc *arc = nullptr;
    for (unsigned int i=0; i<factor.length(); i++) {
        arc = find_arc(factor[i], node);
        if (arc == nullptr) return false;
        node = arc->target_node;
    }
    if (arc->factor.length() == 0) return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x1a87f
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x4430
movq -0x38(%rbp), %rdi
movb (%rax), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0x1a730
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1a868
movb $0x0, -0x1(%rbp)
jmp 0x1a89c
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a81b
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x45e0
cmpq $0x0, %rax
jne 0x1a898
movb $0x0, -0x1(%rbp)
jmp 0x1a89c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::get_score(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
flt_type
StringSet::get_score(const string &factor) const
{
    const StringSet::Node *node = &root_node;
    StringSet::Arc *arc = nullptr;
    for (unsigned int i=0; i<factor.length(); i++) {
        arc = find_arc(factor[i], node);
        if (arc == nullptr) throw string("could not find factor");
        node = arc->target_node;
    }
    if (arc->factor.length() == 0) throw string("could not find factor");
    return arc->cost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x1a9cb
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4430
movq -0x40(%rbp), %rdi
movb (%rax), %al
movq -0x18(%rbp), %rdx
movsbl %al, %esi
callq 0x1a730
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1a9b1
movb $0x1, -0x35(%rbp)
movl $0x20, %edi
callq 0x41e0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x46f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x4bc67(%rip), %rsi     # 0x665c6
callq 0x4550
jmp 0x1a966
movq -0x60(%rbp), %rdi
movb $0x0, -0x35(%rbp)
leaq 0x793db(%rip), %rsi     # 0x93d50
movq 0x79624(%rip), %rdx     # 0x93fa0
callq 0x46b0
jmp 0x1aa77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x4420
testb $0x1, -0x35(%rbp)
jne 0x1a9a3
jmp 0x1a9ac
movq -0x60(%rbp), %rdi
callq 0x42f0
jmp 0x1aa6e
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1a8de
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x45e0
cmpq $0x0, %rax
jne 0x1aa5c
movb $0x1, -0x37(%rbp)
movl $0x20, %edi
callq 0x41e0
movq %rax, -0x70(%rbp)
movq %rax, -0x78(%rbp)
leaq -0x36(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x46f0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x4bbb6(%rip), %rsi     # 0x665c6
callq 0x4550
jmp 0x1aa17
movq -0x78(%rbp), %rdi
movb $0x0, -0x37(%rbp)
leaq 0x7932a(%rip), %rsi     # 0x93d50
movq 0x79573(%rip), %rdx     # 0x93fa0
callq 0x46b0
jmp 0x1aa77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x36(%rbp), %rdi
callq 0x4420
testb $0x1, -0x37(%rbp)
jne 0x1aa51
jmp 0x1aa5a
movq -0x78(%rbp), %rdi
callq 0x42f0
jmp 0x1aa6e
movq -0x20(%rbp), %rax
movsd 0x30(%rax), %xmm0
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x46e0
nopw (%rax,%rax)
// File: aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
flt_type
StringSet::remove(const string &factor)
{
    StringSet::Node *node = &root_node;
    StringSet::Arc *arc = nullptr;

    for (unsigned int i=0; i<factor.length(); i++) {
        arc = find_arc(factor[i], node);
        if (arc == nullptr) throw string("could not remove factor");
        node = arc->target_node;
    }
    arc->factor.clear();
    flt_type cost = arc->cost;
    arc->cost = 0.0;
    return cost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45e0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x1ab8e
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4430
movq -0x48(%rbp), %rdi
movb (%rax), %al
movq -0x18(%rbp), %rdx
movsbl %al, %esi
callq 0x1a730
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1ab74
movb $0x1, -0x35(%rbp)
movl $0x20, %edi
callq 0x41e0
movq %rax, -0x60(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x25(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x46f0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x4bab4(%rip), %rsi     # 0x665dc
callq 0x4550
jmp 0x1ab2f
movq -0x68(%rbp), %rdi
movb $0x0, -0x35(%rbp)
leaq 0x79212(%rip), %rsi     # 0x93d50
movq 0x7945b(%rip), %rdx     # 0x93fa0
callq 0x46b0
jmp 0x1abc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x4420
testb $0x1, -0x35(%rbp)
jne 0x1ab69
jmp 0x1ab72
movq -0x68(%rbp), %rdi
callq 0x42f0
jmp 0x1abc0
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1aaab
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x4510
movq -0x20(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movsd -0x40(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x46e0
nopl (%rax)
// File: aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::collect_arcs(std::vector<StringSet::Arc*, std::allocator<StringSet::Arc*>>&)
void
StringSet::collect_arcs(vector<Arc*> &arcs)
{
    vector<Node*> nodes_to_process;
    nodes_to_process.push_back(&root_node);

    while (nodes_to_process.size() > 0) {
        Node *node = nodes_to_process.back();
        nodes_to_process.pop_back();

        for (auto ait = node->arcs.begin(); ait != node->arcs.end(); ++ait) {
            if (*ait == nullptr) continue;
            arcs.push_back(*ait);
            nodes_to_process.push_back((*ait)->target_node);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1b690
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1b6b0
jmp 0x1af5c
jmp 0x1af5e
leaq -0x28(%rbp), %rdi
callq 0x1b6e0
cmpq $0x0, %rax
jbe 0x1b02e
leaq -0x28(%rbp), %rdi
callq 0x1b700
movq (%rax), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1b740
movq -0x48(%rbp), %rdi
callq 0x1b4d0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1b540
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1b500
testb $0x1, %al
jne 0x1afb7
jmp 0x1b029
leaq -0x50(%rbp), %rdi
callq 0x1b5d0
cmpq $0x0, (%rax)
jne 0x1afdf
jmp 0x1b01b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1b850
jmp 0x1b03d
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1b5d0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x1b770
jmp 0x1affe
leaq -0x50(%rbp), %rdi
callq 0x1b5d0
movq (%rax), %rsi
addq $0x28, %rsi
leaq -0x28(%rbp), %rdi
callq 0x1b7e0
jmp 0x1b019
jmp 0x1b01b
leaq -0x50(%rbp), %rdi
callq 0x1b5f0
jmp 0x1af97
jmp 0x1af5e
leaq -0x28(%rbp), %rdi
callq 0x1b850
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x46e0
nopw %cs:(%rax,%rax)
// File: aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::string_count()
unsigned int
StringSet::string_count()
{
    vector<Arc*> arcs;
    collect_arcs(arcs);

    unsigned int count = 0;
    for (auto ait = arcs.begin(); ait != arcs.end(); ++ait) {
        if (*ait == nullptr) continue;
        if ((*ait)->factor.length() > 0) count++;
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1b4b0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x1af20
jmp 0x1b080
movl $0x0, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1b4d0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1b540
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1b500
testb $0x1, %al
jne 0x1b0b4
jmp 0x1b10d
leaq -0x38(%rbp), %rdi
callq 0x1b5d0
cmpq $0x0, (%rax)
jne 0x1b0dc
jmp 0x1b102
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1b610
jmp 0x1b125
leaq -0x38(%rbp), %rdi
callq 0x1b5d0
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x45e0
cmpq $0x0, %rax
jbe 0x1b100
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1b102
leaq -0x38(%rbp), %rdi
callq 0x1b5f0
jmp 0x1b094
movl -0x30(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1b610
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x46e0
nop
// File: aalto-speech[P]ftk/src/FactorGraph.cc
// Function: FactorGraph::set_text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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)
void
FactorGraph::set_text(const string &text,
                      const string &start_end_symbol,
                      const map<string, flt_type> &vocab,
                      int maxlen)
{
    this->text.assign(text);
    this->start_end_symbol.assign(start_end_symbol);
    if (text.length() == 0) return;

    vector<unordered_set<fg_node_idx_t> > incoming(text.size()+1); // (pos in text, source pos)

    // Create all nodes
    incoming[0].insert(0);
    create_nodes(text, vocab, maxlen, incoming);

    // No possible segmentations
    if (incoming[text.size()].size() == 0) {
        nodes.clear();
        return;
    }

    prune_and_create_arcs(incoming);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4720
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x4720
movq -0x10(%rbp), %rdi
callq 0x45e0
cmpq $0x0, %rax
jne 0x20775
jmp 0x20896
movq -0x10(%rbp), %rdi
callq 0x42d0
incq %rax
movq %rax, -0x88(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x23ca0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x23cc0
jmp 0x207ab
leaq -0x41(%rbp), %rdi
callq 0x23d30
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0x234d0
movq %rax, %rdi
movw $0x0, -0x56(%rbp)
leaq -0x56(%rbp), %rsi
callq 0x23510
movb %dl, -0x91(%rbp)
movq %rax, -0x90(%rbp)
jmp 0x207e2
movq -0x78(%rbp), %rdi
movb -0x91(%rbp), %al
movq -0x90(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x40(%rbp), %r8
callq 0x20d50
jmp 0x20810
movq -0x10(%rbp), %rdi
callq 0x42d0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x234d0
movq %rax, %rdi
callq 0x234f0
cmpq $0x0, %rax
jne 0x20877
movq -0x78(%rbp), %rdi
addq $0x40, %rdi
callq 0x23d50
movl $0x1, -0x6c(%rbp)
jmp 0x2088d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x23d30
jmp 0x2089f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x23d70
jmp 0x2089f
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x218a0
jmp 0x20886
movl $0x0, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x23d70
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x46e0
nopl (%rax,%rax)
// File: aalto-speech[P]ftk/src/FactorGraph.cc
// Function: FactorGraph::set_text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, StringSet const&)
void
FactorGraph::set_text(const string &text,
                      const string &start_end_symbol,
                      const StringSet &vocab)
{
    this->text.assign(text);
    this->start_end_symbol.assign(start_end_symbol);
    if (text.length() == 0) return;

    vector<unordered_set<fg_node_idx_t> > incoming(text.size()+1); // (pos in text, source pos)

    // Create all nodes
    incoming[0].insert(0);
    create_nodes(text, vocab, incoming);

    // No possible segmentations
    if (incoming[text.size()].size() == 0) {
        nodes.clear();
        return;
    }

    prune_and_create_arcs(incoming);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4720
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x4720
movq -0x10(%rbp), %rdi
callq 0x45e0
cmpq $0x0, %rax
jne 0x20c21
jmp 0x20d39
movq -0x10(%rbp), %rdi
callq 0x42d0
incq %rax
movq %rax, -0x80(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x23ca0
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x23cc0
jmp 0x20c51
leaq -0x39(%rbp), %rdi
callq 0x23d30
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x234d0
movq %rax, %rdi
movw $0x0, -0x4e(%rbp)
leaq -0x4e(%rbp), %rsi
callq 0x23510
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x20c88
movq -0x70(%rbp), %rdi
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x21590
jmp 0x20cb3
movq -0x10(%rbp), %rdi
callq 0x42d0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x234d0
movq %rax, %rdi
callq 0x234f0
cmpq $0x0, %rax
jne 0x20d1a
movq -0x70(%rbp), %rdi
addq $0x40, %rdi
callq 0x23d50
movl $0x1, -0x64(%rbp)
jmp 0x20d30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x23d30
jmp 0x20d42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x23d70
jmp 0x20d42
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x218a0
jmp 0x20d29
movl $0x0, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x23d70
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x46e0
nopl (%rax,%rax)
// File: aalto-speech[P]ftk/src/defs.hh
// Function: get_character_positions(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned int, std::allocator<unsigned int>>&, bool)
static void get_character_positions(const std::string &word,
                                    std::vector<unsigned int> &positions,
                                    bool utf8=false)
{
    if (utf8)
        get_character_positions_utf8(word, positions);
    else
        get_character_positions_onebyte(word, positions);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x2115c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23130
jmp 0x2119e
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x41a0
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23230
jmp 0x2117c
leaq -0x38(%rbp), %rdi
callq 0x4828
jmp 0x2119e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4828
jmp 0x211a4
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x46e0
nopl (%rax)
// File: aalto-speech[P]ftk/src/FactorGraph.cc
// Function: FactorGraph::num_paths() const
int
FactorGraph::num_paths() const
{

    if (nodes.size() == 0) return 0;
    vector<int> path_counts(nodes.size());
    path_counts[0] = 1;

    for (unsigned int i=0; i<nodes.size(); i++) {
        const FactorGraph::Node &node = nodes[i];
        for (auto arc = node.outgoing.begin(); arc != node.outgoing.end(); ++arc)
            path_counts[(**arc).target_node] += path_counts[i];
    }

    return path_counts.back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x40, %rdi
callq 0x23a90
cmpq $0x0, %rax
jne 0x222c2
movl $0x0, -0x4(%rbp)
jmp 0x22403
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
callq 0x23a90
movq %rax, -0x70(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xc290
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x23f80
jmp 0x222f3
leaq -0x29(%rbp), %rdi
callq 0xc910
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13820
movl $0x1, (%rax)
movl $0x0, -0x40(%rbp)
movq -0x60(%rbp), %rdi
movl -0x40(%rbp), %eax
movq %rax, -0x78(%rbp)
addq $0x40, %rdi
callq 0x23a90
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x223ec
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
movl -0x40(%rbp), %eax
movl %eax, %esi
callq 0x23ff0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x24010
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x24080
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24040
testb $0x1, %al
jne 0x22385
jmp 0x223dc
movl -0x40(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x13820
movl (%rax), %eax
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x240b0
movq (%rax), %rax
movzwl 0x2(%rax), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x13820
movl -0x7c(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x240d0
jmp 0x22361
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0xc910
jmp 0x2240f
jmp 0x223de
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x22316
leaq -0x28(%rbp), %rdi
callq 0x14230
movl (%rax), %eax
movl %eax, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x14140
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x46e0
nopl (%rax,%rax)
// File: aalto-speech[P]ftk/src/FactorGraph.cc
// Function: FactorGraph::advance(std::vector<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::allocator<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::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>>>>&, unsigned short) const
void
FactorGraph::advance(vector<vector<string> > &paths,
                     vector<string> &curr_string,
                     fg_node_idx_t node_idx) const
{
    const FactorGraph::Node &node = nodes[node_idx];

    std::string tmp;
    get_factor(node, tmp);
    curr_string.push_back(tmp);

    if (node_idx == nodes.size()-1) {
        paths.push_back(curr_string);
        return;
    }

    for (auto arc  = node.outgoing.begin(); arc != node.outgoing.end(); ++arc) {
        vector<string> curr_copy(curr_string);
        advance(paths, curr_copy, (**arc).target_node);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x40, %rdi
movzwl -0x1a(%rbp), %eax
movl %eax, %esi
callq 0x23ff0
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4560
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rdx
movq -0x28(%rbp), %rsi
callq 0x240f0
jmp 0x224f5
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xabb0
jmp 0x22504
movq -0x90(%rbp), %rdi
movzwl -0x1a(%rbp), %eax
movq %rax, -0x98(%rbp)
addq $0x40, %rdi
callq 0x23a90
movq %rax, %rcx
movq -0x98(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x2255e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x24160
jmp 0x22541
movl $0x1, -0x58(%rbp)
jmp 0x22608
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2261a
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x24010
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x24080
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x24040
testb $0x1, %al
jne 0x22593
jmp 0x22601
movq -0x18(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x241d0
jmp 0x225a2
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x240b0
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq (%rax), %rax
movzwl 0x2(%rax), %ecx
leaq -0x80(%rbp), %rdx
callq 0x22490
jmp 0x225d6
leaq -0x80(%rbp), %rdi
callq 0x6970
leaq -0x60(%rbp), %rdi
callq 0x240d0
jmp 0x2256f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6970
jmp 0x2261a
movl $0x0, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4828
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x4828
movq -0x50(%rbp), %rdi
callq 0x46e0
nopl (%rax)
// File: aalto-speech[P]ftk/src/FactorGraph.cc
// Function: FactorGraph::remove_arc(FactorGraph::Arc*)
void
FactorGraph::remove_arc(Arc *arc)
{
    auto ait = find(arcs.begin(), arcs.end(), arc);
    arcs.erase(ait);

    Node &src_node = nodes[(*arc).source_node];
    auto sit = find(src_node.outgoing.begin(), src_node.outgoing.end(), arc);
    src_node.outgoing.erase(sit);

    Node &tgt_node = nodes[(*arc).target_node];
    auto tit = find(tgt_node.incoming.begin(), tgt_node.incoming.end(), arc);
    tgt_node.incoming.erase(tit);

    delete arc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
addq $0x58, %rdi
callq 0x24310
movq -0xb0(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x58, %rdi
callq 0x24340
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x242c0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
movq %rcx, -0x18(%rbp)
addq $0x58, %rax
movq %rax, -0xc0(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x243e0
movq -0xc0(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x24370
movq -0xb0(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x40, %rdi
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %esi
callq 0x23ae0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x24310
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x24340
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x242c0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xb8(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x243e0
movq -0xb8(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x24370
movq -0xb0(%rbp), %rdi
movq %rax, -0x68(%rbp)
addq $0x40, %rdi
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, %esi
callq 0x23ae0
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
callq 0x24310
movq %rax, -0x80(%rbp)
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
callq 0x24340
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x242c0
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xa8(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x243e0
movq -0xa8(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x24370
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x227ef
movq -0xa0(%rbp), %rdi
callq 0x43a0
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: aalto-speech[P]ftk/src/defs.hh
// Function: get_character_positions_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned int, std::allocator<unsigned int>>&)
static void get_character_positions_utf8(const std::string &word,
                                         std::vector<unsigned int> &positions)
{
    positions.clear();
    positions.push_back(0);
    unsigned int charpos=0;

    while (charpos<word.length()) {
        unsigned int utfseqlen=0;
        if (!(word[charpos] & 128)) utfseqlen = 1;
        else if ((word[charpos] & 240) == 240) utfseqlen = 4;
        else if ((word[charpos] & 224) == 224) utfseqlen = 3;
        else utfseqlen = 2;
        charpos += utfseqlen;
        positions.push_back(charpos);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x249a0
movq -0x10(%rbp), %rdi
movl $0x0, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x249c0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x23221
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x4430
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x231af
movl $0x1, -0x1c(%rbp)
jmp 0x23206
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x4430
movsbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xf0, %eax
jne 0x231d5
movl $0x4, -0x1c(%rbp)
jmp 0x23204
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x4430
movsbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xe0, %eax
jne 0x231fb
movl $0x3, -0x1c(%rbp)
jmp 0x23202
movl $0x2, -0x1c(%rbp)
jmp 0x23204
jmp 0x23206
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x23b00
jmp 0x23164
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: aalto-speech[P]ftk/src/FactorGraph.hh
// Function: FactorGraph::Arc::operator!=(FactorGraph::Arc&) const
bool operator!=(Arc& rhs) const {
            if (source_node != rhs.source_node) return true;
            if (target_node != rhs.target_node) return true;
            if (cost != rhs.cost) return true;
            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl (%rax), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
je 0x23ef8
movb $0x1, -0x1(%rbp)
jmp 0x23f34
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
je 0x23f12
movb $0x1, -0x1(%rbp)
jmp 0x23f34
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x23f2a
jp 0x23f2a
jmp 0x23f30
movb $0x1, -0x1(%rbp)
jmp 0x23f34
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: aalto-speech[P]ftk/src/MSFG.cc
// Function: MultiStringFactorGraph::~MultiStringFactorGraph()
MultiStringFactorGraph::~MultiStringFactorGraph() {
    vector<Arc*> arcs;
    collect_arcs(arcs);
    for (auto it = arcs.begin(); it != arcs.end(); ++it)
        delete *it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2fb80
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2ce00
jmp 0x2cd40
leaq -0x20(%rbp), %rdi
callq 0x2fba0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2fc10
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fbd0
testb $0x1, %al
jne 0x2cd6d
jmp 0x2cd99
leaq -0x28(%rbp), %rdi
callq 0x2fc40
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x2cd8c
movq -0x48(%rbp), %rdi
callq 0x43a0
jmp 0x2cd8e
leaq -0x28(%rbp), %rdi
callq 0x2fc60
jmp 0x2cd4d
leaq -0x20(%rbp), %rdi
callq 0x2fc80
movq -0x40(%rbp), %rdi
addq $0xc8, %rdi
callq 0x2fce0
movq -0x40(%rbp), %rdi
addq $0x98, %rdi
callq 0x2fd00
movq -0x40(%rbp), %rdi
addq $0x68, %rdi
callq 0x2fd20
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
callq 0x2fd40
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x2fd60
movq -0x40(%rbp), %rdi
callq 0x4828
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x6210
// File: aalto-speech[P]ftk/src/MSFG.cc
// Function: MultiStringFactorGraph::get_paths(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<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::allocator<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
void
MultiStringFactorGraph::get_paths(const string &text,
                                  vector<vector<string> > &paths) const
{
    if (string_end_nodes.find(text) == string_end_nodes.end()) return;
    msfg_node_idx_t end_node = string_end_nodes.at(text);
    vector<string> curr_string;
    advance(paths, curr_string, end_node);
    for (auto it = paths.begin(); it != paths.end(); ++it)
        std::reverse(it->begin(), it->end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x30910
movq -0x80(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x30940
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x308e0
testb $0x1, %al
jne 0x2dde4
jmp 0x2dde9
jmp 0x2dec5
movq -0x80(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x30970
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xa160
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rdx
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %ecx
callq 0x2dee0
jmp 0x2de28
movq -0x18(%rbp), %rdi
callq 0x2bb30
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2b9a0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x30d70
testb $0x1, %al
jne 0x2de55
jmp 0x2debc
leaq -0x60(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x30df0
movq %rax, %rdi
callq 0xb2f0
movq -0x90(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x30df0
movq %rax, %rdi
callq 0xb320
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x30db0
jmp 0x2de98
jmp 0x2de9a
leaq -0x60(%rbp), %rdi
callq 0x30e10
jmp 0x2de35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6970
jmp 0x2dece
leaq -0x48(%rbp), %rdi
callq 0x6970
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x46e0
nopw (%rax,%rax)