LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ynilu[P]elastic/simulator.cpp
// Function: relax(Aux_node*, std::unordered_map<Aux_node*, double, std::hash<Aux_node*>, std::equal_to<Aux_node*>, std::allocator<std::pair<Aux_node* const, double>>>&, std::unordered_map<Aux_node*, Aux_link*, std::hash<Aux_node*>, std::equal_to<Aux_node*>, std::allocator<std::pair<Aux_node* const, Aux_link*>>>&, std::unordered_map<Aux_node*, bool, std::hash<Aux_node*>, std::equal_to<Aux_node*>, std::allocator<std::pair<Aux_node* const, bool>>>&, std::queue<Aux_node*, std::deque<Aux_node*, std::allocator<Aux_node*>>>&)
void relax(Aux_node* v, Aux_node2Double& distTo, Aux_node2Aux_link& edgeTo, Aux_node2Bool& onQueue, queue<Aux_node*>& queue)
{
    Aux_link* link;
    Aux_node* w;

    for(link = v->first_out; link != NULL; link = link->next_same_from)
    {
        w = link->to;
        if(get_dist(distTo, w) > get_dist(distTo, v) + link->weight)
        {
            distTo[w] = distTo[v] + link->weight;
            edgeTo[w] = link;
            if(!onQueue[w])
            {
                // cout << "other node: "<< w->phy_id << "  <<< " << w->type << "\n";
                queue.push(w);
                onQueue[w] = true;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x20(%rdi), %r13
testq %r13, %r13
je 0x84b2
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x8(%rsp), %rbp
movq 0x28(%r13), %rsi
movq %rsi, 0x8(%rsp)
movq %r12, %rdi
callq 0x84c1
movsd %xmm0, (%rsp)
movq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x84c1
addsd 0x18(%r13), %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x84a5
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
callq 0xa0e6
movsd (%rax), %xmm0
addsd 0x18(%r13), %xmm0
movsd %xmm0, (%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0xa0e6
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x975c
movq %r13, (%rax)
movq %r14, %rdi
movq %rbp, %rsi
callq 0xa5c2
cmpb $0x0, (%rax)
jne 0x84a5
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x848c
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x30(%rbx)
jmp 0x8497
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xa3ae
movq %r14, %rdi
movq %rbp, %rsi
callq 0xa5c2
movb $0x1, (%rax)
movq 0x38(%r13), %r13
testq %r13, %r13
jne 0x83e6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
xorl %ebp, %ebp
cmpq $0x4, %rcx
je 0xa934
movq %rsi, %r14
movq 0x8(%rsp), %rcx
leaq 0x20(%rcx), %r15
xorl %ebx, %ebx
movl $0x1, %r13d
leaq 0x10(%rsp), %r12
xorl %ebp, %ebp
movl (%rax,%rbx,4), %ecx
movl %r13d, %ebx
movl (%rax,%rbx,4), %eax
shlq $0x20, %rax
orq %rcx, %rax
movq %rax, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xbaac
addl 0x10(%rax), %ebp
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
decq %rcx
incl %r13d
cmpq %rbx, %rcx
ja 0xa8f8
movl $0x4, %eax
movq 0x8(%rsp), %rcx
cmpl %ebp, 0x80(%rcx)
jge 0xa963
movl $0x3, %eax
cmpl %ebp, 0x84(%rcx)
jge 0xa963
xorl %eax, %eax
cmpl %ebp, 0x88(%rcx)
setge %al
leal (%rax,%rax,2), %eax
decl %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xd1a0(%rip), %rax      # 0x17b40
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x28(%rdi), %rcx
movl %eax, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
leaq 0x58(%rdi), %rcx
movl %eax, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movq %rcx, 0x68(%rdi)
movq %rcx, 0x70(%rdi)
movq %rax, 0x78(%rdi)
movl 0x28(%rsi), %eax
movl %eax, 0x88(%rdi)
movl 0x24(%rsi), %eax
movl %eax, 0x84(%rdi)
movl 0x20(%rsi), %eax
movl %eax, 0x80(%rdi)
movq (%rsi), %rsi
movl 0x8(%r15), %edx
callq 0xaa54
movl 0xc(%r15), %esi
movl 0x10(%r15), %edx
movl 0x1c(%r15), %ecx
movq %r14, %rdi
callq 0xad50
movq %r14, %rdi
callq 0xae72
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x50(%r14), %rdi
addq $0x20, %r14
callq 0xbccc
movq %r14, %rdi
callq 0xbd5c
movq %rbx, %rdi
callq 0xb85c
movq %r15, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O1/ynilu[P]elastic/graph.cpp
// Function: Phy_graph::assign_transceivers(int, int, int)
void Phy_graph::assign_transceivers(int num_OTDM_transceiver, int num_OFDM_transceiver, int transceiver_connection_limit)
{
    for(auto &node : node_list)
    {
        node.transmitter.resize(num_OTDM_transceiver * node.degree);
        node.num_available_transmitter = num_OTDM_transceiver * node.degree;

        node.receiver.resize(num_OTDM_transceiver * node.degree);
        node.num_available_receiver = num_OTDM_transceiver * node.degree;

        node.OFDMtransmitter.resize(num_OFDM_transceiver * node.degree, OFDMTransceiver(transceiver_connection_limit));
        node.num_available_OFDM_transmitter = num_OFDM_transceiver * node.degree;

        node.OFDMreceiver.resize(num_OFDM_transceiver * node.degree, OFDMTransceiver(transceiver_connection_limit));
        node.num_available_OFDM_receiver = num_OFDM_transceiver * node.degree;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, 0x4(%rsp)
movq 0x8(%rdi), %r13
movq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
cmpq %rax, %r13
je 0xae4b
movl %edx, %ebp
movslq %esi, %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %r14
movslq %edx, %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%r13), %rdi
movslq 0x8(%r13), %rsi
movq 0x10(%rsp), %rbx
imulq %rbx, %rsi
callq 0xb8a0
movslq 0x8(%r13), %rsi
imulq %rbx, %rsi
movl %esi, 0x28(%r13)
leaq 0x50(%r13), %rdi
callq 0xb8a0
movl 0x8(%r13), %eax
movl %ebx, %ecx
imull %eax, %ecx
movl %ecx, 0x30(%r13)
leaq 0x68(%r13), %r15
movl %ebp, %ebx
imull %ebp, %eax
movslq %eax, %r12
movq %r14, %rdi
movl 0x4(%rsp), %ebp
movl %ebp, %esi
callq 0xb6ec
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xb90c
movq %r14, %rdi
callq 0xb786
movslq 0x8(%r13), %r15
imulq 0x8(%rsp), %r15
movl %r15d, 0x2c(%r13)
leaq 0x80(%r13), %r12
movq %r14, %rdi
movl %ebp, %esi
callq 0xb6ec
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb90c
movq %r14, %rdi
callq 0xb786
movl 0x8(%r13), %eax
movl %ebx, %ebp
imull %ebx, %eax
movl %eax, 0x34(%r13)
addq $0x98, %r13
cmpq 0x18(%rsp), %r13
jne 0xad8f
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xae5c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb786
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x3270
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x31f0
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x30(%rsp,%rax)
jne 0xe288
leaq 0x10(%rsp), %r14
movq %rsp, %r15
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x3130
movq %rax, %rdi
movq %r12, %rsi
callq 0x3140
movq %rax, %rdi
movq %r13, %rsi
callq 0x3130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xe263
movslq (%rsp), %rax
leaq -0x1(%rax), %rcx
movl %ecx, (%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x38(%rbx), %rcx
movsd %xmm0, -0x8(%rcx,%rax,8)
movl 0x4(%rsp), %ecx
movq 0x50(%rbx), %rdx
movl %ecx, -0x4(%rdx,%rax,4)
jmp 0xe20b
leaq 0x10(%rsp), %rdi
callq 0x3040
leaq 0x10(%rsp), %rdi
callq 0x3080
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x9d61(%rip), %rdi      # 0x17ff0
leaq 0x3459(%rip), %rsi      # 0x116ef
movl $0x10, %edx
callq 0x3250
movq 0x9d49(%rip), %rdi      # 0x17ff0
movq %r14, %rsi
callq 0x3210
leaq 0x344a(%rip), %rsi      # 0x11700
movl $0x2, %edx
movq %rax, %rdi
callq 0x3250
movq 0x9d26(%rip), %rdi      # 0x17ff0
leaq 0x34d7(%rip), %rsi      # 0x117a8
callq 0x3210
movl $0x1, %edi
callq 0x3280
jmp 0xe2e4
jmp 0xe2e4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x3270
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x31f0
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x30(%rsp,%rax)
jne 0xe3d8
leaq 0x10(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x3130
movq %rax, %rdi
movq %r12, %rsi
callq 0x3130
movq %rax, %rdi
movq %r13, %rsi
callq 0x3140
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xe3b3
movslq 0x4(%rsp), %rax
decq %rax
movl %eax, 0x4(%rsp)
movslq (%rsp), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, (%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x20(%rbx), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rax
movsd %xmm0, -0x8(%rax,%rcx,8)
jmp 0xe353
leaq 0x10(%rsp), %rdi
callq 0x3040
leaq 0x10(%rsp), %rdi
callq 0x3080
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x9c11(%rip), %rdi      # 0x17ff0
leaq 0x3309(%rip), %rsi      # 0x116ef
movl $0x10, %edx
callq 0x3250
movq 0x9bf9(%rip), %rdi      # 0x17ff0
movq %r14, %rsi
callq 0x3210
leaq 0x32fa(%rip), %rsi      # 0x11700
movl $0x2, %edx
movq %rax, %rdi
callq 0x3250
movq 0x9bd6(%rip), %rdi      # 0x17ff0
leaq 0x33b5(%rip), %rsi      # 0x117d6
callq 0x3210
movl $0x1, %edi
callq 0x3280
jmp 0xe434
jmp 0xe434
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %esi, %eax
movq 0x68(%rdi), %rsi
addq $0x68, %rdi
cmpq %rdi, %rsi
je 0xe92b
cmpl $0x1, 0x18(%rsi)
jne 0xe926
cmpl %eax, 0x1c(%rsi)
je 0xee52
movq (%rsi), %rsi
jmp 0xe912
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
leaq 0x8f6f(%rip), %rax      # 0x17c80
movq %rax, (%rdi)
leaq 0x20(%rdi), %rax
movl $0x0, 0x20(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq $-0x1, %rax
movq %rax, 0xc(%rdi)
movq %rax, 0x48(%rdi)
movabsq $-0x407fffff40800000, %rax # imm = 0xBF800000BF800000
movq %rax, 0x50(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x86c2(%rip), %rax      # 0x17cc0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xf61c
movq (%rdi), %rax
movq 0x48(%rdi), %r14
callq *0x8(%rax)
movq %r14, %rdi
testq %r14, %r14
jne 0xf60a
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xf637
movq (%rdi), %rax
movq 0x38(%rdi), %rbx
callq *0x8(%rax)
movq %rbx, %rdi
testq %rbx, %rbx
jne 0xf625
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x70, %rsp
leaq -0x18(%rbp), %rdi
callq 0x1060
callq 0x10b0
testl %eax, %eax
je 0x1210
xorl %edi, %edi
callq 0x10a0
movl -0x18(%rbp), %edi
leaq -0x80(%rbp), %rbx
movl $0x64, %edx
movq %rbx, %rsi
callq 0x1070
leaq 0xe2f(%rip), %rdi       # 0x202a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xded(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1050
leaq 0xe02(%rip), %rdi       # 0x2027
leaq -0x80(%rbp), %rbx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
movl -0x14(%rbp), %r14d
movq %rbx, %rdi
callq 0x1040
leaq 0x1(%rax), %rdx
movl %r14d, %edi
movq %rbx, %rsi
callq 0x1030
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/examples/../src/cxon/lang/common/bio/io.hxx
// Function: std::enable_if<std::is_integral<unsigned long>::value, bool>::type cxon::bio::get<unsigned long, unsigned char const*>(unsigned long&, unsigned int, unsigned char const*&, unsigned char const*)
inline auto get(T& t, unsigned n, II& i, II e)
            -> enable_if_t<std::is_integral<T>::value, bool>
        {
            switch (n) {
                case 1:     return imp::get_<1>(t, i, e);
                case 2:     return imp::get_<2>(t, i, e);
                case 4:     return imp::get_<4>(t, i, e);
                case 8:     return imp::get_<8>(t, i, e);
                default:    return CXON_ASSERT(0, "unexpected"), false; // LCOV_EXCL_LINE
            }
        }

// Assembly:
decl %esi
cmpl $0x7, %esi
ja 0x30e9
leaq 0xfde(%rip), %rax       # 0x4048
movslq (%rax,%rsi,4), %rsi
addq %rax, %rsi
jmpq *%rsi
movq (%rdx), %rsi
cmpq %rcx, %rsi
setne %al
je 0x30e8
movzbl (%rsi), %ecx
movq %rcx, (%rdi)
incq %rsi
movq %rsi, (%rdx)
retq
movq (%rdx), %rsi
subq %rsi, %rcx
cmpq $0x4, %rcx
setge %al
jl 0x30e8
leaq 0x4(%rsi), %rcx
movq %rcx, (%rdx)
movl (%rsi), %ecx
bswapl %ecx
jmp 0x30e5
movq (%rdx), %rsi
subq %rsi, %rcx
cmpq $0x8, %rcx
setge %al
jl 0x30e8
leaq 0x8(%rsi), %rcx
movq %rcx, (%rdx)
movq (%rsi), %rcx
bswapq %rcx
jmp 0x30e5
movq (%rdx), %rsi
subq %rsi, %rcx
cmpq $0x2, %rcx
setge %al
jl 0x30e8
leaq 0x2(%rsi), %rcx
movq %rcx, (%rdx)
movzwl (%rsi), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
movq %rcx, (%rdi)
retq
pushq %rax
leaq 0x129e(%rip), %rdi      # 0x438f
leaq 0x1299(%rip), %rsi      # 0x4391
leaq 0x1484(%rip), %rcx      # 0x4583
movl $0xec, %edx
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
testb %bl, %bl
jle 0x145d
movl %edi, %r14d
leal -0x1(%rbx), %ecx
movl $0x1, %r12d
shll %cl, %r12d
leaq 0x1bdd(%rip), %r15      # 0x3020
xorl %esi, %esi
testl %r14d, %r12d
setne %sil
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
shrl %r12d
decl %ebx
jne 0x1443
movl $0xa, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %esi, %esi
jle 0x3dfc
incl %esi
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
movzbl (%rdi), %ecx
xorl %eax, %ecx
imull $0x1000193, %ecx, %eax  # imm = 0x1000193
incq %rdi
decl %esi
cmpl $0x1, %esi
jg 0x3ddf
imull $0x1326193, %ecx, %eax  # imm = 0x1326193
jmp 0x3e01
movl $0x14d53dc5, %eax       # imm = 0x14D53DC5
movl %eax, %ecx
shrl $0x7, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x11, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0x5, %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
testl %esi, %esi
jle 0x3e4d
incl %esi
movabsq $0x100000001b3, %rax    # imm = 0x100000001B3
movzbl (%rdi), %ecx
xorq %rdx, %rcx
imulq %rax, %rcx
incq %rdi
decl %esi
movq %rcx, %rdx
cmpl $0x1, %esi
jg 0x3e34
jmp 0x3e50
movq %rdx, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
movabsq $-0xae502812aa7333, %rcx # imm = 0xFF51AFD7ED558CCD
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
movabsq $-0x3b314601e57a13ad, %rcx # imm = 0xC4CEB9FE1A85EC53
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/fnvhash.c
// Function: fnv16
void
fnv16(char const *buf, int len, char out[16])
{
    XMM	hash = (__v2di) { 0x07BB01426C62272EULL, 0x6295C58D62B82175ULL };

    while (--len >= 0) {
        unsigned x = *buf++;
	//hash = _mm_xor_si128(hash, _mm_set_epi32(0, 0, 0, 255 & *buf++));
	hash = _mm_xor_si128(hash, _mm_set_epi32(x * 2, x * 3, x * 7, x * 11));
	/* This emulates 128bit mul of the FNV128 coefficient using shift/add/sub:
	 *	h := (h << 88) + (h << 8) + (h << 6) - (h << 2) - h
	 * "{add,sub}_epi64" each lose a carry bit (from [63] to [64]).
	 */
	hash =	_mm_sub_epi64(
		    _mm_sub_epi64(
			_mm_add_epi64(
			    _mm_add_epi64(xm_shl_013(hash),
                                          xm_shl_010(hash)),
			    xm_shl_006(hash)),
			xm_shl_002(hash)),
		    hash);
    }

    //XXX: add final mix-in!

    _mm_storeu_si128((XMM*)out, hash);
}

// Assembly:
testl %esi, %esi
jle 0x3f4d
incl %esi
movdqa 0x3293(%rip), %xmm0     # 0x7130
movsbl (%rdi), %eax
incq %rdi
leal (%rax,%rax), %ecx
leal (%rax,%rax,2), %r8d
leal (,%rax,8), %r9d
subl %eax, %r9d
leal (%rax,%rax,4), %r10d
leal (%rax,%r10,2), %eax
movd %eax, %xmm1
movd %r9d, %xmm2
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movd %r8d, %xmm2
movd %ecx, %xmm3
punpckldq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
punpcklqdq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0]
pxor %xmm0, %xmm1
movdqa %xmm1, %xmm0
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movdqa %xmm0, %xmm2
psllq $0x3, %xmm2
movdqa %xmm1, %xmm3
pslldq $0x9, %xmm3             # xmm3 = zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm3[0,1,2,3,4,5,6]
psrlq $0x3f, %xmm3
movdqa %xmm1, %xmm4
pslldq $0x8, %xmm4             # xmm4 = zero,zero,zero,zero,zero,zero,zero,zero,xmm4[0,1,2,3,4,5,6,7]
movdqa %xmm1, %xmm5
psllq $0x6, %xmm5
movdqa %xmm4, %xmm6
psrlq $0x3a, %xmm6
por %xmm5, %xmm6
psubq %xmm1, %xmm0
psllq $0x2, %xmm1
psrlq $0x3e, %xmm4
por %xmm1, %xmm4
paddq %xmm3, %xmm0
paddq %xmm2, %xmm0
paddq %xmm6, %xmm0
psubq %xmm4, %xmm0
decl %esi
cmpl $0x1, %esi
jg 0x3e9d
jmp 0x3f55
movdqa 0x31db(%rip), %xmm0     # 0x7130
movdqu %xmm0, (%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x3180
movq %rax, %r12
movl $0x8, %edi
movl $0x10, %esi
callq 0x3180
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movq %rbx, 0x10(%r12)
movabsq $0x700000000, %rcx      # imm = 0x700000000
movq %rcx, 0x18(%r12)
movl $0xffffffff, 0x20(%r12) # imm = 0xFFFFFFFF
movq %rax, 0x28(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x40c9
movl %eax, %ebp
movq 0x28(%r14), %rax
movslq %ebp, %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
cmpq $0x0, (%rax,%rdx)
je 0x40b5
movq 0x8(%rax,%rdx), %rbx
decl 0x18(%r14)
cmpl %ebp, 0x20(%r14)
jle 0x400d
movl %ebp, 0x20(%r14)
movslq 0x1c(%r14), %rdx
movl %ebp, %r15d
movslq %r15d, %r15
decq %r15
andq %rdx, %r15
movq %r15, %rsi
shlq $0x4, %rsi
cmpq $0x0, (%rax,%rsi)
jne 0x4014
movq 0x28(%r14), %rax
incq %rcx
movslq 0x1c(%r14), %r12
andq %rcx, %r12
movq %r12, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdi
testq %rdi, %rdi
je 0x40a5
movl %r12d, %r13d
movq 0x10(%r14), %rsi
xorl %eax, %eax
callq *0x8(%r14)
andl 0x1c(%r14), %eax
subl %r15d, %eax
movl %ebp, %ecx
subl %r15d, %ecx
cmpl %ecx, %eax
ja 0x4081
movq 0x28(%r14), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
shlq $0x4, %r12
movups (%rax,%r12), %xmm0
movups %xmm0, (%rax,%rcx)
movl %r13d, %ebp
movq 0x28(%r14), %rax
movslq %r13d, %rcx
incq %rcx
movslq 0x1c(%r14), %r12
andq %rcx, %r12
movq %r12, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdi
movl %r12d, %r13d
testq %rdi, %rdi
jne 0x404c
movslq %ebp, %rcx
shlq $0x4, %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx)
jmp 0x40b7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq *0x8(%r14)
movq %rax, %r15
andl 0x1c(%r14), %r15d
movslq %r15d, %rax
movq 0x28(%r14), %rcx
shlq $0x4, %rax
movq (%rcx,%rax), %rdi
testq %rdi, %rdi
je 0x412a
movq 0x10(%r14), %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq *(%r14)
testl %eax, %eax
je 0x412a
movslq %r15d, %rax
incq %rax
movslq 0x1c(%r14), %r15
andq %rax, %r15
movq 0x28(%r14), %rax
movq %r15, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdi
jmp 0x40f7
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0x1c(%rdi), %r8d
movslq 0x20(%rdi), %rcx
movl %ecx, %eax
cmpl %r8d, %ecx
cmovgl %ecx, %r8d
movslq %r8d, %r8
movq %rcx, %r9
subq %r8, %r9
shlq $0x4, %rcx
xorl %r8d, %r8d
cmpq %r8, %r9
je 0x41d2
movq 0x28(%rdi), %r10
movq 0x10(%r10,%rcx), %r10
decq %r8
addq $0x10, %rcx
testq %r10, %r10
je 0x419d
subl %r8d, %eax
movl %eax, 0x20(%rdi)
movq %r10, (%rsi)
movq 0x28(%rdi), %rax
movq 0x8(%rax,%rcx), %rax
movq %rax, (%rdx)
movl $0x1, %eax
retq
subl %r8d, %eax
incl %eax
movl %eax, 0x20(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/map.c
// Function: map_resize
void
map_resize(MAP mp, int limit)
{
    int		i, j, dups = 0, oldmask = mp->mask;
    KEYVAL      *vdata;
    const void	*kp;

    if (--limit < MINMASK) limit = MINMASK;
    if (limit < mp->count * 5/4) limit = mp->count * 5/4;
    while (mp->mask > limit) mp->mask >>= 1;
    while (mp->mask < limit) mp->mask = (mp->mask << 1) | 1;
    vdata = calloc(mp->mask + 1, sizeof(KEYVAL));

        // PASS 1: insert where there are no collisions,
    for (i = 0; i <= oldmask; ++i) {

        if ((kp = mp->vdata[i].key)) {
            if (vdata[j = FNHASH(mp, kp)].key) {
                mp->vdata[dups++] = mp->vdata[i];
            } else {
                vdata[j] = mp->vdata[i];
            }
        }
    }

        // PASS 2: insert the rest
    for (i = 0; i < dups; ++i) {
        kp = mp->vdata[i].key;
        j = FNHASH(mp, kp);
        do j = (j + 1) & mp->mask; while (vdata[j].key);
        vdata[j] = mp->vdata[i];
    }

    free(mp->vdata);
    mp->vdata = vdata;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %eax
cmpl $0x9, %esi
movl $0x8, %ecx
cmovgel %esi, %ecx
movl 0x1c(%rdi), %r15d
leal -0x1(%rcx), %edx
leal (%rax,%rax,4), %esi
leal (%rax,%rax,4), %eax
addl $0x3, %eax
testl %esi, %esi
cmovnsl %esi, %eax
sarl $0x2, %eax
cmpl %eax, %ecx
cmovgl %edx, %eax
cmpl %eax, %r15d
jle 0x4225
movl %r15d, %ecx
sarl %ecx
cmpl %eax, %ecx
jg 0x421c
movl %ecx, 0x1c(%rbx)
movl 0x1c(%rbx), %ecx
cmpl %eax, %ecx
jge 0x423a
leal 0x1(,%rcx,2), %ecx
cmpl %eax, %ecx
jl 0x422c
movl %ecx, 0x1c(%rbx)
incl %ecx
movslq %ecx, %rdi
movl $0x10, %esi
callq 0x3180
movq %rax, %r14
testl %r15d, %r15d
js 0x42b8
shlq $0x4, %r15
addq $0x10, %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r13), %rdi
testq %rdi, %rdi
je 0x42ad
movq 0x10(%rbx), %rsi
xorl %eax, %eax
callq *0x8(%rbx)
andl 0x1c(%rbx), %eax
cltq
shlq $0x4, %rax
leaq (%r14,%rax), %rcx
movq 0x28(%rbx), %rdx
movslq %r12d, %r12
movq %r12, %rsi
shlq $0x4, %rsi
addq %rdx, %rsi
xorl %edi, %edi
cmpq $0x0, (%r14,%rax)
cmoveq %rcx, %rsi
setne %dil
addl %edi, %r12d
movups (%rdx,%r13), %xmm0
movups %xmm0, (%rsi)
addq $0x10, %r13
cmpq %r13, %r15
jne 0x425f
jmp 0x42bb
xorl %r12d, %r12d
testl %r12d, %r12d
jle 0x430c
movl %r12d, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rsi
movq 0x28(%rbx), %rax
movq %r12, %r13
shlq $0x4, %r13
movq (%rax,%r13), %rdi
xorl %eax, %eax
callq *0x8(%rbx)
movl 0x1c(%rbx), %ecx
andl %ecx, %eax
incl %eax
andl %ecx, %eax
movslq %eax, %rdx
shlq $0x4, %rdx
cmpq $0x0, (%r14,%rdx)
jne 0x42e3
addq %r14, %rdx
movq 0x28(%rbx), %rax
movups (%rax,%r13), %xmm0
movups %xmm0, (%rdx)
incq %r12
cmpq %r15, %r12
jne 0x42c6
movq 0x28(%rbx), %rdi
callq 0x3300
movq %r14, 0x28(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0x40c9
movq 0x28(%r14), %rcx
movslq %eax, %rdx
shlq $0x4, %rdx
movq 0x8(%rcx,%rdx), %r15
cmpq $0x0, (%rcx,%rdx)
jne 0x4380
movl 0x18(%r14), %edx
movl 0x1c(%r14), %ecx
leal (%rdx,%rdx,4), %esi
leal (%rdx,%rdx,4), %edx
addl $0x3, %edx
testl %esi, %esi
cmovnsl %esi, %edx
sarl $0x2, %edx
cmpl %ecx, %edx
jge 0x439e
movq 0x28(%r14), %rcx
movslq %eax, %rdx
shlq $0x4, %rdx
movq %r12, (%rcx,%rdx)
incl 0x18(%r14)
movq 0x28(%r14), %rcx
cltq
shlq $0x4, %rax
movq %rbx, 0x8(%rcx,%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leal 0x2(,%rcx,2), %esi
movq %r14, %rdi
callq 0x41dd
movq 0x10(%r14), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq *0x8(%r14)
movl 0x1c(%r14), %ecx
andl %ecx, %eax
movq 0x28(%r14), %rdx
movslq %eax, %rsi
shlq $0x4, %rsi
cmpq $0x0, (%rdx,%rsi)
je 0x436d
incl %eax
andl %ecx, %eax
jmp 0x43c4
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
callq 0x40c9
cltq
shlq $0x4, %rax
movq (%r14,%rax), %r14
testq %r14, %r14
je 0x4421
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fcc
movq %rax, %rdi
callq 0x3300
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3300
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, 0x20(%rdi) # imm = 0xFFFFFFFF
movl 0x1c(%rbx), %edx
movslq 0x20(%rbx), %rcx
cmpl %edx, %ecx
cmovgl %ecx, %edx
movl %ecx, %esi
movslq %edx, %rdi
leal 0x1(%rdi), %r8d
movq %rcx, %rdx
subq %rdi, %rdx
shlq $0x4, %rcx
addq $0x10, %rcx
xorl %r10d, %r10d
movq %r10, %rdi
cmpq %r10, %rdx
je 0x4488
movq 0x28(%rbx), %r9
movq (%r9,%rcx), %r15
leaq -0x1(%rdi), %r10
addq $0x10, %rcx
testq %r15, %r15
je 0x445e
subl %r10d, %esi
movl %esi, 0x20(%rbx)
movq -0x8(%r9,%rcx), %r14
jmp 0x448f
movl %r8d, 0x20(%rbx)
movq %rax, %r15
cmpq %rdi, %rdx
je 0x44a9
movq %r15, %rdi
callq 0x3300
movq %r14, %rdi
callq 0x3300
movq %r15, %rax
jmp 0x4438
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4133
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
callq 0x544f
movq %rax, %rdi
movq %rdx, %rsi
callq 0x4ded
testq %rax, %rax
je 0x45b4
movq %rax, %rbx
leaq 0x4(%rsp), %r12
movq %rax, %rdi
movl $0xa, %esi
movq %r12, %rdx
callq 0x5344
movq %rax, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x3180
movq %rax, %r14
movl $0x8, %edi
movl $0x10, %esi
callq 0x3180
movq 0x5ac1(%rip), %rcx      # 0x9fe0
movq %rcx, (%r14)
leaq 0x15d(%rip), %rcx       # 0x4686
movq %rcx, 0x8(%r14)
movq $0x0, 0x10(%r14)
movabsq $0x700000000, %rcx      # imm = 0x700000000
movq %rcx, 0x18(%r14)
movl $0xffffffff, 0x20(%r14) # imm = 0xFFFFFFFF
movq %rax, 0x28(%r14)
movl (%r12), %esi
movq %r14, %rdi
callq 0x41dd
cmpl $0x0, (%r12)
jle 0x45a2
movsbl %bpl, %ebp
xorl %r12d, %r12d
movq %r15, %r13
movq (%r13), %rdi
movl %ebp, %esi
callq 0x30f0
testq %rax, %rax
je 0x4591
movq %rax, %rdx
incq %rdx
movb $0x0, (%rax)
movq (%r13), %rsi
movq %r14, %rdi
callq 0x45c9
incq %r12
movslq 0x4(%rsp), %rax
addq $0x10, %r13
cmpq %rax, %r12
jl 0x456c
movq %r15, %rdi
callq 0x3300
movq %rbx, %rdi
callq 0x3300
jmp 0x45b7
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x40c9
movq 0x28(%rbx), %rcx
movslq %eax, %r13
shlq $0x4, %r13
leaq (%rcx,%r13), %r12
cmpq $0x0, (%rcx,%r13)
je 0x4615
movq 0x8(%r12), %rdi
callq 0x3300
movq %r14, %rdi
callq 0x3420
movq 0x28(%rbx), %rcx
movq %rax, 0x8(%rcx,%r13)
jmp 0x465b
movl 0x18(%rbx), %r13d
leal (%r13,%r13,4), %eax
leal 0x3(%r13,%r13,4), %ebp
testl %eax, %eax
cmovnsl %eax, %ebp
sarl $0x2, %ebp
movl 0x1c(%rbx), %eax
movl %eax, 0x4(%rsp)
movq %r15, %rdi
callq 0x3420
movq %rax, %r15
movq %r14, %rdi
callq 0x3420
cmpl 0x4(%rsp), %ebp
jge 0x466a
movq %r15, (%r12)
movq %rax, 0x8(%r12)
incl %r13d
movl %r13d, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4323
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x1d0(%rbp), %rdi
movl $0x18, %edx
callq 0x22c0
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movsbl %r14b, %r14d
leaq -0x1d0(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x2350
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2922
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5ef6
jmp 0x28f9
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2937
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
movq 0x866a(%rip), %rsi      # 0xafa8
leaq -0x1d0(%rbp), %rdi
callq 0x2180
leaq -0x150(%rbp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x29a7
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2988
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
movq 0x8619(%rip), %rsi      # 0xafa8
leaq -0x1d0(%rbp), %rdi
callq 0x2180
leaq -0x150(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x5e50
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_takeWhile()
auto test_takeWhile() -> void {
  using Prelude::takeWhile;
  auto expect = std::vector<int>{1, 2, 3, 4};
  auto result = takeWhile([](int x) { return x < 5; },
                          std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movaps 0x4fd3(%rip), %xmm0     # 0xa010
leaq 0x50(%rsp), %rbx
movups %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rsi
callq 0x7016
movups 0x5b59(%rip), %xmm0     # 0xabbc
movaps %xmm0, 0x10(%rbx)
movups 0x5b3e(%rip), %xmm0     # 0xabac
movaps %xmm0, (%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x6(%rsp), %rcx
movl $0x8, %edx
callq 0x7016
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
subq %rsi, %rax
sarq $0x2, %rax
movq %rsi, %rdx
testq %rax, %rax
jle 0x50d1
movq %rsi, %rdx
movq %rax, %rcx
shrq %rcx
movq %rcx, %rdi
notq %rdi
addq %rax, %rdi
leaq (%rdx,%rcx,4), %rax
addq $0x4, %rax
cmpl $0x5, -0x4(%rax)
cmovlq %rax, %rdx
cmovgeq %rcx, %rdi
movq %rdi, %rax
testq %rdi, %rdi
jg 0x50a6
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x860a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x50f7
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x38(%rsp), %rbx
movq 0x40(%rsp), %rax
movq %rax, %rdx
subq %rbx, %rdx
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0x515c
cmpq %rbx, %rax
je 0x512a
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jne 0x515c
testq %rbx, %rbx
je 0x513f
movq 0x48(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5156
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x70, %rsp
popq %rbx
retq
leaq 0x4f3d(%rip), %rdi      # 0xa0a0
leaq 0x4f05(%rip), %rsi      # 0xa06f
leaq 0x5403(%rip), %rcx      # 0xa574
movl $0xf7, %edx
callq 0x2090
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x519a
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x519a
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x51b1
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_map()
auto test_map() -> void {
  using Prelude::map;
  auto expect = std::vector<bool>{false, true, false, true, false};
  auto even = [](int x) { return x % 2 == 0; };
  auto result = map(even, std::vector<int>{1, 2, 3, 4, 5});
  assert(result == expect);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
leaq 0x10(%rsp), %rsi
movl $0x1000100, (%rsi)      # imm = 0x1000100
movb $0x0, 0x4(%rsi)
leaq 0x40(%rsp), %rdi
leaq 0x68(%rsp), %rcx
movl $0x5, %edx
callq 0x6fb8
movups 0x84bb(%rip), %xmm0     # 0xaac8
leaq 0x80(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x5, 0x10(%rsi)
leaq 0x68(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x5, %edx
callq 0x7016
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x68(%rsp), %r14
movq 0x70(%rsp), %r15
cmpq %r15, %r14
je 0x2678
leaq 0x10(%rsp), %rbx
xorl %esi, %esi
testb $0x1, (%r14)
sete %sil
movq %rbx, %rdi
callq 0x7c50
addq $0x4, %r14
cmpq %r15, %r14
jne 0x265d
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x268f
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl 0x28(%rsp), %ecx
movq %rdx, %rax
subq %rdi, %rax
leaq (%rcx,%rax,8), %rax
movq 0x40(%rsp), %r8
movq 0x50(%rsp), %rsi
movl 0x58(%rsp), %r9d
subq %r8, %rsi
leaq (%r9,%rsi,8), %rsi
cmpq %rsi, %rax
jne 0x274b
leaq 0x20(%rsp), %r14
leaq 0x28(%rsp), %r15
xorl %esi, %esi
xorl %r9d, %r9d
callq 0x800e
testb %al, %al
je 0x274b
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x270e
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x273e
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
xorl %eax, %eax
movq %rax, 0x40(%rsp)
movl %eax, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movl %eax, 0x58(%rsp)
movq %rax, 0x60(%rsp)
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x794e(%rip), %rdi      # 0xa0a0
leaq 0x7916(%rip), %rsi      # 0xa06f
leaq 0x7951(%rip), %rcx      # 0xa0b1
movl $0x17, %edx
callq 0x2090
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x27bc
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x21ce
jmp 0x27bc
movq %rax, %rbx
jmp 0x27bc
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x27a5
leaq 0x10(%rsp), %rdi
callq 0x21a0
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x27bc
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x27ec
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
xorl %eax, %eax
movq %rax, 0x40(%rsp)
movl %eax, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movl %eax, 0x58(%rsp)
movq %rax, 0x60(%rsp)
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_join()
auto test_join() -> void {
  using Prelude::join;
  auto expect = std::vector<int>{1, 2, 3, 4};
  auto result = join(std::vector<int>{1, 2}, std::vector<int>{3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movaps 0x780d(%rip), %xmm0     # 0xa010
leaq 0x58(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movl $0x4, %edx
callq 0x7016
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x78(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x2, %edx
callq 0x7016
movabsq $0x400000003, %rax      # imm = 0x400000003
leaq 0x70(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x40(%rsp), %rdi
leaq 0xe(%rsp), %rcx
movl $0x2, %edx
callq 0x7016
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x705b
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2896
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x28ad
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x58(%rsp), %rbx
movq 0x60(%rsp), %rax
movq %rax, %rdx
subq %rbx, %rdx
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0x2915
cmpq %rbx, %rax
je 0x28e0
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jne 0x2915
testq %rbx, %rbx
je 0x28f5
movq 0x68(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x290c
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x80, %rsp
popq %rbx
retq
leaq 0x7784(%rip), %rdi      # 0xa0a0
leaq 0x774c(%rip), %rsi      # 0xa06f
leaq 0x7797(%rip), %rcx      # 0xa0c1
movl $0x1e, %edx
callq 0x2090
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2953
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x2953
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x296f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x296f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2986
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_filter()
auto test_filter() -> void {
  using Prelude::filter;
  auto expect = std::vector<int>{2, 4};
  auto even = [](int x) { return x % 2 == 0; };
  auto result = filter(even, std::vector<int>{1, 2, 3, 4, 5});
  assert(result == expect);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movabsq $0x400000002, %rax      # imm = 0x400000002
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rcx
movl $0x2, %edx
callq 0x7016
movups 0x8101(%rip), %xmm0     # 0xaac8
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x5, 0x10(%rsi)
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x5, %edx
callq 0x7016
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x38(%rsp), %rsi
subq 0x30(%rsp), %rsi
sarq $0x2, %rsi
callq 0x8354
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %r15
cmpq %r15, %rbx
je 0x2a57
leaq 0x10(%rsp), %r14
movl (%rbx), %eax
testb $0x1, %al
jne 0x2a4e
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x2a43
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x2a4e
movq %r14, %rdi
movq %rbx, %rdx
callq 0x83ea
addq $0x4, %rbx
cmpq %r15, %rbx
jne 0x2a24
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x2a6d
leaq 0x10(%rsp), %rdi
callq 0x84c6
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2a84
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %rax
movq %rax, %rdx
subq %rbx, %rdx
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0x2af0
cmpq %rbx, %rax
je 0x2ab7
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jne 0x2af0
testq %rbx, %rbx
je 0x2acc
movq 0x20(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x2ae3
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x75a9(%rip), %rdi      # 0xa0a0
leaq 0x7571(%rip), %rsi      # 0xa06f
leaq 0x75cd(%rip), %rcx      # 0xa0d2
movl $0x26, %edx
callq 0x2090
jmp 0x2b16
movq %rax, %rbx
jmp 0x2b47
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2b30
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2b47
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x2b5e
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170