LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/pat.cpp
// Function: VectorPatternSource::nextBatchImpl(PerThreadReadBuf&, bool)
pair<bool, int> VectorPatternSource::nextBatchImpl(
	PerThreadReadBuf& pt,
	bool batch_a)
{
	pt.setReadId(cur_);
	EList<Read>& readbuf = batch_a ? pt.bufa_ : pt.bufb_;
	size_t readi = 0;

	for(; readi < pt.max_buf_ && cur_ < bufs_.size(); readi++, cur_++) {
		readbuf[readi].readOrigBuf.append(bufs_[cur_].c_str());
	}
	readCnt_ += readi;
	return make_pair(cur_ == bufs_.size(), readi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
movq %rcx, 0x50(%rsi)
cmpq $0x0, (%rsi)
je 0x4bb5c
movq %rsi, %r14
xorb $0x1, %dl
movzbl %dl, %eax
shll $0x5, %eax
orq $0x8, %rax
movq %rax, (%rsp)
movl $0x120, %ebp            # imm = 0x120
xorl %r13d, %r13d
cmpq 0x68(%rbx), %rcx
jae 0x4bb5f
movq (%rsp), %rax
movq 0x8(%r14,%rax), %r15
addq %rbp, %r15
movq 0x58(%rbx), %rax
shlq $0x5, %rcx
movq (%rax,%rcx), %r12
movq %r12, %rdi
callq 0x91b0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4e5d4
incq %r13
movq 0x20(%rbx), %rcx
incq %rcx
movq %rcx, 0x20(%rbx)
addq $0x268, %rbp            # imm = 0x268
cmpq (%r14), %r13
jb 0x4bb0c
jmp 0x4bb5f
xorl %r13d, %r13d
addq %r13, 0x8(%rbx)
xorl %eax, %eax
cmpq 0x68(%rbx), %rcx
sete %al
shlq $0x20, %r13
orq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/pat.cpp
// Function: VectorPatternSource::nextBatch(PerThreadReadBuf&, bool, bool)
pair<bool, int> VectorPatternSource::nextBatch(
	PerThreadReadBuf& pt,
	bool batch_a,
	bool lock)
{
	if(lock) {
		ThreadSafe ts(&mutex);
		return nextBatchImpl(pt, batch_a);
	} else {
		return nextBatchImpl(pt, batch_a);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testl %ecx, %ecx
je 0x4bbc9
leaq 0x10(%r15), %rbx
movq %rbx, %rdi
callq 0x4ac58
movzbl %bpl, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4bad4
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ac94
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %edx
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4bad4
jmp 0x4bbf7
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ac94
movq %r14, %rdi
callq 0x9930
movq %rax, %rdi
callq 0x1afa3
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/pat.cpp
// Function: wrongQualityFormat(SStringExpandable<char, 25, 2, 0> const&)
void wrongQualityFormat(const BTString& read_name) {
	cerr << "Encountered a space parsing the quality string for read " << read_name << endl
	     << "If this is a FASTQ file with integer (non-ASCII-encoded) qualities, please" << endl
	     << "re-run Bowtie with the --integer-quals option." << endl;
	throw 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1e0d0(%rip), %rdi     # 0x69ff0
leaq 0xb1d7(%rip), %rsi      # 0x570fe
callq 0x9490
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1fb3f
movq %rax, %rdi
callq 0x91f0
leaq 0xb1f1(%rip), %rsi      # 0x57137
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0xb225(%rip), %rsi      # 0x57182
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
movl $0x4, %edi
callq 0x9200
movl $0x1, (%rax)
movq 0x1dfb4(%rip), %rsi     # 0x69f38
movq %rax, %rdi
xorl %edx, %edx
callq 0x98f0
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./qual.h
// Function: charToPhred33(char, bool, bool)
inline static char charToPhred33(char c, bool solQuals, bool phred64Quals) {
	if(c == ' ') {
		cerr << "Saw a space but expected an ASCII-encoded quality value." << endl
		     << "Are quality values formatted as integers?  If so, try --integer-quals." << endl;
		throw 1;
	}
	if (solQuals) {
		// Convert solexa-scaled chars to phred
		// http://maq.sourceforge.net/fastq.shtml
		char cc = solexaToPhred((int)c - 64) + 33;
		if (cc < 33) {
			cerr << "Saw ASCII character "
			     << ((int)c)
			     << " but expected 64-based Solexa qual (converts to " << (int)cc << ")." << endl
			     << "Try not specifying --solexa-quals." << endl;
			throw 1;
		}
		c = cc;
	}
	else if(phred64Quals) {
		if (c < 64) {
			cerr << "Saw ASCII character "
			     << ((int)c)
			     << " but expected 64-based Phred qual." << endl
			     << "Try not specifying --solexa1.3-quals/--phred64-quals." << endl;
			throw 1;
		}
		// Convert to 33-based phred
		c -= (64-33);
	}
	else {
		// Keep the phred quality
		if (c < 33) {
			cerr << "Saw ASCII character "
			     << ((int)c)
			     << " but expected 33-based Phred qual." << endl;
			throw 1;
		}
	}
	return c;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpb $0x20, %bl
je 0x4c039
movl %ebx, %eax
testb %sil, %sil
je 0x4c01d
cmpb $0x36, %al
movb $0x21, %al
jl 0x4c032
movl %ebx, %eax
addl $-0x36, %eax
leaq 0x20c47(%rip), %rcx     # 0x6cc00
movb (%rcx,%rax), %cl
leal 0x21(%rcx), %eax
cmpb $0x5f, %cl
jb 0x4c032
movsbl %al, %ebp
movq 0x1e022(%rip), %rdi     # 0x69ff0
leaq 0xb3ca(%rip), %rsi      # 0x5739f
callq 0x9490
movq %rax, %rdi
movl %ebx, %esi
callq 0x9910
leaq 0xb3c9(%rip), %rsi      # 0x573b4
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
movl %ebp, %esi
callq 0x9910
leaq 0xa669(%rip), %rsi      # 0x5666d
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0xb3ca(%rip), %rsi      # 0x573e5
jmp 0x4c05b
testb %dl, %dl
je 0x4c02a
cmpb $0x3f, %al
jle 0x4c08c
addl $-0x1f, %eax
jmp 0x4c032
cmpb $0x20, %al
jle 0x4c0c9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x1dfb0(%rip), %rdi     # 0x69ff0
leaq 0xb2d8(%rip), %rsi      # 0x5731f
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0xb2fd(%rip), %rsi      # 0x57358
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
movl $0x4, %edi
callq 0x9200
movl $0x1, (%rax)
movq 0x1deb6(%rip), %rsi     # 0x69f38
movq %rax, %rdi
xorl %edx, %edx
callq 0x98f0
movq 0x1df5d(%rip), %rdi     # 0x69ff0
leaq 0xb305(%rip), %rsi      # 0x5739f
callq 0x9490
movq %rax, %rdi
movl %ebx, %esi
callq 0x9910
leaq 0xb358(%rip), %rsi      # 0x57408
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0xb364(%rip), %rsi      # 0x5742b
jmp 0x4c05b
movq 0x1df20(%rip), %rdi     # 0x69ff0
leaq 0xb2c8(%rip), %rsi      # 0x5739f
callq 0x9490
movq %rax, %rdi
movl %ebx, %esi
callq 0x9910
leaq 0xb374(%rip), %rsi      # 0x57461
jmp 0x4c05b
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x200a3(%rdi)
jne 0x4c1fd
movq %r14, %rdi
callq 0x4dc96
cmpl $-0x1, %eax
je 0x4c2c9
cmpl $0xa, %eax
je 0x4c1e2
cmpl $0xd, %eax
jne 0x4c1ec
movq %r14, %rdi
callq 0x4dc96
jmp 0x4c1d8
cmpl $0x3e, %eax
jne 0x4c2d1
movb $0x0, 0x200a3(%r14)
xorl %eax, %eax
cmpq %r15, (%rbx)
jbe 0x4c2ae
xorb $0x1, %bpl
movzbl %bpl, %ebp
shll $0x5, %ebp
orq $0x8, %rbp
leaq 0x6(%rsp), %r13
movq 0x8(%rbx,%rbp), %rax
imulq $0x268, %r15, %r12      # imm = 0x268
leaq (%rax,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb $0x3e, 0x7(%rsp)
leaq 0x7(%rsp), %rsi
callq 0x4dce6
movq %r14, %rdi
callq 0x4dc96
testl %eax, %eax
sets %cl
cmpl $0x3e, %eax
sete %dl
orb %cl, %dl
jne 0x4c286
movq 0x8(%rbx,%rbp), %rcx
leaq (%rcx,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb %al, 0x6(%rsp)
movq %r13, %rsi
callq 0x4dce6
movq %r14, %rdi
callq 0x4dc96
testl %eax, %eax
js 0x4c286
cmpl $0x3e, %eax
jne 0x4c259
shrl $0x1f, %eax
movq %r15, %rdx
incq %r15
cmpq (%rbx), %r15
jae 0x4c298
testb %al, %al
je 0x4c21c
testb %al, %al
je 0x4c2ae
movq 0x8(%rbx,%rbp), %rcx
cmpq $0x1, 0x140(%rcx,%r12)
cmoveq %rdx, %r15
movl %eax, %eax
shlq $0x20, %r15
orq %rax, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r15d
jmp 0x4c2b7
movq 0x1dd18(%rip), %rdi     # 0x69ff0
leaq 0xadbb(%rip), %rsi      # 0x5709a
callq 0x9490
movq %rax, %rdi
callq 0x91f0
movl $0x4, %edi
callq 0x9200
movl $0x1, (%rax)
movq 0x1dc35(%rip), %rsi     # 0x69f38
movq %rax, %rdi
xorl %edx, %edx
callq 0x98f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4c972
leaq 0x150(%rbx), %r15
leaq 0x7(%rsp), %r12
movb %al, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4dc0a
movq 0x128(%rbx), %rax
movb (%rax,%r14), %al
incq %r14
cmpq %r13, %r14
setb %bpl
cmpb $0x9, %al
je 0x4c972
cmpq %r13, %r14
jb 0x4c945
testb %bpl, %bpl
je 0x4ca51
movq %rbx, 0x8(%rsp)
xorl %r15d, %r15d
cmpq %r13, %r14
jae 0x4c9e5
xorl %ebx, %ebx
movq 0x8(%rsp), %rax
movq 0x128(%rax), %rax
movsbl (%rax,%r14), %r12d
movl %r12d, %edi
callq 0x9800
testl %eax, %eax
je 0x4c9d7
leal 0x1(%rbx), %r15d
movq 0x10(%rsp), %rax
cmpl 0x18(%rax), %ebx
jl 0x4c9da
movslq %r12d, %rax
leaq 0x1fb91(%rip), %rcx     # 0x6c550
movb (%rcx,%rax), %al
movb %al, 0x6(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rsi
callq 0x4dc50
jmp 0x4c9da
movl %ebx, %r15d
incq %r14
movl %r15d, %ebx
cmpq %r14, %r13
jne 0x4c98a
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 0x4ca48
leaq 0x60(%r12), %r14
xorl %ebx, %ebx
leaq 0x5(%rsp), %r15
movb $0x49, 0x5(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4dc0a
incq %rbx
cmpq 0x20(%r12), %rbx
jb 0x4ca2e
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_O3/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 0x4dc96
testl %eax, %eax
js 0x4d1e0
cmpl $0xd, %eax
je 0x4d0d5
cmpl $0xa, %eax
jne 0x4d0da
movq %r15, %rdi
jmp 0x4d0be
cmpq %rbx, (%r14)
jbe 0x4d1e0
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 0x4d14b
cmpl $0xd, %eax
je 0x4d1ac
movq 0x8(%r14,%r13), %rcx
leaq (%rcx,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb %al, 0x7(%rsp)
movq %rbp, %rsi
callq 0x4dce6
movq %r15, %rdi
callq 0x4dc96
testl %eax, %eax
jns 0x4d110
jmp 0x4d1dd
movq 0x8(%r14,%r13), %rax
leaq (%rax,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb $0xa, 0x6(%rsp)
leaq 0x6(%rsp), %rsi
callq 0x4dce6
movq %r15, %rdi
callq 0x4dc96
cmpl $0xd, %eax
jne 0x4d19d
movq 0x8(%r14,%r13), %rax
leaq (%rax,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb $0xd, 0x5(%rsp)
leaq 0x5(%rsp), %rsi
callq 0x4dce6
movl $0xd, %eax
jmp 0x4d1ac
movq %r15, %rdi
movl %eax, %esi
callq 0x4dd28
movl $0xa, %eax
cmpl $0xd, %eax
je 0x4d1b6
cmpl $0xa, %eax
jne 0x4d1cf
movq (%r14), %rcx
decq %rcx
cmpq %rcx, %rbx
jae 0x4d1cf
movq %r15, %rdi
callq 0x4dc96
testl %eax, %eax
jns 0x4d1ac
jmp 0x4d1dd
incq %rbx
cmpq (%r14), %rbx
jb 0x4d0f8
jmp 0x4d1e0
incq %rbx
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_O3/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 0x4dc96
testl %eax, %eax
js 0x4d652
cmpl $0xd, %eax
je 0x4d64d
cmpl $0xa, %eax
jne 0x4d6b8
movq %r15, %rdi
jmp 0x4d63a
xorb $0x1, %bpl
movzbl %bpl, %r13d
shll $0x5, %r13d
orq $0x8, %r13
shrl $0x1f, %eax
movq %rbx, %rdx
shlq $0x20, %rdx
orq %rax, %rdx
imulq $0x268, %rbx, %rcx      # imm = 0x268
addq $-0x128, %rcx           # imm = 0xFED8
incq %rbx
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
movq %rdx, %rax
decq %rbx
je 0x4d6a9
leaq (%rax,%rsi), %rdx
movq 0x8(%r14,%r13), %rdi
cmpq $0x0, (%rdi,%rcx)
leaq -0x268(%rcx), %rcx
je 0x4d68a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorb $0x1, %bpl
movzbl %bpl, %r13d
shll $0x5, %r13d
orq $0x8, %r13
cmpq %rbx, (%r14)
jbe 0x4d662
leaq 0x7(%rsp), %rbp
movq 0x8(%r14,%r13), %rcx
imulq $0x268, %rbx, %r12      # imm = 0x268
movq $0x0, 0x140(%rcx,%r12)
cmpl $0xa, %eax
je 0x4d6f4
cmpl $0xd, %eax
jne 0x4d72d
movq %r15, %rdi
callq 0x4dc96
testl %eax, %eax
jns 0x4d6ea
jmp 0x4d7ab
movq 0x8(%r14,%r13), %rcx
leaq (%rcx,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb %al, 0x7(%rsp)
movq %rbp, %rsi
callq 0x4dce6
movq %r15, %rdi
callq 0x4dc96
testl %eax, %eax
js 0x4d7ab
cmpl $0xa, %eax
je 0x4d739
cmpl $0xd, %eax
jne 0x4d705
jmp 0x4d79a
movq 0x8(%r14,%r13), %rax
leaq (%rax,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb $0xa, 0x6(%rsp)
leaq 0x6(%rsp), %rsi
callq 0x4dce6
movq %r15, %rdi
callq 0x4dc96
cmpl $0xd, %eax
jne 0x4d78b
movq 0x8(%r14,%r13), %rax
leaq (%rax,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb $0xd, 0x5(%rsp)
leaq 0x5(%rsp), %rsi
callq 0x4dce6
movl $0xd, %eax
jmp 0x4d79a
movq %r15, %rdi
movl %eax, %esi
callq 0x4dd28
movl $0xa, %eax
incq %rbx
cmpq (%r14), %rbx
jb 0x4d6d2
jmp 0x4d662
incq %rbx
jmp 0x4d662
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c669(%rip), %rdi     # 0x69ff0
leaq 0x98ef(%rip), %rsi      # 0x5727d
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0x9923(%rip), %rsi      # 0x572c5
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0x994c(%rip), %rsi      # 0x57305
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1fb3f
movq %rax, %rdi
callq 0x91f0
movl $0x4, %edi
callq 0x9200
movl $0x1, (%rax)
movq 0x1c54d(%rip), %rsi     # 0x69f38
movq %rax, %rdi
xorl %edx, %edx
callq 0x98f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
jae 0x4da76
addq $0x150, %rbx            # imm = 0x150
leaq 0x7(%rsp), %rsi
movb $0x2f, (%rsi)
movq %rbx, %rdi
callq 0x4dc0a
movslq %ebp, %rax
leaq 0x98b2(%rip), %rsi      # 0x57316
addq %rax, %rsi
movq %rbx, %rdi
callq 0x4dc0a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x158(%rbx), %rcx
movb -0x2(%rcx,%rax), %dl
cmpl $0x1, %ebp
jne 0x4da94
cmpb $0x2f, %dl
jne 0x4da43
cmpb $0x31, -0x1(%rcx,%rax)
jne 0x4da43
jmp 0x4da6f
cmpb $0x2f, %dl
jne 0x4da43
cmpb $0x32, -0x1(%rcx,%rax)
jne 0x4da43
jmp 0x4da6f
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4db93
movl $0xf000, %eax           # imm = 0xF000
andl 0x38(%rsp), %eax
movb $0x1, %bpl
cmpl $0x1000, %eax           # imm = 0x1000
je 0x4db85
leaq 0x8b8b(%rip), %rsi      # 0x5666e
movl $0x1, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x9a30
leaq 0x10(%rsp), %r14
cmpq $-0x1, %rax
je 0x4db1c
incq %rax
movq %rsp, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x94e0
jmp 0x4db31
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x9b0e(%rip), %rdx      # 0x57637
movq %rdx, %rsi
callq 0x1dbaa
leaq 0x9aff(%rip), %rsi      # 0x57637
movq %rsp, %rdi
callq 0x9140
movb $0x1, %bpl
testl %eax, %eax
je 0x4db6f
leaq 0x97cc(%rip), %rsi      # 0x5731a
movq %rsp, %rdi
callq 0x9140
testl %eax, %eax
je 0x4db6f
leaq 0x97bc(%rip), %rsi      # 0x5731d
movq %rsp, %rdi
callq 0x9140
testl %eax, %eax
sete %bpl
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x4db85
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
movl %ebp, %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4a8f(%rip), %rdi      # 0x52629
callq 0x93e0
jmp 0x4dadc
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4dc80
leaq 0x34(,%rax,2), %rsi
movq %rbx, %rdi
callq 0x252d4
movq 0x20(%rbx), %rax
leaq 0x1(%rax), %rcx
movb (%r14), %dl
movq 0x8(%rbx), %rsi
movq %rcx, 0x20(%rbx)
movb %dl, (%rsi,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4b2de
incq 0x80(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4e4d9
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 0x4e4d0
movq (%rdi), %rax
callq *0x20(%rax)
incq %r14
cmpq 0x28(%rbx), %r14
jb 0x4e4af
movl $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4e520
leaq 0x32(,%rax,2), %rsi
movq %rbx, %rdi
callq 0x252d4
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x4e561
movq $-0x1, %rcx
xorl %edx, %edx
movl $0x4, %esi
addq 0x8(%r14), %rax
movb (%rcx,%rax), %al
movl %eax, %edi
xorb $0x3, %dil
cmpb $0x4, %al
movzbl %dil, %eax
cmovel %esi, %eax
movq 0x8(%rbx), %rdi
movb %al, (%rdi,%rdx)
incq %rdx
movq 0x20(%r14), %rax
decq %rcx
cmpq %rax, %rdx
jb 0x4e533
jmp 0x4e563
xorl %eax, %eax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4e598
leaq 0x32(,%rax,2), %rsi
movq %rbx, %rdi
callq 0x2090c
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x4e5c5
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 0x4e5a6
jmp 0x4e5c7
xorl %eax, %eax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1fb3f
movq %rax, %r15
leaq 0x4277(%rip), %r12      # 0x52fea
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x9560
leaq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x1fb3f
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x9560
leaq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x1fb3f
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 0x4ee0a
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0xa0(%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x4ed03
incq %r12
addq $0x30, %r15
cmpq 0xb0(%r14), %r12
jb 0x4ede8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19c3e(%rip), %rax     # 0x68a80
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x20(%rdi)
leaq 0x8761(%rip), %rsi      # 0x575bd
movl $0x17, %edx
callq 0x4fee0
testb %bl, %bl
jne 0x4ef21
movq $0x0, 0x8(%rsp)
testq %r12, %r12
je 0x4ef21
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 0x8730(%rip), %rsi      # 0x575d5
callq 0x4fee0
movq 0x8(%rsp), %rsi
cmpq 0x18(%r15), %rsi
jae 0x4eec9
shlq $0x5, %rsi
addq 0x8(%r15), %rsi
movq %rbp, %rdi
movl %ebx, %edx
callq 0x4fc12
jmp 0x4eed6
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x4fcda
movl $0x4, %edx
movq %rbp, %rdi
leaq 0x86f8(%rip), %rsi      # 0x575dd
callq 0x4fee0
movq 0x8(%rsp), %rax
leaq (%r14,%rax,4), %rsi
movq %rbp, %rdi
callq 0x4fd81
movb $0xa, 0x7(%rsp)
movq %rax, %rdi
movq %r13, %rsi
callq 0x4dc0a
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
cmpq %r12, %rax
jb 0x4ee96
movq 0x98(%rsp), %rbx
testq %rbx, %rbx
je 0x4ef6e
leaq 0x86ad(%rip), %rsi      # 0x575e2
leaq 0x10(%rsp), %rdi
movl $0x4, %edx
callq 0x4fee0
movq %rbx, %rdi
callq 0x91b0
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x4fee0
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x4dc0a
leaq 0x8672(%rip), %rsi      # 0x575e7
leaq 0x10(%rsp), %rdi
movl $0x11, %edx
callq 0x4fee0
leaq 0x3d4f(%rip), %rsi      # 0x52cda
leaq 0x10(%rsp), %rdi
movl $0x5, %edx
callq 0x4fee0
leaq 0x8658(%rip), %rsi      # 0x575f9
leaq 0x10(%rsp), %rdi
movl $0x5, %edx
callq 0x4fee0
movq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0x91b0
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x4fee0
leaq 0x8628(%rip), %rsi      # 0x575ff
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
callq 0x4fee0
leaq 0x10(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0x20b3e
leaq 0x10(%rsp), %rdi
callq 0x250d6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f010
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x250d6
movq %rbx, %rdi
callq 0x9930
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fc92
leaq 0x7a09(%rip), %rsi      # 0x57635
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x9770
cmpq $-0x1, %rax
je 0x4fc92
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 0x4fee0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fc88
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 0x4fee0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fcd2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O3/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 0x77ae(%rip), %rdi      # 0x574a4
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 0x4fd00
movq %rsp, %rax
cmpq %rax, %rsi
jbe 0x4fd56
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 0x4fd3b
movb $0x0, 0x1(%rsi)
movq %rsp, %r14
movq %r14, %rdi
callq 0x91b0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4fee0
movq %rbx, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7566(%rip), %r8       # 0x574a4
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 0x4ff41
cmpl $0x0, (%rdi)
jns 0x4ff77
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 0x4ffaf
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 0x4ff94
movb $0x0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x257f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
subq %rcx, %rdx
je 0x2553
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %eax, %eax
movq (%rcx,%rax,8), %rsi
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x2573
incq %rax
cmpq %rax, %rdx
jne 0x253e
movq %r14, %rdi
callq 0x2586
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
subq %rcx, %rax
shrq $0x3, %rax
decl %eax
movslq %eax, %rdx
movq (%rcx,%rdx,8), %rsi
movq %rbx, 0x8(%rsi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25b3
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x259c
movq (%rsp), %rax
jmp 0x25b7
movq %rax, (%rsp)
testq %rax, %rax
jne 0x25f1
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), %rax
movq %rax, %rdx
xchgq %rdx, 0x10(%rcx)
lock
cmpxchgq %rcx, (%r14)
jne 0x25e3
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x2609
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x2618
addq $0x8, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x3f3e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2719
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 0x26a3
movq %r15, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3c38
movq 0x10(%rbp), %rbp
testq %rbp, %rbp
jne 0x2683
movq 0x30(%rbx), %r15
testq %r15, %r15
je 0x270f
leaq 0x10(%rsp), %r12
movq %rsp, %r13
leaq 0x8(%r15), %rsi
movq %r12, %rdi
callq 0x3ee2
testq %rax, %rax
je 0x26d3
movq (%r15), %r15
jmp 0x270a
movq 0x10(%r15), %rbp
movq (%rbp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x20(%rbp)
je 0x2728
leaq 0x10(%rbp), %rdi
movq %r13, %rsi
callq *0x28(%rbp)
movq 0x58(%rbx), %rax
movq %rax, 0x8(%rbp)
movq %rbp, 0x58(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3b80
movq %rax, %r15
testq %r15, %r15
jne 0x26bd
leaq 0x10(%rsp), %rdi
callq 0x3aa0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
jmp 0x2735
jmp 0x2735
jmp 0x2735
jmp 0x2735
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3aa0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8633(%rip), %al       # 0xad8c
testb $0x1, %al
jne 0x2764
callq 0x21b0
jmp 0x2753
movl 0x81fa(%rip), %eax      # 0xa964
cltd
idivl %ebx
testl %eax, %eax
jle 0x27aa
movl %eax, %ebx
leaq 0x81ee(%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 0x36e0
testb %al, %al
je 0x27a6
lock
incl 0x85e2(%rip)            # 0xad88
decl %ebp
jne 0x2781
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x85c3(%rip), %al       # 0xad8c
testb $0x1, %al
jne 0x27d4
callq 0x21b0
jmp 0x27c3
movl 0x818a(%rip), %eax      # 0xa964
cltd
idivl %ebx
testl %eax, %eax
jle 0x2814
movl %eax, %ebx
leaq 0x817e(%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 0x374e
decl %ebp
jne 0x27f6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x855c(%rip), %al       # 0xad8c
testb $0x1, %al
jne 0x283b
callq 0x21b0
jmp 0x282a
movl 0x8123(%rip), %eax      # 0xa964
cltd
idivl %ebx
testl %eax, %eax
jle 0x287e
movl %eax, %ebx
leaq 0x8117(%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 0x3816
testb %al, %al
je 0x287a
lock
decl 0x850e(%rip)            # 0xad88
decl %ebp
jne 0x2858
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x683b(%rip), %rax      # 0x9c10
movq %rax, (%rdi)
movq 0x8(%rdi), %rcx
cmpq %rcx, 0x10(%rdi)
je 0x3410
xorl %eax, %eax
movq (%rcx,%rax,8), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
jne 0x34d9
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 0x33e4
leaq 0x20(%rbx), %r14
movq 0x30(%rbx), %r12
movq %rsp, %r15
testq %r12, %r12
je 0x349f
movq 0x8(%r12), %rax
movq 0x60(%rbx), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rdx
cmpq %rdx, %rax
je 0x3440
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x342c
jmp 0x3447
callq 0x21b0
jmp 0x3420
movq 0x10(%r12), %r13
movq (%r13), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x20(%r13)
je 0x34d4
leaq 0x10(%r13), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq *0x28(%r13)
movq 0x20(%r13), %rax
testq %rax, %rax
je 0x347f
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 0x3b80
movq %rax, %r12
jmp 0x341b
leaq 0x58(%rbx), %rdi
callq 0x3510
movq %r14, %rdi
callq 0x3a30
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x34c5
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 0x2b38(%rip), %rdi      # 0x6018
leaq 0x2b6d(%rip), %rsi      # 0x6054
leaq 0x2b82(%rip), %rcx      # 0x6070
movl $0x9b, %edx
callq 0x20c0
jmp 0x34fc
jmp 0x34fc
movq %rax, %rdi
callq 0x3504
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3552
movq %rdi, %rbx
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x353d
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 0x351f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3504
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3580
leaq 0x18(%rbx), %r14
movl $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40f4
movq %rax, %r15
movq %rax, 0x8(%r14)
incl %ebp
movq %rax, %r14
cmpl $0x4, %ebp
jne 0x35a5
movl $0x200, %edi            # imm = 0x200
callq 0x2030
movq %rax, %r14
xorl %eax, %eax
movq $0x0, (%r14,%rax,8)
incq %rax
cmpq $0x40, %rax
jne 0x35cf
movq %r14, 0x8(%r15)
movl $0x20, %edi
callq 0x2130
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq 0x6b45(%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 0x65f0(%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 0x366c
jmp 0x366c
movq %rax, %r14
movl $0x408, %r15d           # imm = 0x408
leaq (%rbx,%r15), %rdi
callq 0x407a
addq $-0x10, %r15
cmpq $0x8, %r15
jne 0x3675
movq %r14, %rdi
callq 0x2230