LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movl 0x38(%rdi), %eax
movl 0x40(%rdi), %ecx
movl %eax, 0x18(%rdi)
movl %ecx, 0x1c(%rdi)
testl %ecx, %ecx
je 0x1ffed
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
leaq 0x30(%rsp), %r12
leaq 0x4(%rsp), %r13
leaq 0x10(%rsp), %rbp
movl $0x108, %edx            # imm = 0x108
movq %r12, %rdi
xorl %esi, %esi
callq 0x6260
movl %r15d, 0x4(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0xe16e
movq (%rax), %rsi
movq %rbp, %rdi
callq 0x20d6c
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x6390
movl %r15d, 0x4(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0xe16e
movq (%rax), %rax
movl 0x3c(%rax), %eax
movl %eax, 0x130(%rsp)
movl %r15d, 0x4(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0xe16e
movq (%rax), %rdi
callq 0x20d64
movl %eax, 0x134(%rsp)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x1ffbf
movl $0x108, %edx            # imm = 0x108
movq %rsi, %rdi
movq %r12, %rsi
callq 0x6390
addq $0x108, 0x28(%rbx)      # imm = 0x108
jmp 0x1ffcc
movq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0x207d4
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1ffe0
callq 0x6400
incl %r15d
cmpl 0x40(%rbx), %r15d
jb 0x1ff23
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20003
jmp 0x20003
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x2001a
callq 0x6400
movq %rbx, %rdi
callq 0x6680
// File: /workspace/github_cpp_makefile_star2_O1/yangwanyuan[P]HLKVDS/src/Tier.cc
// Function: hlkvds::MediumTier::OpenVolume(std::vector<hlkvds::BlockDevice*, std::allocator<hlkvds::BlockDevice*>>&)
bool MediumTier::OpenVolume(std::vector<BlockDevice*> &bd_vec) {
    int fast_tier_device_num = hlkvds::FastTierVolNum;

    segSize_ = sbResMediumTierHeader_.segment_size;
    volNum_ = sbResMediumTierHeader_.volume_num;

    if (!verifyTopology(bd_vec)) {
        __ERROR("TheDevice Topology is inconsistent");
        return false;
    }

    for (uint32_t i = 0; i < volNum_; i++) {
        BlockDevice *bdev = bd_vec[i + fast_tier_device_num];
        uint32_t seg_num = sbResMediumTierVolVec_[i].segment_num;
        uint32_t cur_seg_id = sbResMediumTierVolVec_[i].cur_seg_id;
        Volume *vol = new Volume(bdev, idxMgr_, options_, i, 0, segSize_, seg_num, cur_seg_id);
        volMap_.insert( pair<int, Volume*>(i, vol) );
        segTotalNum_ += seg_num;
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movl 0x18(%rdi), %eax
movl 0x1c(%rdi), %ecx
movl %eax, 0x38(%rdi)
movl %ecx, 0x40(%rdi)
movq %rsi, 0x18(%rsp)
callq 0x2012c
movb %al, 0xf(%rsp)
testb %al, %al
je 0x20112
cmpl $0x0, 0x40(%r14)
je 0x200ff
leaq 0x48(%r14), %rax
movq %rax, 0x10(%rsp)
movl $0x104, %ebx            # imm = 0x104
xorl %r13d, %r13d
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax,%r13,8), %r12
movq 0x20(%r14), %rax
movl -0x4(%rax,%rbx), %r15d
movl (%rax,%rbx), %eax
movq %rax, 0x20(%rsp)
movl $0x58, %edi
callq 0x6420
movq %rax, %rbp
movq (%r14), %rcx
movq 0x10(%r14), %rdx
movl 0x38(%r14), %eax
subq $0x8, %rsp
movq %rbp, %rdi
movq %r12, %rsi
movl %r13d, %r8d
xorl %r9d, %r9d
pushq 0x28(%rsp)
pushq %r15
pushq %rax
callq 0x20b3c
addq $0x20, %rsp
leaq 0x1(%r13), %r12
movl %r13d, 0x28(%rsp)
movq %rbp, 0x30(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf866
addl %r15d, 0x3c(%r14)
movl 0x40(%r14), %eax
addq $0x108, %rbx            # imm = 0x108
movq %r12, %r13
cmpq %rax, %r12
jb 0x20071
movb 0xf(%rsp), %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x91cf
jmp 0x200ff
movq %rax, %rbx
movq %rbp, %rdi
callq 0x6400
movq %rbx, %rdi
callq 0x6680
// File: /workspace/github_cpp_makefile_star2_O1/yangwanyuan[P]HLKVDS/src/Tier.cc
// Function: hlkvds::MediumTier::verifyTopology(std::vector<hlkvds::BlockDevice*, std::allocator<hlkvds::BlockDevice*>>&)
bool MediumTier::verifyTopology(std::vector<BlockDevice*> &bd_vec) {
    int fast_tier_device_num = hlkvds::FastTierVolNum;

    // Verify MediumTier Volume Number
    if (volNum_ != bd_vec.size() - fast_tier_device_num) {
        __ERROR("record MediumTierVolNum_ = %d, total block device number: %d", volNum_, (int)bd_vec.size() );
        return false;
    }

    // Verify MediumTier every Volume
    for (uint32_t i = 0; i < volNum_; i++) {
        string record_path = string(sbResMediumTierVolVec_[i].dev_path);
        string device_path = bd_vec[i + fast_tier_device_num]->GetDevicePath();
        if (record_path != device_path) {
            __ERROR("record_path: %s, device_path:%s ", record_path.c_str(), device_path.c_str());
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x40(%rdi), %rbx
movq 0x8(%rsi), %rax
movq %rsi, (%rsp)
subq (%rsi), %rax
movl 0x40(%rdi), %ecx
sarq $0x3, %rax
decq %rax
cmpq %rcx, %rax
jne 0x20240
cmpl $0x0, (%rbx)
sete %bpl
je 0x2022b
movq %rdi, %r15
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x20(%r15), %rax
leaq (%rax,%r12), %r13
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
testq %rax, %rax
je 0x20199
movq %r13, %rdi
callq 0x61a0
movq %rax, %rdx
addq %r13, %rdx
jmp 0x2019e
movl $0x1, %edx
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0xa6dc
movq (%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax,%r14,8), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %rdi
callq *0x28(%rax)
movq 0x10(%rsp), %rdx
cmpq 0x30(%rsp), %rdx
jne 0x20254
testq %rdx, %rdx
je 0x201ea
movq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x6430
testl %eax, %eax
jne 0x20254
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x201fe
callq 0x6400
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x20212
callq 0x6400
incq %r14
movl (%rbx), %eax
addq $0x108, %r12            # imm = 0x108
cmpq %rax, %r14
setae %bpl
jb 0x20172
andb $0x1, %bpl
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rdx
leaq 0x8(%rdx), %rsi
movq %rbx, %rdi
callq 0x9231
xorl %ebp, %ebp
jmp 0x2022b
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x92af
jmp 0x2022b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x20281
callq 0x6400
movq %rbx, %rdi
callq 0x6680
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x0, 0x40(%rdi)
je 0x202d2
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
xorl %ebp, %ebp
movl %r12d, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xe16e
movq (%rax), %rdi
callq 0x20d8a
addl %eax, %ebp
incl %r12d
cmpl 0x40(%rbx), %r12d
jb 0x202ad
jmp 0x202d4
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x0, 0x40(%rdi)
je 0x2032c
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
xorl %ebp, %ebp
movl %r12d, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xe16e
movq (%rax), %rdi
callq 0x20d94
addl %eax, %ebp
incl %r12d
cmpl 0x40(%rbx), %r12d
jb 0x20307
jmp 0x2032e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %r13d, %r13d
cmpl $0x0, 0x40(%rdi)
je 0x20389
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
leaq 0xc(%rsp), %r12
xorl %r15d, %r15d
movl %r13d, 0xc(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xe16e
movq (%rax), %rdi
callq 0x20d7e
addq %rax, %r15
incl %r13d
cmpl 0x40(%rbx), %r13d
jb 0x20363
jmp 0x2038c
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
leaq -0x2f(%rip), %rdx       # 0x20a7c
xorl %esi, %esi
movq %rbx, %rcx
callq 0x66e0
testl %eax, %eax
jne 0x20ac0
movl $0x1, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x1, 0x10(%rdi)
jne 0x20aea
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
xorl %esi, %esi
callq 0x63e0
testl %eax, %eax
jne 0x20ae9
movl $0x0, 0x14(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x1, 0x10(%rdi)
jne 0x20b18
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x14(%rdi)
jne 0x20b17
movq 0x8(%rbx), %rdi
callq 0x6300
testl %eax, %eax
jne 0x20b17
movl $0x1, 0x14(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
addq 0x30(%rdi), %rcx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %r14
cmpq %rbx, %rax
jne 0x20d2a
cmpq %rbx, %r14
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x94de
jmp 0x20d1c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
addq 0x30(%rdi), %rcx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %r14
cmpq %rbx, %rax
jne 0x20d5c
cmpq %rbx, %r14
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x953e
jmp 0x20d4e
nop
// File: /workspace/github_cpp_makefile_star2_O1/yangwanyuan[P]HLKVDS/./src/include/Volume.h
// Function: hlkvds::Volume::CalcSegOffsetFromOffset(unsigned long, unsigned long&)
inline bool CalcSegIdFromOffset(uint64_t offset, uint32_t& seg_id) {
        seg_id = offset >> segSizeBit_;
        if (seg_id >= segNum_) {
            return false;
        }
        return true;
    }

// Assembly:
movl 0x3c(%rdi), %eax
movl 0x40(%rdi), %ecx
shrq %cl, %rsi
cmpl %esi, %eax
jbe 0x20e0d
movl %esi, %edi
shlq %cl, %rdi
movq %rdi, (%rdx)
cmpl %esi, %eax
seta %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x22(%rax), %rdi
movb 0x40(%rbx), %cl
movq %rdi, %r15
shrq %cl, %r15
cmpl %r15d, 0x3c(%rbx)
jbe 0x20e8c
movq (%r14), %rax
movzwl 0x16(%rax), %edx
addl $0x20, %edx
movq 0x8(%rbx), %rdi
movl %r15d, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1d820
callq 0x959e
jmp 0x20e71
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x38, %rsp
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x20(%rsp), %rbx
movq %rax, (%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, 0x8(%rsi)
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rcx
movl $0x2, %edx
movq %r14, %rdi
callq 0x3720
leaq 0x3945(%rip), %rcx      # 0x608c
movq %rbx, %rdi
movq %r14, %rsi
movl $0xd, %edx
callq 0x3766
leaq 0x3981(%rip), %rcx      # 0x60df
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0xe, %edx
callq 0x3abe
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2789
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x27ab
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x48, %rsp
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x28(%rsp), %rbx
movq %rax, (%rbx)
movups 0x3bef(%rip), %xmm0     # 0x6400
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
movabsq $-0x3fff333333333333, %rax # imm = 0xC000CCCCCCCCCCCD
movq %rax, 0x10(%rsi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rcx
movl $0x3, %edx
movq %r14, %rdi
callq 0x3720
leaq 0x3847(%rip), %rcx      # 0x608c
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1a, %edx
callq 0x3766
leaq 0x3883(%rip), %rcx      # 0x60df
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0x1b, %edx
callq 0x3abe
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2887
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x28a9
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/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<std::vector<double, std::allocator<double>>>(std::ostream&, std::vector<double, std::allocator<double>> const&)
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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r13
cmpq 0x8(%rsi), %r13
je 0x3f3a
movq %rsi, %r14
leaq 0x21fc(%rip), %rsi      # 0x60d9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2220
movsd (%r13), %xmm0
movq %rbx, %rdi
callq 0x22c0
addq $0x8, %r13
leaq 0x21d9(%rip), %r15      # 0x60dc
cmpq 0x8(%r14), %r13
je 0x3f41
leaq 0x228d(%rip), %r12      # 0x619d
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2220
movsd (%r13), %xmm0
movq %rbx, %rdi
callq 0x22c0
addq $0x8, %r13
cmpq 0x8(%r14), %r13
jne 0x3f10
jmp 0x3f41
leaq 0x2195(%rip), %r15      # 0x60d6
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/MinAvgTwoSlice.cpp
// Function: solution(std::vector<int, std::allocator<int>>&)
int solution(vector<int> &A) {
	int n = A.size();
	int minI = 0;
	double minAvg = (A[0] + A[1]) / 2.0;
	for (int i = 0; i < n - 2; i++) {
		double avg = (A[i] + A[i + 1]) / 2.0;
		if (avg < minAvg) {
			minAvg = avg;
			minI = i;
		}
		avg = (A[i] + A[i + 1] + A[i + 2]) / 3.0;
		if (avg < minAvg) {
			minAvg = avg;
			minI = i;
		}
	}
	if (n > 2) {	// Check the last 2 elements
		double avg = (A[n - 2] + A[n - 1]) / 2.0;
		if (avg < minAvg) {
			minAvg = avg;
			minI = n - 2;
		}
	}
	return minI;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
movl 0x4(%rcx), %eax
addl (%rcx), %eax
cvtsi2sd %eax, %xmm0
mulsd 0xe0d(%rip), %xmm0      # 0x2008
sarq $0x2, %rdx
leal -0x2(%rdx), %esi
xorl %eax, %eax
cmpl $0x3, %edx
jl 0x1274
movl %esi, %edi
xorl %r8d, %r8d
movsd 0xdf2(%rip), %xmm1      # 0x2008
movsd 0xdf2(%rip), %xmm2      # 0x2010
xorl %eax, %eax
movl 0x4(%rcx,%r8,4), %r9d
addl (%rcx,%r8,4), %r9d
xorps %xmm4, %xmm4
cvtsi2sd %r9d, %xmm4
mulsd %xmm1, %xmm4
movapd %xmm4, %xmm5
addl 0x8(%rcx,%r8,4), %r9d
xorps %xmm3, %xmm3
cvtsi2sd %r9d, %xmm3
minsd %xmm0, %xmm5
divsd %xmm2, %xmm3
ucomisd %xmm3, %xmm5
cmoval %r8d, %eax
ucomisd %xmm4, %xmm0
cmoval %r8d, %eax
leaq 0x1(%r8), %r9
minsd %xmm5, %xmm3
movq %r9, %r8
movapd %xmm3, %xmm0
cmpq %r9, %rdi
jne 0x1220
jmp 0x1278
movapd %xmm0, %xmm3
cmpl $0x2, %edx
jle 0x129e
movslq %esi, %rdi
decl %edx
movl (%rcx,%rdx,4), %edx
addl (%rcx,%rdi,4), %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
mulsd 0xd71(%rip), %xmm0      # 0x2008
ucomisd %xmm0, %xmm3
cmoval %esi, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl $0x1c, %edi
callq 0x1040
movq %rax, %rbx
movq %rax, (%r14)
movq %rax, 0x8(%r14)
addq $0x1c, %rax
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0xc(%rbx)
movq %rax, 0x8(%r14)
movaps 0xd31(%rip), %xmm0      # 0x2020
movups %xmm0, (%rbx)
movabsq $0x500000001, %rax      # imm = 0x500000001
movq %rax, 0x10(%rbx)
movl $0x8, 0x18(%rbx)
movq %r14, %rdi
callq 0x11dc
movq 0x2cc2(%rip), %rdi      # 0x3fd8
movl %eax, %esi
callq 0x1080
leaq -0x11(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1060
movl $0x1c, %esi
movq %rbx, %rdi
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x1c, %esi
movq %rbx, %rdi
callq 0x1050
movq %r14, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x1, %eax
testl %edi, %edi
jle 0x38e7
imull %edi, %eax
leal -0x1(%rdi), %ecx
cmpl $0x1, %edi
movl %ecx, %edi
jg 0x38da
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl $0x1, %eax
cmpl $0x3, %edi
je 0x4442
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x4bd1(%rip), %rbx      # 0x8fd0
leaq 0x1d5e(%rip), %rsi      # 0x6164
movl $0x23, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x18, %rsp
cvtsi2sd %edi, %xmm0
movsd %xmm0, -0x10(%rbp)
callq 0x2290
callq 0x2070
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x2290
callq 0x2260
movl $0x1, %eax
movsd -0x18(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x4485
jnp 0x44c9
movq 0x4b44(%rip), %rbx      # 0x8fd0
leaq 0x1cf5(%rip), %rsi      # 0x6188
movl $0x30, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x1b42(%rip), %rsi      # 0x6023
callq 0x2090
movl $0x1, %ebx
testl %eax, %eax
je 0x4546
leaq 0x1b8d(%rip), %rsi      # 0x6083
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x4546
movq 0x4ac7(%rip), %rbx      # 0x8fd0
leaq 0x1c54(%rip), %rsi      # 0x6164
movl $0x23, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/robertomaldonado[P]HypercubeTopologyRouting/transformations.cpp
// Function: map_to_bin_str[abi:cxx11](std::map<int, std::vector<int, std::allocator<int>>, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&, int)
std::string map_to_bin_str(std::map<int, std::vector<int> > &nodes_map , int n_size){
    int bit_size = log2(n_size); //Stores how many bits long is each node 
    std::string output = "";
    //For each node in the map, print it with the corresponding neighbors
    for(std::map<int,std::vector<int> >::iterator nodes_map_it = nodes_map.begin(); nodes_map_it != nodes_map.end(); ++nodes_map_it){
        //Print the current node in binary
        output += int_to_bin_str( bit_size, nodes_map_it->first);
        output += ": ";
        //Print the neighbors in binary of the current node
        for( std::vector<int>::iterator nei_it = nodes_map_it->second.begin(); nei_it != nodes_map_it->second.end(); ++nei_it){
            output += int_to_bin_str( bit_size, *nei_it);
            if(nei_it+1 != nodes_map_it->second.end() )
                output += " ";
        }
        output += "\n";
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cvtsi2sd %edx, %xmm0
callq 0x2290
movsd %xmm0, -0x58(%rbp)
leaq 0x10(%rbx), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rbx)
leaq 0x1b22(%rip), %rdx      # 0x60a9
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4cd8
movq 0x18(%r14), %r15
addq $0x8, %r14
movq %r14, -0x60(%rbp)
cmpq %r14, %r15
je 0x466a
cvttsd2si -0x58(%rbp), %r12d
leaq -0x48(%rbp), %r13
movl 0x20(%r15), %edx
movq %r13, %rdi
movl %r12d, %esi
callq 0x46b4
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x20a0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x45e2
callq 0x2180
movq %rbx, %rdi
leaq 0x1ac6(%rip), %rsi      # 0x60b2
callq 0x22b0
movq 0x28(%r15), %r14
cmpq 0x30(%r15), %r14
je 0x4646
movl (%r14), %edx
movq %r13, %rdi
movl %r12d, %esi
callq 0x46b4
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x20a0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x462b
callq 0x2180
addq $0x4, %r14
cmpq 0x30(%r15), %r14
je 0x45f5
movq %rbx, %rdi
leaq 0x1aa5(%rip), %rsi      # 0x60e4
callq 0x22b0
jmp 0x45f5
movq %rbx, %rdi
leaq 0x1a58(%rip), %rsi      # 0x60a8
callq 0x22b0
movq %r15, %rdi
callq 0x2120
movq %rax, %r15
cmpq -0x60(%rbp), %rax
jne 0x45b1
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4684
jmp 0x4689
jmp 0x4684
jmp 0x4684
movq %rax, %r15
jmp 0x469e
movq %rax, %r15
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x469e
callq 0x2180
movq (%rbx), %rdi
cmpq -0x50(%rbp), %rdi
je 0x46ac
callq 0x2180
movq %r15, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rax
subq (%rsi), %rax
movl 0x18(%rsi), %ecx
shlq $0x3, %rax
xorl %r14d, %r14d
addq %rcx, %rax
je 0x4a69
movq %rsi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
callq 0x2170
movq %r15, %rcx
shrq $0x6, %rcx
movq (%rbx), %rax
movq (%rax,%rcx,8), %rcx
btq %r15, %rcx
movsd 0x1788(%rip), %xmm1     # 0x61c0
jb 0x4a3e
xorpd %xmm1, %xmm1
movq 0x10(%rbx), %rcx
xorps %xmm2, %xmm2
cvtsi2sd %r14d, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
cvttsd2si %xmm0, %r14d
incq %r15
movl 0x18(%rbx), %edx
subq %rax, %rcx
leaq (%rdx,%rcx,8), %rax
cmpq %r15, %rax
ja 0x4a11
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/robertomaldonado[P]HypercubeTopologyRouting/transformations.cpp
// Function: int_to_bin_vector(int, int)
std::vector<bool> int_to_bin_vector(int bit_size, int node){

    int tmp_count = 0;
    std::vector<bool> node_bits;
    std::string output_str = "";
    // output_str += std::to_string(node) + "(";
    //Keep adding the bits based on the parity of bits
    while(node != 0){
        if( (node % 2) == 0 ){
            node_bits.push_back(0); node = floor(node/2);
        }else{
            node_bits.push_back(1); node = floor(node/2);
        }
    }
    //Push into the vector of node_bits
    tmp_count = node_bits.size();
    while(  tmp_count < bit_size ){
        node_bits.push_back(0);
        tmp_count++;
    }
    //Add the bits to the output string
    for(int i = node_bits.size()-1; i >= 0; i--)
        output_str += std::to_string(node_bits[i]);

    return node_bits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, (%rdi)
movl %eax, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movl %eax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x15f6(%rip), %rdx      # 0x60a9
leaq -0x68(%rbp), %rdi
movq %rdx, %rsi
callq 0x4cd8
testl %r15d, %r15d
je 0x4af6
testb $0x1, %r15b
jne 0x4ad9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4c12
sarl %r15d
jmp 0x4abf
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4c12
movl %r15d, %eax
shrl $0x1f, %eax
addl %r15d, %eax
sarl %eax
movl %eax, %r15d
jmp 0x4abf
movl 0x10(%rbx), %r15d
subl (%rbx), %r15d
shll $0x3, %r15d
addl 0x18(%rbx), %r15d
cmpl %r14d, %r15d
jge 0x4b19
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4c12
incl %r15d
jmp 0x4b05
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl 0x18(%rbx), %edx
movl %ecx, %esi
subl %eax, %esi
leal (%rdx,%rsi,8), %esi
decl %esi
js 0x4ba5
leaq -0x38(%rbp), %r13
leal (%rdx,%rcx,8), %r12d
shll $0x3, %eax
subl %eax, %r12d
movl %esi, %r14d
movq (%rbx), %rax
movq %r14, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %r15
movq %r13, -0x48(%rbp)
movl $0x1, %esi
leaq -0x48(%rbp), %rdi
movl $0x2d, %edx
callq 0x21d0
xorl %edx, %edx
btq %r14, %r15
setb %dl
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x4c66
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x20a0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4b9a
callq 0x2180
decl %r12d
decq %r14
testl %r12d, %r12d
jg 0x4b3f
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4bb7
callq 0x2180
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4bfa
jmp 0x4be5
jmp 0x4be5
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4be8
callq 0x2180
jmp 0x4be8
movq %rax, %r14
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4bfa
callq 0x2180
movq %rbx, %rdi
callq 0x3d8e
movq %r14, %rdi
callq 0x2280
movq %rax, %rdi
callq 0x3c59
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %edi, %edi
je 0x159d
movl %edi, %r8d
shrl $0x2, %r8d
xorl %ecx, %ecx
movl %esi, %eax
shll $0xf, %eax
notl %eax
addl %esi, %eax
movl %eax, %edx
shrl $0xa, %edx
xorl %eax, %edx
leal (%rdx,%rdx,8), %eax
movl %eax, %edx
shrl $0x6, %edx
xorl %eax, %edx
movl %edx, %eax
shll $0xb, %eax
notl %eax
addl %edx, %eax
movl %eax, %esi
shrl $0x10, %esi
xorl %eax, %esi
movl %esi, %eax
xorl %edx, %edx
divl %r8d
movl %edx, %eax
shll $0xf, %eax
notl %eax
addl %edx, %eax
movl %eax, %edx
shrl $0xa, %edx
xorl %eax, %edx
leal (%rdx,%rdx,8), %eax
movl %eax, %edx
shrl $0x6, %edx
xorl %eax, %edx
movl %edx, %eax
shll $0xb, %eax
notl %eax
addl %edx, %eax
movl %eax, %edx
shrl $0x10, %edx
xorl %eax, %edx
addq %rdx, %rcx
decl %edi
jne 0x1539
jmp 0x159f
xorl %ecx, %ecx
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/khashlpp/./khashl.hpp
// Function: klib::KHashSet<klib::KHashMapBucket<unsigned int, int>, klib::KHashMapHash<klib::KHashMapBucket<unsigned int, int>, aux_hash, unsigned int>, klib::KHashMapEq<klib::KHashMapBucket<unsigned int, int>, std::equal_to<unsigned int>>, unsigned int>::put(klib::KHashMapBucket<unsigned int, int> const&, int*)
khint_t put(const T &key, int *absent_ = 0) {
		khint_t nb, i, last, mask;
		int absent = -1;
		nb = n_buckets();
		if (count >= (nb>>1) + (nb>>2)) { /* rehashing */
			if (resize(nb + khint_t(1)) < 0) {
				if (absent_) *absent_ = -1;
				return nb;
			}
			nb = n_buckets();
		} /* TODO: to implement automatically shrinking; resize() already support shrinking */
		mask = nb - 1;
		i = last = __kh_h2b(Hash()(key), bits);
		while (__kh_used(used, i) && !Eq()(keys[i], key)) {
			i = (i + 1U) & mask;
			if (i == last) break;
		}
		if (!__kh_used(used, i)) { /* not present at all */
			keys[i] = key;
			__kh_set_used(used, i);
			++count, absent = 1;
		} else absent = 0; /* Don't touch keys[i] if present */
		if (absent_) *absent_ = absent;
		return i;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movb (%rdi), %cl
movl $0x1, %eax
shll %cl, %eax
xorl %r15d, %r15d
cmpq $0x0, 0x8(%rdi)
cmovnel %eax, %r15d
movq %rsi, %r12
movl %r15d, %eax
shrl %eax
movl %r15d, %ecx
shrl $0x2, %ecx
addl %eax, %ecx
cmpl %ecx, 0x4(%rdi)
jb 0x1738
leal 0x1(%r15), %esi
movq %r14, %rdi
callq 0x17d8
testl %eax, %eax
js 0x17bc
movb (%r14), %cl
movl $0x1, %eax
shll %cl, %eax
xorl %r15d, %r15d
cmpq $0x0, 0x8(%r14)
cmovnel %eax, %r15d
movl %r15d, %eax
movl (%r12), %edx
imull $0x9e3779b9, %edx, %esi # imm = 0x9E3779B9
xorl %ecx, %ecx
subb (%r14), %cl
shrl %cl, %esi
decl %eax
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rdi
movl %esi, %r15d
movl %r15d, %r8d
shrl $0x5, %r8d
movl (%rcx,%r8,4), %r8d
btl %r15d, %r8d
jae 0x177e
movl %r15d, %r8d
cmpl %edx, (%rdi,%r8,8)
je 0x177e
incl %r15d
andl %eax, %r15d
cmpl %esi, %r15d
jne 0x1759
movl %r15d, %edx
shrl $0x5, %edx
movl (%rcx,%rdx,4), %esi
movl %r15d, %ecx
andl $0x1f, %ecx
xorl %eax, %eax
btl %ecx, %esi
jb 0x17c1
movq 0x10(%r14), %rax
movl %r15d, %esi
movq (%r12), %rdi
movq %rdi, (%rax,%rsi,8)
movl $0x1, %eax
shll %cl, %eax
movq 0x8(%r14), %rcx
orl %eax, (%rcx,%rdx,4)
movl $0x1, %eax
incl 0x4(%r14)
jmp 0x17c1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x17c8
movl %eax, (%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0x12cf0
movl %eax, %ebx
testl %eax, %eax
jne 0x1380e
movq (%r15), %rdi
movq 0x8(%rsp), %rsi
callq 0x12f40
movq %rax, %r15
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x13130
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %r14, %rdi
callq 0x12a10
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x126d0
movq 0x8(%rsp), %rdi
callq 0x12500
testl %ebx, %ebx
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x1337c
jmp 0x137ff
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %rdi
callq 0x12cf0
movl %eax, %ebx
testl %eax, %eax
jne 0x139a1
movq (%r15), %rdi
movq 0x10(%rsp), %rsi
callq 0x12f40
movq %rax, %r15
xorps %xmm0, %xmm0
leaq 0x18(%rsp), %rsi
movups %xmm0, 0x18(%rsi)
movq $0x0, 0x28(%rsi)
movq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x12910
movw %ax, 0xe(%rsp)
testw %ax, %ax
je 0x1395f
leaq 0xe(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq 0x18(%rsp), %rbp
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x1391f
movw %ax, (%rsi)
addq $0x2, %rsi
movq %rsi, 0x8(%r14)
jmp 0x1392a
movq %r14, %rdi
movq %r12, %rdx
callq 0x12980
movq 0x10(%rsp), %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x12910
movw %ax, 0xe(%rsp)
andl $0xfffe, %eax           # imm = 0xFFFE
cmpl $0x102, %eax            # imm = 0x102
jne 0x13955
movq 0x48(%rsp), %rdi
callq 0x12ab0
movzwl 0xe(%rsp), %eax
testw %ax, %ax
jne 0x13908
movq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x126d0
movq 0x10(%rsp), %rdi
callq 0x12500
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1398d
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x12990
testl %ebx, %ebx
sete %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1339e
jmp 0x1398d
jmp 0x139aa
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x139c4
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x12990
movq %rbx, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0x20(%rsi), %al
movb %al, 0x20(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x12870
movq $0x0, 0x28(%rbx)
movq %rbx, %rdi
callq 0x126e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0x13d61
movq (%r14), %rdi
testq %rdi, %rdi
je 0x13d5b
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x13d48
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x13d6f
movq %rax, 0x10(%rbx)
movb $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x12ab0
movq $0x0, 0x28(%rbx)
movq $-0x1, 0x30(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::operator<<(std::ostream&, hsql::ConstraintType)
std::ostream& operator<<(std::ostream& os, const ConstraintType constraint_type) {
  switch (constraint_type) {
    case ConstraintType::Null:
      os << "NULL";
      break;
    case ConstraintType::NotNull:
      os << "NOT NULL";
      break;
    case ConstraintType::ForeignKey:
      os << "FOREIGN KEY";
      break;
    case ConstraintType::PrimaryKey:
      os << "PRIMARY KEY";
      break;
    case ConstraintType::Unique:
      os << "UNIQUE";
      break;
  }
  return os;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x4, %esi
ja 0x1ec8a
movl %esi, %eax
leaq 0x14476(%rip), %rcx     # 0x330b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x144ff(%rip), %rsi     # 0x33149
jmp 0x1ec6f
leaq 0x885f(%rip), %rsi      # 0x274b2
movl $0x6, %edx
jmp 0x1ec82
leaq 0x14ae4(%rip), %rsi     # 0x33745
movl $0x4, %edx
jmp 0x1ec82
leaq 0x144e6(%rip), %rsi     # 0x33155
movl $0xb, %edx
jmp 0x1ec82
leaq 0x144c3(%rip), %rsi     # 0x33140
movl $0x8, %edx
movq %rbx, %rdi
callq 0x12a70
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::ReferencesSpecification::~ReferencesSpecification()
ReferencesSpecification::~ReferencesSpecification() {
  free(schema);
  free(table);
  if (columns) {
    for (auto* column : *columns) {
      free(column);
    }
    delete columns;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x12ab0
movq 0x8(%rbx), %rdi
callq 0x12ab0
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1ed9f
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x1ed70
movq (%r14), %rdi
callq 0x12ab0
addq $0x8, %r14
jmp 0x1ed5d
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x1ed9f
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1ed8d
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12990
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::ColumnDefinition::~ColumnDefinition()
ColumnDefinition::~ColumnDefinition() {
  free(name);
  delete column_constraints;
  if (references) {
    for (auto* ref : *references) {
      delete ref;
    }
  }
  delete references;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1c0da(%rip), %rax     # 0x3afa0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
callq 0x12ab0
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x1eef4
movq %r14, %rdi
callq 0x12890
movl $0x38, %esi
movq %r14, %rdi
callq 0x12990
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x1ef2c
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x1ef2c
movq (%r15), %r14
testq %r14, %r14
je 0x1ef26
movq %r14, %rdi
callq 0x131a0
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
addq $0x8, %r15
jmp 0x1ef04
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
je 0x1ef61
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1ef49
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12990
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::ColumnDefinition::trySetNullableExplicit()
bool ColumnDefinition::trySetNullableExplicit() {
  if (column_constraints->count(ConstraintType::NotNull) || column_constraints->count(ConstraintType::PrimaryKey)) {
    if (column_constraints->count(ConstraintType::Null)) {
      return false;
    }
    nullable = false;
  }

  return true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0xc(%rsp), %rsi
movl $0x1, (%rsi)
callq 0x12ac0
testq %rax, %rax
jne 0x1efc0
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x3, (%rsi)
callq 0x12ac0
testq %rax, %rax
je 0x1efe1
movq 0x8(%rbx), %rdi
leaq 0x4(%rsp), %rsi
movl $0x2, (%rsi)
callq 0x12ac0
testq %rax, %rax
je 0x1efdd
xorl %eax, %eax
jmp 0x1efe3
movb $0x0, 0x38(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::CreateStatement::~CreateStatement()
CreateStatement::~CreateStatement() {
  free(filePath);
  free(schema);
  free(tableName);
  free(indexName);
  delete select;

  if (columns) {
    for (auto* def : *columns) {
      delete def;
    }
    delete columns;
  }

  if (tableConstraints) {
    for (auto* def : *tableConstraints) {
      delete def;
    }
    delete tableConstraints;
  }

  if (indexColumns) {
    for (char* column : *indexColumns) {
      free(column);
    }
    delete indexColumns;
  }

  if (viewColumns) {
    for (char* column : *viewColumns) {
      free(column);
    }
    delete viewColumns;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1bf45(%rip), %rax     # 0x3af90
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
callq 0x12ab0
movq 0x30(%rbx), %rdi
callq 0x12ab0
movq 0x38(%rbx), %rdi
callq 0x12ab0
movq 0x40(%rbx), %rdi
callq 0x12ab0
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x1f085
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x1f0d8
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x1f0ae
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f0a8
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x1f095
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x1f0d8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f0cb
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x1f12b
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x1f101
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f0fb
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x1f0e8
movq 0x58(%rbx), %r14
testq %r14, %r14
je 0x1f12b
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f11e
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x1f178
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x1f14e
movq (%r14), %rdi
callq 0x12ab0
addq $0x8, %r14
jmp 0x1f13b
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x1f178
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f16b
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x1f1c5
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x1f19b
movq (%r14), %rdi
callq 0x12ab0
addq $0x8, %r14
jmp 0x1f188
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x1f1c5
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f1b8
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12c10