LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yangwanyuan[P]HLKVDS/src/Tier.cc
// Function: hlkvds::MediumTier::printDeviceTopologyInfo()
void MediumTier::printDeviceTopologyInfo() {
    __INFO( "\n\t Medium Tier Infomation:\n"
            "\t Medium Tier Seg Size          : %d\n"
            "\t Medium Tier Vol Num           : %d",
            sbResMediumTierHeader_.segment_size, sbResMediumTierHeader_.volume_num);

    for (uint32_t i = 0 ; i < volNum_; i++) {
        __INFO("\n\t Medium Tier Volume[%d] : dev_path = %s, segment_num = %d, cur_seg_id = %d",
                i, sbResMediumTierVolVec_[i].dev_path,
                sbResMediumTierVolVec_[i].segment_num,
                sbResMediumTierVolVec_[i].cur_seg_id);
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x2432e(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x8480
movq 0x28(%rsp), %rdi
movq %rax, %rdx
leaq 0x56f6(%rip), %rsi      # 0x523bc
leaq 0x570f(%rip), %rcx      # 0x523dc
leaq 0x780e(%rip), %r8       # 0x544e2
movl $0x25e, %r9d            # imm = 0x25E
movb $0x0, %al
callq 0x86f0
movq 0x30(%rsp), %rax
movq 0x242eb(%rip), %rcx     # 0x70fd8
movq (%rcx), %rdi
movl 0x18(%rax), %edx
movl 0x1c(%rax), %ecx
leaq 0x78fc(%rip), %rsi      # 0x545f9
movb $0x0, %al
callq 0x86f0
movq 0x242cd(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x60b0(%rip), %rsi      # 0x52dc5
movb $0x0, %al
callq 0x86f0
movl $0x0, 0x3c(%rsp)
movq 0x30(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4ce28
jmp 0x4cd38
movq 0x24299(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x8480
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x5663(%rip), %rsi      # 0x523bc
leaq 0x567c(%rip), %rcx      # 0x523dc
leaq 0x777b(%rip), %r8       # 0x544e2
movl $0x264, %r9d            # imm = 0x264
movb $0x0, %al
callq 0x86f0
movq 0x30(%rsp), %rdi
movq 0x24258(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x20, %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x4eca0
movq 0x30(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x20, %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x4eca0
movq 0x30(%rsp), %rdi
movl 0x100(%rax), %eax
movl %eax, 0x24(%rsp)
addq $0x20, %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x4eca0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %r8d
movl 0x104(%rax), %r9d
leaq 0x7867(%rip), %rsi      # 0x5465e
movb $0x0, %al
callq 0x86f0
movq 0x241d3(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x5fb6(%rip), %rsi      # 0x52dc5
movb $0x0, %al
callq 0x86f0
jmp 0x4ce18
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x4cd24
addq $0x48, %rsp
retq
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/src/Tier.cc
// Function: hlkvds::MediumTier::ManualGC()
void MediumTier::ManualGC() {
    map<int, Volume *>::iterator iter;
    for (iter = volMap_.begin(); iter != volMap_.end(); ) {
        Volume *vol = iter->second;
        vol->FullGC();
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x16ad0
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x16af0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x16b40
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x16b20
testb $0x1, %al
jne 0x4d0c2
jmp 0x4d0e1
leaq 0x28(%rsp), %rdi
callq 0x16b70
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x51270
jmp 0x4d09a
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Tier.cc
// Function: hlkvds::MediumTier::GetSBReservedContent(char*, unsigned long)
bool MediumTier::GetSBReservedContent(char* buf, uint64_t length) {
    uint32_t except_length = sizeof(MultiTierDS_SB_Reserved_MediumTier_Header) +
                            volNum_ * sizeof(MultiTierDS_SB_Reserved_MediumTier_Content);
    if (length != except_length) {
        return false;
    }

    updateAllVolSBRes();

    char* buf_ptr = buf;
    uint64_t medium_tier_header_size = sizeof(MultiTierDS_SB_Reserved_MediumTier_Header);
    memcpy((void*)buf, (const void *)&sbResMediumTierHeader_, medium_tier_header_size);
    __DEBUG("MultiTierDS_SB_Reserved_MediumTier_Header: segment_size = %d, volume_num = %d",
            sbResMediumTierHeader_.segment_size, sbResMediumTierHeader_.volume_num);
    buf_ptr += medium_tier_header_size;

    //Get sbResVolVec_
    uint64_t sb_res_item_size = sizeof(MultiTierDS_SB_Reserved_MediumTier_Content);
    for (uint32_t i = 0; i < volNum_; i++) {
        memcpy((void*)buf_ptr, (const void*)&sbResMediumTierVolVec_[i], sb_res_item_size);
        buf_ptr += sb_res_item_size;
        __DEBUG("MultiTierDS_SB_Reserved_MediumTier_Content[%d]: device_path = %s, segment_num = %d, current_seg_id = %d",
            i, sbResMediumTierVolVec_[i].dev_path, sbResMediumTierVolVec_[i].segment_num,
            sbResMediumTierVolVec_[i].cur_seg_id);

    }
    return true;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x40(%rax), %eax
imulq $0x108, %rax, %rax      # imm = 0x108
addq $0x8, %rax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %ecx
cmpq %rcx, %rax
je 0x4d137
movb $0x0, 0x57(%rsp)
jmp 0x4d1e9
movq 0x8(%rsp), %rdi
callq 0x4d200
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x8, 0x20(%rsp)
movq 0x40(%rsp), %rdi
addq $0x18, %rsi
movq 0x20(%rsp), %rdx
callq 0x8410
movq 0x20(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x108, 0x18(%rsp)      # imm = 0x108
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4d1e4
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
addq $0x20, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x4eca0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x8410
movq 0x18(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4d18c
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Tier.cc
// Function: hlkvds::MediumTier::GetSST(char*, unsigned long)
bool MediumTier::GetSST(char* buf, uint64_t length) {
    char* buf_ptr = buf;
    for (uint32_t i = 0; i < volNum_; i++) {
        uint64_t vol_sst_length = volMap_[i]->GetSSTLength();
        if ( !volMap_[i]->GetSST(buf_ptr, vol_sst_length) ) {
            return false;
        }
        buf_ptr += vol_sst_length;
    }
    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4d540
movq (%rsp), %rdi
addq $0x48, %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0xc(%rsp), %rsi
callq 0x160f0
movq (%rax), %rdi
callq 0x510c0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x48, %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x160f0
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x50e70
xorb $-0x1, %al
testb $0x1, %al
jne 0x4d51a
jmp 0x4d521
movb $0x0, 0x47(%rsp)
jmp 0x4d545
movq 0x10(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4d4ae
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
// File: yangwanyuan[P]HLKVDS/src/Tier.cc
// Function: hlkvds::MediumTier::SetSST(char*, unsigned long)
bool MediumTier::SetSST(char* buf, uint64_t length) {
    char* buf_ptr = buf;
    for (uint32_t i = 0; i < volNum_; i++) {
        uint64_t vol_sst_length = volMap_[i]->GetSSTLength();
        if ( !volMap_[i]->SetSST(buf_ptr, vol_sst_length) ) {
            return false;
        }
        buf_ptr += vol_sst_length;
    }
    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4d610
movq (%rsp), %rdi
addq $0x48, %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0xc(%rsp), %rsi
callq 0x160f0
movq (%rax), %rdi
callq 0x510c0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x48, %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x160f0
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x50ea0
xorb $-0x1, %al
testb $0x1, %al
jne 0x4d5ea
jmp 0x4d5f1
movb $0x0, 0x47(%rsp)
jmp 0x4d615
movq 0x10(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4d57e
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
// File: yangwanyuan[P]HLKVDS/src/Tier.cc
// Function: hlkvds::MediumTier::initSBReservedContentForCreate()
void MediumTier::initSBReservedContentForCreate() {
    sbResMediumTierHeader_.segment_size = segSize_;
    sbResMediumTierHeader_.volume_num = volNum_;
    for (uint32_t i = 0; i < volNum_; i++) {
        MultiTierDS_SB_Reserved_MediumTier_Content sb_res_item;
        string dev_path = volMap_[i]->GetDevicePath();
        memcpy((void*)&sb_res_item.dev_path, (const void*)dev_path.c_str(), dev_path.size());
        sb_res_item.segment_num = volMap_[i]->GetNumberOfSeg();
        sb_res_item.cur_seg_id = volMap_[i]->GetCurSegId();
        sbResMediumTierVolVec_.push_back(sb_res_item);
    }
}

// Assembly:
subq $0x198, %rsp            # imm = 0x198
movq %rdi, 0x190(%rsp)
movq 0x190(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x38(%rax), %ecx
movl %ecx, 0x18(%rax)
movl 0x40(%rax), %ecx
movl %ecx, 0x1c(%rax)
movl $0x0, 0x18c(%rsp)
movq 0x40(%rsp), %rcx
movl 0x18c(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4da4e
leaq 0x84(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4ecc0
movq 0x40(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x30(%rsp)
movl 0x18c(%rsp), %eax
movl %eax, 0x5c(%rsp)
leaq 0x5c(%rsp), %rsi
callq 0x160f0
movq (%rax), %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x51090
movq 0x18(%rsp), %rdi
callq 0x8180
movq 0x18(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0x8350
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rax, %rdx
callq 0x8410
movq 0x30(%rsp), %rdi
movl 0x18c(%rsp), %eax
movl %eax, 0x58(%rsp)
leaq 0x58(%rsp), %rsi
callq 0x160f0
movq %rax, 0x38(%rsp)
jmp 0x4d99b
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0x16d50
movl %eax, 0x14(%rsp)
jmp 0x4d9ae
movq 0x40(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x184(%rsp)
addq $0x48, %rdi
movl 0x18c(%rsp), %eax
movl %eax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x160f0
movq %rax, 0x8(%rsp)
jmp 0x4d9de
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x51070
movl %eax, 0x4(%rsp)
jmp 0x4d9f1
movq 0x40(%rsp), %rdi
movl 0x4(%rsp), %eax
movl %eax, 0x188(%rsp)
addq $0x20, %rdi
leaq 0x84(%rsp), %rsi
callq 0x4ecf0
jmp 0x4da14
leaq 0x60(%rsp), %rdi
callq 0x8928
movl 0x18c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18c(%rsp)
jmp 0x4d8f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x8928
jmp 0x4da56
addq $0x198, %rsp            # imm = 0x198
retq
movq 0x50(%rsp), %rdi
callq 0x8820
// File: yangwanyuan[P]HLKVDS/src/Tier.cc
// Function: hlkvds::MediumTier::GetTotalFreeSegs()
uint32_t MediumTier::GetTotalFreeSegs() {
    uint32_t free_num = 0;
    for (uint32_t i = 0; i < volNum_; i++) {
        free_num += volMap_[i]->GetTotalFreeSegs();
    }
    return free_num;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4e059
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x160f0
movq (%rax), %rdi
callq 0x510f0
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x4e013
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Tier.cc
// Function: hlkvds::MediumTier::GetTotalUsedSegs()
uint32_t MediumTier::GetTotalUsedSegs() {
    uint32_t used_num = 0;
    for (uint32_t i = 0; i < volNum_; i++) {
        used_num += volMap_[i]->GetTotalUsedSegs();
    }
    return used_num;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4e0d9
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x160f0
movq (%rax), %rdi
callq 0x51110
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x4e093
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Tier.cc
// Function: hlkvds::MediumTier::GetSSTLength()
uint64_t MediumTier::GetSSTLength() {
    uint64_t length = 0;
    for (uint32_t i = 0; i < volNum_; i++) {
        length += volMap_[i]->GetSSTLength();
    }
    return length;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4e15c
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x160f0
movq (%rax), %rdi
callq 0x510c0
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e114
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Utils.cc
// Function: hlkvds::KVTime::operator>(hlkvds::KVTime const&)
bool KVTime::operator>(const KVTime& toBeCopied) {
    if (tm_.tv_sec > toBeCopied.tm_.tv_sec) {
        return true;
    } else if (tm_.tv_sec < toBeCopied.tm_.tv_sec) {
        return false;
    } else {
        return tm_.tv_usec > toBeCopied.tm_.tv_usec;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
jle 0x507d8
movb $0x1, -0x1(%rsp)
jmp 0x5080c
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
jge 0x507f1
movb $0x0, -0x1(%rsp)
jmp 0x5080c
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
setg %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Utils.cc
// Function: hlkvds::Thread::Start()
int Thread::Start() {
    int result = pthread_create(&tid_, NULL, runThread, (void *) this);
    if (result == 0) {
        running_ = 1;
    }
    return result;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq %rcx, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x94(%rip), %rdx       # 0x50930
callq 0x8890
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x509df
movq (%rsp), %rax
movl $0x1, 0x10(%rax)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Utils.cc
// Function: hlkvds::Thread::Join()
int Thread::Join() {
    int result = -1;
    if (running_ == 1) {
        result = pthread_join(tid_, NULL);
        if (result == 0) {
            detached_ = 0;
        }
    }
    return result;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
cmpl $0x1, 0x10(%rax)
jne 0x50a39
movq (%rsp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8490
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x50a37
movq (%rsp), %rax
movl $0x0, 0x14(%rax)
jmp 0x50a39
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Utils.cc
// Function: hlkvds::Thread::Detach()
int Thread::Detach() {
    int result = -1;
    if (running_ == 1 && detached_ == 0) {
        result = pthread_detach(tid_);
        if (result == 0) {
            detached_ = 1;
        }
    }
    return result;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
cmpl $0x1, 0x10(%rax)
jne 0x50a9f
movq (%rsp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x50a9f
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x8370
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x50a9d
movq (%rsp), %rax
movl $0x1, 0x14(%rax)
jmp 0x50a9f
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Volume.cc
// Function: hlkvds::Volume::GCThdEntry()
void Volume::GCThdEntry() {
    __DEBUG("GC thread start!!");
    while (!gcT_stop_) {
        gcMgr_->BackGC();
        usleep(1000000);
    } __DEBUG("GC thread stop!!");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x16f80
xorb $-0x1, %al
testb $0x1, %al
jne 0x50dd9
jmp 0x50df3
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x227b0
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x86e0
jmp 0x50dc3
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Volume.cc
// Function: hlkvds::Volume::Read(char*, unsigned long, long)
bool Volume::Read(char* data, size_t count, off_t offset) {
    uint64_t phy_offset = offset + startOff_;
    if (bdev_->pRead(data, count, phy_offset) != (ssize_t)count) {
        __ERROR("Read data error!!!");
        return false;
    }
    return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
addq 0x30(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rdi), %rax
callq *0x50(%rax)
cmpq 0x18(%rsp), %rax
je 0x50f8f
jmp 0x50f1c
movq 0x200b5(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x8480
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x1574(%rip), %rsi      # 0x524b1
leaq 0x38c3(%rip), %rcx      # 0x54807
leaq 0x38c1(%rip), %r8       # 0x5480c
movl $0x40, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x20079(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x38b1(%rip), %rsi      # 0x5481a
movb $0x0, %al
callq 0x86f0
movq 0x20061(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1e44(%rip), %rsi      # 0x52dc5
movb $0x0, %al
callq 0x86f0
movb $0x0, 0x37(%rsp)
jmp 0x50f94
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: yangwanyuan[P]HLKVDS/src/Volume.cc
// Function: hlkvds::Volume::Write(char*, unsigned long, long)
bool Volume::Write(char* data, size_t count, off_t offset) {
    uint64_t phy_offset = offset + startOff_;
    if (bdev_->pWrite(data, count, phy_offset) != (ssize_t)count) {
        __ERROR("Write data error!!!");
        return false;
    }
    return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
addq 0x30(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rdi), %rax
callq *0x48(%rax)
cmpq 0x18(%rsp), %rax
je 0x5105f
jmp 0x50fec
movq 0x1ffe5(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x8480
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x14a4(%rip), %rsi      # 0x524b1
leaq 0x18d7(%rip), %rcx      # 0x528eb
leaq 0x37f1(%rip), %r8       # 0x5480c
movl $0x49, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x1ffa9(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x37f4(%rip), %rsi      # 0x5482d
movb $0x0, %al
callq 0x86f0
movq 0x1ff91(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1d74(%rip), %rsi      # 0x52dc5
movb $0x0, %al
callq 0x86f0
movb $0x0, 0x37(%rsp)
jmp 0x51064
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: yangwanyuan[P]HLKVDS/src/Volume.cc
// Function: hlkvds::Volume::CalcSegOffsetFromOffset(unsigned long, unsigned long&)
bool Volume::CalcSegOffsetFromOffset(uint64_t offset,
                                         uint64_t& seg_offset) {
    uint32_t seg_id = 0;
    if (!CalcSegIdFromOffset(offset, seg_id)) {
        return false;
    }
    if (!CalcSegOffsetFromId(seg_id, seg_offset)) {
        return false;
    }
    return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x515e0
testb $0x1, %al
jne 0x512ef
movb $0x0, 0x37(%rsp)
jmp 0x51312
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x23960
testb $0x1, %al
jne 0x5130d
movb $0x0, 0x37(%rsp)
jmp 0x51312
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/src/Volume.cc
// Function: hlkvds::Volume::CalcDataOffsetPhyFromEntry(hlkvds::HashEntry*, unsigned long&)
bool Volume::CalcDataOffsetPhyFromEntry(HashEntry* entry,
                                            uint64_t& data_offset) {
    uint64_t seg_offset = 0;
    uint64_t header_offset = entry->GetHeaderOffset();
    if (!CalcSegOffsetFromOffset(header_offset, seg_offset)) {
        return false;
    }
    data_offset = seg_offset + entry->GetDataOffsetInSeg();
    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x51640
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x512b0
testb $0x1, %al
jne 0x51374
movb $0x0, 0x47(%rsp)
jmp 0x5139f
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x51660
movq 0x8(%rsp), %rcx
movl %eax, %eax
addq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Volume.cc
// Function: hlkvds::Volume::ModifyDeathEntry(hlkvds::HashEntry&)
void Volume::ModifyDeathEntry(HashEntry &entry) {
    uint32_t seg_id;
    uint64_t offset = entry.GetHeaderOffset();
    if (!CalcSegIdFromOffset(offset, seg_id)) {
        __ERROR("Calculate Seg Id Wrong!!! offset = %ld", offset);
    }

    uint16_t data_size = entry.GetDataSize();
    uint32_t death_size = (uint32_t) data_size
            + (uint32_t) IndexManager::SizeOfDataHeader();

    segMgr_->AddDeathSize(seg_id, death_size);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x51640
movq 0x18(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x34(%rsp), %rdx
callq 0x515e0
testb $0x1, %al
jne 0x514b6
jmp 0x51441
movq 0x1fb90(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x8480
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x104d(%rip), %rsi      # 0x524b1
leaq 0x33d6(%rip), %rcx      # 0x54841
leaq 0x339a(%rip), %r8       # 0x5480c
movl $0xac, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x1fb52(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x33bd(%rip), %rsi      # 0x54852
movb $0x0, %al
callq 0x86f0
movq 0x1fb35(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1918(%rip), %rsi      # 0x52dc5
movb $0x0, %al
callq 0x86f0
jmp 0x514b6
movq 0x38(%rsp), %rdi
callq 0x16580
movw %ax, 0x26(%rsp)
movzwl 0x26(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x238d0
movl 0xc(%rsp), %ecx
movq %rax, %rdx
movq 0x18(%rsp), %rax
addl %edx, %ecx
movl %ecx, 0x20(%rsp)
movq 0x8(%rax), %rdi
movl 0x34(%rsp), %esi
movl 0x20(%rsp), %edx
callq 0x47490
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/./src/include/Volume.h
// Function: hlkvds::Volume::CalcSegIdFromOffset(unsigned long, unsigned int&)
inline bool CalcSegIdFromOffset(uint64_t offset, uint32_t& seg_id) {
        seg_id = offset >> segSizeBit_;
        if (seg_id >= segNum_) {
            return false;
        }
        return true;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x28(%rsp)
movq -0x18(%rsp), %rax
movl 0x40(%rcx), %ecx
shrq %cl, %rax
movq -0x28(%rsp), %rcx
movl %eax, %edx
movq -0x20(%rsp), %rax
movl %edx, (%rax)
movq -0x20(%rsp), %rax
movl (%rax), %eax
cmpl 0x3c(%rcx), %eax
jb 0x51625
movb $0x0, -0x1(%rsp)
jmp 0x5162a
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Write_batch.cc
// Function: hlkvds::WriteBatch::clear()
void WriteBatch::clear() {
    while(!batch_.empty()) {
        KVSlice *slice = batch_.front();
        batch_.pop_front();
        delete slice;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x239b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x51ad5
jmp 0x51b17
movq 0x10(%rsp), %rdi
callq 0x239d0
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x23a00
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x51b15
movq 0x8(%rsp), %rdi
callq 0x40c40
movq 0x8(%rsp), %rdi
callq 0x84b0
jmp 0x51ac3
addq $0x28, %rsp
retq
nopl (%rax)
// File: eecs280staff[P]unit_test_framework/test/sequence_equal.cpp
// Function: array_vector_equal()
TEST(array_vector_equal) {
  int a[] = { 1, 2 };
  std::vector<double> b = { 1.0, 2.0 };
  ASSERT_SEQUENCE_EQUAL(a, b);
  ASSERT_SEQUENCE_EQUAL(b, a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, -0x8(%rbp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x40(%rbp)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, -0x38(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x2, -0x28(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x57c0
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x57e0
jmp 0x3926
leaq -0x41(%rbp), %rdi
callq 0x5860
leaq 0x7710(%rip), %rcx      # 0xb046
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0xd, %edx
callq 0x5880
jmp 0x394a
leaq 0x7748(%rip), %rcx      # 0xb099
leaq -0x20(%rbp), %rdi
leaq -0x8(%rbp), %rsi
movl $0xe, %edx
callq 0x5d50
jmp 0x3965
leaq -0x20(%rbp), %rdi
callq 0x6220
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x5860
jmp 0x39a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6220
movq -0x50(%rbp), %rdi
callq 0x33d0
nopl (%rax)
// File: eecs280staff[P]unit_test_framework/test/sequence_equal.cpp
// Function: array_vector_unequal()
TEST(array_vector_unequal) {
  int a[] = { 1, 2 };
  std::vector<double> b = { 1.0, 2.0, -2.1 };
  ASSERT_SEQUENCE_EQUAL(a, b);
  ASSERT_SEQUENCE_EQUAL(b, a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, -0x8(%rbp)
movabsq $-0x3fff333333333333, %rax # imm = 0xC000CCCCCCCCCCCD
movq %rax, -0x40(%rbp)
movups 0x79dd(%rip), %xmm0     # 0xb3f8
movaps %xmm0, -0x50(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x3, -0x28(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x57c0
movq -0x70(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x57e0
jmp 0x3a53
leaq -0x51(%rbp), %rdi
callq 0x5860
leaq 0x75e3(%rip), %rcx      # 0xb046
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x1a, %edx
callq 0x5880
jmp 0x3a77
leaq 0x761b(%rip), %rcx      # 0xb099
leaq -0x20(%rbp), %rdi
leaq -0x8(%rbp), %rsi
movl $0x1b, %edx
callq 0x5d50
jmp 0x3a92
leaq -0x20(%rbp), %rdi
callq 0x6220
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x5860
jmp 0x3acd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6220
movq -0x60(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
// File: eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: decltype(print(fp, (*std::begin(fp0), *std::end(fp0))))& unit_test_framework::Diagnostic::print_sequence_helper<int [2]>(std::ostream&, int const (&) [2])
static auto print_sequence_helper(std::ostream &os, const Sequence& seq)
      -> decltype(print(os, (*std::begin(seq), *std::end(seq))))& {
      if (std::begin(seq) == std::end(seq)) {
        return os << "{}";
      }

      auto it = std::begin(seq);
      os << "{ ";
      print(os, *it);
      for (++it; it != std::end(seq); ++it) {
        os << ", ";
        print(os, *it);
      }
      return os << " }";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5740
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5750
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x569b
movq -0x10(%rbp), %rdi
leaq 0x5a03(%rip), %rsi      # 0xb090
callq 0x3210
movq %rax, -0x8(%rbp)
jmp 0x572d
movq -0x18(%rbp), %rdi
callq 0x5740
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x59e0(%rip), %rsi      # 0xb093
callq 0x3210
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x55c0
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5750
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x5719
movq -0x10(%rbp), %rdi
leaq 0x5a5e(%rip), %rsi      # 0xb157
callq 0x3210
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x55c0
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x56d1
movq -0x10(%rbp), %rdi
leaq 0x5972(%rip), %rsi      # 0xb096
callq 0x3210
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zengfenfei[P]codility/src/MinAvgTwoSlice.cpp
// Function: main
int main() {
	vector<int> A(7);
	A[0] = 4;
	A[1] = 2;
	A[2] = 2;
	A[3] = 5;
	A[4] = 1;
	A[5] = 5;
	A[6] = 8;

	cout << solution(A) << '\n';	// 1
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1590
movq -0x38(%rbp), %rdx
leaq -0x18(%rbp), %rdi
movl $0x7, %esi
callq 0x15b0
jmp 0x1439
leaq -0x19(%rbp), %rdi
callq 0x1620
xorl %eax, %eax
movl %eax, %esi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1570
movq -0x48(%rbp), %rdi
movl $0x4, (%rax)
movl $0x1, %esi
callq 0x1570
movq -0x48(%rbp), %rdi
movl $0x2, (%rax)
movl $0x2, %esi
callq 0x1570
movq -0x48(%rbp), %rdi
movl $0x2, (%rax)
movl $0x3, %esi
callq 0x1570
movq -0x48(%rbp), %rdi
movl $0x5, (%rax)
movl $0x4, %esi
callq 0x1570
movq -0x48(%rbp), %rdi
movl $0x1, (%rax)
movl $0x5, %esi
callq 0x1570
movq -0x48(%rbp), %rdi
movl $0x5, (%rax)
movl $0x6, %esi
callq 0x1570
movq -0x48(%rbp), %rdi
movl $0x8, (%rax)
callq 0x1230
movl %eax, %esi
movq 0x2af5(%rip), %rdi      # 0x3fd8
callq 0x10d0
movq %rax, -0x40(%rbp)
jmp 0x14ee
movq -0x40(%rbp), %rdi
movl $0xa, %esi
callq 0x10b0
jmp 0x14fe
leaq -0x18(%rbp), %rdi
callq 0x1640
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x1620
jmp 0x153b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1640
movq -0x28(%rbp), %rdi
callq 0x10e0
nopw %cs:(%rax,%rax)
nop
// File: robertomaldonado[P]HypercubeTopologyRouting/links.cpp
// Function: print_single_route(int, std::vector<int, std::allocator<int>>&)
void print_single_route(int bits_for_node, vector<int> &ref_to_route){
    for(int i = 0 ; i < ref_to_route.size() ; i++){
        printf( int_to_bin_str(bits_for_node, ref_to_route[i]).c_str() );
        if( i+1 != ref_to_route.size() )
            printf("->");
        else
            printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42b0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x32f0
movl -0x4(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x42d0
movl -0x5c(%rbp), %esi
movl (%rax), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x8a20
movq -0x58(%rbp), %rdi
callq 0x20b0
movq %rax, %rdi
xorl %eax, %eax
callq 0x2040
jmp 0x3281
leaq -0x38(%rbp), %rdi
callq 0x2120
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42b0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
je 0x32d2
leaq 0x7e1d(%rip), %rdi      # 0xb0cf
movb $0x0, %al
callq 0x2040
jmp 0x32e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2120
jmp 0x32f6
leaq 0x7de9(%rip), %rdi      # 0xb0c2
movb $0x0, %al
callq 0x2040
jmp 0x32e2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3226
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2290
nop
// File: robertomaldonado[P]HypercubeTopologyRouting/links.cpp
// Function: factorial(int)
int factorial(int n){
    int fact = 1;
    while( n>0 ){
      fact = fact*n;
      n--;
    }
    return fact;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x38d9
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x38be
movl -0x8(%rbp), %eax
popq %rbp
retq
nop
// File: robertomaldonado[P]HypercubeTopologyRouting/checker.cpp
// Function: isArgCountCorrect(int)
int isArgCountCorrect(int arg_count){
    if (arg_count != 3){
        cout << "Usage: ./executable Nsize [dim|all]" << endl;
        return 0;
    }else{
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x864c
movq 0x79a0(%rip), %rdi      # 0xffc8
leaq 0x2af1(%rip), %rsi      # 0xb120
callq 0x21a0
movq %rax, %rdi
movq 0x797a(%rip), %rsi      # 0xffb8
callq 0x21d0
movl $0x0, -0x4(%rbp)
jmp 0x8653
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: robertomaldonado[P]HypercubeTopologyRouting/checker.cpp
// Function: isPowerOfTwo(int)
int isPowerOfTwo(int n_size){

    if ( (ceil(log2(n_size)) == floor(log2(n_size))) ){
        return 1;
    }else{
        cout << "Error: Nsize must be a power of 2 for hypercube." << endl;
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x39c0
callq 0x2060
movsd %xmm0, -0x10(%rbp)
movl -0x8(%rbp), %edi
callq 0x39c0
callq 0x2260
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x86a3
jp 0x86a3
movl $0x1, -0x4(%rbp)
jmp 0x86cc
movq 0x791e(%rip), %rdi      # 0xffc8
leaq 0x2a93(%rip), %rsi      # 0xb144
callq 0x21a0
movq %rax, %rdi
movq 0x78f8(%rip), %rsi      # 0xffb8
callq 0x21d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: robertomaldonado[P]HypercubeTopologyRouting/checker.cpp
// Function: isValidOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int isValidOption(string routing_model){

    if ( routing_model.compare("dim") == 0 || routing_model.compare("all") == 0  ){
        return 1;
    }else{
        cout << "Usage: ./executable Nsize [dim|all]" << endl;
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x2910(%rip), %rsi      # 0xb007
callq 0x2080
cmpl $0x0, %eax
je 0x8716
movq -0x18(%rbp), %rdi
leaq 0x2976(%rip), %rsi      # 0xb082
callq 0x2080
cmpl $0x0, %eax
jne 0x871f
movl $0x1, -0x4(%rbp)
jmp 0x8748
movq 0x78a2(%rip), %rdi      # 0xffc8
leaq 0x29f3(%rip), %rsi      # 0xb120
callq 0x21a0
movq %rax, %rdi
movq 0x787c(%rip), %rsi      # 0xffb8
callq 0x21d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: robertomaldonado[P]HypercubeTopologyRouting/transformations.cpp
// Function: bin_vector_to_int(int, std::vector<bool, std::allocator<bool>>)
int bin_vector_to_int(int bit_size, std::vector<bool >node){
    int translated_node = 0;
    // cout << "Began translation..."<<endl;
    for(int i=0; i < node.size(); i++){
        // cout << pow(2, i) * node[i] << endl;
        translated_node += pow(2, i) * node[i];
    }
    return translated_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x3ac0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x8dcb
movl -0x18(%rbp), %esi
movl $0x2, %edi
callq 0x93a0
movq -0x30(%rbp), %rdi
movsd %xmm0, -0x40(%rbp)
movslq -0x18(%rbp), %rsi
callq 0x3b40
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3ba0
movsd -0x40(%rbp), %xmm0
andb $0x1, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm2
cvtsi2sdl -0x14(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8d51
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/khashlpp/./../common.c
// Function: traverse_rng(unsigned int, unsigned int)
uint64_t traverse_rng(uint32_t n, uint32_t x0)
{
	uint64_t sum = 0;
	uint32_t i, x;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		sum += get_key(n, x);
	}
	return sum;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x123e
movl (%rsp), %edi
callq 0x1250
movl %eax, (%rsp)
movl 0x14(%rsp), %edi
movl (%rsp), %esi
callq 0x12c0
movl %eax, %eax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1204
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/khashlpp/./../common.c
// Function: hash32(unsigned int)
static inline uint32_t hash32(uint32_t key)
{
    key += ~(key << 15);
    key ^=  (key >> 10);
    key +=  (key << 3);
    key ^=  (key >> 6);
    key += ~(key << 11);
    key ^=  (key >> 16);
    return key;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0xf, %eax
xorl $-0x1, %eax
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0xa, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0x3, %eax
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x6, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0xb, %eax
xorl $-0x1, %eax
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: attractivechaos[P]udb2/khashlpp/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	klib::KHashMap<uint32_t, int, aux_hash> h;
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t k;
		int absent;
		x = hash32(x);
		k = h.put(get_key(n, x), &absent);
#ifndef UDB2_TEST_DEL
		if (absent) h.value(k) = 0;
		z += ++h.value(k);
#else
		if (absent) ++z;
		else h.del(k);
#endif
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u; capacity: %d\n", h.size(), z, h.n_buckets());
	return h.size();
}

// Assembly:
subq $0x88, %rsp
movl %edi, 0x84(%rsp)
movl %esi, 0x80(%rsp)
movl $0x0, 0x74(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1770
movl $0x0, 0x7c(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0x84(%rsp), %eax
jae 0x16d1
movl 0x78(%rsp), %edi
callq 0x1250
movl %eax, 0x3c(%rsp)
jmp 0x160a
movl 0x3c(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x84(%rsp), %edi
movl 0x78(%rsp), %esi
callq 0x12c0
movl %eax, 0x38(%rsp)
jmp 0x1628
movl 0x38(%rsp), %eax
movl %eax, 0x40(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1780
movl %eax, 0x34(%rsp)
jmp 0x164a
movl 0x34(%rsp), %eax
movl %eax, 0x54(%rsp)
cmpl $0x0, 0x50(%rsp)
je 0x1698
movl 0x54(%rsp), %esi
leaq 0x58(%rsp), %rdi
callq 0x17c0
movq %rax, 0x28(%rsp)
jmp 0x166e
movq 0x28(%rsp), %rax
movl $0x0, (%rax)
jmp 0x1698
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1840
jmp 0x174e
movl 0x54(%rsp), %esi
leaq 0x58(%rsp), %rdi
callq 0x17c0
movq %rax, 0x20(%rsp)
jmp 0x16ad
movq 0x20(%rsp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
addl 0x74(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x15ea
movq 0x2908(%rip), %rax      # 0x3fe0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x17f0
movl %eax, 0x1c(%rsp)
jmp 0x16f0
movl 0x74(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1800
movl %eax, 0xc(%rsp)
jmp 0x1708
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %ecx
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rdi
leaq 0x954(%rip), %rsi       # 0x2075
xorl %eax, %eax
callq 0x10a0
leaq 0x58(%rsp), %rdi
callq 0x17f0
movl %eax, 0x4(%rsp)
jmp 0x1738
leaq 0x58(%rsp), %rdi
callq 0x1840
movl 0x4(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x10d0
nopl (%rax,%rax)
// File: hyrise[P]sql-parser/src/SQLParser.cpp
// Function: hsql::SQLParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, hsql::SQLParserResult*)
bool SQLParser::parse(const std::string& sql, SQLParserResult* result) {
  yyscan_t scanner;
  YY_BUFFER_STATE state;

  if (hsql_lex_init(&scanner)) {
    // Couldn't initialize the lexer.
    fprintf(stderr, "SQLParser: Error when initializing lexer!\n");
    return false;
  }
  const char* text = sql.c_str();
  state = hsql__scan_string(text, scanner);

  // Parse the tokens.
  // If parsing fails, the result will contain an error object.
  int ret = hsql_parse(result, scanner);
  bool success = (ret == 0);
  result->setIsValid(success);

  hsql__delete_buffer(state, scanner);
  hsql_lex_destroy(scanner);

  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x38af0
cmpl $0x0, %eax
je 0x3a59c
movq 0x529a4(%rip), %rax     # 0x8cf28
movq (%rax), %rdi
leaq 0x34aad(%rip), %rsi     # 0x6f03b
movb $0x0, %al
callq 0x38c00
movb $0x0, 0x37(%rsp)
jmp 0x3a611
movq 0x28(%rsp), %rdi
callq 0x35de0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x39400
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x39a60
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
sete %al
andb $0x1, %al
movb %al, 0x3(%rsp)
movq 0x20(%rsp), %rdi
movb 0x3(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x37b20
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x36ec0
movq 0x18(%rsp), %rdi
callq 0x36530
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: hyrise[P]sql-parser/src/SQLParser.cpp
// Function: hsql::SQLParser::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<short, std::allocator<short>>*)
bool SQLParser::tokenize(const std::string& sql, std::vector<int16_t>* tokens) {
  // Initialize the scanner.
  yyscan_t scanner;
  if (hsql_lex_init(&scanner)) {
    fprintf(stderr, "SQLParser: Error when initializing lexer!\n");
    return false;
  }

  YY_BUFFER_STATE state;
  state = hsql__scan_string(sql.c_str(), scanner);

  YYSTYPE yylval;
  YYLTYPE yylloc;

  // Step through the string until EOF is read.
  // Note: hsql_lex returns int, but we know that its range is within 16 bit.
  int16_t token = hsql_lex(&yylval, &yylloc, scanner);
  while (token != 0) {
    tokens->push_back(token);
    token = hsql_lex(&yylval, &yylloc, scanner);

    if (token == SQL_IDENTIFIER || token == SQL_STRING) {
      free(yylval.sval);
    }
  }

  hsql__delete_buffer(state, scanner);
  hsql_lex_destroy(scanner);
  return true;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x38af0
cmpl $0x0, %eax
je 0x3a74e
movq 0x527f8(%rip), %rax     # 0x8cf28
movq (%rax), %rdi
leaq 0x34901(%rip), %rsi     # 0x6f03b
movb $0x0, %al
callq 0x38c00
movb $0x0, 0xa7(%rsp)
jmp 0x3a867
movq 0x98(%rsp), %rdi
callq 0x35de0
movq %rax, %rdi
movq 0x88(%rsp), %rsi
callq 0x39400
movq %rax, 0x80(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x35e60
movq 0x10(%rsp), %rsi
movq 0x88(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x376d0
movl %eax, 0x18(%rsp)
jmp 0x3a79f
movl 0x18(%rsp), %eax
movw %ax, 0x2e(%rsp)
movswl 0x2e(%rsp), %eax
cmpl $0x0, %eax
je 0x3a82f
movq 0x90(%rsp), %rdi
leaq 0x2e(%rsp), %rsi
callq 0x35750
jmp 0x3a7c6
movq 0x88(%rsp), %rdx
leaq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x376d0
movl %eax, 0xc(%rsp)
jmp 0x3a7e3
movl 0xc(%rsp), %eax
movw %ax, 0x2e(%rsp)
movswl 0x2e(%rsp), %eax
cmpl $0x102, %eax            # imm = 0x102
je 0x3a804
movswl 0x2e(%rsp), %eax
cmpl $0x103, %eax            # imm = 0x103
jne 0x3a82a
movq 0x60(%rsp), %rdi
callq 0x38090
jmp 0x3a82a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3a3e0
jmp 0x3a878
jmp 0x3a7a8
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x36ec0
jmp 0x3a846
movq 0x88(%rsp), %rdi
callq 0x36530
jmp 0x3a855
movb $0x1, 0xa7(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3a3e0
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x399c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: hyrise[P]sql-parser/src/SQLParserResult.cpp
// Function: hsql::SQLParserResult::operator=(hsql::SQLParserResult&&)
SQLParserResult& SQLParserResult::operator=(SQLParserResult&& moved) {
  isValid_ = moved.isValid_;
  errorMsg_ = moved.errorMsg_;
  statements_ = std::move(moved.statements_);

  moved.errorMsg_ = nullptr;
  moved.reset();
  return *this;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movb 0x20(%rax), %al
andb $0x1, %al
movb %al, 0x20(%rdi)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x28(%rdi)
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x393d0
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rdi
callq 0x36ee0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: hyrise[P]sql-parser/src/SQLParserResult.cpp
// Function: hsql::SQLParserResult::reset()
void SQLParserResult::reset() {
  for (SQLStatement* statement : statements_) {
    delete statement;
  }
  statements_.clear();

  isValid_ = false;

  free(errorMsg_);
  errorMsg_ = nullptr;
  errorLine_ = -1;
  errorColumn_ = -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x38280
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x36080
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x36d80
testb $0x1, %al
jne 0x3b9af
jmp 0x3b9e8
leaq 0x20(%rsp), %rdi
callq 0x36f00
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3b9da
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3b9dc
leaq 0x20(%rsp), %rdi
callq 0x38c40
jmp 0x3b99a
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x39ae0
movq 0x8(%rsp), %rax
movb $0x0, 0x20(%rax)
movq 0x28(%rax), %rdi
callq 0x38090
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x34(%rax) # imm = 0xFFFFFFFF
addq $0x38, %rsp
retq
nopl (%rax,%rax)