LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/bowtie_inspect.cpp
// Function: print_index_sequence_names(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::ostream&)
void print_index_sequence_names(const string& fname, ostream& fout)
{
	EList<string> p_refnames;
	readEbwtRefnames(fname, p_refnames);
	for(size_t i = 0; i < p_refnames.size(); i++) {
		cout << p_refnames[i] << endl;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rsp, %rsi
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
movq $0x80, 0x10(%rsi)
andq $0x0, 0x18(%rsi)
callq 0xa7c4
xorl %ebx, %ebx
movq %rsp, %r14
movq 0x29845(%rip), %r15     # 0x33fb8
cmpq 0x18(%rsp), %rbx
jae 0xa79d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x140da
movq %r15, %rdi
movq %rax, %rsi
callq 0x4270
movq %rax, %rdi
callq 0x4130
incq %rbx
jmp 0xa773
movq %rsp, %rdi
callq 0x141a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xa7b1
movq %rax, %rbx
movq %rsp, %rdi
callq 0x141a0
movq %rbx, %rdi
callq 0x45e0
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./word_io.h
// Function: int readI<int>(std::istream&, bool)
static inline T readI(std::istream& in, bool swap) {
	T x;
	in.read((char *)&x, sizeof(T));
	assert_eq(sizeof(T), in.gcount());
	if(swap) {
		if(sizeof(T) == 4) {
			return endianSwapI32(x);
		} else if(sizeof(T) == 8) {
			return endianSwapI64(x);
		} else {
			assert(false);
		}
	} else {
		return x;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x43c0
cmpq $0x4, 0x8(%r14)
jne 0xc525
movl 0x4(%rsp), %ecx
movl %ecx, %eax
bswapl %eax
testb %bl, %bl
cmovel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x27a8c(%rip), %rbx     # 0x33fb8
leaq 0x1bc26(%rip), %rsi     # 0x28159
movq %rbx, %rdi
callq 0x42d0
pushq $0x4
popq %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b0
leaq 0x1bc1e(%rip), %r15     # 0x2816f
movq %rax, %rdi
movq %r15, %rsi
callq 0x42d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0x1bbdc(%rip), %rsi     # 0x28174
movq %rax, %rdi
callq 0x42d0
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x4610
movq %rax, %rdi
movq %r15, %rsi
callq 0x42d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x4610
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0x1de24(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x1d694(%rip), %r14     # 0x29c9f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
leaq 0x1d11e(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
pushq $0x5d
popq %rbx
movq %rax, %rdi
movl %ebx, %esi
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x1cfda(%rip), %rdi     # 0x2961b
leaq 0x1defc(%rip), %rcx     # 0x2a544
movq %r14, %rsi
movl %ebx, %edx
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./multikey_qsort.h
// Function: void swap<unsigned long, unsigned long>(unsigned long*, unsigned long, unsigned long, unsigned long)
static inline void swap(TVal* s, size_t slen, TPos a, TPos b) {
	assert_lt(a, slen);
	assert_lt(b, slen);
	TVal tmp = s[a];
	s[a] = s[b];
	s[b] = tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %rbx
cmpq %rsi, %rdx
jae 0xca6f
movq %rcx, %r15
cmpq %rbx, %rcx
jae 0xcae6
movq (%rdi,%r12,8), %rax
movq (%rdi,%r15,8), %rcx
movq %rcx, (%rdi,%r12,8)
movq %rax, (%rdi,%r15,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x27542(%rip), %r14     # 0x33fb8
leaq 0x1b80a(%rip), %rsi     # 0x28287
movq %r14, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b0
leaq 0x1b806(%rip), %rsi     # 0x2829d
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x1d967(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x1e255(%rip), %rbx     # 0x2ad1d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42d0
leaq 0x1cc61(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
pushq $0x21
jmp 0xcb5b
movq 0x274cb(%rip), %r14     # 0x33fb8
leaq 0x1b793(%rip), %rsi     # 0x28287
movq %r14, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
leaq 0x1b78f(%rip), %rsi     # 0x2829d
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x1d8f0(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x1e1de(%rip), %rbx     # 0x2ad1d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42d0
leaq 0x1cbea(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
pushq $0x22
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x1caa6(%rip), %rdi     # 0x2961b
leaq 0x1ec07(%rip), %rcx     # 0x2b783
movq %rbx, %rsi
movl %ebp, %edx
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./sstring.h
// Function: bool sstr_suf_lt<S2bDnaString, S2bDnaString>(S2bDnaString const&, unsigned long, unsigned long, S2bDnaString const&, unsigned long, unsigned long, bool)
static inline bool sstr_suf_lt(
	const T1& s1, size_t suf1, size_t len1,
	const T2& s2, size_t suf2, size_t len2,
	bool endlt = true)
{
	assert_leq(suf1, len1);
	assert_leq(suf2, len2);
	size_t left1 = len1 - suf1;
	size_t left2 = len2 - suf2;
	size_t minleft = (left1 < left2 ? left1 : left2);
	for(size_t i = 0; i < minleft; i++) {
		if(s1[suf1+i] < s2[suf2+i]) {
			return true;
		} else if(s1[suf1+i] > s2[suf2+i]) {
			return false;
		}
	}
	if(left1 == left2) return false;
	return (left1 < left2) == endlt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rsi, %r14
movq %rdx, %rax
subq %rsi, %rax
jb 0xd131
movq %r9, %r13
movq %r8, %rbx
movq %r9, %r15
subq %r8, %r15
jb 0xd1d7
movq %rdi, %r12
cmpq %r15, %rax
movq %r15, (%rsp)
movq %rax, 0x8(%rsp)
cmovbq %rax, %r15
subq $0x1, %r15
jb 0xd113
movq %r12, %rdi
movq %r14, %rsi
callq 0x22204
movl %eax, %ebp
movq 0x10(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x22204
cmpb %al, %bpl
setl %bpl
jl 0xd120
movq %r12, %rdi
movq %r14, %rsi
callq 0x22204
movq %r13, %rdi
movl %eax, %r13d
movq %rbx, %rsi
callq 0x22204
incq %r14
incq %rbx
cmpb %al, %r13b
jle 0xd0c1
jmp 0xd120
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
seta %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbp
movq 0x26e7d(%rip), %rbx     # 0x33fb8
leaq 0x1b0a1(%rip), %rsi     # 0x281e3
movq %rbx, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
leaq 0x1b09e(%rip), %rsi     # 0x281fa
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x40b0
leaq 0x1d2a2(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x1e094(%rip), %r14     # 0x2b221
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
leaq 0x1c59c(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0xcc, %esi
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x1c458(%rip), %rdi     # 0x2961b
leaq 0x1e11e(%rip), %rcx     # 0x2b2e8
movq %r14, %rsi
movl $0xcc, %edx
callq 0x4190
movq 0x26dda(%rip), %r14     # 0x33fb8
leaq 0x1affe(%rip), %rsi     # 0x281e3
movq %r14, %rdi
callq 0x42d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x1affb(%rip), %rsi     # 0x281fa
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r13, %rsi
callq 0x40b0
leaq 0x1d1ff(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x1dff1(%rip), %rbx     # 0x2b221
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42d0
leaq 0x1c4f9(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0xcd, %esi
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x1c3b5(%rip), %rdi     # 0x2961b
leaq 0x1e07b(%rip), %rcx     # 0x2b2e8
movq %rbx, %rsi
movl $0xcd, %edx
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./multikey_qsort.h
// Function: void mkeyQSortSuf<S2bDnaString>(S2bDnaString const&, unsigned long*, unsigned long, int, bool, bool, unsigned long)
void mkeyQSortSuf(
	const T& host,
	TIndexOffU *s,
	size_t slen,
	int hi,
	bool verbose = false,
	bool sanityCheck = false,
	size_t upto = OFF_MASK)
{
	size_t hlen = host.length();
	assert_gt(slen, 0);
	if(sanityCheck) sanityCheckInputSufs(s, slen);
	mkeyQSortSuf(host, hlen, s, slen, hi, (size_t)0, slen, (size_t)0, upto);
	if(sanityCheck) sanityCheckOrderedSufs(host, hlen, s, slen, upto);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdx, %rdx
je 0xd4f4
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x50(%rsp), %r13
movq 0x18(%rdi), %r12
testb %r9b, %r9b
je 0xd4bf
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc652
andq $0x0, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq %rbx, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x23ce2
orq $-0x1, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
xorl %r9d, %r9d
callq 0x203db
jmp 0xd4e5
andq $0x0, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq %rbx, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x23ce2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x26abd(%rip), %rbx     # 0x33fb8
leaq 0x1ac36(%rip), %rsi     # 0x28138
movq %rbx, %rdi
callq 0x42d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x40b0
leaq 0x1ac33(%rip), %rsi     # 0x2814e
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x45d0
leaq 0x1cee4(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x1d7d2(%rip), %r14     # 0x2ad1d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
leaq 0x1c1de(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0x1e1, %esi            # imm = 0x1E1
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x1c09a(%rip), %rdi     # 0x2961b
leaq 0x1e3d2(%rip), %rcx     # 0x2b95a
movq %r14, %rsi
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x4190
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./sstring.h
// Function: SString<char>::resize(unsigned long)
void resize(size_t sz) {
		if(cs_ != NULL) {
			delete cs_;
			cs_ = NULL;
		}
		if(printcs_ != NULL) {
			delete printcs_;
			printcs_ = NULL;
		}
		if(sz != 0) {
			cs_ = new T[sz+1];
		}
		len_ = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xdda4
pushq $0x1
popq %rsi
callq 0x4300
andq $0x0, 0x8(%r14)
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xddba
pushq $0x1
popq %rsi
callq 0x4300
andq $0x0, 0x10(%r14)
testq %rbx, %rbx
je 0xddcc
leaq 0x1(%rbx), %rdi
callq 0x4030
movq %rax, 0x8(%r14)
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./sstring.h
// Function: SString<char>::~SString()
virtual ~SString() {
		if(cs_ != NULL) {
			delete[] cs_;
			cs_ = NULL;
		}
		if(printcs_ != NULL) {
			delete[] printcs_;
			printcs_ = NULL;
		}
		len_ = 0;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x255cd(%rip), %rax     # 0x33cc8
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe711
callq 0x43d0
andq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xe724
callq 0x43d0
andq $0x0, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: is_fread_err(_IO_FILE*, unsigned long, unsigned long)
inline bool is_fread_err(FILE* file_hd, size_t ret, size_t count){
	if (ferror(file_hd)) {
		gLastIOErrMsg = "Error Reading File!";
		return true;
	}
	return false;
}

// Assembly:
pushq %rbx
callq 0x4650
movl %eax, %ebx
testl %eax, %eax
je 0xf33c
leaq 0x26df0(%rip), %rdi     # 0x36120
leaq 0x1a272(%rip), %rsi     # 0x295a9
callq 0x4670
testl %ebx, %ebx
setne %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./bitset.h
// Function: Bitset::Bitset(unsigned long, char const*)
Bitset(TIndexOffU sz, const char *errmsg = NULL) : _errmsg(errmsg) {
		TIndexOffU nwords = (sz / WORD_SIZE)+1;
		try {
			_words = new TIndexOffU[nwords];
		} catch(std::bad_alloc& ba) {
			if(_errmsg != NULL) {
				std::cerr << _errmsg;
			}
			throw 1;
		}
		assert(_words != NULL);
		memset(_words, 0, nwords * OFF_SIZE);
		_sz = nwords * WORD_SIZE;
		_cnt = 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x8(%rdi)
shrq $0x6, %r14
leaq 0x8(,%r14,8), %r15
movq %r15, %rdi
callq 0x4030
incq %r14
movq %rax, 0x18(%rbx)
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4160
shlq $0x6, %r14
movq %r14, 0x10(%rbx)
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0xf9ef
movq %r14, %rdi
callq 0x4110
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0xf9c8
movq 0x2462d(%rip), %rdi     # 0x33ff0
callq 0x42d0
pushq $0x4
popq %rdi
callq 0x4140
movl $0x1, (%rax)
movq 0x24593(%rip), %rsi     # 0x33f70
movq %rax, %rdi
xorl %edx, %edx
callq 0x45b0
movq %rax, %r14
callq 0x4540
movq %r14, %rdi
callq 0x45e0
movq %rax, %rdi
callq 0xdd58
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./bitset.h
// Function: Bitset::set(unsigned long)
void set(TIndexOffU i) {
		while(i >= _sz) {
			// Slow path: bitset needs to be expanded before the
			// specified bit can be set
			ASSERT_ONLY(TIndexOffU oldsz = _sz);
			expand();
			assert_gt(_sz, oldsz);
		}
		// Fast path
		assert(((_words[i / WORD_SIZE] >> (i & BITSET_MASK)) & 1) == 0);
		_cnt++;
		_words[i / WORD_SIZE] |= ((TIndexOffU)1 << (i & BITSET_MASK));
		assert(((_words[i / WORD_SIZE] >> (i & BITSET_MASK)) & 1) == 1);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %r14, %rax
ja 0xfad0
movq %rax, %r15
movq %rbx, %rdi
callq 0x1a5ce
movq 0x10(%rbx), %rax
cmpq %r15, %rax
ja 0xfa0f
movq 0x24585(%rip), %r14     # 0x33fb8
leaq 0x186fe(%rip), %rsi     # 0x28138
movq %r14, %rdi
callq 0x42d0
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x40b0
leaq 0x186f9(%rip), %rsi     # 0x2814e
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
leaq 0x1a9a9(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x19b37(%rip), %rbx     # 0x295bd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42d0
leaq 0x19ca3(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0xd3, %esi
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x19b5f(%rip), %rdi     # 0x2961b
leaq 0x19b05(%rip), %rcx     # 0x295c8
movq %rbx, %rsi
movl $0xd3, %edx
callq 0x4190
movq 0x18(%rbx), %rdx
movq %r14, %rax
shrq $0x6, %rax
movq (%rdx,%rax,8), %rdi
pushq $0x1
popq %rsi
movl %r14d, %ecx
shlq %cl, %rsi
btq %r14, %rdi
jb 0xfb05
incq (%rbx)
orq %rsi, (%rdx,%rax,8)
movq 0x18(%rbx), %rcx
testq %rsi, (%rcx,%rax,8)
je 0xfb24
popq %rbx
popq %r14
popq %r15
retq
leaq 0x19ad9(%rip), %rdi     # 0x295e5
leaq 0x19aaa(%rip), %rsi     # 0x295bd
leaq 0x19aae(%rip), %rcx     # 0x295c8
movl $0xd6, %edx
callq 0x4190
leaq 0x19af2(%rip), %rdi     # 0x2961d
leaq 0x19a8b(%rip), %rsi     # 0x295bd
leaq 0x19a8f(%rip), %rcx     # 0x295c8
movl $0xd9, %edx
callq 0x4190
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::postReadInit(EbwtParams&)
void postReadInit(EbwtParams& eh) {
		TIndexOffU sideNum     = _zOff / eh._sideBwtLen;
		TIndexOffU sideCharOff = _zOff % eh._sideBwtLen;
		TIndexOffU sideByteOff = sideNum * eh._sideSz;
		_zEbwtByteOff = sideCharOff >> 2;
		assert_lt(_zEbwtByteOff, eh._sideBwtSz);
		_zEbwtBpOff = sideCharOff & 3;
		assert_lt(_zEbwtBpOff, 4);
		if(!eh._isBt2Index && (sideNum & 1) == 0) {
			// This is an even (backward) side
			_zEbwtByteOff = eh._sideBwtSz - _zEbwtByteOff - 1;
			_zEbwtBpOff = 3 - _zEbwtBpOff;
			assert_lt(_zEbwtBpOff, 4);
		}
		_zEbwtByteOff += sideByteOff;
		assert(repOk(eh)); // Ebwt should be fully initialized now
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rax
movl 0x84(%rsi), %ecx
movl 0x8c(%rsi), %esi
xorl %edx, %edx
divq %rsi
movl %edx, %esi
shrl $0x2, %esi
movq %rsi, 0x70(%rdi)
movl 0x88(%rbx), %edi
cmpq %rdi, %rsi
jae 0xfbd2
imulq %rax, %rcx
andl $0x3, %edx
movq %rdx, 0x78(%r14)
testb $0x1, %al
jne 0xfbb2
cmpb $0x0, 0xb9(%rbx)
jne 0xfbb2
movl 0x88(%rbx), %eax
notq %rsi
addq %rax, %rsi
xorq $0x3, %rdx
movq %rdx, 0x78(%r14)
addq %rcx, %rsi
movq %rsi, 0x70(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a766
testb %al, %al
je 0xfc79
popq %rbx
popq %r14
popq %r15
retq
movq 0x243df(%rip), %r15     # 0x33fb8
leaq 0x186a7(%rip), %rsi     # 0x28287
movq %r15, %rdi
callq 0x42d0
movq 0x70(%r14), %rsi
movq %rax, %rdi
callq 0x40b0
leaq 0x186a2(%rip), %rsi     # 0x2829d
movq %rax, %rdi
callq 0x42d0
movl 0x88(%rbx), %esi
movq %rax, %rdi
callq 0x4400
leaq 0x1a800(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x184ce(%rip), %rbx     # 0x280fd
movq %r15, %rdi
movq %rbx, %rsi
callq 0x42d0
leaq 0x19afa(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0x418, %esi            # imm = 0x418
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x199b6(%rip), %rdi     # 0x2961b
leaq 0x19a2d(%rip), %rcx     # 0x29699
movq %rbx, %rsi
movl $0x418, %edx            # imm = 0x418
callq 0x4190
leaq 0x19a3f(%rip), %rdi     # 0x296bf
leaq 0x18476(%rip), %rsi     # 0x280fd
leaq 0x19a0b(%rip), %rcx     # 0x29699
movl $0x422, %edx            # imm = 0x422
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::~Ebwt()
~Ebwt() {
		// Only free buffers if we're *not* using memory-mapped files
		if(!_useMm) {
			// Delete everything that was allocated in read(false, ...)
			if(_fchr    != NULL) delete[] _fchr;
			if(_ftab    != NULL) delete[] _ftab;
			if(_eftab   != NULL) delete[] _eftab;
			if(_offs != NULL && !useShmem_)
				delete[] _offs;
			else if(_offs != NULL && useShmem_)
				FREE_SHARED(_offs);
			if(_isa     != NULL) delete[] _isa;
			if(_plen    != NULL) delete[] _plen;
			if(_rstarts != NULL) delete[] _rstarts;
			if(_ebwt != NULL && !useShmem_)
				delete[] _ebwt;
			else if(_ebwt != NULL && useShmem_)
				FREE_SHARED(_ebwt);
		}
		if (_in1 != NULL) fclose(_in1);
		if (_in2 != NULL) fclose(_in2);
#ifdef EBWT_STATS
		cout << (_fw ? "Forward index:" : "Mirror index:") << endl;
		cout << "  mapLFEx:   " << mapLFExs_ << endl;
		cout << "  mapLF:     " << mapLFs_   << endl;
		cout << "  mapLF(c):  " << mapLFcs_  << endl;
		cout << "  mapLF1(c): " << mapLF1cs_ << endl;
		cout << "  mapLF(c):  " << mapLF1s_  << endl;
#endif
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xd0(%rdi)
jne 0x14955
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x148be
callq 0x43d0
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x148cf
callq 0x43d0
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x148e0
callq 0x43d0
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x14901
cmpb $0x0, 0xd1(%rbx)
je 0x148fc
callq 0x4640
jmp 0x14901
callq 0x43d0
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x14912
callq 0x43d0
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x14923
callq 0x43d0
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x14934
callq 0x43d0
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x14955
cmpb $0x0, 0xd1(%rbx)
je 0x14950
callq 0x4640
jmp 0x14955
callq 0x43d0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x14963
callq 0x42e0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x14971
callq 0x42e0
leaq 0xd8(%rbx), %rdi
callq 0x141a0
leaq 0x48(%rbx), %rdi
callq 0x46c8
addq $0x28, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x46c8
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::ftabHi(unsigned long*, unsigned long*, unsigned long, unsigned long, unsigned long, unsigned long)
static TIndexOffU ftabHi(TIndexOffU *ftab,
			TIndexOffU *eftab,
			TIndexOffU len,
			TIndexOffU ftabLen,
			TIndexOffU eftabLen,
			TIndexOffU i)
	{
		assert_lt(i, ftabLen);
		if(ftab[i] <= len) {
			return ftab[i];
		} else {
			TIndexOffU efIdx = ftab[i] ^ OFF_MASK;
			assert_lt(efIdx*2+1, eftabLen);
			return eftab[efIdx*2+1];
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %r15
cmpq %rcx, %r9
jae 0x149cb
movq (%rdi,%r15,8), %rax
cmpq %rdx, %rax
jbe 0x149c5
movq %r8, %rbx
notq %rax
leaq 0x1(,%rax,2), %r15
cmpq %r8, %r15
jae 0x14a71
movq (%rsi,%r15,8), %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rcx, %r14
movq 0x1f5e3(%rip), %rbx     # 0x33fb8
leaq 0x138ab(%rip), %rsi     # 0x28287
movq %rbx, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
leaq 0x138a7(%rip), %rsi     # 0x2829d
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
leaq 0x15a08(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x136d6(%rip), %r14     # 0x280fd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
leaq 0x14d02(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0x3e0, %esi            # imm = 0x3E0
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x14bbe(%rip), %rdi     # 0x2961b
leaq 0x145dd(%rip), %rcx     # 0x29041
movq %r14, %rsi
movl $0x3e0, %edx            # imm = 0x3E0
callq 0x4190
movq 0x1f540(%rip), %r14     # 0x33fb8
leaq 0x13808(%rip), %rsi     # 0x28287
movq %r14, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
leaq 0x13804(%rip), %rsi     # 0x2829d
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x15965(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x13633(%rip), %rbx     # 0x280fd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42d0
leaq 0x14c5f(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0x3e5, %esi            # imm = 0x3E5
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x14b1b(%rip), %rdi     # 0x2961b
leaq 0x1453a(%rip), %rcx     # 0x29041
movq %rbx, %rsi
movl $0x3e5, %edx            # imm = 0x3E5
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::ftabLo(unsigned long*, unsigned long*, unsigned long, unsigned long, unsigned long, unsigned long)
static TIndexOffU ftabLo(TIndexOffU *ftab,
			TIndexOffU *eftab,
			TIndexOffU len,
			TIndexOffU ftabLen,
			TIndexOffU eftabLen,
			TIndexOffU i)
	{
		assert_lt(i, ftabLen);
		if(ftab[i] <= len) {
			return ftab[i];
		} else {
			TIndexOffU efIdx = ftab[i] ^ OFF_MASK;
			assert_lt(efIdx*2+1, eftabLen);
			return eftab[efIdx*2];
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %r15
cmpq %rcx, %r9
jae 0x14b4e
movq (%rdi,%r15,8), %rax
cmpq %rdx, %rax
jbe 0x14b48
movq %r8, %rbx
notq %rax
leaq 0x1(,%rax,2), %r15
cmpq %r8, %r15
jae 0x14bf4
addq %rax, %rax
movq (%rsi,%rax,8), %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rcx, %r14
movq 0x1f460(%rip), %rbx     # 0x33fb8
leaq 0x13728(%rip), %rsi     # 0x28287
movq %rbx, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
leaq 0x13724(%rip), %rsi     # 0x2829d
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
leaq 0x15885(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x13553(%rip), %r14     # 0x280fd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
leaq 0x14b7f(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0x402, %esi            # imm = 0x402
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x14a3b(%rip), %rdi     # 0x2961b
leaq 0x144c5(%rip), %rcx     # 0x290ac
movq %r14, %rsi
movl $0x402, %edx            # imm = 0x402
callq 0x4190
movq 0x1f3bd(%rip), %r14     # 0x33fb8
leaq 0x13685(%rip), %rsi     # 0x28287
movq %r14, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
leaq 0x13681(%rip), %rsi     # 0x2829d
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
leaq 0x157e2(%rip), %rsi     # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x134b0(%rip), %rbx     # 0x280fd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42d0
leaq 0x14adc(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0x407, %esi            # imm = 0x407
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x14998(%rip), %rdi     # 0x2961b
leaq 0x14422(%rip), %rcx     # 0x290ac
movq %rbx, %rsi
movl $0x407, %edx            # imm = 0x407
callq 0x4190
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: USE_POPCNT_GENERIC::pop64(unsigned long)
inline static int pop64(uint64_t x) {
   x = x - ((x >> 1) & 0x5555555555555555llu);
   x = (x & 0x3333333333333333llu) + ((x >> 2) & 0x3333333333333333llu);
   x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0Fllu;
   x = x + (x >> 8);
   x = x + (x >> 16);
   x = x + (x >> 32);
   return x & 0x3F;
}

// Assembly:
movq %rdi, %rax
shrq %rax
movabsq $0x5555555555555555, %rcx # imm = 0x5555555555555555
andq %rax, %rcx
subq %rcx, %rdi
movabsq $0x3333333333333333, %rax # imm = 0x3333333333333333
movq %rdi, %rcx
andq %rax, %rcx
shrq $0x2, %rdi
andq %rdi, %rax
addq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
addq %rax, %rcx
movabsq $0xf0f0f0f0f0f0f0f, %rax # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
addq %rax, %rcx
movq %rcx, %rdx
shrq $0x10, %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x20, %rax
addl %edx, %eax
andl $0x3f, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::repOk(EbwtParams const&) const
bool repOk(const EbwtParams& eh) const {
		assert(_eh.repOk());
		if(isInMemory()) {
			return inMemoryRepOk(eh);
		}
		return true;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x108, %rdi            # imm = 0x108
callq 0xffd2
testb %al, %al
je 0x1a7a8
movq %r14, %rdi
callq 0xd5d2
testb %al, %al
je 0x1a79e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a7c8
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xe4ce(%rip), %rdi      # 0x28c7d
leaq 0xd947(%rip), %rsi      # 0x280fd
leaq 0xef0c(%rip), %rcx      # 0x296c9
movl $0x49f, %edx            # imm = 0x49F
callq 0x4190
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ref_read.h
// Function: RefRecord::RefRecord(_IO_FILE*, bool)
RefRecord(FILE *in, bool swap) {
		assert(in != NULL);
		if(!fread(&off, OFF_SIZE, 1, in)) {
			cerr << "Error reading RefRecord offset from FILE" << endl;
			throw 1;
		}
		if(swap) off = endianSwapU(off);
		if(!fread(&len, OFF_SIZE, 1, in)) {
			cerr << "Error reading RefRecord offset from FILE" << endl;
			throw 1;
		}
		if(swap) len = endianSwapU(len);
		first = fgetc(in) ? true : false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1b2ae
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x44b0
testq %rax, %rax
je 0x1b274
testb %bpl, %bpl
je 0x1b233
movq (%rbx), %rax
bswapq %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %r15
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x44b0
testq %rax, %rax
je 0x1b274
testb %bpl, %bpl
je 0x1b25b
movq (%r15), %rax
bswapq %rax
movq %rax, (%r15)
movq %r14, %rdi
callq 0x44f0
testl %eax, %eax
setne 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18d75(%rip), %rdi     # 0x33ff0
leaq 0xeb4d(%rip), %rsi      # 0x29dcf
callq 0x42d0
movq %rax, %rdi
callq 0x4130
pushq $0x4
popq %rdi
callq 0x4140
movl $0x1, (%rax)
movq 0x18ccc(%rip), %rsi     # 0x33f70
movq %rax, %rdi
xorl %edx, %edx
callq 0x45b0
leaq 0xef81(%rip), %rdi      # 0x2a236
leaq 0xeae3(%rip), %rsi      # 0x29d9f
leaq 0xeae9(%rip), %rcx      # 0x29dac
pushq $0x40
popq %rdx
callq 0x4190
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ds.h
// Function: EList<RefRecord, 128>::expandCopy(unsigned long)
void expandCopy(size_t thresh) {
		if(thresh <= sz_) return;
		size_t newsz = (sz_ * 2)+1;
		while(newsz < thresh) newsz *= 2;
		expandCopyExact(newsz);
	}

// Assembly:
movq 0x10(%rdi), %rax
cmpq %rsi, %rax
jae 0x1b8aa
leaq 0x1(,%rax,2), %rcx
movq %rcx, %rax
addq %rcx, %rcx
cmpq %rsi, %rax
jb 0x1b897
movq %rax, %rsi
jmp 0x1b8f8
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ds.h
// Function: EList<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 128>::alloc(unsigned long)
T *alloc(size_t sz) {
		T* tmp = new T[sz];
		assert(tmp != NULL);
#ifdef USE_MEM_TALLY
		gMemTally.add(cat_, sz);
#endif
		allocCat_ = cat_;
		return tmp;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x3b, %rax
movq %rsi, %r15
shlq $0x5, %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
orq $0x8, %rdi
callq 0x4030
movq %rax, %rcx
movq %r14, (%rax)
addq $0x8, %rax
testq %r14, %r14
je 0x1db96
addq $0x18, %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
addq $0x20, %rcx
addq $-0x20, %r15
jne 0x1db80
movl (%rbx), %ecx
movl %ecx, 0x4(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ds.h
// Function: EList<SString<char>, 128>::expandCopyExact(unsigned long)
void expandCopyExact(size_t newsz) {
		if(newsz <= sz_) return;
		T* tmp = alloc(newsz);
		assert(tmp != NULL);
		size_t cur = cur_;
		if(list_ != NULL) {
 			for(size_t i = 0; i < cur_; i++) {
				// Note: operator= is used
				tmp[i] = list_[i];
			}
			free();
		}
		list_ = tmp;
		sz_ = newsz;
		cur_ = cur;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rsi, 0x10(%rdi)
jae 0x1c84e
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1c76e
testq %rax, %rax
je 0x1c85d
movq %rax, %r15
movq 0x18(%rbx), %r12
cmpq $0x0, 0x8(%rbx)
je 0x1c842
xorl %r13d, %r13d
movq %r12, %rax
xorl %ebp, %ebp
cmpq %rax, %rbp
jae 0x1c83a
movq 0x8(%rbx), %rax
leaq (%r15,%r13), %rdi
movq 0x8(%rax,%r13), %rsi
movq 0x18(%rax,%r13), %rdx
movq (%r15,%r13), %rax
callq *0x10(%rax)
incq %rbp
movq 0x18(%rbx), %rax
addq $0x20, %r13
jmp 0x1c80f
movq %rbx, %rdi
callq 0x1c87c
movq %r15, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %r12, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd4b0(%rip), %rdi      # 0x29d14
leaq 0xd0b2(%rip), %rsi      # 0x2991d
leaq 0xd844(%rip), %rcx      # 0x2a0b6
movl $0x3c8, %edx            # imm = 0x3C8
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./filebuf.h
// Function: void FileBuf::parseFastaRecord<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, SString<char>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, SString<char>&, bool)
void parseFastaRecord(
		TNameStr& name,
		TSeqStr&  seq,
		bool      gotCaret = false)
	{
		int c;
		if(!gotCaret) {
			// Skip over caret and non-newline whitespace
			c = peek();
			while(isspace_notnl(c) || c == '>') { get(); c = peek(); }
		} else {
			// Skip over non-newline whitespace
			c = peek();
			while(isspace_notnl(c)) { get(); c = peek(); }
		}
		size_t namecur = 0, seqcur = 0;
		// c is the first character of the fasta name record, or is the first
		// newline character if the name record is empty
		while(!isnewline(c) && c != -1) {
			name[namecur++] = c; get(); c = peek();
		}
		// sequence consists of all the non-whitespace characters between here
		// and the next caret
		while(true) {
			// skip over whitespace
			while(isspace(c)) { get(); c = peek(); }
			// if we see caret or EOF, break
			if(c == '>' || c == -1) break;
			// append and continue
			seq[seqcur++] = asc2dna[c];
			get(); c = peek();
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
callq 0x1d0f6
movl %eax, %r15d
testl %ebp, %ebp
je 0x1cc22
movl %r15d, %edi
callq 0xc4cc
testb %al, %al
je 0x1cc4c
movq %r14, %rdi
callq 0x1d2b6
movq %r14, %rdi
callq 0x1d0f6
movl %eax, %r15d
jmp 0x1cc01
movl %r15d, %edi
callq 0xc4cc
notb %al
cmpl $0x3e, %r15d
setne %cl
testb %cl, %al
jne 0x1cc4c
movq %r14, %rdi
callq 0x1d2b6
movq %r14, %rdi
callq 0x1d0f6
movl %eax, %r15d
jmp 0x1cc22
xorl %r13d, %r13d
movl $0x4801, %ebp           # imm = 0x4801
leal 0x1(%r15), %eax
cmpl $0xe, %eax
ja 0x1cc62
btl %eax, %ebp
jb 0x1cc82
movq (%r12), %rax
movb %r15b, (%rax,%r13)
incq %r13
movq %r14, %rdi
callq 0x1d2b6
movq %r14, %rdi
callq 0x1d0f6
movl %eax, %r15d
jmp 0x1cc54
xorl %ebx, %ebx
leaq 0x18ca5(%rip), %r13     # 0x35930
movl %r15d, %edi
callq 0x4050
testl %eax, %eax
je 0x1ccac
movq %r14, %rdi
callq 0x1d2b6
movq %r14, %rdi
callq 0x1d0f6
movl %eax, %r15d
jmp 0x1cc8b
cmpl $-0x1, %r15d
je 0x1cceb
cmpl $0x3e, %r15d
je 0x1cceb
movslq %r15d, %rax
movb (%r13,%rax), %bpl
leaq 0x1(%rbx), %r12
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0xe1f4
movb %bpl, (%rax)
movq %r14, %rdi
callq 0x1d2b6
movq %r14, %rdi
callq 0x1d0f6
movl %eax, %r15d
movq %r12, %rbx
jmp 0x1cc8b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::parseFastaRecordLength(unsigned long&, unsigned long&, bool)
void parseFastaRecordLength(
		size_t&   nameLen,
		size_t&   seqLen,
		bool      gotCaret = false)
	{
		int c;
		nameLen = seqLen = 0;
		if(!gotCaret) {
			// Skip over caret and non-newline whitespace
			c = peek();
			while(isspace_notnl(c) || c == '>') { get(); c = peek(); }
		} else {
			// Skip over non-newline whitespace
			c = peek();
			while(isspace_notnl(c)) { get(); c = peek(); }
		}
		// c is the first character of the fasta name record, or is the first
		// newline character if the name record is empty
		while(!isnewline(c) && c != -1) {
			nameLen++; get(); c = peek();
		}
		// sequence consists of all the non-whitespace characters between here
		// and the next caret
		while(true) {
			// skip over whitespace
			while(isspace(c)) { get(); c = peek(); }
			// if we see caret or EOF, break
			if(c == '>' || c == -1) break;
			// append and continue
			seqLen++;
			get(); c = peek();
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
andq $0x0, (%rdx)
movq %rdi, %r14
andq $0x0, (%rsi)
callq 0x1d0f6
movl %eax, %r12d
testl %ebp, %ebp
je 0x1cede
movl %r12d, %edi
callq 0xc4cc
testb %al, %al
je 0x1cf08
movq %r14, %rdi
callq 0x1d2b6
movq %r14, %rdi
callq 0x1d0f6
movl %eax, %r12d
jmp 0x1cebd
movl %r12d, %edi
callq 0xc4cc
notb %al
cmpl $0x3e, %r12d
setne %cl
testb %cl, %al
jne 0x1cf08
movq %r14, %rdi
callq 0x1d2b6
movq %r14, %rdi
callq 0x1d0f6
movl %eax, %r12d
jmp 0x1cede
movl $0x4801, %ebp           # imm = 0x4801
leal 0x1(%r12), %eax
cmpl $0xe, %eax
ja 0x1cf1c
btl %eax, %ebp
jb 0x1cf4a
incq (%r15)
movq %r14, %rdi
callq 0x1d2b6
movq %r14, %rdi
callq 0x1d0f6
movl %eax, %r12d
jmp 0x1cf0d
incq (%rbx)
movq %r14, %rdi
callq 0x1d2b6
movq %r14, %rdi
callq 0x1d0f6
movl %eax, %r12d
movl %r12d, %edi
callq 0x4050
testl %eax, %eax
jne 0x1cf37
cmpl $-0x1, %r12d
je 0x1cf62
cmpl $0x3e, %r12d
jne 0x1cf34
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::get()
int get() {
		assert(_in != NULL || _zIn != NULL || _inf != NULL || _ins != NULL);
		int c = peek();
		if(c != -1) {
			_cur++;
			if(_lastn_cur < LASTN_BUF_SZ) _lastn_buf[_lastn_cur++] = c;
		}
		return c;
	}

// Assembly:
pushq %rbx
movdqu (%rdi), %xmm0
movdqu 0x10(%rdi), %xmm1
por %xmm0, %xmm1
pxor %xmm0, %xmm0
pcmpeqd %xmm1, %xmm0
movmskps %xmm0, %eax
xorl $0xf, %eax
je 0x1d309
movq %rdi, %rbx
callq 0x1d0f6
cmpl $-0x1, %eax
je 0x1d307
incq 0x20(%rbx)
movq 0x40038(%rbx), %rcx
cmpq $0x1fff, %rcx           # imm = 0x1FFF
ja 0x1d307
leaq 0x1(%rcx), %rdx
movq %rdx, 0x40038(%rbx)
movb %al, 0x40040(%rbx,%rcx)
popq %rbx
retq
leaq 0xcec9(%rip), %rdi      # 0x2a1d9
leaq 0xcefe(%rip), %rsi      # 0x2a215
leaq 0xcf23(%rip), %rcx      # 0x2a241
pushq $0x7d
popq %rdx
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::close()
void close() {
		if(_in != NULL && _in != stdin) {
			fclose(_in);
		} else if(_inf != NULL) {
			_inf->close();
		} else if(_zIn != NULL) {
			gzclose(_zIn);
		} else {
			// can't close _ins
		}
	}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x1d342
movq 0x16c6b(%rip), %rcx     # 0x33fa0
cmpq (%rcx), %rax
je 0x1d342
movq %rax, %rdi
jmp 0x42e0
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1d353
movq %rax, %rdi
jmp 0x4080
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x4590
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: EbwtParams::setOffRate(int)
void setOffRate(int __offRate) {
		_offRate = __offRate;
		_offMask = OFF_MASK << _offRate;
		_offsLen = (_bwtLen + (1 << _offRate) - 1) >> _offRate;
		_offsSz = (uint64_t) _offsLen*OFF_SIZE;
	}

// Assembly:
movl %esi, %ecx
movl %esi, 0x2c(%rdi)
pushq $-0x1
popq %rax
shlq %cl, %rax
pushq $0x1
popq %rdx
shll %cl, %edx
movq %rax, 0x30(%rdi)
movq 0x8(%rdi), %rax
movslq %edx, %rdx
addq %rdx, %rax
decq %rax
shrq %cl, %rax
movq %rax, 0x60(%rdi)
shlq $0x3, %rax
movq %rax, 0x68(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: EbwtParams::setIsaRate(int)
void setIsaRate(int __isaRate) {
		_isaRate = __isaRate;
		_isaMask = OFF_MASK << _isaRate;
		_isaLen = (_bwtLen + (1 << _isaRate) - 1) >> _isaRate;
		_isaSz = (uint64_t)_isaLen*OFF_SIZE;
	}

// Assembly:
movl %esi, %ecx
movl %esi, 0x38(%rdi)
pushq $-0x1
popq %rax
shlq %cl, %rax
pushq $0x1
popq %rdx
shll %cl, %edx
movl %eax, 0x3c(%rdi)
movq 0x8(%rdi), %rax
movslq %edx, %rdx
addq %rdx, %rax
decq %rax
shrq %cl, %rax
movq %rax, 0x70(%rdi)
shlq $0x3, %rax
movq %rax, 0x78(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::evictFromMemory()
void evictFromMemory() {
		assert(isInMemory());
		if(!_useMm) {
			delete[] _fchr;
			delete[] _ftab;
			delete[] _eftab;
			if(!useShmem_) delete[] _offs;
			delete[] _isa;
			// Keep plen; it's small and the client may want to query it
			// even when the others are evicted.
			//delete[] _plen;
			delete[] _rstarts;
			if(!useShmem_) delete[] _ebwt;
		}
		_fchr  = NULL;
		_ftab  = NULL;
		_eftab = NULL;
		_offs  = NULL;
		_isa   = NULL;
		// Keep plen; it's small and the client may want to query it
		// even when the others are evicted.
		//_plen  = NULL;
		_rstarts = NULL;
		_ebwt    = NULL;
		_zEbwtByteOff = OFF_MASK;
		_zEbwtBpOff = -1;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xd5d2
testb %al, %al
je 0x1da2a
cmpb $0x0, 0xd0(%rbx)
jne 0x1d9fb
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x1d983
callq 0x43d0
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x1d994
callq 0x43d0
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x1d9a5
callq 0x43d0
cmpb $0x0, 0xd1(%rbx)
jne 0x1d9bf
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x1d9bf
callq 0x43d0
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x1d9d0
callq 0x43d0
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x1d9e1
callq 0x43d0
cmpb $0x0, 0xd1(%rbx)
jne 0x1d9fb
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x1d9fb
callq 0x43d0
pxor %xmm0, %xmm0
movdqu %xmm0, 0xb8(%rbx)
andq $0x0, 0xc8(%rbx)
movdqu %xmm0, 0xa8(%rbx)
movdqu %xmm0, 0x98(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x70(%rbx)
popq %rbx
retq
leaq 0xa6bf(%rip), %rdi      # 0x280f0
leaq 0xa6c5(%rip), %rsi      # 0x280fd
leaq 0xd0ba(%rip), %rcx      # 0x2aaf9
movl $0x3ad, %edx            # imm = 0x3AD
callq 0x4190
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./sstring.h
// Function: S2bDnaString::get(unsigned long) const
char get(size_t i) const {
		assert_lt(i, len_);
		size_t word = i >> 4;
		size_t bpoff = (i & 15) << 1;
		return (char)((cs_[word] >> bpoff) & 3);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jbe 0x232c7
movq 0x8(%r14), %rax
movq %r15, %rcx
shrq $0x4, %rcx
movl (%rax,%rcx,4), %eax
addl %r15d, %r15d
movl %r15d, %ecx
shrl %cl, %eax
andb $0x3, %al
popq %rbx
popq %r14
popq %r15
retq
movq 0x10cea(%rip), %rbx     # 0x33fb8
leaq 0x4fb2(%rip), %rsi      # 0x28287
movq %rbx, %rdi
callq 0x42d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
leaq 0x4fae(%rip), %rsi      # 0x2829d
movq %rax, %rdi
callq 0x42d0
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x40b0
leaq 0x710e(%rip), %rsi      # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x7f00(%rip), %r14      # 0x2b221
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
leaq 0x6408(%rip), %rsi      # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0x474, %esi            # imm = 0x474
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x62c4(%rip), %rdi      # 0x2961b
leaq 0x7efb(%rip), %rcx      # 0x2b259
movq %r14, %rsi
movl $0x474, %edx            # imm = 0x474
callq 0x4190
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ds.h
// Function: EList<EList<unsigned long, 128>, 128>::resize(unsigned long)
void resize(size_t sz) {
		if(sz > 0 && list_ == NULL) lazyInit();
		if(sz <= cur_) {
			cur_ = sz;
			return;
		}
		if(sz_ < sz) {
			expandCopy(sz);
		}
		cur_ = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x23454
cmpq $0x0, 0x8(%r14)
jne 0x23454
movq %r14, %rdi
callq 0x234dc
cmpq %rbx, 0x18(%r14)
jae 0x2346b
cmpq %rbx, 0x10(%r14)
jae 0x2346b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23516
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ds.h
// Function: EList<unsigned long, 128>::expandNoCopy(unsigned long)
void expandNoCopy(size_t thresh) {
		assert(list_ != NULL);
		if(thresh <= sz_) return;
		size_t newsz = (sz_ * 2)+1;
		while(newsz < thresh) newsz *= 2;
		expandNoCopyExact(newsz);
	}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x23ba4
movq 0x10(%rdi), %rax
cmpq %rsi, %rax
jae 0x23ba3
leaq 0x1(,%rax,2), %rcx
movq %rcx, %rax
addq %rcx, %rcx
cmpq %rsi, %rax
jb 0x23b90
movq %rax, %rsi
jmp 0x23bc4
retq
pushq %rax
leaq 0x79c9(%rip), %rdi      # 0x2b575
leaq 0x5d6a(%rip), %rsi      # 0x2991d
leaq 0x79c9(%rip), %rcx      # 0x2b583
movl $0x3dc, %edx            # imm = 0x3DC
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ds.h
// Function: EList<unsigned long, 128>::expandNoCopyExact(unsigned long)
void expandNoCopyExact(size_t newsz) {
		assert(list_ != NULL);
		assert_gt(newsz, 0);
		free();
		T* tmp = alloc(newsz);
		assert(tmp != NULL);
		list_ = tmp;
		sz_ = newsz;
		assert_gt(sz_, 0);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x23c03
movq %rsi, %rbx
testq %rsi, %rsi
je 0x23c22
movq %rdi, %r14
callq 0x1bd3c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1bc8a
testq %rax, %rax
je 0x23cc3
movq %rax, 0x8(%r14)
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x796b(%rip), %rdi      # 0x2b575
leaq 0x5d0c(%rip), %rsi      # 0x2991d
leaq 0x79b8(%rip), %rcx      # 0x2b5d0
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x4190
movq 0x1038f(%rip), %rbx     # 0x33fb8
leaq 0x4508(%rip), %rsi      # 0x28138
movq %rbx, %rdi
callq 0x42d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x40b0
leaq 0x4505(%rip), %rsi      # 0x2814e
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x45d0
leaq 0x67b6(%rip), %rsi      # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x5ca4(%rip), %r14      # 0x2991d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
leaq 0x5ab0(%rip), %rsi      # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0x3e9, %esi            # imm = 0x3E9
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x596c(%rip), %rdi      # 0x2961b
leaq 0x791a(%rip), %rcx      # 0x2b5d0
movq %r14, %rsi
movl $0x3e9, %edx            # imm = 0x3E9
callq 0x4190
leaq 0x604a(%rip), %rdi      # 0x29d14
leaq 0x5c4c(%rip), %rsi      # 0x2991d
leaq 0x78f8(%rip), %rcx      # 0x2b5d0
movl $0x3ec, %edx            # imm = 0x3EC
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::getPastNewline()
int getPastNewline() {
		int c = get();
		while(!isnewline(c) && c != -1) c = get();
		while(isnewline(c)) c = get();
		assert_neq(c, '\r');
		assert_neq(c, '\n');
		return c;
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x4801, %ebp           # imm = 0x4801
movq %rbx, %rdi
callq 0x1d2b6
leal 0x1(%rax), %ecx
cmpl $0xe, %ecx
ja 0x2699d
btl %ecx, %ebp
jae 0x2699d
jmp 0x269bc
movq %rbx, %rdi
callq 0x1d2b6
cmpl $0xd, %eax
je 0x269b4
cmpl $0xa, %eax
je 0x269b4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./filebuf.h
// Function: BitpairOutFileBuf::write(int)
void write(int bp) {
		assert_lt(bp, 4);
		assert_geq(bp, 0);
		buf_[cur_] |= (bp << bpPtr_);
		if(bpPtr_ == 6) {
			bpPtr_ = 0;
			cur_++;
			if(cur_ == BUF_SZ) {
				// Flush the buffer
				if(!fwrite((const void *)buf_, BUF_SZ, 1, out_)) {
					std::cerr << "Error writing to the reference index file (.4.ebwt)" << std::endl;
					throw 1;
				}
				// Reset to beginning of the buffer
				cur_ = 0;
			}
			// Initialize next octet to 0
			buf_[cur_] = 0;
		} else {
			bpPtr_ += 2;
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
cmpl $0x4, %esi
jge 0x26a4a
testl %ebp, %ebp
js 0x26aec
movq %rdi, %rbx
movb 0x8(%rdi), %cl
shll %cl, %ebp
movq 0x10(%rdi), %rax
orb %bpl, 0x18(%rdi,%rax)
movl 0x8(%rdi), %eax
cmpl $0x6, %eax
jne 0x26a3f
leaq 0x18(%rbx), %r14
andl $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
cmpq $0x20000, %rax          # imm = 0x20000
jne 0x26a38
movq (%rbx), %rcx
pushq $0x1
popq %rdx
movl $0x20000, %esi          # imm = 0x20000
movq %r14, %rdi
callq 0x4690
testq %rax, %rax
je 0x26b8d
andq $0x0, 0x10(%rbx)
xorl %eax, %eax
movb $0x0, (%r14,%rax)
jmp 0x26a45
addl $0x2, %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0xd567(%rip), %rbx      # 0x33fb8
leaq 0x182f(%rip), %rsi      # 0x28287
movq %rbx, %rdi
callq 0x42d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x45d0
leaq 0x182c(%rip), %rsi      # 0x2829d
movq %rax, %rdi
callq 0x42d0
pushq $0x4
popq %rsi
movq %rax, %rdi
callq 0x45d0
leaq 0x398d(%rip), %rsi      # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x3773(%rip), %r14      # 0x2a215
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
leaq 0x2c87(%rip), %rsi      # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0x228, %esi            # imm = 0x228
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x2b43(%rip), %rdi      # 0x2961b
leaq 0x59a1(%rip), %rcx      # 0x2c480
movq %r14, %rsi
movl $0x228, %edx            # imm = 0x228
callq 0x4190
movq 0xd4c5(%rip), %rbx      # 0x33fb8
leaq 0x174b(%rip), %rsi      # 0x28245
movq %rbx, %rdi
callq 0x42d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x45d0
leaq 0x1749(%rip), %rsi      # 0x2825c
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
xorl %esi, %esi
callq 0x45d0
leaq 0x38ec(%rip), %rsi      # 0x2a418
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x36d2(%rip), %r14      # 0x2a215
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
leaq 0x2be6(%rip), %rsi      # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl $0x229, %esi            # imm = 0x229
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x2aa2(%rip), %rdi      # 0x2961b
leaq 0x5900(%rip), %rcx      # 0x2c480
movq %r14, %rsi
movl $0x229, %edx            # imm = 0x229
callq 0x4190
movq 0xd45c(%rip), %rdi      # 0x33ff0
leaq 0x5908(%rip), %rsi      # 0x2c4a3
callq 0x42d0
movq %rax, %rdi
callq 0x4130
pushq $0x4
popq %rdi
callq 0x4140
movl $0x1, (%rax)
movq 0xd3b3(%rip), %rsi      # 0x33f70
movq %rax, %rdi
xorl %edx, %edx
callq 0x45b0
nop