LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
setne %cl
movl 0x8(%rdi), %eax
testl %eax, %eax
setg %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xefa1
testl %eax, %eax
jne 0xef8a
decq %rsi
movq %rsi, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
incq %rsi
movq (%rbx), %rcx
pushq $0x1
popq %rdx
callq 0x5720
testq %rax, %rax
je 0xefaa
movq (%rbx), %rdi
popq %rbx
jmp 0x5360
movq 0x2303f(%rip), %rdi     # 0x31ff0
leaq 0x16e80(%rip), %rsi     # 0x25e38
callq 0x5350
movq %rax, %rdi
callq 0x5180
pushq $0x4
popq %rdi
callq 0x5190
movl $0x1, (%rax)
movq 0x22f86(%rip), %rsi     # 0x31f60
movq %rax, %rdi
xorl %edx, %edx
callq 0x5630
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: SString<char> Ebwt::join<SString<char>>(EList<FileBuf*, 128>&, EList<RefRecord, 128>&, unsigned int, RefReadInParams const&, unsigned int)
TStr Ebwt::join(EList<FileBuf*>& l,
		EList<RefRecord>& szs,
		TIndexOffU sztot,
		const RefReadInParams& refparams,
		uint32_t seed)
{
	RandomSource rand; // reproducible given same seed
	rand.init(seed);
	RefReadInParams rpcp = refparams;
	TStr ret;
	size_t guessLen = sztot;
	ret.resize(guessLen);
	TIndexOffU dstoff = 0;
	ASSERT_ONLY(size_t szsi = 0);
	for(size_t i = 0; i < l.size(); i++) {
		// For each sequence we can pull out of istream l[i]...
		assert(!l[i]->eof());
		bool first = true;
		while(!l[i]->eof()) {
			RefRecord rec = fastaRefReadAppend(*l[i], first, ret, dstoff, rpcp);
#ifndef ACCOUNT_FOR_ALL_GAP_REFS
			if(rec.first && rec.len == 0) rec.first = false;
#endif
			first = false;
			size_t bases = rec.len;
			assert_eq(rec.off, szs[szsi].off);
			assert_eq(rec.len, szs[szsi].len);
			assert_eq(rec.first, szs[szsi].first);
			ASSERT_ONLY(szsi++);
			if(bases == 0) continue;
		}
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%r8), %rax
movq %rax, (%rsp)
leaq 0x21fe7(%rip), %rax     # 0x31a48
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
movl %ecx, %esi
callq 0xb54a
leaq 0xc(%rsp), %r15
andl $0x0, (%r15)
xorl %r13d, %r13d
movq %rsp, %r12
cmpq 0x18(%r14), %r13
jae 0xfac6
movb $0x1, %al
movq 0x8(%r14), %rcx
movq (%rcx,%r13,8), %rdi
movq 0x20(%rdi), %rcx
cmpq 0x28(%rdi), %rcx
jne 0xfaa6
testb $0x1, 0x30(%rdi)
jne 0xfac1
movzbl %al, %esi
andl $0x1, %esi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %r9d, %r9d
callq 0xabff
xorl %eax, %eax
jmp 0xfa8e
incq %r13
jmp 0xfa86
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xfad9
movq %rax, %r14
movq %rbx, %rdi
callq 0xb646
movq %r14, %rdi
callq 0x5680
// File: /workspace/github_cpp_makefile_star2_O2/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 $-0x1
popq %rax
xorl %ecx, %ecx
movq 0x18(%rdi), %rdx
movq %rdx, %rsi
shrq %rsi
cmpq %rsi, %rcx
jae 0xfb25
movq 0x8(%rdi), %rsi
movb (%rsi,%rcx), %r8b
addq %rsi, %rdx
movb (%rax,%rdx), %dl
movb %dl, (%rsi,%rcx)
movq 0x8(%rdi), %rdx
addq 0x18(%rdi), %rdx
movb %r8b, (%rax,%rdx)
incq %rcx
decq %rax
jmp 0xfaf1
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
jne 0xfb49
movq 0x18(%rbx), %rdi
incq %rdi
callq 0x5030
movq %rax, 0x10(%rbx)
xorl %ecx, %ecx
movq 0x18(%rbx), %rdx
cmpq %rdx, %rcx
jae 0xfb69
movq 0x8(%rbx), %rdx
movsbq (%rdx,%rcx), %rdx
movb (%r14,%rdx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0xfb4b
movb $0x0, (%rax,%rdx)
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x8(%rsi), %rcx
movq 0x18(%rsi), %rdx
xorl %eax, %eax
xorl %esi, %esi
movl %esi, %esi
cmpq %rsi, %rdx
jbe 0xfd7d
imulq $0xc, %rsi, %rdi
addl 0x4(%rcx,%rdi), %eax
incl %esi
jmp 0xfd6a
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::szsToDisk(EList<RefRecord, 128> const&, std::ostream&, int)
void szsToDisk(const EList<RefRecord>& szs, ostream& os, int reverse) {
		TIndexOffU seq = 0;
		TIndexOffU off = 0;
		TIndexOffU totlen = 0;
		for(unsigned int i = 0; i < szs.size(); i++) {
			if(szs[i].len == 0) continue;
			if(szs[i].first) off = 0;
			off += szs[i].off;
#ifdef ACCOUNT_FOR_ALL_GAP_REFS
			if(szs[i].first && szs[i].len > 0) seq++;
#else
			if(szs[i].first) seq++;
#endif
			TIndexOffU seqm1 = seq-1;
			assert_lt(seqm1, _nPat);
			TIndexOffU fwoff = off;
			if(reverse == REF_READ_REVERSE) {
				// Invert pattern idxs
				seqm1 = _nPat - seqm1 - 1;
				// Invert pattern idxs
				assert_leq(off + szs[i].len, _plen[seqm1]);
				fwoff = _plen[seqm1] - (off + szs[i].len);
			}
			writeU<TIndexOffU>(os, totlen, this->toBe()); // offset from beginning of joined string
			writeU<TIndexOffU>(os, seqm1,  this->toBe()); // sequence id
			writeU<TIndexOffU>(os, fwoff,  this->toBe()); // offset into sequence
			totlen += szs[i].len;
			off += szs[i].len;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, %r14
xorl %eax, %eax
xorl %ebx, %ebx
xorl %r10d, %r10d
xorl %ebp, %ebp
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %r12
movl %ebp, %ebp
cmpq %rbp, 0x18(%rsi)
jbe 0x11587
movq 0x8(%rsi), %rdi
imulq $0xc, %rbp, %r15
movl 0x4(%rdi,%r15), %ecx
testl %ecx, %ecx
je 0x11521
addq %r15, %rdi
movzbl 0x8(%rdi), %edx
testl %edx, %edx
movl $0x0, %esi
cmovnel %esi, %ebx
addl (%rdi), %ebx
leal (%rax,%rdx), %esi
cmpl $0x1, 0xc(%rsp)
movl %esi, 0x10(%rsp)
jne 0x11523
movl 0x74(%r14), %r13d
subl %esi, %r13d
movq 0x80(%r14), %rax
movl (%rax,%r13,4), %eax
addl %ebx, %ecx
subl %ecx, %eax
movl %eax, 0x8(%rsp)
jmp 0x1152e
jmp 0x11580
leal (%rax,%rdx), %r13d
decl %r13d
movl %ebx, 0x8(%rsp)
movzbl 0x1(%r14), %edx
movq %r12, %rdi
movl %r10d, %esi
movl %r10d, 0x14(%rsp)
callq 0x80de
movzbl 0x1(%r14), %edx
movq %r12, %rdi
movl %r13d, %esi
callq 0x80de
movzbl 0x1(%r14), %edx
movq %r12, %rdi
movl 0x8(%rsp), %esi
callq 0x80de
movl 0x14(%rsp), %r10d
movq 0x18(%rsp), %rsi
movq 0x8(%rsi), %rax
movl 0x4(%rax,%r15), %eax
addl %eax, %r10d
addl %eax, %ebx
movl 0x10(%rsp), %eax
incl %ebp
jmp 0x114c7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xaea8
movq 0x18(%r14), %rax
movl %ebx, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rbx
imulq 0x18(%r15), %rbx
leaq (%rbx,%rbx,2), %rsi
addq $0x100000, %rsi         # imm = 0x100000
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
callq 0x11660
shlq $0x2, %rbx
leaq 0x28(%rsp), %rdi
callq 0x116ac
leaq 0x8(%rsp), %rdi
callq 0x12c5c
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x12c5c
movq %rbx, %rdi
callq 0x5680
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rdi), %rax
movl %esi, %ebx
leal -0x1(%rsi), %ecx
cmpl $0x1, %ecx
adcl $-0x1, %esi
xorl %edx, %edx
divq %rsi
leaq (%rbx,%rax), %rsi
addq $0x100000, %rsi         # imm = 0x100000
movq %rsp, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x11660
movq %r14, %rdi
callq 0x116ac
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ds.h
// Function: AutoArray<unsigned int>::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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %rax
shrq $0x3e, %rax
leaq (,%rsi,4), %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
callq 0x5030
movq %rax, 0x8(%r14)
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x51b0
movq %rbx, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1f5af(%rip), %rax     # 0x31a90
movq %rax, (%rdi)
movq 0x78(%rdi), %r14
testq %r14, %r14
je 0x12502
movq %r14, %rdi
callq 0x1a562
movl $0xc8, %esi
movq %r14, %rdi
callq 0x5380
movq 0x128(%rbx), %rdi
testq %rdi, %rdi
je 0x1251b
callq 0x5440
andq $0x0, 0x128(%rbx)
leaq 0xc8(%rbx), %r14
movq 0xe0(%rbx), %rax
testq %rax, %rax
je 0x12579
xorl %r13d, %r13d
pushq $0x8
popq %r15
cmpq %rax, %r13
jae 0x12579
movq 0xd0(%rbx), %rax
movq (%rax,%r13,8), %rdi
callq 0x5620
movq 0xd0(%rbx), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x12562
movq %r12, %rdi
callq 0x1a59a
movq %r12, %rdi
movq %r15, %rsi
callq 0x5380
incq %r13
movq 0xe0(%rbx), %rax
jmp 0x12535
leaq 0x108(%rbx), %rdi
callq 0x14238
leaq 0xe8(%rbx), %rdi
callq 0x142a2
movq %r14, %rdi
callq 0x142c6
leaq 0xa0(%rbx), %rdi
callq 0x5778
leaq 0x48(%rbx), %rdi
callq 0x12c5c
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x14220
movq %rax, %r15
leaq 0x108(%rbx), %rdi
callq 0x14238
leaq 0xe8(%rbx), %rdi
callq 0x142a2
movq %r14, %rdi
callq 0x142c6
leaq 0xa0(%rbx), %rdi
callq 0x5778
leaq 0x48(%rbx), %rdi
callq 0x12c5c
movq %rbx, %rdi
callq 0x14220
movq %r15, %rdi
callq 0x5680
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
leaq (%rdx,%rsi), %rax
decq %rax
shrq %rdx
subq $0x1, %rdx
jb 0x12746
movq 0x8(%rdi), %rcx
movb (%rcx,%rsi), %r8b
movb (%rcx,%rax), %r9b
movb %r9b, (%rcx,%rsi)
movq 0x8(%rdi), %rcx
movb %r8b, (%rcx,%rax)
incq %rsi
decq %rax
jmp 0x12720
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ds.h
// Function: EList<unsigned int, 128>::insert(unsigned int const&, unsigned long)
void insert(const T& el, size_t idx) {
		if(list_ == NULL) lazyInit();
		assert_leq(idx, cur_);
		if(cur_ == sz_) expandCopy(sz_+1);
		for(size_t i = cur_; i > idx; i--) {
			list_[i] = list_[i-1];
		}
		list_[idx] = el;
		cur_++;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
jne 0x12b51
movq %r14, %rdi
callq 0x12b94
movq 0x18(%r14), %rsi
cmpq 0x10(%r14), %rsi
jne 0x12b7a
incq %rsi
movq %r14, %rdi
callq 0x12ba8
movq 0x18(%r14), %rsi
jmp 0x12b7a
movq 0x8(%r14), %rax
movl -0x4(%rax,%rsi,4), %ecx
movl %ecx, (%rax,%rsi,4)
decq %rsi
cmpq %rbx, %rsi
ja 0x12b6c
movl (%r15), %eax
movq 0x8(%r14), %rcx
movl %eax, (%rcx,%rbx,4)
incq 0x18(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./blockwise_sa.h
// Function: KarkkainenBlockwiseSA<SString<char>>::reset()
virtual void reset() {
		if(!_built) {
			build();
		}
		assert(_built);
		_cur = 0;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x80(%rdi)
jne 0x130c7
movq %rbx, %rdi
callq 0x14b76
andl $0x0, 0x70(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./blockwise_sa.h
// Function: KarkkainenBlockwiseSA<SString<char>>::qsort(EList<unsigned int, 128>&)
void KarkkainenBlockwiseSA<TStr>::qsort(EList<TIndexOffU>& bucket) {
	const TStr& t = this->text();
	TIndexOffU *s = &bucket[0];
	TIndexOffU slen = (TIndexOffU)bucket.size();
	TIndexOffU len = (TIndexOffU)t.length();
	if(_dc != NULL) {
		// Use the difference cover as a tie-breaker if we have it
		VMSG_NL("  (Using difference cover)");
		// Extract the 'host' array because it's faster to work
		// with than the String<> container
		uint8_t *host = (uint8_t*)&t[0];
		mkeyQSortSufDcU8(t, host, len, s, slen, *_dc, 4,
				 this->verbose(), this->sanityCheck());
	} else {
		VMSG_NL("  (Not using difference cover)");
		// We don't have a difference cover - just do a normal
		// suffix sort
		mkeyQSortSuf(t, s, slen, 4,
			     this->verbose(), this->sanityCheck());
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %r12
movq 0x8(%rdi), %r15
movq 0x8(%rsi), %r14
movl 0x18(%rsi), %ebx
movq 0x78(%rdi), %r9
movb 0x16(%rdi), %al
testq %r9, %r9
je 0x140b3
movl 0x18(%r15), %r13d
testb %al, %al
je 0x14115
leaq 0x28(%rsp), %rdi
callq 0x5200
leaq 0x38(%rsp), %rdi
leaq 0x10056(%rip), %rsi     # 0x240c0
callq 0x5350
movq %rax, %rdi
callq 0x5180
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5580
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x15946
leaq 0x8(%rsp), %rdi
callq 0x5778
leaq 0x28(%rsp), %rdi
callq 0x5240
movq 0x78(%r12), %r9
movb 0x16(%r12), %al
jmp 0x14117
testb %al, %al
je 0x1414f
leaq 0x28(%rsp), %rdi
callq 0x5200
leaq 0x38(%rsp), %rdi
leaq 0x1000a(%rip), %rsi     # 0x240db
callq 0x5350
movq %rax, %rdi
callq 0x5180
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5580
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x15946
leaq 0x8(%rsp), %rdi
callq 0x5778
leaq 0x28(%rsp), %rdi
callq 0x5240
movb 0x16(%r12), %al
jmp 0x14151
xorl %eax, %eax
movq 0x8(%r15), %rcx
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
movzbl 0x14(%r12), %r10d
subq $0x8, %rsp
movzbl %al, %eax
andl $0x1, %eax
movq %r15, %rdi
movq %r13, %rdx
movq %r14, %rcx
movq %rbx, %r8
pushq %r10
pushq %rax
pushq $0x4
callq 0x192d0
addq $0x20, %rsp
jmp 0x1417e
xorl %eax, %eax
movzbl 0x14(%r12), %r9d
subq $0x8, %rsp
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movzbl %al, %r8d
andl $0x1, %r8d
pushq $0x4
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
pushq %r10
callq 0x19343
popq %rax
popq %rcx
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5778
jmp 0x141b9
jmp 0x141b1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5778
jmp 0x141b9
jmp 0x141b6
movq %rax, %rbx
jmp 0x141b9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5240
movq %rbx, %rdi
callq 0x5680
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./blockwise_sa.h
// Function: KarkkainenBlockwiseSA<SString<char>>::build()
void build() {
		// Calculate difference-cover sample
		assert(_dc == NULL);
		if(_dcV != 0) {
			_dc = new TDC(this->text(), _dcV, this->verbose(), this->sanityCheck());
			_dc->build(this->_nthreads);
		}
		// Calculate sample suffixes
		if(this->bucketSz() <= this->text().length()) {
			VMSG_NL("Building samples");
			buildSamples();
		} else {
			VMSG_NL("Skipping building samples since text length " <<
				this->text().length() << " is less than bucket size: " <<
				this->bucketSz());
		}
		_built = true;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
movl 0x74(%rdi), %ebp
testl %ebp, %ebp
je 0x14bc5
movl $0xc8, %edi
callq 0x5370
movq %rax, %r14
movq 0x8(%rbx), %rsi
movzbl 0x16(%rbx), %ecx
movzbl 0x14(%rbx), %r8d
movq 0x1d3f4(%rip), %r9      # 0x31fa0
movq %rax, %rdi
movl %ebp, %edx
callq 0x14d10
movq %r14, 0x78(%rbx)
movl 0x68(%rbx), %esi
movq %r14, %rdi
callq 0x14e7a
movl 0x10(%rbx), %ecx
movq 0x8(%rbx), %rdx
movb 0x16(%rbx), %al
cmpq %rcx, 0x18(%rdx)
jae 0x14c60
testb %al, %al
je 0x14cbf
leaq 0x28(%rsp), %rdi
callq 0x5200
leaq 0x38(%rsp), %rdi
leaq 0x11a4a(%rip), %rsi     # 0x26641
callq 0x5350
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rsi
movq %rax, %rdi
callq 0x51e0
leaq 0x11a5b(%rip), %rsi     # 0x2666e
movq %rax, %rdi
callq 0x5350
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x51e0
movq %rax, %rdi
callq 0x5180
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5580
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x15946
leaq 0x8(%rsp), %rdi
callq 0x5778
leaq 0x28(%rsp), %rdi
callq 0x5240
jmp 0x14cbf
testb %al, %al
je 0x14cb7
leaq 0x28(%rsp), %rdi
callq 0x5200
leaq 0x38(%rsp), %rdi
leaq 0x119b6(%rip), %rsi     # 0x26630
callq 0x5350
movq %rax, %rdi
callq 0x5180
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5580
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x15946
leaq 0x8(%rsp), %rdi
callq 0x5778
leaq 0x28(%rsp), %rdi
callq 0x5240
movq %rbx, %rdi
callq 0x15968
movb $0x1, 0x80(%rbx)
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x14cd6
jmp 0x14cfb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5778
jmp 0x14cfe
jmp 0x14cfb
jmp 0x14cfb
movq %rax, %rbx
movl $0xc8, %esi
movq %r14, %rdi
callq 0x5380
jmp 0x14d08
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5240
movq %rbx, %rdi
callq 0x5680
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./diff_sample.h
// Function: DifferenceCoverSample<SString<char>>::DifferenceCoverSample(SString<char> const&, unsigned int, bool, bool, std::ostream&)
DifferenceCoverSample(const TStr& __text,
	                      uint32_t __v,
	                      bool __verbose = false,
	                      bool __sanity = false,
	                      ostream& __logger = cout) :
		_text(__text),
		_v(__v),
		_verbose(__verbose),
		_sanity(__sanity),
		_ds(getDiffCover(_v, _verbose, _sanity)),
		_dmap(getDeltaMap(_v, _ds)),
		_d((uint32_t)_ds.size()),
		_doffs(),
		_isaPrime(),
		_dInv(),
		_log2v(myLog2(_v)),
		_vmask(OFF_MASK << _log2v),
		_logger(__logger)
	{
		assert_gt(_d, 0);
		assert_eq(1, popCount(_v)); // must be power of 2
		// Build map from d's to idx's
		_dInv.resizeExact((size_t)_v);
		_dInv.fill(0xffffffff);
		uint32_t lim = (uint32_t)_ds.size();
		for(uint32_t i = 0; i < lim; i++) {
			_dInv[_ds[i]] = i;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %rdi, %rbx
movq %rsi, (%rdi)
movl %edx, 0x8(%rdi)
movb %cl, 0xc(%rdi)
movb %r8b, 0xd(%rdi)
leaq 0x10(%rdi), %r14
movq %r14, %rdi
movl %edx, %esi
movl %ecx, %edx
movl %r8d, %ecx
callq 0xaea8
leaq 0x30(%rbx), %r15
movl 0x8(%rbx), %esi
movq %r15, %rdi
movq %r14, %rdx
callq 0xb086
movl 0x8(%rbx), %r13d
movl 0x28(%rbx), %eax
movl %eax, 0x50(%rbx)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x58(%rbx)
andq $0x0, 0x60(%rbx)
movl $0x80, %ecx
movq %rcx, 0x68(%rbx)
andq $0x0, 0x70(%rbx)
leaq 0x58(%rbx), %rdx
movq %rdx, 0x8(%rsp)
leaq 0x78(%rbx), %rdx
movq %rdx, (%rsp)
movq %rax, 0x78(%rbx)
andq $0x0, 0x80(%rbx)
movq %rcx, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
leaq 0x98(%rbx), %rbp
movq %rax, 0x98(%rbx)
andq $0x0, 0xa0(%rbx)
movq %rcx, 0xa8(%rbx)
andq $0x0, 0xb0(%rbx)
movl %r13d, %edi
callq 0xb159
pushq $-0x1
popq %rdx
movl %eax, %ecx
shll %cl, %edx
movl %eax, 0xb8(%rbx)
movl %edx, 0xbc(%rbx)
movq %r12, 0xc0(%rbx)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x166ec
leaq 0x14(%rsp), %rsi
orl $-0x1, (%rsi)
movq %rbp, %rdi
callq 0x16730
movl 0x28(%rbx), %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x14e2f
movq 0x18(%rbx), %rdx
movq 0xa0(%rbx), %rsi
movl (%rdx,%rcx,4), %edx
movl %ecx, (%rsi,%rdx,4)
incq %rcx
jmp 0x14e14
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rbp, %rdi
callq 0x12c5c
movq (%rsp), %rdi
callq 0x12c5c
movq 0x8(%rsp), %rdi
callq 0x12c5c
movq %r15, %rdi
callq 0x12c5c
jmp 0x14e69
movq %rax, %rbx
movq %r14, %rdi
callq 0x12c5c
movq %rbx, %rdi
callq 0x5680
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ds.h
// Function: EList<unsigned int, 128>::resizeExact(unsigned long)
void resizeExact(size_t sz) {
		if(sz > 0 && list_ == NULL) lazyInitExact(sz);
		if(sz <= cur_) {
			cur_ = sz;
			return;
		}
		if(sz_ < sz) expandCopyExact(sz);
		cur_ = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x1670d
cmpq $0x0, 0x8(%r14)
jne 0x1670d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16748
cmpq %rbx, 0x18(%r14)
jae 0x16724
cmpq %rbx, 0x10(%r14)
jae 0x16724
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12bf6
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./diff_sample.h
// Function: DifferenceCoverSample<SString<char>>::buildSPrime(EList<unsigned int, 128>&, unsigned long)
void DifferenceCoverSample<TStr>::buildSPrime(
	EList<TIndexOffU>& sPrime,
	size_t padding)
{
	const TStr& t = this->text();
	const EList<uint32_t>& ds = this->ds();
	TIndexOffU tlen = (TIndexOffU)t.length();
	uint32_t v = this->v();
	uint32_t d = this->d();
	assert_gt(v, 2);
	assert_lt(d, v);
	// Record where each d section should begin in sPrime
	TIndexOffU tlenDivV = this->divv(tlen);
	uint32_t tlenModV = this->modv(tlen);
	TIndexOffU sPrimeSz = 0;
	assert(_doffs.empty());
	_doffs.resize(d+1);
	for(uint32_t di = 0; di < d; di++) {
		// mu mapping
		TIndexOffU sz = tlenDivV + ((ds[di] <= tlenModV) ? 1 : 0);
		assert_geq(sz, 0);
		_doffs[di] = sPrimeSz;
		sPrimeSz += sz;
	}
	_doffs[d] = sPrimeSz;
#ifndef NDEBUG
	if(tlenDivV > 0) {
		for(size_t i = 0; i < d; i++) {
			assert_gt(_doffs[i+1], _doffs[i]);
			TIndexOffU diff = _doffs[i+1] - _doffs[i];
			assert(diff == tlenDivV || diff == tlenDivV+1);
		}
	}
#endif
	assert_eq(_doffs.size(), d+1);
	// Size sPrime appropriately
	sPrime.resizeExact((size_t)sPrimeSz + padding);
	sPrime.fill(OFF_MASK);
	// Slot suffixes from text into sPrime according to the mu
	// mapping; where the mapping would leave a blank, insert a 0
	TIndexOffU added = 0;
	TIndexOffU i = 0;
	for(uint64_t ti = 0; ti <= tlen; ti += v) {
		for(uint32_t di = 0; di < d; di++) {
			TIndexOffU tti = (TIndexOffU)(ti + ds[di]);
			if(tti > tlen) break;
			TIndexOffU spi = _doffs[di] + i;
			assert_lt(spi, _doffs[di+1]);
			assert_leq(tti, tlen);
			assert_lt(spi, sPrimeSz);
			assert_eq(OFF_MASK, sPrime[spi]);
			sPrime[spi] = tti; added++;
		}
		i++;
	}
	assert_eq(added, sPrimeSz);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x18(%rax), %r12
movl %r12d, %eax
movq %rax, 0x18(%rsp)
movl 0x8(%rdi), %eax
movq %rax, 0x10(%rsp)
movl 0x50(%rdi), %r15d
movb 0xb8(%rdi), %cl
movl %r12d, %ebp
shrl %cl, %ebp
movl 0xbc(%rdi), %r13d
notl %r13d
andl %r12d, %r13d
addq $0x58, %rdi
leal 0x1(%r15), %esi
callq 0x14752
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rax, %r15
je 0x16800
movq 0x18(%r14), %rdx
movq 0x60(%r14), %rsi
cmpl (%rdx,%rax,4), %r13d
movl %ecx, (%rsi,%rax,4)
leal (%rcx,%rbp), %ecx
sbbl $-0x1, %ecx
incq %rax
jmp 0x167e1
movq 0x60(%r14), %rax
movl %ecx, (%rax,%r15,4)
movl %ecx, %esi
addq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x166ec
leaq 0x24(%rsp), %rsi
orl $-0x1, (%rsi)
movq %rbx, %rdi
callq 0x16730
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x18(%rsp), %r9
movq 0x10(%rsp), %r10
cmpq %r9, %rcx
ja 0x1686c
xorl %edx, %edx
cmpq %rdx, %r15
je 0x16865
movq 0x18(%r14), %rsi
movl (%rsi,%rdx,4), %esi
addl %ecx, %esi
cmpl %r12d, %esi
ja 0x16865
movq 0x60(%r14), %rdi
movl (%rdi,%rdx,4), %edi
addl %eax, %edi
movq 0x8(%rbx), %r8
movl %esi, (%r8,%rdi,4)
incq %rdx
jmp 0x1683c
incl %eax
addq %r10, %rcx
jmp 0x16835
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./multikey_qsort.h
// Function: void mkeyQSortSuf2<SString<char>>(SString<char> const&, unsigned int*, unsigned long, unsigned int*, int, bool, bool, unsigned long, EList<unsigned long, 128>*)
void mkeyQSortSuf2(
	const T& host,
	TIndexOffU *s,
	size_t slen,
	TIndexOffU *s2,
	int hi,
	bool verbose = false,
	bool sanityCheck = false,
	size_t upto = OFF_MASK,
	EList<size_t>* boundaries = NULL)
{
	size_t hlen = host.length();
	if(sanityCheck) sanityCheckInputSufs(s, slen);
	TIndexOffU *sOrig = NULL;
	if(sanityCheck) {
		sOrig = new TIndexOffU[slen];
		memcpy(sOrig, s, OFF_SIZE * slen);
	}
	mkeyQSortSuf2(host, hlen, s, slen, s2, hi, (size_t)0, slen, (size_t)0, upto, boundaries);
	if(sanityCheck) {
		sanityCheckOrderedSufs(host, hlen, s, slen, upto);
		for(size_t i = 0; i < slen; i++) {
			assert_eq(s[i], sOrig[s2[i]]);
		}
		delete[] sOrig;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r9d
movq %rcx, %r8
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x70(%rsp), %r10
movq 0x68(%rsp), %rax
movb 0x60(%rsp), %bpl
movq 0x18(%rdi), %rsi
testb %bpl, %bpl
je 0x1691f
movq %r15, %rdi
movq %rsi, 0x8(%rsp)
movq %rbx, %rsi
movl %r9d, 0x4(%rsp)
movq %r8, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movq %r10, 0x10(%rsp)
callq 0xaaa6
movq %rbx, %rax
shrq $0x3e, %rax
leaq (,%rbx,4), %r14
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r14, %rdi
callq 0x5030
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5260
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %r10
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %r8
movl 0x4(%rsp), %r9d
jmp 0x16922
xorl %r13d, %r13d
subq $0x8, %rsp
movq %r12, %rdi
movq %r15, %rdx
movq %rbx, %rcx
pushq %r10
pushq %rax
pushq $0x0
pushq %rbx
pushq $0x0
callq 0x16c6f
addq $0x30, %rsp
testq %r13, %r13
sete %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0x16965
movq %r13, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5440
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./diff_sample.h
// Function: DifferenceCoverSample<SString<char>>::doBuiltSanityCheck() const
void DifferenceCoverSample<TStr>::doBuiltSanityCheck() const {
	uint32_t v = this->v();
	assert(built());
	VMSG_NL("  Doing sanity check");
	TIndexOffU added = 0;
	EList<TIndexOffU> sorted;
	sorted.resizeExact(_isaPrime.size());
	sorted.fill(OFF_MASK);
	for(size_t di = 0; di < this->d(); di++) {
		uint32_t d = _ds[di];
		size_t i = 0;
		for(size_t doi = _doffs[di]; doi < _doffs[di+1]; doi++, i++) {
			assert_eq(OFF_MASK, sorted[_isaPrime[doi]]);
			// Maps the offset of the suffix to its rank
			sorted[_isaPrime[doi]] = (TIndexOffU)(v*i + d);
			added++;
		}
	}
	assert_eq(added, _isaPrime.size());
	for(size_t i = 0; i < sorted.size()-1; i++) {
		assert(suffixLt(this->text(), sorted[i], sorted[i+1]));
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
cmpb $0x1, 0xc(%rdi)
jne 0x16ba8
leaq 0x20(%rsp), %rdi
callq 0x5200
leaq 0x30(%rsp), %rdi
leaq 0xfc50(%rip), %rsi      # 0x267c1
callq 0x5350
movq %rax, %rdi
callq 0x5180
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x5580
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1675c
movq %rsp, %rdi
callq 0x5778
leaq 0x20(%rsp), %rdi
callq 0x5240
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq $0x80, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq 0x90(%rbx), %rsi
callq 0x166ec
movq %rsp, %rsi
orl $-0x1, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x16730
xorl %eax, %eax
movl 0x50(%rbx), %ecx
cmpq %rcx, %rax
jae 0x16c28
movq 0x18(%rbx), %rcx
movq 0x60(%rbx), %rsi
movl (%rcx,%rax,4), %ecx
movl (%rsi,%rax,4), %edx
incq %rax
movl (%rsi,%rax,4), %esi
cmpq %rsi, %rdx
jae 0x16bea
movq 0x80(%rbx), %rsi
movl (%rsi,%rdx,4), %esi
movq 0x28(%rsp), %rdi
movl %ecx, (%rdi,%rsi,4)
incq %rdx
movq 0x60(%rbx), %rsi
addl %ebp, %ecx
jmp 0x16c03
leaq 0x20(%rsp), %rdi
callq 0x12c5c
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5778
jmp 0x16c5d
jmp 0x16c5a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x12c5c
jmp 0x16c67
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5240
movq %rbx, %rdi
callq 0x5680
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ds.h
// Function: EList<QSortRange, 128>::erase(unsigned long)
void erase(size_t idx) {
		assert_lt(idx, cur_);
		for(size_t i = idx; i < cur_-1; i++) {
			list_[i] = list_[i+1];
		}
		cur_--;
	}

// Assembly:
imulq $0x18, %rsi, %rax
movq 0x18(%rdi), %rcx
decq %rcx
cmpq %rcx, %rsi
jae 0x172f4
movq 0x8(%rdi), %rcx
incq %rsi
movq 0x28(%rcx,%rax), %rdx
movq %rdx, 0x10(%rcx,%rax)
movups 0x18(%rcx,%rax), %xmm0
movups %xmm0, (%rcx,%rax)
addq $0x18, %rax
jmp 0x172c8
movq %rcx, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ls.h
// Function: LarssonSadakane<int>::bucketsort(int*, int*, int, int)
inline void bucketsort(T *x, T *p, T n, T k)
	{
	   T *pi, i, c, d, g;

	   for (pi=p; pi<p+k; ++pi)
		  *pi=-1;                   /* mark linked lists empty.*/
	   for (i=0; i<=n; ++i) {
		  x[i]=p[c=x[i]];           /* insert in linked list.*/
		  p[c]=i;
	   }
	   for (pi=p+k-1, i=n; pi>=p; --pi) {
		  d=x[c=*pi];               /* c is position, d is next in list.*/
		  x[c]=g=i;                 /* last position equals group number.*/
		  if (d == 0 || d > 0) {    /* if more than one element in group.*/
			 p[i--]=c;              /* p is permutation for the sorted x.*/
			 do {
				d=x[c=d];           /* next in linked list.*/
				x[c]=g;             /* group number in x.*/
				p[i--]=c;           /* permutation in p.*/
			 } while (d == 0 || d > 0);
		  } else
			 p[i--]=-1;             /* one element, sorted group.*/
	   }
	}

// Assembly:
movslq %r8d, %rax
leaq (%rdx,%rax,4), %rax
movq %rdx, %rdi
cmpq %rax, %rdi
jae 0x17a28
orl $-0x1, (%rdi)
addq $0x4, %rdi
jmp 0x17a1a
movslq %ecx, %rdi
xorl %r8d, %r8d
cmpq %rdi, %r8
jg 0x17a8e
movslq (%rsi,%r8,4), %r9
movl (%rdx,%r9,4), %r10d
movl %r10d, (%rsi,%r8,4)
movl %r8d, (%rdx,%r9,4)
incq %r8
jmp 0x17a2e
movslq (%rax), %r9
movl (%rsi,%r9,4), %r8d
movl %ecx, (%rsi,%r9,4)
leal -0x1(%rcx), %edi
movslq %ecx, %r10
testl %r8d, %r8d
js 0x17a87
movl %r9d, (%rdx,%r10,4)
movslq %edi, %r9
leaq (%rdx,%r9,4), %r9
movl %r8d, %r10d
movl (%rsi,%r10,4), %r11d
movl %ecx, (%rsi,%r10,4)
movl %r8d, (%r9)
addq $-0x4, %r9
decl %edi
movl %r11d, %r8d
testl %r11d, %r11d
jns 0x17a69
jmp 0x17a8c
orl $-0x1, (%rdx,%r10,4)
movl %edi, %ecx
addq $-0x4, %rax
cmpq %rdx, %rax
jae 0x17a48
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ls.h
// Function: LarssonSadakane<int>::select_sort_split(int*, int)
inline void select_sort_split(T *p, T n) {
	   T *pa, *pb, *pi, *pn;
	   T f, v, tmp;

	   pa=p;                        /* pa is start of group being picked out.*/
	   pn=p+n-1;                    /* pn is last position of subarray.*/
	   while (pa<pn) {
		  for (pi=pb=pa+1, f=LS_KEY(pa); pi<=pn; ++pi)
			 if ((v=LS_KEY(pi))<f) {
				f=v;                /* f is smallest key found.*/
				LS_SWAP(pi, pa);       /* place smallest element at beginning.*/
				pb=pa+1;            /* pb is position for elements equal to f.*/
			 } else if (v==f) {     /* if equal to smallest key.*/
				LS_SWAP(pi, pb);       /* place next to other smallest elements.*/
				++pb;
			 }
		  update_group(pa, pb-1);   /* update group values for new group.*/
		  pa=pb;                    /* continue sorting rest of the subarray.*/
	   }
	   if (pa==pn) {                /* check if last part is single element.*/
		  V[*pa]=(T)(pa-I);
		  *pa=-1;                   /* sorted group.*/
	   }
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %edx, %rax
leaq (%rsi,%rax,4), %r14
addq $-0x4, %r14
cmpq %r14, %rsi
jae 0x17d11
leaq 0x4(%rsi), %rax
movq 0x8(%rbx), %rcx
movslq (%rsi), %rdx
movslq 0x14(%rbx), %rdi
addq %rdx, %rdi
movl (%rcx,%rdi,4), %edx
movq %rax, %rcx
movq %rax, %r15
cmpq %r14, %rcx
ja 0x17d00
movq 0x8(%rbx), %rdi
movslq (%rcx), %r8
movslq 0x14(%rbx), %r9
addq %r8, %r9
movl (%rdi,%r9,4), %edi
cmpl %edx, %edi
jge 0x17ce8
movl (%rsi), %edx
movl %edx, (%rcx)
movl %r8d, (%rsi)
movq %rax, %r15
jmp 0x17cf8
jne 0x17cf6
movl (%r15), %edi
movl %edi, (%rcx)
movl %r8d, (%r15)
addq $0x4, %r15
movl %edx, %edi
addq $0x4, %rcx
movl %edi, %edx
jmp 0x17cc1
leaq -0x4(%r15), %rdx
movq %rbx, %rdi
callq 0x17f00
movq %r15, %rsi
jmp 0x17ca1
jne 0x17d2b
movq %r14, %rax
subq (%rbx), %rax
shrq $0x2, %rax
movq 0x8(%rbx), %rcx
movslq (%r14), %rdx
movl %eax, (%rcx,%rdx,4)
orl $-0x1, (%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ls.h
// Function: LarssonSadakane<int>::update_group(int*, int*)
inline void update_group(T *pl, T *pm) {
	   T g;
	   g=(T)(pm-I);                 /* group number.*/
	   V[*pl]=g;                    /* update group number of first position.*/
	   if (pl==pm)
		  *pl=-1;                   /* one element, sorted group.*/
	   else
		  do                        /* more than one element, unsorted group.*/
			 V[*++pl]=g;            /* update group numbers.*/
		  while (pl<pm);
	}

// Assembly:
movq %rdx, %rax
subq (%rdi), %rax
shrq $0x2, %rax
movq 0x8(%rdi), %rcx
movslq (%rsi), %r8
movl %eax, (%rcx,%r8,4)
cmpq %rdx, %rsi
je 0x17f30
movq 0x8(%rdi), %rcx
movslq 0x4(%rsi), %r8
addq $0x4, %rsi
movl %eax, (%rcx,%r8,4)
cmpq %rdx, %rsi
jb 0x17f1a
retq
orl $-0x1, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./random_source.h
// Function: RandomSource::nextU32()
uint32_t nextU32() {
		assert(inited_);
		uint32_t ret;
		last = a * last + c;
		ret = last >> 16;
		last = a * last + c;
		ret ^= last;
		lastOff = 0;
		return ret;
	}

// Assembly:
movl (%rdi), %ecx
movl 0x4(%rdi), %edx
movl 0x8(%rdi), %eax
imull %ecx, %eax
addl %edx, %eax
movl %eax, %esi
shrl $0x10, %esi
imull %ecx, %eax
addl %edx, %eax
movl %eax, 0x8(%rdi)
xorl %esi, %eax
andl $0x0, 0xc(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./blockwise_sa.h
// Function: KarkkainenBlockwiseSA<S2bDnaString>::tieBreakingLcp(unsigned int, unsigned int, unsigned int&, bool&)
inline
bool KarkkainenBlockwiseSA<TStr>::tieBreakingLcp(TIndexOffU aOff,
						 TIndexOffU bOff,
						 TIndexOffU& lcp,
						 bool& lcpIsSoft)
{
	const TStr& t = this->text();
	TIndexOffU c = 0;
	TIndexOffU tlen = TIndexOffU(t.length());
	assert_leq(aOff, tlen);
	assert_leq(bOff, tlen);
	assert(_dc != NULL);
	uint32_t dcDist = _dc->tieBreakOff(aOff, bOff);
	lcpIsSoft = false; // hard until proven soft
	while(c < dcDist &&    // we haven't hit the tie breaker
	      c < tlen-aOff && // we haven't fallen off of LHS suffix
	      c < tlen-bOff && // we haven't fallen off of RHS suffix
	      t[aOff+c] == t[bOff+c]) // we haven't hit a mismatch
		c++;
	lcp = c;
	if(c == tlen-aOff) {
		// Fell off LHS (a), a is greater
		return false;
	} else if(c == tlen-bOff) {
		// Fell off RHS (b), b is greater
		return true;
	} else if(c == dcDist) {
		// Hit a tie-breaker element
		lcpIsSoft = true;
		assert_neq(dcDist, 0xffffffff);
		return _dc->breakTie(aOff+c, bOff+c) < 0;
	} else {
		assert_neq(t[aOff+c], t[bOff+c]);
		return t[aOff+c] < t[bOff+c];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movq %rcx, 0x10(%rsp)
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r12
movq 0x8(%rdi), %rbp
movq 0x78(%rdi), %rdi
movl 0x18(%rbp), %r15d
callq 0xe342
movl %r15d, %esi
subl %r14d, %esi
cmpl %esi, %eax
movl %esi, %edx
cmovbl %eax, %edx
subl %ebx, %r15d
cmpl %edx, %r15d
cmovbl %r15d, %edx
movq %r13, 0x8(%rsp)
movb $0x0, (%r13)
leal (%r14,%r14), %edi
leal (%rbx,%rbx), %r9d
xorl %r8d, %r8d
cmpl %r8d, %edx
je 0x223c3
leal (%r14,%r8), %ecx
movq 0x8(%rbp), %r10
shrl $0x4, %ecx
movl (%r10,%rcx,4), %r11d
movl %edi, %ecx
andb $0x1e, %cl
shrl %cl, %r11d
leal (%rbx,%r8), %ecx
shrl $0x4, %ecx
movl (%r10,%rcx,4), %r10d
movl %r9d, %ecx
andb $0x1e, %cl
shrl %cl, %r10d
xorl %r11d, %r10d
testb $0x3, %r10b
jne 0x223c0
incl %r8d
addl $0x2, %edi
addl $0x2, %r9d
jmp 0x2237b
movl %r8d, %edx
movq 0x10(%rsp), %rcx
movl %edx, (%rcx)
cmpl %esi, %edx
jne 0x223d2
xorl %ecx, %ecx
jmp 0x22436
movb $0x1, %cl
cmpl %r15d, %edx
je 0x22436
cmpl %eax, %edx
jne 0x22402
movq 0x8(%rsp), %rcx
movb $0x1, (%rcx)
movq 0x78(%r12), %rdi
addl %eax, %r14d
addl %eax, %ebx
movl %r14d, %esi
movl %ebx, %edx
callq 0xe3de
movq %rax, %rcx
shrq $0x3f, %rcx
jmp 0x22436
addl %edx, %r14d
movq 0x8(%rbp), %rax
movl %r14d, %ecx
shrl $0x4, %ecx
movl (%rax,%rcx,4), %esi
addl %r14d, %r14d
movl %r14d, %ecx
shrl %cl, %esi
addl %edx, %ebx
movl %ebx, %ecx
shrl $0x4, %ecx
movl (%rax,%rcx,4), %eax
addl %ebx, %ebx
movl %ebx, %ecx
shrl %cl, %eax
andb $0x3, %sil
andb $0x3, %al
cmpb %al, %sil
setb %cl
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./sstring.h
// Function: S2bDnaString::resize(unsigned long)
void resize(size_t sz) {
		if(cs_ != NULL) {
			delete cs_;
			cs_ = NULL;
		}
		if(printcs_ != NULL) {
			delete printcs_;
			printcs_ = NULL;
		}
		len_ = sz;
		if(sz != 0) {
			cs_ = new uint32_t[nwords()];
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1c370
pushq $0x4
popq %rsi
callq 0x5380
andq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1c386
pushq $0x1
popq %rsi
callq 0x5380
andq $0x0, 0x10(%rbx)
movq %r14, 0x18(%rbx)
testq %r14, %r14
je 0x1c3a7
addq $0xf, %r14
shrq $0x2, %r14
andq $-0x4, %r14
movq %r14, %rdi
callq 0x5030
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./sstring.h
// Function: S2bDnaString::reverse()
void reverse() {
		if(len_ <= 1) return;
		size_t wordf = nwords()-1;
		size_t bpf   = (len_-1) & 15;
		size_t wordi = 0;
		size_t bpi   = 0;
		while(wordf > wordi || (wordf == wordi && bpf > bpi)) {
			int f = (cs_[wordf] >> (bpf << 1)) & 3;
			int i = (cs_[wordi] >> (bpi << 1)) & 3;
			cs_[wordf] &= ~(uint32_t)(3 << (bpf << 1));
			cs_[wordi] &= ~(uint32_t)(3 << (bpi << 1));
			cs_[wordf] |=  (uint32_t)(i << (bpf << 1));
			cs_[wordi] |=  (uint32_t)(f << (bpi << 1));
			if(bpf == 0) {
				bpf = 15;
				wordf--;
			} else bpf--;
			if(bpi == 15) {
				bpi = 0;
				wordi++;
			} else bpi++;
		}
	}

// Assembly:
movq 0x18(%rdi), %rsi
cmpq $0x2, %rsi
jb 0x1ca8d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
addq $0xf, %rsi
movq %rsi, %r8
shrq $0x4, %r8
decq %r8
andl $0xf, %esi
xorl %r9d, %r9d
movl $0x3, %r10d
movabsq $0xf, %r11
xorl %ebx, %ebx
cmpq %r9, %r8
ja 0x1c9f6
jne 0x1ca83
cmpq %rbx, %rsi
jbe 0x1ca83
movq 0x8(%rdi), %r14
movl (%r14,%r8,4), %r12d
leal (%rsi,%rsi), %eax
movl %r12d, %ebp
movl %eax, %ecx
shrl %cl, %ebp
movl (%r14,%r9,4), %r15d
leal (%rbx,%rbx), %edx
movl %edx, %ecx
shrl %cl, %r15d
movl %r10d, %r13d
movl %eax, %ecx
shll %cl, %r13d
andl $0x3, %ebp
notl %r13d
andl %r12d, %r13d
movl %r10d, %r12d
movl %edx, %ecx
shll %cl, %r12d
andl $0x3, %r15d
movl %r13d, (%r14,%r8,4)
notl %r12d
movq 0x8(%rdi), %rcx
andl %r12d, (%rcx,%r9,4)
movl %eax, %ecx
shll %cl, %r15d
movq 0x8(%rdi), %rax
orl %r15d, (%rax,%r8,4)
movl %edx, %ecx
shll %cl, %ebp
movq 0x8(%rdi), %rax
orl %ebp, (%rax,%r9,4)
subq $0x1, %rsi
cmovbq %r11, %rsi
sbbq $0x0, %r8
leaq 0x1(%rbx), %rax
xorl %ecx, %ecx
cmpq $0xf, %rbx
sete %cl
movl $0x0, %ebx
cmovneq %rax, %rbx
addq %rcx, %r9
jmp 0x1c9e2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./sstring.h
// Function: S2bDnaString::reverseWindow(unsigned long, unsigned long)
void reverseWindow(size_t off, size_t len) {
		assert_leq(off, len_);
		assert_leq(off+len, len_);
		if(len <= 1) return;
		size_t wordf = (off+len-1) >> 4;
		size_t bpf   = (off+len-1) & 15;
		size_t wordi = (off      ) >> 4;
		size_t bpi   = (off      ) & 15;
		while(wordf > wordi || (wordf == wordi && bpf > bpi)) {
			int f = (cs_[wordf] >> (bpf << 1)) & 3;
			int i = (cs_[wordi] >> (bpi << 1)) & 3;
			cs_[wordf] &= ~(uint32_t)(3 << (bpf << 1));
			cs_[wordi] &= ~(uint32_t)(3 << (bpi << 1));
			cs_[wordf] |=  (uint32_t)(i << (bpf << 1));
			cs_[wordi] |=  (uint32_t)(f << (bpi << 1));
			if(bpf == 0) {
				bpf = 15;
				wordf--;
			} else bpf--;
			if(bpi == 15) {
				bpi = 0;
				wordi++;
			} else bpi++;
		}
	}

// Assembly:
cmpq $0x2, %rdx
jb 0x1dbcc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq (%rsi,%rdx), %r8
decq %r8
movq %r8, %r9
shrq $0x4, %r9
andl $0xf, %r8d
movq %rsi, %r10
shrq $0x4, %r10
andl $0xf, %esi
movl $0x3, %r14d
cmpq %r10, %r9
ja 0x1db2c
jne 0x1dbc2
cmpq %rsi, %r8
jbe 0x1dbc2
movq 0x8(%rdi), %r15
movl (%r15,%r9,4), %r12d
leal (%r8,%r8), %eax
movl %r12d, %ebp
movl %eax, %ecx
shrl %cl, %ebp
movl (%r15,%r10,4), %r13d
leal (%rsi,%rsi), %edx
movl %edx, %ecx
shrl %cl, %r13d
movl %r14d, %r11d
movl %eax, %ecx
shll %cl, %r11d
notl %r11d
movl %r14d, %ebx
movl %edx, %ecx
shll %cl, %ebx
andl %r12d, %r11d
movl %r11d, (%r15,%r9,4)
notl %ebx
movq 0x8(%rdi), %rcx
andl %ebx, (%rcx,%r10,4)
andl $0x3, %r13d
movl %eax, %ecx
shll %cl, %r13d
movq 0x8(%rdi), %rax
orl %r13d, (%rax,%r9,4)
andl $0x3, %ebp
movl %edx, %ecx
shll %cl, %ebp
movq 0x8(%rdi), %rax
orl %ebp, (%rax,%r10,4)
subq $0x1, %r8
movabsq $0xf, %rax
cmovbq %rax, %r8
sbbq $0x0, %r9
xorl %eax, %eax
cmpq $0xf, %rsi
leaq 0x1(%rsi), %rsi
sete %al
movl $0x0, %ecx
cmoveq %rcx, %rsi
addq %rax, %r10
jmp 0x1db18
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mattn[P]wandbox-run/./json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::operator++()
iter_impl& operator++()
        {
            assert(m_object != nullptr);

            switch (m_object->m_type)
            {
                case basic_json::value_t::object:
                {
                    std::advance(m_it.object_iterator, 1);
                    break;
                }

                case basic_json::value_t::array:
                {
                    std::advance(m_it.array_iterator, 1);
                    break;
                }

                default:
                {
                    ++m_it.primitive_iterator;
                    break;
                }
            }

            return *this;
        }

// Assembly:
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x17197
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x17187
cmpl $0x1, %eax
jne 0x1718e
leaq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x1a2d1
jmp 0x17192
addq $0x10, 0x10(%rbx)
jmp 0x17192
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0xb4347(%rip), %rdi     # 0xcb4e5
leaq 0xb3160(%rip), %rsi     # 0xca305
leaq 0xb4a16(%rip), %rcx     # 0xcbbc2
movl $0x23db, %edx           # imm = 0x23DB
callq 0x13130
// File: /workspace/github_cpp_makefile_star2_O2/mattn[P]wandbox-run/./json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::parser::parse()
basic_json parse()
        {
            // read first token
            get_token();

            basic_json result = parse_internal(true);
            result.assert_invariant();

            expect(lexer::token_type::end_of_input);

            // return parser result and replace it with null in case the
            // top-level value was discarded by the callback function
            return result.is_discarded() ? basic_json() : std::move(result);
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1755c
movq %rsp, %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1756e
movq %r15, %rdi
callq 0x17a70
pushq $0xf
popq %rsi
movq %r14, %rdi
callq 0x17b12
cmpb $0x8, (%rsp)
jne 0x1742d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x16d54
jmp 0x17438
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x17cac
movq %rsp, %rdi
callq 0x16ecc
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x16ecc
movq %rbx, %rdi
callq 0xc6e00