LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: hm3::VectorList::shiftL_(unsigned long)
bool VectorList::shiftL_(size_type const index){
	// this is the most slow operation of them all
	xmemmove(
		& buffer_[index],
		& buffer_[index + 1],
		(dataCount_ - index - 1) * ELEMENT_SIZE
	);

	resize_(-1);

	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq (%rax,%rsi,8), %rdi
leaq (%rax,%rsi,8), %rax
addq $0x8, %rax
notq %rsi
addq 0x18(%rbx), %rsi
leaq (,%rsi,8), %rdx
movq %rax, %rsi
callq 0x2200
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x99de
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: hm3::VectorList::resize_(int)
bool VectorList::resize_(int const delta){
	if (delta == 0){
		// already resized, done :)
		return true;
	}

	if (dataCount_ == 0 && delta < 0){
		// must be an error
		return true;
	}

	size_type const new_dataCount = dataCount_ + (size_type) sgn(delta);

	if (new_dataCount == 0){
		clear_(true);
		return true;
	}

	size_type const new_reservedCount = calcNewCount_(new_dataCount);

	if (reservedCount_ == new_reservedCount){
		// already resized, done :)
		dataCount_ = new_dataCount;

		return true;
	}

	Pair *new_buffer = (Pair *) xrealloc(buffer_, new_reservedCount * ELEMENT_SIZE);

	if (new_buffer == nullptr)
		return false;

	dataCount_	= new_dataCount;
	reservedCount_	= new_reservedCount;
	buffer_		= new_buffer;

	return true;
}

// Assembly:
movb $0x1, %al
testl %esi, %esi
je 0x9a87
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
testq %r14, %r14
sete %cl
testl %esi, %esi
sets %dl
testb %cl, %dl
jne 0x9a82
sarl $0x1f, %esi
orl $0x1, %esi
movslq %esi, %rax
addq %rax, %r14
je 0x9a3a
movq (%rbx), %rcx
movq 0x10(%rbx), %rsi
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r15
cmpq $0x1, %rdx
sbbq $-0x1, %r15
imulq %rcx, %r15
cmpq %r15, %rsi
jne 0x9a58
movq %r14, 0x18(%rbx)
jmp 0x9a80
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0x9a4c
callq 0x21b0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x9a80
movq 0x8(%rbx), %rdi
leaq (,%r15,8), %rsi
callq 0x2220
movq %rax, %rcx
testq %rax, %rax
setne %al
je 0x9a82
movq %r14, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movq %rcx, 0x8(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: hm3::VectorList::calcNewCount_(unsigned long)
auto VectorList::calcNewCount_(size_type const count) -> size_type{
	size_type newsize = count / reallocCount_;

	if (count % reallocCount_)
		++newsize;

	return newsize * reallocCount_;
}

// Assembly:
movq %rsi, %rax
movq (%rdi), %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rdx
sbbq $-0x1, %rax
imulq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/vectorlist.cc
// Function: bool hm3::VectorList::putT_<hm3::Pair>(hm3::Pair&&)
bool VectorList::putT_(UPAIR&& newdata){
	const StringRef &key = newdata.getKey();

	size_type result;
	bool const found = binarySearch_(key, result);

	if (found){
		// key exists, overwrite, do not shift

		Pair & olddata = buffer_[ result ];

		// check if the data in database is valid
		if (! newdata.valid(olddata) ){
			// newdata will be magically destroyed.
			return false;
		}

		dataSize_ = dataSize_
					- olddata.getBytes()
					+ newdata.getBytes();

		// copy assignment
		olddata = std::forward<UPAIR>(newdata);

		return true;
	}

	// key not exists, shift, then add
	if ( ! shiftR_( result ) ){
		return false;
	}

	dataSize_ += newdata.getBytes();

	// placement new with copy constructor
	void *placement = & buffer_[ result ];
	new(placement) Pair(std::forward<UPAIR>(newdata));

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xacd4
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
movq 0x18(%r14), %rdx
movq $0x5, (%rsp)
leaq 0x17(%rsp), %r8
leaq 0x18(%rsp), %r9
movq %r14, %rdi
xorl %esi, %esi
callq 0x9cc4
testb %al, %al
je 0x9b36
movq 0x8(%r14), %r15
movq 0x18(%rsp), %r12
movq %rbx, %rdi
xorl %esi, %esi
callq 0xadd8
movl %eax, %ebp
testb %al, %al
je 0x9ba3
leaq (%r15,%r12,8), %r15
movq 0x20(%r14), %r12
movq %r15, %rdi
callq 0xadec
subq %rax, %r12
movq %rbx, %rdi
callq 0xadec
addq %r12, %rax
movq %rax, 0x20(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xac48
jmp 0x9ba3
movq 0x18(%rsp), %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0x99de
testb %al, %al
je 0x9ba1
movl %eax, %ebp
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x9b76
movq %r15, %rdx
notq %rdx
addq 0x18(%r14), %rdx
leaq (%rax,%r15,8), %rsi
leaq (%rax,%r15,8), %rdi
addq $0x8, %rdi
shlq $0x3, %rdx
callq 0x2200
testb %bpl, %bpl
je 0x9ba1
movq %rbx, %rdi
callq 0xadec
addq %rax, 0x20(%r14)
movq 0x18(%rsp), %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xac3a
movb $0x1, %bpl
jmp 0x9ba3
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/linklist.cc
// Function: hm3::LinkList::removeAll()
bool LinkList::removeAll(){
	for(Node *node = head_; node; ){
		Node *copy = node;

		node = node->next;

		delete copy;
	}

	clear_();

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x9e3f
movq 0x8(%r14), %r15
movq %r14, %rdi
callq 0xac20
movl $0x10, %esi
movq %r14, %rdi
callq 0x2190
movq %r15, %r14
testq %r15, %r15
jne 0x9e1e
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/linklist.cc
// Function: hm3::LinkList::locate_(StringRef const&, bool) const
const LinkList::Node *LinkList::locate_(const StringRef &key, bool const exact) const{
	for(const Node *node = head_; node; node = node->next){
		const Pair & data = node->data;

		int const cmp = data.cmp(key);

		if (cmp == 0)
			return node;

		if (cmp > 0)
			return exact ? nullptr : node;
			//break;
	}

	return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x9eb7
movl %edx, %ebx
movq %rsi, %r14
xorl %r13d, %r13d
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0xad48
testb %bl, %bl
movq %r12, %rcx
cmovneq %r13, %rcx
testl %eax, %eax
cmovgq %rcx, %r15
cmoveq %r12, %r15
jns 0x9eba
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x9e89
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/linklist.cc
// Function: hm3::LinkList::remove(StringRef const&)
bool LinkList::remove(const StringRef &key){
	Node *prev = nullptr;
	for(Node *node = head_; node; node = node->next){
		const Pair & data = node->data;
		int const cmp = data.cmp(key);

		if (cmp == 0){
			if (prev){
				prev->next = node->next;
			}else{
				// First node...
				head_ = node->next;
			}

			dataSize_ -= data.getBytes();
			--dataCount_;

			delete node;
			return true;
		}

		if (cmp > 0)
			break;

		prev = node;
	}

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
testq %r15, %r15
je 0x9f44
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0xad48
testl %eax, %eax
je 0x9efd
setle %al
cmovleq %r15, %r12
jmp 0x9f37
leaq 0x8(%r12), %rax
testq %r12, %r12
movq 0x8(%r15), %rcx
cmoveq %r14, %rax
movq %rcx, (%rax)
movq %r15, %rdi
callq 0xadec
subq %rax, 0x10(%r14)
decq 0x8(%r14)
movq %r15, %rdi
callq 0xac20
movl $0x10, %esi
movq %r15, %rdi
callq 0x2190
xorl %eax, %eax
testb %al, %al
je 0x9f44
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x9ee1
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::locate_(StringRef const&, bool) const
auto SkipList::locate_(const StringRef &key, bool const complete_evaluation) const -> NodeLocator{
	// it is extremly dangerous to have key == nullptr here.
	if (key.empty()){
		std::logic_error exception("Key can not be nullptr in SkipList::_locate");
		throw exception;
	}

	NodeArrayC loc;

	// smart over-optimizations, such skip NULL lanes or
	// start from the middle of the list did not pay off.

	int cmp = 1;

	const Node *node = nullptr;
	const Node *prev = nullptr;

	height_type height = height_;
	while(height){
		node = prev ? prev : heads_[height - 1];

		while(node){
			const Pair & data = node->data;
			cmp = data.cmp(key);

			if (cmp >= 0)
				break;

			prev = node;
			node = node->next[height - 1];
		}


		if (complete_evaluation == false && cmp == 0)
			return { node, loc };

		loc[height - 1] = prev;

		--height;
	}

	return { cmp ? nullptr : node , loc };
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movl %ecx, 0x4(%rsp)
cmpq $0x0, (%rdx)
je 0xa3b5
movq %rdi, %rbx
movzbl (%rsi), %r13d
testq %r13, %r13
je 0xa385
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
movl $0x1, %eax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
movq %r15, %r12
testq %r15, %r15
jne 0xa323
leal (%rbx,%r13), %ecx
movq 0x10(%rsp), %rdx
movq 0x8(%rdx,%rcx,8), %r12
testq %r12, %r12
je 0xa358
leal (%rbx,%r13), %ebp
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0xad48
testl %eax, %eax
js 0xa344
movq %r12, %rcx
jmp 0xa34c
movq 0x8(%r12,%rbp,8), %rcx
movq %r12, %r15
testl %eax, %eax
jns 0xa35a
movq %rcx, %r12
testq %rcx, %rcx
jne 0xa32c
xorl %ecx, %ecx
cmpb $0x0, 0x4(%rsp)
jne 0xa365
testl %eax, %eax
je 0xa37e
leal (%rbx,%r13), %edx
movq %r15, 0x18(%rsp,%rdx,8)
decq %r13
testb %r13b, %r13b
jne 0xa30d
xorl %edx, %edx
testl %eax, %eax
cmovneq %rdx, %rcx
movq 0x8(%rsp), %rbx
jmp 0xa387
xorl %ecx, %ecx
movq %rcx, (%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
leaq 0x18(%rsp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x2140
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1efa(%rip), %rsi      # 0xc2b6
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x21d0
movl $0x10, %edi
callq 0x20a0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2110
movq 0x5c00(%rip), %rsi      # 0xffe8
movq 0x5be9(%rip), %rdx      # 0xffd8
movq %r14, %rdi
callq 0x2230
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2268
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::_getRandomHeight()
auto SkipList::_getRandomHeight() -> height_type{
	// This gives slightly better performance,
	// than divide by 3 or multply by 0.33

	// We execute rand() inside the loop,
	// but performance is fast enought.

	height_type h = 1;
	while( h < height_ && rand_() )
		h++;

	return h;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movb $0x1, %bl
cmpb $0x2, (%rdi)
jb 0xa43f
movq %rdi, %r14
leaq 0x5d36(%rip), %r15      # 0x10158
movq %r15, %rdi
callq 0xa993
movsd 0x70ae(%rip), %xmm1     # 0x114e0
ucomisd %xmm0, %xmm1
jbe 0xa43f
incb %bl
cmpb (%r14), %bl
jb 0xa422
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::SkipList(unsigned char)
SkipList::SkipList(height_type height){
	if (height == 0 || height > MAX_HEIGHT)
		height = DEFAULT_HEIGHT;

	height_ = height;

	clear_();
}

// Assembly:
leal -0x41(%rsi), %eax
cmpb $-0x40, %al
movl $0x20, %eax
cmovael %esi, %eax
movb %al, (%rdi)
addq $0x8, %rdi
movl $0x210, %edx            # imm = 0x210
xorl %esi, %esi
jmp 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::removeAll()
bool SkipList::removeAll(){
	for(const Node *node = heads_[0]; node; ){
		const Node *copy = node;

		node = node->next[0];

		delete copy;
	}

	clear_();

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
addq $0x8, %rbx
testq %r14, %r14
je 0xa508
movq 0x8(%r14), %r15
movq %r14, %rdi
callq 0xac20
movl $0x10, %esi
movq %r14, %rdi
callq 0x2190
movq %r15, %r14
testq %r15, %r15
jne 0xa4e7
movl $0x210, %edx            # imm = 0x210
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20d0
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::get(StringRef const&) const
const Pair &SkipList::get(const StringRef &key) const{
	if (key.empty())
		return Pair::zero();

	const auto nl = locate_(key);

	return nl.node ? nl.node->data : Pair::zero();
}

// Assembly:
movq %rsi, %rdx
cmpq $0x0, (%rsi)
je 0xa55b
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xa2c4
movq (%rbx), %rax
testq %rax, %rax
jne 0xa552
leaq 0x6f96(%rip), %rax      # 0x114e8
addq $0x210, %rsp            # imm = 0x210
popq %rbx
retq
leaq 0x6f86(%rip), %rax      # 0x114e8
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: hm3::SkipList::printLane(unsigned char) const
void SkipList::printLane(height_type const lane) const{
	uint64_t i = 0;
	const Node *node;
	for(node = heads_[lane]; node; node = node->next[lane]){
		const Pair & data = node->data;
		data.print();

		if (++i > 10)
			break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq 0x8(%rdi,%r14,8), %rbx
testq %rbx, %rbx
je 0xa701
movl $0xb, %r15d
movq %rbx, %rdi
callq 0xae10
decq %r15
je 0xa701
movq 0x8(%rbx,%r14,8), %rbx
testq %rbx, %rbx
jne 0xa6ea
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/skiplist.cc
// Function: bool hm3::SkipList::putT_<hm3::Pair>(hm3::Pair&&)
bool SkipList::putT_(UPAIR&& newdata){
	const StringRef &key = newdata.getKey();

	if (key.empty())
		return true;

	const auto nl = locate_(key);

	if (nl.node){
		// update in place. node MUST be not NULL...

		const Pair & olddata = nl.node->data;

		// check if the data in database is valid
		if (! newdata.valid(olddata) ){
			// newdata will be magically destroyed.
			return false;
		}

		dataSize_ = dataSize_
			- olddata.getBytes()
			+ newdata.getBytes();

		// copy assignment
		const_cast<Pair &>(olddata) = std::forward<UPAIR>(newdata);

		return true;
	}

	// create new node

	size_t const size = newdata.getBytes();
	height_type const height = _getRandomHeight();

	Node *newnode = new(height, true) Node(std::forward<UPAIR>(newdata));

	if (newnode == nullptr){
		// newdata will be magically destroyed.
		return false;
	}

	/* SEE REMARK ABOUT NEXT[] SIZE AT THE TOP */
	// newnode->height = height

	// place new node where it belongs

	for(height_type i = 0; i < height; ++i){
		if (nl.loc[i]){
			// we are at the middle
			const Node *node = nl.loc[i];

			newnode->next[i] = node->next[i];
			const_cast<Node *>(node)->next[i] = newnode;
		}else{
			newnode->next[i] = heads_[i];
			heads_[i] = newnode;
		}
	}

#ifdef DEBUG_PRINT_LANES
	printf("%3u Lanes-> ", height);
	for(height_type i = 0; i < height; ++i)
		printf("%p ", (void *) newnode->next[i]);
	printf("\n");
#endif

	/* SEE REMARK ABOUT NEXT[] SIZE AT THE TOP */
	// newnode->next[i] = NULL;

	dataSize_ += size;
	++dataCount_;

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xacd4
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
testq %rax, %rax
je 0xa844
leaq 0x10(%rsp), %r15
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xa2c4
movq (%r15), %r15
movq %r14, %rdi
testq %r15, %r15
je 0xa7ba
xorl %esi, %esi
callq 0xadd8
movl %eax, %ebp
testb %al, %al
je 0xa847
movq 0x210(%rbx), %r12
movq %r15, %rdi
callq 0xadec
subq %rax, %r12
movq %r14, %rdi
callq 0xadec
addq %r12, %rax
movq %rax, 0x210(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0xac48
jmp 0xa847
callq 0xadec
movq %rax, %r15
movq %rbx, %rdi
callq 0xa40c
movzbl %al, %r13d
leaq 0x8(,%r13,8), %rdi
movq 0x57e3(%rip), %rsi      # 0xffc0
callq 0x2250
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0xac3a
testb %r13b, %r13b
je 0xa81f
shll $0x3, %r13d
xorl %eax, %eax
movq 0x18(%rsp,%rax), %rcx
testq %rcx, %rcx
cmoveq %rbx, %rcx
movq 0x8(%rcx,%rax), %rdx
movq %rdx, 0x8(%r12,%rax)
movq %r12, 0x8(%rcx,%rax)
addq $0x8, %rax
cmpq %rax, %r13
jne 0xa7fb
movdqu 0x208(%rbx), %xmm0
movq %r15, %xmm1
movdqa 0x19fc(%rip), %xmm2     # 0xc230
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
paddq %xmm0, %xmm2
movdqu %xmm2, 0x208(%rbx)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/main/dbadapter.h
// Function: DBAdapter<hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>, hm3::tableloader::DirectoryTableLoader>::info[abi:cxx11]() const
std::string info() const{
		std::stringstream ss;

		ss	<< "Keys (estimated): "	<< list_.getCount(true)	<< '\n'
			<< "Size: "		<< list_.getBytes()	<< '\n'
		;

		return ss.str();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x31a0
leaq 0x18(%rsp), %r15
leaq 0x6471(%rip), %rsi      # 0xb1b7
movl $0x12, %edx
movq %r15, %rdi
callq 0x32d0
movq (%r14), %rax
movq (%rax), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x4d73
addq 0x8(%rax), %rsi
addq $0xe0, %rax
jmp 0x4d62
movq %r15, %rdi
callq 0x3190
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x32d0
movq %rax, %r15
leaq 0x6430(%rip), %rsi      # 0xb1ca
movl $0x6, %edx
movq %rax, %rdi
callq 0x32d0
movq (%r14), %rax
movq (%rax), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x4dc7
addq 0x58(%rax), %rsi
addq $0xe0, %rax
jmp 0x4db6
movq %r15, %rdi
callq 0x3190
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x32d0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x33c0
movq 0xb1b8(%rip), %rsi      # 0xffb0
leaq 0x8(%rsp), %rdi
callq 0x31d0
leaq 0x88(%rsp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0xb187(%rip), %rsi      # 0xffb0
leaq 0x8(%rsp), %rdi
callq 0x31d0
leaq 0x88(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/main/dbadapter.h
// Function: DBAdapter<hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>, hm3::tableloader::DirectoryTableLoader>::get[abi:cxx11](StringRef const&) const
std::string get(const StringRef &key) const{
		const auto &p = list_.get(key);
		std::string s = p.getVal();
		std::cout << s << '\n';
		return s;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x60d4
movq %r14, %rdi
callq 0x7616
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
addq %rdx, %rax
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3d54
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xb13e(%rip), %rdi      # 0xffd0
callq 0x32d0
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x32d0
leaq 0x8(%rsp), %rdi
callq 0x7540
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x4ede
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4ede
movq (%r15), %rsi
incq %rsi
callq 0x3290
leaq 0x8(%rsp), %rdi
callq 0x7540
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/lsmtable_impl.h
// Function: hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>::get(StringRef const&) const
Pair LSMTable<CONTAINER>::get(const StringRef &key) const{
	// CONTAINER is responsible for ordering the tables,
	// in correct (probably reverse) order.
	for(const auto &table : container_ ){
		if (Pair pair = table.get(key))
			return pair;
	}

	return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
sete %bpl
je 0x613e
movq %rdx, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x88ec
cmpq $0x0, (%rbx)
jne 0x6139
addq $0xe0, %r15
movq %rbx, %rdi
callq 0x7540
cmpq %r12, %r15
sete %bpl
je 0x613e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x88ec
addq $0xe0, %r15
cmpq $0x0, (%rbx)
je 0x610d
testb %bpl, %bpl
je 0x6148
movq %rbx, %rdi
xorl %esi, %esi
callq 0x75b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/tableloader/directorytableloader.cc
// Function: hm3::tableloader::DirectoryTableLoader::refresh()
bool DirectoryTableLoader::refresh(){
	container_.clear();

	MyGlob gl;
	if (gl.open(path_) == false)
		return true;

	const auto &files = gl.getData();

	container_.reserve(files.size());

	// order in the iterator, does not matter
	// but order in get, still very important
	auto it_rend = files.rend();
	for (auto it = files.rbegin(); it != it_rend; ++it){
		const auto &filename = *it;

                DiskTable dt;
                dt.open(filename);
                container_.push_back( std::move(dt) );
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdi, %rbx
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
cmpq %r15, %r12
je 0x6b7c
movq %r15, %r14
movq %r14, %rdi
callq 0x3df0
addq $0xe0, %r14
cmpq %r12, %r14
jne 0x6b64
movq %r15, 0x28(%rbx)
movq %rsp, %rdi
movb $0x0, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movq $0x0, 0x60(%rdi)
movq 0x8(%rbx), %rax
leaq 0x68(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
movq %rax, 0x8(%rsi)
callq 0x72bc
testb %al, %al
je 0x6c8d
addq $0x20, %rbx
movq 0x58(%rsp), %rsi
subq 0x50(%rsp), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0x6ccc
movq 0x50(%rsp), %r12
movq 0x58(%rsp), %r14
cmpq %r12, %r14
je 0x6c8d
leaq 0x70(%rsp), %r13
xorl %ebp, %ebp
leaq 0x68(%rsp), %r15
addq $-0x10, %r14
movb %bpl, 0x68(%rsp)
movb %bpl, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movups %xmm0, 0x28(%r13)
movups %xmm0, 0x18(%r13)
movq $0x0, 0x38(%r13)
movl %ebp, 0x54(%r13)
movups %xmm0, 0x44(%r13)
movl $0x1, 0xcc(%rsp)
movups %xmm0, 0x60(%r13)
movl %ebp, 0xfc(%rsp)
movl %ebp, 0x84(%r13)
movups %xmm0, 0x74(%r13)
movb $0x1, 0x100(%rsp)
movups %xmm0, 0xc8(%r13)
movups %xmm0, 0xb8(%r13)
movups %xmm0, 0xa8(%r13)
movups %xmm0, 0x98(%r13)
movq %r15, %rdi
movq %r14, %rsi
callq 0x7d1c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6fb6
movq %r15, %rdi
callq 0x3df0
cmpq %r12, %r14
jne 0x6beb
movq %rsp, %rdi
callq 0x6d96
movb $0x1, %al
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6cbb
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3df0
movq %rsp, %rdi
callq 0x6d96
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]floppytools/kryoflux4.cpp
// Function: main
int main(int argc,char **argv) {
    struct flux_bits fb;
    struct kryoflux_event ev;

    if (argc < 2) {
        fprintf(stderr,"%s <raw>\n",argv[0]);
        return 1;
    }

    FILE *fp = fopen(argv[1],"rb");
    if (fp == NULL) return 1;

    if (!autodetect_flux_bits_mfm(fb,ev,fp)) {
        fprintf(stderr,"Autodetect failure\n");
        return 1;
    }

    /* TODO: autodetection is possible (for MFM at least).
     *       look at the histogram code in kryoflux2.cpp */

    /* from my tests:
     *
     * distance of 10101010101010 = 49
     * change in distance to encode 1001001001001001 = 23.
     *
     * shortest is therefore 49 - 23 = 26 which is the distance to encode 111111111111 */

    fb.clear();

    do {
        kryoflux_bits_refill(fb,ev,fp);

        unsigned int c = fb.avail();
        for (unsigned int i=0;i < c;i++) printf("%u",fb.get(1));

        kryoflux_bits_refill(fb,ev,fp);
    } while (fb.avail() > 0);

    fclose(fp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movups %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x1, %edi
jle 0x1487
movq 0x8(%rsi), %rdi
leaq 0x1c4e(%rip), %rsi      # 0x300e
callq 0x1110
movl $0x1, %r14d
testq %rax, %rax
je 0x1467
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x177c
testb %al, %al
je 0x1497
leaq -0x38(%rbp), %rdi
callq 0x1720
leaq -0x38(%rbp), %r14
leaq -0x60(%rbp), %r15
leaq 0x1c1e(%rip), %r12      # 0x3025
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x164e
movq %r14, %rdi
callq 0x16d4
movl %eax, %r13d
testl %eax, %eax
je 0x1442
movq %r14, %rdi
movl $0x1, %esi
callq 0x1754
movq %r12, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1040
decl %r13d
jne 0x1424
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x164e
movq %r14, %rdi
callq 0x16d4
testl %eax, %eax
jne 0x1407
movq %rbx, %rdi
callq 0x10e0
xorl %r14d, %r14d
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x1475
callq 0x10d0
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rdi
callq 0x11e2
movl $0x1, %r14d
jmp 0x1467
callq 0x11c0
jmp 0x1467
jmp 0x14a4
jmp 0x14a4
jmp 0x14a4
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x14b5
callq 0x10d0
movq %rbx, %rdi
callq 0x1170
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/PrzemekWirkus[P]functional-workshop/src/utest.h
// Function: bool CHECK_EQUAL<int, int>(char const*, int, int)
bool CHECK_EQUAL<int, int>(const char *str, int t1, int t2) {
    using namespace std;

    bool result = t1 == t2;
    if (__NOT result) {
        cout << endl << __FILE__ << ": Value mismatch: " << t1 << " != " << t2 << endl;
    }
    cout << str << "\t" << (result ? "OK" : "FAIL") << endl;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpl %edx, %esi
jne 0x13fa
leaq 0xc35(%rip), %r15       # 0x202a
jmp 0x14af
movq 0x2bd7(%rip), %r15      # 0x3fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq %rax, %r15
leaq 0xbd2(%rip), %rsi       # 0x2004
movl $0xb, %edx
movq %rax, %rdi
callq 0x10f0
leaq 0xbca(%rip), %rsi       # 0x2010
movl $0x12, %edx
movq %r15, %rdi
callq 0x10f0
movq %r15, %rdi
movl %ebp, %esi
callq 0x1130
movq %rax, %r15
leaq 0xbbc(%rip), %rsi       # 0x2023
movl $0x4, %edx
movq %rax, %rdi
callq 0x10f0
movq %r15, %rdi
movl %ebx, %esi
callq 0x1130
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0xb7e(%rip), %r15       # 0x202d
testq %r14, %r14
je 0x14d0
movq %r14, %rdi
callq 0x1050
movq 0x2b15(%rip), %rdi      # 0x3fd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x10f0
jmp 0x14ee
movq 0x2b01(%rip), %rax      # 0x3fd8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x1120
cmpl %ebx, %ebp
sete %bl
movq 0x2ade(%rip), %r14      # 0x3fd8
leaq 0xb27(%rip), %rsi       # 0x2028
movl $0x1, %edx
movq %r14, %rdi
callq 0x10f0
movq %r15, %rdi
callq 0x1050
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x10f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: HasPtr::~HasPtr()
HasPtr::~HasPtr()
{
	std::cout << "deconstructor." << std::endl;
	if (--*use == 0) {   // if the reference count goes to 0
		std::cout << "delete memory." << std::endl;
		delete ps;       // delete the string
		delete use;      // and the counter
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2d7b(%rip), %r14      # 0x3fd8
leaq 0xda0(%rip), %rsi       # 0x2004
movl $0xe, %edx
movq %r14, %rdi
callq 0x10d0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq 0x2d49(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq 0x10(%rbx), %rax
decq (%rax)
je 0x12aa
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2d27(%rip), %r14      # 0x3fd8
leaq 0xd5b(%rip), %rsi       # 0x2013
movl $0xe, %edx
movq %r14, %rdi
callq 0x10d0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq 0x2cf5(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq (%rbx), %r14
testq %r14, %r14
je 0x131c
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x130f
movq (%rax), %rsi
incq %rsi
callq 0x10c0
movl $0x20, %esi
movq %r14, %rdi
callq 0x10c0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x12a5
movl $0x8, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x10c0
movq %rax, %rdi
callq 0x1628
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: HasPtr::operator=(HasPtr&&)
HasPtr& HasPtr::operator=(HasPtr&& rhs)
{
	std::cout << "move assign." << std::endl;
	if (this != &rhs) {
		if (--*use == 0) {   // do the work of the destructor
			delete ps;
			delete use;
		}
		ps = rhs.ps;         // do the work of the move constructor
		i = rhs.i;
		use = rhs.use;

		rhs.ps = nullptr;
		++*rhs.use;
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2c85(%rip), %r15      # 0x3fd8
leaq 0xcc8(%rip), %rsi       # 0x2022
movl $0xc, %edx
movq %r15, %rdi
callq 0x10d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
cmpq %r14, %rbx
je 0x13fe
movq 0x10(%rbx), %rax
decq (%rax)
jne 0x13db
movq (%rbx), %r15
testq %r15, %r15
je 0x13c8
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x13bb
movq (%rax), %rsi
incq %rsi
callq 0x10c0
movl $0x20, %esi
movq %r15, %rdi
callq 0x10c0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x13db
movl $0x8, %esi
callq 0x10c0
movq (%r14), %rax
movq %rax, (%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq $0x0, (%r14)
movq 0x10(%r14), %rax
incq (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: HasPtr::operator=(HasPtr const&)
HasPtr& HasPtr::operator=(const HasPtr& rhs)
{
	std::cout << "copy assign." << std::endl;
	++*rhs.use;  // increment the use count of the right-hand operand
	if (--*use == 0) {   // then decrement this object's counter
		delete ps;       // if no other users
		delete use;      // free this object's allocated members
	}
	ps = rhs.ps;         // copy data from rhs into this object
	i = rhs.i;
	use = rhs.use;
	return *this;        // return this object
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2bb5(%rip), %r15      # 0x3fd8
leaq 0xc05(%rip), %rsi       # 0x202f
movl $0xc, %edx
movq %r15, %rdi
callq 0x10d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq 0x10(%r14), %rax
incq (%rax)
movq 0x10(%rbx), %rax
decq (%rax)
jne 0x14ad
movq (%rbx), %r15
testq %r15, %r15
je 0x149a
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x148d
movq (%rax), %rsi
incq %rsi
callq 0x10c0
movl $0x20, %esi
movq %r15, %rdi
callq 0x10c0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x14ad
movl $0x8, %esi
callq 0x10c0
movq (%r14), %rax
movq %rax, (%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: f(HasPtr)
HasPtr f(HasPtr hp) // HasPtr passed by value, so it is copied
{
	HasPtr ret;
	ret = hp;        // assignment copies the given HasPtr
	// proces ret
	return ret;      // ret and hp are destroyed
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x38(%rbp), %rsi
callq 0x1636
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1515
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x10c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x140c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x124c
jmp 0x1553
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1553
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x10c0
movq %r14, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: main
int main()
{
	HasPtr h("hi mom!");

	// no new memory is allocated,
	// h and h2 share the same underlying string
	HasPtr h2 = h;

	HasPtr h3 = std::move(h2);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xac7(%rip), %rsi       # 0x203c
leaq 0xac7(%rip), %rdx       # 0x2043
leaq -0x30(%rbp), %rdi
callq 0x186a
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1636
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x15a7
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x10c0
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x16f0
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x175c
leaq -0x60(%rbp), %rdi
callq 0x124c
leaq -0x30(%rbp), %rdi
callq 0x124c
leaq -0x48(%rbp), %rdi
callq 0x124c
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x124c
jmp 0x15f8
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x124c
jmp 0x1620
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1620
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x10c0
jmp 0x1620
movq %rax, %rbx
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH06_Functions/examples/fact.cc
// Function: main
int main()
{
	cout << factorial(5) << endl;
	cout << fact(5) << endl;
	cout << factorial(0) << endl;
	cout << fact(0) << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl $0x5, %edi
callq 0x1310
movq 0x2df4(%rip), %rbx      # 0x3fd8
movq %rbx, %rdi
movl %eax, %esi
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movl $0x5, %edi
callq 0x12f3
movq %rbx, %rdi
movl %eax, %esi
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %edi, %edi
callq 0x1310
movq %rbx, %rdi
movl %eax, %esi
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %edi, %edi
callq 0x12f3
movq %rbx, %rdi
movl %eax, %esi
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH06_Functions/examples/LocalMath.cc
// Function: gcd(int, int)
int gcd(int v1, int v2)
{
    while (v2) {
        int temp = v2;
        v2 = v1 % v2;
        v1 = temp;
    }
    return v1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
testl %esi, %esi
je 0x12ed
movl %esi, %edx
movl %edx, %ecx
cltd
idivl %ecx
movl %ecx, %eax
testl %edx, %edx
jne 0x12e0
jmp 0x12ef
movl %eax, %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH06_Functions/examples/LocalMath.cc
// Function: fact(int)
int fact(int val)
{
	int ret = 1; // local variable to hold the result as we calculate it
	while (val > 1) 
		ret *= val--;  // assign ret * val to ret and decrement val
	return ret;        // return the result
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
cmpl $0x2, %edi
jl 0x130e
imull %edi, %eax
leal -0x1(%rdi), %ecx
cmpl $0x2, %edi
movl %ecx, %edi
jg 0x1301
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH04_Expressions/examples/unaryOps.cc
// Function: main
int main()
{
	int i = 1024;
	int k = -i; // i is -1024
	
	bool b = true;
	bool b2 = -b; // b2 is true!
	
	cout << b << " " << b2 << " " << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2dee(%rip), %rdi      # 0x3fd8
movl $0x1, %esi
callq 0x1090
movq %rax, %rbx
leaq 0xe06(%rip), %r14       # 0x2004
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1070
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1090
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1070
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eschwabe[P]interview-practice/src/convert.cpp
// Function: IntToString[abi:cxx11](int const&)
string IntToString(const int& value) {

    string str;
    int tmp = value;
    bool negate_flag = false;

    if(tmp < 0) {
        negate_flag = true;
        tmp = -tmp;
    }

    if(tmp == 0) {
        str.insert(0, 1, '0');
    } else {
        while(tmp > 0) {
            char c = (tmp % 10) + '0';
            str.insert(0, 1, c);
            tmp /= 10;
        }
    }

    if(negate_flag) {
        str.insert(0, 1, '-');
    }

    return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl (%rsi), %ebp
testl %ebp, %ebp
je 0x12db
movl %ebp, %r14d
negl %r14d
cmovsl %ebp, %r14d
movl $0xcccccccd, %r12d      # imm = 0xCCCCCCCD
movl %r14d, %r13d
imulq %r12, %r13
shrq $0x23, %r13
leal (,%r13,2), %eax
leal (%rax,%rax,4), %eax
movl %r14d, %ecx
subl %eax, %ecx
orb $0x30, %cl
movzbl %cl, %ecx
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10f0
cmpl $0xa, %r14d
movl %r13d, %r14d
jae 0x12a0
jmp 0x12ef
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x30, %ecx
callq 0x10f0
testl %ebp, %ebp
jns 0x1307
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2d, %ecx
callq 0x10f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x131b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1331
movq (%r15), %rsi
incq %rsi
callq 0x1090
movq %r14, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O1/mlugo2[P]SunshineGPU/inc/stringproc.h
// Function: tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void tokenize(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters )
{
	// Skip delimiters at beginning.
    std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    std::string::size_type pos     = str.find_first_of(delimiters, lastPos);

    while (std::string::npos != pos || std::string::npos != lastPos)
    {
        // Found a token, add it to the vector.
        tokens.push_back(str.substr(lastPos, pos - lastPos));
        // Skip delimiters.  Note the "not_of"
        lastPos = str.find_first_not_of(delimiters, pos);
        // Find next "non-delimiter"
        pos = str.find_first_of(delimiters, lastPos);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %edx, %edx
callq 0x2360
movq %rax, %rbp
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r15, %rdi
movq %rax, %rdx
callq 0x2320
movq %rax, %r13
movq %rbp, %rax
andq %r13, %rax
cmpq $-0x1, %rax
je 0x266b
leaq 0x8(%rsp), %r12
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x2280
movq %r14, %rdi
movq %r12, %rsi
callq 0x4250
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2635
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2270
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r15, %rdi
movq %r13, %rdx
callq 0x2360
movq %rax, %rbp
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r15, %rdi
movq %rax, %rdx
callq 0x2320
movq %rax, %r13
movq %rbp, %rax
andq %r13, %rax
cmpq $-0x1, %rax
jne 0x25fa
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2699
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2270
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/mlugo2[P]SunshineGPU/inc/screen.h
// Function: init_screen()
bool init_screen() {

	// Initialization flag
	bool success = true;

	// Initialize SDL
	if (SDL_Init( SDL_INIT_VIDEO) < 0) {
		printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
		success = false;
	}
	else {

		//Set texture filtering to linear
		if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
		{
			printf( "Warning: Linear texture filtering not enabled!" );
		}

		// Create window
		gWindow = SDL_CreateWindow("GPU", SDL_WINDOWPOS_UNDEFINED,
			SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );

		if (gWindow == NULL) {
			printf("Window could not created! SDL_Error: %s\n", SDL_GetError());
			success = false;
		}
		else {

			// Create renderer for window
			gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED);
			if ( gRenderer == NULL ) {
				printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
				success = false;
			}
			else {
				// Initialize renderer color
				SDL_SetRenderDrawColor( gRenderer, 0x00, 0x00, 0x00, 0x00);
			}
		}
	}

	return success;
}

// Assembly:
pushq %rbx
movl $0x20, %edi
callq 0x2210
testl %eax, %eax
js 0x3692
leaq 0x5a6d(%rip), %rdi      # 0x907b
leaq 0x5a7f(%rip), %rsi      # 0x9094
callq 0x2380
testl %eax, %eax
jne 0x362c
leaq 0x5a71(%rip), %rdi      # 0x9096
xorl %eax, %eax
callq 0x2070
leaq 0x5a92(%rip), %rdi      # 0x90c5
movl $0x1fff0000, %esi       # imm = 0x1FFF0000
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
movl $0x320, %ecx            # imm = 0x320
movl $0x280, %r8d            # imm = 0x280
movl $0x4, %r9d
callq 0x2080
movq %rax, 0x8bbe(%rip)      # 0xc218
testq %rax, %rax
je 0x36a0
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
callq 0x2050
movq %rax, 0x8bb0(%rip)      # 0xc228
testq %rax, %rax
je 0x36ae
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x22f0
movb $0x1, %bl
jmp 0x36c6
callq 0x21c0
leaq 0x59b4(%rip), %rdi      # 0x9052
jmp 0x36ba
callq 0x21c0
leaq 0x5a1d(%rip), %rdi      # 0x90c9
jmp 0x36ba
callq 0x21c0
leaq 0x5a38(%rip), %rdi      # 0x90f2
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x2070
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mlugo2[P]SunshineGPU/inc/screen.h
// Function: thread_screen(unsigned char (*) [800][3])
void thread_screen( unsigned char FB[][SCREEN_WIDTH][3])
{
	// Event handler
	SDL_Event e;

	// Accessing each byte in vram
	int x, y;

	// Start up SDL and create window
	if ( !init_screen() ) {
		std::cout << "Failed to Initialize!\n";
	}
	else {
		// While application is running
		while( !m_quit ) {

			// Handle events on queue
			while( SDL_PollEvent(&e) != 0) {
				// User requests quit
				if ( e.type == SDL_QUIT ) { m_quit = true; }
			}

			// Clear screen
			SDL_SetRenderDrawColor( gRenderer, 0x00, 0x00, 0x00, 0x00);
			SDL_RenderClear( gRenderer );

			// Render to screen given frame buffer
			for (y = 0; y < SCREEN_HEIGHT; y++) {
				for (x = 0; x < SCREEN_WIDTH; x++) {

					// Render pixel
					SDL_Rect pixel = { x, y, 1, 1};

					// Draw to the screen
					SDL_SetRenderDrawColor( gRenderer, 
							FB[y][x][0], 
							FB[y][x][1], 
							FB[y][x][2], 
							255
						);
					SDL_RenderFillRect( gRenderer, &pixel );
				}
			}

			// Update screen
			SDL_RenderPresent( gRenderer );
		}

		// Free resources and close SDL
		close_sdl();
		
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
callq 0x35f4
testb %al, %al
je 0x3810
cmpb $0x0, 0x8b01(%rip)      # 0xc211
jne 0x37fc
addq $0x2, 0x8(%rsp)
leaq 0x20(%rsp), %rbx
movabsq $0x100000001, %r12      # imm = 0x100000001
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x374f
cmpl $0x100, 0x20(%rsp)      # imm = 0x100
jne 0x3730
movb $0x1, 0x8ac4(%rip)      # 0xc211
jmp 0x3730
movq 0x8ad2(%rip), %rdi      # 0xc228
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x22f0
movq 0x8abd(%rip), %rdi      # 0xc228
callq 0x2240
movq 0x8(%rsp), %rbx
xorl %ebp, %ebp
movq %rbx, %r13
xorl %r14d, %r14d
movl %r14d, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
movq %r12, 0x18(%rsp)
movq 0x8a96(%rip), %rdi      # 0xc228
movzbl -0x2(%r13), %esi
movzbl -0x1(%r13), %edx
movzbl (%r13), %ecx
movl $0xff, %r8d
callq 0x22f0
movq 0x8a75(%rip), %rdi      # 0xc228
movq %r15, %rsi
callq 0x2130
incq %r14
addq $0x3, %r13
cmpq $0x320, %r14            # imm = 0x320
jne 0x377d
incq %rbp
addq $0x960, %rbx            # imm = 0x960
cmpq $0x280, %rbp            # imm = 0x280
jne 0x3777
movq 0x8a43(%rip), %rdi      # 0xc228
callq 0x20a0
cmpb $0x1, 0x8a20(%rip)      # 0xc211
leaq 0x20(%rsp), %rbx
jne 0x3730
callq 0x36ca
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x87c1(%rip), %rdi      # 0xbfd8
leaq 0x5902(%rip), %rsi      # 0x9120
movl $0x16, %edx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::load_const_mem(std::vector<float, std::allocator<float>>)
void gpu::load_const_mem(vector<float> constants)
{
	// Load this baby up.
	int index = 0;
	for ( int i = 0; i < constants.size(); i += 4 )
	{
		main_mem[CONST_REG][index].x = constants[i];
		main_mem[CONST_REG][index].y = constants[i+1];
		main_mem[CONST_REG][index].z = constants[i+2];
		main_mem[CONST_REG][index].w = constants[i+3];
		index++;
	}
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
subq %rax, %rdx
je 0x5157
sarq $0x2, %rdx
cmpq $0x5, %rdx
movl $0x4, %ecx
cmovaeq %rdx, %rcx
decq %rcx
shrq $0x2, %rcx
incq %rcx
xorl %edx, %edx
movss (%rax,%rdx), %xmm0
movss %xmm0, 0x7d8cc(%rdi,%rdx)
movss 0x4(%rax,%rdx), %xmm0
movss %xmm0, 0x7d8c8(%rdi,%rdx)
movss 0x8(%rax,%rdx), %xmm0
movss %xmm0, 0x7d8c4(%rdi,%rdx)
movss 0xc(%rax,%rdx), %xmm0
movss %xmm0, 0x7d8c0(%rdi,%rdx)
addq $0x10, %rdx
decq %rcx
jne 0x5113
retq