LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CMU-SAFARI[P]ramulator/src/Memory.h
// Function: ramulator::Memory<ramulator::DDR3, ramulator::Controller>::record_core(int)
void record_core(int coreid) {
#ifndef INTEGRATED_WITH_GEM5
      record_read_requests[coreid] = num_read_requests[coreid];
      record_write_requests[coreid] = num_write_requests[coreid];
#endif
      for (auto ctrl : ctrls) {
        ctrl->record_core(coreid);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x1d0, %rdi            # imm = 0x1D0
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x9e8, %rdi            # imm = 0x9E8
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x49a10
movq -0x38(%rbp), %rdi
addq $0x280, %rdi            # imm = 0x280
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x38(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0xa98, %rdi            # imm = 0xA98
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x49a10
movq -0x38(%rbp), %rax
addq $0xc08, %rax            # imm = 0xC08
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36f70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36e00
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3fd70
testb $0x1, %al
jne 0x393ca
jmp 0x393f1
leaq -0x20(%rbp), %rdi
callq 0x3fdb0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x49a50
leaq -0x20(%rbp), %rdi
callq 0x3fe20
jmp 0x393b7
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Refresh.h
// Function: ramulator::Refresh<ramulator::DDR3>::tick_ref()
void tick_ref() {
    clk++;

    int refresh_interval = ctrl->channel->spec->speed_entry.nREFI;

    // Time to schedule a refresh
    if ((clk - refreshed) >= refresh_interval) {
      inject_refresh(true);
      // ALDRAM: update timing parameters based on temperatures
      ALDRAM::Temp current_temperature = ALDRAM::Temp::COLD;
      ctrl->update_temp(current_temperature);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x10(%rcx)
movq 0x8(%rcx), %rax
movq 0x1098(%rax), %rax
movq 0x390(%rax), %rax
movl 0x2dbc(%rax), %eax
movl %eax, -0xc(%rbp)
movq 0x10(%rcx), %rax
subq 0x18(%rcx), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jl 0x41021
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x422c0
movq -0x18(%rbp), %rax
movl $0x0, -0x10(%rbp)
movq 0x8(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x42430
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Refresh.h
// Function: ramulator::Refresh<ramulator::DDR3>::inject_refresh(bool)
void inject_refresh(bool b_ref_rank) {
    // Rank-level refresh
    if (b_ref_rank) {
      for (auto rank : ctrl->channel->children)
        refresh_target(ctrl, rank->id, -1, -1);
    }
    // Bank-level refresh. Simultaneously issue to all ranks (better performance than staggered refreshes).
    else {
      for (auto rank : ctrl->channel->children)
        refresh_target(ctrl, rank->id, bank_ref_counters[rank->id], -1);
    }
    refreshed = clk;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
testb $0x1, -0x9(%rbp)
je 0x4236c
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x1098(%rax), %rax
addq $0x3b0, %rax            # imm = 0x3B0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2be80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bd10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2ce10
testb $0x1, %al
jne 0x4232c
jmp 0x42367
leaq -0x20(%rbp), %rdi
callq 0x2ce50
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rdi), %rsi
movq -0x30(%rbp), %rax
movl 0x39c(%rax), %edx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl %r8d, %ecx
callq 0x42440
leaq -0x20(%rbp), %rdi
callq 0x2ce70
jmp 0x42319
jmp 0x42414
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x1098(%rax), %rax
addq $0x3b0, %rax            # imm = 0x3B0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2be80
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2bd10
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2ce10
testb $0x1, %al
jne 0x423b2
jmp 0x42412
leaq -0x40(%rbp), %rdi
callq 0x2ce50
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movl 0x39c(%rax), %eax
movl %eax, -0x5c(%rbp)
addq $0x20, %rdi
movq -0x50(%rbp), %rax
movslq 0x39c(%rax), %rsi
callq 0x384f0
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl -0x5c(%rbp), %edx
movl (%rax), %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x42440
leaq -0x40(%rbp), %rdi
callq 0x2ce70
jmp 0x4239f
jmp 0x42414
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Refresh.h
// Function: ramulator::Refresh<ramulator::DDR3>::refresh_target(ramulator::Controller<ramulator::DDR3>*, int, int, int)
void refresh_target(Controller<T>* ctrl, int rank, int bank, int sa)
  {
    vector<int> addr_vec(int(T::Level::MAX), -1);
    addr_vec[0] = ctrl->channel->id;
    addr_vec[1] = rank;
    addr_vec[2] = bank;
    addr_vec[3] = sa;
    Request req(addr_vec, Request::Type::REFRESH, NULL);
    bool res = ctrl->enqueue(req);
    assert(res);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
leaq -0x3d(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x2fb30
movq -0xe0(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x5, %esi
leaq -0x3c(%rbp), %rdx
callq 0x32d70
jmp 0x4248f
leaq -0x3d(%rbp), %rdi
callq 0x2fbd0
movq -0x10(%rbp), %rax
movq 0x1098(%rax), %rax
movl 0x39c(%rax), %eax
movl %eax, -0x110(%rbp)
xorl %eax, %eax
movl %eax, -0xe4(%rbp)
movl %eax, %esi
movq %rsi, -0x100(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x384f0
movl -0x110(%rbp), %ecx
movq -0xf8(%rbp), %rdi
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x10c(%rbp)
movl $0x1, %esi
callq 0x384f0
movl -0x10c(%rbp), %ecx
movq -0xf8(%rbp), %rdi
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x108(%rbp)
movl $0x2, %esi
callq 0x384f0
movl -0x108(%rbp), %ecx
movq -0xf8(%rbp), %rdi
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x104(%rbp)
movl $0x3, %esi
callq 0x384f0
movl -0x104(%rbp), %ecx
movq -0x100(%rbp), %rsi
movl %ecx, (%rax)
leaq -0xd0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x42660
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %r8d
leaq -0xb0(%rbp), %rdi
movl $0x2, %edx
callq 0x426a0
jmp 0x42580
leaq -0xd0(%rbp), %rdi
callq 0x367b0
movq -0x10(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x42730
movb %al, -0x111(%rbp)
jmp 0x425a4
movb -0x111(%rbp), %al
andb $0x1, %al
movb %al, -0xd1(%rbp)
testb $0x1, -0xd1(%rbp)
je 0x425bd
jmp 0x42627
leaq 0x20ec06(%rip), %rdi    # 0x2511ca
leaq 0x20ec03(%rip), %rsi    # 0x2511ce
movl $0x6b, %edx
leaq 0x20ec05(%rip), %rcx    # 0x2511dc
callq 0xc280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x3d(%rbp), %rdi
callq 0x2fbd0
jmp 0x4264e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x367b0
jmp 0x42645
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x36780
jmp 0x42645
leaq -0xb0(%rbp), %rdi
callq 0x36780
leaq -0x38(%rbp), %rdi
callq 0x2fcd0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x2fcd0
movq -0x48(%rbp), %rdi
callq 0xc5d0
nopw (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Controller.h
// Function: ramulator::Controller<ramulator::DDR3>::enqueue(ramulator::Request&)
bool enqueue(Request& req)
    {
        Queue& queue = get_queue(req.type);
        if (queue.max == queue.size())
            return false;

        req.arrive = clk;
        queue.q.push_back(req);
        // shortcut for read requests, if a write to same addr exists
        // necessary for coherence
        if (req.type == Request::Type::READ && find_if(writeq.q.begin(), writeq.q.end(),
                [req](Request& wreq){ return req.addr == wreq.addr;}) != writeq.q.end()){
            req.depart = clk + 1;
            pending.push_back(req);
            readq.q.pop_back();
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x42a10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0xc4(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3fdd0
movl %eax, %ecx
movl -0xc4(%rbp), %eax
cmpl %ecx, %eax
jne 0x42789
movb $0x0, -0x1(%rbp)
jmp 0x42921
movq -0xd0(%rbp), %rax
movq 0x1090(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41cb0
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %ecx
movb $0x0, -0xa1(%rbp)
movb $0x0, -0xa2(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd1(%rbp)
jne 0x42884
movq -0xd0(%rbp), %rdi
addq $0x10e0, %rdi           # imm = 0x10E0
movq %rdi, -0xf0(%rbp)
callq 0x42b70
movq -0xf0(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x417c0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x42ba0
movq -0xe8(%rbp), %rdx
movq %rdx, -0xa0(%rbp)
movb $0x1, -0xa1(%rbp)
movb $0x1, -0xa2(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x42a70
movq %rax, -0xe0(%rbp)
jmp 0x42849
movq -0xd0(%rbp), %rdi
movq -0xe0(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x10e0, %rdi           # imm = 0x10E0
callq 0x417c0
movq %rax, -0xc0(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x41790
movb %al, -0xd1(%rbp)
movb -0xd1(%rbp), %al
movb %al, -0xf1(%rbp)
testb $0x1, -0xa2(%rbp)
jne 0x4289b
jmp 0x428a7
leaq -0x98(%rbp), %rdi
callq 0x42c30
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x428b3
jmp 0x4291d
movq -0xd0(%rbp), %rdi
movq 0x1090(%rdi), %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
addq $0x1140, %rdi           # imm = 0x1140
movq -0x18(%rbp), %rsi
callq 0x41d80
movq -0xd0(%rbp), %rdi
addq $0x10c0, %rdi           # imm = 0x10C0
callq 0x42c50
jmp 0x4291d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
testb $0x1, -0xa2(%rbp)
jne 0x4290f
jmp 0x4291b
leaq -0x98(%rbp), %rdi
callq 0x42c30
jmp 0x4292f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0xc5d0
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Controller.h
// Function: ramulator::Controller<ramulator::DDR3>::get_queue(ramulator::Request::Type)
Queue& get_queue(Request::Type type)
    {
        switch (int(type)) {
            case int(Request::Type::READ): return readq;
            case int(Request::Type::WRITE): return writeq;
            default: return otherq;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x42a39
jmp 0x42a2f
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x42a49
jmp 0x42a59
movq -0x20(%rbp), %rax
addq $0x10c0, %rax           # imm = 0x10C0
movq %rax, -0x8(%rbp)
jmp 0x42a67
movq -0x20(%rbp), %rax
addq $0x10e0, %rax           # imm = 0x10E0
movq %rax, -0x8(%rbp)
jmp 0x42a67
movq -0x20(%rbp), %rax
addq $0x1120, %rax           # imm = 0x1120
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/DRAM.h
// Function: ramulator::DRAM<ramulator::DDR3>::update_state(ramulator::DDR3::Command, int const*)
void DRAM<T>::update_state(typename T::Command cmd, const int* addr)
{
    int child_id = addr[int(level)+1];
    if (lambda[int(cmd)])
        lambda[int(cmd)](this, child_id); // update this level

    if (level == spec->scope[int(cmd)] || !children.size())
        return; // stop recursion: updated all levels

    // recursively update my child
    children[child_id]->update_state(cmd, addr);
}

// 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), %rcx
movl 0x398(%rax), %edx
addl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x888(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x454a0
testb $0x1, %al
jne 0x44f8e
jmp 0x44fac
movq -0x28(%rbp), %rsi
movq 0x888(%rsi), %rdi
movslq -0xc(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movl -0x1c(%rbp), %edx
callq 0x454c0
movq -0x28(%rbp), %rcx
movl 0x398(%rcx), %eax
movq 0x390(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl 0x180(%rcx,%rdx,4), %eax
je 0x44fe0
movq -0x28(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
callq 0x2bfd0
cmpq $0x0, %rax
jne 0x44fe2
jmp 0x45005
movq -0x28(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
movslq -0x1c(%rbp), %rsi
callq 0x2f3f0
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x44f40
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/DDR3.h
// Function: ramulator::DDR3::is_closing(ramulator::DDR3::Command)
bool is_closing(Command cmd) 
    {
        switch(int(cmd)) {
            case int(Command::RDA):
            case int(Command::WRA):
            case int(Command::PRE):
            case int(Command::PREA):
                return true;
            default:
                return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
decl %eax
subl $0x2, %eax
jb 0x46167
jmp 0x4615a
movl -0x18(%rbp), %eax
addl $-0x5, %eax
subl $0x1, %eax
ja 0x4616d
jmp 0x46167
movb $0x1, -0x1(%rbp)
jmp 0x46171
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/DRAM.h
// Function: ramulator::DRAM<ramulator::DDR3>::check_row_open(ramulator::DDR3::Command, int const*)
bool DRAM<T>::check_row_open(typename T::Command cmd, const int* addr)
{
    int child_id = addr[int(level)+1];
    if (rowopen[int(cmd)]) {
        return rowopen[int(cmd)](this, cmd, child_id);  // stop recursion: there is a row hit at this level
    }

    if (child_id < 0 || !children.size())
        return false; // stop recursion: there were no row hits at any level

    // recursively check for row hits at my child
    return children[child_id]->check_row_open(cmd, addr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movl 0x398(%rax), %edx
addl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x24(%rbp)
movq 0x880(%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x31340
testb $0x1, %al
jne 0x46b4e
jmp 0x46b76
movq -0x30(%rbp), %rsi
movq 0x880(%rsi), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movl -0x14(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0x31360
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x46bc0
cmpl $0x0, -0x24(%rbp)
jl 0x46b92
movq -0x30(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
callq 0x2bfd0
cmpq $0x0, %rax
jne 0x46b98
movb $0x0, -0x1(%rbp)
jmp 0x46bc0
movq -0x30(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
movslq -0x24(%rbp), %rsi
callq 0x2f3f0
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x46b00
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Controller.h
// Function: ramulator::Controller<ramulator::DDR3>::finish(long, long)
void finish(long read_req, long dram_cycles) {
      read_latency_avg = read_latency_sum.value() / read_req;
      req_queue_length_avg = req_queue_length_sum.value() / dram_cycles;
      read_req_queue_length_avg = read_req_queue_length_sum.value() / dram_cycles;
      write_req_queue_length_avg = write_req_queue_length_sum.value() / dram_cycles;
      // call finish function of each channel
      channel->finish(dram_cycles);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x848, %rdi            # imm = 0x848
callq 0x485e0
movq -0x40(%rbp), %rdi
cvtsi2sdq -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
addq $0x7b0, %rdi            # imm = 0x7B0
leaq -0x20(%rbp), %rsi
callq 0x485b0
movq -0x40(%rbp), %rdi
addq $0x978, %rdi            # imm = 0x978
callq 0x485e0
movq -0x40(%rbp), %rdi
cvtsi2sdq -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x8e0, %rdi            # imm = 0x8E0
leaq -0x28(%rbp), %rsi
callq 0x485b0
movq -0x40(%rbp), %rdi
addq $0xaa8, %rdi            # imm = 0xAA8
callq 0x485e0
movq -0x40(%rbp), %rdi
cvtsi2sdq -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0xa10, %rdi            # imm = 0xA10
leaq -0x30(%rbp), %rsi
callq 0x485b0
movq -0x40(%rbp), %rdi
addq $0xbd8, %rdi            # imm = 0xBD8
callq 0x485e0
movq -0x40(%rbp), %rdi
cvtsi2sdq -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0xb40, %rdi            # imm = 0xB40
leaq -0x38(%rbp), %rsi
callq 0x485b0
movq -0x40(%rbp), %rax
movq 0x1098(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x48720
addq $0x40, %rsp
popq %rbp
retq
nop
// File: CMU-SAFARI[P]ramulator/src/DRAM.h
// Function: ramulator::DRAM<ramulator::DDR3>::finish(long)
void DRAM<T>::finish(long dram_cycles) {
  // finalize busy cycles
  busy_cycles = active_cycles.value() + refresh_cycles.value() - active_refresh_overlap_cycles.value();

  // finalize average serving requests
  average_serving_requests = serving_requests.value() / dram_cycles;

  if (!children.size()) {
    return;
  }

  for (auto child : children) {
    child->finish(dram_cycles);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x485e0
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x58(%rbp)
addq $0x98, %rdi
callq 0x485e0
movq -0x48(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
addq $0x1c8, %rdi            # imm = 0x1C8
callq 0x485e0
movq -0x48(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
addq $0x130, %rdi            # imm = 0x130
leaq -0x18(%rbp), %rsi
callq 0x485b0
movq -0x48(%rbp), %rdi
addq $0x260, %rdi            # imm = 0x260
callq 0x485e0
movq -0x48(%rbp), %rdi
cvtsi2sdq -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
addq $0x2f8, %rdi            # imm = 0x2F8
leaq -0x20(%rbp), %rsi
callq 0x485b0
movq -0x48(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
callq 0x2bfd0
cmpq $0x0, %rax
jne 0x487e3
jmp 0x48846
movq -0x48(%rbp), %rax
addq $0x3b0, %rax            # imm = 0x3B0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2be80
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2bd10
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2ce10
testb $0x1, %al
jne 0x4881e
jmp 0x48846
leaq -0x30(%rbp), %rdi
callq 0x2ce50
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x48720
leaq -0x30(%rbp), %rdi
callq 0x2ce70
jmp 0x4880b
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/Controller.h
// Function: ramulator::Controller<ramulator::DDR3>::record_core(int)
void record_core(int coreid) {
#ifndef INTEGRATED_WITH_GEM5
      record_read_hits[coreid] = read_row_hits[coreid];
      record_read_misses[coreid] = read_row_misses[coreid];
      record_read_conflicts[coreid] = read_row_conflicts[coreid];
      record_write_hits[coreid] = write_row_hits[coreid];
      record_write_misses[coreid] = write_row_misses[coreid];
      record_write_conflicts[coreid] = write_row_conflicts[coreid];
#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x2f8, %rdi            # imm = 0x2F8
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x20(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0xc70, %rdi            # imm = 0xC70
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x49a10
movq -0x20(%rbp), %rdi
addq $0x3a8, %rdi            # imm = 0x3A8
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x20(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0xd20, %rdi            # imm = 0xD20
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x49a10
movq -0x20(%rbp), %rdi
addq $0x458, %rdi            # imm = 0x458
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0xdd0, %rdi            # imm = 0xDD0
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x49a10
movq -0x20(%rbp), %rdi
addq $0x508, %rdi            # imm = 0x508
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0xe80, %rdi            # imm = 0xE80
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x49a10
movq -0x20(%rbp), %rdi
addq $0x5b8, %rdi            # imm = 0x5B8
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0xf30, %rdi            # imm = 0xF30
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x49a10
movq -0x20(%rbp), %rdi
addq $0x668, %rdi            # imm = 0x668
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0xfe0, %rdi            # imm = 0xFE0
movl -0xc(%rbp), %esi
callq 0x41b70
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x49a10
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/Config.h
// Function: ramulator::Config::is_early_exit() const
bool is_early_exit() const {
      // the default value is true
      if (options.find("early_exit") != options.end()) {
        if ((options.find("early_exit"))->second == "off") {
          return false;
        }
        return true;
      }
      return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xc5e0
movq -0x90(%rbp), %rdx
leaq 0x207835(%rip), %rsi    # 0x251874
leaq -0x38(%rbp), %rdi
callq 0x17a40
jmp 0x4a04a
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1c1d0
movq %rax, -0xa8(%rbp)
jmp 0x4a063
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1c200
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1c1a0
movb %al, -0xa9(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc6b8
leaq -0x39(%rbp), %rdi
callq 0xc3c0
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x4a0b2
jmp 0x4a1be
movq -0x98(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xc5e0
movq -0xb8(%rbp), %rdx
leaq 0x207793(%rip), %rsi    # 0x251874
leaq -0x80(%rbp), %rdi
callq 0x17a40
jmp 0x4a0ec
movq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c1d0
movq %rax, -0xc8(%rbp)
jmp 0x4a105
movq -0xc8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1c230
movq %rax, %rdi
addq $0x20, %rdi
leaq 0x207758(%rip), %rsi    # 0x25187f
callq 0x17f10
movb %al, -0xc9(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xc6b8
leaq -0x81(%rbp), %rdi
callq 0xc3c0
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x4a153
jmp 0x4a1b8
movb $0x0, -0x1(%rbp)
jmp 0x4a1c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4a17c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc6b8
leaq -0x39(%rbp), %rdi
callq 0xc3c0
jmp 0x4a1d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4a1aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xc6b8
leaq -0x81(%rbp), %rdi
callq 0xc3c0
jmp 0x4a1d0
movb $0x1, -0x1(%rbp)
jmp 0x4a1c2
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xc5d0
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/StatType.h
// Function: Stats::StatList::printall()
void printall() {
    for(off_type i = 0 ; i < list.size() ; ++i) {
      if (!list[i]) {
        continue;
      }
      if (list[i]->is_nozero() && list[i]->zero()) {
        continue;
      }
      if (list[i]->is_display()) {
        list[i]->prepare();
        list[i]->print(stat_output);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
callq 0x26e10
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x4a2d2
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x4b0b0
cmpq $0x0, (%rax)
jne 0x4a234
jmp 0x4a2c4
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x4b0b0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testb $0x1, %al
jne 0x4a251
jmp 0x4a270
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x4b0b0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x4a26e
jmp 0x4a270
jmp 0x4a2c4
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x4b0b0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb $0x1, %al
jne 0x4a28d
jmp 0x4a2c2
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x4b0b0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x4b0b0
movq -0x18(%rbp), %rsi
movq (%rax), %rdi
addq $0x18, %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x4a2c4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4a1fb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/SALP.h
// Function: ramulator::SALP::is_closing(ramulator::SALP::Command)
bool is_closing(Command cmd) 
    {
        switch(int(cmd)) {
            case int(Command::RDA):
            case int(Command::WRA):
            case int(Command::PRE):
            case int(Command::PRER):
            case int(Command::PRE_OTHER):
                return true;
            default:
                return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
addl $-0x2, %eax
subl $0x2, %eax
jb 0x794f2
jmp 0x794db
movl -0x18(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x794f2
jmp 0x794e8
movl -0x18(%rbp), %eax
subl $0xd, %eax
jne 0x794f8
jmp 0x794f2
movb $0x1, -0x1(%rbp)
jmp 0x794fc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/LPDDR3.h
// Function: ramulator::LPDDR3::is_closing(ramulator::LPDDR3::Command)
bool is_closing(Command cmd) 
    {
        switch(int(cmd)) {
            case int(Command::RDA):
            case int(Command::WRA):
            case int(Command::PRE):
            case int(Command::PRA):
                return true;
            default:
                return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
decl %eax
subl $0x2, %eax
jb 0x8fc17
jmp 0x8fc0a
movl -0x18(%rbp), %eax
addl $-0x5, %eax
subl $0x1, %eax
ja 0x8fc1d
jmp 0x8fc17
movb $0x1, -0x1(%rbp)
jmp 0x8fc21
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/ALDRAM.cpp
// Function: ramulator::ALDRAM::aldram_timing(ramulator::ALDRAM::Temp)
void ALDRAM::aldram_timing(Temp current_temperature)
{
    for (int i = 0; i < int(Level::MAX); i++) {
        for (int j = 0; j < int(Command::MAX); j++) {
            timing[i][j].clear();
        }
    }
    temperature = current_temperature;
    read_latency = speed_entry.nCL + speed_entry.nBL;
    init_timing(speed_table[int(temperature)][int(current_speed)]);

    //std::cout << "vector size: " << timing[int(Temp::HOT)][int(current_speed)].size() << endl;
    //std::cout << "after cold nRCD : ";
    //std::cout << int(timing[int(Level::Bank)][int(Command::ACT)][0].val) << endl << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x5, -0x10(%rbp)
jge 0x1719fb
movl $0x0, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jge 0x1719ee
movq -0x90(%rbp), %rdi
addq $0x1860, %rdi           # imm = 0x1860
movslq -0x10(%rbp), %rax
imulq $0x120, %rax, %rax      # imm = 0x120
addq %rax, %rdi
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x177270
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1719b1
jmp 0x1719f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1719a4
movq -0x90(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x2744(%rax)
movl 0x33b4(%rax), %ecx
addl 0x33a8(%rax), %ecx
movl %ecx, 0x3400(%rax)
movq %rax, %rsi
addq $0x2750, %rsi           # imm = 0x2750
movslq 0x2744(%rax), %rcx
imulq $0x620, %rcx, %rcx      # imm = 0x620
addq %rcx, %rsi
movslq 0x2740(%rax), %rax
imulq $0x70, %rax, %rax
addq %rax, %rsi
leaq -0x88(%rbp), %rdi
movl $0x70, %edx
callq 0xc300
movq -0x90(%rbp), %rdi
movups -0x28(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x60(%rax)
movups -0x38(%rbp), %xmm0
movups %xmm0, 0x50(%rax)
movups -0x48(%rbp), %xmm0
movups %xmm0, 0x40(%rax)
movups -0x88(%rbp), %xmm0
movups -0x78(%rbp), %xmm1
movups -0x68(%rbp), %xmm2
movups -0x58(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x170300
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/Cache.cpp
// Function: ramulator::Cache::is_hit(std::__cxx11::list<ramulator::Cache::Line, std::allocator<ramulator::Cache::Line>>&, long, std::_List_iterator<ramulator::Cache::Line>*)
bool Cache::is_hit(std::list<Line>& lines, long addr,
    std::list<Line>::iterator* pos_ptr) {
  auto pos = find_if(lines.begin(), lines.end(),
      [addr, this](Line l){return (l.tag == get_tag(addr));});
  *pos_ptr = pos;
  if (pos == lines.end()) {
    return false;
  }
  return !pos->lock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x180800
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x180690
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x17ea30
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x180690
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x180660
testb $0x1, %al
jne 0x17ddc1
jmp 0x17ddc7
movb $0x0, -0x1(%rbp)
jmp 0x17ddda
leaq -0x30(%rbp), %rdi
callq 0x180300
movb 0x10(%rax), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Cache.cpp
// Function: ramulator::Cache::allocate_line(std::__cxx11::list<ramulator::Cache::Line, std::allocator<ramulator::Cache::Line>>&, long)
std::list<Cache::Line>::iterator Cache::allocate_line(
    std::list<Line>& lines, long addr) {
  // See if an eviction is needed
  if (need_eviction(lines, addr)) {
    // Get victim.
    // The first one might still be locked due to reorder in MC
    auto victim = find_if(lines.begin(), lines.end(),
        [this](Line line) {
          bool check = !line.lock;
          if (!is_first_level) {
            for (auto hc : higher_cache) {
              if(!check) {
                return check;
              }
              check = check && hc->check_unlock(line.addr);
            }
          }
          return check;
        });
    if (victim == lines.end()) {
      return victim;  // doesn't exist a line that's already unlocked in each level
    }
    assert(victim != lines.end());
    evict(&lines, victim);
  }

  // Allocate newline, with lock bit on and dirty bit off
  lines.push_back(Line(addr, get_tag(addr)));
  auto last_element = lines.end();
  --last_element;
  return last_element;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x17e900
testb $0x1, %al
jne 0x17de25
jmp 0x17dede
movq -0x18(%rbp), %rdi
callq 0x180800
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x180690
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x17e9d0
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x180690
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x180660
testb $0x1, %al
jne 0x17de7f
jmp 0x17de84
jmp 0x17df2e
movq -0x18(%rbp), %rdi
callq 0x180690
movq %rax, -0x48(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x180830
testb $0x1, %al
jne 0x17dea4
jmp 0x17dea6
jmp 0x17dec5
leaq 0xdd23d(%rip), %rdi     # 0x25b0ea
leaq 0xdce77(%rip), %rsi     # 0x25ad2b
movl $0x143, %edx            # imm = 0x143
leaq 0xdd240(%rip), %rcx     # 0x25b100
callq 0xc280
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdx
callq 0x17e5a0
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1802e0
movq -0x80(%rbp), %rsi
movq %rax, %rdx
leaq -0x68(%rbp), %rdi
callq 0x180ac0
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1802a0
movq -0x18(%rbp), %rdi
callq 0x180690
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x180af0
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Cache.cpp
// Function: ramulator::Cache::evictline(long, bool)
void Cache::evictline(long addr, bool dirty) {

  auto it = cache_lines.find(get_index(addr));
  assert(it != cache_lines.end()); // check inclusive cache
  auto& lines = it->second;
  auto line = find_if(lines.begin(), lines.end(),
      [addr, this](Line l){return (l.tag == get_tag(addr));});

  assert(line != lines.end());
  // Update LRU queue. The dirty bit will be set if the dirty
  // bit inherited from higher level(s) is set.
  lines.push_back(Line(addr, get_tag(addr), false,
      dirty || line->dirty));
  lines.erase(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
addq $0x6c0, %rax            # imm = 0x6C0
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x180750
movq -0xa0(%rbp), %rdi
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x180720
movq -0x98(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x6c0, %rdi            # imm = 0x6C0
callq 0x1807b0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x180780
testb $0x1, %al
jne 0x17dfbf
jmp 0x17dfc1
jmp 0x17dfe0
leaq 0xdd022(%rip), %rdi     # 0x25afea
leaq 0xdcd5c(%rip), %rsi     # 0x25ad2b
movl $0xca, %edx
leaq 0xdd027(%rip), %rcx     # 0x25b002
callq 0xc280
leaq -0x20(%rbp), %rdi
callq 0x1807e0
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x180800
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x180690
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0x17e140
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x180690
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x180830
testb $0x1, %al
jne 0x17e05a
jmp 0x17e05c
jmp 0x17e07b
leaq 0xdcfcc(%rip), %rdi     # 0x25b02f
leaq 0xdccc1(%rip), %rsi     # 0x25ad2b
movl $0xcf, %edx
leaq 0xdcf8c(%rip), %rcx     # 0x25b002
callq 0xc280
movq -0x98(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1802e0
movq %rax, -0xb0(%rbp)
movb $0x1, %al
testb $0x1, -0x11(%rbp)
movb %al, -0xa1(%rbp)
jne 0x17e0c8
leaq -0x40(%rbp), %rdi
callq 0x180300
movb 0x11(%rax), %al
movb %al, -0xa1(%rbp)
movq -0xb0(%rbp), %rdx
movq -0xb8(%rbp), %rsi
movb -0xa1(%rbp), %al
xorl %ecx, %ecx
movzbl %al, %r8d
andl $0x1, %r8d
leaq -0x80(%rbp), %rdi
xorl %ecx, %ecx
callq 0x180320
movq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1802a0
movq -0x38(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1803c0
movq -0xc8(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x180370
movq %rax, -0x90(%rbp)
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: CMU-SAFARI[P]ramulator/src/Cache.cpp
// Function: ramulator::Cache::need_eviction(std::__cxx11::list<ramulator::Cache::Line, std::allocator<ramulator::Cache::Line>> const&, long)
bool Cache::need_eviction(const std::list<Line>& lines, long addr) {
  if (find_if(lines.begin(), lines.end(),
      [addr, this](Line l){
        return (get_tag(addr) == l.tag);})
      != lines.end()) {
    // Due to MSHR, the program can't reach here. Just for checking
    assert(false);
  } else {
    if (lines.size() < assoc) {
      return false;
    } else {
      return true;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x180b70
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x180ba0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x17eb10
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x180ba0
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x180b40
testb $0x1, %al
jne 0x17e982
jmp 0x17e9a1
leaq 0xd11d8(%rip), %rdi     # 0x24fb61
leaq 0xdc39b(%rip), %rsi     # 0x25ad2b
movl $0x165, %edx            # imm = 0x165
leaq 0xdc7fb(%rip), %rcx     # 0x25b197
callq 0xc280
movq -0x18(%rbp), %rdi
callq 0x180860
movq -0x58(%rbp), %rcx
movl 0x670(%rcx), %ecx
cmpq %rcx, %rax
jae 0x17e9bf
movb $0x0, -0x1(%rbp)
jmp 0x17e9c3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: CMU-SAFARI[P]ramulator/src/Cache.cpp
// Function: ramulator::Cache::callback(ramulator::Request&)
void Cache::callback(Request& req) {
  debug("level %d", int(level));

  auto it = find_if(mshr_entries.begin(), mshr_entries.end(),
      [&req, this](std::pair<long, std::list<Line>::iterator> mshr_entry) {
        return (align(mshr_entry.first) == align(req.addr));
      });

  if (it != mshr_entries.end()) {
    it->second->lock = false;
    mshr_entries.erase(it);
  }

  if (higher_cache.size()) {
    for (auto hc : higher_cache) {
      hc->callback(req);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x690, %rdi            # imm = 0x690
callq 0x180bd0
movq -0x78(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x690, %rdi            # imm = 0x690
callq 0x180540
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x17ece0
movq -0x78(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x690, %rdi            # imm = 0x690
callq 0x180540
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x180500
testb $0x1, %al
jne 0x17ec12
jmp 0x17ec5a
leaq -0x18(%rbp), %rdi
callq 0x180570
movq %rax, %rdi
addq $0x8, %rdi
callq 0x180300
movq %rax, %rcx
movq -0x78(%rbp), %rax
movb $0x0, 0x10(%rcx)
addq $0x690, %rax            # imm = 0x690
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x180c70
movq -0x80(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x180c00
movq %rax, -0x50(%rbp)
movq -0x78(%rbp), %rdi
addq $0x640, %rdi            # imm = 0x640
callq 0x180920
cmpq $0x0, %rax
je 0x17ecd5
movq -0x78(%rbp), %rax
addq $0x640, %rax            # imm = 0x640
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x180940
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x180970
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1809a0
testb $0x1, %al
jne 0x17ecab
jmp 0x17ecd3
leaq -0x60(%rbp), %rdi
callq 0x1809e0
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17eb80
leaq -0x60(%rbp), %rdi
callq 0x180a00
jmp 0x17ec98
jmp 0x17ecd5
addq $0x80, %rsp
popq %rbp
retq
nop
// File: CMU-SAFARI[P]ramulator/src/Cache.cpp
// Function: ramulator::Cache::tick()
void Cache::tick() {

    if(!lower_cache->is_last_level)
        lower_cache->tick();

    for (auto it = retry_list.begin(); it != retry_list.end(); it++) {
        if(lower_cache->send(*it))
            it = retry_list.erase(it);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x658(%rax), %rax
testb $0x1, 0x661(%rax)
jne 0x17ed8d
movq -0xa8(%rbp), %rax
movq 0x658(%rax), %rdi
callq 0x17ed50
movq -0xa8(%rbp), %rdi
addq $0x6a8, %rdi            # imm = 0x6A8
callq 0x42b70
movq %rax, -0x10(%rbp)
movq -0xa8(%rbp), %rdi
addq $0x6a8, %rdi            # imm = 0x6A8
callq 0x417c0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x41790
testb $0x1, %al
jne 0x17edd1
jmp 0x17eeb0
movq -0xa8(%rbp), %rax
movq 0x658(%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x41cf0
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x42ba0
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x17d630
movb %al, -0xa9(%rbp)
jmp 0x17ee1d
leaq -0x78(%rbp), %rdi
callq 0x36780
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x17ee32
jmp 0x17ee97
movq -0xa8(%rbp), %rax
addq $0x6a8, %rax            # imm = 0x6A8
movq %rax, -0xc8(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x41d60
movq -0xc8(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x41d10
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x17ee97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x36780
jmp 0x17eeb9
jmp 0x17ee99
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x43320
movq %rax, -0xa0(%rbp)
jmp 0x17eda4
addq $0xd0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xc5d0
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Cache.h
// Function: ramulator::Cache::get_lines[abi:cxx11](long)
std::list<Line>& get_lines(long addr) {
    if (cache_lines.find(get_index(addr))
        == cache_lines.end()) {
      cache_lines.insert(make_pair(get_index(addr),
          std::list<Line>()));
    }
    return cache_lines[get_index(addr)];
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
addq $0x6c0, %rax            # imm = 0x6C0
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x180750
movq -0xa8(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x180720
movq -0xa0(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x6c0, %rdi            # imm = 0x6C0
callq 0x1807b0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x181080
testb $0x1, %al
jne 0x18015b
jmp 0x18022e
movq -0xa0(%rbp), %rdi
movq %rdi, %rax
addq $0x6c0, %rax            # imm = 0x6C0
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x180750
movl %eax, -0x4c(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq $0x0, -0x60(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x181130
movq -0xb0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x1810f0
jmp 0x1801b3
movq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1810b0
movb %dl, -0xc1(%rbp)
movq %rax, -0xc0(%rbp)
jmp 0x1801d2
movb -0xc1(%rbp), %al
movq -0xc0(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movb %al, -0x88(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x181150
leaq -0x70(%rbp), %rdi
callq 0x4b5d0
jmp 0x18022e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x180223
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x181150
leaq -0x70(%rbp), %rdi
callq 0x4b5d0
jmp 0x180270
movq -0xa0(%rbp), %rdi
movq %rdi, %rax
addq $0x6c0, %rax            # imm = 0x6C0
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x180750
movq -0xd0(%rbp), %rdi
movl %eax, -0x94(%rbp)
leaq -0x94(%rbp), %rsi
callq 0x181170
addq $0xd0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xc5d0
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/Cache.h
// Function: ramulator::Cache::hit_mshr(long)
std::vector<std::pair<long, std::list<Line>::iterator>>::iterator
  hit_mshr(long addr) {
    auto mshr_it =
        find_if(mshr_entries.begin(), mshr_entries.end(),
            [addr, this](std::pair<long, std::list<Line>::iterator>
                   mshr_entry) {
              return (align(mshr_entry.first) == align(addr));
            });
    return mshr_it;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x690, %rdi            # imm = 0x690
callq 0x180bd0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x690, %rdi            # imm = 0x690
callq 0x180540
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x1824f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/Cache.h
// Function: ramulator::Cache::all_sets_locked(std::__cxx11::list<ramulator::Cache::Line, std::allocator<ramulator::Cache::Line>> const&)
bool all_sets_locked(const std::list<Line>& lines) {
    if (lines.size() < assoc) {
      return false;
    }
    for (const auto& line : lines) {
      if (!line.lock) {
        return false;
      }
    }
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x180860
movq -0x40(%rbp), %rcx
movl 0x670(%rcx), %ecx
cmpq %rcx, %rax
jae 0x1805e6
movb $0x0, -0x1(%rbp)
jmp 0x180649
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x180b70
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x180ba0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x180b40
testb $0x1, %al
jne 0x18061b
jmp 0x180645
leaq -0x28(%rbp), %rdi
callq 0x1829b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x180638
movb $0x0, -0x1(%rbp)
jmp 0x180649
jmp 0x18063a
leaq -0x28(%rbp), %rdi
callq 0x1829e0
jmp 0x180608
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop