LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movl %ecx, 0x8(%rsp)
movq %rdx, 0x28(%rsp)
cmpq $0x0, 0x18(%rsi)
je 0x15dba
movq %rdi, %r14
movl $0x1, %ebp
xorl %ecx, %ecx
xorl %r9d, %r9d
xorl %r12d, %r12d
xorl %eax, %eax
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %r13
movq 0x8(%rsi), %rdx
leaq (%rcx,%rcx,2), %r8
movl 0x4(%rdx,%r8,4), %ecx
testl %ecx, %ecx
je 0x15dac
movq %r8, 0x30(%rsp)
leaq (%rdx,%r8,4), %rsi
movzbl 0x8(%rsi), %edx
testl %edx, %edx
movl $0x0, %r8d
cmovnel %r8d, %r12d
addl (%rsi), %r12d
leal (%rax,%rdx), %esi
cmpl $0x1, 0x8(%rsp)
movl %esi, 0xc(%rsp)
jne 0x15d12
movl 0x74(%r14), %r15d
subl %esi, %r15d
movq 0x80(%r14), %rax
movl (%rax,%r15,4), %ebx
addl %r12d, %ecx
subl %ecx, %ebx
jmp 0x15d1c
leal (%rax,%rdx), %r15d
decl %r15d
movl %r12d, %ebx
cmpb $0x0, 0x1(%r14)
movl %r9d, %eax
bswapl %eax
cmovel %r9d, %eax
movl %eax, 0x14(%rsp)
movl $0x4, %edx
movq %r13, %rdi
leaq 0x14(%rsp), %rsi
movl %r9d, 0x10(%rsp)
callq 0x5460
cmpb $0x0, 0x1(%r14)
movl %r15d, %eax
bswapl %eax
cmovel %r15d, %eax
movl %eax, 0x18(%rsp)
movl $0x4, %edx
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
callq 0x5460
cmpb $0x0, 0x1(%r14)
movl %ebx, %eax
bswapl %eax
cmovel %ebx, %eax
movl %eax, 0x1c(%rsp)
movl $0x4, %edx
movq %r13, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x5460
movl 0x10(%rsp), %r9d
movq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
addl %eax, %r9d
addl %eax, %r12d
movl 0xc(%rsp), %eax
movl %ebp, %ecx
incl %ebp
cmpq %rcx, 0x18(%rsi)
ja 0x15cba
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd3e1
movq 0x18(%r14), %r14
movq 0x8(%r15), %rdi
movq 0x18(%r15), %r15
testq %rdi, %rdi
je 0x15e17
leaq 0x10(%rsp), %r12
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movl %ebx, %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
imulq %r15, %rax
shlq $0x2, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x23a18(%rip), %rax     # 0x3ab08
movq %rax, (%rdi)
movq 0x78(%rdi), %r14
testq %r14, %r14
je 0x171be
movq 0xa0(%r14), %rdi
testq %rdi, %rdi
je 0x17127
leaq 0xa0(%r14), %r15
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x80(%r14), %rdi
testq %rdi, %rdi
je 0x1714e
leaq 0x80(%r14), %r15
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x1716f
leaq 0x60(%r14), %r15
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x17190
leaq 0x38(%r14), %r15
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x171b1
leaq 0x18(%r14), %r15
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl $0xc8, %esi
movq %r14, %rdi
callq 0x5380
movq 0x128(%rbx), %rdi
testq %rdi, %rdi
je 0x171da
callq 0x5450
movq $0x0, 0x128(%rbx)
cmpq $0x0, 0xe0(%rbx)
je 0x17226
leaq 0xd0(%rbx), %r14
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x5640
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x1721a
cmpq $0x0, (%rdi)
jne 0x172f5
movl $0x8, %esi
callq 0x5380
incq %r15
cmpq 0xe0(%rbx), %r15
jb 0x171ee
leaq 0x108(%rbx), %rdi
callq 0x198de
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x17259
leaq 0xf0(%rbx), %r14
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x17280
leaq 0xd0(%rbx), %r14
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0xa0(%rbx), %rdi
leaq 0xb0(%rbx), %rax
cmpq %rax, %rdi
je 0x1729e
movq (%rax), %rsi
incq %rsi
callq 0x5380
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x172bf
leaq 0x50(%rbx), %r14
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x238d2(%rip), %rax     # 0x3ab98
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x172e9
addq $0x20, %rbx
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x50f0
movq %rax, %r15
leaq 0x108(%rbx), %rdi
callq 0x198de
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x17332
leaq 0xf0(%rbx), %r12
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x585d
movq %r15, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1797d
movq 0x10(%r14), %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x5030
movl (%r14), %ecx
movl %ecx, 0x4(%r14)
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rcx
cmpq %rcx, 0x18(%r14)
jne 0x179aa
movq %rcx, %rax
incq %rax
je 0x179aa
leaq 0x1(,%rcx,2), %rcx
movq %rcx, %rsi
addq %rcx, %rcx
cmpq %rax, %rsi
jb 0x17997
movq %r14, %rdi
callq 0x179d8
movq 0x18(%r14), %rax
cmpq %rbx, %rax
jbe 0x179c3
movq 0x8(%r14), %rcx
movl -0x4(%rcx,%rax,4), %edx
movl %edx, (%rcx,%rax,4)
decq %rax
jmp 0x179ae
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_O1/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 0x18099
movq %rbx, %rdi
callq 0x1a480
movl $0x0, 0x70(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
movl %edx, 0x8(%rdi)
movb %cl, 0xc(%rdi)
movb %r8b, 0xd(%rdi)
leaq 0x10(%rdi), %r15
movq %r15, %rdi
movl %edx, %esi
movl %ecx, %edx
movl %r8d, %ecx
callq 0xd3e1
leaq 0x30(%rbx), %rdi
movl 0x8(%rbx), %esi
movq %r15, %rdx
callq 0xd603
movl 0x8(%rbx), %esi
movl 0x28(%rbx), %eax
movl %eax, 0x50(%rbx)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x58(%rbx)
leaq 0x60(%rbx), %r15
xorl %ecx, %ecx
movq %rcx, 0x60(%rbx)
movl $0x80, %edx
movq %rdx, 0x68(%rbx)
movq %rcx, 0x70(%rbx)
movq %rax, 0x78(%rbx)
leaq (%rbx,%rdx), %r12
movq %rcx, 0x80(%rbx)
movq %rdx, 0x88(%rbx)
movq %rcx, 0x90(%rbx)
leaq 0x98(%rbx), %rdi
movq %rax, 0x98(%rbx)
leaq 0xa0(%rbx), %rbp
movq %rcx, 0xa0(%rbx)
movq %rdx, 0xa8(%rbx)
movq %rcx, 0xb0(%rbx)
movl %esi, %eax
testb $0x1, %al
jne 0x1a7ba
shrl %eax
incq %rcx
cmpq $0x20, %rcx
jne 0x1a7a6
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
movl %ecx, 0xb8(%rbx)
movl %eax, 0xbc(%rbx)
movq %r14, 0xc0(%rbx)
callq 0x1cbe2
cmpq $0x0, 0xb0(%rbx)
je 0x1a7ff
xorl %eax, %eax
movq 0xa0(%rbx), %rcx
movl $0xffffffff, (%rcx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
cmpq 0xb0(%rbx), %rax
jb 0x1a7e5
movl 0x28(%rbx), %eax
testq %rax, %rax
je 0x1a822
xorl %ecx, %ecx
movq 0x18(%rbx), %rdx
movq 0xa0(%rbx), %rsi
movl (%rdx,%rcx,4), %edx
movl %ecx, (%rsi,%rdx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x1a809
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rax, %r13
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x1a854
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movq $0x0, 0x10(%rbp)
leaq 0x8(%rsp), %rbp
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r13, %rcx
movl %r14d, %r8d
movq %rbp, %r9
callq 0x58eb
movq (%rbp), %r14
jmp 0x1a879
movq %rax, %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1a899
addq $0x18, %rbx
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1cc26
cmpq $0x0, 0x8(%r14)
jne 0x1cc26
movq %rbx, 0x10(%r14)
movq %rbx, %rax
shrq $0x3e, %rax
leaq (,%rbx,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x5030
movl (%r14), %ecx
movl %ecx, 0x4(%r14)
movq %rax, 0x8(%r14)
cmpq %rbx, 0x18(%r14)
jae 0x1cc3d
cmpq %rbx, 0x10(%r14)
jae 0x1cc3d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x179d8
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r11
movq 0x68(%rsp), %r10
movb 0x60(%rsp), %r13b
movq 0x18(%rdi), %rsi
testb %r13b, %r13b
je 0x1cec1
movq %rsi, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x4(%rsp)
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq $0x1001, %rbx           # imm = 0x1001
jb 0x1ce7a
leaq (,%rbx,4), %rbp
cmpq %rax, %rbx
movq $-0x1, %rdi
cmovbeq %rbp, %rdi
callq 0x5030
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x5270
leaq (%r14,%rbx,4), %rbp
bsrq %rbx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1177e
movq %r14, %rdi
movq %rbp, %rsi
callq 0x11859
movq %r14, %rdi
callq 0x5450
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
leaq (,%rbx,4), %r14
cmpq %rax, %rbx
movq $-0x1, %rdi
cmovbeq %r14, %rdi
callq 0x5030
movq %rax, %rbp
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5270
movl 0x4(%rsp), %r9d
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r11
movq 0x8(%rsp), %rsi
jmp 0x1cec3
xorl %ebp, %ebp
subq $0x8, %rsp
xorl %eax, %eax
movq %r12, %rdi
movq %r15, %rdx
movq %rbx, %rcx
pushq %r11
pushq %r10
pushq %rax
pushq %rbx
pushq %rax
callq 0x1d36c
addq $0x30, %rsp
testq %rbp, %rbp
sete %al
xorb $0x1, %r13b
orb %al, %r13b
jne 0x1cf07
movq %rbp, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5450
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ls.h
// Function: LarssonSadakane<int>::choose_pivot(int*, int)
inline T choose_pivot(T *p, T n) {
	   T *pl, *pm, *pn;
	   T s;

	   pm=p+(n>>1);                 /* small arrays, middle element.*/
	   if (n>7) {
		  pl=p;
		  pn=p+n-1;
		  if (n>40) {               /* big arrays, pseudomedian of 9.*/
			 s=n>>3;
			 pl=LS_SMED3(pl, pl+s, pl+s+s);
			 pm=LS_SMED3(pm-s, pm, pm+s);
			 pn=LS_SMED3(pn-s-s, pn-s, pn);
		  }
		  pm=LS_SMED3(pl, pm, pn);      /* midsize arrays, median of 3.*/
	   }
	   return LS_KEY(pm);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %eax
sarl %eax
cltq
leaq (%rsi,%rax,4), %rax
cmpl $0x8, %edx
jl 0x1e733
movl %edx, %ecx
leaq (%rsi,%rcx,4), %rcx
addq $-0x4, %rcx
cmpl $0x29, %edx
jl 0x1e635
shrl $0x3, %edx
movq 0x8(%rdi), %r9
movslq (%rsi), %r8
movslq 0x14(%rdi), %r10
addq %r10, %r8
movl (%r9,%r8,4), %r11d
movl %edx, %r15d
shll $0x2, %r15d
leaq (%rsi,%r15), %r8
movslq (%rsi,%r15), %rbx
addq %r10, %rbx
movl (%r9,%rbx,4), %r14d
leaq (%r8,%r15), %rbx
movslq (%r15,%r8), %r15
addq %r10, %r15
movl (%r9,%r15,4), %ebp
cmpl %r14d, %r11d
jge 0x1e63d
cmpl %ebp, %r14d
jl 0x1e64c
cmpl %ebp, %r11d
cmovlq %rbx, %rsi
jmp 0x1e649
movq %rsi, %r8
jmp 0x1e6ee
cmpl %ebp, %r14d
jg 0x1e64c
cmpl %ebp, %r11d
cmovgq %rbx, %rsi
movq %rsi, %r8
movq %rdx, %rsi
negq %rsi
leal (,%rdx,4), %r15d
movq %rax, %rdx
subq %r15, %rdx
movslq (%rdx), %r11
addq %r10, %r11
movl (%r9,%r11,4), %r11d
movslq (%rax), %rbx
addq %r10, %rbx
movl (%r9,%rbx,4), %r14d
leaq (%rax,%r15), %rbx
movslq (%rax,%r15), %r15
addq %r10, %r15
movl (%r9,%r15,4), %ebp
cmpl %r14d, %r11d
jge 0x1e696
cmpl %ebp, %r14d
jl 0x1e6a5
cmpl %ebp, %r11d
cmovlq %rbx, %rdx
jmp 0x1e6a2
cmpl %ebp, %r14d
jg 0x1e6a5
cmpl %ebp, %r11d
cmovgq %rbx, %rdx
movq %rdx, %rax
leaq (%rcx,%rsi,4), %r11
leaq (%r11,%rsi,4), %rdx
movslq (%rdx), %rsi
addq %r10, %rsi
movl (%r9,%rsi,4), %esi
movslq (%r11), %rbx
addq %r10, %rbx
movl (%r9,%rbx,4), %ebx
movslq (%rcx), %r14
addq %r10, %r14
movl (%r9,%r14,4), %r9d
cmpl %ebx, %esi
jge 0x1e6dd
cmpl %r9d, %ebx
jl 0x1e6e2
cmpl %r9d, %esi
cmovgeq %rdx, %rcx
jmp 0x1e6ee
cmpl %r9d, %ebx
jle 0x1e6e7
movq %r11, %rcx
jmp 0x1e6ee
cmpl %r9d, %esi
cmovleq %rdx, %rcx
movq 0x8(%rdi), %rsi
movslq (%r8), %rdx
movslq 0x14(%rdi), %r10
addq %r10, %rdx
movl (%rsi,%rdx,4), %edx
movslq (%rax), %r9
addq %r10, %r9
movl (%rsi,%r9,4), %r9d
movslq (%rcx), %r11
addq %r10, %r11
movl (%rsi,%r11,4), %esi
cmpl %r9d, %edx
jge 0x1e725
cmpl %esi, %r9d
jl 0x1e733
cmpl %esi, %edx
cmovlq %rcx, %r8
jmp 0x1e730
cmpl %esi, %r9d
jg 0x1e733
cmpl %esi, %edx
cmovgq %rcx, %r8
movq %r8, %rax
movq 0x8(%rdi), %rcx
movslq (%rax), %rax
movslq 0x14(%rdi), %rdx
addq %rax, %rdx
movl (%rcx,%rdx,4), %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23967
movl $0x4, %esi
callq 0x5380
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x23982
movl $0x1, %esi
callq 0x5380
movq $0x0, 0x10(%rbx)
movq %r14, 0x18(%rbx)
testq %r14, %r14
je 0x239a3
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_O1/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 0x24229
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
addq $0xf, %rsi
movq %rsi, %r8
shrq $0x4, %r8
decq %r8
andl $0xf, %esi
xorl %r9d, %r9d
movl $0xf, %r10d
xorl %r11d, %r11d
cmpq %r9, %r8
ja 0x2418f
jne 0x24221
cmpq %r11, %rsi
jbe 0x24221
movq 0x8(%rdi), %r14
movl (%r14,%r8,4), %r15d
leal (%rsi,%rsi), %eax
movl %r15d, %ebx
movl %eax, %ecx
shrl %cl, %ebx
movl (%r14,%r9,4), %ebp
leal (%r11,%r11), %edx
movl %edx, %ecx
shrl %cl, %ebp
movl $0x3, %r12d
movl %eax, %ecx
shll %cl, %r12d
andl $0x3, %ebx
notl %r12d
andl %r15d, %r12d
movl $0x3, %r15d
movl %edx, %ecx
shll %cl, %r15d
andl $0x3, %ebp
movl %r12d, (%r14,%r8,4)
notl %r15d
movq 0x8(%rdi), %rcx
andl %r15d, (%rcx,%r9,4)
movl %eax, %ecx
shll %cl, %ebp
movq 0x8(%rdi), %rax
orl %ebp, (%rax,%r8,4)
movl %edx, %ecx
shll %cl, %ebx
movq 0x8(%rdi), %rax
orl %ebx, (%rax,%r9,4)
subq $0x1, %rsi
cmovbq %r10, %rsi
sbbq $0x0, %r8
leaq 0x1(%r11), %rax
xorl %ecx, %ecx
cmpq $0xf, %r11
sete %cl
movl $0x0, %r11d
cmovneq %rax, %r11
addq %rcx, %r9
jmp 0x2417b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x258c7
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 $0xf, %r11d
xorl %ebx, %ebx
cmpq %r10, %r9
ja 0x2582e
jne 0x258bd
cmpq %rsi, %r8
jbe 0x258bd
movq 0x8(%rdi), %r14
movl (%r14,%r9,4), %r12d
leal (%r8,%r8), %eax
movl %r12d, %ebp
movl %eax, %ecx
shrl %cl, %ebp
movl (%r14,%r10,4), %r15d
leal (%rsi,%rsi), %edx
movl %edx, %ecx
shrl %cl, %r15d
movl $0x3, %r13d
movl %eax, %ecx
shll %cl, %r13d
andl $0x3, %ebp
notl %r13d
andl %r12d, %r13d
movl $0x3, %r12d
movl %edx, %ecx
shll %cl, %r12d
andl $0x3, %r15d
movl %r13d, (%r14,%r9,4)
notl %r12d
movq 0x8(%rdi), %rcx
andl %r12d, (%rcx,%r10,4)
movl %eax, %ecx
shll %cl, %r15d
movq 0x8(%rdi), %rax
orl %r15d, (%rax,%r9,4)
movl %edx, %ecx
shll %cl, %ebp
movq 0x8(%rdi), %rax
orl %ebp, (%rax,%r10,4)
subq $0x1, %r8
cmovbq %r11, %r8
sbbq $0x0, %r9
xorl %eax, %eax
cmpq $0xf, %rsi
leaq 0x1(%rsi), %rsi
sete %al
cmoveq %rbx, %rsi
addq %rax, %r10
jmp 0x2581a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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>::operator=(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>)
reference& operator=(basic_json other) noexcept (
        std::is_nothrow_move_constructible<value_t>::value and
        std::is_nothrow_move_assignable<value_t>::value and
        std::is_nothrow_move_constructible<json_value>::value and
        std::is_nothrow_move_assignable<json_value>::value
    )
    {
        // check that passed value is valid
        other.assert_invariant();

        using std::swap;
        swap(m_type, other.m_type);
        swap(m_value, other.m_value);

        assert_invariant();
        return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x183f2
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x183f2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x30(%rsi), %rdi
callq 0x1877e
movl %eax, 0x28(%r14)
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x17d28
movq %r15, %rdi
callq 0x183f2
movq %r14, %rdi
movl $0xf, %esi
callq 0x18494
movb (%rsp), %al
cmpb $0x8, %al
jne 0x17b5e
movb $0x0, (%rbx)
movq %rbx, %rdi
callq 0x183f2
jmp 0x17b7f
movb %al, (%rbx)
movq %rsp, %r14
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x183f2
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
callq 0x183f2
movq %rsp, %rdi
callq 0x17518
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x17518
movq %rbx, %rdi
callq 0xc7b30
nop
// File: /workspace/github_cpp_makefile_star2_O1/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>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
reference operator[](const typename object_t::key_type& key)
    {
        // implicitly convert null value to an empty object
        if (is_null())
        {
            m_type = value_t::object;
            m_value.object = create<object_t>();
            assert_invariant();
        }

        // operator[] only works for objects
        if (is_object())
        {
            return m_value.object->operator[](key);
        }

        JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0x19aa3
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x1d510
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x183f2
cmpb $0x1, (%r14)
jne 0x19abd
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1a41a
movl $0x10, %edi
callq 0x1c400
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1a496
leaq 0xb23a6(%rip), %rsi     # 0xcbe82
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x19d9e
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x4de10
xorl %ebp, %ebp
leaq 0xec38e(%rip), %rsi     # 0x105e90
leaq 0xc237(%rip), %rdx      # 0x25d40
movq %rbx, %rdi
callq 0x1d450
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19b37
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1c120
jmp 0x19b37
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19b5a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1c120
jmp 0x19b5a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x19b67
movq %rbx, %rdi
callq 0x1c460
movq %r14, %rdi
callq 0xc7b30
nop
// File: /workspace/github_cpp_makefile_star2_O1/mattn[P]wandbox-run/./json.hpp
// Function: bool 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>::lexer::strtonum::parse<unsigned long>(unsigned long&, std::integral_constant<bool, true>) const
bool parse(T& value, /*is_integral=*/std::true_type) const
            {
                char* endptr = nullptr;
                errno = 0; // these are thread-local
                const auto x = parse_integral(&endptr, std::is_signed<T>());

                // called right overload?
                static_assert(std::is_signed<T>() == std::is_signed<decltype(x)>(), "");

                value = static_cast<T>(x);

                return (x == static_cast<decltype(x)>(value)) // x fits into destination T
                       and (x < 0) == (value < 0)             // preserved sign
                       //and ((x != 0) or is_integral())        // strto[u]ll did nto fail
                       and (errno == 0)                       // strto[u]ll did not overflow
                       and (m_start < m_end)                  // token was not empty
                       and (endptr == m_end);                 // parsed entire token exactly
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq $0x0, (%r15)
callq 0x13690
movq %rax, %r12
movl $0x0, (%rax)
movq (%rbx), %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x13570
movq %rax, (%r14)
cmpl $0x0, (%r12)
jne 0x1ab56
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
jae 0x1ab56
cmpq %rax, (%rsp)
sete %al
jmp 0x1ab58
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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==(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>> const&) const
bool operator==(const iter_impl& other) const
        {
            // if objects are not the same, the comparison is undefined
            if (m_object != other.m_object)
            {
                JSON_THROW(std::domain_error("cannot compare iterators of different containers"));
            }

            assert(m_object != nullptr);

            switch (m_object->m_type)
            {
                case basic_json::value_t::object:
                {
                    return (m_it.object_iterator == other.m_it.object_iterator);
                }

                case basic_json::value_t::array:
                {
                    return (m_it.array_iterator == other.m_it.array_iterator);
                }

                default:
                {
                    return (m_it.primitive_iterator == other.m_it.primitive_iterator);
                }
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x1aeff
testq %rax, %rax
je 0x1af31
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x1aee2
cmpl $0x1, %eax
jne 0x1aeec
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x1aef4
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x1aef4
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1c400
movq %rax, %rbx
leaq 0xb18d0(%rip), %rsi     # 0xcc7e3
movq %rax, %rdi
callq 0x301a0
leaq 0xeaf6e(%rip), %rsi     # 0x105e90
leaq 0xae17(%rip), %rdx      # 0x25d40
movq %rbx, %rdi
callq 0x1d450
leaq 0xb15ad(%rip), %rdi     # 0xcc4e5
leaq 0xb03c6(%rip), %rsi     # 0xcb305
leaq 0xb18ce(%rip), %rcx     # 0xcc814
movl $0x242c, %edx           # imm = 0x242C
callq 0x13130
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c460
movq %r14, %rdi
callq 0xc7b30
// File: /workspace/github_cpp_makefile_star2_O1/mattn[P]wandbox-run/./json.hpp
// Function: void 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>::serializer::dump_integer<long, 0>(long)
void dump_integer(NumberType x)
        {
            // special case for "0"
            if (x == 0)
            {
                o.put('0');
                return;
            }

            const bool is_negative = x < 0;
            size_t i = 0;

            // spare 1 byte for '\0'
            while (x != 0 and i < number_buffer.size() - 1)
            {
                const auto digit = std::labs(static_cast<long>(x % 10));
                number_buffer[i++] = static_cast<char>('0' + digit);
                x /= 10;
            }

            // make sure the number has been processed completely
            assert(x == 0);

            if (is_negative)
            {
                // make sure there is capacity for the '-'
                assert(i < number_buffer.size() - 2);
                number_buffer[i++] = '-';
            }

            std::reverse(number_buffer.begin(), number_buffer.begin() + i);
            o.write(number_buffer.data(), static_cast<std::streamsize>(i));
        }

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x1b97c
xorl %ecx, %ecx
movabsq $0x6666666666666667, %r9 # imm = 0x6666666666666667
movq %rsi, %r8
cmpq $0x3f, %rcx
je 0x1b98a
movq %r8, %rax
imulq %r9
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %r8, %r10
subq %rax, %r10
movq %r10, %rax
negq %rax
cmovsq %r10, %rax
addb $0x30, %al
movb %al, 0x8(%rdi,%rcx)
incq %rcx
addq $0x9, %r8
cmpq $0x13, %r8
movq %rdx, %r8
jae 0x1b8db
testq %rsi, %rsi
jns 0x1b93e
leaq -0x1(%rcx), %rax
cmpq $0x3d, %rax
jae 0x1b9a9
movb $0x2d, 0x8(%rdi,%rcx)
incq %rcx
leaq 0x8(%rdi), %rsi
leaq (%rdi,%rcx), %rax
addq $0x7, %rax
cmpq %rsi, %rax
jbe 0x1b970
leaq 0x9(%rdi), %rdx
movb -0x1(%rdx), %r8b
movb (%rax), %r9b
movb %r9b, -0x1(%rdx)
movb %r8b, (%rax)
decq %rax
leaq 0x1(%rdx), %r8
cmpq %rax, %rdx
movq %r8, %rdx
jb 0x1b953
movq (%rdi), %rdi
movq %rcx, %rdx
popq %rax
jmp 0x884a0
movq (%rdi), %rdi
movl $0x30, %esi
popq %rax
jmp 0x88320
leaq 0xb1805(%rip), %rdi     # 0xcd196
leaq 0xaf96d(%rip), %rsi     # 0xcb305
leaq 0xb17fe(%rip), %rcx     # 0xcd19d
movl $0x19e0, %edx           # imm = 0x19E0
callq 0x13130
leaq 0xb1950(%rip), %rdi     # 0xcd300
leaq 0xaf94e(%rip), %rsi     # 0xcb305
leaq 0xb17df(%rip), %rcx     # 0xcd19d
movl $0x19e5, %edx           # imm = 0x19E5
callq 0x13130
// File: /workspace/github_cpp_makefile_star2_O1/moya-lang[P]Allocator/Measure.cpp
// Function: PushFrontTest<std::forward_list<unsigned long, std::allocator<unsigned long>>>::testIteration(unsigned long)
virtual void testIteration(size_t newSize)
    {
        size_t size = 0;

        while (size < newSize)
            this->container.push_front(size++);

        for (; size > newSize; size--)
            this->container.pop_front();
    }

// Assembly:
testq %rsi, %rsi
je 0x356b
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x1(%r15), %r12
movl $0x10, %edi
callq 0x20e0
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%r14)
movq %r12, %r15
cmpq %r12, %rbx
jne 0x3534
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/moya-lang[P]Allocator/./Allocator.h
// Function: Moya::MemoryPool<std::_Fwd_list_node<unsigned long>, 1024ul>::allocate()
T *allocate()
        {
            if (firstFreeBlock) {
                Block *block = firstFreeBlock;
                firstFreeBlock = block->next;
                return reinterpret_cast<T *>(block);
            }

            if (bufferedBlocks >= growSize) {
                firstBuffer = new Buffer(firstBuffer);
                bufferedBlocks = 0;
            }

            return firstBuffer->getBlock(bufferedBlocks++);
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x369a
movq (%rax), %rcx
movq %rcx, (%rbx)
jmp 0x36d9
cmpq $0x400, 0x10(%rbx)      # imm = 0x400
jb 0x36c5
movl $0x4008, %edi           # imm = 0x4008
callq 0x20e0
movq 0x8(%rbx), %rcx
movq %rcx, 0x4000(%rax)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rbx)
shlq $0x4, %rax
addq 0x8(%rbx), %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/moya-lang[P]Allocator/Measure.cpp
// Function: PushBackTest<std::__cxx11::list<unsigned long, std::allocator<unsigned long>>>::~PushBackTest()
virtual void testIteration(size_t newSize)
    {
        size_t size = 0;

        while (size < newSize)
            this->container.push_back(size++);

        for (; size > newSize; size--)
            this->container.pop_back();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x41d5(%rip), %rax      # 0x7ac8
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %rdi
cmpq %r14, %rdi
je 0x3918
movq (%rdi), %r15
movl $0x18, %esi
callq 0x20f0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x3903
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/moya-lang[P]Allocator/Measure.cpp
// Function: MapTest<std::map<unsigned long, unsigned long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, unsigned long>>>>::testIteration(unsigned long)
virtual void testIteration(size_t newSize)
    {
        size_t size = 0;

        for (; size < newSize; size++)
            this->container.insert(typename Container::value_type(size, size));

        while (size > newSize)
            this->container.erase(--size);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rsp)
testq %rsi, %rsi
je 0x39f6
leaq 0x8(%r14), %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3aae
movq (%rsp), %rax
incq %rax
movq %rax, (%rsp)
cmpq %rbx, %rax
jb 0x39d1
movq (%rsp), %rax
cmpq %rbx, %rax
jbe 0x3a2c
addq $0x8, %r14
movq %rsp, %r15
decq %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3bc2
movq %r14, %rdi
movq %rax, %rsi
callq 0x3c3e
movq (%rsp), %rax
cmpq %rbx, %rax
ja 0x3a06
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/moya-lang[P]Allocator/Measure.cpp
// Function: SetTest<std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>>>::testIteration(unsigned long)
virtual void testIteration(size_t newSize)
    {
        size_t size = 0;

        while (size < newSize)
            this->container.insert(size++);

        while (size > newSize)
            this->container.erase(--size);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
testq %rsi, %rsi
je 0x40e1
leaq 0x8(%r14), %r15
xorl %eax, %eax
leaq 0x10(%rsp), %r12
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x419e
movq 0x8(%rsp), %rax
cmpq %rbx, %rax
jb 0x40be
movq 0x8(%rsp), %rax
cmpq %rbx, %rax
jbe 0x411c
addq $0x8, %r14
leaq 0x8(%rsp), %r15
decq %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x42b0
movq %r14, %rdi
movq %rax, %rsi
callq 0x432c
movq 0x8(%rsp), %rax
cmpq %rbx, %rax
ja 0x40f4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/moya-lang[P]Allocator/Measure.cpp
// Function: PerformanceTest<std::forward_list<unsigned long, std::allocator<unsigned long>>>::run()
double run()
        {
            auto from = std::chrono::high_resolution_clock::now();

            for (size_t i = 0; i < numberOfIterations; i++)
                testIteration(randomNumberDistribution(randomNumberGenerator));

            auto to = std::chrono::high_resolution_clock::now();
            return std::chrono::duration_cast<std::chrono::duration<double>>(to - from).count();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x2040
movq %rax, %rbx
leaq 0x18(%r14), %r15
leaq 0x10(%r14), %r12
movl $0x400, %r13d           # imm = 0x400
movq %r15, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4844
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
decq %r13
jne 0x47a6
callq 0x2040
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0x847(%rip), %xmm0      # 0x5020
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/estudiante.cpp
// Function: ed::Estudiante::leerEstudiante()
void ed::Estudiante::leerEstudiante(){
	std::cout << IYELLOW << "Introduce el nombre: " << RESET;
	//Uso de getline para leer nombres compuestos separados por espacios
	std::getline(std::cin,this->_nombre);

	//Esta sentencia no permite leer nombres compuestos con espacios en blanco
	//std::cin >> this->_nombre;

	std::cout << IYELLOW << "Introduce los apellidos: " << RESET;
	//Uso de getline para leer los apellidos separados por espacios
	std::getline(std::cin,this->_apellidos);

	//Esta sentencia no permite leer dos apellidos separados por espacios en blanco
	//std::cin >> this->_apellidos;

	std::cout << IYELLOW << "Introduce la nota de teoría: " << RESET;
	std::cin >> this->_teoria;

	std::cout << IYELLOW << "Introduce la nota de práctica: " << RESET;
	std::cin >> this->_practica;

	//Se elimina el salto de línea para evitar problemas en una posterior lectura de cadenas 
	std::cin.ignore();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xab3c(%rip), %r14      # 0xcfd0
leaq 0x6b6d(%rip), %rsi      # 0x9008
movl $0x7, %edx
movq %r14, %rdi
callq 0x2190
leaq 0x6b61(%rip), %rsi      # 0x9010
movl $0x15, %edx
movq %r14, %rdi
callq 0x2190
leaq 0x78ec(%rip), %r12      # 0x9daf
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2190
leaq 0x8(%rbx), %r15
movq 0xab02(%rip), %r13      # 0xcfe0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x2260
movl $0x7, %edx
movq %r14, %rdi
leaq 0x6af8(%rip), %rsi      # 0x9008
callq 0x2190
leaq 0x6b0a(%rip), %rsi      # 0x9026
movl $0x19, %edx
movq %r14, %rdi
callq 0x2190
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2190
leaq 0x28(%rbx), %r15
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x2260
movl $0x7, %edx
movq %r14, %rdi
leaq 0x6a99(%rip), %r15      # 0x9008
movq %r15, %rsi
callq 0x2190
leaq 0x6ac2(%rip), %rsi      # 0x9040
movl $0x1e, %edx
movq %r14, %rdi
callq 0x2190
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2190
leaq 0x48(%rbx), %rsi
movq %r13, %rdi
callq 0x2280
movl $0x7, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
leaq 0x6aa1(%rip), %rsi      # 0x905f
movl $0x20, %edx
movq %r14, %rdi
callq 0x2190
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2190
addq $0x4c, %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2280
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/estudiante.cpp
// Function: ed::Estudiante::operator=(ed::Estudiante const&)
ed::Estudiante &ed::Estudiante::operator=(const ed::Estudiante &e){
	//Se comprueba que no sean el mismo objeto
	if (this != &e){
		this->setNombre(e.getNombre());
		this->setApellidos(e.getApellidos());

		this->setTeoria(e.getTeoria());
		this->setPractica(e.getPractica());
	}

	//Postcondición
	#ifndef NDEBUG
		assert((*this)==e);
	#endif
	
	//Se devuelve el objeto actual
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x2966
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x38(%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
leaq -0x18(%rbp), %rsi
movss %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
leaq -0x14(%rbp), %rsi
movss %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29a0
testb %al, %al
je 0x2981
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6751(%rip), %rdi      # 0x90d9
leaq 0x6755(%rip), %rsi      # 0x90e4
leaq 0x675d(%rip), %rcx      # 0x90f3
movl $0x4d, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/estudiante.cpp
// Function: ed::operator>>(std::istream&, ed::Estudiante&)
std::istream &operator>>(std::istream &i, ed::Estudiante &e){
	std::getline(i,e._nombre);

	std::getline(i,e._apellidos);

	i >> e._teoria;
	//Se elimina el salto de línea del flujo de entrada para evitar problemas con la posterior lectura de cadenas
	i.ignore();

	i >> e._practica;
	//Se elimina el salto de línea del flujo de entrada para evitar problemas con la posterior lectura de cadenas
	i.ignore();

	/*Forma alternativa para la lectura de datos numéricos usando una variable auxiliar: cadena
	std::string cadena;

	std::getline(i,cadena);
	e._teoria = atof(cadena.c_str());

	std::getline(i,cadena);
	e._practica = atof(cadena.c_str());*/

	//Se devuelve el flujo de entrada
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %r15
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2260
leaq 0x28(%r14), %r15
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2260
leaq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x2280
movq %rbx, %rdi
callq 0x2250
addq $0x4c, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2280
movq %rbx, %rdi
callq 0x2250
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/estudiante.cpp
// Function: ed::operator<<(std::ostream&, ed::Estudiante const&)
std::ostream &operator<<(std::ostream &o, ed::Estudiante const &e){
	o << e._nombre << std::endl;
	o << e._apellidos << std::endl;

	o << e._teoria << std::endl;
	o << e._practica << std::endl;

	//Se devuelve el flujo de salida
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
callq 0x2190
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
movq %rbx, %rdi
callq 0x2190
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cvtss2sd 0x48(%r14), %xmm0
movq %rbx, %rdi
callq 0x2200
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
xorps %xmm0, %xmm0
cvtss2sd 0x4c(%r14), %xmm0
movq %rbx, %rdi
callq 0x2200
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)