LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CMU-SAFARI[P]ramulator/src/Controller.cpp
// Function: ramulator::Controller<ramulator::SALP>::get_addr_vec(ramulator::SALP::Command, std::_List_iterator<ramulator::Request>)
vector<int> Controller<SALP>::get_addr_vec(SALP::Command cmd, list<Request>::iterator req){
    if (cmd == SALP::Command::PRE_OTHER)
        return get_offending_subarray(channel, req->addr_vec);
    else
        return req->addr_vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0xd, -0x1c(%rbp)
jne 0x18740e
movq -0x28(%rbp), %rax
movq 0x1098(%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2eb90
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
addq $0x10, %rdx
callq 0x187440
jmp 0x187427
leaq -0x10(%rbp), %rdi
callq 0x2eb90
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rsi
callq 0x31b10
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Controller.cpp
// Function: ramulator::get_offending_subarray(ramulator::DRAM<ramulator::SALP>*, std::vector<int, std::allocator<int>>&)
static vector<int> get_offending_subarray(DRAM<SALP>* channel, vector<int> & addr_vec){
    int sa_id = 0;
    auto rank = channel->children[addr_vec[int(SALP::Level::Rank)]];
    auto bank = rank->children[addr_vec[int(SALP::Level::Bank)]];
    auto sa = bank->children[addr_vec[int(SALP::Level::SubArray)]];
    for (auto sa_other : bank->children)
        if (sa != sa_other && sa_other->state == SALP::State::Opened){
            sa_id = sa_other->id;
            break;
        }
    vector<int> offending = addr_vec;
    offending[int(SALP::Level::SubArray)] = sa_id;
    offending[int(SALP::Level::Row)] = -1;
    return offending;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x3b0, %rax            # imm = 0x3B0
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x384f0
movq -0x78(%rbp), %rdi
movslq (%rax), %rsi
callq 0x70450
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x3b0, %rax            # imm = 0x3B0
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x384f0
movq -0x70(%rbp), %rdi
movslq (%rax), %rsi
callq 0x70450
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x3b0, %rax            # imm = 0x3B0
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x384f0
movq -0x68(%rbp), %rdi
movslq (%rax), %rsi
callq 0x70450
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x3b0, %rax            # imm = 0x3B0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x6ddb0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x6dc40
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6e630
testb $0x1, %al
jne 0x187534
jmp 0x187577
leaq -0x48(%rbp), %rdi
callq 0x6e670
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0x18756a
movq -0x58(%rbp), %rax
cmpl $0x0, 0x3c8(%rax)
jne 0x18756a
movq -0x58(%rbp), %rax
movl 0x39c(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x187577
jmp 0x18756c
leaq -0x48(%rbp), %rdi
callq 0x6e690
jmp 0x187521
movq -0x88(%rbp), %rdi
movb $0x0, -0x59(%rbp)
movq -0x18(%rbp), %rsi
callq 0x31b10
movq -0x88(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movl $0x3, %esi
callq 0x384f0
movl -0x8c(%rbp), %ecx
movq -0x88(%rbp), %rdi
movl %ecx, (%rax)
movl $0x4, %esi
callq 0x384f0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movb $0x1, -0x59(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x1875da
movq -0x88(%rbp), %rdi
callq 0x2fcd0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Controller.cpp
// Function: ramulator::Controller<ramulator::SALP>::is_ready(std::_List_iterator<ramulator::Request>)
bool Controller<SALP>::is_ready(list<Request>::iterator req){
    SALP::Command cmd = get_first_cmd(req);
    if (cmd == SALP::Command::PRE_OTHER){

        vector<int> addr_vec = get_offending_subarray(channel, req->addr_vec);
        return channel->check(cmd, addr_vec.data(), clk);
    }
    else return channel->check(cmd, req->addr_vec.data(), clk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x77330
movl %eax, -0x1c(%rbp)
cmpl $0xd, -0x1c(%rbp)
jne 0x1876c0
movq -0x58(%rbp), %rax
movq 0x1098(%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2eb90
movq -0x78(%rbp), %rsi
movq %rax, %rdx
addq $0x10, %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x187440
movq -0x70(%rbp), %rdi
movq -0x58(%rbp), %rax
movq 0x1098(%rax), %rax
movq %rax, -0x68(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x60(%rbp)
callq 0x2f270
movq -0x68(%rbp), %rdi
movl -0x60(%rbp), %esi
movq %rax, %rdx
movq -0x58(%rbp), %rax
movq 0x1090(%rax), %rcx
callq 0x70c30
movb %al, -0x59(%rbp)
jmp 0x187696
movb -0x59(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2fcd0
jmp 0x18770f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2fcd0
jmp 0x18771d
movq -0x58(%rbp), %rax
movq 0x1098(%rax), %rax
movq %rax, -0x88(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2eb90
movq %rax, %rdi
addq $0x10, %rdi
callq 0x2f270
movq -0x88(%rbp), %rdi
movl -0x7c(%rbp), %esi
movq %rax, %rdx
movq -0x58(%rbp), %rax
movq 0x1090(%rax), %rcx
callq 0x70c30
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xc5d0
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/TLDRAM.h
// Function: ramulator::TLDRAM::is_opening(ramulator::TLDRAM::Command)
bool is_opening(Command cmd)
    {
        switch(int(cmd)) {
            case int(Command::ACT):
            case int(Command::ACTF):
            case int(Command::ACTM):
                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)
testl %eax, %eax
je 0x189f2b
jmp 0x189f17
movl -0x18(%rbp), %eax
subl $0xa, %eax
je 0x189f2b
jmp 0x189f21
movl -0x18(%rbp), %eax
subl $0xe, %eax
jne 0x189f31
jmp 0x189f2b
movb $0x1, -0x1(%rbp)
jmp 0x189f35
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/TLDRAM.h
// Function: ramulator::TLDRAM::is_accessing(ramulator::TLDRAM::Command)
bool is_accessing(Command cmd)
    {
        switch(int(cmd)) {
            case int(Command::RD):
            case int(Command::WR):
            case int(Command::MIG):
                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 $-0x3, %eax
subl $0x2, %eax
jb 0x189ff5
jmp 0x189feb
movl -0x18(%rbp), %eax
subl $0xd, %eax
jne 0x189ffb
jmp 0x189ff5
movb $0x1, -0x1(%rbp)
jmp 0x189fff
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/TLDRAM.h
// Function: ramulator::TLDRAM::is_closing(ramulator::TLDRAM::Command)
bool is_closing(Command cmd)
    {
        switch(int(cmd)) {
            case int(Command::PRE):
            case int(Command::PREF):
            case int(Command::PREM):
            case int(Command::PREA):
            case int(Command::PREAF):
            case int(Command::PREAM):
                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 0x18a044
jmp 0x18a02a
movl -0x18(%rbp), %eax
addl $-0xb, %eax
subl $0x2, %eax
jb 0x18a044
jmp 0x18a037
movl -0x18(%rbp), %eax
addl $-0xf, %eax
subl $0x1, %eax
ja 0x18a04a
jmp 0x18a044
movb $0x1, -0x1(%rbp)
jmp 0x18a04e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: CMU-SAFARI[P]ramulator/src/DSARP.cpp
// Function: ramulator::DSARP::init_speed()
void DSARP::init_speed()
{
  /* Numbers are in DRAM cycles */

  // The numbers for RFCab are extrapolated based on past and current DRAM
  // generation since they are not available yet. Details on the extrapolation
  // are in the paper.
  const static int RFCAB_TABLE[int(Org::MAX)][int(Speed::MAX)] = {
    {234}, {354}, {594},
  };

  // These are extrapolated using the RFCab/REFpb ratio from the LPDDR standard, which is 2.16.
  const static int RFCPB_TABLE[int(Org::MAX)][int(Speed::MAX)] = {
    {109}, {164}, {275}
  };

  // High temperature mode (32ms retention time)
  const static int REFI_TABLE[int(RefreshMode::MAX)][int(Speed::MAX)] = {
    {2600},
  };

  const static int REFIPB_TABLE[int(RefreshMode::MAX)][int(Speed::MAX)] = {
    {325},
  };

  int speed = 0, density = 0;
  switch (speed_entry.rate) {
    case 1333: speed = 0; break;
    default: assert(false);
  };
  switch (org_entry.size >> 10){
    case 8: density = 0; break;
    case 16: density = 1; break;
    case 32: density = 2; break;
    default: assert(false && "Unknown density");
  }

  speed_entry.nRFCpb = RFCPB_TABLE[density][speed];
  speed_entry.nRFCab = RFCAB_TABLE[density][speed];
  speed_entry.nREFI = REFI_TABLE[int(refresh_mode)][speed];
  speed_entry.nREFIpb = REFIPB_TABLE[int(refresh_mode)][speed];
}

// 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)
movl $0x0, -0x10(%rbp)
movl 0x3170(%rax), %eax
subl $0x535, %eax            # imm = 0x535
jne 0x1a63ba
jmp 0x1a63b1
movl $0x0, -0xc(%rbp)
jmp 0x1a63d9
leaq 0xa97a0(%rip), %rdi     # 0x24fb61
leaq 0xb71fc(%rip), %rsi     # 0x25d5c4
movl $0x72, %edx
leaq 0xb722d(%rip), %rcx     # 0x25d601
callq 0xc280
movq -0x18(%rbp), %rax
movl 0x30c0(%rax), %eax
sarl $0xa, %eax
movl %eax, -0x1c(%rbp)
subl $0x8, %eax
je 0x1a6404
jmp 0x1a63f0
movl -0x1c(%rbp), %eax
subl $0x10, %eax
je 0x1a640d
jmp 0x1a63fa
movl -0x1c(%rbp), %eax
subl $0x20, %eax
je 0x1a6416
jmp 0x1a641f
movl $0x0, -0x10(%rbp)
jmp 0x1a643e
movl $0x1, -0x10(%rbp)
jmp 0x1a643e
movl $0x2, -0x10(%rbp)
jmp 0x1a643e
leaq 0xb71ff(%rip), %rdi     # 0x25d625
leaq 0xb7197(%rip), %rsi     # 0x25d5c4
movl $0x78, %edx
leaq 0xb71c8(%rip), %rcx     # 0x25d601
callq 0xc280
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rdx
leaq 0xb6cef(%rip), %rcx     # 0x25d13c
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x31c8(%rax)
movslq -0x10(%rbp), %rdx
leaq 0xb6cc4(%rip), %rcx     # 0x25d130
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x31c4(%rax)
movslq 0x30e0(%rax), %rdx
leaq 0xb6cba(%rip), %rcx     # 0x25d148
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x31cc(%rax)
movslq 0x30e0(%rax), %rdx
leaq 0xb6c9c(%rip), %rcx     # 0x25d14c
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x31d0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/HBM.cpp
// Function: ramulator::HBM::init_speed()
void HBM::init_speed()
{
    const static int RFC_TABLE[int(Speed::MAX)][int(Org::MAX)] = {
        {55, 80, 130}
    };
    const static int REFI1B_TABLE[int(Speed::MAX)][int(Org::MAX)] = {
        {64, 128, 256}
    };
    const static int XS_TABLE[int(Speed::MAX)][int(Org::MAX)] = {
        {60, 85, 135}
    };

    int speed = 0, density = 0;
    switch (speed_entry.rate) {
        case 1000: speed = 0; break;
        default: assert(false);
    };
    switch (org_entry.size >> 10){
        case 1: density = 0; break;
        case 2: density = 1; break;
        case 4: density = 2; break;
        default: assert(false);
    }
    speed_entry.nRFC = RFC_TABLE[speed][density];
    speed_entry.nREFI1B = REFI1B_TABLE[speed][density];
    speed_entry.nXS = XS_TABLE[speed][density];
}

// 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)
movl $0x0, -0x10(%rbp)
movl 0x3158(%rax), %eax
subl $0x3e8, %eax            # imm = 0x3E8
jne 0x1c252a
jmp 0x1c2521
movl $0x0, -0xc(%rbp)
jmp 0x1c2549
leaq 0x8d630(%rip), %rdi     # 0x24fb61
leaq 0x9c5e3(%rip), %rsi     # 0x25eb1b
movl $0x42, %edx
leaq 0x9c5e3(%rip), %rcx     # 0x25eb27
callq 0xc280
movq -0x18(%rbp), %rax
movl 0x30b8(%rax), %eax
sarl $0xa, %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x1c2574
jmp 0x1c2560
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x1c257d
jmp 0x1c256a
movl -0x1c(%rbp), %eax
subl $0x4, %eax
je 0x1c2586
jmp 0x1c258f
movl $0x0, -0x10(%rbp)
jmp 0x1c25ae
movl $0x1, -0x10(%rbp)
jmp 0x1c25ae
movl $0x2, -0x10(%rbp)
jmp 0x1c25ae
leaq 0x8d5cb(%rip), %rdi     # 0x24fb61
leaq 0x9c57e(%rip), %rsi     # 0x25eb1b
movl $0x48, %edx
leaq 0x9c57e(%rip), %rcx     # 0x25eb27
callq 0xc280
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rdx
leaq 0x9c22b(%rip), %rcx     # 0x25e7e8
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x31b4(%rax)
movslq -0xc(%rbp), %rdx
leaq 0x9c218(%rip), %rcx     # 0x25e7f4
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x31bc(%rax)
movslq -0xc(%rbp), %rdx
leaq 0x9c205(%rip), %rcx     # 0x25e800
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x31cc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/LPDDR3.cpp
// Function: ramulator::LPDDR3::init_speed()
void LPDDR3::init_speed()
{
    // 12Gb/16Gb RFCab/RFCpb TBD

    const static int RFCPB_TABLE[3][4] = {
        {40, 48, 56, 64},
        {60, 72, 84, 96},
        {60, 72, 84, 96}
    };

    const static int RFCAB_TABLE[3][4] = {
        {87, 104, 122, 139},
        {140, 168, 196, 224},
        {140, 168, 196, 224}
    };

    const static int XSR_TABLE[3][4] = {
        {94, 112, 131, 150},
        {147, 176, 206, 235},
        {147, 176, 206, 235}
    };

    int speed = 0, density = 0;
    switch (speed_entry.rate) {
        case 1333: speed = 0; break;
        case 1600: speed = 1; break;
        case 1866: speed = 2; break;
        case 2133: speed = 3; break;
        default: assert(false);
    };
    switch (org_entry.size >> 10){
        case 4: density = 0; break;
        case 6: density = 1; break;
        case 8: density = 2; break;
        default: assert(false && "12Gb/16Gb is still TBD");
    }
    speed_entry.nRFCpb = RFCPB_TABLE[density][speed];
    speed_entry.nRFCab = RFCAB_TABLE[density][speed];
    speed_entry.nXSR = XSR_TABLE[density][speed];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl 0x2bb8(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x535, %eax            # imm = 0x535
je 0x1cf508
jmp 0x1cf4e4
movl -0x14(%rbp), %eax
subl $0x640, %eax            # imm = 0x640
je 0x1cf511
jmp 0x1cf4f0
movl -0x14(%rbp), %eax
subl $0x74a, %eax            # imm = 0x74A
je 0x1cf51a
jmp 0x1cf4fc
movl -0x14(%rbp), %eax
subl $0x855, %eax            # imm = 0x855
je 0x1cf523
jmp 0x1cf52c
movl $0x0, -0xc(%rbp)
jmp 0x1cf54b
movl $0x1, -0xc(%rbp)
jmp 0x1cf54b
movl $0x2, -0xc(%rbp)
jmp 0x1cf54b
movl $0x3, -0xc(%rbp)
jmp 0x1cf54b
leaq 0x8062e(%rip), %rdi     # 0x24fb61
leaq 0x900a5(%rip), %rsi     # 0x25f5df
movl $0x53, %edx
leaq 0x900a8(%rip), %rcx     # 0x25f5ee
callq 0xc280
movq -0x20(%rbp), %rax
movl 0x29b0(%rax), %eax
sarl $0xa, %eax
movl %eax, -0x24(%rbp)
subl $0x4, %eax
je 0x1cf576
jmp 0x1cf562
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0x1cf57f
jmp 0x1cf56c
movl -0x24(%rbp), %eax
subl $0x8, %eax
je 0x1cf588
jmp 0x1cf591
movl $0x0, -0x10(%rbp)
jmp 0x1cf5b0
movl $0x1, -0x10(%rbp)
jmp 0x1cf5b0
movl $0x2, -0x10(%rbp)
jmp 0x1cf5b0
leaq 0x9007b(%rip), %rdi     # 0x25f613
leaq 0x90040(%rip), %rsi     # 0x25f5df
movl $0x59, %edx
leaq 0x90043(%rip), %rcx     # 0x25f5ee
callq 0xc280
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rdx
leaq 0x8fb91(%rip), %rcx     # 0x25f150
shlq $0x4, %rdx
addq %rdx, %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x2c14(%rax)
movslq -0x10(%rbp), %rdx
leaq 0x8fba2(%rip), %rcx     # 0x25f180
shlq $0x4, %rdx
addq %rdx, %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x2c10(%rax)
movslq -0x10(%rbp), %rdx
leaq 0x8fbb3(%rip), %rcx     # 0x25f1b0
shlq $0x4, %rdx
addq %rdx, %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x2c28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/MemoryFactory.h
// Function: ramulator::MemoryFactory<ramulator::WideIO2>::extend_channel_width(ramulator::WideIO2*, int)
static void extend_channel_width(T* spec, int cacheline)
    {
        int channel_unit = spec->prefetch_size * spec->channel_width / 8;
        int gang_number = cacheline / channel_unit;
        
        assert(gang_number >= 1 && 
            "cacheline size must be greater or equal to minimum channel width");
        
        assert(cacheline == gang_number * channel_unit &&
            "cacheline size must be a multiple of minimum channel width");
        
        spec->channel_width *= gang_number;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x28b4(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x28b8(%rcx), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cltd
idivl -0x10(%rbp)
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x14(%rbp)
movb %al, -0x15(%rbp)
jl 0x1e950b
movb $0x1, %al
movb %al, -0x15(%rbp)
jmp 0x1e950b
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1e9514
jmp 0x1e9516
jmp 0x1e9535
leaq 0x76f33(%rip), %rdi     # 0x260450
leaq 0x76f83(%rip), %rsi     # 0x2604a7
movl $0x1c, %edx
leaq 0x76f8b(%rip), %rcx     # 0x2604bb
callq 0xc280
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %edx
imull -0x10(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x16(%rbp)
jne 0x1e954f
movb $0x1, %al
movb %al, -0x16(%rbp)
jmp 0x1e954f
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x1e9558
jmp 0x1e955a
jmp 0x1e9579
leaq 0x77007(%rip), %rdi     # 0x260568
leaq 0x76f3f(%rip), %rsi     # 0x2604a7
movl $0x1f, %edx
leaq 0x76f47(%rip), %rcx     # 0x2604bb
callq 0xc280
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
imull 0x28b8(%rax), %ecx
movl %ecx, 0x28b8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/PCM.cpp
// Function: ramulator::PCM::init_speed()
void PCM::init_speed()
{
    // nRRD, nFAW
    int page = (org_entry.dq * org_entry.count[int(Level::Column)]) >> 13;
    switch (speed_entry.rate) {
        case 800:  speed_entry.nFAW = (page==1) ? 16 : 20; break;
        default: assert(false);
    }

    // nRFC, nXS
    int chip = org_entry.size;
    switch (speed_entry.rate) {
        case 800:  speed_entry.nRFC = 0; break;
        default: assert(false);
    }
    switch (speed_entry.rate) {
        case 800:  speed_entry.nXS  = (chip==512) ? 40  : (chip==1<<10) ? 48  : (chip==1<<11) ? 68  : (chip==1<<12) ? 108 : 144; break;
        default: assert(false);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x2728(%rax), %ecx
movl 0x273c(%rax), %edx
imull %edx, %ecx
sarl $0xd, %ecx
movl %ecx, -0xc(%rbp)
movl 0x27c0(%rax), %eax
subl $0x320, %eax            # imm = 0x320
jne 0x1ead67
jmp 0x1ead48
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %esi
movl $0x14, %ecx
movl $0x10, %edx
cmpl $0x1, %esi
cmovel %edx, %ecx
movl %ecx, 0x2810(%rax)
jmp 0x1ead86
leaq 0x64df3(%rip), %rdi     # 0x24fb61
leaq 0x760a6(%rip), %rsi     # 0x260e1b
movl $0x44, %edx
leaq 0x760a6(%rip), %rcx     # 0x260e27
callq 0xc280
movq -0x18(%rbp), %rax
movl 0x2724(%rax), %ecx
movl %ecx, -0x10(%rbp)
movl 0x27c0(%rax), %eax
subl $0x320, %eax            # imm = 0x320
jne 0x1eadb2
jmp 0x1eada2
movq -0x18(%rbp), %rax
movl $0x0, 0x2814(%rax)
jmp 0x1eadd1
leaq 0x64da8(%rip), %rdi     # 0x24fb61
leaq 0x7605b(%rip), %rsi     # 0x260e1b
movl $0x4b, %edx
leaq 0x7605b(%rip), %rcx     # 0x260e27
callq 0xc280
movq -0x18(%rbp), %rax
movl 0x27c0(%rax), %eax
subl $0x320, %eax            # imm = 0x320
jne 0x1eae51
jmp 0x1eade4
cmpl $0x200, -0x10(%rbp)     # imm = 0x200
jne 0x1eadf7
movl $0x28, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1eae42
cmpl $0x400, -0x10(%rbp)     # imm = 0x400
jne 0x1eae0a
movl $0x30, %eax
movl %eax, -0x20(%rbp)
jmp 0x1eae3c
cmpl $0x800, -0x10(%rbp)     # imm = 0x800
jne 0x1eae1d
movl $0x44, %eax
movl %eax, -0x24(%rbp)
jmp 0x1eae36
movl -0x10(%rbp), %edx
movl $0x90, %eax
movl $0x6c, %ecx
cmpl $0x1000, %edx           # imm = 0x1000
cmovel %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x282c(%rax)
jmp 0x1eae70
leaq 0x64d09(%rip), %rdi     # 0x24fb61
leaq 0x75fbc(%rip), %rsi     # 0x260e1b
movl $0x4f, %edx
leaq 0x75fbc(%rip), %rcx     # 0x260e27
callq 0xc280
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Processor.cpp
// Function: ramulator::Processor::receive(ramulator::Request&)
void Processor::receive(Request& req) {
  if (!no_shared_cache) {
    llc.callback(req);
  } else if (!cores[0]->no_core_caches) {
    // Assume all cores have caches or don't have caches
    // at the same time.
    for (unsigned int i = 0 ; i < cores.size() ; ++i) {
      Core* core = cores[i].get();
      core->caches[0]->callback(req);
    }
  }
  for (unsigned int i = 0 ; i < cores.size() ; ++i) {
    Core* core = cores[i].get();
    core->receive(req);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x3a(%rax)
jne 0x1f78d4
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
callq 0x17eb80
jmp 0x1f7963
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49fa0
movq %rax, %rdi
callq 0x49fc0
testb $0x1, 0x58(%rax)
jne 0x1f7961
movl $0x0, -0x14(%rbp)
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x40(%rbp)
callq 0x49f80
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f795f
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x49fa0
movq %rax, %rdi
callq 0x4aff0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1faba0
movq %rax, %rdi
callq 0x1fabc0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x17eb80
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f78f6
jmp 0x1f7961
jmp 0x1f7963
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %eax
movq %rax, -0x48(%rbp)
callq 0x49f80
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f79b8
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x49fa0
movq %rax, %rdi
callq 0x4aff0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f82f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1f796a
addq $0x50, %rsp
popq %rbp
retq
nop
// File: CMU-SAFARI[P]ramulator/src/Processor.cpp
// Function: ramulator::Processor::tick()
void Processor::tick() {
  cpu_cycles++;

  if((int(cpu_cycles.value()) % 50000000) == 0)
      printf("CPU heartbeat, cycles: %d \n", (int(cpu_cycles.value())));

  if (!(no_core_caches && no_shared_cache)) {
    cachesys->tick();
  }
  for (unsigned int i = 0 ; i < cores.size() ; ++i) {
    Core* core = cores[i].get();
    core->tick();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x750, %rdi            # imm = 0x750
xorl %esi, %esi
callq 0x40970
movq -0x20(%rbp), %rdi
addq $0x750, %rdi            # imm = 0x750
callq 0x485e0
cvttsd2si %xmm0, %eax
movl $0x2faf080, %ecx        # imm = 0x2FAF080
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1f7a25
movq -0x20(%rbp), %rdi
addq $0x750, %rdi            # imm = 0x750
callq 0x485e0
cvttsd2si %xmm0, %esi
leaq 0x69661(%rip), %rdi     # 0x26107f
movb $0x0, %al
callq 0xc070
movq -0x20(%rbp), %rax
testb $0x1, 0x39(%rax)
je 0x1f7a39
movq -0x20(%rbp), %rax
testb $0x1, 0x3a(%rax)
jne 0x1f7a4e
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x180090
movq %rax, %rdi
callq 0x17eed0
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x49f80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f7a9f
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x49fa0
movq %rax, %rdi
callq 0x4aff0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f7ab0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f7a55
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Processor.cpp
// Function: ramulator::Core::receive(ramulator::Request&)
void Core::receive(Request& req)
{
    window.set_ready(req.addr, ~(l1_blocksz - 1l));
    if (req.arrive != -1 && req.depart > last) {
      memory_access_cycles += (req.depart - max(last, req.arrive));
      last = req.depart;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, %rdi
addq $0x410, %rdi            # imm = 0x410
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
movslq 0x64(%rax), %rax
subq $0x1, %rax
xorq $-0x1, %rax
movl %eax, %edx
callq 0x1f9e60
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x30(%rax)
je 0x1f83a6
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq 0x480(%rcx), %rax
jle 0x1f83a6
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
addq $0x480, %rdi            # imm = 0x480
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x45510
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq (%rcx), %rax
movq %rax, -0x18(%rbp)
addq $0x490, %rdi            # imm = 0x490
leaq -0x18(%rbp), %rsi
callq 0x40b80
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq %rcx, 0x480(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/Processor.cpp
// Function: ramulator::Processor::finished()
bool Processor::finished() {
  if (early_exit) {
    for (unsigned int i = 0 ; i < cores.size(); ++i) {
      if (cores[i]->finished()) {
        for (unsigned int j = 0 ; j < cores.size() ; ++j) {
          ipc += cores[j]->calc_ipc();
        }
        return true;
      }
    }
    return false;
  } else {
    for (unsigned int i = 0 ; i < cores.size(); ++i) {
      if (!cores[i]->finished()) {
        return false;
      }
      if (ipcs[i] < 0) {
        ipcs[i] = cores[i]->calc_ipc();
        ipc += ipcs[i];
      }
    }
    return true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x38(%rax)
je 0x1f8495
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0x49f80
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f848c
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x49fa0
movq %rax, %rdi
callq 0x49fc0
movq %rax, %rdi
callq 0x1f8590
testb $0x1, %al
jne 0x1f8419
jmp 0x1f847c
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x38(%rbp)
callq 0x49f80
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f8473
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x49fa0
movq %rax, %rdi
callq 0x49fc0
movq %rax, %rdi
callq 0x1f85d0
movq -0x28(%rbp), %rax
addsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f8420
movb $0x1, -0x1(%rbp)
jmp 0x1f857b
jmp 0x1f847e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f83d5
movb $0x0, -0x1(%rbp)
jmp 0x1f857b
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x40(%rbp)
callq 0x49f80
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f8577
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x49fa0
movq %rax, %rdi
callq 0x49fc0
movq %rax, %rdi
callq 0x1f8590
testb $0x1, %al
jne 0x1f84e7
movb $0x0, -0x1(%rbp)
jmp 0x1f857b
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2e5e0
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0x1f8567
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x49fa0
movq %rax, %rdi
callq 0x49fc0
movq %rax, %rdi
callq 0x1f85d0
movq -0x28(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2e5e0
movsd -0x48(%rbp), %xmm0
movq -0x28(%rbp), %rdi
movsd %xmm0, (%rax)
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2e5e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movsd (%rcx), %xmm0
addsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
jmp 0x1f8569
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f849c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Processor.cpp
// Function: ramulator::Processor::has_reached_limit()
bool Processor::has_reached_limit() {
  for (unsigned int i = 0 ; i < cores.size() ; ++i) {
    if (!cores[i]->has_reached_limit()) {
      return false;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x49f80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f868c
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x49fa0
movq %rax, %rdi
callq 0x49fc0
movq %rax, %rdi
callq 0x1f86a0
testb $0x1, %al
jne 0x1f867f
movb $0x0, -0x1(%rbp)
jmp 0x1f8690
jmp 0x1f8681
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f863b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Processor.cpp
// Function: ramulator::Processor::get_insts()
long Processor::get_insts() {
    long insts_total = 0;
    for (unsigned int i = 0 ; i < cores.size(); i++) {
        insts_total += cores[i]->get_insts();
    }

    return insts_total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x49f80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f8730
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x49fa0
movq %rax, %rdi
callq 0x49fc0
movq %rax, %rdi
callq 0x1f8740
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f86e3
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Processor.cpp
// Function: ramulator::Processor::reset_stats()
void Processor::reset_stats() {
    for (unsigned int i = 0 ; i < cores.size(); i++) {
        cores[i]->reset_stats();
    }

    ipc = 0;

    for (unsigned int i = 0; i < ipcs.size(); i++)
        ipcs[i] = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %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 0x49f80
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f87d0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x49fa0
movq %rax, %rdi
callq 0x49fc0
movq %rax, %rdi
callq 0x1f8840
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f878b
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
callq 0x1fabe0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f882c
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x2e5e0
movsd 0x6875b(%rip), %xmm0    # 0x260f78
movsd %xmm0, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1f87e3
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Processor.cpp
// Function: ramulator::Window::retire()
long Window::retire()
{
    assert(load <= depth);

    if (load == 0) return 0;

    int retired = 0;
    while (load > 0 && retired < ipc) {
        if (!ready_list.at(tail))
            break;

        tail = (tail + 1) % depth;
        load--;
        retired++;
    }

    return retired;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl 0x8(%rcx), %eax
cmpl 0x4(%rcx), %eax
jg 0x1f9c7e
jmp 0x1f9c9d
leaq 0x676d7(%rip), %rdi     # 0x26135c
leaq 0x67328(%rip), %rsi     # 0x260fb4
movl $0x159, %edx            # imm = 0x159
leaq 0x676fd(%rip), %rcx     # 0x261395
callq 0xc280
movq -0x30(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x1f9cb4
movq $0x0, -0x8(%rbp)
jmp 0x1f9d42
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x8(%rcx)
movb %al, -0x31(%rbp)
jle 0x1f9cd9
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1f9ce2
jmp 0x1f9d3a
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x10(%rax), %rsi
callq 0x1faf10
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1faff0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f9d0f
jmp 0x1f9d11
jmp 0x1f9d3a
movq -0x30(%rbp), %rcx
movl 0x10(%rcx), %eax
addl $0x1, %eax
cltd
idivl 0x4(%rcx)
movq -0x30(%rbp), %rax
movl %edx, 0x10(%rax)
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f9cbb
movslq -0x14(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/Processor.cpp
// Function: ramulator::Window::insert(bool, long)
void Window::insert(bool ready, long addr)
{
    assert(load <= depth);

    ready_list.at(head) = ready;
    addr_list.at(head) = addr;

    head = (head + 1) % depth;
    load++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl 0x8(%rcx), %eax
cmpl 0x4(%rcx), %eax
jg 0x1f9d9a
jmp 0x1f9db9
leaq 0x675bb(%rip), %rdi     # 0x26135c
leaq 0x6720c(%rip), %rsi     # 0x260fb4
movl $0x14d, %edx            # imm = 0x14D
leaq 0x675b6(%rip), %rcx     # 0x26136a
callq 0xc280
movq -0x30(%rbp), %rax
movb -0x9(%rbp), %cl
movb %cl, -0x39(%rbp)
movq %rax, %rdi
addq $0x18, %rdi
movslq 0xc(%rax), %rsi
callq 0x1faf10
movq %rax, %rcx
movb -0x39(%rbp), %al
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x1faf60
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq %rax, %rdi
addq $0x40, %rdi
movslq 0xc(%rax), %rsi
callq 0x1fafb0
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, (%rax)
movl 0xc(%rcx), %eax
addl $0x1, %eax
cltd
idivl 0x4(%rcx)
movq -0x30(%rbp), %rax
movl %edx, 0xc(%rax)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Processor.cpp
// Function: ramulator::Window::set_ready(long, int)
void Window::set_ready(long addr, int mask)
{
    if (load == 0) return;

    for (int i = 0; i < load; i++) {
        int index = (tail + i) % depth;
        if ((addr_list.at(index) & mask) != (addr & mask))
            continue;
        ready_list.at(index) = true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x8(%rax)
jne 0x1f9e83
jmp 0x1f9f02
movl $0x0, -0x18(%rbp)
movq -0x38(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x1f9f02
movq -0x38(%rbp), %rdi
movl 0x10(%rdi), %eax
addl -0x18(%rbp), %eax
cltd
idivl 0x4(%rdi)
movl %edx, -0x1c(%rbp)
addq $0x40, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1fafb0
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
andq %rcx, %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
andq %rdx, %rcx
cmpq %rcx, %rax
je 0x1f9ed0
jmp 0x1f9ef7
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1faf10
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x1faf60
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f9e8a
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Config.h
// Function: ramulator::Config::has_core_caches() const
bool has_core_caches() const {
      if (options.find("cache") != options.end()) {
        const std::string& cache_option = (options.find("cache"))->second;
        return (cache_option == "all" || cache_option == "L1L2");
      } else {
        return false;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq %rax, -0xa0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xc5e0
movq -0x98(%rbp), %rdx
leaq 0x6714d(%rip), %rsi     # 0x26145c
leaq -0x38(%rbp), %rdi
callq 0x17a40
jmp 0x1fa31a
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1c1d0
movq %rax, -0xb0(%rbp)
jmp 0x1fa333
movq -0xa0(%rbp), %rdi
movq -0xb0(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1c200
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1c1a0
movb %al, -0xb1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc6b8
leaq -0x39(%rbp), %rdi
callq 0xc3c0
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x1fa382
jmp 0x1fa4c1
movq -0xa0(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xc5e0
movq -0xc0(%rbp), %rdx
leaq 0x670ab(%rip), %rsi     # 0x26145c
leaq -0x88(%rbp), %rdi
callq 0x17a40
jmp 0x1fa3bf
movq -0xc8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1c1d0
movq %rax, -0xd0(%rbp)
jmp 0x1fa3db
movq -0xd0(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c230
addq $0x20, %rax
movq %rax, -0xe0(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xc6b8
leaq -0x89(%rbp), %rdi
callq 0xc3c0
movq -0xe0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
leaq 0x6703a(%rip), %rsi     # 0x261462
callq 0x17f10
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xd1(%rbp)
jne 0x1fa452
movq -0x60(%rbp), %rdi
leaq 0x6701f(%rip), %rsi     # 0x261466
callq 0x17f10
movb %al, -0xd1(%rbp)
movb -0xd1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1fa4c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1fa482
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 0x1fa4d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1fa4b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xc6b8
leaq -0x89(%rbp), %rdi
callq 0xc3c0
jmp 0x1fa4d3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xc5d0
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/Config.h
// Function: ramulator::Config::has_l3_cache() const
bool has_l3_cache() const {
      if (options.find("cache") != options.end()) {
        const std::string& cache_option = (options.find("cache"))->second;
        return (cache_option == "all") || (cache_option == "L3");
      } else {
        return false;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq %rax, -0xa0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xc5e0
movq -0x98(%rbp), %rdx
leaq 0x66f3d(%rip), %rsi     # 0x26145c
leaq -0x38(%rbp), %rdi
callq 0x17a40
jmp 0x1fa52a
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1c1d0
movq %rax, -0xb0(%rbp)
jmp 0x1fa543
movq -0xa0(%rbp), %rdi
movq -0xb0(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1c200
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1c1a0
movb %al, -0xb1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc6b8
leaq -0x39(%rbp), %rdi
callq 0xc3c0
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x1fa592
jmp 0x1fa6d1
movq -0xa0(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xc5e0
movq -0xc0(%rbp), %rdx
leaq 0x66e9b(%rip), %rsi     # 0x26145c
leaq -0x88(%rbp), %rdi
callq 0x17a40
jmp 0x1fa5cf
movq -0xc8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1c1d0
movq %rax, -0xd0(%rbp)
jmp 0x1fa5eb
movq -0xd0(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c230
addq $0x20, %rax
movq %rax, -0xe0(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xc6b8
leaq -0x89(%rbp), %rdi
callq 0xc3c0
movq -0xe0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
leaq 0x66e2a(%rip), %rsi     # 0x261462
callq 0x17f10
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xd1(%rbp)
jne 0x1fa662
movq -0x60(%rbp), %rdi
leaq 0x606b8(%rip), %rsi     # 0x25ad0f
callq 0x17f10
movb %al, -0xd1(%rbp)
movb -0xd1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1fa6d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1fa692
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 0x1fa6e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1fa6c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xc6b8
leaq -0x89(%rbp), %rdi
callq 0xc3c0
jmp 0x1fa6e3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xc5d0
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/Cache.h
// Function: ramulator::CacheSystem::CacheSystem(ramulator::Config const&, std::function<bool (ramulator::Request)>)
CacheSystem(const Config& configs, std::function<bool(Request)> send_memory):
    send_memory(send_memory) {
      if (configs.has_core_caches()) {
        first_level = Cache::Level::L1;
      } else if (configs.has_l3_cache()) {
        first_level = Cache::Level::L3;
      } else {
        last_level = Cache::Level::MAX; // no cache
      }

      if (configs.has_l3_cache()) {
        last_level = Cache::Level::L3;
      } else if (configs.has_core_caches()) {
        last_level = Cache::Level::L2;
      } else {
        last_level = Cache::Level::MAX; // no cache
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x1fb110
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x48(%rbp)
callq 0x1fb110
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x30, %rdi
movq %rdi, -0x30(%rbp)
callq 0x1fa6f0
jmp 0x1fa7f4
movq -0x50(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rdi
callq 0x1fa2d0
movb %al, -0x51(%rbp)
jmp 0x1fa80e
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1fa817
jmp 0x1fa84f
movq -0x50(%rbp), %rax
movl $0x0, 0x58(%rax)
jmp 0x1fa880
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1fa8db
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x49f40
jmp 0x1fa8db
movq -0x10(%rbp), %rdi
callq 0x1fa4e0
movb %al, -0x52(%rbp)
jmp 0x1fa85d
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0x1fa866
jmp 0x1fa873
movq -0x50(%rbp), %rax
movl $0x2, 0x58(%rax)
jmp 0x1fa87e
movq -0x50(%rbp), %rax
movl $0x3, 0x5c(%rax)
jmp 0x1fa880
movq -0x10(%rbp), %rdi
callq 0x1fa4e0
movb %al, -0x53(%rbp)
jmp 0x1fa88e
movb -0x53(%rbp), %al
testb $0x1, %al
jne 0x1fa897
jmp 0x1fa8a4
movq -0x50(%rbp), %rax
movl $0x2, 0x5c(%rax)
jmp 0x1fa8d5
movq -0x10(%rbp), %rdi
callq 0x1fa2d0
movb %al, -0x54(%rbp)
jmp 0x1fa8b2
movb -0x54(%rbp), %al
testb $0x1, %al
jne 0x1fa8bb
jmp 0x1fa8c8
movq -0x50(%rbp), %rax
movl $0x1, 0x5c(%rax)
jmp 0x1fa8d3
movq -0x50(%rbp), %rax
movl $0x3, 0x5c(%rax)
jmp 0x1fa8d5
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x1fb130
movq -0x40(%rbp), %rdi
callq 0x1fb130
movq -0x20(%rbp), %rdi
callq 0xc5d0
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Refresh.cpp
// Function: ramulator::Refresh<ramulator::DSARP>::tick_ref()
void Refresh<DSARP>::tick_ref() {
  clk++;

  bool b_ref_rank = ctrl->channel->spec->b_ref_rank;
  int refresh_interval =
      (b_ref_rank) ?
          ctrl->channel->spec->speed_entry.nREFI :
          ctrl->channel->spec->speed_entry.nREFIpb;

  // DARP
  if (ctrl->channel->spec->type == DSARP::Type::DARP ||
    ctrl->channel->spec->type == DSARP::Type::DSARP) {
    // Write-Refresh Parallelization. Issue refreshes when the controller enters writeback mode
    if (!ctrl_write_mode && ctrl->write_mode)
      wrp();
    // Record write mode
    ctrl_write_mode = ctrl->write_mode;
    // Inject early to pull in some refreshes during read mode
    early_inject_refresh();
  }

  // Time to schedule a refresh and also try to skip some refreshes
  if ((clk - refreshed) >= refresh_interval)
    inject_refresh(b_ref_rank);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rax), %rax
movq 0x1098(%rax), %rax
movq 0x390(%rax), %rax
movb 0x31f8(%rax), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2003c4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x1098(%rax), %rax
movq 0x390(%rax), %rax
movl 0x31cc(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2003e3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x1098(%rax), %rax
movq 0x390(%rax), %rax
movl 0x31d0(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq 0x1098(%rax), %rax
movq 0x390(%rax), %rax
cmpl $0x2, (%rax)
je 0x20041f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x1098(%rax), %rax
movq 0x390(%rax), %rax
cmpl $0x4, (%rax)
jne 0x200461
movq -0x18(%rbp), %rax
testb $0x1, 0x90(%rax)
jne 0x200446
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x1190(%rax)
je 0x200446
movq -0x18(%rbp), %rdi
callq 0x1ffd20
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rax
movb 0x1190(%rax), %al
andb $0x1, %al
movb %al, 0x90(%rdi)
callq 0x1ff2e0
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rax
subq 0x18(%rcx), %rax
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jl 0x200487
movq -0x18(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1ff900
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)