LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: biotomas[P]ipasir/app/genipareach/genipareach.cpp
// Function: assumeLits(void*, std::vector<int, std::allocator<int>> const&, int)
void assumeLits(void* solver, const vector<int>& lits, int variableOffset) {
	for (size_t lid = 0; lid < lits.size(); lid++) {
		int lit = lits[lid];
		if (lit > 0) {
			ipasir_assume(solver, lit+variableOffset);
		} else {
			ipasir_assume(solver, lit-variableOffset);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1cf0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1740
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d10
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x1721
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
addl -0x14(%rbp), %esi
callq 0x3cb0
jmp 0x1730
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
subl -0x14(%rbp), %esi
callq 0x3cb0
jmp 0x1732
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x16db
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/app/genipareach/genipareach.cpp
// Function: Formula::addLit(int)
void addLit(int lit) {
		if (lit == 0) {
			clausesCount++;
			clauses.push_back(tmpClause);
			tmpClause.clear();
		} else {
			tmpClause.push_back(lit);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1c89
movq -0x18(%rbp), %rsi
movl 0x4(%rsi), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsi)
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x20, %rsi
callq 0x1ed0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x1f40
jmp 0x1c9a
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
leaq -0xc(%rbp), %rsi
callq 0x1db0
addq $0x20, %rsp
popq %rbp
retq
// File: biotomas[P]ipasir/sat/picosat961/ipasirpicosatglue.c
// Function: ipasir_init
void * ipasir_init () { 
  char prefix[80];
  void * res = picosat_init ();
  sprintf (prefix, "c [%s] ", sig);
  picosat_set_prefix (res, prefix);
  picosat_set_verbosity (res, 1);
  picosat_set_output (res, stdout);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
callq 0x3f00
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
movq 0x2054c(%rip), %rdx     # 0x24148
leaq 0x1861f(%rip), %rsi     # 0x1c222
movb $0x0, %al
callq 0x1050
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6130
movq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0x5fc0
movq -0x58(%rbp), %rdi
movq 0x20398(%rip), %rax     # 0x23fc8
movq (%rax), %rsi
callq 0x60d0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./word_io.h
// Function: unsigned int readU<unsigned int>(_IO_FILE*, bool)
static inline T readU(FILE* in, bool swap) {
	T x;
	if(fread((void *)&x, 1, sizeof(T), in) != sizeof(T)) {
		assert(false);
	}
	if(swap) {
		if(sizeof(T) == 4) {
			return endianSwapU32(x);
		} else if(sizeof(T) == 8) {
			return endianSwapU64(x);
		} else {
			assert(false);
		}
	} else {
		return x;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x5600
cmpq $0x4, %rax
je 0xe2a0
leaq 0x32a60(%rip), %rdi     # 0x40ce8
leaq 0x32a5f(%rip), %rsi     # 0x40cee
movl $0x4a, %edx
leaq 0x34f9e(%rip), %rcx     # 0x43239
callq 0x51e0
testb $0x1, -0x11(%rbp)
je 0xe2b3
movl -0x18(%rbp), %edi
callq 0xe2d0
movl %eax, -0x4(%rbp)
jmp 0xe2b9
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./endian_swap.h
// Function: endianSwapU32(unsigned int)
static inline uint32_t endianSwapU32(uint32_t u) {
	uint32_t tmp = 0;
	tmp |= ((u >> 24) & (0xff <<  0));
	tmp |= ((u >>  8) & (0xff <<  8));
	tmp |= ((u <<  8) & (0xff << 16));
	tmp |= ((u << 24) & (0xff << 24));
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
shll $0x8, %eax
andl $0xff0000, %eax         # imm = 0xFF0000
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
shll $0x18, %eax
andl $0xff000000, %eax       # imm = 0xFF000000
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./word_io.h
// Function: int readI<int>(_IO_FILE*, bool)
static inline T readI(FILE* in, bool swap) {
	T x;
	if(fread((void *)&x, 1, sizeof(T), in) != sizeof(T)) {
		assert(false);
	}
	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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x5600
cmpq $0x4, %rax
je 0xe400
leaq 0x32900(%rip), %rdi     # 0x40ce8
leaq 0x328ff(%rip), %rsi     # 0x40cee
movl $0x6f, %edx
leaq 0x34e67(%rip), %rcx     # 0x43262
callq 0x51e0
testb $0x1, -0x11(%rbp)
je 0xe413
movl -0x18(%rbp), %edi
callq 0x13fa0
movl %eax, -0x4(%rbp)
jmp 0xe419
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./endian_swap.h
// Function: endianSwapU64(unsigned long)
static inline uint64_t endianSwapU64(uint64_t u) {
	uint64_t tmp = 0;
	tmp |= ((u >> 56) & (0xffull <<  0));
	tmp |= ((u >> 40) & (0xffull <<  8));
	tmp |= ((u >> 24) & (0xffull << 16));
	tmp |= ((u >>  8) & (0xffull << 24));
	tmp |= ((u <<  8) & (0xffull << 32));
	tmp |= ((u << 24) & (0xffull << 40));
	tmp |= ((u << 40) & (0xffull << 48));
	tmp |= ((u << 56) & (0xffull << 56));
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
shrq $0x38, %rax
andq $0xff, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shrq $0x28, %rax
andq $0xff00, %rax           # imm = 0xFF00
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shrq $0x18, %rax
andq $0xff0000, %rax         # imm = 0xFF0000
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shrq $0x8, %rax
movabsq $0xff000000, %rcx       # imm = 0xFF000000
andq %rcx, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shlq $0x8, %rax
movabsq $0xff00000000, %rcx     # imm = 0xFF00000000
andq %rcx, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shlq $0x18, %rax
movabsq $0xff0000000000, %rcx   # imm = 0xFF0000000000
andq %rcx, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shlq $0x28, %rax
movabsq $0xff000000000000, %rcx # imm = 0xFF000000000000
andq %rcx, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shlq $0x38, %rax
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
andq %rcx, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/bowtie_inspect.cpp
// Function: print_fasta_record(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void print_fasta_record(ostream& fout,
						const string& defline,
						const string& seq)
{
	fout << ">";
	fout << defline << endl;

	if(across > 0) {
		size_t i = 0;
		while (i + across < seq.length())
		{
			fout << seq.substr(i, across) << endl;
			i += across;
		}
		if (i < seq.length())
			fout << seq.substr(i) << endl;
	} else {
		fout << seq << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x32aed(%rip), %rsi     # 0x418cf
callq 0x5360
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x52f0
movq %rax, %rdi
movq 0x3b182(%rip), %rsi     # 0x49f80
callq 0x53c0
cmpl $0x0, 0x3b646(%rip)     # 0x4a450
jle 0xef71
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq 0x3b62d(%rip), %rcx     # 0x4a450
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5610
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0xeecf
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movslq 0x3b5f3(%rip), %rcx     # 0x4a450
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x53b0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x52f0
movq %rax, -0x80(%rbp)
jmp 0xee86
movq -0x80(%rbp), %rdi
movq 0x3b0ef(%rip), %rsi     # 0x49f80
callq 0x53c0
jmp 0xee98
leaq -0x40(%rbp), %rdi
callq 0x5888
movslq 0x3b5a8(%rip), %rax     # 0x4a450
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xee18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5888
jmp 0xef96
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5610
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0xef6f
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq $-0x1, %rcx
callq 0x53b0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x52f0
movq %rax, -0xa0(%rbp)
jmp 0xef38
movq -0xa0(%rbp), %rdi
movq 0x3b03a(%rip), %rsi     # 0x49f80
callq 0x53c0
jmp 0xef4d
leaq -0x70(%rbp), %rdi
callq 0x5888
jmp 0xef6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5888
jmp 0xef96
jmp 0xef8d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x52f0
movq %rax, %rdi
movq 0x3aff8(%rip), %rsi     # 0x49f80
callq 0x53c0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5760
nop
// File: BenLangmead[P]bowtie/bowtie_inspect.cpp
// Function: print_alln_ref_sequence(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
void print_alln_ref_sequence(
	ostream& fout,
	const string& name,
	size_t len)
{
	fout << ">" << name << "\n";
	size_t j = 0;
	for(size_t i = 0; i < len; i += across) {
		while(j < len && j < i+across) {
			fout << 'N';
			j++;
		}
		fout << "\n";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x32910(%rip), %rsi     # 0x418cf
callq 0x5360
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x52f0
movq %rax, %rdi
leaq 0x30de9(%rip), %rsi     # 0x3fdc3
callq 0x5360
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xf06b
jmp 0xeffb
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x29(%rbp)
jae 0xf025
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq 0x3b437(%rip), %rdx     # 0x4a450
addq %rdx, %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xf02e
jmp 0xf04a
movq -0x8(%rbp), %rdi
movl $0x4e, %esi
callq 0x54a0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xeffb
movq -0x8(%rbp), %rdi
leaq 0x30d6e(%rip), %rsi     # 0x3fdc3
callq 0x5360
movslq 0x3b3ef(%rip), %rax     # 0x4a450
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xefef
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./assert_helpers.h
// Function: void assert_range_helper<int>(int const&, int const&, int const&, char const*, int)
inline static void assert_range_helper(const T& begin,
                                       const T& end,
                                       const T& val,
                                       const char *file,
                                       int line)
{
	if(val < begin || val > end) {
		std::cout << "assert_range: (" << val << ") not in  ["
		          << begin << ", " << end << "]" << std::endl;
		std::cout << file << ":" << line << std::endl;
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jl 0xf39c
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0xf46d
movq 0x3ac1d(%rip), %rdi     # 0x49fc0
leaq 0x32925(%rip), %rsi     # 0x41ccf
callq 0x5360
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x5750
movq %rax, %rdi
leaq 0x32918(%rip), %rsi     # 0x41cdf
callq 0x5360
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x5750
movq %rax, %rdi
leaq 0x302d6(%rip), %rsi     # 0x3f6ba
callq 0x5360
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x5750
movq %rax, %rdi
leaq 0x2fece(%rip), %rsi     # 0x3f2cf
callq 0x5360
movq %rax, %rdi
movq 0x3ab70(%rip), %rsi     # 0x49f80
callq 0x53c0
movq -0x20(%rbp), %rsi
movq 0x3aba0(%rip), %rdi     # 0x49fc0
callq 0x5360
movq %rax, %rdi
leaq 0x3135b(%rip), %rsi     # 0x4078a
callq 0x5360
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0x5750
movq %rax, %rdi
movq 0x3ab37(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x31215(%rip), %rdi     # 0x4066a
leaq 0x3288f(%rip), %rsi     # 0x41ceb
movl $0xfd, %edx
leaq 0x32896(%rip), %rcx     # 0x41cfe
callq 0x51e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x22020
movq -0x50(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0xf950
jmp 0xf89c
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1aaa0
movq %rax, -0x58(%rbp)
jmp 0xf8bb
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
cmpq %rcx, %rax
jae 0xf92a
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x22060
movq %rax, -0x68(%rbp)
jmp 0xf8db
movq -0x68(%rbp), %rsi
movq 0x3a6da(%rip), %rdi     # 0x49fc0
callq 0x52f0
movq %rax, -0x70(%rbp)
jmp 0xf8f1
movq -0x70(%rbp), %rdi
movq 0x3a684(%rip), %rsi     # 0x49f80
callq 0x53c0
jmp 0xf903
jmp 0xf905
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xf8a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x22160
jmp 0xf939
leaq -0x30(%rbp), %rdi
callq 0x22160
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: readEntireReverse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static inline bool
readEntireReverse(const string& instr) {
	int32_t flags = readFlags(instr);
	if(flags < 0 && (((-flags) & EBWT_ENTIRE_REV) != 0)) {
		return true;
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10640
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x10e51
xorl %eax, %eax
subl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x10e51
movb $0x1, -0x1(%rbp)
jmp 0x10e55
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: int countInU64<USE_POPCNT_INSTRUCTION>(int, unsigned long)
inline static int countInU64(int c, uint64_t dw) {
	uint64_t c0 = c_table[c];
	uint64_t x0 = dw ^ c0;
	uint64_t x1 = (x0 >> 1);
	uint64_t x2 = x1 & (0x5555555555555555llu);
	uint64_t x3 = x0 & x2;
#ifdef POPCNT_CAPABILITY
    uint64_t tmp = Operation().pop64(x3);
#else
    uint64_t tmp = pop64(x3);
#endif
	return (int) tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x31366(%rip), %rax     # 0x43370
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq %rax
movq %rax, -0x28(%rbp)
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
andq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
andq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x26640
cltq
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: BenLangmead[P]bowtie/./sequence_io.h
// Function: void parseFastaLens<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, EList<unsigned long, 128>&, EList<unsigned long, 128>&)
static void parseFastaLens(
	const TFnStr&  infile,   // filename
	EList<size_t>& namelens, // destination for fasta name lengths
	EList<size_t>& seqlens)  // destination for fasta sequence lengths
{
	FILE *in = fopen(sstr_to_cstr(infile), "r");
	if(in == NULL) {
		cerr << "Could not open sequence file" << endl;
		throw 1;
	}
	FileBuf fb(in);
	while(!fb.eof()) {
		namelens.push_back(0);
		seqlens.push_back(0);
		fb.parseFastaRecordLength(namelens.back(), seqlens.back());
		if(seqlens.back() == 0) {
			// Couldn't read a record.  We're probably done with this file.
			namelens.pop_back();
			seqlens.pop_back();
			continue;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420a0, %rsp          # imm = 0x420A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x132d0
movq %rax, %rdi
leaq 0x2c606(%rip), %rsi     # 0x3f750
callq 0x5460
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1319f
movq 0x36e8f(%rip), %rdi     # 0x49ff0
leaq 0x2e164(%rip), %rsi     # 0x412cc
callq 0x5360
movq %rax, %rdi
movq 0x36e09(%rip), %rsi     # 0x49f80
callq 0x53c0
movl $0x4, %edi
callq 0x5180
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x36dda(%rip), %rsi     # 0x49f70
xorl %eax, %eax
movl %eax, %edx
callq 0x5720
movq -0x20(%rbp), %rsi
leaq -0x42060(%rbp), %rdi
callq 0x2e810
leaq -0x42060(%rbp), %rdi
callq 0x2e870
movb %al, -0x42081(%rbp)
jmp 0x131c3
movb -0x42081(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x131d4
jmp 0x132af
movq -0x10(%rbp), %rdi
movq $0x0, -0x42078(%rbp)
leaq -0x42078(%rbp), %rsi
callq 0x2c110
jmp 0x131f1
movq -0x18(%rbp), %rdi
movq $0x0, -0x42080(%rbp)
leaq -0x42080(%rbp), %rsi
callq 0x2c110
jmp 0x1320e
movq -0x10(%rbp), %rdi
callq 0x2edf0
movq %rax, -0x42090(%rbp)
jmp 0x13220
movq -0x18(%rbp), %rdi
callq 0x2edf0
movq %rax, -0x42098(%rbp)
jmp 0x13232
movq -0x42098(%rbp), %rdx
movq -0x42090(%rbp), %rsi
leaq -0x42060(%rbp), %rdi
xorl %ecx, %ecx
callq 0x2ec80
jmp 0x13250
movq -0x18(%rbp), %rdi
callq 0x2edf0
movq %rax, -0x420a0(%rbp)
jmp 0x13262
movq -0x420a0(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x132aa
movq -0x10(%rbp), %rdi
callq 0x2eef0
jmp 0x1327a
movq -0x18(%rbp), %rdi
callq 0x2eef0
jmp 0x13285
jmp 0x131af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42068(%rbp)
movl %eax, -0x4206c(%rbp)
leaq -0x42060(%rbp), %rdi
callq 0x2ec50
jmp 0x132c4
jmp 0x131af
leaq -0x42060(%rbp), %rdi
callq 0x2ec50
addq $0x420a0, %rsp          # imm = 0x420A0
popq %rbp
retq
movq -0x42068(%rbp), %rdi
callq 0x5760
// File: BenLangmead[P]bowtie/./word_io.h
// Function: unsigned int readU<unsigned int>(std::istream&, bool)
static inline T readU(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 endianSwapU32(x);
		} else if(sizeof(T) == 8) {
			return endianSwapU64(x);
		} else {
			assert(false);
		}
	} else {
		return x;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x54f0
movq -0x10(%rbp), %rdi
callq 0x5870
movq %rax, %rcx
movl $0x4, %eax
cmpq %rcx, %rax
je 0x13c13
movq 0x364e9(%rip), %rdi     # 0x49fc0
leaq 0x2b63b(%rip), %rsi     # 0x3f119
callq 0x5360
movq %rax, %rdi
movl $0x4, %esi
callq 0x50c0
movq %rax, %rdi
leaq 0x2b635(%rip), %rsi     # 0x3f12f
callq 0x5360
movq %rax, %rdi
leaq 0x4cd7(%rip), %rsi      # 0x187e0
callq 0x5120
movq %rax, %rdi
movl $0x4, %esi
callq 0x50c0
movq %rax, %rdi
leaq 0x4ceb(%rip), %rsi      # 0x18810
callq 0x5120
movq %rax, %rdi
leaq 0x2b600(%rip), %rsi     # 0x3f134
callq 0x5360
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5870
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x57b0
movq %rax, %rdi
leaq 0x2b5d3(%rip), %rsi     # 0x3f12f
callq 0x5360
movq %rax, %rdi
leaq 0x4c75(%rip), %rsi      # 0x187e0
callq 0x5120
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5870
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x57b0
movq %rax, %rdi
leaq 0x4c7d(%rip), %rsi      # 0x18810
callq 0x5120
movq %rax, %rdi
leaq 0x2da16(%rip), %rsi     # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x363cf(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x36403(%rip), %rdi     # 0x49fc0
leaq 0x2d12a(%rip), %rsi     # 0x40cee
callq 0x5360
movq %rax, %rdi
leaq 0x2cbb7(%rip), %rsi     # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x37, %esi
callq 0x5750
movq %rax, %rdi
movq 0x36391(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x2ca6f(%rip), %rdi     # 0x4066a
leaq 0x2d0ec(%rip), %rsi     # 0x40cee
movl $0x37, %edx
leaq 0x2da8c(%rip), %rcx     # 0x4169a
callq 0x51e0
testb $0x1, -0x11(%rbp)
je 0x13c26
movl -0x18(%rbp), %edi
callq 0xe2d0
movl %eax, -0x4(%rbp)
jmp 0x13c2c
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x54f0
movq -0x10(%rbp), %rdi
callq 0x5870
movq %rax, %rcx
movl $0x4, %eax
cmpq %rcx, %rax
je 0x13f73
movq 0x36189(%rip), %rdi     # 0x49fc0
leaq 0x2b2db(%rip), %rsi     # 0x3f119
callq 0x5360
movq %rax, %rdi
movl $0x4, %esi
callq 0x50c0
movq %rax, %rdi
leaq 0x2b2d5(%rip), %rsi     # 0x3f12f
callq 0x5360
movq %rax, %rdi
leaq 0x4977(%rip), %rsi      # 0x187e0
callq 0x5120
movq %rax, %rdi
movl $0x4, %esi
callq 0x50c0
movq %rax, %rdi
leaq 0x498b(%rip), %rsi      # 0x18810
callq 0x5120
movq %rax, %rdi
leaq 0x2b2a0(%rip), %rsi     # 0x3f134
callq 0x5360
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5870
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x57b0
movq %rax, %rdi
leaq 0x2b273(%rip), %rsi     # 0x3f12f
callq 0x5360
movq %rax, %rdi
leaq 0x4915(%rip), %rsi      # 0x187e0
callq 0x5120
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5870
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x57b0
movq %rax, %rdi
leaq 0x491d(%rip), %rsi      # 0x18810
callq 0x5120
movq %rax, %rdi
leaq 0x2d6b6(%rip), %rsi     # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x3606f(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x360a3(%rip), %rdi     # 0x49fc0
leaq 0x2cdca(%rip), %rsi     # 0x40cee
callq 0x5360
movq %rax, %rdi
leaq 0x2c857(%rip), %rsi     # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x5d, %esi
callq 0x5750
movq %rax, %rdi
movq 0x36031(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x2c70f(%rip), %rdi     # 0x4066a
leaq 0x2cd8c(%rip), %rsi     # 0x40cee
movl $0x5d, %edx
leaq 0x2d78f(%rip), %rcx     # 0x416fd
callq 0x51e0
testb $0x1, -0x11(%rbp)
je 0x13f86
movl -0x18(%rbp), %edi
callq 0x13fa0
movl %eax, -0x4(%rbp)
jmp 0x13f8c
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/bowtie_inspect.cpp
// Function: parseInt(int, char const*)
static int parseInt(int lower, const char *errmsg) {
	long l;
	char *endPtr= NULL;
	l = strtol(optarg, &endPtr, 10);
	if (endPtr != NULL) {
		if (l < lower) {
			cerr << errmsg << endl;
			printUsage(cerr);
			throw 1;
		}
		return (int32_t)l;
	}
	cerr << errmsg << endl;
	printUsage(cerr);
	throw 1;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq 0x35e8a(%rip), %rax     # 0x49f88
movq (%rax), %rdi
leaq -0x20(%rbp), %rsi
movl $0xa, %edx
callq 0x55a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1417f
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
cmpq %rcx, %rax
jge 0x14175
movq -0x10(%rbp), %rsi
movq 0x35ebe(%rip), %rdi     # 0x49ff0
callq 0x5360
movq %rax, %rdi
movq 0x35e3f(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x35ea3(%rip), %rdi     # 0x49ff0
callq 0x118a0
movl $0x4, %edi
callq 0x5180
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x35e04(%rip), %rsi     # 0x49f70
xorl %eax, %eax
movl %eax, %edx
callq 0x5720
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rsi
movq 0x35e66(%rip), %rdi     # 0x49ff0
callq 0x5360
movq %rax, %rdi
movq 0x35de7(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x35e4b(%rip), %rdi     # 0x49ff0
callq 0x118a0
movl $0x4, %edi
callq 0x5180
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x35dac(%rip), %rsi     # 0x49f70
xorl %eax, %eax
movl %eax, %edx
callq 0x5720
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x156eb
movq 0x34983(%rip), %rdi     # 0x49fc0
leaq 0x29c03(%rip), %rsi     # 0x3f247
callq 0x5360
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x29bfe(%rip), %rsi     # 0x3f25d
callq 0x5360
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x2bf3e(%rip), %rsi     # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x348f7(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x3492b(%rip), %rdi     # 0x49fc0
leaq 0x2c892(%rip), %rsi     # 0x41f2e
callq 0x5360
movq %rax, %rdi
leaq 0x2b0df(%rip), %rsi     # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x21, %esi
callq 0x5750
movq %rax, %rdi
movq 0x348b9(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x2af97(%rip), %rdi     # 0x4066a
leaq 0x2c854(%rip), %rsi     # 0x41f2e
movl $0x21, %edx
leaq 0x2d30f(%rip), %rcx     # 0x429f5
callq 0x51e0
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x157ae
movq 0x348c0(%rip), %rdi     # 0x49fc0
leaq 0x29b40(%rip), %rsi     # 0x3f247
callq 0x5360
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x29b3b(%rip), %rsi     # 0x3f25d
callq 0x5360
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x2be7b(%rip), %rsi     # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x34834(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x34868(%rip), %rdi     # 0x49fc0
leaq 0x2c7cf(%rip), %rsi     # 0x41f2e
callq 0x5360
movq %rax, %rdi
leaq 0x2b01c(%rip), %rsi     # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x22, %esi
callq 0x5750
movq %rax, %rdi
movq 0x347f6(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x2aed4(%rip), %rdi     # 0x4066a
leaq 0x2c791(%rip), %rsi     # 0x41f2e
movl $0x22, %edx
leaq 0x2d24c(%rip), %rcx     # 0x429f5
callq 0x51e0
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./endian_swap.h
// Function: unsigned long endianizeU<unsigned long>(unsigned long, bool)
static inline T endianizeU(T u, bool toBig) {
	if(toBig == currentlyBigEndian()) {
		return u;
	}
	if(sizeof(T) == 4) {
		return endianSwapU32((uint32_t)u);
	} else if(sizeof(T) == 8) {
		return endianSwapU64((uint64_t)u);
	} else {
		assert(false);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
callq 0x11c90
movb %al, %cl
movl -0x18(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x1790d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1791a
movq -0x10(%rbp), %rdi
callq 0xe4b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./str_util.h
// Function: hash_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static inline int
hash_string(const std::string& s) {
	int ret = 0;
	int a = 63689;
	int b = 378551;
	for(size_t i = 0; i < s.length(); i++) {
		ret = (ret * a) + (int)s[i];
		if(a == 0) {
			a += b;
		} else {
			a *= b;
		}
		if(a == 0) {
			a += b;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0xf8c9, -0x10(%rbp)    # imm = 0xF8C9
movl $0x5c6b7, -0x14(%rbp)   # imm = 0x5C6B7
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5610
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x179d5
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5420
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x179ac
movl -0x14(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x179b6
movl -0x14(%rbp), %eax
imull -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x179c5
movl -0x14(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x179c7
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x17959
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./endian_swap.h
// Function: endianSwapI64(long)
static inline int64_t endianSwapI64(int64_t u) {
        int64_t tmp = 0;
        tmp |= ((u >> 56) & (0xffull <<  0));
        tmp |= ((u >> 40) & (0xffull <<  8));
        tmp |= ((u >> 24) & (0xffull << 16));
        tmp |= ((u >>  8) & (0xffull << 24));
        tmp |= ((u <<  8) & (0xffull << 32));
        tmp |= ((u << 24) & (0xffull << 40));
        tmp |= ((u << 40) & (0xffull << 48));
        tmp |= ((u << 56) & (0xffull << 56));
        return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
sarq $0x38, %rax
andq $0xff, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
sarq $0x28, %rax
andq $0xff00, %rax           # imm = 0xFF00
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
sarq $0x18, %rax
andq $0xff0000, %rax         # imm = 0xFF0000
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
sarq $0x8, %rax
movabsq $0xff000000, %rcx       # imm = 0xFF000000
andq %rcx, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shlq $0x8, %rax
movabsq $0xff00000000, %rcx     # imm = 0xFF00000000
andq %rcx, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shlq $0x18, %rax
movabsq $0xff0000000000, %rcx   # imm = 0xFF0000000000
andq %rcx, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shlq $0x28, %rax
movabsq $0xff000000000000, %rcx # imm = 0xFF000000000000
andq %rcx, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
shlq $0x38, %rax
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
andq %rcx, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./endian_swap.h
// Function: int endianizeI<int>(int, bool)
static inline T endianizeI(T i, bool toBig) {
	if(toBig == currentlyBigEndian()) {
		return i;
	}
	if(sizeof(T) == 4) {
		return endianSwapI32((int32_t)i);
	} else if(sizeof(T) == 8) {
		return endianSwapI64((int64_t)i);
	} else {
		assert(false);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
callq 0x11c90
movb %al, %cl
movl -0x10(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x17b0a
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x17b15
movl -0x8(%rbp), %edi
callq 0x13fa0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movl %r8d, -0x40(%rbp)
movl %ecx, %eax
movl -0x40(%rbp), %ecx
movl %eax, -0x3c(%rbp)
movq %rdx, %rax
movl -0x3c(%rbp), %edx
movq %rax, -0x38(%rbp)
movq %rsi, %rax
movq -0x38(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rdi, %r8
movq -0x30(%rbp), %rdi
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %cl
movb %cl, -0x1d(%rbp)
andb $0x1, %al
movb %al, -0x1e(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17c60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
ja 0x17f2c
movq 0x32140(%rip), %rdi     # 0x49fc0
leaq 0x27271(%rip), %rsi     # 0x3f0f8
callq 0x5360
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x2726c(%rip), %rsi     # 0x3f10e
callq 0x5360
movq %rax, %rdi
xorl %esi, %esi
callq 0x5750
movq %rax, %rdi
leaq 0x296fd(%rip), %rsi     # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x320b6(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x320ea(%rip), %rdi     # 0x49fc0
leaq 0x2a051(%rip), %rsi     # 0x41f2e
callq 0x5360
movq %rax, %rdi
leaq 0x2889e(%rip), %rsi     # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x1e1, %esi            # imm = 0x1E1
callq 0x5750
movq %rax, %rdi
movq 0x32078(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x28756(%rip), %rdi     # 0x4066a
leaq 0x2a013(%rip), %rsi     # 0x41f2e
movl $0x1e1, %edx            # imm = 0x1E1
leaq 0x2aca5(%rip), %rcx     # 0x42bcc
callq 0x51e0
testb $0x1, -0x1e(%rbp)
je 0x17f3f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x141d0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movq -0x18(%rbp), %r10
movq 0x10(%rbp), %rax
xorl %r9d, %r9d
movq %r10, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x37cb0
testb $0x1, -0x1e(%rbp)
je 0x17fa1
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq 0x10(%rbp), %r8
xorl %eax, %eax
movl %eax, %r9d
movq $-0x1, (%rsp)
callq 0x32480
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x189eb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x189df
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x5390
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x18a22
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x18a16
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x5390
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x18a41
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x5030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x305cd(%rip), %rcx     # 0x49cb8
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x19720
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x19714
movq -0x18(%rbp), %rdi
callq 0x5510
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x19752
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x19746
movq -0x20(%rbp), %rdi
callq 0x5510
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x57f0
cmpl $0x0, %eax
je 0x1aa0b
leaq 0x31827(%rip), %rdi     # 0x4c220
leaq 0x25bc0(%rip), %rsi     # 0x405c0
callq 0x5570
movb $0x1, -0x1(%rbp)
jmp 0x1aa0f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
shrq $0x6, %rax
incq %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x5030
movq %rax, -0x40(%rbp)
jmp 0x1b448
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x1b4e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1b542
movq -0x28(%rbp), %rdi
callq 0x5140
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x1b4bb
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x2eb51(%rip), %rdi     # 0x49ff0
callq 0x5360
jmp 0x1b4a6
jmp 0x1b4bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x56a0
jmp 0x1b4e0
movl $0x4, %edi
callq 0x5180
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x2ea9b(%rip), %rsi     # 0x49f70
xorl %eax, %eax
movl %eax, %edx
callq 0x5720
jmp 0x1b553
jmp 0x1b542
movq -0x48(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1b4ef
jmp 0x1b50e
leaq 0x250de(%rip), %rdi     # 0x405d4
leaq 0x250e6(%rip), %rsi     # 0x405e3
movl $0xb0, %edx
leaq 0x250e5(%rip), %rcx     # 0x405ee
callq 0x51e0
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x5190
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x6, %rcx
movq %rcx, 0x10(%rax)
movq $0x0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5760
movq %rax, %rdi
callq 0x18920
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./bitset.h
// Function: Bitset::test(unsigned long) const
bool test(TIndexOffU i) const {
		bool ret = false;
		if(i < _sz) {
			ret = ((_words[i / WORD_SIZE] >> (i & BITSET_MASK)) & 1) != 0;
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x1b5b1
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
andq $0x3f, %rcx
shrq %cl, %rax
andq $0x1, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
jb 0x1b6cb
movq -0x20(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x18(%rbp)
callq 0x2aea0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
ja 0x1b6c6
movq 0x2e9ac(%rip), %rdi     # 0x49fc0
leaq 0x23add(%rip), %rsi     # 0x3f0f8
callq 0x5360
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x23ad4(%rip), %rsi     # 0x3f10e
callq 0x5360
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x25f63(%rip), %rsi     # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x2e91c(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x2e950(%rip), %rdi     # 0x49fc0
leaq 0x24f6c(%rip), %rsi     # 0x405e3
callq 0x5360
movq %rax, %rdi
leaq 0x25104(%rip), %rsi     # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0xd3, %esi
callq 0x5750
movq %rax, %rdi
movq 0x2e8de(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x24fbc(%rip), %rdi     # 0x4066a
leaq 0x24f2e(%rip), %rsi     # 0x405e3
movl $0xd3, %edx
leaq 0x24f56(%rip), %rcx     # 0x40617
callq 0x51e0
jmp 0x1b5d8
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
andq $0x3f, %rcx
shrq %cl, %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x1b6f6
jmp 0x1b715
leaq 0x24f37(%rip), %rdi     # 0x40634
leaq 0x24edf(%rip), %rsi     # 0x405e3
movl $0xd6, %edx
leaq 0x24f07(%rip), %rcx     # 0x40617
callq 0x51e0
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %esi
shlq %cl, %rsi
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rdx
shrq $0x6, %rdx
orq (%rcx,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
andq $0x3f, %rcx
shrq %cl, %rax
andq $0x1, %rax
cmpq $0x1, %rax
jne 0x1b76e
jmp 0x1b78d
leaq 0x24ef7(%rip), %rdi     # 0x4066c
leaq 0x24e67(%rip), %rsi     # 0x405e3
movl $0xd9, %edx
leaq 0x24e8f(%rip), %rcx     # 0x40617
callq 0x51e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x23293
movq 0x26ddb(%rip), %rdi     # 0x49fc0
leaq 0x1c05b(%rip), %rsi     # 0x3f247
callq 0x5360
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x1c056(%rip), %rsi     # 0x3f25d
callq 0x5360
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x1e396(%rip), %rsi     # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x26d4f(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x26d83(%rip), %rdi     # 0x49fc0
leaq 0x1be79(%rip), %rsi     # 0x3f0bd
callq 0x5360
movq %rax, %rdi
leaq 0x1d537(%rip), %rsi     # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x3e0, %esi            # imm = 0x3E0
callq 0x5750
movq %rax, %rdi
movq 0x26d11(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x1d3ef(%rip), %rdi     # 0x4066a
leaq 0x1be3b(%rip), %rsi     # 0x3f0bd
movl $0x3e0, %edx            # imm = 0x3E0
leaq 0x1cdca(%rip), %rcx     # 0x40058
callq 0x51e0
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
ja 0x232ba
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x233b3
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
xorq $-0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shlq %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
jb 0x2339f
movq 0x26cd6(%rip), %rdi     # 0x49fc0
leaq 0x1bf56(%rip), %rsi     # 0x3f247
callq 0x5360
movq %rax, %rdi
movq -0x40(%rbp), %rsi
shlq %rsi
addq $0x1, %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x1bf4a(%rip), %rsi     # 0x3f25d
callq 0x5360
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x1e28a(%rip), %rsi     # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x26c43(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x26c77(%rip), %rdi     # 0x49fc0
leaq 0x1bd6d(%rip), %rsi     # 0x3f0bd
callq 0x5360
movq %rax, %rdi
leaq 0x1d42b(%rip), %rsi     # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x3e5, %esi            # imm = 0x3E5
callq 0x5750
movq %rax, %rdi
movq 0x26c05(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x1d2e3(%rip), %rdi     # 0x4066a
leaq 0x1bd2f(%rip), %rsi     # 0x3f0bd
movl $0x3e5, %edx            # imm = 0x3E5
leaq 0x1ccbe(%rip), %rcx     # 0x40058
callq 0x51e0
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
shlq %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)