LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/pat.cpp
// Function: FastaPatternSource::nextBatchFromFile(PerThreadReadBuf&, bool, unsigned long)
pair<bool, int> FastaPatternSource::nextBatchFromFile(
	PerThreadReadBuf& pt,
	bool batch_a,
	size_t readi)
{
	int c;
	EList<Read>& readbuf = batch_a ? pt.bufa_ : pt.bufb_;
	if(first_) {
		c = getc_wrapper();
		if(c == EOF) {
			return make_pair(true, 0);
		}
		while(c == '\r' || c == '\n') {
			c = getc_wrapper();
		}
		if(c != '>') {
			cerr << "Error: reads file does not look like a FASTA file" << endl;
			throw 1;
		}
		first_ = false;
	}
	bool done = false;
	// Read until we run out of input or until we've filled the buffer
	for(; readi < pt.max_buf_ && !done; readi++) {
		readbuf[readi].readOrigBuf.append('>');
		while(true) {
			c = getc_wrapper();
			if(c < 0 || c == '>') {
				done = c < 0;
				break;
			}
			readbuf[readi].readOrigBuf.append(c);
		}
	}
	// Immediate EOF case
	if(done && readbuf[readi-1].readOrigBuf.length() == 1) {
		readi--;
	}
	return make_pair(done, readi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0x200a3(%rdi)
jne 0x4d5d5
movq %r15, %rdi
callq 0x4f0ba
cmpl $-0x1, %eax
je 0x4d6ad
cmpl $0xa, %eax
je 0x4d5ba
cmpl $0xd, %eax
jne 0x4d5c4
movq %r15, %rdi
callq 0x4f0ba
jmp 0x4d5b0
cmpl $0x3e, %eax
jne 0x4d6b4
movb $0x0, 0x200a3(%r15)
xorb $0x1, %bpl
movzbl %bpl, %ebp
shll $0x5, %ebp
orq $0x8, %rbp
cmpq %rbx, (%r14)
jbe 0x4d66f
leaq 0x6(%rsp), %r13
movq 0x8(%r14,%rbp), %rax
imulq $0x268, %rbx, %r12      # imm = 0x268
leaq (%rax,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb $0x3e, 0x7(%rsp)
leaq 0x7(%rsp), %rsi
callq 0x4f10a
movq %r15, %rdi
callq 0x4f0ba
testl %eax, %eax
sets %cl
cmpl $0x3e, %eax
sete %dl
orb %cl, %dl
jne 0x4d65c
movq 0x8(%r14,%rbp), %rcx
leaq (%rcx,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb %al, 0x6(%rsp)
movq %r13, %rsi
callq 0x4f10a
movq %r15, %rdi
callq 0x4f0ba
testl %eax, %eax
js 0x4d65c
cmpl $0x3e, %eax
jne 0x4d62f
shrl $0x1f, %eax
incq %rbx
cmpq (%r14), %rbx
jae 0x4d66b
testb %al, %al
je 0x4d5f2
movl %eax, %ecx
jmp 0x4d673
xorl %ecx, %ecx
xorl %eax, %eax
testb %al, %al
je 0x4d694
leaq -0x1(%rbx), %rax
movq 0x8(%r14,%rbp), %rdx
imulq $0x268, %rbx, %rsi      # imm = 0x268
cmpq $0x1, -0x128(%rsi,%rdx)
cmoveq %rax, %rbx
shlq $0x20, %rbx
orq %rcx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ebx
jmp 0x4d69b
movq 0x1d935(%rip), %rdi     # 0x6aff0
leaq 0xa930(%rip), %rsi      # 0x57ff2
callq 0x9490
movq %rax, %rdi
callq 0x91f0
movl $0x4, %edi
callq 0x9200
movl $0x1, (%rax)
movq 0x1d852(%rip), %rsi     # 0x6af38
movq %rax, %rdi
xorl %edx, %edx
callq 0x98f0
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/pat.cpp
// Function: FastaContinuousPatternSource::parse(Read&, Read&, unsigned long) const
bool FastaContinuousPatternSource::parse(
	Read& ra,
	Read& rb,
	TReadId rdid) const
{
	// Light parser (nextBatchFromFile) puts unparsed data
	// into Read& r, even when the read is paired.
	assert(ra.empty());
	assert(rb.empty());
	assert(!ra.readOrigBuf.empty()); // raw data for read/pair is here
	assert(rb.readOrigBuf.empty());
	int c = '\t';
	size_t cur = 0;
	const size_t buflen = ra.readOrigBuf.length();

	// Parse read name
	c = ra.readOrigBuf[cur++];
	while(c != '\t' && cur < buflen) {
		ra.name.append(c);
		c = ra.readOrigBuf[cur++];
	}
	assert_eq('\t', c);
	if(cur >= buflen) {
		return false; // record ended prematurely
	}

	// Parse sequence
	assert(ra.patFw.empty());
	int nchar = 0;
	while(cur < buflen) {
		c = ra.readOrigBuf[cur++];
		if(isalpha(c)) {
			assert_in(toupper(c), "ACGTN");
			if(nchar++ >= this->trim5_) {
				assert_neq(0, asc2dnacat[c]);
				ra.patFw.append(asc2dna[c]); // ascii to int
			}
		}
	}
	// record amt trimmed from 5' end due to --trim5
	ra.trimmed5 = (int)(nchar - ra.patFw.length());
	// record amt trimmed from 3' end due to --trim3
	ra.trimmed3 = (int)(ra.patFw.trimEnd(this->trim3_));

	// Make fake qualities
	assert(ra.qual.empty());
	for(size_t i = 0; i < ra.patFw.length(); i++) {
		ra.qual.append('I');
	}

	ra.parsed = true;
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movq 0x128(%rsi), %rax
movq 0x140(%rsi), %r13
movb (%rax), %al
cmpb $0x9, %al
setne %cl
cmpq $0x2, %r13
setae %bpl
andb %bpl, %cl
movl $0x1, %r14d
cmpb $0x1, %cl
jne 0x4dd50
leaq 0x150(%rbx), %r15
leaq 0x7(%rsp), %r12
movb %al, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4f02e
movq 0x128(%rbx), %rax
movb (%rax,%r14), %al
incq %r14
cmpq %r13, %r14
setb %bpl
cmpb $0x9, %al
je 0x4dd50
cmpq %r13, %r14
jb 0x4dd23
testb %bpl, %bpl
je 0x4de2f
movq %rbx, 0x8(%rsp)
xorl %r15d, %r15d
cmpq %r13, %r14
jae 0x4ddc3
xorl %ebx, %ebx
movq 0x8(%rsp), %rax
movq 0x128(%rax), %rax
movsbl (%rax,%r14), %r12d
movl %r12d, %edi
callq 0x9800
testl %eax, %eax
je 0x4ddb5
leal 0x1(%rbx), %r15d
movq 0x10(%rsp), %rax
cmpl 0x18(%rax), %ebx
jl 0x4ddb8
movslq %r12d, %rax
leaq 0x1f7b3(%rip), %rcx     # 0x6d550
movb (%rcx,%rax), %al
movb %al, 0x6(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rsi
callq 0x4f074
jmp 0x4ddb8
movl %ebx, %r15d
incq %r14
movl %r15d, %ebx
cmpq %r14, %r13
jne 0x4dd68
movq 0x8(%rsp), %r12
movq 0x20(%r12), %rax
subl %eax, %r15d
movl %r15d, 0x1a8(%r12)
movq 0x10(%rsp), %rcx
movslq 0x14(%rcx), %rcx
xorl %edx, %edx
movq %rax, %rsi
subq %rcx, %rsi
cmovaeq %rsi, %rdx
cmovbq %rax, %rcx
movq %rdx, 0x20(%r12)
movl %ecx, 0x1ac(%r12)
jbe 0x4de26
leaq 0x60(%r12), %r14
xorl %ebx, %ebx
leaq 0x5(%rsp), %r15
movb $0x49, 0x5(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4f02e
incq %rbx
cmpq 0x20(%r12), %rbx
jb 0x4de0c
movb $0x1, 0x190(%r12)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/pat.cpp
// Function: TabbedPatternSource::nextBatchFromFile(PerThreadReadBuf&, bool, unsigned long)
pair<bool, int> TabbedPatternSource::nextBatchFromFile(
	PerThreadReadBuf& pt,
	bool batch_a,
	size_t readi)
{
	int c = getc_wrapper();
	while(c >= 0 && (c == '\n' || c == '\r')) {
		c = getc_wrapper();
	}
	EList<Read>& readbuf = batch_a ? pt.bufa_ : pt.bufb_;
	// Read until we run out of input or until we've filled the buffer
	for(; readi < pt.max_buf_ && c >= 0; readi++) {
		readbuf[readi].readOrigBuf.clear();
		while(c >= 0 && c != '\n' && c != '\r') {
			readbuf[readi].readOrigBuf.append(c);
			c = getc_wrapper();
		}
                if (c == '\n') {
			readbuf[readi].readOrigBuf.append(c);
			c = getc_wrapper();
			if (c == '\r')
				readbuf[readi].readOrigBuf.append(c);
                        else {
				ungetc_wrapper(c);
				c = '\n'; // reset to last seen char
                        }
                }
                while(c >= 0 && (c == '\n' || c == '\r') && readi < pt.max_buf_ - 1) {
			c = getc_wrapper();
		}
	}
	return make_pair(c < 0, readi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
callq 0x4f0ba
testl %eax, %eax
js 0x4e4f8
cmpl $0xd, %eax
je 0x4e4f3
cmpl $0xa, %eax
jne 0x4e4f8
movq %r15, %rdi
jmp 0x4e4e0
testl %eax, %eax
js 0x4e602
cmpq %rbx, (%r14)
jbe 0x4e602
xorb $0x1, %bpl
movzbl %bpl, %r13d
shll $0x5, %r13d
orq $0x8, %r13
leaq 0x7(%rsp), %rbp
movq 0x8(%r14,%r13), %rcx
imulq $0x268, %rbx, %r12      # imm = 0x268
movq $0x0, 0x140(%rcx,%r12)
cmpl $0xa, %eax
je 0x4e56e
cmpl $0xd, %eax
je 0x4e5d9
movq 0x8(%r14,%r13), %rcx
leaq (%rcx,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb %al, 0x7(%rsp)
movq %rbp, %rsi
callq 0x4f10a
movq %r15, %rdi
callq 0x4f0ba
testl %eax, %eax
jns 0x4e536
jmp 0x4e5d9
movq 0x8(%r14,%r13), %rax
leaq (%rax,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb $0xa, 0x6(%rsp)
leaq 0x6(%rsp), %rsi
callq 0x4f10a
movq %r15, %rdi
callq 0x4f0ba
cmpl $0xd, %eax
jne 0x4e5c0
movq 0x8(%r14,%r13), %rax
leaq (%rax,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb $0xd, 0x5(%rsp)
leaq 0x5(%rsp), %rsi
callq 0x4f10a
movl $0xd, %eax
jmp 0x4e5d9
movq %r15, %rdi
movl %eax, %esi
callq 0x4f14a
movl $0xa, %eax
jmp 0x4e5d9
movq %r15, %rdi
callq 0x4f0ba
testl %eax, %eax
js 0x4e5f2
cmpl $0xd, %eax
je 0x4e5e7
cmpl $0xa, %eax
jne 0x4e5f2
movq (%r14), %rcx
decq %rcx
cmpq %rcx, %rbx
jb 0x4e5d1
incq %rbx
testl %eax, %eax
js 0x4e602
cmpq (%r14), %rbx
jb 0x4e51e
shrl $0x1f, %eax
shlq $0x20, %rbx
orq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/pat.cpp
// Function: RawPatternSource::nextBatchFromFile(PerThreadReadBuf&, bool, unsigned long)
pair<bool, int> RawPatternSource::nextBatchFromFile(
	PerThreadReadBuf& pt,
	bool batch_a,
	size_t readi)
{
	int c = getc_wrapper();
	while(c >= 0 && (c == '\n' || c == '\r')) {
		c = getc_wrapper();
	}
	EList<Read>& readbuf = batch_a ? pt.bufa_ : pt.bufb_;
	// Read until we run out of input or until we've filled the buffer
	for(; readi < pt.max_buf_ && c >= 0; readi++) {
		readbuf[readi].readOrigBuf.clear();
		while(c >= 0 && (c == '\n' || c == '\r')) {
			c = getc_wrapper();
		}
		while(c >= 0 && (c != '\n' && c != '\r')) {
			readbuf[readi].readOrigBuf.append(c);
			c = getc_wrapper();
		}
                if (c == '\n') {
			readbuf[readi].readOrigBuf.append(c);
			c = getc_wrapper();
			if (c == '\r')
				readbuf[readi].readOrigBuf.append(c);
			else {
				ungetc_wrapper(c);
				c = '\n'; // reset to last character seen
			}
                }
        }
	while (readi > 0 && readbuf[readi-1].readOrigBuf.length() == 0)
		readi--;
	return make_pair(c < 0, readi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
callq 0x4f0ba
testl %eax, %eax
js 0x4ea9a
cmpl $0xd, %eax
je 0x4ea95
cmpl $0xa, %eax
jne 0x4ea9a
movq %r15, %rdi
jmp 0x4ea82
xorb $0x1, %bpl
movzbl %bpl, %r13d
shll $0x5, %r13d
orq $0x8, %r13
testl %eax, %eax
js 0x4eb95
cmpq %rbx, (%r14)
jbe 0x4eb95
leaq 0x7(%rsp), %rbp
movq 0x8(%r14,%r13), %rcx
imulq $0x268, %rbx, %r12      # imm = 0x268
movq $0x0, 0x140(%rcx,%r12)
cmpl $0xd, %eax
je 0x4eae2
cmpl $0xa, %eax
jne 0x4eb14
movq %r15, %rdi
callq 0x4f0ba
testl %eax, %eax
jns 0x4ead8
jmp 0x4eb14
movq 0x8(%r14,%r13), %rcx
leaq (%rcx,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb %al, 0x7(%rsp)
movq %rbp, %rsi
callq 0x4f10a
movq %r15, %rdi
callq 0x4f0ba
testl %eax, %eax
js 0x4eb85
cmpl $0xa, %eax
je 0x4eb24
cmpl $0xd, %eax
jne 0x4eaf0
jmp 0x4eb85
movq 0x8(%r14,%r13), %rax
leaq (%rax,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb $0xa, 0x6(%rsp)
leaq 0x6(%rsp), %rsi
callq 0x4f10a
movq %r15, %rdi
callq 0x4f0ba
cmpl $0xd, %eax
jne 0x4eb76
movq 0x8(%r14,%r13), %rax
leaq (%rax,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb $0xd, 0x5(%rsp)
leaq 0x5(%rsp), %rsi
callq 0x4f10a
movl $0xd, %eax
jmp 0x4eb85
movq %r15, %rdi
movl %eax, %esi
callq 0x4f14a
movl $0xa, %eax
incq %rbx
testl %eax, %eax
js 0x4eb95
cmpq (%r14), %rbx
jb 0x4eac0
imulq $0x268, %rbx, %rcx      # imm = 0x268
incq %rbx
addq $-0x128, %rcx           # imm = 0xFED8
cmpq $0x1, %rbx
je 0x4ebc4
movq 0x8(%r14,%r13), %rdx
decq %rbx
cmpq $0x0, (%rdx,%rcx)
leaq -0x268(%rcx), %rcx
je 0x4eba6
jmp 0x4ebc6
xorl %ebx, %ebx
shrl $0x1f, %eax
shlq $0x20, %rbx
orq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x1c23b(%rip), %rdi     # 0x6aff0
leaq 0x9419(%rip), %rsi      # 0x581d5
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0x944d(%rip), %rsi      # 0x5821d
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0x9476(%rip), %rsi      # 0x5825d
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1fe01
movq %rax, %rdi
callq 0x91f0
movl $0x4, %edi
callq 0x9200
movl $0x1, (%rax)
movq 0x1c11f(%rip), %rsi     # 0x6af38
movq %rax, %rdi
xorl %edx, %edx
callq 0x98f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x170(%rdi), %rax
cmpq $0x2, %rax
jb 0x4ee92
movq 0x158(%rbx), %rcx
cmpb $0x2f, -0x2(%rcx,%rax)
jne 0x4ee92
cmpl $0x1, %ebp
sete %dl
movb $0x32, %sil
subb %dl, %sil
cmpb %sil, -0x1(%rcx,%rax)
je 0x4eebe
addq $0x150, %rbx            # imm = 0x150
leaq 0x7(%rsp), %rsi
movb $0x2f, (%rsi)
movq %rbx, %rdi
callq 0x4f02e
movslq %ebp, %rax
leaq 0x93bb(%rip), %rsi      # 0x5826e
addq %rax, %rsi
movq %rbx, %rdi
callq 0x4f02e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movq (%rsi), %rdi
leaq 0x20(%rsp), %rsi
callq 0x9900
testl %eax, %eax
jne 0x4efb7
movl $0xf000, %eax           # imm = 0xF000
andl 0x38(%rsp), %eax
movb $0x1, %bpl
cmpl $0x1000, %eax           # imm = 0x1000
je 0x4efa9
leaq 0x8687(%rip), %rsi      # 0x5758e
movl $0x1, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x9a30
leaq 0x10(%rsp), %r14
cmpq $-0x1, %rax
je 0x4ef40
incq %rax
movq %rsp, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x94e0
jmp 0x4ef55
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x9608(%rip), %rdx      # 0x58555
movq %rdx, %rsi
callq 0x1dde4
leaq 0x95f9(%rip), %rsi      # 0x58555
movq %rsp, %rdi
callq 0x9140
movb $0x1, %bpl
testl %eax, %eax
je 0x4ef93
leaq 0x9300(%rip), %rsi      # 0x58272
movq %rsp, %rdi
callq 0x9140
testl %eax, %eax
je 0x4ef93
leaq 0x92f0(%rip), %rsi      # 0x58275
movq %rsp, %rdi
callq 0x9140
testl %eax, %eax
sete %bpl
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x4efa9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
movl %ebp, %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x458b(%rip), %rdi      # 0x53549
callq 0x93e0
jmp 0x4ef00
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
leaq 0x1(%rax), %rcx
cmpq %rcx, 0x28(%rdi)
jae 0x4f09c
leaq 0x34(,%rax,2), %rsi
movq %rbx, %rdi
callq 0x25560
movb (%r14), %al
movq 0x8(%rbx), %rcx
movq 0x20(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x20(%rbx)
movb %al, (%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./pat.h
// Function: CFilePatternSource::reset()
virtual void reset() {
		TrimmingPatternSource::reset();
		filecur_ = 0,
		open();
		filecur_++;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq %rax, 0x80(%rdi)
callq 0x4c6a4
incq 0x80(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x200a8(%rdi), %rax
decq %rax
movq %rax, 0x200b8(%rdi)
xorl %eax, %eax
movq %rax, 0x204d0(%rdi)
movq 0x204c8(%rdi), %rcx
movb $0x0, (%rcx)
movb $0x1, 0x200c0(%rdi)
movq %rax, 0x20500(%rdi)
movq 0x20508(%rdi), %rax
movq %rax, 0x20510(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x4f867
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4f85e
movq (%rdi), %rax
callq *0x20(%rax)
incq %r14
cmpq 0x28(%rbx), %r14
jb 0x4f83d
movl $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rax
cmpq %rax, 0x28(%rdi)
jae 0x4f8aa
leaq 0x32(,%rax,2), %rsi
movq %rbx, %rdi
callq 0x25560
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x4f8ee
movq $-0x1, %rax
xorl %ecx, %ecx
movl $0x4, %esi
addq 0x8(%r14), %rdx
movb (%rax,%rdx), %dl
movl %edx, %edi
xorb $0x3, %dil
cmpb $0x4, %dl
movzbl %dil, %edx
cmovel %esi, %edx
movq 0x8(%rbx), %rdi
movb %dl, (%rdi,%rcx)
incq %rcx
movq 0x20(%r14), %rdx
decq %rax
cmpq %rdx, %rcx
jb 0x4f8c1
movq %rdx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rax
cmpq %rax, 0x28(%rdi)
jae 0x4f91e
leaq 0x32(,%rax,2), %rsi
movq %rbx, %rdi
callq 0x20c2a
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x4f94d
movq $-0x1, %rcx
xorl %edx, %edx
addq 0x8(%r14), %rax
movb (%rcx,%rax), %al
movq 0x8(%rbx), %rsi
movb %al, (%rsi,%rdx)
incq %rdx
movq 0x20(%r14), %rax
decq %rcx
cmpq %rax, %rdx
jb 0x4f930
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1fe01
movq %rax, %r15
leaq 0x3e17(%rip), %r12      # 0x53f0a
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x9560
leaq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x1fe01
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x9560
leaq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x1fe01
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r15, %rdi
callq 0x9050
movq %rax, %rdi
callq 0x92f0
cmpq $0x0, 0xb0(%r14)
je 0x5018a
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0xa0(%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x50083
incq %r12
addq $0x30, %r15
cmpq 0xb0(%r14), %r12
jb 0x50168
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/sam.cpp
// Function: SAMHitSink::appendHeaders(OutFileBuf&, unsigned long, EList<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 128> const&, bool, unsigned int const*, bool, bool, char const*, char const*)
void SAMHitSink::appendHeaders(
	OutFileBuf& os,
	size_t numRefs,
	const EList<string>& refnames,
	bool nosq,
	const TIndexOffU* plen,
	bool fullRef,
	bool noQnameTrunc,
	const char *cmdline,
	const char *rgline)
{
	BTString o;
	o << "@HD\tVN:1.0\tSO:unsorted\n";
	if(!nosq) {
		for(size_t i = 0; i < numRefs; i++) {
			// RNAME
			o << "@SQ\tSN:";
			if(i < refnames.size()) {
				printUptoWs(o, refnames[i], !fullRef);
			} else {
				o << i;
			}
			o << "\tLN:" << (plen[i]) << '\n';
		}
	}
	if(rgline != NULL) {
		o << "@RG\t" << rgline << '\n';
	}
	o << "@PG\tID:Bowtie\tVN:" << BOWTIE_VERSION << "\tCL:\"" << cmdline << "\"\n";
	os.writeString(o);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r14
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x40(%rsp)
leaq 0x1983e(%rip), %rax     # 0x69a00
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x20(%rdi)
leaq 0x82ff(%rip), %rsi      # 0x584db
movl $0x17, %edx
callq 0x512bc
testb %bl, %bl
jne 0x502a1
movq $0x0, 0x8(%rsp)
testq %r12, %r12
je 0x502a1
movb 0x80(%rsp), %al
xorb $0x1, %al
leaq 0x10(%rsp), %rbp
movzbl %al, %ebx
leaq 0x7(%rsp), %r13
movl $0x7, %edx
movq %rbp, %rdi
leaq 0x82ce(%rip), %rsi      # 0x584f3
callq 0x512bc
movq 0x8(%rsp), %rsi
cmpq 0x18(%r15), %rsi
jae 0x50249
shlq $0x5, %rsi
addq 0x8(%r15), %rsi
movq %rbp, %rdi
movl %ebx, %edx
callq 0x50fee
jmp 0x50256
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x510b6
movl $0x4, %edx
movq %rbp, %rdi
leaq 0x8296(%rip), %rsi      # 0x584fb
callq 0x512bc
movq 0x8(%rsp), %rax
leaq (%r14,%rax,4), %rsi
movq %rbp, %rdi
callq 0x5115d
movb $0xa, 0x7(%rsp)
movq %rax, %rdi
movq %r13, %rsi
callq 0x4f02e
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
cmpq %r12, %rax
jb 0x50216
movq 0x98(%rsp), %rbx
testq %rbx, %rbx
je 0x502ee
leaq 0x824b(%rip), %rsi      # 0x58500
leaq 0x10(%rsp), %rdi
movl $0x4, %edx
callq 0x512bc
movq %rbx, %rdi
callq 0x91b0
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x512bc
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x4f02e
leaq 0x8210(%rip), %rsi      # 0x58505
leaq 0x10(%rsp), %rdi
movl $0x11, %edx
callq 0x512bc
leaq 0x38ef(%rip), %rsi      # 0x53bfa
leaq 0x10(%rsp), %rdi
movl $0x5, %edx
callq 0x512bc
leaq 0x81f6(%rip), %rsi      # 0x58517
leaq 0x10(%rsp), %rdi
movl $0x5, %edx
callq 0x512bc
movq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0x91b0
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x512bc
leaq 0x81c6(%rip), %rsi      # 0x5851d
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
callq 0x512bc
leaq 0x10(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0x20e76
leaq 0x10(%rsp), %rdi
callq 0x253a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x50390
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x253a0
movq %rbx, %rdi
callq 0x9930
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x5106e
leaq 0x754b(%rip), %rsi      # 0x58553
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x9770
cmpq $-0x1, %rax
je 0x5106e
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x94e0
movq (%r15), %r14
movq %r14, %rdi
callq 0x91b0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x512bc
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51064
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %r14
movq %r14, %rdi
callq 0x91b0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x512bc
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x510ae
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./sstring.h
// Function: SStringExpandable<char, 25, 2, 0>& operator<<<char, 25, 2, 0, unsigned long>(SStringExpandable<char, 25, 2, 0>&, unsigned long const&)
SStringExpandable<T, S, M, I>& operator<<(
	SStringExpandable<T, S, M, I>& o,
	const A& i)
{
	char buf[1024];
	itoa10<A>(static_cast<A>(i), buf);
	o.append(buf);
	return o;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
movq (%rsi), %rcx
leaq -0x1(%rsp), %rsi
leaq 0x732a(%rip), %rdi      # 0x583fc
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %r8
shrq $0x3, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r9
subq %rax, %r9
movb (%rdi,%r9), %al
movb %al, 0x1(%rsi)
incq %rsi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x510dc
movq %rsp, %rax
cmpq %rax, %rsi
jbe 0x51132
leaq 0x1(%rsp), %rax
movq %rsi, %rcx
movb -0x1(%rax), %dl
movb (%rcx), %dil
movb %dil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x51117
movb $0x0, 0x1(%rsi)
movq %rsp, %r14
movq %r14, %rdi
callq 0x91b0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x512bc
movq %rbx, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl (%rdi), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
leaq 0x70e3(%rip), %r8       # 0x583fc
movq %rsi, %rax
movl %ecx, %r9d
imulq %rdx, %r9
shrq $0x23, %r9
leal (%r9,%r9), %r10d
leal (%r10,%r10,4), %r10d
movl %ecx, %r11d
subl %r10d, %r11d
movb (%r11,%r8), %r10b
movb %r10b, (%rax)
incq %rax
cmpl $0x9, %ecx
movl %r9d, %ecx
ja 0x5131c
cmpl $0x0, (%rdi)
jns 0x51352
movb $0x2d, (%rax)
incq %rax
cmpq %rsi, %rax
setne %dl
leaq -0x1(%rax), %rcx
cmpq %rsi, %rcx
seta %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x5138a
incq %rsi
movb -0x1(%rsi), %dl
movb (%rcx), %dil
movb %dil, -0x1(%rsi)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rsi), %rdx
cmpq %rcx, %rsi
movq %rdx, %rsi
jb 0x5136f
movb $0x0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x60(%rdi), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
cmpq %rsi, %rcx
je 0x24f5
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x24e3
cmpq %rsi, %rcx
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x2566
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
cmpq %rsi, 0x10(%rdi)
setne %cl
je 0x256c
xorl %edx, %edx
movq (%rsi,%rdx,8), %rdi
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
jne 0x2545
movq %rbx, 0x8(%rdi)
movl %edx, %eax
testq %rsi, %rsi
je 0x256c
incq %rdx
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rcx
subq %rsi, %rcx
sarq $0x3, %rcx
cmpq %rdx, %rcx
seta %cl
ja 0x2532
jmp 0x256c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
testb $0x1, %cl
jne 0x2595
movq %r14, %rdi
callq 0x259e
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
subq %rcx, %rax
shrq $0x3, %rax
decl %eax
movslq %eax, %rdx
movq (%rcx,%rdx,8), %rcx
movq %rbx, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bhhbazinga[P]LockFreeHashTable/./HazardPointer/reclaimer.h
// Function: Reclaimer::TryAcquireHazardPointer()
void Reclaimer::TryAcquireHazardPointer() {
  std::atomic<InternalHazardPointer*>& head = global_hp_list_.head;
  InternalHazardPointer* p = head.load(std::memory_order_acquire);
  InternalHazardPointer* hp = nullptr;
  do {
    // Try to get the idle hazard pointer.
    if (!p->flag.test_and_set()) {
      hp = p;
      break;
    }
    p = p->next.load(std::memory_order_acquire);
  } while (p != nullptr);

  if (nullptr == hp) {
    // No idle hazard pointer, allocate new one.
    InternalHazardPointer* new_head = new InternalHazardPointer();
    new_head->flag.test_and_set();
    hp = new_head;
    global_hp_list_.size.fetch_add(1, std::memory_order_release);
    InternalHazardPointer* old_head = head.load(std::memory_order_acquire);
    do {
      new_head->next = old_head;
    } while (!head.compare_exchange_weak(old_head, new_head,
                                         std::memory_order_release,
                                         std::memory_order_relaxed));
  }
  hp_list_.push_back(hp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq (%r14), %rax
movq $0x0, (%rsp)
movb $0x1, %cl
xchgb %cl, (%rax)
testb %cl, %cl
je 0x25c7
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x25b4
jmp 0x25cb
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x260e
movl $0x18, %edi
callq 0x2130
movq %rax, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movb $0x1, %al
xchgb %al, (%rcx)
movq %rcx, (%rsp)
movq 0x60(%rbx), %rax
lock
incl 0x8(%rax)
movq (%r14), %rdx
movq %rdx, %rax
xchgq %rax, 0x10(%rcx)
movq %rdx, %rax
lock
cmpxchgq %rcx, (%r14)
cmovneq %rax, %rdx
jne 0x25f9
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x2626
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x2635
addq $0x8, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x3fd0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bhhbazinga[P]LockFreeHashTable/./HazardPointer/reclaimer.h
// Function: Reclaimer::ReclaimNoHazardPointer()
void Reclaimer::ReclaimNoHazardPointer() {
  if (reclaim_map_.size() < kCoefficient * global_hp_list_.get_size()) {
    return;
  }

  // Used to speed up the inspection of the ptr.
  std::unordered_set<void*> not_allow_delete_set;
  std::atomic<InternalHazardPointer*>& head = global_hp_list_.head;
  InternalHazardPointer* p = head.load(std::memory_order_acquire);
  do {
    void* const ptr = p->ptr.load(std::memory_order_consume);
    if (nullptr != ptr) {
      not_allow_delete_set.insert(ptr);
    }
    p = p->next.load(std::memory_order_acquire);
  } while (p);

  for (auto it = reclaim_map_.begin(); it != reclaim_map_.end();) {
    if (not_allow_delete_set.find(it->first) == not_allow_delete_set.end()) {
      ReclaimNode* node = it->second;
      node->delete_func(node->ptr);
      reclaim_pool_.Push(node);
      it = reclaim_map_.erase(it);
    } else {
      ++it;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x60(%rdi), %rax
movl 0x8(%rax), %eax
cltq
shlq $0x2, %rax
cmpq %rax, 0x38(%rdi)
jb 0x2795
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x40(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq 0x60(%rdi), %rax
movq (%rax), %rbp
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq 0x8(%rbp), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x26c1
movq %r15, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3cee
movq 0x10(%rbp), %rbp
testq %rbp, %rbp
jne 0x26a1
movq 0x30(%rbx), %r15
testq %r15, %r15
je 0x278b
movq %rsp, %r12
movq 0x8(%r15), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %r8
movq %rcx, %rax
xorl %edx, %edx
divq %r8
movq %rdx, %rsi
movq (%rdi,%rdx,8), %rdx
movl $0x0, %eax
testq %rdx, %rdx
je 0x273a
movq (%rdx), %r9
movq %rdx, %rax
cmpq 0x8(%r9), %rcx
je 0x273a
movq %r9, %r10
movq (%r9), %r9
testq %r9, %r9
je 0x2738
movq 0x8(%r9), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %eax
cmpq %rsi, %rdx
jne 0x273a
movq %r10, %rax
cmpq %rdi, %rcx
jne 0x270d
jmp 0x273a
xorl %eax, %eax
testq %rax, %rax
je 0x274a
cmpq $0x0, (%rax)
je 0x274a
movq (%r15), %r15
jmp 0x2782
movq 0x10(%r15), %r13
movq (%r13), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x20(%r13)
je 0x27a4
leaq 0x10(%r13), %rdi
movq %r12, %rsi
callq *0x28(%r13)
movq 0x58(%rbx), %rax
movq %rax, 0x8(%r13)
movq %r13, 0x58(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c2e
movq %rax, %r15
testq %r15, %r15
jne 0x26da
leaq 0x10(%rsp), %rdi
callq 0x3b4e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
jmp 0x27af
jmp 0x27af
jmp 0x27af
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3b4e
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movb 0x85b9(%rip), %al       # 0xad8c
testb $0x1, %al
jne 0x27de
callq 0x21b0
jmp 0x27cd
movl 0x8180(%rip), %eax      # 0xa964
cltd
idivl %ebx
testl %eax, %eax
jle 0x2824
movl %eax, %ebx
leaq 0x8174(%rip), %r14      # 0xa968
leaq 0x4(%rsp), %r15
movl %eax, %ebp
callq 0x2040
cltd
idivl %ebx
movl %edx, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x376a
testb %al, %al
je 0x2820
lock
incl 0x8568(%rip)            # 0xad88
decl %ebp
jne 0x27fb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movb 0x8549(%rip), %al       # 0xad8c
testb $0x1, %al
jne 0x284e
callq 0x21b0
jmp 0x283d
movl 0x8110(%rip), %eax      # 0xa964
cltd
idivl %ebx
testl %eax, %eax
jle 0x288e
movl %eax, %ebx
leaq 0x8104(%rip), %r14      # 0xa968
leaq 0x8(%rsp), %r15
leaq 0xc(%rsp), %r12
movl %eax, %ebp
callq 0x2040
cltd
idivl %ebx
movl %edx, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x37d8
decl %ebp
jne 0x2870
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movb 0x84e2(%rip), %al       # 0xad8c
testb $0x1, %al
jne 0x28b5
callq 0x21b0
jmp 0x28a4
movl 0x80a9(%rip), %eax      # 0xa964
cltd
idivl %ebx
testl %eax, %eax
jle 0x28f8
movl %eax, %ebx
leaq 0x809d(%rip), %r14      # 0xa968
leaq 0x4(%rsp), %r15
movl %eax, %ebp
callq 0x2040
cltd
idivl %ebx
movl %edx, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x38a0
testb %al, %al
je 0x28f4
lock
decl 0x8494(%rip)            # 0xad88
decl %ebp
jne 0x28d2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bhhbazinga[P]LockFreeHashTable/./HazardPointer/reclaimer.h
// Function: Reclaimer::~Reclaimer()
Reclaimer::~Reclaimer() {
  // The Reclaimer destruct when the thread exit

  // 1.Hand over the hazard pointer
  for (int i = 0; i < hp_list_.size(); ++i) {
    // If assert fired, you should make sure no pointer is marked as hazard
    // before thread exit
    assert(nullptr == hp_list_[i]->ptr.load(std::memory_order_relaxed));
    hp_list_[i]->flag.clear();
  }

  // 2.Make sure reclaim all no hazard pointers
  for (auto it = reclaim_map_.begin(); it != reclaim_map_.end();) {
    // Wait until pointer is no hazard
    while (Hazard(it->first)) {
      std::this_thread::yield();
    }

    ReclaimNode* node = it->second;
    node->delete_func(node->ptr);
    delete node;
    it = reclaim_map_.erase(it);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x67c1(%rip), %rax      # 0x9c10
movq %rax, (%rdi)
movq 0x8(%rdi), %rcx
cmpq %rcx, 0x10(%rdi)
je 0x348a
xorl %eax, %eax
movq (%rcx,%rax,8), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
jne 0x3559
xorl %edx, %edx
xchgb %dl, (%rcx)
incq %rax
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
ja 0x345e
leaq 0x20(%rbx), %r14
movq 0x30(%rbx), %r12
movq %rsp, %r15
testq %r12, %r12
jne 0x34a4
jmp 0x351f
callq 0x21b0
movq 0x8(%r12), %rax
movq 0x60(%rbx), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rdx
cmpq %rdx, %rax
je 0x349f
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x34b0
cmpq %rdx, %rax
je 0x349f
movq 0x10(%r12), %r13
movq (%r13), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x20(%r13)
je 0x3554
leaq 0x10(%r13), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq *0x28(%r13)
movq 0x20(%r13), %rax
testq %rax, %rax
je 0x34ff
movq %rbp, %rdi
movq %rbp, %rsi
movl $0x3, %edx
callq *%rax
movl $0x30, %esi
movq %r13, %rdi
callq 0x2140
movq %r14, %rdi
movq %r12, %rsi
callq 0x3c2e
movq %rax, %r12
jmp 0x3495
leaq 0x58(%rbx), %rdi
callq 0x3590
movq %r14, %rdi
callq 0x3ade
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3545
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
leaq 0x2ab8(%rip), %rdi      # 0x6018
leaq 0x2aed(%rip), %rsi      # 0x6054
leaq 0x2b02(%rip), %rcx      # 0x6070
movl $0x9b, %edx
callq 0x20c0
jmp 0x357c
jmp 0x357c
movq %rax, %rdi
callq 0x3584
// File: /workspace/github_cpp_makefile_star2_O1/bhhbazinga[P]LockFreeHashTable/./HazardPointer/reclaimer.h
// Function: Reclaimer::ReclaimPool::~ReclaimPool()
~ReclaimPool() {
      ReclaimNode* temp;
      while (head) {
        temp = head;
        head = head->next;
        delete temp;
      }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x35d2
movq %rdi, %rbx
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x35bd
leaq 0x10(%r14), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl $0x30, %esi
movq %r14, %rdi
callq 0x2140
movq (%rbx), %r14
testq %r14, %r14
jne 0x359f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3584
// File: /workspace/github_cpp_makefile_star2_O1/bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::LockFreeHashTable()
LockFreeHashTable() : power_of_2_(1), size_(0), hash_func_(Hash()) {
    // Initialize first bucket
    int level = 1;
    Segment* segments = segments_;  // Point to current segment.
    while (level++ <= kMaxLevel - 2) {
      Segment* sub_segments = NewSegments(level);
      segments[0].data.store(sub_segments, std::memory_order_release);
      segments = sub_segments;
    }

    Bucket* buckets = NewBuckets();
    segments[0].data.store(buckets, std::memory_order_release);

    DummyNode* head = new DummyNode(0);
    buckets[0].store(head, std::memory_order_release);
    head_ = head;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x1, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x20, %eax
movl $0x1, -0x8(%rbx,%rax)
movq $0x0, (%rbx,%rax)
addq $0x10, %rax
cmpq $0x420, %rax            # imm = 0x420
jne 0x3600
leaq 0x18(%rbx), %r14
movl $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4186
movq %rax, %r15
movq %rax, 0x8(%r14)
incl %ebp
movq %rax, %r14
cmpl $0x4, %ebp
jne 0x3625
movl $0x200, %edi            # imm = 0x200
callq 0x2030
movq %rax, %r14
xorl %eax, %eax
movq $0x0, (%r14,%rax,8)
incq %rax
cmpq $0x40, %rax
jne 0x364f
movq %r14, 0x8(%r15)
movl $0x20, %edi
callq 0x2130
leaq 0x6623(%rip), %rcx      # 0x9c98
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq 0x6abb(%rip), %rdx      # 0xa140
movq %rdx, %rsi
shlq $0x38, %rsi
movq %rdx, %rdi
shlq $0x30, %rdi
orq %rsi, %rdi
movq %rdx, %rsi
shlq $0x28, %rsi
movq %rdx, %r8
shlq $0x20, %r8
orq %rsi, %r8
orq %rdi, %r8
movq %rdx, %rsi
shlq $0x18, %rsi
movq %rdx, %rdi
shlq $0x10, %rdi
orq %rsi, %rdi
movq %rdx, %rsi
shlq $0x8, %rsi
orq %rdi, %rsi
orq %r8, %rsi
orq %rdx, %rsi
movq %rsi, 0x10(%rax)
movq %rcx, 0x18(%rax)
leaq 0x6566(%rip), %rcx      # 0x9c40
movq %rcx, (%rax)
movq %rax, (%r14)
movq %rax, 0x418(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36f6
jmp 0x36f6
movq %rax, %r14
movl $0x408, %r15d           # imm = 0x408
leaq (%rbx,%r15), %rdi
callq 0x410c
addq $-0x10, %r15
cmpq $0x8, %r15
jne 0x36ff
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x418(%rdi), %rdi
testq %rdi, %rdi
je 0x373b
movq 0x18(%rdi), %r14
movq (%rdi), %rax
callq *(%rax)
movq %r14, %rdi
jmp 0x3728
movl $0x408, %r14d           # imm = 0x408
leaq (%rbx,%r14), %rdi
callq 0x410c
addq $-0x10, %r14
cmpq $0x8, %r14
jne 0x3741
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3584
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq (%rsi), %rsi
callq 0x42f2
movq %rax, %r12
movslq (%r15), %rsi
leaq 0x6494(%rip), %rax      # 0x9c98
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movq %rsi, 0x8(%r13)
btsq $0x3f, %rsi
movq %r13, %rdi
callq 0x41fe
movq %rax, 0x10(%r13)
xorl %eax, %eax
movq %rax, 0x18(%r13)
leaq 0x6499(%rip), %rbp      # 0x9cc8
movq %rbp, (%r13)
movl (%r15), %ecx
movl %ecx, 0x20(%r13)
movq %rax, 0x28(%r13)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x51ea
movl %eax, %ebx
movq %rbp, 0x8(%rsp)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x386a
movl $0x4, %esi
callq 0x2140
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rbp, 0x8(%rsp)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3897
movl $0x4, %esi
callq 0x2140
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %rsi
callq 0x42f2
movq %rax, %r15
movslq (%r14), %rsi
leaq 0x63d0(%rip), %rax      # 0x9c98
movq %rsp, %r12
movq %rax, (%r12)
movq %rsi, 0x8(%r12)
btsq $0x3f, %rsi
movq %r12, %rdi
callq 0x41fe
movq %rax, 0x10(%r12)
xorl %eax, %eax
movq %rax, 0x18(%r12)
leaq 0x63d4(%rip), %r13      # 0x9cc8
movq %r13, (%r12)
movl (%r14), %ecx
movl %ecx, 0x20(%r12)
movq %rax, 0x28(%r12)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x52aa
movl %eax, %ebx
movq %r13, (%rsp)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x392d
movl $0x4, %esi
callq 0x2140
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r13, (%rsp)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3958
movl $0x4, %esi
callq 0x2140
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movl %esi, %ebx
movl $0x408, %edi            # imm = 0x408
callq 0x2030
movq %rax, %rcx
movq $0x40, (%rax)
xorl %edx, %edx
movl $0x1, 0x8(%rcx,%rdx)
movq $0x0, 0x10(%rcx,%rdx)
addq $0x10, %rdx
cmpq $0x400, %rdx            # imm = 0x400
jne 0x419f
addq $0x8, %rax
xorl %edx, %edx
movl %ebx, 0x8(%rcx,%rdx)
movq $0x0, 0x10(%rcx,%rdx)
addq $0x10, %rdx
cmpq $0x400, %rdx            # imm = 0x400
jne 0x41c3
popq %rbx
retq
nop