LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ynilu[P]elastic/graph.cpp
// Function: Phy_graph::get_reach(std::vector<int, std::allocator<int>>)
int Phy_graph::get_reach(vector<int> path)
{
    int from;
    int to;
    int dis = 0;
    for(unsigned int node_i = 0; node_i < path.size() - 1; node_i++)
    {
        from = path[node_i];
        to = path[node_i + 1];
        dis += get_link(from, to).distance;
    }
    return modlev(dis);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0x38(%rbp)
callq 0xb380
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1a718
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0xb210
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0xb210
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x1a730
movl 0x10(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1a6aa
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1a610
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ynilu[P]elastic/graph.cpp
// Function: Phy_graph::Phy_graph(Graph_info&)
Phy_graph::Phy_graph(Graph_info &g_info)
{
    this->transmission_distance_QPSK = g_info.transmission_distance_QPSK;
    this->transmission_distance_8QAM = g_info.transmission_distance_8QAM;
    this->transmission_distance_16QAM = g_info.transmission_distance_16QAM;
    read_network_file(g_info.graph_file, g_info.num_slots);
    // assign transceivers for each node
    assign_transceivers(g_info.num_OTDM_transceiver, g_info.num_OFDM_transceiver, g_info.transceiver_connection_limit);
    find_candidate_path();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x283a9(%rip), %rax     # 0x42b48
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x1bb20
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
callq 0x1bb40
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x30(%rbp)
callq 0x1bb60
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x88(%rdi)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, 0x84(%rdi)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x80(%rdi)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl 0x8(%rax), %edx
callq 0x1a870
jmp 0x1a80d
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movl 0x10(%rax), %edx
movl 0x1c(%rax), %ecx
callq 0x1ac80
jmp 0x1a825
movq -0x28(%rbp), %rdi
callq 0x1ae90
jmp 0x1a830
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1bb80
movq -0x38(%rbp), %rdi
callq 0x1bba0
movq -0x40(%rbp), %rdi
callq 0x1bbc0
movq -0x18(%rbp), %rdi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: ynilu[P]elastic/graph.cpp
// Function: Phy_graph::DFS_back_trace(int, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, std::__cxx11::list<CandidatePath, std::allocator<CandidatePath>>&, CandidatePath&)
void Phy_graph::DFS_back_trace(int current_node, vector<Parents>& parents, list<CandidatePath>& path_set, CandidatePath& path)
{
    path.path.push_back(current_node);

    if(parents[current_node].empty())
    {
        CandidatePath new_path = path;

        reverse(new_path.path.begin(), new_path.path.end());

        int modulation = get_reach(new_path.path);

        if(modulation != -1)
        {
            new_path.modulation_level = modulation;
            path_set.push_back(new_path);
        }
    }

    for(auto &parent : parents[current_node])
    {
        DFS_back_trace(parent, parents, path_set, path);
    }

    path.path.pop_back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0xc(%rbp), %rsi
callq 0x1c1a0
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1c180
movq %rax, %rdi
callq 0x1c2a0
testb $0x1, %al
jne 0x1b4d8
jmp 0x1b5b8
movq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x1c2e0
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xbf70
movq -0xb8(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0xbfa0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x1c330
jmp 0x1b518
leaq -0x48(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0xd1b0
jmp 0x1b52a
movq -0xb0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1a680
movl %eax, -0xbc(%rbp)
jmp 0x1b545
leaq -0x88(%rbp), %rdi
callq 0xaef0
movl -0xbc(%rbp), %eax
movl %eax, -0x70(%rbp)
cmpl $-0x1, -0x70(%rbp)
je 0x1b59f
movl -0x70(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1c370
jmp 0x1b575
jmp 0x1b59f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1b5aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xaef0
jmp 0x1b5aa
leaq -0x50(%rbp), %rdi
callq 0x1bac0
jmp 0x1b5b8
leaq -0x50(%rbp), %rdi
callq 0x1bac0
jmp 0x1b663
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1c180
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
callq 0xbf70
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rdi
callq 0xbfa0
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xbfd0
testb $0x1, %al
jne 0x1b60b
jmp 0x1b64d
leaq -0x98(%rbp), %rdi
callq 0xc010
movq -0xb0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x1b480
leaq -0x98(%rbp), %rdi
callq 0xc030
jmp 0x1b5f2
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x1c3b0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3340
nopl (%rax)
// File: ynilu[P]elastic/graph.cpp
// Function: Phy_node::Phy_node()
Phy_node::Phy_node()
{
    degree = 0;
    num_available_transmitter = 0;
    num_available_OFDM_transmitter = 0;
    num_available_receiver = 0;
    num_available_OFDM_receiver = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x2747d(%rip), %rax     # 0x42b58
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0xaed0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x1c6d0
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x1c6d0
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x1c6f0
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0x1c6f0
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x2c(%rax)
movl $0x0, 0x30(%rax)
movl $0x0, 0x34(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: ynilu[P]elastic/traffic.cpp
// Function: Traffic::read_source_file(char*)
void Traffic::read_source_file(char* source_file)
{
    fstream fs;

    fs.open(source_file, ios::in);
    if(!fs)
    {
        cerr << "Can't open file\"" << source_file << "\"\n";
        cerr << "Please give source file, program aborting...\n";
        exit(1);
    }

    int node_a, max_num_dest;
    double source_probility;
    while(fs >> node_a >> source_probility >> max_num_dest)
    {
        node_a--;
        source_matrix[node_a] = source_probility;
        num_dest_matrix[node_a] = max_num_dest;
    }

    fs.close();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x3260
movq -0x248(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x31e0
jmp 0x26f58
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x30d0
movb %al, -0x251(%rbp)
jmp 0x26f78
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x26f87
jmp 0x27013
movq 0x1c062(%rip), %rdi     # 0x42ff0
leaq 0x674f(%rip), %rsi      # 0x2d6e4
callq 0x31f0
movq %rax, -0x260(%rbp)
jmp 0x26fa3
movq -0x260(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x31f0
movq %rax, -0x268(%rbp)
jmp 0x26fbc
movq -0x268(%rbp), %rdi
leaq 0x672b(%rip), %rsi      # 0x2d6f5
callq 0x31f0
jmp 0x26fd1
movq 0x1c018(%rip), %rdi     # 0x42ff0
leaq 0x67b5(%rip), %rsi      # 0x2d794
callq 0x31f0
jmp 0x26fe6
movl $0x1, %edi
callq 0x3270
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x3070
jmp 0x27128
jmp 0x27015
leaq -0x220(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x3130
movq %rax, -0x270(%rbp)
jmp 0x27031
movq -0x270(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x31b0
movq %rax, -0x278(%rbp)
jmp 0x2704d
movq -0x278(%rbp), %rdi
leaq -0x234(%rbp), %rsi
callq 0x3130
movq %rax, -0x280(%rbp)
jmp 0x27069
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3280
movb %al, -0x281(%rbp)
jmp 0x27087
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x27093
jmp 0x27105
movq -0x250(%rbp), %rdi
movl -0x230(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x230(%rbp)
movsd -0x240(%rbp), %xmm0
movsd %xmm0, -0x290(%rbp)
addq $0x38, %rdi
movslq -0x230(%rbp), %rsi
callq 0x28440
movsd -0x290(%rbp), %xmm0
movq -0x250(%rbp), %rdi
movsd %xmm0, (%rax)
movl -0x234(%rbp), %eax
movl %eax, -0x288(%rbp)
addq $0x50, %rdi
movslq -0x230(%rbp), %rsi
callq 0xb210
movl -0x288(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x27015
leaq -0x220(%rbp), %rdi
callq 0x3030
jmp 0x27113
leaq -0x220(%rbp), %rdi
callq 0x3070
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: ynilu[P]elastic/traffic.cpp
// Function: Traffic::read_traffic_file(char*)
void Traffic::read_traffic_file(char* traffic_file)
{
    fstream fs;

    fs.open(traffic_file, ios::in);
    if(!fs)
    {
        cerr << "Can't open file\"" << traffic_file << "\"\n";
        cerr << "Please give Traffic file, program aborting...\n";
        exit(1);
    }

    int node_a, node_b;
    double traffic_probility;
    while(fs >> node_a >> node_b >> traffic_probility)
    {
        node_a--;
        node_b--;
        traffic_matrix[node_a][node_b] = traffic_probility;
    }

    fs.close();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x3260
movq -0x248(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x31e0
jmp 0x27188
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x30d0
movb %al, -0x251(%rbp)
jmp 0x271a8
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x271b7
jmp 0x27243
movq 0x1be32(%rip), %rdi     # 0x42ff0
leaq 0x651f(%rip), %rsi      # 0x2d6e4
callq 0x31f0
movq %rax, -0x260(%rbp)
jmp 0x271d3
movq -0x260(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x31f0
movq %rax, -0x268(%rbp)
jmp 0x271ec
movq -0x268(%rbp), %rdi
leaq 0x64fb(%rip), %rsi      # 0x2d6f5
callq 0x31f0
jmp 0x27201
movq 0x1bde8(%rip), %rdi     # 0x42ff0
leaq 0x65b3(%rip), %rsi      # 0x2d7c2
callq 0x31f0
jmp 0x27216
movl $0x1, %edi
callq 0x3270
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x3070
jmp 0x2734b
jmp 0x27245
leaq -0x220(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x3130
movq %rax, -0x270(%rbp)
jmp 0x27261
movq -0x270(%rbp), %rdi
leaq -0x234(%rbp), %rsi
callq 0x3130
movq %rax, -0x278(%rbp)
jmp 0x2727d
movq -0x278(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x31b0
movq %rax, -0x280(%rbp)
jmp 0x27299
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3280
movb %al, -0x281(%rbp)
jmp 0x272b7
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x272c3
jmp 0x27328
movq -0x250(%rbp), %rdi
movl -0x230(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x230(%rbp)
movl -0x234(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x234(%rbp)
movsd -0x240(%rbp), %xmm0
movsd %xmm0, -0x290(%rbp)
addq $0x20, %rdi
movslq -0x230(%rbp), %rsi
callq 0x28460
movq %rax, %rdi
movslq -0x234(%rbp), %rsi
callq 0x28440
movsd -0x290(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x27245
leaq -0x220(%rbp), %rdi
callq 0x3030
jmp 0x27336
leaq -0x220(%rbp), %rdi
callq 0x3070
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x3340
nopw (%rax,%rax)
// File: ynilu[P]elastic/traffic.cpp
// Function: Traffic::delete_event(int)
void Traffic::delete_event(int request_id)
{
    for(list<Event>::iterator it = event_list.begin(); it != event_list.end(); it++)
    {
        if((*it).type == Event::departure && (*it).request_id == request_id)
        {
            event_list.erase(it);
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x68, %rdi
callq 0x28500
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rdi
addq $0x68, %rdi
callq 0xf500
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x28530
testb $0x1, %al
jne 0x27938
jmp 0x2799a
leaq -0x18(%rbp), %rdi
callq 0x10520
cmpl $0x1, 0x8(%rax)
jne 0x27984
leaq -0x18(%rbp), %rdi
callq 0x10520
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x27984
movq -0x40(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x285b0
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x28560
movq %rax, -0x30(%rbp)
jmp 0x2799a
jmp 0x27986
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x285d0
movq %rax, -0x38(%rbp)
jmp 0x27914
addq $0x50, %rsp
popq %rbp
retq
// File: ynilu[P]elastic/traffic.cpp
// Function: Traffic::generate_source()
int Traffic::generate_source()
{
    float p = random_number(nextrand(s_seed));
    int i;
    for(i = 0; i < num_nodes; i++){
        p = p - (float)source_matrix[i];
        if(p <= 0){
            return i;
        }
    }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rsi
addq $0x130, %rsi            # imm = 0x130
callq 0x27ed0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x27f10
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x80(%rcx), %eax
jge 0x27a38
movq -0x20(%rbp), %rdi
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
addq $0x38, %rdi
movslq -0x18(%rbp), %rsi
callq 0x28440
movss -0x24(%rbp), %xmm0
movsd (%rax), %xmm1
cvtsd2ss %xmm1, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jb 0x27a2b
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x27a3e
jmp 0x27a2d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x279da
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ynilu[P]elastic/traffic.cpp
// Function: Traffic::generate_num_dest(int)
int Traffic::generate_num_dest(int max_num_dest)
{
    int num_dest;
    float temp_m = random_number(nextrand(numD_seed));
    if(temp_m <= unicast_percentage){
        num_dest = 1;
    }else{
        num_dest = (int) ( (max_num_dest - 1) * random_number(nextrand(numD_seed)) );
        num_dest += 2;
        //num_dest range : [2,max_num_dest]
    }
    return num_dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rsi
addq $0x140, %rsi            # imm = 0x140
callq 0x27ed0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x27f10
movq -0x20(%rbp), %rax
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm1
movss 0x11c(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x27aa5
movl $0x1, -0x10(%rbp)
jmp 0x27aee
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x24(%rbp)
movq %rdi, %rsi
addq $0x140, %rsi            # imm = 0x140
callq 0x27ed0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x27f10
movaps %xmm0, %xmm1
movss -0x24(%rbp), %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ynilu[P]elastic/traffic.cpp
// Function: Traffic::generate_destination(int)
int Traffic::generate_destination(int source)
{
    float p = random_number(nextrand(s_seed));
    int i;
    for(i = 0;i < num_nodes; i++){
        p = p - (float)traffic_matrix[source][i];
        if(p <= 0){
            return i;
        }
    }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rsi
addq $0x130, %rsi            # imm = 0x130
callq 0x27ed0
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x27f10
movss %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x80(%rcx), %eax
jge 0x27ba7
movq -0x28(%rbp), %rdi
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
addq $0x20, %rdi
movslq -0x14(%rbp), %rsi
callq 0x28460
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x28440
movss -0x2c(%rbp), %xmm0
movsd (%rax), %xmm1
cvtsd2ss %xmm1, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x18(%rbp), %xmm0
jb 0x27b9a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x27bad
jmp 0x27b9c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27b3d
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ynilu[P]elastic/traffic.cpp
// Function: Event::Event()
Event::Event()
{
    request_id = -1;
    source = -1;
    num_dest = -1;
    bandwidth = -1;
    arrival_time = -1;
    holding_time = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x1acdd(%rip), %rax     # 0x42c78
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
callq 0x28a60
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x4c(%rax) # imm = 0xFFFFFFFF
movss 0x57bd(%rip), %xmm0     # 0x2d790
movss %xmm0, 0x50(%rax)
movss 0x57b0(%rip), %xmm0     # 0x2d790
movss %xmm0, 0x54(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ynilu[P]elastic/auxiliary.cpp
// Function: Aux_node::Aux_node(int, Aux_node::Aux_node_type)
Aux_node::Aux_node(int phy_id, Aux_node_type type)
{
    this -> phy_id = phy_id;
    this -> type = type;
    first_in = NULL;
    last_in = NULL;
    first_out = NULL;
    last_out = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0x182bf(%rip), %rcx     # 0x42cb8
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
popq %rbp
retq
nop
// File: ynilu[P]elastic/auxiliary.cpp
// Function: Aux_node::~Aux_node()
Aux_node::~Aux_node()
{
    Aux_link *current;
    Aux_link *next;

    // remove all the incoming links
    current = this -> first_in;
    while(current != NULL)
    {
        next = current -> next_same_to;
        delete current;
        current = next;
    }

    // remove all the outgoing links
    current = this -> first_out;
    while(current != NULL)
    {
        next = current -> next_same_from;
        delete current;
        current = next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1826d(%rip), %rcx     # 0x42cb8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2aa8f
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2aa85
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2aa5a
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2aad0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2aac6
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2aa9b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ynilu[P]elastic/auxiliary.cpp
// Function: Aux_link::Aux_link(Aux_node*, Aux_node*, double, Aux_link::Aux_link_type)
Aux_link::Aux_link(Aux_node* from, Aux_node* to, double weight, Aux_link_type type)
{
    this -> light_path = NULL;
    this -> from = from;
    this -> to = to;
    this -> weight = weight;
    this -> type = type;

    // same_from list
    Aux_link *from_last_out = from -> last_out;
    if(from_last_out == NULL) // list is empty;
    {
        this -> prev_same_from = NULL;
        this -> next_same_from = NULL;
        from -> first_out = this;
        from -> last_out = this;
    }
    else
    {
        this -> prev_same_from = from_last_out;
        this -> next_same_from = NULL;
        from_last_out -> next_same_from = this;
        from -> last_out = this;
    }

    // same_to list
    Aux_link *to_last_in = to -> last_in;
    if(to_last_in == NULL) // list is empty;
    {
        this -> prev_same_to = NULL;
        this -> next_same_to = NULL;
        to -> first_in = this;
        to -> last_in = this;
    }
    else
    {
        this -> prev_same_to = to_last_in;
        this -> next_same_to = NULL;
        to_last_in -> next_same_to = this;
        to -> last_in = this;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x181a1(%rip), %rcx     # 0x42cd8
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x28(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2ab9f
movq -0x40(%rbp), %rcx
movq $0x0, 0x30(%rcx)
movq $0x0, 0x38(%rcx)
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x2abc3
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rax, 0x30(%rcx)
movq $0x0, 0x38(%rcx)
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2abfc
movq -0x40(%rbp), %rcx
movq $0x0, 0x40(%rcx)
movq $0x0, 0x48(%rcx)
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x2ac20
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rax, 0x40(%rcx)
movq $0x0, 0x48(%rcx)
movq -0x38(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kerolloz[P]os/pipe.c
// Function: main
int main() {
  // We use pipes to send output from child to parent

  int fd[2]; // Used to store two ends of pipe
  pipe(fd);
  if (fork() == 0) {
    // child process
    char concat_str[100];
    printf("Hello from child, enter a string: ");
    scanf("%s", concat_str);
    write(fd[1], concat_str, strlen(concat_str) + 1);

    exit(0);
  } else {
    // Parent process
    wait(NULL); // wait the child to finish
    char concat_str[100];
    read(fd[0], concat_str, 100);
    printf("Hello from parent, this is the string you entered: %s\n",
           concat_str);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq -0x8(%rbp), %rdi
callq 0x1060
callq 0x10b0
cmpl $0x0, %eax
jne 0x123b
leaq 0xe1f(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
leaq -0x70(%rbp), %rsi
leaq 0xe30(%rip), %rdi       # 0x2027
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %eax
movl %eax, -0xec(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1040
movl -0xec(%rbp), %edi
movq -0xe8(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x1030
xorl %edi, %edi
callq 0x1090
xorl %eax, %eax
movl %eax, %edi
callq 0x10a0
movl -0x8(%rbp), %edi
leaq -0xe0(%rbp), %rsi
movl $0x64, %edx
callq 0x1070
leaq -0xe0(%rbp), %rsi
leaq 0xdc4(%rip), %rdi       # 0x202a
movb $0x0, %al
callq 0x1050
xorl %eax, %eax
addq $0xf0, %rsp
popq %rbp
retq
// File: oknenavin[P]cxon/examples/../src/cxon/lang/common/bio/io.hxx
// Function: std::enable_if<std::is_integral<int>::value && sizeof (int) == 4, bool>::type cxon::bio::imp::put_<int, std::vector<unsigned char, std::allocator<unsigned char>>>(std::vector<unsigned char, std::allocator<unsigned char>>&, int, unsigned int)
inline auto put_(O& o, T t, unsigned n)
                -> enable_if_t<std::is_integral<T>::value && sizeof(T) == 4, bool>
            {
                byte bs[sizeof(T)];
                    switch (n) {
                        default:    CXON_ASSERT(0, "unexpected");   // LCOV_EXCL_LINE
                                    return false;                   // LCOV_EXCL_LINE
                        case 4:     bs[n - 4] = byte(t >> 24);
                                    bs[n - 3] = byte(t >> 16); CXON_FALLTHROUGH;
                        case 2:     bs[n - 2] = byte(t >>  8); CXON_FALLTHROUGH;
                        case 1:     bs[n - 1] = byte(t >>  0);
                    }
                return poke_(o, bs, n);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x624e
jmp 0x61df
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x623a
jmp 0x61e9
movl -0x18(%rbp), %eax
subl $0x4, %eax
je 0x6212
jmp 0x61f3
leaq 0x52a1(%rip), %rdi      # 0xb49b
leaq 0x529c(%rip), %rsi      # 0xb49d
movl $0x17a, %edx            # imm = 0x17A
leaq 0x5352(%rip), %rcx      # 0xb55f
callq 0x20e0
movl -0xc(%rbp), %eax
sarl $0x18, %eax
movb %al, %cl
movl -0x10(%rbp), %eax
subl $0x4, %eax
movl %eax, %eax
movb %cl, -0x14(%rbp,%rax)
movl -0xc(%rbp), %eax
sarl $0x10, %eax
movb %al, %cl
movl -0x10(%rbp), %eax
subl $0x3, %eax
movl %eax, %eax
movb %cl, -0x14(%rbp,%rax)
movl -0xc(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movl -0x10(%rbp), %eax
subl $0x2, %eax
movl %eax, %eax
movb %cl, -0x14(%rbp,%rax)
movl -0xc(%rbp), %eax
sarl $0x0, %eax
movb %al, %cl
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movb %cl, -0x14(%rbp,%rax)
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl -0x10(%rbp), %edx
callq 0x5e40
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dm4[P]huffman-homework/my_decode.cc
// Function: p(unsigned int, char)
void p(unsigned int a, char cl) {
    unsigned int mask = 1 << (cl - 1);
    for (int i = 0; i < cl; i++) {
        printf("%d", (a & mask)?1:0);
        mask >>= 1;
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movsbl -0x5(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1388
movl -0x4(%rbp), %ecx
andl -0xc(%rbp), %ecx
xorl %esi, %esi
movl $0x1, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0x3c96(%rip), %rdi      # 0x5004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1349
leaq 0x3d2d(%rip), %rdi      # 0x50bc
movb $0x0, %al
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/concurs.c
// Function: main
int
main(int argc, char **argv)
{
    int		timeout = argc > 2 ? atoi(argv[2]) : 0;
    char *const	env_port = getenv("CONCUR_PORT");
    int		port     = env_port ? atoi(env_port) : CONCUR_PORT;
    int		skt	 = sock_bind("", port);

    if (skt < 0) {
	perror("concurs");
	exit(1);
    }

    setvbuf(stdout, NULL, _IOLBF, 0);
    if (argc == 1) record(skt); 
    else play(skt, argv[1], timeout);

    return    0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jle 0x35ee
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x33d0
movl %eax, -0x2c(%rbp)
jmp 0x35f5
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x35f5
movl -0x2c(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq 0x5a02(%rip), %rdi      # 0x9004
callq 0x3340
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3620
movq -0x20(%rbp), %rdi
callq 0x33d0
movl %eax, -0x30(%rbp)
jmp 0x362a
movl $0x14b9, %eax           # imm = 0x14B9
movl %eax, -0x30(%rbp)
jmp 0x362a
movl -0x30(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
leaq 0x5af5(%rip), %rdi      # 0x912f
callq 0x7630
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x365e
leaq 0x59c1(%rip), %rdi      # 0x9010
callq 0x3220
movl $0x1, %edi
callq 0x3330
movq 0x895b(%rip), %rax      # 0xbfc0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
movq %rcx, %rsi
callq 0x3030
cmpl $0x1, -0x8(%rbp)
jne 0x3689
movl -0x28(%rbp), %edi
callq 0x36b0
jmp 0x369c
movl -0x28(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %edx
callq 0x3bc0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/fnvhash.c
// Function: fnv04
uint32_t
fnv04(char const *buf, int len)
{
    // B=2166136261 M=16777619
    uint32_t	hash = 0x811C9DC5;

    for (; --len >= 0; ++buf)
	hash = (hash ^ *(uint8_t const*)buf) * 0x01000193;

    hash += hash << 13;
    hash ^= hash >> 7;
    hash += hash << 3;
    hash ^= hash >> 17;
    hash += hash << 5;

    return  hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x811c9dc5, -0x10(%rbp) # imm = 0x811C9DC5
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jl 0x41f3
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
xorl %ecx, %eax
imull $0x1000193, %eax, %eax  # imm = 0x1000193
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x41c2
movl -0x10(%rbp), %eax
shll $0xd, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shrl $0x7, %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0x3, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shrl $0x11, %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0x5, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/fnvhash.c
// Function: fnv08
uint64_t
fnv08(char const *buf, int len)
{
    uint64_t hash = 0xCBF29CE484222325ULL;

    for (; --len >= 0; ++buf)
	hash = (hash ^ *(uint8_t const*)buf) * 0x00000100000001B3ULL;

    hash ^= hash >> 33;
    hash *= 0xFF51AFD7ED558CCDULL;
    hash ^= hash >> 33;
    hash *= 0xC4CEB9FE1A85EC53ULL;
    hash ^= hash >> 33;

    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movabsq $-0x340d631b7bdddcdb, %rax # imm = 0xCBF29CE484222325
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jl 0x4295
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
xorq %rcx, %rax
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
imulq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4259
movq -0x18(%rbp), %rax
shrq $0x21, %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $-0xae502812aa7333, %rax # imm = 0xFF51AFD7ED558CCD
imulq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x21, %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $-0x3b314601e57a13ad, %rax # imm = 0xC4CEB9FE1A85EC53
imulq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x21, %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/map.c
// Function: map_create
MAP
map_create(map_diff *diff, map_hash *hash, void *context)
{
    MAP    mp = calloc(1, sizeof(*mp));

    *mp = (struct map) {
		diff, hash, context, 0, MINMASK, -1,
		calloc(MINMASK + 1, sizeof(KEYVAL))
	    };

    return mp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x31a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x7, -0x34(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl $0x8, %edi
movl $0x10, %esi
callq 0x31a0
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0x3200
movq -0x20(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/map.c
// Function: map_del
void *
map_del(MAP mp, MKEY key)
{
    int         pos = _find(mp, key), alpha = pos, hole = pos;
    void        *oldval = mp->vdata[pos].val;

    if (!mp->vdata[pos].key)
        return NULL;

    --mp->count;
    if (mp->last > pos)
	mp->last = pos;    //TODO

    do alpha = (alpha - 1) & mp->mask;
    while (mp->vdata[alpha].key);

    while (mp->vdata[pos = (pos + 1) & mp->mask].key) {
        int     want = FNHASH(mp, mp->vdata[pos].key);
        if ((unsigned)(want - alpha) <= (unsigned)(hole - alpha)) {
            mp->vdata[hole] = mp->vdata[pos];
            hole = pos;
        }
    }
    mp->vdata[hole] = (KEYVAL){NULL, NULL};

    return oldval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x48e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x478d
movq $0x0, -0x8(%rbp)
jmp 0x48ca
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x1c(%rbp), %eax
jle 0x47b0
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
jmp 0x47b2
movl -0x20(%rbp), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
andl 0x1c(%rcx), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x47b2
jmp 0x47dd
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rdx
andl 0x1c(%rdx), %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x4890
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movb $0x0, %al
callq *%rcx
movq -0x10(%rbp), %rcx
movslq 0x1c(%rcx), %rcx
andq %rcx, %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
subl -0x20(%rbp), %eax
movl -0x24(%rbp), %ecx
subl -0x20(%rbp), %ecx
cmpl %ecx, %eax
ja 0x488b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x47dd
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/map.c
// Function: find
static int
_find(MAP const mp, MKEY key)
{
    int     pos = FNHASH(mp, key);

    while (mp->vdata[pos].key &&
           mp->fndiff(mp->vdata[pos].key, key, mp->context))
        pos = (pos + 1) & mp->mask;

    return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rcx
movslq 0x1c(%rcx), %rcx
andq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movslq -0x14(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x15(%rbp)
je 0x496a
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movb $0x0, %al
callq *%rcx
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x4973
jmp 0x4985
movl -0x14(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
andl 0x1c(%rcx), %eax
movl %eax, -0x14(%rbp)
jmp 0x4916
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/map.c
// Function: map_next
int
map_next(MAP mp, void const**pkey, void **pval)
{
    do if (++mp->last > mp->mask) return 0;
    while (!mp->vdata[mp->last].key);

    *pkey = mp->vdata[mp->last].key;
    *pval = mp->vdata[mp->last].val;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x20(%rcx)
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jle 0x4a8f
movl $0x0, -0x4(%rbp)
jmp 0x4aff
jmp 0x4a91
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x20(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4a70
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x20(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x20(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/map.c
// Function: map_set
void *
map_set(MAP mp, MKEY key, void *val)
{
    int         pos     = _find(mp, key);
    void        *oldval = mp->vdata[pos].val;

    if (!mp->vdata[pos].key) {    // new entry
        if (IS_FULL(mp)) {
            map_resize(mp, (mp->mask + 1) << 1);
            pos = FNHASH(mp, key);
            while (mp->vdata[pos].key)
                pos = (pos + 1) & mp->mask;
        }

        mp->vdata[pos].key = key;
        ++mp->count;
    }

    mp->vdata[pos].val = val;
    return oldval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x48e0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x4eb4
movq -0x8(%rbp), %rax
imull $0x5, 0x18(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jl 0x4e8d
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
addl $0x1, %esi
shll %esi
callq 0x4b10
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rcx
movslq 0x1c(%rcx), %rcx
andq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x4e8b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
andl 0x1c(%rcx), %eax
movl %eax, -0x1c(%rbp)
jmp 0x4e60
jmp 0x4e8d
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/map.c
// Function: kvs_del
void
kvs_del(KVS sh, const char *key)
{
    char    *ownkey = (char*)(intptr_t)map_key(sh, key);
    if (ownkey) {
        free(map_del(/*(MAP)*/sh, ownkey));
        free(ownkey);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4a10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4f46
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4720
movq %rax, %rdi
callq 0x3320
movq -0x18(%rbp), %rdi
callq 0x3320
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/map.c
// Function: kvs_destroy
void
kvs_destroy(KVS sh)
{
    char        *key, *val;

    kvs_start(sh);
    while (kvs_next(sh, &key, &val))
	free(key), free(val);

    map_destroy(sh);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4fa0
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x4fc0
cmpl $0x0, %eax
je 0x4f8f
movq -0x10(%rbp), %rdi
callq 0x3320
movq -0x18(%rbp), %rdi
callq 0x3320
jmp 0x4f65
movq -0x8(%rbp), %rdi
callq 0x4990
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/map.c
// Function: kvs_load
KVS
kvs_load(char const *file, char sep)
{
    MEMBUF  data = chomp(slurp(file));
    if (nilbuf(data))
        return NULL;

    int     nstrs, i;
    MEMREF  *strv = refsplit(data.ptr, '\n', &nstrs);
    KVS     kvs = kvs_create();
    kvs_resize(kvs, nstrs);

    for (i = 0; i < nstrs; ++i) {
        char *cp = (char*)(intptr_t)strchr(strv[i].ptr, sep);
        if (cp)  {
            *cp++ = 0;
            kvs_set(kvs, strv[i].ptr, cp);
        }
    }

    free(strv);
    buffree(data);
    return  kvs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6f20
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6450
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5110
cmpl $0x0, %eax
je 0x5047
movq $0x0, -0x8(%rbp)
jmp 0x5103
movq -0x28(%rbp), %rdi
movl $0xa, %esi
leaq -0x3c(%rbp), %rdx
callq 0x6cd0
movq %rax, -0x48(%rbp)
callq 0x5130
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x5150
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x50e5
movq -0x48(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movsbl -0x11(%rbp), %esi
callq 0x3100
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x50d8
movq -0x58(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x58(%rbp)
movb $0x0, (%rax)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x58(%rbp), %rdx
callq 0x5180
jmp 0x50da
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x5079
movq -0x48(%rbp), %rdi
callq 0x3320
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x52b0
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/map.c
// Function: kvs_set
void
kvs_set(KVS sh, const char *key, const char *val)
{
    int         pos = _find(sh, key);

    if (sh->vdata[pos].key) {
        free(sh->vdata[pos].val);
        sh->vdata[pos].val = strdup(val);
    } else if (!IS_FULL(sh)) {
        sh->vdata[pos] = (KEYVAL){strdup(key), strdup(val)};
        ++sh->count;
    } else {    // redundantly calls FNHASH:
        map_set(sh, strdup(key), strdup(val));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x48e0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x5201
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x3320
movq -0x18(%rbp), %rdi
callq 0x3460
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x52a0
movq -0x8(%rbp), %rax
imull $0x5, 0x18(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x5270
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3460
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3460
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x529e
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3460
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3460
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x4db0
jmp 0x52a0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: monikakushwaha28[P]Fiduccia_Matthesys-using-c-/Fiduccia_Mattheyses_v1.0.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
vector<string> split(string str, char delimiter) {
	vector<string> internal;
	stringstream ss(str); // Turn the string into a stream.
	string tok;

	while (getline(ss, tok, delimiter)) {
		internal.push_back(tok);
	}
	return internal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rsi, -0x1f0(%rbp)
movq %rdi, -0x1e8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x6960
movl $0x10, %edi
movl $0x8, %esi
callq 0x6b20
movl %eax, -0x1d4(%rbp)
jmp 0x2980
movl -0x1d4(%rbp), %edx
movq -0x1f0(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x22f0
jmp 0x299b
leaq -0x1d0(%rbp), %rdi
callq 0x22a0
movsbl -0x11(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x2360
movq %rax, -0x1f8(%rbp)
jmp 0x29c7
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2270
movb %al, -0x1f9(%rbp)
jmp 0x29e5
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0x29f1
jmp 0x2a48
movq -0x1e8(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x6b40
jmp 0x2a06
jmp 0x29a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x2a86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x2378
leaq -0x1a0(%rbp), %rdi
callq 0x21b0
jmp 0x2a86
movb $0x1, -0x12(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x2378
leaq -0x1a0(%rbp), %rdi
callq 0x21b0
testb $0x1, -0x12(%rbp)
jne 0x2a76
movq -0x1e8(%rbp), %rdi
callq 0x6980
movq -0x1e0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1e8(%rbp), %rdi
callq 0x6980
movq -0x1a8(%rbp), %rdi
callq 0x2350
nop