LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::MemPoolT<88>::Alloc()
virtual void* Alloc() {
        if ( !_root ) {
            // Need a new block.
            Block* block = new Block();
            _blockPtrs.Push( block );

            for( int i=0; i<COUNT-1; ++i ) {
                block->chunk[i].next = &block->chunk[i+1];
            }
            block->chunk[COUNT-1].next = 0;
            _root = block->chunk;
        }
        void* result = _root;
        _root = _root->next;

        ++_currentAllocs;
        if ( _currentAllocs > _maxAllocs ) {
            _maxAllocs = _currentAllocs;
        }
        _nAllocs++;
        _nUntracked++;
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x68(%rax)
jne 0x1f08d
movl $0xfd0, %edi            # imm = 0xFD0
callq 0x4270
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0xfd0, %edx            # imm = 0xFD0
callq 0x4170
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x20480
movl $0x0, -0x14(%rbp)
cmpl $0x2d, -0x14(%rbp)
jge 0x1f072
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
imulq $0x58, %rax, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x58, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f03c
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, 0xf78(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x28(%rbp), %rcx
movq 0x68(%rcx), %rax
movq %rax, -0x20(%rbp)
movq 0x68(%rcx), %rax
movq (%rax), %rax
movq %rax, 0x68(%rcx)
movl 0x70(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x70(%rcx)
movl 0x70(%rcx), %eax
cmpl 0x78(%rcx), %eax
jle 0x1f0bf
movq -0x28(%rbp), %rax
movl 0x70(%rax), %ecx
movl %ecx, 0x78(%rax)
movq -0x28(%rbp), %rax
movl 0x74(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x74(%rax)
movl 0x7c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x7c(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::MemPoolT<104>::Clear()
void Clear() {
        // Delete the blocks.
        while( !_blockPtrs.Empty()) {
            Block* b  = _blockPtrs.Pop();
            delete b;
        }
        _root = 0;
        _currentAllocs = 0;
        _nAllocs = 0;
        _maxAllocs = 0;
        _nUntracked = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x20dc0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1faf9
jmp 0x1fb23
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x20de0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1fb21
movq -0x20(%rbp), %rdi
callq 0x4230
jmp 0x1fae4
movq -0x18(%rbp), %rax
movq $0x0, 0x68(%rax)
movl $0x0, 0x70(%rax)
movl $0x0, 0x74(%rax)
movl $0x0, 0x78(%rax)
movl $0x0, 0x7c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::DynArray<char, 20>::PushArr(int)
T* PushArr( int count ) {
        EnsureCapacity( _size+count );
        T* ret = &_mem[_size];
        _size += count;
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl 0x20(%rdi), %esi
addl -0xc(%rbp), %esi
callq 0x203d0
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movslq 0x20(%rax), %rdx
addq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::DynArray<char, 20>::EnsureCapacity(int)
void EnsureCapacity( int cap ) {
        if ( cap > _allocated ) {
            int newAllocated = cap * 2;
            T* newMem = new T[newAllocated];
            memcpy( newMem, _mem, sizeof(T)*_size );	// warning: not using constructors, only works for PODs
            if ( _mem != _pool ) {
                delete [] _mem;
            }
            _mem = newMem;
            _allocated = newAllocated;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jle 0x2046b
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rdi
movq $-0x1, %rax
cmpq $0x0, %rdi
cmovlq %rax, %rdi
callq 0x4040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
movslq 0x20(%rax), %rdx
shlq $0x0, %rdx
callq 0x41f0
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x2045a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x20458
movq -0x28(%rbp), %rdi
callq 0x4310
jmp 0x2045a
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x1c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::MemPoolT<104>::Free(void*)
virtual void Free( void* mem ) {
        if ( !mem ) {
            return;
        }
        --_currentAllocs;
        Chunk* chunk = static_cast<Chunk*>( mem );
#ifdef DEBUG
        memset( chunk, 0xfe, sizeof(Chunk) );
#endif
        chunk->next = _root;
        _root = chunk;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2096d
jmp 0x20995
movq -0x20(%rbp), %rax
movl 0x70(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x70(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x68(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x68(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day00/ex00/megaphone.cpp
// Function: main
int main(int argc, char **argv)
{
	if (argc > 1)
	{
		for (int i = 1; i < argc; i++)
			print_capitalized(argv[i]);
		std::cout << std::endl;
	}
	else
		std::cout << "* LOUD AND UNBEARABLE FEEDBACK NOISE *" << std::endl;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x129c
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1287
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1263
movq 0x2d4a(%rip), %rdi      # 0x3fd8
movq 0x2d33(%rip), %rsi      # 0x3fc8
callq 0x1060
jmp 0x12be
movq 0x2d35(%rip), %rdi      # 0x3fd8
leaq 0xd5a(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movq 0x2d0f(%rip), %rsi      # 0x3fc8
callq 0x1060
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: macfergus[P]baduk/cppsrc/apps/benchmark.cpp
// Function: main
int main() {
    for (int i = 0; i < 10000; ++i) {
        auto game = baduk::newGame(9, 7.5);
        baduk::RandomBot black_bot;
        baduk::RandomBot white_bot;

        while (!game->isOver()) {
            auto next_agent =
                game->nextPlayer() == baduk::Stone::black ?
                    &black_bot :
                    &white_bot;
            const auto next_move = next_agent->selectMove(*game);

            game = game->applyMove(next_move);
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x2710, -0x8(%rbp)     # imm = 0x2710
jge 0x4016e
leaq -0x18(%rbp), %rdi
movl $0x9, %esi
movss 0x161d(%rip), %xmm0     # 0x41634
callq 0x44a0
leaq -0x28(%rbp), %rdi
callq 0xb810
jmp 0x40027
leaq -0x48(%rbp), %rdi
callq 0xb810
jmp 0x40032
jmp 0x40034
leaq -0x18(%rbp), %rdi
callq 0xb8c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
movb %al, -0x81(%rbp)
jmp 0x40051
movb -0x81(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x40062
jmp 0x40157
leaq -0x18(%rbp), %rdi
callq 0xb8c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movl %eax, -0x88(%rbp)
jmp 0x4007f
movl -0x88(%rbp), %eax
cmpl $0x0, %eax
jne 0x40097
leaq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x400a4
leaq -0x48(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x400a4
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb8e0
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movb %dl, -0x99(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x400e4
movb -0x99(%rbp), %al
movq -0x98(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
movb -0x68(%rbp), %al
movb %al, -0x58(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb8c0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq *%rax
jmp 0x40125
leaq -0x18(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xb910
leaq -0x80(%rbp), %rdi
callq 0xb940
jmp 0x40034
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb960
jmp 0x40179
leaq -0x18(%rbp), %rdi
callq 0xb960
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3fff9
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3370
// File: BenLangmead[P]bowtie/ebwt_build.cpp
// Function: resetOptions()
static void resetOptions() {
	verbose      = true;  // be talkative (default)
	sanityCheck  = 0;     // do slow sanity checks
	format       = FASTA; // input sequence format
	bmax         = OFF_MASK; // max blockwise SA bucket size
	bmaxMultSqrt = OFF_MASK; // same, as multplier of sqrt(n)
	bmaxDivN     = 4;          // same, as divisor of n
	dcv          = 1024;  // bwise SA difference-cover sample sz
	noDc         = 0;     // disable difference-cover sample
	entireSA     = 0;     // 1 = disable blockwise SA
	seed         = 0;     // srandom seed
	showVersion  = 0;     // just print version and quit?
	doubleEbwt   = true;  // build forward and reverse Ebwts
	//   Ebwt parameters
	lineRate     = Ebwt::default_lineRate;  // a "line" is 64 bytes
	linesPerSide = 1;  // 1 64-byte line on a side
	offRate      = 5;  // sample 1 out of 32 SA elts
	ftabChars    = 10; // 10 chars in initial lookup table
	bigEndian    = 0;  // little endian
	nsToAs       = false; // convert reference Ns to As prior to indexing
	autoMem      = true;  // automatically adjust memory usage parameters
	packed       = false; //
	writeRef     = true;  // write compact reference to .3.ebwt/.4.ebwt
	justRef      = false; // *just* write compact reference, don't index
	reverseType  = REF_READ_REVERSE_EACH;
	nthreads     = 1;
	wrapper.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, 0x47a51(%rip)     # 0x54e7c
movl $0x0, 0x47a73(%rip)     # 0x54ea8
movl $0x1, 0x47a71(%rip)     # 0x54eb0
movl $0xffffffff, 0x47a4b(%rip) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x47a45(%rip) # imm = 0xFFFFFFFF
movl $0x4, 0x47a3f(%rip)     # 0x54e9c
movl $0x400, 0x47a39(%rip)   # imm = 0x400
movl $0x0, 0x47a47(%rip)     # 0x54eb8
movl $0x0, 0x47a41(%rip)     # 0x54ebc
movl $0x0, 0x47a27(%rip)     # 0x54eac
movl $0x0, 0x479e9(%rip)     # 0x54e78
movb $0x1, 0x47a1f(%rip)     # 0x54eb5
movl $0x6, 0x479e0(%rip)     # 0x54e80
movl $0x1, 0x479da(%rip)     # 0x54e84
movl $0x5, 0x479d4(%rip)     # 0x54e88
movl $0xa, 0x479ce(%rip)     # 0x54e8c
movl $0x0, 0x479dc(%rip)     # 0x54ea4
movb $0x0, 0x479f1(%rip)     # 0x54ec0
movb $0x1, 0x479de(%rip)     # 0x54eb4
movb $0x0, 0x479b3(%rip)     # 0x54e90
movb $0x1, 0x479dd(%rip)     # 0x54ec1
movb $0x0, 0x479d7(%rip)     # 0x54ec2
movl $0x2, 0x479cf(%rip)     # 0x54ec4
movl $0x1, 0x479c9(%rip)     # 0x54ec8
leaq 0x4794a(%rip), %rdi     # 0x54e50
callq 0x65c0
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./tokenize.h
// Function: tokenize(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&, EList<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 128>&, unsigned long)
static inline void tokenize(
	const string& s,
	const string& delims,
	EList<string>& ss,
	size_t max = std::numeric_limits<size_t>::max())
{
	string::size_type lastPos = s.find_first_not_of(delims, 0);
	string::size_type pos = s.find_first_of(delims, lastPos);
	while (string::npos != pos || string::npos != lastPos) {
		ss.push_back(s.substr(lastPos, pos - lastPos));
		lastPos = s.find_first_not_of(delims, pos);
		pos = s.find_first_of(delims, lastPos);
		if(ss.size() == (max - 1)) {
			pos = string::npos;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x6330
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6390
movq %rax, -0x30(%rbp)
movb $0x1, %al
movq $-0x1, %rcx
cmpq -0x30(%rbp), %rcx
movb %al, -0x5d(%rbp)
jne 0xe1b5
movq $-0x1, %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x5d(%rbp)
movb -0x5d(%rbp), %al
testb $0x1, %al
jne 0xe1c1
jmp 0xe263
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
subq %rdx, %rcx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x6460
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x15e60
jmp 0xe1f4
leaq -0x50(%rbp), %rdi
callq 0x69a8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x6330
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6390
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15ee0
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0xe25e
movq $-0x1, -0x30(%rbp)
jmp 0xe25e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x69a8
jmp 0xe269
jmp 0xe192
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/ebwt_build.cpp
// Function: int parseNumber<int>(int, char const*)
static int parseNumber(T lower, const char *errmsg) {
	char *endPtr= NULL;
	T t = (T)strtol(optarg, &endPtr, 10);
	if (endPtr != NULL) {
		if (t < lower) {
			cerr << errmsg << endl;
			printUsage(cerr);
			throw 1;
		}
		return t;
	}
	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, -0x18(%rbp)
movq 0x41b72(%rip), %rax     # 0x51f70
movq (%rax), %rdi
leaq -0x18(%rbp), %rsi
movl $0xa, %edx
callq 0x6660
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10478
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1046f
movq -0x10(%rbp), %rsi
movq 0x41bc4(%rip), %rdi     # 0x51ff0
callq 0x6410
movq %rax, %rdi
movq 0x41b2d(%rip), %rsi     # 0x51f68
callq 0x6470
movq 0x41ba9(%rip), %rdi     # 0x51ff0
callq 0xd9f0
movl $0x4, %edi
callq 0x61f0
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x41aea(%rip), %rsi     # 0x51f50
xorl %eax, %eax
movl %eax, %edx
callq 0x67f0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rsi
movq 0x41b6d(%rip), %rdi     # 0x51ff0
callq 0x6410
movq %rax, %rdi
movq 0x41ad6(%rip), %rsi     # 0x51f68
callq 0x6470
movq 0x41b52(%rip), %rdi     # 0x51ff0
callq 0xd9f0
movl $0x4, %edi
callq 0x61f0
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x41a93(%rip), %rsi     # 0x51f50
xorl %eax, %eax
movl %eax, %edx
callq 0x67f0
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: fileSize(char const*)
static inline int64_t fileSize(const char* name) {
	std::ifstream f;
	f.open(name, std::ios_base::binary | std::ios_base::in);
	if (!f.good() || f.eof() || !f.is_open()) { return 0; }
	f.seekg(0, std::ios_base::beg);
	std::ifstream::pos_type begin_pos = f.tellg();
	f.seekg(0, std::ios_base::end);
	return static_cast<int64_t>(f.tellg() - begin_pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x10(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x6510
movq -0x10(%rbp), %rax
movq %rax, -0x258(%rbp)
movl $0x4, %edi
movl $0x8, %esi
callq 0x32650
movl %eax, -0x24c(%rbp)
jmp 0x11a1d
movl -0x24c(%rbp), %edx
movq -0x258(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x6240
jmp 0x11a38
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x67d0
movb %al, -0x259(%rbp)
jmp 0x11a58
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x11a64
jmp 0x11ab0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x68c0
movb %al, -0x25a(%rbp)
jmp 0x11a84
movb -0x25a(%rbp), %al
testb $0x1, %al
jne 0x11ab0
jmp 0x11a90
leaq -0x218(%rbp), %rdi
callq 0x6750
movb %al, -0x25b(%rbp)
jmp 0x11aa4
movb -0x25b(%rbp), %al
testb $0x1, %al
jne 0x11aea
jmp 0x11ab0
movq $0x0, -0x8(%rbp)
movl $0x1, -0x228(%rbp)
jmp 0x11bb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x6120
jmp 0x11bcd
xorl %edx, %edx
movl %edx, %esi
leaq -0x218(%rbp), %rdi
callq 0x6610
jmp 0x11afc
leaq -0x218(%rbp), %rdi
callq 0x6840
movq %rdx, -0x270(%rbp)
movq %rax, -0x268(%rbp)
jmp 0x11b18
movq -0x270(%rbp), %rax
movq -0x268(%rbp), %rcx
movq %rcx, -0x238(%rbp)
movq %rax, -0x230(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x218(%rbp), %rdi
movl $0x2, %edx
callq 0x6610
jmp 0x11b4b
leaq -0x218(%rbp), %rdi
callq 0x6840
movq %rdx, -0x280(%rbp)
movq %rax, -0x278(%rbp)
jmp 0x11b67
movq -0x280(%rbp), %rax
movq -0x278(%rbp), %rcx
movq %rcx, -0x248(%rbp)
movq %rax, -0x240(%rbp)
leaq -0x248(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x32670
movq %rax, -0x288(%rbp)
jmp 0x11b9f
movq -0x288(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x6120
movq -0x8(%rbp), %rax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x6850
nopl (%rax)
// File: BenLangmead[P]bowtie/./diff_sample.h
// Function: unsigned int myLog2<unsigned int>(unsigned int)
static unsigned int myLog2(T i) {
	assert_eq(1, popCount(i)); // must be power of 2
	for(size_t j = 0; j < sizeof(T)*8; j++) {
		if(i & 1) return (int)j;
		i >>= 1;
	}
	assert(false);
	return 0xffffffff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x20, -0x10(%rbp)
jae 0x126a0
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1268a
movq -0x10(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x126a7
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1266f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./diff_sample.h
// Function: void VSorting_worker<SString<char>>(void*)
static void VSorting_worker(void *vp)
{
        VSortingParam<TStr>* param = (VSortingParam<TStr>*)vp;
	DifferenceCoverSample<TStr>* dcs = param->dcs;
	const TStr& host = dcs->text();
	const size_t hlen = host.length();
	uint32_t v = dcs->v();
	while(true) {
	  size_t cur = 0;
	  {
	    ThreadSafe ts(param->mutex);
	    cur = *(param->cur);
	    (*param->cur)++;
	  }
	  if(cur >= param->boundaries->size()) return;
	  size_t begin = (cur == 0 ? 0 : (*param->boundaries)[cur-1]);
	  size_t end = (*param->boundaries)[cur];
	  assert_leq(begin, end);
	  if(end - begin <= 1) continue;
	  mkeyQSortSuf2(
			host,
			hlen,
			param->sPrimeArr,
			param->sPrimeSz,
			param->sPrimeOrderArr,
			4,
			begin,
			end,
			param->depth,
			v);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2a550
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x14c10
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2a570
movl %eax, -0x3c(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x26660
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x26690
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x19e40
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jb 0x1276b
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpq $0x0, -0x48(%rbp)
jne 0x1277a
xorl %eax, %eax
movq %rax, -0x70(%rbp)
jmp 0x12796
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x48(%rbp), %rsi
subq $0x1, %rsi
callq 0x2cd30
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x48(%rbp), %rsi
callq 0x2cd30
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
subq -0x58(%rbp), %rax
cmpq $0x1, %rax
ja 0x127c9
jmp 0x126fb
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %r8
movq -0x58(%rbp), %rbx
movq -0x60(%rbp), %r11
movq -0x20(%rbp), %rax
movq 0x20(%rax), %r10
movl -0x3c(%rbp), %eax
movl $0x4, %r9d
xorl %r14d, %r14d
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
callq 0x2b260
jmp 0x126fb
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./diff_sample.h
// Function: bool suffixSameUpTo<SString<char>>(SString<char> const&, unsigned int, unsigned int, unsigned int)
static inline bool suffixSameUpTo(
	const TStr& host,
	TIndexOffU suf1,
	TIndexOffU suf2,
	TIndexOffU v)
{
	for(TIndexOffU i = 0; i < v; i++) {
		bool endSuf1 = suf1+i >= host.length();
		bool endSuf2 = suf2+i >= host.length();
		if((endSuf1 && !endSuf2) || (!endSuf1 && endSuf2)) return false;
		if(endSuf1 && endSuf2) return true;
		if(host[suf1+i] != host[suf2+i]) return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x12925
movl -0x14(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14c10
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
setae %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movl -0x18(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14c10
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
setae %al
andb $0x1, %al
movb %al, -0x22(%rbp)
testb $0x1, -0x21(%rbp)
je 0x128b2
testb $0x1, -0x22(%rbp)
je 0x128be
testb $0x1, -0x21(%rbp)
jne 0x128c4
testb $0x1, -0x22(%rbp)
je 0x128c4
movb $0x0, -0x1(%rbp)
jmp 0x12929
testb $0x1, -0x21(%rbp)
je 0x128d6
testb $0x1, -0x22(%rbp)
je 0x128d6
movb $0x1, -0x1(%rbp)
jmp 0x12929
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x14c30
movsbl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x14c30
movq %rax, %rcx
movl -0x3c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x12915
movb $0x0, -0x1(%rbp)
jmp 0x12929
jmp 0x12917
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1284c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./multikey_qsort.h
// Function: void vecswap2<unsigned int, unsigned long>(unsigned int*, unsigned long, unsigned int*, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long)
static inline void vecswap2(TVal* s, size_t slen, TVal* s2, TPos i, TPos j, TPos n, TPos begin, TPos end) {
	assert_geq(i, begin);
	assert_geq(j, begin);
	assert_lt(i, end);
	assert_lt(j, end);
	while(n-- > 0) {
		assert_geq(n, 0);
		TPos a = i+n;
		TPos b = j+n;
		assert_geq(a, begin);
		assert_geq(b, begin);
		assert_lt(a, end);
		assert_lt(b, end);
		swap(s, slen, a, b);
		swap(s2, slen, a, b);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x30(%rbp)
cmpq $0x0, %rax
jbe 0x129c1
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x10f10
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x10f10
jmp 0x12968
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./blockwise_sa.h
// Function: void BinarySorting_worker<SString<char>>(void*)
static void BinarySorting_worker(void *vp)
{
	BinarySortingParam<TStr>* param = (BinarySortingParam<TStr>*)vp;
	const TStr& t = *(param->t);
	size_t len = t.length();
	const EList<TIndexOffU>& sampleSuffs = *(param->sampleSuffs);
	EList<TIndexOffU>& bucketSzs = param->bucketSzs;
	EList<TIndexOffU>& bucketReps = param->bucketReps;
	ASSERT_ONLY(size_t numBuckets = bucketSzs.size());
	size_t begin = param->begin;
	size_t end = param->end;
	// Iterate through every suffix in the text, determine which
	// bucket it falls into by doing a binary search across the
	// sorted list of samples, and increment a counter associated
	// with that bucket.  Also, keep one representative for each
	// bucket so that we can split it later.  We loop in ten
	// stretches so that we can print out a helpful progress
	// message.  (This step can take a long time.)
	for(TIndexOffU i = (TIndexOffU)begin; i < end && i < len; i++) {
		TIndexOffU r = binarySASearch(t, i, sampleSuffs);
		if(r == std::numeric_limits<TIndexOffU>::max()) continue; // r was one of the samples
		assert_lt(r, numBuckets);
		bucketSzs[r]++;
		assert_lt(bucketSzs[r], len);
		if(bucketReps[r] == OFF_MASK || (i & 100) == 0) {
			bucketReps[r] = i; // clobbers previous one, but that's OK
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14c10
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq -0x48(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0x12a5c
movl -0x4c(%rbp), %eax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x12a68
jmp 0x12aed
movq -0x18(%rbp), %rdi
movl -0x4c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x30010
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x58(%rbp)
callq 0x30260
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
jne 0x12a91
jmp 0x12adf
movq -0x30(%rbp), %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
callq 0x14410
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
callq 0x14410
cmpl $-0x1, (%rax)
je 0x12ac4
movl -0x4c(%rbp), %eax
andl $0x64, %eax
cmpl $0x0, %eax
jne 0x12add
movl -0x4c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
callq 0x14410
movl -0x5c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x12adf
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x12a3f
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./blockwise_sa.h
// Function: unsigned int lookupSuffixZ<SString<char>>(SString<char> const&, unsigned int, unsigned int, EList<unsigned int, 128> const&)
static TIndexOffU lookupSuffixZ(
	const T& t,
	TIndexOffU zOff,
	TIndexOffU off,
	const EList<TIndexOffU>& z)
{
	if(zOff < z.size()) {
		TIndexOffU ret = z[zOff];
		assert_eq(ret, suffixLcp(t, off + zOff, off));
		return ret;
	}
	assert_leq(off + zOff, t.length());
	return suffixLcp(t, off + zOff, off);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14440
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x12b4d
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x19d10
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12b62
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
addl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x12b70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./blockwise_sa.h
// Function: unsigned int suffixLcp<SString<char>>(SString<char> const&, unsigned int, unsigned int)
inline
static TIndexOffU suffixLcp(const T& t, TIndexOffU aOff, TIndexOffU bOff) {
	TIndexOffU c = 0;
	size_t len = t.length();
	assert_leq(aOff, len);
	assert_leq(bOff, len);
	while(aOff + c < len && bOff + c < len && t[aOff + c] == t[bOff + c]) c++;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14c10
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x21(%rbp)
jae 0x12bfd
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x21(%rbp)
jae 0x12bfd
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x14c30
movsbl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x14c30
movq %rax, %rcx
movl -0x28(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x12c06
jmp 0x12c11
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12b96
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::isGzippedFile(char const*)
static bool isGzippedFile(const char *filename) {
		if (filename == NULL) {
			return false;
		}

		int fd = open(filename, O_RDONLY);
		if (fd == -1) {
			std::cerr << "Unable to open " << filename << std::endl;
			throw 1;
		}

		uint8_t byte1, byte2;

		ssize_t r1 = read(fd, &byte1, sizeof(uint8_t));
		ssize_t r2 = read(fd, &byte2, sizeof(uint8_t));

		if (::close(fd) == -1) {
			std::cerr << "Unable to close " << filename << std::endl;
			throw 1;
		}

		if (r1 == 0 || r2 == 0) {
                        std::cerr << "Unable to read file magic number" << std::endl;
                        return false;
                }

		if (byte1 == 0x1f && byte2 == 0x8b) {
			return true;
		}

		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b26c
movb $0x0, -0x1(%rbp)
jmp 0x1b3af
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x6820
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1b2d3
movq 0x36d67(%rip), %rdi     # 0x51ff0
leaq 0x2aaa8(%rip), %rsi     # 0x45d38
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6410
movq %rax, %rdi
movq 0x36cbd(%rip), %rsi     # 0x51f68
callq 0x6470
movl $0x4, %edi
callq 0x61f0
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x36c86(%rip), %rsi     # 0x51f50
xorl %eax, %eax
movl %eax, %edx
callq 0x67f0
movl -0x14(%rbp), %edi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x6680
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
leaq -0x16(%rbp), %rsi
movl $0x1, %edx
callq 0x6680
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x6960
cmpl $-0x1, %eax
jne 0x1b35b
movq 0x36cdf(%rip), %rdi     # 0x51ff0
leaq 0x2aa30(%rip), %rsi     # 0x45d48
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6410
movq %rax, %rdi
movq 0x36c35(%rip), %rsi     # 0x51f68
callq 0x6470
movl $0x4, %edi
callq 0x61f0
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x36bfe(%rip), %rsi     # 0x51f50
xorl %eax, %eax
movl %eax, %edx
callq 0x67f0
cmpq $0x0, -0x20(%rbp)
je 0x1b369
cmpq $0x0, -0x28(%rbp)
jne 0x1b391
movq 0x36c80(%rip), %rdi     # 0x51ff0
leaq 0x2a9e2(%rip), %rsi     # 0x45d59
callq 0x6410
movq %rax, %rdi
movq 0x36be2(%rip), %rsi     # 0x51f68
callq 0x6470
movb $0x0, -0x1(%rbp)
jmp 0x1b3af
movzbl -0x15(%rbp), %eax
cmpl $0x1f, %eax
jne 0x1b3ab
movzbl -0x16(%rbp), %eax
cmpl $0x8b, %eax
jne 0x1b3ab
movb $0x1, -0x1(%rbp)
jmp 0x1b3af
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./filebuf.h
// Function: BitpairOutFileBuf::BitpairOutFileBuf(char const*)
BitpairOutFileBuf(const char *in) : bpPtr_(0), cur_(0) {
		assert(in != NULL);
		out_ = fopen(in, "wb");
		if(out_ == NULL) {
			std::cerr << "Error: Could not open bitpair-output file " << in << std::endl;
			throw 1;
		}
		memset(buf_, 0, BUF_SZ);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
leaq 0x2a838(%rip), %rsi     # 0x45d7a
callq 0x6500
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x1b5a8
movq 0x36a92(%rip), %rdi     # 0x51ff0
leaq 0x2a818(%rip), %rsi     # 0x45d7d
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6410
movq %rax, %rdi
movq 0x369e8(%rip), %rsi     # 0x51f68
callq 0x6470
movl $0x4, %edi
callq 0x61f0
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x369b1(%rip), %rsi     # 0x51f50
xorl %eax, %eax
movl %eax, %edx
callq 0x67f0
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x20000, %edx          # imm = 0x20000
callq 0x6200
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./filebuf.h
// Function: BitpairOutFileBuf::close()
void close() {
		if(cur_ > 0 || bpPtr_ > 0) {
			if(bpPtr_ == 0) cur_--;
			if(!fwrite((const void *)buf_, cur_ + 1, 1, out_)) {
				std::cerr << "Error writing to the reference index file (.4.ebwt)" << std::endl;
				throw 1;
			}
		}
		fclose(out_);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10(%rax)
ja 0x1b6d9
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1b760
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x1b6f3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x10(%rax), %rsi
addq $0x1, %rsi
movq (%rax), %rcx
movl $0x1, %edx
callq 0x6930
cmpq $0x0, %rax
jne 0x1b75e
movq 0x368d0(%rip), %rdi     # 0x51ff0
leaq 0x2a681(%rip), %rsi     # 0x45da8
callq 0x6410
movq %rax, %rdi
movq 0x36832(%rip), %rsi     # 0x51f68
callq 0x6470
movl $0x4, %edi
callq 0x61f0
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x367fb(%rip), %rsi     # 0x51f50
xorl %eax, %eax
movl %eax, %edx
callq 0x67f0
jmp 0x1b760
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6420
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SString<char>::reverse()
void reverse() {
		for(size_t i = 0; i < (len_ >> 1); i++) {
			T tmp = get(i);
			set(get(len_-i-1), i);
			set(tmp, len_-i-1);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rcx), %rcx
shrq %rcx
cmpq %rcx, %rax
jae 0x1cd7e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x221b0
movq -0x20(%rbp), %rdi
movb (%rax), %al
movb %al, -0x11(%rbp)
movq 0x18(%rdi), %rsi
subq -0x10(%rbp), %rsi
subq $0x1, %rsi
callq 0x221b0
movq -0x20(%rbp), %rdi
movsbl (%rax), %esi
movq -0x10(%rbp), %rdx
callq 0x21f30
movq -0x20(%rbp), %rdi
movsbl -0x11(%rbp), %esi
movq 0x18(%rdi), %rdx
subq -0x10(%rbp), %rdx
subq $0x1, %rdx
callq 0x21f30
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1cd0c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SString<char>::toZBufXForm(char const*) const
const char* toZBufXForm(const char *xform) const {
		ASSERT_ONLY(size_t xformElts = strlen(xform));
		// Lazily allocate space for print buffer
		if(printcs_ == NULL) {
			const_cast<char*&>(printcs_) = new char[len_+1];
		}
		char* printcs = const_cast<char*>(printcs_);
		assert(printcs != NULL);
		for(size_t i = 0; i < len_; i++) {
			assert_lt(cs_[i], (int)xformElts);
			printcs[i] = xform[(int)cs_[i]];
		}
		printcs[len_] = 0;
		return printcs_;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x1cdcb
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x1, %rdi
callq 0x6040
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x1ce20
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1cddf
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rax), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x10(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::joinedLen(EList<RefRecord, 128>&)
TIndexOffU joinedLen(EList<RefRecord>& szs) {
		TIndexOffU ret = 0;
		for(unsigned int i = 0; i < szs.size(); i++) {
			ret += szs[i].len;
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b600
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x1d3fc
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x1b620
movl 0x4(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d3be
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./diff_sample.h
// Function: DifferenceCoverSample<SString<char>>::simulateAllocs(SString<char> const&, unsigned int)
static size_t simulateAllocs(const TStr& text, uint32_t v) {
		EList<uint32_t> ds = getDiffCover(v, false /*verbose*/, false /*sanity*/);
		size_t len = text.length();
		size_t sPrimeSz = (len / v) * ds.size();
		// sPrime, sPrimeOrder, _isaPrime all exist in memory at
		// once and that's the peak
		AutoArray<TIndexOffU> aa(sPrimeSz * 3 + (1024 * 1024 /*out of caution*/));
		return sPrimeSz * 4; // sPrime array
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
xorl %ecx, %ecx
movl %ecx, -0x74(%rbp)
movl %ecx, %edx
callq 0x12080
movq -0x8(%rbp), %rdi
callq 0x14c10
movq -0x80(%rbp), %rdi
movl -0x74(%rbp), %edx
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
divq %rcx
movq %rax, -0x70(%rbp)
callq 0x14440
movl -0x74(%rbp), %edx
movq %rax, %rcx
movq -0x70(%rbp), %rax
imulq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
leaq 0x100000(%rax,%rax,2), %rsi
leaq -0x58(%rbp), %rdi
callq 0x1fff0
jmp 0x1fe99
movq -0x40(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x20070
leaq -0x30(%rbp), %rdi
callq 0x1d0c0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d0c0
movq -0x60(%rbp), %rdi
callq 0x6850
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./ds.h
// Function: AutoArray<unsigned char>::AutoArray(unsigned long, int)
AutoArray(size_t sz, int cat = 0) : cat_(cat) {
		t_ = NULL;
		t_ = new T[sz];
#ifdef USE_MEM_TALLY
		gMemTally.add(cat_, sz);
#else
		(void)cat_;
#endif
		memset(t_, 0, sz * sizeof(T));
		sz_ = sz;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x6040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rdx
shlq $0x0, %rdx
xorl %esi, %esi
callq 0x6200
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./blockwise_sa.h
// Function: KarkkainenBlockwiseSA<SString<char>>::simulateAllocs(SString<char> const&, unsigned int)
static size_t simulateAllocs(const TStr& text, TIndexOffU bucketSz) {
		size_t len = text.length();
		// _sampleSuffs and _itrBucket are in memory at the peak
		size_t bsz = bucketSz;
		size_t sssz = len / max<TIndexOffU>(bucketSz-1, 1);
		AutoArray<TIndexOffU> tmp(bsz + sssz + (1024 * 1024 /*out of caution*/));
		return bsz;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14c10
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl $0x1, -0x30(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1fd60
movq %rax, %rcx
movq -0x58(%rbp), %rax
movl (%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
addq -0x28(%rbp), %rsi
addq $0x100000, %rsi         # imm = 0x100000
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq 0x1fff0
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20070
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./ds.h
// Function: AutoArray<unsigned int>::~AutoArray()
~AutoArray() {
		if(t_ != NULL) {
			delete[] t_;
#ifdef USE_MEM_TALLY
			gMemTally.del(cat_, sz_);
#endif
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x200a8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x200a6
movq -0x18(%rbp), %rdi
callq 0x65b0
jmp 0x200a8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./blockwise_sa.h
// Function: KarkkainenBlockwiseSA<SString<char>>::~KarkkainenBlockwiseSA()
noexcept(false)
#endif
		{
			if(_dc != NULL) delete _dc; // difference cover sample
			if (_done != NULL) {
				delete[] _done;
				_done = NULL;
			}
			if(_threads.size() > 0) {
				for (size_t tid = 0; tid < _threads.size(); tid++) {
					_threads[tid]->join();
					delete _threads[tid];
				}
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x30065(%rip), %rcx     # 0x51a70
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x78(%rax)
je 0x21a44
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x21a42
movq -0x30(%rbp), %rdi
callq 0x32530
movq -0x30(%rbp), %rdi
movl $0xc8, %esi
callq 0x6440
jmp 0x21a44
movq -0x28(%rbp), %rax
cmpq $0x0, 0x128(%rax)
je 0x21a7f
movq -0x28(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x21a70
movq -0x38(%rbp), %rdi
callq 0x65b0
movq -0x28(%rbp), %rax
movq $0x0, 0x128(%rax)
movq -0x28(%rbp), %rdi
addq $0xc8, %rdi
callq 0x25570
cmpq $0x0, %rax
jbe 0x21bac
movq $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0xc8, %rdi
callq 0x25570
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x21baa
movq -0x28(%rbp), %rdi
addq $0xc8, %rdi
movq -0x10(%rbp), %rsi
callq 0x32590
movq %rax, -0x48(%rbp)
jmp 0x21ae3
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x67e0
jmp 0x21af1
movq -0x28(%rbp), %rdi
addq $0xc8, %rdi
movq -0x10(%rbp), %rsi
callq 0x32590
movq %rax, -0x50(%rbp)
jmp 0x21b0b
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x21b33
movq -0x58(%rbp), %rdi
callq 0x325c0
movq -0x58(%rbp), %rdi
movl $0x8, %esi
callq 0x6440
jmp 0x21b35
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x21aa1
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
addq $0x108, %rdi            # imm = 0x108
callq 0x22bd0
movq -0x28(%rbp), %rdi
addq $0xe8, %rdi
callq 0x22c00
movq -0x28(%rbp), %rdi
addq $0xc8, %rdi
callq 0x22c30
movq -0x28(%rbp), %rdi
addq $0xa0, %rdi
callq 0x69a8
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
callq 0x1d0c0
movq -0x28(%rbp), %rdi
callq 0x25300
jmp 0x21c08
jmp 0x21bac
movq -0x28(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x22bd0
movq -0x28(%rbp), %rdi
addq $0xe8, %rdi
callq 0x22c00
movq -0x28(%rbp), %rdi
addq $0xc8, %rdi
callq 0x22c30
movq -0x28(%rbp), %rdi
addq $0xa0, %rdi
callq 0x69a8
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
callq 0x1d0c0
movq -0x28(%rbp), %rdi
callq 0x25300
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SString<char>::reverseWindow(unsigned long, unsigned long)
void reverseWindow(size_t off, size_t len) {
		assert_leq(off, len_);
		assert_leq(off + len, len_);
		size_t mid = len >> 1;
		for(size_t i = 0; i < mid; i++) {
			T tmp = get(off+i);
			set(get(off+len-i-1), off+i);
			set(tmp, off+len-i-1);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x22007
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x28(%rbp), %rsi
callq 0x221b0
movq -0x38(%rbp), %rdi
movb (%rax), %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rsi
addq -0x18(%rbp), %rsi
subq -0x28(%rbp), %rsi
subq $0x1, %rsi
callq 0x221b0
movq -0x38(%rbp), %rdi
movsbl (%rax), %esi
movq -0x10(%rbp), %rdx
addq -0x28(%rbp), %rdx
callq 0x21f30
movq -0x38(%rbp), %rdi
movsbl -0x29(%rbp), %esi
movq -0x10(%rbp), %rdx
addq -0x18(%rbp), %rdx
subq -0x28(%rbp), %rdx
subq $0x1, %rdx
callq 0x21f30
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x21f8f
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)