LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::isGzippedFile(char const*)
static bool isGzippedFile(const char *filename) {
		if (filename == NULL) {
			return false;
		}

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

		uint8_t byte1, byte2;

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

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

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

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

		return false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x12649
movq %rdi, %rbx
xorl %esi, %esi
xorl %eax, %eax
callq 0x5650
cmpl $-0x1, %eax
je 0x12656
movl %eax, %ebp
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
movl %eax, %edi
callq 0x54d0
movq %rax, %r14
leaq 0x6(%rsp), %rsi
movl $0x1, %edx
movl %ebp, %edi
callq 0x54d0
movq %rax, %r15
movl %ebp, %edi
callq 0x5740
cmpl $-0x1, %eax
je 0x12666
testq %r14, %r14
je 0x12607
testq %r15, %r15
je 0x12607
movb 0x7(%rsp), %al
xorb $0x1f, %al
movb 0x6(%rsp), %cl
xorb $-0x75, %cl
orb %al, %cl
sete %al
jmp 0x1264b
movq 0x289e2(%rip), %rbx     # 0x3aff0
leaq 0x1d811(%rip), %rsi     # 0x2fe26
movl $0x20, %edx
movq %rbx, %rdi
callq 0x53f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5330
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28993(%rip), %rdi     # 0x3aff0
leaq 0x1d7a1(%rip), %rsi     # 0x2fe05
jmp 0x12674
movq 0x28983(%rip), %rdi     # 0x3aff0
leaq 0x1d7a1(%rip), %rsi     # 0x2fe15
callq 0x5340
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5340
movq %rax, %rdi
callq 0x5170
movl $0x4, %edi
callq 0x5180
movl $0x1, (%rax)
movq 0x288a5(%rip), %rsi     # 0x3af48
movq %rax, %rdi
xorl %edx, %edx
callq 0x5630
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./filebuf.h
// Function: BitpairOutFileBuf::BitpairOutFileBuf(char const*)
BitpairOutFileBuf(const char *in) : bpPtr_(0), cur_(0) {
		assert(in != NULL);
		out_ = fopen(in, "wb");
		if(out_ == NULL) {
			std::cerr << "Error: Could not open bitpair-output file " << in << std::endl;
			throw 1;
		}
		memset(buf_, 0, BUF_SZ);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x1d779(%rip), %rsi     # 0x2fe47
movq %rbx, %rdi
callq 0x53c0
movq %rax, (%r14)
testq %rax, %rax
je 0x126f8
addq $0x18, %r14
movl $0x20000, %edx          # imm = 0x20000
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51b0
movq 0x288f1(%rip), %rdi     # 0x3aff0
leaq 0x1d744(%rip), %rsi     # 0x2fe4a
callq 0x5340
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5340
movq %rax, %rdi
callq 0x5170
movl $0x4, %edi
callq 0x5180
movl $0x1, (%rax)
movq 0x28813(%rip), %rsi     # 0x3af48
movq %rax, %rdi
xorl %edx, %edx
callq 0x5630
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./filebuf.h
// Function: BitpairOutFileBuf::close()
void close() {
		if(cur_ > 0 || bpPtr_ > 0) {
			if(bpPtr_ == 0) cur_--;
			if(!fwrite((const void *)buf_, cur_ + 1, 1, out_)) {
				std::cerr << "Error writing to the reference index file (.4.ebwt)" << std::endl;
				throw 1;
			}
		}
		fclose(out_);
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
setne %cl
movl 0x8(%rdi), %eax
testl %eax, %eax
setg %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x127e7
testl %eax, %eax
jne 0x127ce
decq %rsi
movq %rsi, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
incq %rsi
movq (%rbx), %rcx
movl $0x1, %edx
callq 0x5720
testq %rax, %rax
je 0x127f0
movq (%rbx), %rdi
popq %rbx
jmp 0x5350
movq 0x287f9(%rip), %rdi     # 0x3aff0
leaq 0x1d677(%rip), %rsi     # 0x2fe75
callq 0x5340
movq %rax, %rdi
callq 0x5170
movl $0x4, %edi
callq 0x5180
movl $0x1, (%rax)
movq 0x28726(%rip), %rsi     # 0x3af48
movq %rax, %rdi
xorl %edx, %edx
callq 0x5630
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./ebwt.h
// Function: SString<char> Ebwt::join<SString<char>>(EList<FileBuf*, 128>&, EList<RefRecord, 128>&, unsigned int, RefReadInParams const&, unsigned int)
TStr Ebwt::join(EList<FileBuf*>& l,
		EList<RefRecord>& szs,
		TIndexOffU sztot,
		const RefReadInParams& refparams,
		uint32_t seed)
{
	RandomSource rand; // reproducible given same seed
	rand.init(seed);
	RefReadInParams rpcp = refparams;
	TStr ret;
	size_t guessLen = sztot;
	ret.resize(guessLen);
	TIndexOffU dstoff = 0;
	ASSERT_ONLY(size_t szsi = 0);
	for(size_t i = 0; i < l.size(); i++) {
		// For each sequence we can pull out of istream l[i]...
		assert(!l[i]->eof());
		bool first = true;
		while(!l[i]->eof()) {
			RefRecord rec = fastaRefReadAppend(*l[i], first, ret, dstoff, rpcp);
#ifndef ACCOUNT_FOR_ALL_GAP_REFS
			if(rec.first && rec.len == 0) rec.first = false;
#endif
			first = false;
			size_t bases = rec.len;
			assert_eq(rec.off, szs[szsi].off);
			assert_eq(rec.len, szs[szsi].len);
			assert_eq(rec.first, szs[szsi].first);
			ASSERT_ONLY(szsi++);
			if(bases == 0) continue;
		}
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%r8), %rax
movq %rax, 0x8(%rsp)
leaq 0x27336(%rip), %rax     # 0x3aac0
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movl %ecx, %esi
callq 0xdc12
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x18(%r14)
je 0x137fd
xorl %r13d, %r13d
leaq 0x4(%rsp), %r15
leaq 0x8(%rsp), %r12
movb $0x1, %al
movq 0x8(%r14), %rcx
movq (%rcx,%r13,8), %rdi
movq 0x20(%rdi), %rcx
cmpq 0x28(%rdi), %rcx
jne 0x137d9
testb $0x1, 0x30(%rdi)
jne 0x137f4
movzbl %al, %esi
andl $0x1, %esi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %r9d, %r9d
callq 0xd00c
xorl %eax, %eax
jmp 0x137c1
incq %r13
cmpq 0x18(%r14), %r13
jb 0x137bf
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x13810
movq %rax, %r14
movq %rbx, %rdi
callq 0xdc70
movq %r14, %rdi
callq 0x5680
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./sstring.h
// Function: SString<char>::toZBufXForm(char const*) const
const char* toZBufXForm(const char *xform) const {
		ASSERT_ONLY(size_t xformElts = strlen(xform));
		// Lazily allocate space for print buffer
		if(printcs_ == NULL) {
			const_cast<char*&>(printcs_) = new char[len_+1];
		}
		char* printcs = const_cast<char*>(printcs_);
		assert(printcs != NULL);
		for(size_t i = 0; i < len_; i++) {
			assert_lt(cs_[i], (int)xformElts);
			printcs[i] = xform[(int)cs_[i]];
		}
		printcs[len_] = 0;
		return printcs_;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %r15
testq %rax, %rax
jne 0x13849
leaq 0x1(%r15), %rdi
callq 0x5030
movq %rax, 0x10(%rbx)
testq %r15, %r15
je 0x1386e
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movsbq (%rdx,%rcx), %rdx
movb (%r14,%rdx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
movq 0x18(%rbx), %rdx
cmpq %rdx, %rcx
jb 0x13850
jmp 0x13870
xorl %edx, %edx
movb $0x0, (%rax,%rdx)
movq 0x10(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq %rsi, 0x20(%rsp)
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x15bc3
movq %rdi, %r12
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movl $0x1, %ebp
xorl %esi, %esi
xorl %r9d, %r9d
xorl %r15d, %r15d
xorl %edx, %edx
movq 0x28(%rsp), %r13
leaq (%rsi,%rsi,2), %r8
movl 0x4(%rcx,%r8,4), %esi
testl %esi, %esi
je 0x15bb6
movq %r8, 0x30(%rsp)
leaq (%rcx,%r8,4), %rcx
movzbl 0x8(%rcx), %eax
testl %eax, %eax
movl $0x0, %r8d
cmovnel %r8d, %r15d
addl (%rcx), %r15d
leal (%rdx,%rax), %ecx
cmpl $0x1, 0x8(%rsp)
movl %ecx, 0xc(%rsp)
jne 0x15b15
movl 0x74(%r12), %r14d
subl %ecx, %r14d
movq 0x80(%r12), %rax
movl (%rax,%r14,4), %ebx
addl %r15d, %esi
subl %esi, %ebx
jmp 0x15b1f
leal (%rdx,%rax), %r14d
decl %r14d
movl %r15d, %ebx
cmpb $0x0, 0x1(%r12)
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 0x5450
cmpb $0x0, 0x1(%r12)
movl %r14d, %eax
bswapl %eax
cmovel %r14d, %eax
movl %eax, 0x18(%rsp)
movl $0x4, %edx
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
callq 0x5450
cmpb $0x0, 0x1(%r12)
movl %ebx, %eax
bswapl %eax
cmovel %ebx, %eax
movl %eax, 0x1c(%rsp)
movl $0x4, %edx
movq %r13, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x5450
movl 0x10(%rsp), %r9d
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rax
movq 0x30(%rsp), %rdx
movl 0x4(%rcx,%rdx,4), %edx
addl %edx, %r9d
addl %edx, %r15d
movl 0xc(%rsp), %edx
movl %ebp, %esi
incl %ebp
cmpq %rsi, %rax
ja 0x15abf
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./diff_sample.h
// Function: DifferenceCoverSample<SString<char>>::simulateAllocs(SString<char> const&, unsigned int)
static size_t simulateAllocs(const TStr& text, uint32_t v) {
		EList<uint32_t> ds = getDiffCover(v, false /*verbose*/, false /*sanity*/);
		size_t len = text.length();
		size_t sPrimeSz = (len / v) * ds.size();
		// sPrime, sPrimeOrder, _isaPrime all exist in memory at
		// once and that's the peak
		AutoArray<TIndexOffU> aa(sPrimeSz * 3 + (1024 * 1024 /*out of caution*/));
		return sPrimeSz * 4; // sPrime array
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd336
movq 0x18(%r14), %r14
movq 0x8(%r15), %rdi
movq 0x18(%r15), %r15
testq %rdi, %rdi
je 0x15c05
callq 0x5440
movl %ebx, %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
imulq %r15, %rax
shlq $0x2, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23c86(%rip), %rax     # 0x3ab08
movq %rax, (%rdi)
movq 0x78(%rdi), %r14
testq %r14, %r14
je 0x16f50
movq 0xa0(%r14), %rdi
testq %rdi, %rdi
je 0x16eb9
leaq 0xa0(%r14), %r15
callq 0x5440
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x80(%r14), %rdi
testq %rdi, %rdi
je 0x16ee0
leaq 0x80(%r14), %r15
callq 0x5440
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x16f01
leaq 0x60(%r14), %r15
callq 0x5440
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x16f22
leaq 0x38(%r14), %r15
callq 0x5440
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x16f43
leaq 0x18(%r14), %r15
callq 0x5440
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl $0xc8, %esi
movq %r14, %rdi
callq 0x5370
movq 0x128(%rbx), %rdi
testq %rdi, %rdi
je 0x16f6c
callq 0x5440
movq $0x0, 0x128(%rbx)
cmpq $0x0, 0xe0(%rbx)
je 0x16fb8
leaq 0xd0(%rbx), %r14
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x5620
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x16fa2
cmpq $0x0, (%rdi)
jne 0x17087
movl $0x8, %esi
callq 0x5370
incq %r15
cmpq 0xe0(%rbx), %r15
jb 0x16f80
leaq 0x108(%rbx), %rdi
callq 0x19820
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x16feb
leaq 0xf0(%rbx), %r14
callq 0x5440
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x17012
leaq 0xd0(%rbx), %r14
callq 0x5440
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0xa0(%rbx), %rdi
leaq 0xb0(%rbx), %rax
cmpq %rax, %rdi
je 0x17030
movq (%rax), %rsi
incq %rsi
callq 0x5370
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x17051
leaq 0x50(%rbx), %r14
callq 0x5440
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x23b40(%rip), %rax     # 0x3ab98
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1707b
addq $0x20, %rbx
callq 0x5440
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 0x19820
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x170c4
leaq 0xf0(%rbx), %r12
callq 0x5440
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x583d
movq %r15, %rdi
callq 0x5680
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
movq 0x10(%rdi), %r12
jne 0x1786c
movq %r12, %rax
shrq $0x3e, %rax
leaq (,%r12,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)
movq 0x18(%r14), %rax
cmpq %r12, %rax
jne 0x178b3
movq %r12, %rcx
movq $-0x1, %rax
incq %rcx
je 0x178b3
leaq 0x1(,%r12,2), %rax
movq %rax, %rsi
addq %rax, %rax
cmpq %rcx, %rsi
jb 0x1788c
movq %r14, %rdi
callq 0x178d2
movq 0x18(%r14), %rax
jmp 0x178b3
movq 0x8(%r14), %rcx
movl -0x4(%rcx,%rax,4), %edx
movl %edx, (%rcx,%rax,4)
decq %rax
cmpq %rbx, %rax
ja 0x178a5
movl (%r15), %eax
movq 0x8(%r14), %rcx
movl %eax, (%rcx,%rbx,4)
incq 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17f85
movq %rbx, %rdi
callq 0x1a392
movl $0x0, 0x70(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd336
leaq 0x30(%rbx), %rdi
movl 0x8(%rbx), %esi
movq %r15, %rdx
callq 0xd555
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 0x1a6cc
shrl %eax
incq %rcx
cmpq $0x20, %rcx
jne 0x1a6b8
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 0x1ca80
cmpq $0x0, 0xb0(%rbx)
je 0x1a711
xorl %eax, %eax
movq 0xa0(%rbx), %rcx
movl $0xffffffff, (%rcx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
cmpq 0xb0(%rbx), %rax
jb 0x1a6f7
movl 0x28(%rbx), %eax
testq %rax, %rax
je 0x1a734
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 0x1a71b
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 0x1a766
callq 0x5440
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 0x58cb
movq (%rbp), %r14
jmp 0x1a78b
movq %rax, %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1a7ab
addq $0x18, %rbx
callq 0x5440
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x5680
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x1cace
cmpq $0x0, 0x8(%r14)
jne 0x1cace
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)
addq $0x18, %r14
movq %r14, %r15
jmp 0x1cae9
leaq 0x18(%r14), %r15
cmpq %rbx, 0x18(%r14)
jae 0x1cae9
cmpq %rbx, 0x10(%r14)
jae 0x1cae9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x178d2
movq %rbx, (%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x18, %rsp
movl %r8d, %r9d
movq %rcx, %r8
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movb 0x50(%rsp), %al
xorb $0x1, %al
movq 0x60(%rsp), %r11
movq 0x58(%rsp), %r10
movq 0x18(%rdi), %r13
cmpq $0x1001, %rdx           # imm = 0x1001
setb %cl
orb %al, %cl
jne 0x1cd13
movq %rbx, %rax
shrq $0x3e, %rax
leaq (,%rbx,4), %rbp
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rbp, %rdi
movl %r9d, 0xc(%rsp)
movq %r8, 0x10(%rsp)
callq 0x5030
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x5260
leaq (%r14,%rbx,4), %rbp
bsrq %rbx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1162c
movq %r14, %rdi
movq %rbp, %rsi
callq 0x11707
movq %r14, %rdi
callq 0x5440
movq 0x60(%rsp), %r11
movq 0x58(%rsp), %r10
movq 0x10(%rsp), %r8
movl 0xc(%rsp), %r9d
subq $0x8, %rsp
xorl %eax, %eax
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
pushq %r11
pushq %r10
pushq %rax
pushq %rbx
pushq %rax
callq 0x1d18c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./diff_sample.h
// Function: DifferenceCoverSample<SString<char>>::doBuiltSanityCheck() const
void DifferenceCoverSample<TStr>::doBuiltSanityCheck() const {
	uint32_t v = this->v();
	assert(built());
	VMSG_NL("  Doing sanity check");
	TIndexOffU added = 0;
	EList<TIndexOffU> sorted;
	sorted.resizeExact(_isaPrime.size());
	sorted.fill(OFF_MASK);
	for(size_t di = 0; di < this->d(); di++) {
		uint32_t d = _ds[di];
		size_t i = 0;
		for(size_t doi = _doffs[di]; doi < _doffs[di+1]; doi++, i++) {
			assert_eq(OFF_MASK, sorted[_isaPrime[doi]]);
			// Maps the offset of the suffix to its rank
			sorted[_isaPrime[doi]] = (TIndexOffU)(v*i + d);
			added++;
		}
	}
	assert_eq(added, _isaPrime.size());
	for(size_t i = 0; i < sorted.size()-1; i++) {
		assert(suffixLt(this->text(), sorted[i], sorted[i+1]));
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
cmpb $0x1, 0xc(%rdi)
jne 0x1d072
leaq 0x28(%rsp), %rdi
callq 0x5200
leaq 0x38(%rsp), %r14
leaq 0x13817(%rip), %rsi     # 0x307fe
movl $0x14, %edx
movq %r14, %rdi
callq 0x53f0
movq 0x38(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5330
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51f0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5580
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1caf2
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d054
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
movq 0x1defd(%rip), %rsi     # 0x3af58
leaq 0x28(%rsp), %rdi
callq 0x5230
leaq 0xa8(%rsp), %rdi
callq 0x5130
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq $0x80, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq 0x90(%rbx), %rsi
callq 0x1ca80
cmpq $0x0, 0x40(%rsp)
je 0x1d0c2
xorl %eax, %eax
movq 0x30(%rsp), %rcx
movl $0xffffffff, (%rcx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
cmpq 0x40(%rsp), %rax
jb 0x1d0ac
movl 0x50(%rbx), %edx
testl %edx, %edx
je 0x1d112
movq 0x60(%rbx), %rcx
xorl %eax, %eax
movq %rax, %rdi
movl (%rcx,%rax,4), %esi
incq %rax
cmpl 0x4(%rcx,%rdi,4), %esi
jae 0x1d10b
movq 0x18(%rbx), %rcx
movl (%rcx,%rdi,4), %edx
movq 0x80(%rbx), %rcx
movl (%rcx,%rsi,4), %ecx
movq 0x30(%rsp), %rdi
movl %edx, (%rdi,%rcx,4)
incq %rsi
movq 0x60(%rbx), %rcx
movl (%rcx,%rax,4), %edi
addl %ebp, %edx
cmpq %rdi, %rsi
jb 0x1d0e5
movl 0x50(%rbx), %edx
movl %edx, %esi
cmpq %rsi, %rax
jb 0x1d0cf
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1d121
callq 0x5440
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d166
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0x1d166
jmp 0x1d163
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1d184
callq 0x5440
jmp 0x1d184
movq %rax, %rbx
movq 0x1ddeb(%rip), %rsi     # 0x3af58
leaq 0x28(%rsp), %rdi
callq 0x5230
leaq 0xa8(%rsp), %rdi
callq 0x5130
movq %rbx, %rdi
callq 0x5680
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2364b
movl $0x4, %esi
callq 0x5370
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x23666
movl $0x1, %esi
callq 0x5370
movq $0x0, 0x10(%rbx)
movq %r14, 0x18(%rbx)
testq %r14, %r14
je 0x23687
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_O3/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 0x23f0b
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 0x23e71
jne 0x23f03
cmpq %r11, %rsi
jbe 0x23f03
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 0x23e5d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25519
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 0x25480
jne 0x2550f
cmpq %rsi, %r8
jbe 0x2550f
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 0x2546c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1839a
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 0x1839a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18704
movl %eax, 0x28(%r14)
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x17cac
movq %r15, %rdi
callq 0x1839a
movq %r14, %rdi
movl $0xf, %esi
callq 0x1843c
movb (%rsp), %al
cmpb $0x8, %al
jne 0x17ae2
movb $0x0, (%rbx)
movq %rbx, %rdi
callq 0x1839a
jmp 0x17b03
movb %al, (%rbx)
movq %rsp, %r14
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x1839a
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
callq 0x1839a
movq %rsp, %rdi
callq 0x174ba
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x174ba
movq %rbx, %rdi
callq 0xc7ad0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movb (%rdi), %al
testb %al, %al
jne 0x1997d
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x1d4b0
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x1839a
movb (%r14), %al
cmpb $0x1, %al
jne 0x19995
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1a364
movl $0x10, %edi
callq 0x1c3a0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1a3e0
leaq 0xb24ce(%rip), %rsi     # 0xcbe82
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x19ca3
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddb0
xorl %ebp, %ebp
leaq 0xec4b6(%rip), %rsi     # 0x105e90
leaq 0xc2ff(%rip), %rdx      # 0x25ce0
movq %rbx, %rdi
callq 0x1d3f0
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19a07
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1c0c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19a22
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1c0c0
testb %bpl, %bpl
jne 0x19a4c
jmp 0x19a54
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19a4c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1c0c0
jmp 0x19a4c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c400
movq %r14, %rdi
callq 0xc7ad0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1aaa8
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
jae 0x1aaa8
cmpq %rax, (%rsp)
sete %al
jmp 0x1aaaa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ae5d
testq %rax, %rax
je 0x1ae8f
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x1ae40
cmpl $0x1, %eax
jne 0x1ae4a
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x1ae52
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x1ae52
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1c3a0
movq %rax, %rbx
leaq 0xb1972(%rip), %rsi     # 0xcc7e3
movq %rax, %rdi
callq 0x30140
leaq 0xeb010(%rip), %rsi     # 0x105e90
leaq 0xae59(%rip), %rdx      # 0x25ce0
movq %rbx, %rdi
callq 0x1d3f0
leaq 0xb164f(%rip), %rdi     # 0xcc4e5
leaq 0xb0468(%rip), %rsi     # 0xcb305
leaq 0xb1970(%rip), %rcx     # 0xcc814
movl $0x242c, %edx           # imm = 0x242C
callq 0x13130
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c400
movq %r14, %rdi
callq 0xc7ad0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b907
movq %rsi, %r8
leaq 0x8(%rdi), %rsi
xorl %ecx, %ecx
movabsq $0x6666666666666667, %r10 # imm = 0x6666666666666667
movq %r8, %r9
cmpq $0x3f, %rcx
je 0x1b915
movq %r9, %rax
imulq %r10
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %r9, %r11
subq %rax, %r11
movq %r11, %rax
negq %rax
cmovsq %r11, %rax
addb $0x30, %al
movb %al, 0x8(%rdi,%rcx)
incq %rcx
addq $0x9, %r9
cmpq $0x13, %r9
movq %rdx, %r9
jae 0x1b86a
testq %r8, %r8
jns 0x1b8cd
leaq -0x1(%rcx), %rax
cmpq $0x3d, %rax
jae 0x1b934
movb $0x2d, 0x8(%rdi,%rcx)
incq %rcx
leaq (%rdi,%rcx), %rax
addq $0x7, %rax
cmpq %rsi, %rax
jbe 0x1b8fb
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 0x1b8de
movq (%rdi), %rdi
movq %rcx, %rdx
popq %rax
jmp 0x88440
movq (%rdi), %rdi
movl $0x30, %esi
popq %rax
jmp 0x882c0
leaq 0xb187a(%rip), %rdi     # 0xcd196
leaq 0xaf9e2(%rip), %rsi     # 0xcb305
leaq 0xb1873(%rip), %rcx     # 0xcd19d
movl $0x19e0, %edx           # imm = 0x19E0
callq 0x13130
leaq 0xb19c5(%rip), %rdi     # 0xcd300
leaq 0xaf9c3(%rip), %rsi     # 0xcb305
leaq 0xb1854(%rip), %rcx     # 0xcd19d
movl $0x19e5, %edx           # imm = 0x19E5
callq 0x13130
nop
// File: /workspace/github_cpp_makefile_star2_O3/moya-lang[P]Allocator/Measure.cpp
// Function: PushFrontTest<std::forward_list<unsigned long, Moya::Allocator<unsigned long, 1024ul>>>::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 0x3603
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
xorl %r12d, %r12d
leaq 0x1(%r12), %r13
movq %r15, %rdi
callq 0x3678
movq $0x0, (%rax)
movq %r12, 0x8(%rax)
movq 0x20(%r14), %rcx
movq %rcx, (%rax)
movq %rax, 0x20(%r14)
movq %r13, %r12
cmpq %r13, %rbx
jne 0x35cf
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x368c
movq (%rax), %rcx
movq %rcx, (%rbx)
jmp 0x36cb
movq 0x10(%rbx), %rax
cmpq $0x3ff, %rax            # imm = 0x3FF
jbe 0x36b8
movl $0x4008, %edi           # imm = 0x4008
callq 0x20e0
movq %rax, %rcx
movq 0x8(%rbx), %rax
movq %rax, 0x4000(%rcx)
movq %rcx, 0x8(%rbx)
xorl %eax, %eax
jmp 0x36bc
movq 0x8(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x10(%rbx)
shlq $0x4, %rax
addq %rcx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x41e9(%rip), %rax      # 0x7ac8
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %rdi
cmpq %r14, %rdi
je 0x3904
movq (%rdi), %r15
movl $0x18, %esi
callq 0x20f0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x38ef
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x3a1f
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
movq $-0x1, %r12
movq %rsp, %r15
movq %r12, %r13
incq %r12
movq %r12, (%rsp)
movq %r12, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a96
addq $0x2, %r13
cmpq %rbx, %r13
jb 0x39be
cmpq %rbx, %r12
jb 0x3a12
incq %r12
movq %rsp, %r15
decq %r12
movq %r12, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3baa
movq %r14, %rdi
movq %rax, %rsi
callq 0x3c2c
movq (%rsp), %r12
cmpq %rbx, %r12
ja 0x39ec
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x4111
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
movq $-0x1, %r12
leaq 0x8(%rsp), %r15
movq %r12, %r13
incq %r12
movq %r12, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4188
addq $0x2, %r13
cmpq %rbx, %r13
jb 0x40b0
cmpq %rbx, %r12
jb 0x4104
incq %r12
leaq 0x8(%rsp), %r15
decq %r12
movq %r12, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x429a
movq %r14, %rdi
movq %rax, %rsi
callq 0x431c
movq 0x8(%rsp), %r12
cmpq %rbx, %r12
ja 0x40dc
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x482e
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
decq %r13
jne 0x4790
callq 0x2040
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0x85d(%rip), %xmm0      # 0x5020
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop