LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x2278c
movq -0x28(%rbp), %rdi
callq 0x22820
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rax
cmpq 0x10(%rcx), %rax
jne 0x227ab
movq -0x28(%rbp), %rdi
movq 0x10(%rdi), %rsi
addq $0x1, %rsi
callq 0x22850
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x227ed
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
movl (%rcx,%rdx,4), %edx
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x227b7
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %esi
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./blockwise_sa.h
// Function: KarkkainenBlockwiseSA<SString<char>>::reset()
virtual void reset() {
		if(!_built) {
			build();
		}
		assert(_built);
		_cur = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x80(%rax)
jne 0x233e6
movq -0x10(%rbp), %rdi
callq 0x26e30
movq -0x10(%rbp), %rax
movl $0x0, 0x70(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x2a3f7
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2a3f7
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a490
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
ja 0x2a413
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x2a43a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0x2a42e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22920
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movl %r9d, %eax
movq %rcx, -0x60(%rbp)
movq %rdx, %rcx
movq -0x60(%rbp), %rdx
movq %rcx, -0x58(%rbp)
movq %rsi, %rcx
movq -0x58(%rbp), %rsi
movq %rcx, -0x50(%rbp)
movq %rdi, %r9
movq -0x50(%rbp), %rdi
movb %al, %cl
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movb 0x10(%rbp), %al
movq %r9, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
andb $0x1, %cl
movb %cl, -0x2d(%rbp)
andb $0x1, %al
movb %al, -0x2e(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14c10
movq %rax, -0x38(%rbp)
testb $0x1, -0x2e(%rbp)
je 0x2a87c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x105c0
movq $0x0, -0x40(%rbp)
testb $0x1, -0x2e(%rbp)
je 0x2a8c8
movq -0x20(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
shlq $0x2, %rdx
callq 0x6300
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
movq -0x20(%rbp), %r11
movq 0x18(%rbp), %r10
movq 0x20(%rbp), %rax
xorl %ebx, %ebx
movq $0x0, (%rsp)
movq %r11, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x2b260
testb $0x1, -0x2e(%rbp)
je 0x2a97b
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq 0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %r9d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, (%rsp)
callq 0x2ab90
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2a962
jmp 0x2a954
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x2a948
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x2a979
movq -0x68(%rbp), %rdi
callq 0x65b0
jmp 0x2a97b
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2c158
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x8(%rax), %rax
imulq $0x18, -0x18(%rbp), %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2c0fc
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq (%rax), %rdx
subq %rdx, %rcx
sarq $0x2, %rcx
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x2e080
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x2e0af
jmp 0x2e082
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %edx
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rsi
addq $0x4, %rsi
movq %rsi, -0x10(%rbp)
movslq 0x4(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2e082
jmp 0x2e0af
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
imull 0x8(%rax), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %ecx
shrl $0x10, %ecx
movl %ecx, -0xc(%rbp)
movl (%rax), %ecx
imull 0x8(%rax), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %ecx
xorl -0xc(%rbp), %ecx
movl %ecx, -0xc(%rbp)
movl $0x0, 0xc(%rax)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./util.h
// Function: void erase<EList<unsigned int, 128>>(EList<unsigned int, 128>&, unsigned long)
void erase(Container& v, size_t index) {
	assert_lt(index, v.size());
	for (size_t i = index; i < v.size()-1; i++)
		v[i] = v[i+1];
	v.pop_back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14440
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2e31f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x14410
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14410
movl -0x24(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2e2c8
movq -0x8(%rbp), %rdi
callq 0x30270
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x3588b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x3587f
movq -0x20(%rbp), %rdi
movl $0x4, %esi
callq 0x6440
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x358c2
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x358b6
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x6440
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x3590a
movq -0x18(%rbp), %rdi
callq 0x37db0
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x1, 0x18(%rax)
ja 0x36050
jmp 0x361cb
movq -0x38(%rbp), %rdi
callq 0x37db0
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movq 0x18(%rax), %rax
subq $0x1, %rax
andq $0xf, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq -0x20(%rbp), %rcx
movb %al, -0x39(%rbp)
ja 0x360ba
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x3a(%rbp)
jne 0x360b4
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
seta %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x360c6
jmp 0x361cb
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
movq -0x18(%rbp), %rcx
shlq %rcx
shrl %cl, %edx
movl %edx, %ecx
andl $0x3, %ecx
movl %ecx, -0x2c(%rbp)
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
movq -0x28(%rbp), %rcx
shlq %rcx
shrl %cl, %edx
movl %edx, %ecx
andl $0x3, %ecx
movl %ecx, -0x30(%rbp)
movq -0x18(%rbp), %rcx
shlq %rcx
movl $0x3, %esi
shll %cl, %esi
xorl $-0x1, %esi
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rdx
andl (%rcx,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
movq -0x28(%rbp), %rcx
shlq %rcx
movl $0x3, %esi
shll %cl, %esi
xorl $-0x1, %esi
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rdx
andl (%rcx,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
movl -0x30(%rbp), %esi
movq -0x18(%rbp), %rcx
shlq %rcx
shll %cl, %esi
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rdx
orl (%rcx,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rcx
shlq %rcx
shll %cl, %edx
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
cmpq $0x0, -0x18(%rbp)
jne 0x36191
movq $0xf, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3619d
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0xf, -0x28(%rbp)
jne 0x361ba
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x361c6
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x36088
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: S2bDnaString::set(int, unsigned long)
void set(int c, size_t idx) {
		assert_lt(idx, len_);
		assert_range(0, 3, c);
		size_t word = idx >> 4;
		size_t bpoff = (idx & 15) << 1;
		cs_[word] = cs_[word] & ~(uint32_t)(3 << bpoff);
		cs_[word] = cs_[word] |  (uint32_t)(c << bpoff);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
andq $0xf, %rcx
shlq %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq -0x28(%rbp), %rcx
movl $0x3, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl %ecx, %esi
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rcx
shll %cl, %esi
movl %esi, %ecx
orl %ecx, %edx
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x17d6c
jmp 0x17d8b
leaq 0xbe187(%rip), %rdi     # 0xd5efa
leaq 0xbc967(%rip), %rsi     # 0xd46e1
movl $0x23db, %edx           # imm = 0x23DB
leaq 0xbe9c9(%rip), %rcx     # 0xd674f
callq 0x13130
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
subb $0x1, %al
je 0x17da6
jmp 0x17d9d
movb -0x11(%rbp), %al
subb $0x2, %al
je 0x17dba
jmp 0x17dd2
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x21f20
jmp 0x17de3
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x21f70
jmp 0x17de3
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x21fc0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x187a0
movq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x1, %edx
callq 0x187d0
movq -0x38(%rbp), %rdi
callq 0x19170
jmp 0x18309
movq -0x40(%rbp), %rdi
movl $0xf, %esi
callq 0x19260
jmp 0x18319
leaq -0x20(%rbp), %rdi
callq 0x19530
testb $0x1, %al
jne 0x18328
jmp 0x18337
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x174b0
jmp 0x18344
movq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x19550
leaq -0x20(%rbp), %rdi
callq 0x177b0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x177b0
movq -0x28(%rbp), %rdi
callq 0xd1250
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1eaa0
testb $0x1, %al
jne 0x1bad3
jmp 0x1baec
movq -0x68(%rbp), %rax
movb $0x1, (%rax)
callq 0x1bf50
movq -0x68(%rbp), %rdi
movq %rax, 0x8(%rdi)
callq 0x19170
movq -0x68(%rbp), %rdi
callq 0x1eac0
testb $0x1, %al
jne 0x1bafb
jmp 0x1bb12
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1eae0
addq $0x70, %rsp
popq %rbp
retq
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x25740
movq -0x68(%rbp), %rsi
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1ebc0
jmp 0x1bb33
leaq 0xb9d5d(%rip), %rsi     # 0xd5897
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x1d7b0
jmp 0x1bb49
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x571b0
jmp 0x1bb58
movq -0x70(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
leaq 0xf9329(%rip), %rsi     # 0x114e90
leaq 0x13572(%rip), %rdx     # 0x2f0e0
callq 0x26790
jmp 0x1bbcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1bbaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1bba6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa23d0
leaq -0x50(%rbp), %rdi
callq 0xa23d0
testb $0x1, -0x5d(%rbp)
jne 0x1bbb7
jmp 0x1bbc0
movq -0x70(%rbp), %rdi
callq 0x257a0
jmp 0x1bbc2
movq -0x58(%rbp), %rdi
callq 0xd1250
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x13690
movq -0x38(%rbp), %rdi
movl $0x0, (%rax)
leaq -0x20(%rbp), %rsi
callq 0x20ca0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x2b(%rbp)
jne 0x20c95
cmpq $0x0, -0x28(%rbp)
setb %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
setb %al
andb $0x1, %al
movzbl %al, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x2b(%rbp)
jne 0x20c95
callq 0x13690
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x2b(%rbp)
jne 0x20c95
movq -0x38(%rbp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x2b(%rbp)
jae 0x20c95
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x8(%rcx), %rax
sete %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: 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>>::set_begin()
void set_begin() noexcept
        {
            assert(m_object != nullptr);

            switch (m_object->m_type)
            {
                case basic_json::value_t::object:
                {
                    m_it.object_iterator = m_object->m_value.object->begin();
                    break;
                }

                case basic_json::value_t::array:
                {
                    m_it.array_iterator = m_object->m_value.array->begin();
                    break;
                }

                case basic_json::value_t::null:
                {
                    // set to end so begin()==end() is true: null is empty
                    m_it.primitive_iterator.set_end();
                    break;
                }

                default:
                {
                    m_it.primitive_iterator.set_begin();
                    break;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x217ec
jmp 0x2180b
leaq 0xb4707(%rip), %rdi     # 0xd5efa
leaq 0xb2ee7(%rip), %rsi     # 0xd46e1
movl $0x2343, %edx           # imm = 0x2343
leaq 0xb4880(%rip), %rcx     # 0xd6086
callq 0x13130
movq -0x20(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
testb %al, %al
je 0x21879
jmp 0x2181d
movb -0x21(%rbp), %al
subb $0x1, %al
je 0x2182f
jmp 0x21826
movb -0x21(%rbp), %al
subb $0x2, %al
je 0x21854
jmp 0x2188c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x21980
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x2189d
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x204c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x2189d
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x219b0
jmp 0x2189d
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x219d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: moya-lang[P]Allocator/Measure.cpp
// Function: void printTestStatus<PushFrontTest<std::forward_list<unsigned long, std::allocator<unsigned long>>>, PushFrontTest<std::forward_list<unsigned long, Moya::Allocator<unsigned long, 1024ul>>>>(char const*, PushFrontTest<std::forward_list<unsigned long, std::allocator<unsigned long>>>&, PushFrontTest<std::forward_list<unsigned long, Moya::Allocator<unsigned long, 1024ul>>>&)
void printTestStatus(const char *name, StlAllocatorContainer &stlContainer, MoyaAllocatorContainer &fastContainer)
{
    double stlRunTime = stlContainer.run();
    double moyaRunTime = fastContainer.run();

    std::cout << std::fixed;
    std::cout << name << " - Default STL Allocator : " << stlRunTime << " seconds." << std::endl;
    std::cout << name << " - Memory Pool Allocator : " << moyaRunTime << " seconds." << std::endl;
    std::cout << name << " - Gain : x" << stlRunTime / moyaRunTime << "." << std::endl;
    std::cout << std::endl;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xa290
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa330
movsd %xmm0, (%rsp)
movq 0xe8b7(%rip), %rdi      # 0x10fd0
leaq 0x7cb0(%rip), %rsi      # 0xa3d0
callq 0x2070
movq 0x20(%rsp), %rsi
movq 0xe89f(%rip), %rdi      # 0x10fd0
callq 0x20f0
movq %rax, %rdi
leaq 0x8933(%rip), %rsi      # 0xb073
callq 0x20f0
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2190
movq %rax, %rdi
leaq 0x8932(%rip), %rsi      # 0xb08f
callq 0x20f0
movq %rax, %rdi
movq 0xe83c(%rip), %rsi      # 0x10fa8
callq 0x2130
movq 0x20(%rsp), %rsi
movq 0xe853(%rip), %rdi      # 0x10fd0
callq 0x20f0
movq %rax, %rdi
leaq 0x890d(%rip), %rsi      # 0xb099
callq 0x20f0
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0x2190
movq %rax, %rdi
leaq 0x88e7(%rip), %rsi      # 0xb08f
callq 0x20f0
movq %rax, %rdi
movq 0xe7f1(%rip), %rsi      # 0x10fa8
callq 0x2130
movq 0x20(%rsp), %rsi
movq 0xe808(%rip), %rdi      # 0x10fd0
callq 0x20f0
movq %rax, %rdi
leaq 0x88de(%rip), %rsi      # 0xb0b5
callq 0x20f0
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
divsd (%rsp), %xmm0
callq 0x2190
movq %rax, %rdi
leaq 0x889e(%rip), %rsi      # 0xb097
callq 0x20f0
movq %rax, %rdi
movq 0xe7a0(%rip), %rsi      # 0x10fa8
callq 0x2130
movq 0xe7bc(%rip), %rdi      # 0x10fd0
movq 0xe78d(%rip), %rsi      # 0x10fa8
callq 0x2130
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x3066
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x3590
jmp 0x3030
jmp 0x3068
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jbe 0x3091
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x35d0
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3068
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: moya-lang[P]Allocator/./Allocator.h
// Function: Moya::MemoryPool<std::_Fwd_list_node<unsigned long>, 1024ul>::~MemoryPool()
~MemoryPool()
        {
            while (firstBuffer) {
                Buffer *buffer = firstBuffer;
                firstBuffer = buffer->next;
                delete buffer;
            }
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3dce
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq 0x4000(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3dcc
movq 0x8(%rsp), %rdi
movl $0x4008, %esi           # imm = 0x4008
callq 0x2110
jmp 0x3d83
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
je 0x40b0
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x413a
movq 0x8(%rsp), %rax
cmpq $0x400, 0x10(%rax)      # imm = 0x400
jb 0x4118
movl $0x4008, %edi           # imm = 0x4008
callq 0x2100
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rsi
callq 0x4170
jmp 0x40e3
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
jmp 0x4118
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x4008, %esi           # imm = 0x4008
callq 0x2110
jmp 0x4144
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
callq 0x4190
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x2180
nop
// File: moya-lang[P]Allocator/Measure.cpp
// Function: PushBackTest<std::__cxx11::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_back(size++);

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x54d6
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x5540
jmp 0x54a0
jmp 0x54d8
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jbe 0x5501
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x5580
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x54d8
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x5853
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rdx, %rsi
callq 0x5d20
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5cd0
movq %rax, 0x10(%rsp)
movb %dl, 0x18(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x5801
jmp 0x5855
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jbe 0x5884
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x30(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x5d50
jmp 0x5855
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x7e5f
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x8260
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
jmp 0x7e20
jmp 0x7e61
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jbe 0x7e8f
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x82c0
jmp 0x7e61
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x2030
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
cmpq $0x400, 0x20(%rsp)      # imm = 0x400
jae 0xa2f0
movq (%rsp), %rsi
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x10, %rsi
callq 0xa3f0
movq (%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xa2b5
callq 0x2030
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa450
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xa420
movsd %xmm0, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xa4a0
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0xca85(%rip), %rdi      # 0xefd0
leaq 0x7abe(%rip), %rsi      # 0xa010
callq 0x21a0
movq %rax, %rdi
leaq 0x7ab7(%rip), %rsi      # 0xa018
callq 0x21a0
movq %rax, %rdi
leaq 0x8a4b(%rip), %rsi      # 0xafbb
callq 0x21a0
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq 0xca5c(%rip), %rdi      # 0xefe0
callq 0x2070
movq 0xca40(%rip), %rdi      # 0xefd0
leaq 0x7a79(%rip), %rsi      # 0xa010
callq 0x21a0
movq %rax, %rdi
leaq 0x7a88(%rip), %rsi      # 0xa02e
callq 0x21a0
movq %rax, %rdi
leaq 0x8a06(%rip), %rsi      # 0xafbb
callq 0x21a0
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq 0xca17(%rip), %rdi      # 0xefe0
callq 0x2070
movq 0xc9fb(%rip), %rdi      # 0xefd0
leaq 0x7a34(%rip), %rsi      # 0xa010
callq 0x21a0
movq %rax, %rdi
leaq 0x7a5d(%rip), %rsi      # 0xa048
callq 0x21a0
movq %rax, %rdi
leaq 0x89c1(%rip), %rsi      # 0xafbb
callq 0x21a0
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
movq 0xc9d2(%rip), %rdi      # 0xefe0
callq 0x2080
movq 0xc9b6(%rip), %rdi      # 0xefd0
leaq 0x79ef(%rip), %rsi      # 0xa010
callq 0x21a0
movq %rax, %rdi
leaq 0x7a37(%rip), %rsi      # 0xa067
callq 0x21a0
movq %rax, %rdi
leaq 0x897c(%rip), %rsi      # 0xafbb
callq 0x21a0
movq -0x10(%rbp), %rsi
addq $0x4c, %rsi
movq 0xc98d(%rip), %rdi      # 0xefe0
callq 0x2080
movq 0xc981(%rip), %rdi      # 0xefe0
callq 0x22d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x10(%rbp), %rax
je 0x2916
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x20(%rbp), %rdi
movss %xmm0, -0x14(%rbp)
movq (%rdi), %rax
leaq -0x14(%rbp), %rsi
callq *0x40(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x20(%rbp), %rdi
movss %xmm0, -0x18(%rbp)
movq (%rdi), %rax
leaq -0x18(%rbp), %rsi
callq *0x48(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2960
testb $0x1, %al
jne 0x2929
jmp 0x292b
jmp 0x294a
leaq 0x77af(%rip), %rdi      # 0xa0e1
leaq 0x77b3(%rip), %rsi      # 0xa0ec
movl $0x4d, %edx
leaq 0x77b6(%rip), %rcx      # 0xa0fb
callq 0x2140
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x2070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x2070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
callq 0x2080
movq -0x8(%rbp), %rdi
callq 0x22d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4c, %rsi
callq 0x2080
movq -0x8(%rbp), %rdi
callq 0x22d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x2180
movq %rax, %rdi
movq 0xc495(%rip), %rsi      # 0xefc0
callq 0x21c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x2180
movq %rax, %rdi
movq 0xc475(%rip), %rsi      # 0xefc0
callq 0x21c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movss 0x48(%rax), %xmm0
callq 0x2160
movq %rax, %rdi
movq 0xc454(%rip), %rsi      # 0xefc0
callq 0x21c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movss 0x4c(%rax), %xmm0
callq 0x2160
movq %rax, %rdi
movq 0xc433(%rip), %rsi      # 0xefc0
callq 0x21c0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::liberarMemoria()
void ed::NodoEnlazadoArbolBinarioEstudiante::liberarMemoria(){
	if(hasLeftTree()){ //Liberamos la memoria del subárbol hijo izquierdo
		getLeftTree()->liberarMemoria();
	}
			
	if(hasRightTree()){ //Liberamos la memoria del subárbol hijo derecho
		getRightTree()->liberarMemoria();
	}
	
	//Borramos los atributos del nodo raíz
	delete _item;
	delete getLeftTree();
	delete getRightTree();
		
	_item=NULL;
	setLeftTree(NULL);
	setRightTree(NULL);
	setParent(NULL);
	
	//Postcondición
	#ifndef NDEBUG
		assert(isEmpty());
	#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x3f10
testb $0x1, %al
jne 0x2cef
jmp 0x2d00
movq -0x10(%rbp), %rdi
callq 0x3f40
movq %rax, %rdi
callq 0x2cd0
movq -0x10(%rbp), %rdi
callq 0x3f60
testb $0x1, %al
jne 0x2d0f
jmp 0x2d20
movq -0x10(%rbp), %rdi
callq 0x3f90
movq %rax, %rdi
callq 0x2cd0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2d3c
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x3f40
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2d59
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x3f90
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2d76
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
movq $0x0, 0x8(%rdi)
xorl %eax, %eax
movl %eax, %esi
callq 0x3fb0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4000
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4050
movq -0x10(%rbp), %rdi
callq 0x40a0
testb $0x1, %al
jne 0x2db4
jmp 0x2db6
jmp 0x2dd5
leaq 0x74bb(%rip), %rdi      # 0xa278
leaq 0x7379(%rip), %rsi      # 0xa13d
movl $0x24, %edx
leaq 0x7394(%rip), %rcx      # 0xa164
callq 0x2140
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::nItems() const
int ed::NodoEnlazadoArbolBinarioEstudiante::nItems() const{
	int items=0;

	if(!isEmpty()){
		items++; //Sumamos el ítem del nodo raíz

		if(hasLeftTree()){
			items=items+getLeftTree()->nItems(); //Sumamos los ítems de su subárbol hijo izquierdo
		}

		if(hasRightTree()){
			items=items+getRightTree()->nItems(); //Sumamos los ítems de su subárbol hijo derecho
		}
	}

	return items;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x40a0
testb $0x1, %al
jne 0x2e6f
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
callq 0x3f10
testb $0x1, %al
jne 0x2e1c
jmp 0x2e3d
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x3f40
movq %rax, %rdi
callq 0x2de0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3f60
testb $0x1, %al
jne 0x2e4c
jmp 0x2e6d
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
callq 0x3f90
movq %rax, %rdi
callq 0x2de0
movl %eax, %ecx
movl -0x20(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x2e6f
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DaCasBe[P]Gestion-de-asignaturas-mediante-arboles-binarios-ordenados/nodoEnlazadoArbolBinarioEstudiante.cpp
// Function: ed::NodoEnlazadoArbolBinarioEstudiante::exists(ed::Estudiante const&)
bool ed::NodoEnlazadoArbolBinarioEstudiante::exists(ed::Estudiante const &item){
	if(isEmpty()){
		return false; //Si el árbol está vacío, es imposible que exista el ítem
	}

	else{ //El árbol no está vacío
		if(getItem()==item){ //El nodo raíz contiene el ítem que buscamos
			return true;
		}

		else{ //El nodo raíz no contiene el ítem que buscamos
			if(item<getItem()){ //El ítem ha de encontrarse a la izquierda del árbol
				if(hasLeftTree()){
					return getLeftTree()->exists(item); //Buscamos el ítem en el subárbol hijo izquierdo
				}

				else{
					return false;
				}
			}

			else{ //El ítem ha de encontrarse a la derecha del árbol
				if(hasRightTree()){
					return getRightTree()->exists(item); //Buscamos el ítem en el subárbol hijo derecho
				}

				else{
					return false;
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x40a0
testb $0x1, %al
jne 0x2ea3
jmp 0x2eac
movb $0x0, -0x1(%rbp)
jmp 0x2f55
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2960
testb $0x1, %al
jne 0x2ec8
jmp 0x2ed1
movb $0x1, -0x1(%rbp)
jmp 0x2f55
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x29e0
testb $0x1, %al
jne 0x2ef5
jmp 0x2f26
movq -0x20(%rbp), %rdi
callq 0x3f10
testb $0x1, %al
jne 0x2f04
jmp 0x2f20
movq -0x20(%rbp), %rdi
callq 0x3f40
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2e80
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2f55
movb $0x0, -0x1(%rbp)
jmp 0x2f55
movq -0x20(%rbp), %rdi
callq 0x3f60
testb $0x1, %al
jne 0x2f35
jmp 0x2f51
movq -0x20(%rbp), %rdi
callq 0x3f90
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2e80
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2f55
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq