LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: NishadSaraf[P]Championship-Simulator/inc/block.h
// Function: LOAD_STORE_QUEUE::LOAD_STORE_QUEUE(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
LOAD_STORE_QUEUE(string v1, uint32_t v2) : NAME(v1), SIZE(v2) {
        occupancy = 0;
        head = 0;
        tail = 0;

        entry = new LSQ_ENTRY[SIZE];
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
callq 0x3100
movq 0x28(%rsp), %rax
movl 0x54(%rsp), %ecx
movl %ecx, 0x20(%rax)
movl $0x0, 0x24(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x2c(%rax)
movl 0x20(%rax), %eax
movq %rax, 0x30(%rsp)
shlq $0x6, %rax
leaq (%rax,%rax,4), %rdi
callq 0x3030
movq %rax, 0x38(%rsp)
jmp 0x1ca26
movq 0x30(%rsp), %rax
cmpq $0x0, %rax
je 0x1ca7d
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rcx
imulq $0x140, %rcx, %rdx      # imm = 0x140
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1c670
jmp 0x1ca63
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq $0x140, %rax            # imm = 0x140
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x1ca52
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, 0x30(%rax)
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1cab8
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x32b0
movq 0x28(%rsp), %rdi
callq 0x3150
movq 0x48(%rsp), %rdi
callq 0x33c0
nopl (%rax)
// File: NishadSaraf[P]Championship-Simulator/inc/block.h
// Function: PACKET_QUEUE::PACKET_QUEUE(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
PACKET_QUEUE(string v1, uint32_t v2) : NAME(v1), SIZE(v2) {
        is_RQ = 0;
        is_WQ = 0;

        cpu = 0; 
        head = 0;
        tail = 0;
        occupancy = 0;
        num_returned = 0;
        next_fill_index = 0;
        next_schedule_index = 0;
        next_process_index = 0;

        next_fill_cycle = UINT64_MAX;
        next_schedule_cycle = UINT64_MAX;
        next_process_cycle = UINT64_MAX;

        ACCESS = 0;
        FORWARD = 0;
        MERGED = 0;
        TO_CACHE = 0;
        ROW_BUFFER_HIT = 0;
        ROW_BUFFER_MISS = 0;
        FULL = 0;

        entry = new PACKET[SIZE]; 
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x3100
movq 0x38(%rsp), %rax
movl 0x64(%rsp), %ecx
movl %ecx, 0x20(%rax)
addq $0xa0, %rax
movq %rax, %rcx
addq $0x1c00, %rcx           # imm = 0x1C00
movq %rcx, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x9750
jmp 0x1d858
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
addq $0x380, %rax            # imm = 0x380
cmpq %rcx, %rax
movq %rax, 0x48(%rsp)
jne 0x1d847
movq 0x38(%rsp), %rax
movb $0x0, 0x24(%rax)
movb $0x0, 0x25(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x2c(%rax)
movl $0x0, 0x30(%rax)
movl $0x0, 0x34(%rax)
movl $0x0, 0x38(%rax)
movl $0x0, 0x3c(%rax)
movl $0x0, 0x40(%rax)
movl $0x0, 0x44(%rax)
movq $-0x1, 0x48(%rax)
movq $-0x1, 0x50(%rax)
movq $-0x1, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
movq $0x0, 0x78(%rax)
movq $0x0, 0x80(%rax)
movq $0x0, 0x88(%rax)
movq $0x0, 0x90(%rax)
movl 0x20(%rax), %eax
movq %rax, 0x20(%rsp)
imulq $0x380, %rax, %rdi      # imm = 0x380
callq 0x3030
movq %rax, 0x28(%rsp)
jmp 0x1d92b
movq 0x20(%rsp), %rax
cmpq $0x0, %rax
je 0x1d982
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
imulq $0x380, %rcx, %rdx      # imm = 0x380
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x9750
jmp 0x1d968
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq $0x380, %rax            # imm = 0x380
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x1d957
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x98(%rax)
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1d9c0
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x32b0
movq 0x38(%rsp), %rdi
callq 0x3150
movq 0x58(%rsp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
nop
// File: NishadSaraf[P]Championship-Simulator/inc/cache.h
// Function: CACHE_STATS::CACHE_STATS()
CACHE_STATS () {
        pf_issued = 0;
        pf_useful = 0;
        pf_useless = 0;
        pf_fill = 0;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
retq
nopw (%rax,%rax)
// File: NishadSaraf[P]Championship-Simulator/inc/block.h
// Function: BLOCK::BLOCK()
BLOCK() {
        valid = 0;
        prefetch = 0;
        dirty = 0;
        used = 0;

        delta = 0;
        depth = 0;
        signature = 0;
        confidence = 0;

        address = 0;
        full_addr = 0;
        tag = 0;
        data = 0;
        cpu = 0;
        instr_id = 0;

        lru = 0;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, (%rax)
movb $0x0, 0x1(%rax)
movb $0x0, 0x2(%rax)
movb $0x0, 0x3(%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movl $0x0, 0x48(%rax)
retq
nopl (%rax)
// File: NishadSaraf[P]Championship-Simulator/inc/memory_class.h
// Function: BANK_REQUEST::BANK_REQUEST()
BANK_REQUEST() {
        cycle_available = 0;
        address = 0;
        full_addr = 0;

        open_row = UINT32_MAX;

        working = 0;
        working_type = 0;
        row_buffer_hit = 0;
        drc_hit = 0;
        is_write = 0;
        is_read = 0;

        request_index = -1;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x1c(%rax)
movb $0x0, 0x1d(%rax)
movb $0x0, 0x1e(%rax)
movb $0x0, 0x1f(%rax)
movb $0x0, 0x20(%rax)
movb $0x0, 0x21(%rax)
movl $0xffffffff, 0x24(%rax) # imm = 0xFFFFFFFF
retq
nopl (%rax,%rax)
// File: NishadSaraf[P]Championship-Simulator/src/drc_controller.cc
// Function: DRC_MEMORY_CONTROLLER::fill_cache(BLOCK*, unsigned int, unsigned int, PACKET*)
void DRC_MEMORY_CONTROLLER::fill_cache(BLOCK *block, uint32_t set, uint32_t way, PACKET *packet)
{
    if (block->valid == 0) {
        block->valid = 1;
        num_valid++;
    }
    // block->prefetch = packet->prefetch; // FIXME: looks like this needs to be fixed
    block->used = 0;
    block->dirty = 0;

    block->tag = packet->address;
    block->address = packet->address;
    block->full_addr = packet->full_addr;
    block->data = packet->data;
    block->cpu = packet->cpu;
    block->instr_id = packet->instr_id;

    DP ( if (warmup_complete[packet->cpu]) {
    cout << "[" << NAME << "] " << __func__ << " set: " << set << " way: " << way;
    cout << " lru: " << block->lru << " instr_id: " << packet->instr_id << " type: " << +packet->type << " tag: " << hex << block->tag << " full_addr: " << block->full_addr;
    cout << " data: " << block->data << dec << endl; });
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2175d
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
movb $0x1, (%rcx)
movq 0x409038(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x409038(%rax)
movq -0x10(%rsp), %rax
movb $0x0, 0x3(%rax)
movq -0x10(%rsp), %rax
movb $0x0, 0x2(%rax)
movq -0x20(%rsp), %rax
movq 0x340(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rsp), %rax
movq 0x340(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rsp), %rax
movq 0x348(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rsp), %rax
movq 0x360(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rsp), %rax
movl 0x330(%rax), %eax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rsp), %rax
movq 0x368(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x40(%rax)
retq
nop
// File: NishadSaraf[P]Championship-Simulator/src/drc_controller.cc
// Function: DRC_MEMORY_CONTROLLER::add_wq(PACKET*)
int DRC_MEMORY_CONTROLLER::add_wq(PACKET *packet)
{
    // check for duplicates in the write queue
    int index = check_drc_queue(&WQ, packet);
    if (index != -1)
        return index; // merged index

    // search for the empty index
    for (index=0; index<DRC_WQ_SIZE; index++) {
        if (WQ.entry[index].address == 0) {
            
            memcpy(&WQ.entry[index], packet, sizeof(PACKET));
            WQ.occupancy++;

#ifdef DEBUG_PRINT
            uint32_t channel = drc_get_channel(packet->address),
                     rank = drc_get_rank(packet->address),
                     bank = drc_get_bank(packet->address),
                     row = drc_get_row(packet->address),
                     column = drc_get_column(packet->address); 
#endif

            DP ( if(warmup_complete[packet->cpu]) {
            cout << "[" << NAME << "_WQ] " <<  __func__ << " instr_id: " << packet->instr_id << " address: " << hex << packet->address;
            cout << " full_addr: " << packet->full_addr << dec << " ch: " << channel;
            cout << " rank: " << rank << " bank: " << bank << " row: " << row << " col: " << column;
            cout << " occupancy: " << WQ.occupancy << " current: " << current_core_cycle[packet->cpu] << " event: " << packet->event_cycle << endl; });

            break;
        }
    }

    update_schedule_cycle(&WQ);

    return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq %rdi, %rsi
addq $0x40a870, %rsi         # imm = 0x40A870
movq 0x10(%rsp), %rdx
callq 0x21b60
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
je 0x21c23
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x21cbe
movl $0x0, 0xc(%rsp)
cmpl $0x30, 0xc(%rsp)
jge 0x21ca3
movq (%rsp), %rax
movq 0x40a908(%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x380, %rcx, %rcx      # imm = 0x380
addq %rcx, %rax
cmpq $0x0, 0x340(%rax)
jne 0x21c94
movq (%rsp), %rax
movq 0x40a908(%rax), %rdi
movslq 0xc(%rsp), %rax
imulq $0x380, %rax, %rax      # imm = 0x380
addq %rax, %rdi
movq 0x10(%rsp), %rsi
movl $0x380, %edx            # imm = 0x380
callq 0x31a0
movq (%rsp), %rax
movl 0x40a8a4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40a8a4(%rax)
jmp 0x21ca3
jmp 0x21c96
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x21c2b
movq (%rsp), %rdi
movq %rdi, %rsi
addq $0x40a870, %rsi         # imm = 0x40A870
callq 0x1e6f0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: NishadSaraf[P]Championship-Simulator/src/drc_controller.cc
// Function: DRC_MEMORY_CONTROLLER::get_occupancy(unsigned char)
uint32_t DRC_MEMORY_CONTROLLER::get_occupancy(uint8_t queue_type)
{
    if (queue_type == 0)
        return MSHR.occupancy;
    else if (queue_type == 1)
        return RQ.occupancy;
    else if (queue_type == 2)
        return WQ.occupancy;

    return 0;
}

// Assembly:
movb %sil, %al
movq %rdi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movzbl -0x11(%rsp), %eax
cmpl $0x0, %eax
jne 0x22021
movq -0x20(%rsp), %rax
movl 0x4073a4(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x22063
movzbl -0x11(%rsp), %eax
cmpl $0x1, %eax
jne 0x2203c
movq -0x20(%rsp), %rax
movl 0x40c544(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x22063
movzbl -0x11(%rsp), %eax
cmpl $0x2, %eax
jne 0x22057
movq -0x20(%rsp), %rax
movl 0x40a8a4(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x22063
jmp 0x22059
jmp 0x2205b
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: NishadSaraf[P]Championship-Simulator/src/drc_controller.cc
// Function: DRC_MEMORY_CONTROLLER::get_size(unsigned char)
uint32_t DRC_MEMORY_CONTROLLER::get_size(uint8_t queue_type)
{
    if (queue_type == 0)
        return MSHR.SIZE;
    else if (queue_type == 1)
        return RQ.SIZE;
    else if (queue_type == 2)
        return WQ.SIZE;

    return 0;
}

// Assembly:
movb %sil, %al
movq %rdi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movzbl -0x11(%rsp), %eax
cmpl $0x0, %eax
jne 0x220a1
movq -0x20(%rsp), %rax
movl 0x407390(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x220e3
movzbl -0x11(%rsp), %eax
cmpl $0x1, %eax
jne 0x220bc
movq -0x20(%rsp), %rax
movl 0x40c530(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x220e3
movzbl -0x11(%rsp), %eax
cmpl $0x2, %eax
jne 0x220d7
movq -0x20(%rsp), %rax
movl 0x40a890(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x220e3
jmp 0x220d9
jmp 0x220db
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: NishadSaraf[P]Championship-Simulator/branch/branch_predictor.cc
// Function: O3_CPU::predict_branch(unsigned long)
uint8_t O3_CPU::predict_branch(uint64_t ip)
{
    int prediction = 1;

    int hash = ip % BIMODAL_PRIME;
    prediction = (bimodal_table[cpu][hash] >= ((MAX_COUNTER + 1)/2)) ? 1 : 0;

    return prediction;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x1, -0x14(%rsp)
movq -0x10(%rsp), %rax
movl $0x3ffd, %ecx           # imm = 0x3FFD
xorl %edx, %edx
divq %rcx
movq -0x20(%rsp), %rax
movl %edx, %ecx
movl %ecx, -0x18(%rsp)
movl (%rax), %eax
movl %eax, %ecx
leaq 0x89c7f(%rip), %rax     # 0xabe70
shlq $0x10, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x2, %edx
cmovgel %ecx, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: NishadSaraf[P]Championship-Simulator/branch/branch_predictor.cc
// Function: O3_CPU::last_branch_result(unsigned long, unsigned char)
void O3_CPU::last_branch_result(uint64_t ip, uint8_t taken)
{
    int hash = ip % BIMODAL_PRIME;

    if (taken && (bimodal_table[cpu][hash] < MAX_COUNTER))
        bimodal_table[cpu][hash]++;
    else if ((taken == 0) && (bimodal_table[cpu][hash] > 0))
        bimodal_table[cpu][hash]--;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movl $0x3ffd, %ecx           # imm = 0x3FFD
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x18(%rsp)
cmpb $0x0, -0x11(%rsp)
je 0x2229f
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x89c0a(%rip), %rax     # 0xabe70
shlq $0x10, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
cmpl $0x3, (%rax,%rcx,4)
jge 0x2229f
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x89be8(%rip), %rax     # 0xabe70
shlq $0x10, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x222f2
movzbl -0x11(%rsp), %eax
cmpl $0x0, %eax
jne 0x222f0
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x89bb7(%rip), %rax     # 0xabe70
shlq $0x10, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x222f0
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x89b95(%rip), %rax     # 0xabe70
shlq $0x10, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x222f2
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: NishadSaraf[P]Championship-Simulator/replacement/base_replacement.cc
// Function: CACHE::update_replacement_state(unsigned int, unsigned int, unsigned int, unsigned long, unsigned long, unsigned long, unsigned int, unsigned char)
void CACHE::update_replacement_state(uint32_t cpu, uint32_t set, uint32_t way, uint64_t full_addr, uint64_t ip, uint64_t victim_addr, uint32_t type, uint8_t hit)
{
    if (type == WRITEBACK) {
        if (hit) // wrietback hit does not update LRU state
            return;
    }

    return lru_update(set, way);
}

// Assembly:
subq $0x38, %rsp
movb 0x50(%rsp), %al
movl 0x48(%rsp), %eax
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x3, 0x48(%rsp)
jne 0x22558
cmpb $0x0, 0x50(%rsp)
je 0x22556
jmp 0x2256a
jmp 0x22558
movq 0x8(%rsp), %rdi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
callq 0x22570
addq $0x38, %rsp
retq
nop
// File: NishadSaraf[P]Championship-Simulator/replacement/base_replacement.cc
// Function: CACHE::lru_update(unsigned int, unsigned int)
void CACHE::lru_update(uint32_t set, uint32_t way)
{
    // update lru replacement state
    for (uint32_t i=0; i<NUM_WAY; i++) {
        if (block[set][i].lru < block[set][way].lru) {
            block[set][i].lru++;
        }
    }
    block[set][way].lru = 0; // promote to the MRU position
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0x14(%rsp)
movq -0x20(%rsp), %rcx
movl -0x14(%rsp), %eax
cmpl 0x7374(%rcx), %eax
jae 0x2261b
movq -0x20(%rsp), %rcx
movq 0x7390(%rcx), %rax
movl -0xc(%rsp), %edx
movq (%rax,%rdx,8), %rax
movl -0x14(%rsp), %edx
imulq $0x50, %rdx, %rdx
addq %rdx, %rax
movl 0x48(%rax), %eax
movq 0x7390(%rcx), %rcx
movl -0xc(%rsp), %edx
movq (%rcx,%rdx,8), %rcx
movl -0x10(%rsp), %edx
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x48(%rcx), %eax
jae 0x22609
movq -0x20(%rsp), %rax
movq 0x7390(%rax), %rax
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x14(%rsp), %ecx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
jmp 0x2260b
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x2258f
movq -0x20(%rsp), %rax
movq 0x7390(%rax), %rax
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x10(%rsp), %ecx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x48(%rax)
retq
nopw %cs:(%rax,%rax)
// File: NishadSaraf[P]Championship-Simulator/replacement/llc_replacement.cc
// Function: CACHE::llc_update_replacement_state(unsigned int, unsigned int, unsigned int, unsigned long, unsigned long, unsigned long, unsigned int, unsigned char)
void CACHE::llc_update_replacement_state(uint32_t cpu, uint32_t set, uint32_t way, uint64_t full_addr, uint64_t ip, uint64_t victim_addr, uint32_t type, uint8_t hit)
{
    string TYPE_NAME;
    if (type == LOAD)
        TYPE_NAME = "LOAD";
    else if (type == RFO)
        TYPE_NAME = "RFO";
    else if (type == PREFETCH)
        TYPE_NAME = "PF";
    else if (type == WRITEBACK)
        TYPE_NAME = "WB";
    else
        assert(0);

    if (hit)
        TYPE_NAME += "_HIT";
    else
        TYPE_NAME += "_MISS";

    if ((type == WRITEBACK) && ip)
        assert(0);

    // uncomment this line to see the LLC accesses
    // cout << "CPU: " << cpu << "  LLC " << setw(9) << TYPE_NAME << " set: " << setw(5) << set << " way: " << setw(2) << way;
    // cout << hex << " paddr: " << setw(12) << paddr << " ip: " << setw(8) << ip << " victim_addr: " << victim_addr << dec << endl;

    // baseline LRU
    if (hit && (type == WRITEBACK)) // writeback hit does not update LRU state
        return;

    return lru_update(set, way);
}

// Assembly:
subq $0x68, %rsp
movb 0x80(%rsp), %al
movl 0x78(%rsp), %eax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl %edx, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x32f0
cmpl $0x0, 0x78(%rsp)
jne 0x227cf
leaq 0x19d8(%rip), %rsi      # 0x24179
leaq 0x20(%rsp), %rdi
callq 0x32d0
jmp 0x227ad
jmp 0x22848
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3150
jmp 0x228f0
cmpl $0x1, 0x78(%rsp)
jne 0x227eb
leaq 0x19a1(%rip), %rsi      # 0x2417e
leaq 0x20(%rsp), %rdi
callq 0x32d0
jmp 0x227e9
jmp 0x22846
cmpl $0x2, 0x78(%rsp)
jne 0x22807
leaq 0x1989(%rip), %rsi      # 0x24182
leaq 0x20(%rsp), %rdi
callq 0x32d0
jmp 0x22805
jmp 0x22844
cmpl $0x3, 0x78(%rsp)
jne 0x22823
leaq 0x1970(%rip), %rsi      # 0x24185
leaq 0x20(%rsp), %rdi
callq 0x32d0
jmp 0x22821
jmp 0x22842
leaq 0x7da(%rip), %rdi       # 0x23004
leaq 0x1957(%rip), %rsi      # 0x24188
movl $0x1d, %edx
leaq 0x196a(%rip), %rcx      # 0x241a7
callq 0x3160
jmp 0x22844
jmp 0x22846
jmp 0x22848
cmpb $0x0, 0x80(%rsp)
je 0x22867
leaq 0x19c6(%rip), %rsi      # 0x2421f
leaq 0x20(%rsp), %rdi
callq 0x3200
jmp 0x22865
jmp 0x2287c
leaq 0x19b6(%rip), %rsi      # 0x24224
leaq 0x20(%rsp), %rdi
callq 0x3200
jmp 0x2287a
jmp 0x2287c
cmpl $0x3, 0x78(%rsp)
jne 0x228aa
cmpq $0x0, 0x40(%rsp)
je 0x228aa
leaq 0x772(%rip), %rdi       # 0x23004
leaq 0x18ef(%rip), %rsi      # 0x24188
movl $0x25, %edx
leaq 0x1902(%rip), %rcx      # 0x241a7
callq 0x3160
cmpb $0x0, 0x80(%rsp)
je 0x228c5
cmpl $0x3, 0x78(%rsp)
jne 0x228c5
movl $0x1, 0x10(%rsp)
jmp 0x228e1
movq 0x8(%rsp), %rdi
movl 0x58(%rsp), %esi
movl 0x54(%rsp), %edx
callq 0x22570
jmp 0x228d9
movl $0x1, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3150
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x33c0
nopw (%rax,%rax)
// File: grogers0[P]dots_and_boxes/Board.cpp
// Function: Board::move(int, Edge)
bool Board::move(int player, Edge move)
{
    assert(is_move_valid(move));

    int oldscore = score[player];

    edges[edge_index(move)] = true;

    for_each_adjacent_node(move, [&] (Node node)
            { if (this->degree(node) == 4) ++score[player]; });

    return oldscore != score[player];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x27e0
testb $0x1, %al
jne 0x272e
jmp 0x2730
jmp 0x274f
leaq 0x78f4(%rip), %rdi      # 0xa02b
leaq 0x78c6(%rip), %rsi      # 0xa004
movl $0x11, %edx
leaq 0x78c4(%rip), %rcx      # 0xa00e
callq 0x2150
movq -0x50(%rbp), %rdi
movslq -0x14(%rbp), %rax
movl 0x8(%rdi,%rax,4), %eax
movl %eax, -0x1c(%rbp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
callq 0x32f0
movq -0x58(%rbp), %rdi
movslq %eax, %rsi
callq 0x3290
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x3380
movq -0x50(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, -0x38(%rbp)
movq %rdi, -0x48(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x38(%rbp), %esi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x28f0
movq -0x50(%rbp), %rcx
movl -0x1c(%rbp), %eax
movslq -0x14(%rbp), %rdx
cmpl 0x8(%rcx,%rdx,4), %eax
setne %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: grogers0[P]dots_and_boxes/Board.cpp
// Function: Board::is_move_valid(Edge) const
bool Board::is_move_valid(Edge move) const
{
    if (move.dir == HORIZ) {
        if (move.x < 0 || move.x >= width || move.y < 0 || move.y > height)
            return false;
    } else {
        if (move.x < 0 || move.x > width || move.y < 0 || move.y >= height)
            return false;
    }

    return !edges[edge_index(move)];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %esi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movw -0x8(%rbp), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x2859
movw -0x8(%rbp), %ax
shlw $0x8, %ax
sarw $0x9, %ax
cwtl
cmpl $0x0, %eax
jl 0x284e
movq -0x20(%rbp), %rcx
movw -0x8(%rbp), %ax
shlw $0x8, %ax
sarw $0x9, %ax
cwtl
cmpl (%rcx), %eax
jge 0x284e
movw -0x8(%rbp), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
jl 0x284e
movq -0x20(%rbp), %rcx
movw -0x8(%rbp), %ax
sarw $0x8, %ax
cwtl
cmpl 0x4(%rcx), %eax
jle 0x2857
movb $0x0, -0x1(%rbp)
jmp 0x28d8
jmp 0x28a8
movw -0x8(%rbp), %ax
shlw $0x8, %ax
sarw $0x9, %ax
cwtl
cmpl $0x0, %eax
jl 0x28a0
movq -0x20(%rbp), %rcx
movw -0x8(%rbp), %ax
shlw $0x8, %ax
sarw $0x9, %ax
cwtl
cmpl (%rcx), %eax
jg 0x28a0
movw -0x8(%rbp), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
jl 0x28a0
movq -0x20(%rbp), %rcx
movw -0x8(%rbp), %ax
sarw $0x8, %ax
cwtl
cmpl 0x4(%rcx), %eax
jl 0x28a6
movb $0x0, -0x1(%rbp)
jmp 0x28d8
jmp 0x28a8
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x32f0
movq -0x28(%rbp), %rdi
movslq %eax, %rsi
callq 0x33d0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: grogers0[P]dots_and_boxes/./Board.h
// Function: void Board::for_each_adjacent_node<Board::move(int, Edge)::$_0>(Edge, Board::move(int, Edge)::$_0) const
void Board::for_each_adjacent_node(Edge edge, F f) const
{
    if (edge.dir == HORIZ) {
        if (edge.y > 0)
            f(Node(edge.x, edge.y - 1));

        if (edge.y < height)
            f(Node(edge.x, edge.y));
    } else {
        if (edge.x > 0)
            f(Node(edge.x - 1, edge.y));

        if (edge.x < width)
            f(Node(edge.x, edge.y));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %esi, -0x4(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movw -0x4(%rbp), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x29ab
movw -0x4(%rbp), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
jle 0x2964
movw -0x4(%rbp), %ax
shlw $0x8, %ax
sarw $0x9, %ax
movswl %ax, %esi
movw -0x4(%rbp), %ax
sarw $0x8, %ax
movswl %ax, %edx
subl $0x1, %edx
leaq -0x22(%rbp), %rdi
callq 0x3e20
leaq -0x18(%rbp), %rdi
movzwl -0x22(%rbp), %esi
callq 0x3080
movq -0x30(%rbp), %rcx
movw -0x4(%rbp), %ax
sarw $0x8, %ax
cwtl
cmpl 0x4(%rcx), %eax
jge 0x29a6
movw -0x4(%rbp), %ax
shlw $0x8, %ax
sarw $0x9, %ax
movswl %ax, %esi
movw -0x4(%rbp), %ax
sarw $0x8, %ax
movswl %ax, %edx
leaq -0x24(%rbp), %rdi
callq 0x3e20
leaq -0x18(%rbp), %rdi
movzwl -0x24(%rbp), %esi
callq 0x3080
jmp 0x2a37
movw -0x4(%rbp), %ax
shlw $0x8, %ax
sarw $0x9, %ax
cwtl
cmpl $0x0, %eax
jle 0x29f0
movw -0x4(%rbp), %ax
shlw $0x8, %ax
sarw $0x9, %ax
movswl %ax, %esi
subl $0x1, %esi
movw -0x4(%rbp), %ax
sarw $0x8, %ax
movswl %ax, %edx
leaq -0x26(%rbp), %rdi
callq 0x3e20
leaq -0x18(%rbp), %rdi
movzwl -0x26(%rbp), %esi
callq 0x3080
movq -0x30(%rbp), %rcx
movw -0x4(%rbp), %ax
shlw $0x8, %ax
sarw $0x9, %ax
cwtl
cmpl (%rcx), %eax
jge 0x2a35
movw -0x4(%rbp), %ax
shlw $0x8, %ax
sarw $0x9, %ax
movswl %ax, %esi
movw -0x4(%rbp), %ax
sarw $0x8, %ax
movswl %ax, %edx
leaq -0x28(%rbp), %rdi
callq 0x3e20
leaq -0x18(%rbp), %rdi
movzwl -0x28(%rbp), %esi
callq 0x3080
jmp 0x2a37
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: grogers0[P]dots_and_boxes/./Board.h
// Function: void Board::for_each_adjacent_edge<Board::degree(Node) const::$_0>(Node, Board::degree(Node) const::$_0) const
void Board::for_each_adjacent_edge(Node node, F f) const
{
    f(Edge(HORIZ, node.x, node.y));
    f(Edge(HORIZ, node.x, node.y + 1));
    f(Edge(VERT, node.x, node.y));
    f(Edge(VERT, node.x + 1, node.y));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movw %ax, -0x2(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movsbl -0x2(%rbp), %edx
movsbl -0x1(%rbp), %ecx
leaq -0x24(%rbp), %rdi
xorl %esi, %esi
callq 0x41d0
movl -0x24(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x3140
movsbl -0x2(%rbp), %edx
movsbl -0x1(%rbp), %ecx
addl $0x1, %ecx
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x41d0
movl -0x28(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x3140
movsbl -0x2(%rbp), %edx
movsbl -0x1(%rbp), %ecx
leaq -0x2c(%rbp), %rdi
movl $0x1, %esi
callq 0x41d0
movl -0x2c(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x3140
movsbl -0x2(%rbp), %edx
addl $0x1, %edx
movsbl -0x1(%rbp), %ecx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x41d0
movl -0x30(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x3140
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: grogers0[P]dots_and_boxes/Board.cpp
// Function: basename_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string basename_str(const std::string &str)
{
    char *cpy = strdup(str.c_str());
    char *base = basename(cpy);
    std::string ret(base);
    free(cpy);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x2440
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2370
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x22(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2410
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x3510
jmp 0x2e39
leaq -0x22(%rbp), %rdi
callq 0x2270
movq -0x18(%rbp), %rdi
callq 0x22d0
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x2e77
jmp 0x2e6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x22(%rbp), %rdi
callq 0x2270
jmp 0x2e81
movq -0x50(%rbp), %rdi
callq 0x2140
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2400
nopw (%rax,%rax)
// File: grogers0[P]dots_and_boxes/InputOutput.cpp
// Function: Board::print_horiz_edges(int, _IO_FILE*) const
void Board::print_horiz_edges(int y, FILE *fp) const
{
    fprintf(fp, "+");
    for (int x = 0; x < width; ++x) {
        if (edges[edge_index(Edge(HORIZ, x, y))])
            fprintf(fp, "-+");
        else
            fprintf(fp, " +");
    }
    fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x59eb(%rip), %rsi      # 0xa1e1
movb $0x0, %al
callq 0x2340
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x487d
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x41d0
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x32f0
movq -0x30(%rbp), %rdi
movslq %eax, %rsi
callq 0x33d0
testb $0x1, %al
jne 0x484a
jmp 0x485e
movq -0x18(%rbp), %rdi
leaq 0x5988(%rip), %rsi      # 0xa1dd
movb $0x0, %al
callq 0x2340
jmp 0x4870
movq -0x18(%rbp), %rdi
leaq 0x5977(%rip), %rsi      # 0xa1e0
movb $0x0, %al
callq 0x2340
jmp 0x4872
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4804
movq -0x18(%rbp), %rdi
leaq 0x5963(%rip), %rsi      # 0xa1eb
movb $0x0, %al
callq 0x2340
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: grogers0[P]dots_and_boxes/InputOutput.cpp
// Function: Board::print_vert_edges(int, _IO_FILE*) const
void Board::print_vert_edges(int y, FILE *fp) const
{
    for (int x = 0; x < width; ++x) {
        if (edges[edge_index(Edge(VERT, x, y))])
            fprintf(fp, "|");
        else
            fprintf(fp, " ");

        if (degree(Node(x, y)) == 4)
            fprintf(fp, "#");
        else
            fprintf(fp, " ");
    }

    if (edges[edge_index(Edge(VERT, width, y))])
        fprintf(fp, "|\n");
    else
        fprintf(fp, " \n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x498c
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x41d0
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x32f0
movq -0x38(%rbp), %rdi
movslq %eax, %rsi
callq 0x33d0
testb $0x1, %al
jne 0x490f
jmp 0x4923
movq -0x18(%rbp), %rdi
leaq 0x58c9(%rip), %rsi      # 0xa1e3
movb $0x0, %al
callq 0x2340
jmp 0x4935
movq -0x18(%rbp), %rdi
leaq 0x5d4e(%rip), %rsi      # 0xa67c
movb $0x0, %al
callq 0x2340
movl -0x1c(%rbp), %esi
movl -0xc(%rbp), %edx
leaq -0x22(%rbp), %rdi
callq 0x3e20
movq -0x30(%rbp), %rdi
movzwl -0x22(%rbp), %esi
callq 0x2cd0
cmpl $0x4, %eax
jne 0x496a
movq -0x18(%rbp), %rdi
leaq 0x5884(%rip), %rsi      # 0xa1e5
movb $0x0, %al
callq 0x2340
jmp 0x497c
movq -0x18(%rbp), %rdi
leaq 0x5d07(%rip), %rsi      # 0xa67c
movb $0x0, %al
callq 0x2340
jmp 0x497e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x48c2
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %edx
movl -0xc(%rbp), %ecx
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x41d0
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x32f0
movq -0x40(%rbp), %rdi
movslq %eax, %rsi
callq 0x33d0
testb $0x1, %al
jne 0x49cc
jmp 0x49e0
movq -0x18(%rbp), %rdi
leaq 0x5810(%rip), %rsi      # 0xa1e7
movb $0x0, %al
callq 0x2340
jmp 0x49f2
movq -0x18(%rbp), %rdi
leaq 0x57ff(%rip), %rsi      # 0xa1ea
movb $0x0, %al
callq 0x2340
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: grogers0[P]dots_and_boxes/InputOutput.cpp
// Function: Board::print(_IO_FILE*, int) const
void Board::print(FILE *fp, int player) const
{
    fprintf(fp, "%d %d %d %d\n", width, height, score[player], score[!player]);
    for (int y = 0; y < height; ++y) {
        print_horiz_edges(y, fp);
        print_vert_edges(y, fp);
    }
    print_horiz_edges(height, fp);
    fflush(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl (%rax), %edx
movl 0x4(%rax), %ecx
movslq -0x14(%rbp), %rsi
movl 0x8(%rax,%rsi,4), %r8d
cmpl $0x0, -0x14(%rbp)
setne %sil
xorb $-0x1, %sil
andb $0x1, %sil
movzbl %sil, %esi
movl 0x8(%rax,%rsi,4), %r9d
leaq 0x57a0(%rip), %rsi      # 0xa1ed
movb $0x0, %al
callq 0x2340
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x4a92
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x47d0
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x48a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4a5b
movq -0x20(%rbp), %rdi
movl 0x4(%rdi), %esi
movq -0x10(%rbp), %rdx
callq 0x47d0
movq -0x10(%rbp), %rdi
callq 0x22b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: grogers0[P]dots_and_boxes/InputOutput.cpp
// Function: read_board(_IO_FILE*)
Board read_board(FILE *fp)
{
    Board board;

    fscanf(fp, "%d %d %d %d\n", &board.height, &board.width,
            &board.score[0], &board.score[1]);
    if (feof(fp))
        exit(0);

    board.edges.assign(board.width * (board.height + 1) + board.height * (board.width + 1), false);

    for (int y = 0; y < board.height; ++y) {
        board.read_horiz_edges(y, fp);
        board.read_vert_edges(y, fp);
    }
    board.read_horiz_edges(board.height, fp);

    if (feof(fp))
        exit(0);

    return board;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5070
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rdi
movq %rcx, %rdx
addq $0x4, %rdx
movq %rcx, %r8
addq $0x8, %r8
movq %rcx, %r9
addq $0xc, %r9
leaq 0x5295(%rip), %rsi      # 0xa1ed
xorl %eax, %eax
callq 0x2450
jmp 0x4f61
movq -0x10(%rbp), %rdi
callq 0x2390
cmpl $0x0, %eax
je 0x4f90
xorl %edi, %edi
callq 0x22e0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x50d0
jmp 0x504a
movq -0x38(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movl (%rax), %edx
movl 0x4(%rax), %ecx
movl %ecx, %esi
incl %esi
movl %edx, %eax
imull %esi, %eax
incl %edx
imull %edx, %ecx
addl %ecx, %eax
movslq %eax, %rsi
movb $0x0, -0x25(%rbp)
leaq -0x25(%rbp), %rdx
callq 0x5090
jmp 0x4fc2
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x5006
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x4ac0
jmp 0x4fe7
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x4cc0
jmp 0x4ff9
jmp 0x4ffb
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4fc9
movq -0x38(%rbp), %rdi
movl 0x4(%rdi), %esi
movq -0x10(%rbp), %rdx
callq 0x4ac0
jmp 0x5018
movq -0x10(%rbp), %rdi
callq 0x2390
cmpl $0x0, %eax
je 0x502d
xorl %edi, %edi
callq 0x22e0
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5040
movq -0x38(%rbp), %rdi
callq 0x50d0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: grogers0[P]dots_and_boxes/BasicMoveDeciders.cpp
// Function: Board::decide_move_random()
Edge Board::decide_move_random()
{
    std::vector<Edge> valid_moves;

    std::for_each(edge_begin(), edge_end(), [&] (Edge edge)
            { if (this->is_move_valid(edge)) valid_moves.push_back(edge); });

    int r = 0;

    int fd = open("/dev/urandom", O_RDONLY);
    read(fd, &r, sizeof(r));
    close(fd);

    return valid_moves[r % valid_moves.size()];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7be0
movq -0xd8(%rbp), %rdi
callq 0x7c00
movl %edx, -0xcc(%rbp)
movq %rax, -0xc8(%rbp)
jmp 0x6dfe
movq -0xd8(%rbp), %rdi
movl -0xcc(%rbp), %eax
movq -0xc8(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x7c60
movl %edx, -0xe4(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0x6e3b
movq -0xd8(%rbp), %rax
movl -0xe4(%rbp), %ecx
movq -0xe0(%rbp), %rdx
movq %rdx, -0x78(%rbp)
movl %ecx, -0x70(%rbp)
movl -0x70(%rbp), %ecx
movl %ecx, -0x60(%rbp)
movq -0x78(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x88(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
movl -0x90(%rbp), %esi
movl -0x60(%rbp), %eax
movl %eax, -0xa0(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdx
movl -0xa0(%rbp), %ecx
movq -0x88(%rbp), %r8
movq -0x80(%rbp), %r9
callq 0x6fb0
movq %rdx, -0xf8(%rbp)
movq %rax, -0xf0(%rbp)
jmp 0x6ed5
movq -0xf8(%rbp), %rax
movq -0xf0(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movq %rax, -0xb0(%rbp)
movl $0x0, -0xbc(%rbp)
leaq 0x34ad(%rip), %rdi      # 0xa3af
xorl %esi, %esi
movb %sil, %al
callq 0x21a0
movl %eax, -0xfc(%rbp)
jmp 0x6f14
movl -0xfc(%rbp), %eax
movl %eax, -0xc0(%rbp)
movl -0xc0(%rbp), %edi
leaq -0xbc(%rbp), %rsi
movl $0x4, %edx
callq 0x2350
jmp 0x6f39
movl -0xc0(%rbp), %edi
callq 0x2460
jmp 0x6f46
movslq -0xbc(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7ce0
movq %rax, %rcx
movq -0x108(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
leaq -0x28(%rbp), %rdi
callq 0x7cc0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7d00
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7d00
movq -0x40(%rbp), %rdi
callq 0x2400
// File: grogers0[P]dots_and_boxes/BasicMoveDeciders.cpp
// Function: Board::decide_move_first()
Edge Board::decide_move_first()
{
    EdgeIterator it = std::find_if(edge_begin(), edge_end(),
            [&] (Edge edge)
            { return this->is_move_valid(edge); });
    return *it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x7c00
movq -0x98(%rbp), %rdi
movl %edx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x7c60
movq %rax, %rcx
movq -0x98(%rbp), %rax
movl %edx, -0x50(%rbp)
movq %rcx, -0x58(%rbp)
movl -0x50(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x60(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movl -0x68(%rbp), %esi
movl -0x40(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdx
movl -0x78(%rbp), %ecx
movq -0x60(%rbp), %r8
callq 0x7120
movl %edx, -0x88(%rbp)
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x1c(%rbp)
movl -0x88(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x7d60
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: grogers0[P]dots_and_boxes/DotsDriver.cpp
// Function: echo(void*)
void *echo(void *args)
{
    FILE *fd = (FILE *)args;
    char buf[200];
    while (fgets(buf, sizeof(buf), fd)) {
        fputs(buf, stderr);
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0xe0(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xc8, %esi
callq 0x23c0
cmpq $0x0, %rax
je 0x8f2a
leaq -0xe0(%rbp), %rdi
movq 0x60b8(%rip), %rax      # 0xefd8
movq (%rax), %rsi
callq 0x22a0
jmp 0x8ef7
xorl %eax, %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: grogers0[P]dots_and_boxes/DotsDriver.cpp
// Function: print_win_info(Board const&, int)
void print_win_info(const Board &board, int winning_player = -1)
{
    int score[2] = {board.get_score(0), board.get_score(1)};

    board.print(stdout);

    if (winning_player == -1) {
        if (score[0] > score[1]) {
            winning_player = 0;
        } else if (score[0] < score[1]) {
            winning_player = 1;
        } else {
            printf("tie game! final score => player 1: %d, player 2: %d\n",
                    score[0], score[1]);
            return;
        }
    }

    printf("player %d wins! final score => player 1: %d, player 2: %d\n",
            winning_player + 1, score[0], score[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x9450
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x9450
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x603f(%rip), %rax      # 0xefb8
movq (%rax), %rsi
xorl %edx, %edx
callq 0x4a00
cmpl $-0x1, -0xc(%rbp)
jne 0x8fc5
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x8f9a
movl $0x0, -0xc(%rbp)
jmp 0x8fc3
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x8fab
movl $0x1, -0xc(%rbp)
jmp 0x8fc1
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x15ea(%rip), %rdi      # 0xa5a2
movb $0x0, %al
callq 0x2040
jmp 0x8fdf
jmp 0x8fc3
jmp 0x8fc5
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl -0x14(%rbp), %edx
movl -0x10(%rbp), %ecx
leaq 0x15ff(%rip), %rdi      # 0xa5d7
movb $0x0, %al
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: grogers0[P]dots_and_boxes/DotsDriver.cpp
// Function: parseArgs(int, char**)
static void parseArgs(int argc, char **argv)
{
    if (argc < 5)
        usage();

    width = atoi(argv[1]);
    height = atoi(argv[2]);
    command[0] = argv[3];
    command[1] = argv[4];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x5, -0x4(%rbp)
jge 0x93ca
callq 0x9430
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movl %eax, 0x5ed3(%rip)      # 0xf2b0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x23a0
movl %eax, 0x5ec4(%rip)      # 0xf2b4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x5e71(%rip), %rdi      # 0xf270
callq 0x2300
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0x5e5d(%rip), %rdi      # 0xf270
addq $0x20, %rdi
callq 0x2300
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nikhilYadala[P]Python_to_cpp/Source/src/convert_to_cpp.cpp
// Function: is_symbol(char)
bool is_symbol(char c){
	char symbols[]=" =:;(){}[]|,.&+-<>*/'\n#";

	for(int i=0;symbols[i]!='#';++i)
		if(symbols[i]==c)
			return 1;
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movq 0x1275f(%rip), %rax     # 0x161b0
movq %rax, -0x20(%rbp)
movq 0x1275c(%rip), %rax     # 0x161b8
movq %rax, -0x18(%rbp)
movq 0x12759(%rip), %rax     # 0x161c0
movq %rax, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movsbl -0x20(%rbp,%rax), %eax
cmpl $0x23, %eax
je 0x3aa4
movslq -0x24(%rbp), %rax
movsbl -0x20(%rbp,%rax), %eax
movsbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3a97
movb $0x1, -0x1(%rbp)
jmp 0x3aa8
jmp 0x3a99
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3a72
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: nikhilYadala[P]Python_to_cpp/Source/src/convert_to_cpp.cpp
// Function: map_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
std::string map_type(std::string s, int l)
{
	if(s=="int")
		return "long int";
	if(s=="float")
		return "float";
	if(s=="s")
		return "artificial_string";
	else {
		std::cout<<"[ WARNING ] Bad type name "<<s<<"!! on line "<<l<<std::endl;
		return s;
	}


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x11d5e(%rip), %rsi     # 0x1604e
callq 0x71d0
testb $0x1, %al
jne 0x42fb
jmp 0x4346
leaq -0x15(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3400
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x11d32(%rip), %rsi     # 0x16049
callq 0x3340
jmp 0x431e
leaq -0x15(%rbp), %rdi
callq 0x32a0
jmp 0x4457
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x32a0
jmp 0x4461
movq -0x40(%rbp), %rdi
leaq 0x11d01(%rip), %rsi     # 0x16052
callq 0x71d0
testb $0x1, %al
jne 0x435c
jmp 0x43a7
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3400
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x11cda(%rip), %rsi     # 0x16052
callq 0x3340
jmp 0x437f
leaq -0x25(%rbp), %rdi
callq 0x32a0
jmp 0x4457
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x32a0
jmp 0x4461
movq -0x40(%rbp), %rdi
leaq 0x11f97(%rip), %rsi     # 0x16349
callq 0x71d0
testb $0x1, %al
jne 0x43bd
jmp 0x4402
leaq -0x26(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3400
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x11c57(%rip), %rsi     # 0x16030
callq 0x3340
jmp 0x43e0
leaq -0x26(%rbp), %rdi
callq 0x32a0
jmp 0x4457
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x32a0
jmp 0x4461
movq 0x1abcf(%rip), %rdi     # 0x1efd8
leaq 0x11c48(%rip), %rsi     # 0x16058
callq 0x3220
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
leaq 0x11c48(%rip), %rsi     # 0x16073
callq 0x3220
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x33e0
movq %rax, %rdi
movq 0x1ab83(%rip), %rsi     # 0x1efc8
callq 0x3280
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3150
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33f0
nopw (%rax,%rax)