LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: BenLangmead[P]bowtie/./qual.h
// Function: intToPhred33(int, bool)
inline static char intToPhred33(int iQ, bool solQuals) {
	int pQ;
	if (solQuals) {
		// Convert from solexa quality to phred
		// quality and translate to ASCII
		// http://maq.sourceforge.net/qual.shtml
		pQ = solexaToPhred((int)iQ) + 33;
	} else {
		// Keep the phred quality and translate
		// to ASCII
		pQ = (iQ <= 93 ? iQ : 93) + 33;
	}
	if (pQ < 33) {
		cerr << "Saw negative Phred quality " << ((int)pQ-33) << "." << endl;
		throw 1;
	}
	assert_geq(pQ, 0);
	return (int)pQ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
testb $0x1, -0x5(%rbp)
je 0x81a5c
movl -0x4(%rbp), %edi
callq 0x827b0
movzbl %al, %eax
addl $0x21, %eax
movl %eax, -0xc(%rbp)
jmp 0x81a7d
cmpl $0x5d, -0x4(%rbp)
jg 0x81a6a
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x81a74
movl $0x5d, %eax
movl %eax, -0x10(%rbp)
jmp 0x81a74
movl -0x10(%rbp), %eax
addl $0x21, %eax
movl %eax, -0xc(%rbp)
cmpl $0x21, -0xc(%rbp)
jge 0x81ae5
movq 0x26566(%rip), %rdi     # 0xa7ff0
leaq 0xcc91(%rip), %rsi      # 0x8e722
callq 0xa5d0
movq %rax, %rdi
movl -0xc(%rbp), %esi
subl $0x21, %esi
callq 0xab40
movq %rax, %rdi
leaq 0xbe51(%rip), %rsi      # 0x8d8ff
callq 0xa5d0
movq %rax, %rdi
movq 0x264ab(%rip), %rsi     # 0xa7f68
callq 0xa640
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x26474(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/pat.cpp
// Function: tooManySeqChars(SStringExpandable<char, 25, 2, 0> const&)
void tooManySeqChars(const BTString& read_name) {
	cerr << "Reads file contained a pattern with more than 1024 sequence characters." << endl
		 << "Please truncate reads and quality values and and re-run Bowtie." << endl
		 << "Offending read: " << read_name << endl;
	throw 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x258cd(%rip), %rdi     # 0xa7ff0
leaq 0xbdf1(%rip), %rsi      # 0x8e51b
callq 0xa5d0
movq %rax, %rdi
movq 0x2582f(%rip), %rsi     # 0xa7f68
callq 0xa640
movq %rax, %rdi
leaq 0xbe1b(%rip), %rsi      # 0x8e563
callq 0xa5d0
movq %rax, %rdi
movq 0x25811(%rip), %rsi     # 0xa7f68
callq 0xa640
movq %rax, %rdi
leaq 0xbe3d(%rip), %rsi      # 0x8e5a3
callq 0xa5d0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2c0d0
movq %rax, %rdi
movq 0x257e7(%rip), %rsi     # 0xa7f68
callq 0xa640
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x257b0(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
nopl (%rax)
// File: BenLangmead[P]bowtie/./read.h
// Function: Read::fixMateName(int)
void fixMateName(int i) {
		assert(i == 1 || i == 2);
		size_t namelen = name.length();
		bool append = false;
		if(namelen < 2) {
			// Name is too short to possibly have /1 or /2 on the end
			append = true;
		} else {
			if(i == 1) {
				// append = true iff mate name does not already end in /1
				append =
					name[namelen-2] != '/' ||
					name[namelen-1] != '1';
			} else {
				// append = true iff mate name does not already end in /2
				append =
					name[namelen-2] != '/' ||
					name[namelen-1] != '2';
			}
		}
		if(append) {
			name.append('/');
			name.append("012"[i]);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x150, %rdi            # imm = 0x150
callq 0x2ef90
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
cmpq $0x2, -0x18(%rbp)
jae 0x828ab
movb $0x1, -0x19(%rbp)
jmp 0x82957
cmpl $0x1, -0xc(%rbp)
jne 0x82904
movq -0x28(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
movq -0x18(%rbp), %rsi
subq $0x2, %rsi
callq 0x46bf0
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2f, %ecx
movb %al, -0x29(%rbp)
jne 0x828fa
movq -0x28(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x46bf0
movsbl (%rax), %eax
cmpl $0x31, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x82955
movq -0x28(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
movq -0x18(%rbp), %rsi
subq $0x2, %rsi
callq 0x46bf0
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2f, %ecx
movb %al, -0x2a(%rbp)
jne 0x8294d
movq -0x28(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x46bf0
movsbl (%rax), %eax
cmpl $0x32, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x82957
testb $0x1, -0x19(%rbp)
je 0x82993
movq -0x28(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
movb $0x2f, -0x1a(%rbp)
leaq -0x1a(%rbp), %rsi
callq 0x82ff0
movq -0x28(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
movslq -0xc(%rbp), %rax
leaq 0xbc29(%rip), %rsi      # 0x8e5b4
addq %rax, %rsi
callq 0x82ff0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./pat.h
// Function: PatternSourcePerThread::nextBatch()
std::pair<bool, int> nextBatch() {
		buf_.reset();
		std::pair<bool, int> res = composer_.nextBatch(buf_);
		buf_.init();
		batch_id_ = (size_t)(buf_.rdid()/buf_.max_buf_);
		return res;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x34a90
movq -0x18(%rbp), %rsi
movq (%rsi), %rdi
addq $0x8, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
movq %rax, -0x8(%rbp)
addq $0x8, %rdi
callq 0x83da0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x49a20
movq -0x18(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./pat.h
// Function: CFilePatternSource::is_gzipped_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool is_gzipped_file(const std::string& filename) {
		struct stat s;
		if (stat(filename.c_str(), &s) != 0) {
			perror("stat");
		}
		else {
			if (S_ISFIFO(s.st_mode))
				return true;
		}
		size_t pos = filename.find_last_of(".");
		std::string ext = (pos == std::string::npos) ? "" : filename.substr(pos + 1);
		if (ext == "" || ext == "gz" || ext == "Z") {
			return true;
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa210
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0xab20
cmpl $0x0, %eax
je 0x82c3e
leaq 0x6c5d(%rip), %rdi      # 0x89894
callq 0xa4e0
jmp 0x82c5b
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x82c59
movb $0x1, -0x1(%rbp)
jmp 0x82deb
jmp 0x82c5b
movq -0x18(%rbp), %rdi
leaq 0xac99(%rip), %rsi      # 0x8d8ff
movq $-0x1, %rdx
callq 0xa590
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movb $0x0, -0xd2(%rbp)
cmpq $-0x1, %rax
jne 0x82cc5
leaq -0xd1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xab70
movq -0xf0(%rbp), %rdx
movb $0x1, -0xd2(%rbp)
leaq 0xbbe6(%rip), %rsi      # 0x8e89b
leaq -0xd0(%rbp), %rdi
callq 0x24c10
jmp 0x82cc3
jmp 0x82cea
movq -0x18(%rbp), %rsi
movq -0xb0(%rbp), %rdx
incq %rdx
leaq -0xd0(%rbp), %rdi
movq $-0x1, %rcx
callq 0xa620
jmp 0x82ce8
jmp 0x82cea
testb $0x1, -0xd2(%rbp)
jne 0x82cf5
jmp 0x82d01
leaq -0xd1(%rbp), %rdi
callq 0xa670
leaq 0xbb93(%rip), %rsi      # 0x8e89b
leaq -0xd0(%rbp), %rdi
callq 0x28440
movb %al, -0xf1(%rbp)
jmp 0x82d1c
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x82d76
jmp 0x82d28
leaq 0xb889(%rip), %rsi      # 0x8e5b8
leaq -0xd0(%rbp), %rdi
callq 0x28440
movb %al, -0xf2(%rbp)
jmp 0x82d43
movb -0xf2(%rbp), %al
testb $0x1, %al
jne 0x82d76
jmp 0x82d4f
leaq 0xb865(%rip), %rsi      # 0x8e5bb
leaq -0xd0(%rbp), %rdi
callq 0x28440
movb %al, -0xf3(%rbp)
jmp 0x82d6a
movb -0xf3(%rbp), %al
testb $0x1, %al
jne 0x82d76
jmp 0x82dd1
movb $0x1, -0x1(%rbp)
movl $0x1, -0xe8(%rbp)
jmp 0x82ddf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
testb $0x1, -0xd2(%rbp)
jne 0x82da3
jmp 0x82daf
leaq -0xd1(%rbp), %rdi
callq 0xa670
jmp 0x82df9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0xacd8
jmp 0x82df9
movb $0x0, -0x1(%rbp)
movl $0x1, -0xe8(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0xacd8
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xe0(%rbp), %rdi
callq 0xab60
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./util.h
// Function: char* itoa10<int>(int const&, char*)
char* itoa10(const T& value, char* result) {
	// Check that base is valid
	char* out = result;
	T quotient = value;
	if(std::numeric_limits<T>::is_signed) {
		if(quotient <= 0) quotient = -quotient;
	}
	// Now write each digit from most to least significant
	do {
		*out = "0123456789"[quotient % 10];
		++out;
		quotient /= 10;
	} while (quotient > 0);
	// Only apply negative sign for base 10
	if(std::numeric_limits<T>::is_signed) {
		// Avoid compiler warning in cases where T is unsigned
		if (value < 0) *out++ = '-';
	}
	std::reverse( result, out );
	*out = 0; // terminator
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x8670f
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x86711
movl -0x1c(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x801c(%rip), %rax      # 0x8e742
movb (%rax,%rcx), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x86711
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x8676a
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x2d, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x83e80
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SDnaStringExpandable<25, 2>::append(char const&)
void append(const char& c) {
		if(this->sz_ < this->len_ + 1) {
			this->expandCopy((this->len_ + 1 + S) * M);
		}
		assert_range(0, 4, (int)c);
		this->cs_[this->len_++] = c;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x28(%rcx), %rax
movq 0x20(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x830a1
movq -0x18(%rbp), %rdi
movq 0x20(%rdi), %rsi
addq $0x1, %rsi
addq $0x19, %rsi
shlq %rsi
callq 0x35620
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movb (%rax), %dl
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x20(%rsi)
movb %dl, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SStringExpandable<char, 25, 2, 0>::trimEnd(unsigned long)
size_t trimEnd(size_t len) {
		if(len >= len_) {
			size_t ret = len_;
			len_ = 0;
			return ret;
		}
		len_ -= len;
		return len;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x20(%rcx), %rax
jb 0x8310c
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x83127
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./pat.h
// Function: CFilePatternSource::reset()
virtual void reset() {
		TrimmingPatternSource::reset();
		filecur_ = 0,
		open();
		filecur_++;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c010
movq -0x10(%rbp), %rdi
movq $0x0, 0x80(%rdi)
callq 0x7f0e0
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x80(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./pat.h
// Function: FastaContinuousPatternSource::resetForNextFile()
virtual void resetForNextFile() {
		eat_ = length_-1;
		name_prefix_buf_.clear();
		beginning_ = true;
		bufCur_ = 0;
		last_ = cur_;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq 0x200a8(%rdi), %rax
subq $0x1, %rax
movq %rax, 0x200b8(%rdi)
addq $0x204c8, %rdi          # imm = 0x204C8
callq 0xa7e0
movq -0x10(%rbp), %rax
movb $0x1, 0x200c0(%rax)
movq $0x0, 0x20500(%rax)
movq 0x20508(%rax), %rcx
movq %rcx, 0x20510(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./pat.h
// Function: DualPatternComposer::reset()
virtual void reset() {
		for(size_t i = 0; i < srca_.size(); i++) {
			srca_[i]->reset();
			if(srcb_[i] != NULL) {
				srcb_[i]->reset();
			}
		}
		cur_ = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0x29fa0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x83ba8
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x29fc0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x29fc0
cmpq $0x0, (%rax)
je 0x83b98
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x29fc0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x83b9a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x83b2c
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SDnaStringExpandable<25, 2>::installReverseComp(SDnaStringExpandable<25, 2> const&)
void installReverseComp(const SDnaStringExpandable<S, M>& b) {
		if(this->sz_ < b.len_) this->expandCopy((b.len_ + S) * M);
		for(size_t i = 0; i < b.len_; i++) {
			this->cs_[i] = (b.cs_[b.len_-i-1] == 4 ? 4 : b.cs_[b.len_-i-1] ^ 3);
		}
		this->len_ = b.len_;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x83c4e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0x19, %rsi
shlq %rsi
callq 0x35620
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x83cd3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x4, %eax
jne 0x83c8f
movl $0x4, %eax
movl %eax, -0x24(%rbp)
jmp 0x83cb1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
xorl $0x3, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %cl, %dl
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x83c56
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SStringExpandable<char, 25, 2, 0>::installReverse(SStringExpandable<char, 25, 2, 0> const&)
void installReverse(const SStringExpandable<T, S>& b) {
		if(sz_ < b.len_) expandNoCopy((b.len_ + S) * M);
		for(size_t i = 0; i < b.len_; i++) {
			cs_[i] = b.cs_[b.len_ - i - 1];
		}
		len_ = b.len_;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x83d2e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0x19, %rsi
shlq %rsi
callq 0x2e640
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x83d7c
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq -0x18(%rbp), %rdx
subq $0x1, %rdx
movb (%rcx,%rdx), %dl
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x83d36
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./alphabet.h
// Function: void reverseComplementInPlace<SDnaStringExpandable<25, 2>>(SDnaStringExpandable<25, 2>&)
static inline void reverseComplementInPlace(TStr& s) {
	size_t len = s.length();
	size_t i;
	for(i = 0; i < (len>>1); i++) {
		int sv = (int)s[len-i-1];
		int sf = (int)s[i];
		if(sv == 4) {
			s[i] = (char)4;
		} else {
			s[i] = (char)(sv ^ 3);
		}
		if(sf == 4)  {
			s[len-i-1] = (char)4;
		} else {
			s[len-i-1] = (char)(sf ^ 3);
		}
	}
	if((len & 1) != 0 && (int)s[len >> 1] != 4) {
		s[len >> 1] = (char)((int)s[len >> 1] ^ 3);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2ef90
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq %rcx
cmpq %rcx, %rax
jae 0x8497c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
subq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x403a0
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x403a0
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x4, -0x1c(%rbp)
jne 0x8490b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x403a0
movb $0x4, (%rax)
jmp 0x84926
movl -0x1c(%rbp), %eax
xorl $0x3, %eax
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x403a0
movb -0x21(%rbp), %cl
movb %cl, (%rax)
cmpl $0x4, -0x20(%rbp)
jne 0x84946
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
subq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x403a0
movb $0x4, (%rax)
jmp 0x84969
movl -0x20(%rbp), %eax
xorl $0x3, %eax
movb %al, -0x22(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
subq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x403a0
movb -0x22(%rbp), %cl
movb %cl, (%rax)
jmp 0x8496b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x848b1
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x849d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
shrq %rsi
callq 0x403a0
movsbl (%rax), %eax
cmpl $0x4, %eax
je 0x849d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
shrq %rsi
callq 0x403a0
movsbl (%rax), %eax
xorl $0x3, %eax
movb %al, -0x23(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
shrq %rsi
callq 0x403a0
movb -0x23(%rbp), %cl
movb %cl, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./alphabet.h
// Function: void reverseInPlace<SStringExpandable<char, 25, 2, 0>>(SStringExpandable<char, 25, 2, 0>&)
static inline void reverseInPlace(TStr& s) {
	size_t len = s.length();
	for(size_t i = 0; i < (len>>1); i++) {
		char tmp = s[i];
		s[i] = s[len-i-1];
		s[len-i-1] = tmp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2ef90
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq %rcx
cmpq %rcx, %rax
jae 0x84a7d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x46bf0
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
subq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x46bf0
movb (%rax), %al
movb %al, -0x1b(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x46bf0
movb -0x1b(%rbp), %cl
movb %cl, (%rax)
movb -0x19(%rbp), %al
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
subq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x46bf0
movb -0x1a(%rbp), %cl
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x84a01
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/hit_set.cpp
// Function: operator<<(std::ostream&, HitSet const&)
ostream& operator << (ostream& os, const HitSet& hs) {
	os << hs.name << ":" << hs.seq << ":" << hs.qual << endl;
	for (size_t i = 0; i < hs.ents.size(); i++)
		os << hs.ents[i];
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2c0d0
movq %rax, %rdi
leaq 0x573e(%rip), %rsi      # 0x8a255
callq 0xa5d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x2c0d0
movq %rax, %rdi
leaq 0x571f(%rip), %rsi      # 0x8a255
callq 0xa5d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0x2c0d0
movq %rax, %rdi
movq 0x23413(%rip), %rsi     # 0xa7f68
callq 0xa640
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
callq 0x84c70
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x84bbc
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
movq -0x18(%rbp), %rsi
callq 0x84c90
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x84a90
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x84b62
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./hit.h
// Function: printUptoWs(SStringExpandable<char, 25, 2, 0>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
inline void printUptoWs(BTString& o, const std::string& str, bool ws) {
	if(!ws) {
		o << str;
	} else {
		size_t pos = str.find_first_of(" \t");
		if(pos != string::npos) {
			o << str.substr(0, pos);
		} else {
			o << str;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x861ef
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x86560
jmp 0x8626f
movq -0x10(%rbp), %rdi
leaq 0x869f(%rip), %rsi      # 0x8e899
xorl %eax, %eax
movl %eax, %edx
callq 0xa2a0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x86260
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xa620
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x86560
jmp 0x8623e
leaq -0x40(%rbp), %rdi
callq 0xacd8
jmp 0x8626d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xacd8
jmp 0x86275
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x86560
jmp 0x8626f
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xab60
nop
// File: bhhbazinga[P]LockFreeHashTable/./HazardPointer/reclaimer.h
// Function: Reclaimer::Hazard(void*)
bool Reclaimer::Hazard(void* const ptr) {
  std::atomic<InternalHazardPointer*>& head = global_hp_list_.head;
  InternalHazardPointer* p = head.load(std::memory_order_acquire);
  do {
    if (p->ptr.load(std::memory_order_consume) == ptr) {
      return true;
    }
    p = p->next.load(std::memory_order_acquire);
  } while (p != nullptr);

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x4300
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x3ec0
cmpq -0x18(%rbp), %rax
jne 0x273c
movb $0x1, -0x1(%rbp)
jmp 0x275d
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movl $0x2, %esi
callq 0x4300
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x271e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: bhhbazinga[P]LockFreeHashTable/./HazardPointer/reclaimer.h
// Function: Reclaimer::MarkHazard(void*)
Reclaimer::HPIndex Reclaimer::MarkHazard(void* ptr) {
  if (nullptr == ptr) return HP_INDEX_NULL;

  for (int i = 0; i < hp_list_.size(); ++i) {
    InternalHazardPointer* hp = hp_list_[i];
    if (nullptr == hp->ptr.load(std::memory_order_relaxed)) {
      hp->ptr.store(ptr, std::memory_order_release);
      return i;
    }
  }

  TryAcquireHazardPointer();
  int index = hp_list_.size() - 1;
  hp_list_[index]->ptr.store(ptr, std::memory_order_release);
  return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x27cc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2899
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
callq 0x3e80
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x2850
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3ea0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0x3ec0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x2843
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0x41b0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2899
jmp 0x2845
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27d3
movq -0x38(%rbp), %rdi
callq 0x28b0
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x3e80
movq -0x38(%rbp), %rdi
subq $0x1, %rax
movl %eax, -0x2c(%rbp)
addq $0x8, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3ea0
movq (%rax), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0x41b0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bhhbazinga[P]LockFreeHashTable/test.cc
// Function: onInsert(int)
void onInsert(int divide) {
  while (!start) {
    std::this_thread::yield();
  }

  int n = maxElements / divide;
  for (int i = 0; i < n; ++i) {
    int x = rand() % n;
    if (ht.Insert(x, x)) {
      ++cnt;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x17f3a(%rip), %rdi     # 0x1ad8c
callq 0x4e30
xorb $-0x1, %al
testb $0x1, %al
jne 0x2e5f
jmp 0x2e66
callq 0x4010
jmp 0x2e4b
movl 0x17af8(%rip), %eax     # 0x1a964
cltd
idivl -0x4(%rbp)
movl %eax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2ec0
callq 0x2040
cltd
idivl -0x8(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x17ad3(%rip), %rdi     # 0x1a968
leaq -0x10(%rbp), %rdx
movq %rdx, %rsi
callq 0x4eb0
testb $0x1, %al
jne 0x2ea7
jmp 0x2eb3
leaq 0x17eda(%rip), %rdi     # 0x1ad88
callq 0x4f50
jmp 0x2eb5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2e7a
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bhhbazinga[P]LockFreeHashTable/test.cc
// Function: onFind(int)
void onFind(int divide) {
  while (!start) {
    std::this_thread::yield();
  }

  int n = maxElements / divide;
  for (int i = 0; i < n; ++i) {
    int x;
    ht.Find(rand() % n, x);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x17eaa(%rip), %rdi     # 0x1ad8c
callq 0x4e30
xorb $-0x1, %al
testb $0x1, %al
jne 0x2eef
jmp 0x2ef6
callq 0x4010
jmp 0x2edb
movl 0x17a68(%rip), %eax     # 0x1a964
cltd
idivl -0x4(%rbp)
movl %eax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2f3d
callq 0x2040
cltd
idivl -0x8(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x17a43(%rip), %rdi     # 0x1a968
leaq -0x14(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x4f80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f0a
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bhhbazinga[P]LockFreeHashTable/test.cc
// Function: onDelete(int)
void onDelete(int divide) {
  while (!start) {
    std::this_thread::yield();
  }

  int n = maxElements / divide;
  for (int i = 0; i < n; ++i) {
    if (ht.Delete(rand() % n)) {
      --cnt;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x17e2a(%rip), %rdi     # 0x1ad8c
callq 0x4e30
xorb $-0x1, %al
testb $0x1, %al
jne 0x2f6f
jmp 0x2f76
callq 0x4010
jmp 0x2f5b
movl 0x179e8(%rip), %eax     # 0x1a964
cltd
idivl -0x4(%rbp)
movl %eax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2fcd
callq 0x2040
cltd
idivl -0x8(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x179c3(%rip), %rdi     # 0x1a968
leaq -0x10(%rbp), %rsi
callq 0x5030
testb $0x1, %al
jne 0x2fb4
jmp 0x2fc0
leaq 0x17dcd(%rip), %rdi     # 0x1ad88
callq 0x50e0
jmp 0x2fc2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f8a
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bhhbazinga[P]LockFreeHashTable/./HazardPointer/reclaimer.h
// Function: Reclaimer::ReclaimPool::~ReclaimPool()
~ReclaimPool() {
      ReclaimNode* temp;
      while (head) {
        temp = head;
        head = head->next;
        delete temp;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x412a
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4128
movq -0x20(%rbp), %rdi
callq 0x4070
movq -0x20(%rbp), %rdi
movl $0x30, %esi
callq 0x2150
jmp 0x40e4
addq $0x20, %rsp
popq %rbp
retq
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::~LockFreeHashTable()
~LockFreeHashTable() {
    Node* p = head_;
    while (p != nullptr) {
      Node* tmp = p;
      p = p->next.load(std::memory_order_acquire);
      tmp->Release();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x418(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4da4
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movl $0x2, %esi
callq 0x9360
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x4da2
jmp 0x4d6f
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
addq $0x400, %rax            # imm = 0x400
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $-0x10, %rdi
movq %rdi, -0x38(%rbp)
callq 0x8cf0
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x28(%rbp)
jne 0x4dba
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x4000
nopw (%rax,%rax)
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::Find(int const&, int&)
bool Find(const K& key, V& value) {
    HashKey hash = hash_func_(key);
    DummyNode* head = GetBucketHeadByHash(hash);
    RegularNode find_node(key, hash_func_);
    return FindNode(head, &find_node, value);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x10, %rdi
movq %rdi, -0x80(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0xa050
movq -0x78(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x9490
movq -0x80(%rbp), %rdx
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xe280
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rcx
callq 0xe2f0
movb %al, -0x65(%rbp)
jmp 0x4ff6
leaq -0x58(%rbp), %rdi
callq 0xa0d0
movb -0x65(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa0d0
movq -0x60(%rbp), %rdi
callq 0x2230
nopl (%rax,%rax)
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::Delete(int const&)
bool Delete(const K& key) {
    HashKey hash = hash_func_(key);
    DummyNode* head = GetBucketHeadByHash(hash);
    RegularNode delete_node(key, hash_func_);
    return DeleteNode(head, &delete_node);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x10, %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0xa050
movq -0x70(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x9490
movq -0x78(%rbp), %rdx
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xe280
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
movq -0x20(%rbp), %rsi
callq 0xe440
movb %al, -0x5d(%rbp)
jmp 0x509e
leaq -0x50(%rbp), %rdi
callq 0xa0d0
movb -0x5d(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa0d0
movq -0x58(%rbp), %rdi
callq 0x2230
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bhhbazinga[P]LockFreeHashTable/./HazardPointer/reclaimer.h
// Function: Reclaimer::HazardPointerList::~HazardPointerList()
~HazardPointerList() {
      // HazardPointerList destruct when program exit.
      InternalHazardPointer* p = head.load(std::memory_order_acquire);
      while (p) {
        InternalHazardPointer* temp = p;
        p = p->next.load(std::memory_order_consume);
        delete temp;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x4300
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x572a
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0x4300
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5728
movq -0x20(%rbp), %rdi
callq 0xe270
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0x2150
jmp 0x56de
addq $0x20, %rsp
popq %rbp
retq
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::Segment::~Segment()
~Segment() {
      void* ptr = data.load(std::memory_order_consume);
      if (nullptr == ptr) return;

      if (level == kMaxLevel - 1) {
        Bucket* buckets = static_cast<Bucket*>(ptr);
        delete[] buckets;
      } else {
        Segment* sub_segments = static_cast<Segment*>(ptr);
        delete[] sub_segments;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
movl $0x1, %esi
callq 0x3ec0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x8d23
jmp 0x8dc6
movq -0x28(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x8d4d
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8d4b
movq -0x30(%rbp), %rdi
callq 0x2160
jmp 0x8dc6
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x8dc4
movq -0x38(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rcx), %rdx
movq %rdx, -0x48(%rbp)
shlq $0x4, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x40(%rbp)
je 0x8daf
movq -0x40(%rbp), %rdi
addq $-0x10, %rdi
movq %rdi, -0x58(%rbp)
callq 0x8cf0
movq -0x38(%rbp), %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x40(%rbp)
jne 0x8d8d
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
shlq $0x4, %rsi
addq $0x8, %rsi
callq 0x2240
jmp 0x8dc6
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::NewSegments(int)
Segment* NewSegments(int level) {
    Segment* segments = new Segment[kSegmentSize];
    for (int i = 0; i < kSegmentSize; ++i) {
      segments[i].level = level;
      segments[i].data.store(nullptr, std::memory_order_release);
    }
    return segments;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x408, %edi            # imm = 0x408
callq 0x2030
movq %rax, -0x48(%rbp)
movq $0x40, (%rax)
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq %rax, %rcx
addq $0x400, %rcx            # imm = 0x400
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x8cc0
jmp 0x8e1d
movq -0x38(%rbp), %rcx
movq -0x50(%rbp), %rax
addq $0x10, %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0x8e0e
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x40, -0x28(%rbp)
jge 0x8ed8
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x3, %edx
callq 0x41b0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x8e41
movq -0x40(%rbp), %rcx
movq %rax, %rsi
movq -0x50(%rbp), %rax
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
cmpq %rax, %rcx
movq %rax, -0x58(%rbp)
je 0x8ec8
movq -0x58(%rbp), %rdi
addq $-0x10, %rdi
movq %rdi, -0x60(%rbp)
callq 0x8cf0
movq -0x40(%rbp), %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0x8ea6
movq -0x48(%rbp), %rdi
movl $0x408, %esi            # imm = 0x408
callq 0x2240
jmp 0x8ee2
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2230
nopl (%rax,%rax)
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::NewBuckets()
Bucket* NewBuckets() {
    Bucket* buckets = new Bucket[kSegmentSize];
    for (int i = 0; i < kSegmentSize; ++i) {
      buckets[i].store(nullptr, std::memory_order_release);
    }
    return buckets;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x200, %edi            # imm = 0x200
callq 0x2030
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0x8f3f
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x3, %edx
callq 0x8f90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8f11
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::Node::Reverse(unsigned long) const
HashKey Reverse(HashKey hash) const {
      return reverse8bits_[hash & 0xff] << 56 |
             reverse8bits_[(hash >> 8) & 0xff] << 48 |
             reverse8bits_[(hash >> 16) & 0xff] << 40 |
             reverse8bits_[(hash >> 24) & 0xff] << 32 |
             reverse8bits_[(hash >> 32) & 0xff] << 24 |
             reverse8bits_[(hash >> 40) & 0xff] << 16 |
             reverse8bits_[(hash >> 48) & 0xff] << 8 |
             reverse8bits_[(hash >> 56) & 0xff];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
andq $0xff, %rcx
leaq 0x10ef2(%rip), %rax     # 0x1a140
movq (%rax,%rcx,8), %rax
shlq $0x38, %rax
movq -0x10(%rbp), %rdx
shrq $0x8, %rdx
andq $0xff, %rdx
leaq 0x10ed4(%rip), %rcx     # 0x1a140
movq (%rcx,%rdx,8), %rcx
shlq $0x30, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rdx
shrq $0x10, %rdx
andq $0xff, %rdx
leaq 0x10eb3(%rip), %rcx     # 0x1a140
movq (%rcx,%rdx,8), %rcx
shlq $0x28, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rdx
shrq $0x18, %rdx
andq $0xff, %rdx
leaq 0x10e92(%rip), %rcx     # 0x1a140
movq (%rcx,%rdx,8), %rcx
shlq $0x20, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rdx
shrq $0x20, %rdx
andq $0xff, %rdx
leaq 0x10e71(%rip), %rcx     # 0x1a140
movq (%rcx,%rdx,8), %rcx
shlq $0x18, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rdx
shrq $0x28, %rdx
andq $0xff, %rdx
leaq 0x10e50(%rip), %rcx     # 0x1a140
movq (%rcx,%rdx,8), %rcx
shlq $0x10, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rdx
shrq $0x30, %rdx
andq $0xff, %rdx
leaq 0x10e2f(%rip), %rcx     # 0x1a140
movq (%rcx,%rdx,8), %rcx
shlq $0x8, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rdx
shrq $0x38, %rdx
andq $0xff, %rdx
leaq 0x10e0e(%rip), %rcx     # 0x1a140
orq (%rcx,%rdx,8), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::GetBucketHeadByHash(unsigned long)
DummyNode* GetBucketHeadByHash(HashKey hash) {
    BucketIndex bucket_index = (hash & (bucket_size() - 1));
    DummyNode* head = GetBucketHeadByIndex(bucket_index);
    if (nullptr == head) {
      head = InitializeBucket(bucket_index);
    }
    return head;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xa220
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0xa2b0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x94f1
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa3e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::GetBucketHeadByIndex(unsigned long)
typename LockFreeHashTable<K, V, Hash>::DummyNode*
LockFreeHashTable<K, V, Hash>::GetBucketHeadByIndex(BucketIndex bucket_index) {
  int level = 1;
  const Segment* segments = segments_;
  while (level++ <= kMaxLevel - 2) {
    segments =
        segments[(bucket_index / static_cast<SegmentIndex>(pow(
                                     kSegmentSize, kMaxLevel - level + 1))) %
                 kSegmentSize]
            .get_sub_segments();
    if (nullptr == segments) return nullptr;
  }

  Bucket* buckets =
      segments[(bucket_index / kSegmentSize) % kSegmentSize].get_sub_buckets();
  if (nullptr == buckets) return nullptr;

  Bucket& bucket = buckets[bucket_index % kSegmentSize];
  return bucket.load(std::memory_order_consume);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, -0x1c(%rbp)
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x2, %eax
jg 0xa370
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x1c(%rbp), %ecx
movl $0x5, %eax
subl %ecx, %eax
cvtsi2sd %eax, %xmm1
movsd 0x6d6b(%rip), %xmm0     # 0x11078
callq 0x2210
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movsd 0x6d57(%rip), %xmm1     # 0x11088
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
xorl %edx, %edx
divq %rcx
andq $0x3f, %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0xa770
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0xa36b
movq $0x0, -0x8(%rbp)
jmp 0xa3cb
jmp 0xa2d3
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
shrq $0x6, %rax
andq $0x3f, %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0xa7a0
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jne 0xa3a2
movq $0x0, -0x8(%rbp)
jmp 0xa3cb
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0xa7d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::InsertDummyNode(LockFreeHashTable<int, int, std::hash<int>>::DummyNode*, LockFreeHashTable<int, int, std::hash<int>>::DummyNode*, LockFreeHashTable<int, int, std::hash<int>>::DummyNode**)
bool LockFreeHashTable<K, V, Hash>::InsertDummyNode(DummyNode* parent_head,
                                                    DummyNode* new_head,
                                                    DummyNode** real_head) {
  Node* prev;
  Node* cur;
  HazardPointer prev_hp, cur_hp;
  do {
    if (SearchNode(parent_head, new_head, &prev, &cur, prev_hp, cur_hp)) {
      // The head of bucket already insert into list.
      *real_head = static_cast<DummyNode*>(cur);
      return false;
    }
    new_head->next.store(cur, std::memory_order_release);
  } while (!prev->next.compare_exchange_weak(
      cur, new_head, std::memory_order_release, std::memory_order_relaxed));
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb020
leaq -0x58(%rbp), %rdi
callq 0xb020
jmp 0xae77
jmp 0xae79
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq %rsp, %rax
leaq -0x58(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
leaq -0x48(%rbp), %r9
callq 0xb040
movb %al, -0x71(%rbp)
jmp 0xaea5
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xaeae
jmp 0xaeeb
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0xaf33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xaf53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xba10
jmp 0xaf53
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x38(%rbp), %rsi
movl $0x3, %edx
callq 0xb400
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rsi
movl $0x3, %ecx
xorl %r8d, %r8d
callq 0xb490
xorb $-0x1, %al
testb $0x1, %al
jne 0xae79
movb $0x1, -0x1(%rbp)
movl $0x1, -0x68(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xba10
leaq -0x48(%rbp), %rdi
callq 0xba10
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0xba10
movq -0x60(%rbp), %rdi
callq 0x2230
nopw %cs:(%rax,%rax)
nop
// File: bhhbazinga[P]LockFreeHashTable/./HazardPointer/reclaimer.h
// Function: HazardPointer::operator=(HazardPointer&&)
HazardPointer& operator=(HazardPointer&& other) {
    reclaimer_ = other.reclaimer_;
    index = other.index;

    // If move assign is called, we must disable the other's index to avoid
    // incorrectly unmark index when other destruct.
    other.index = Reclaimer::HP_INDEX_NULL;
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl $0xffffffff, 0x8(%rcx)  # imm = 0xFFFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: bhhbazinga[P]LockFreeHashTable/./HazardPointer/reclaimer.h
// Function: Reclaimer::ReclaimLater(void*, std::function<void (void*)>&&)
void ReclaimLater(void* const ptr, std::function<void(void*)>&& func) {
    ReclaimNode* new_node = reclaim_pool_.Pop();
    new_node->ptr = ptr;
    new_node->delete_func = std::move(func);
    reclaim_map_.insert(std::make_pair(ptr, new_node));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x58, %rdi
callq 0xc880
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc920
movq -0x50(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc9b0
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xc970
movq %rax, -0x40(%rbp)
movb %dl, -0x38(%rbp)
addq $0x50, %rsp
popq %rbp
retq