LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ds.h
// Function: EList<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 128>::alloc(unsigned long)
T *alloc(size_t sz) {
		T* tmp = new T[sz];
		assert(tmp != NULL);
#ifdef USE_MEM_TALLY
		gMemTally.add(cat_, sz);
#endif
		allocCat_ = cat_;
		return tmp;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x3b, %rax
movq %rsi, %r15
shlq $0x5, %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
orq $0x8, %rdi
callq 0x4030
movq %rax, %rcx
movq %r14, (%rax)
addq $0x8, %rax
testq %r14, %r14
je 0x21d37
addq $0x18, %rcx
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
addq $0x20, %rcx
addq $-0x20, %r15
jne 0x21d1e
movl (%rbx), %ecx
movl %ecx, 0x4(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./filebuf.h
// Function: void FileBuf::parseFastaRecord<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, SString<char>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, SString<char>&, bool)
void parseFastaRecord(
		TNameStr& name,
		TSeqStr&  seq,
		bool      gotCaret = false)
	{
		int c;
		if(!gotCaret) {
			// Skip over caret and non-newline whitespace
			c = peek();
			while(isspace_notnl(c) || c == '>') { get(); c = peek(); }
		} else {
			// Skip over non-newline whitespace
			c = peek();
			while(isspace_notnl(c)) { get(); c = peek(); }
		}
		size_t namecur = 0, seqcur = 0;
		// c is the first character of the fasta name record, or is the first
		// newline character if the name record is empty
		while(!isnewline(c) && c != -1) {
			name[namecur++] = c; get(); c = peek();
		}
		// sequence consists of all the non-whitespace characters between here
		// and the next caret
		while(true) {
			// skip over whitespace
			while(isspace(c)) { get(); c = peek(); }
			// if we see caret or EOF, break
			if(c == '>' || c == -1) break;
			// append and continue
			seq[seqcur++] = asc2dna[c];
			get(); c = peek();
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
callq 0x21232
movl %eax, %r15d
movl %eax, %edi
callq 0x4060
testl %ebp, %ebp
je 0x20d20
testl %eax, %eax
je 0x20d5b
cmpl $0xa, %r15d
je 0x20d5b
cmpl $0xd, %r15d
je 0x20d5b
movq %r14, %rdi
callq 0x213fa
movq %r14, %rdi
callq 0x21232
movl %eax, %r15d
movl %eax, %edi
callq 0x4060
jmp 0x20cf4
testl %eax, %eax
setne %al
cmpl $0xd, %r15d
setne %cl
cmpl $0xa, %r15d
setne %dl
cmpl $0x3e, %r15d
je 0x20d3f
andb %dl, %cl
andb %al, %cl
je 0x20d5b
movq %r14, %rdi
callq 0x213fa
movq %r14, %rdi
callq 0x21232
movl %eax, %r15d
movl %eax, %edi
callq 0x4060
jmp 0x20d20
xorl %r13d, %r13d
movl $0x4801, %ebp           # imm = 0x4801
leal 0x1(%r15), %eax
cmpl $0xe, %eax
ja 0x20d71
btl %eax, %ebp
jb 0x20d91
movq (%r12), %rax
movb %r15b, (%rax,%r13)
incq %r13
movq %r14, %rdi
callq 0x213fa
movq %r14, %rdi
callq 0x21232
movl %eax, %r15d
jmp 0x20d63
xorl %ebx, %ebx
leaq 0x17ba6(%rip), %r13     # 0x38940
movl %r15d, %edi
callq 0x4060
testl %eax, %eax
je 0x20dbd
movq %r14, %rdi
callq 0x213fa
movq %r14, %rdi
callq 0x21232
movl %eax, %r15d
movl %eax, %edi
jmp 0x20d9d
cmpl $-0x1, %r15d
je 0x20dfc
cmpl $0x3e, %r15d
je 0x20dfc
movslq %r15d, %rax
movb (%r13,%rax), %bpl
leaq 0x1(%rbx), %r12
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x10648
movb %bpl, (%rax)
movq %r14, %rdi
callq 0x213fa
movq %r14, %rdi
callq 0x21232
movl %eax, %r15d
movq %r12, %rbx
jmp 0x20d9a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::parseFastaRecordLength(unsigned long&, unsigned long&, bool)
void parseFastaRecordLength(
		size_t&   nameLen,
		size_t&   seqLen,
		bool      gotCaret = false)
	{
		int c;
		nameLen = seqLen = 0;
		if(!gotCaret) {
			// Skip over caret and non-newline whitespace
			c = peek();
			while(isspace_notnl(c) || c == '>') { get(); c = peek(); }
		} else {
			// Skip over non-newline whitespace
			c = peek();
			while(isspace_notnl(c)) { get(); c = peek(); }
		}
		// c is the first character of the fasta name record, or is the first
		// newline character if the name record is empty
		while(!isnewline(c) && c != -1) {
			nameLen++; get(); c = peek();
		}
		// sequence consists of all the non-whitespace characters between here
		// and the next caret
		while(true) {
			// skip over whitespace
			while(isspace(c)) { get(); c = peek(); }
			// if we see caret or EOF, break
			if(c == '>' || c == -1) break;
			// append and continue
			seqLen++;
			get(); c = peek();
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %eax, %eax
movq %rax, (%rdx)
movq %rax, (%rsi)
callq 0x21232
movl %eax, %r12d
movl %eax, %edi
callq 0x4060
testl %ebp, %ebp
je 0x20ff2
testl %eax, %eax
je 0x2102d
cmpl $0xa, %r12d
je 0x2102d
cmpl $0xd, %r12d
je 0x2102d
movq %r14, %rdi
callq 0x213fa
movq %r14, %rdi
callq 0x21232
movl %eax, %r12d
movl %eax, %edi
callq 0x4060
jmp 0x20fc6
testl %eax, %eax
setne %al
cmpl $0xd, %r12d
setne %cl
cmpl $0xa, %r12d
setne %dl
cmpl $0x3e, %r12d
je 0x21011
andb %dl, %cl
andb %al, %cl
je 0x2102d
movq %r14, %rdi
callq 0x213fa
movq %r14, %rdi
callq 0x21232
movl %eax, %r12d
movl %eax, %edi
callq 0x4060
jmp 0x20ff2
movl $0x4801, %ebp           # imm = 0x4801
leal 0x1(%r12), %eax
cmpl $0xe, %eax
ja 0x21041
btl %eax, %ebp
jb 0x2106f
incq (%r15)
movq %r14, %rdi
callq 0x213fa
movq %r14, %rdi
callq 0x21232
movl %eax, %r12d
jmp 0x21032
incq (%rbx)
movq %r14, %rdi
callq 0x213fa
movq %r14, %rdi
callq 0x21232
movl %eax, %r12d
movl %r12d, %edi
callq 0x4060
testl %eax, %eax
je 0x21092
movq %r14, %rdi
callq 0x213fa
movq %r14, %rdi
callq 0x21232
movl %eax, %r12d
movl %eax, %edi
jmp 0x21072
cmpl $-0x1, %r12d
je 0x2109e
cmpl $0x3e, %r12d
jne 0x21059
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::get()
int get() {
		assert(_in != NULL || _zIn != NULL || _inf != NULL || _ins != NULL);
		int c = peek();
		if(c != -1) {
			_cur++;
			if(_lastn_cur < LASTN_BUF_SZ) _lastn_buf[_lastn_cur++] = c;
		}
		return c;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x21419
cmpq $0x0, 0x8(%rbx)
jne 0x21419
cmpq $0x0, 0x10(%rbx)
jne 0x21419
cmpq $0x0, 0x18(%rbx)
je 0x2144e
movq %rbx, %rdi
callq 0x21232
cmpl $-0x1, %eax
je 0x2144c
incq 0x20(%rbx)
movq 0x40038(%rbx), %rcx
cmpq $0x1fff, %rcx           # imm = 0x1FFF
ja 0x2144c
leaq 0x1(%rcx), %rdx
movq %rdx, 0x40038(%rbx)
movb %al, 0x40040(%rbx,%rcx)
popq %rbx
retq
leaq 0xdc81(%rip), %rdi      # 0x2f0d6
leaq 0xdcb6(%rip), %rsi      # 0x2f112
leaq 0xdcdb(%rip), %rcx      # 0x2f13e
movl $0x7d, %edx
callq 0x41c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::close()
void close() {
		if(_in != NULL && _in != stdin) {
			fclose(_in);
		} else if(_inf != NULL) {
			_inf->close();
		} else if(_zIn != NULL) {
			gzclose(_zIn);
		} else {
			// can't close _ins
		}
	}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x2148a
movq 0x15b1b(%rip), %rcx     # 0x36f98
cmpq (%rcx), %rax
je 0x2148a
movq %rax, %rdi
jmp 0x4320
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2149b
movq %rax, %rdi
jmp 0x4090
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x45d0
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::evictFromMemory()
void evictFromMemory() {
		assert(isInMemory());
		if(!_useMm) {
			delete[] _fchr;
			delete[] _ftab;
			delete[] _eftab;
			if(!useShmem_) delete[] _offs;
			delete[] _isa;
			// Keep plen; it's small and the client may want to query it
			// even when the others are evicted.
			//delete[] _plen;
			delete[] _rstarts;
			if(!useShmem_) delete[] _ebwt;
		}
		_fchr  = NULL;
		_ftab  = NULL;
		_eftab = NULL;
		_offs  = NULL;
		_isa   = NULL;
		// Keep plen; it's small and the client may want to query it
		// even when the others are evicted.
		//_plen  = NULL;
		_rstarts = NULL;
		_ebwt    = NULL;
		_zEbwtByteOff = OFF_MASK;
		_zEbwtBpOff = -1;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xfb60
testb %al, %al
je 0x21b65
cmpb $0x0, 0xd0(%rbx)
jne 0x21b33
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x21abb
callq 0x4420
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x21acc
callq 0x4420
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x21add
callq 0x4420
cmpb $0x0, 0xd1(%rbx)
jne 0x21af7
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x21af7
callq 0x4420
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x21b08
callq 0x4420
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x21b19
callq 0x4420
cmpb $0x0, 0xd1(%rbx)
jne 0x21b33
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x21b33
callq 0x4420
pxor %xmm0, %xmm0
movdqu %xmm0, 0xb8(%rbx)
movdqu %xmm0, 0xa8(%rbx)
movdqu %xmm0, 0x98(%rbx)
movq $0x0, 0xc8(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x70(%rbx)
popq %rbx
retq
leaq 0xb561(%rip), %rdi      # 0x2d0cd
leaq 0xb567(%rip), %rsi      # 0x2d0da
leaq 0xde7c(%rip), %rcx      # 0x2f9f6
movl $0x3ad, %edx            # imm = 0x3AD
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./sstring.h
// Function: S2bDnaString::get(unsigned long) const
char get(size_t i) const {
		assert_lt(i, len_);
		size_t word = i >> 4;
		size_t bpoff = (i & 15) << 1;
		return (char)((cs_[word] >> bpoff) & 3);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jbe 0x279bf
movq 0x8(%r14), %rax
movq %r15, %rcx
shrq $0x4, %rcx
movl (%rax,%rcx,4), %eax
addl %r15d, %r15d
movl %r15d, %ecx
shrl %cl, %eax
andb $0x3, %al
popq %rbx
popq %r14
popq %r15
retq
movq 0xf5f2(%rip), %rbx      # 0x36fb8
leaq 0x5897(%rip), %rsi      # 0x2d264
movq %rbx, %rdi
callq 0x4310
movq %rax, %rdi
movq %r15, %rsi
callq 0x40c0
leaq 0x5893(%rip), %rsi      # 0x2d27a
movq %rax, %rdi
callq 0x4310
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x40c0
leaq 0x7913(%rip), %rsi      # 0x2f315
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
callq 0x4150
leaq 0x8705(%rip), %r14      # 0x3011e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4310
leaq 0x6ced(%rip), %rsi      # 0x2e718
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movl $0x474, %esi            # imm = 0x474
callq 0x4610
movq %rax, %rdi
callq 0x4150
leaq 0x6ba9(%rip), %rdi      # 0x2e5f8
leaq 0x8700(%rip), %rcx      # 0x30156
movq %r14, %rsi
movl $0x474, %edx            # imm = 0x474
callq 0x41c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ds.h
// Function: EList<EList<unsigned long, 128>, 128>::resize(unsigned long)
void resize(size_t sz) {
		if(sz > 0 && list_ == NULL) lazyInit();
		if(sz <= cur_) {
			cur_ = sz;
			return;
		}
		if(sz_ < sz) {
			expandCopy(sz);
		}
		cur_ = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x27b4c
cmpq $0x0, 0x8(%r14)
jne 0x27b4c
movq %r14, %rdi
callq 0x27bf6
movq 0x10(%r14), %rax
cmpq %rbx, 0x18(%r14)
setb %cl
cmpq %rbx, %rax
setb %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x27b7f
leaq 0x1(,%rax,2), %rax
movq %rax, %rsi
addq %rax, %rax
cmpq %rbx, %rsi
jb 0x27b6c
movq %r14, %rdi
callq 0x27ca2
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ds.h
// Function: EList<unsigned long, 128>::expandNoCopy(unsigned long)
void expandNoCopy(size_t thresh) {
		assert(list_ != NULL);
		if(thresh <= sz_) return;
		size_t newsz = (sz_ * 2)+1;
		while(newsz < thresh) newsz *= 2;
		expandNoCopyExact(newsz);
	}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2829a
movq 0x10(%rdi), %rax
cmpq %rsi, %rax
jae 0x28299
leaq 0x1(,%rax,2), %rcx
movq %rcx, %rax
addq %rcx, %rcx
cmpq %rsi, %rax
jb 0x28286
movq %rax, %rsi
jmp 0x282ba
retq
pushq %rax
leaq 0x81d0(%rip), %rdi      # 0x30472
leaq 0x6651(%rip), %rsi      # 0x2e8fa
leaq 0x81d0(%rip), %rcx      # 0x30480
movl $0x3dc, %edx            # imm = 0x3DC
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ds.h
// Function: EList<unsigned long, 128>::expandNoCopyExact(unsigned long)
void expandNoCopyExact(size_t newsz) {
		assert(list_ != NULL);
		assert_gt(newsz, 0);
		free();
		T* tmp = alloc(newsz);
		assert(tmp != NULL);
		list_ = tmp;
		sz_ = newsz;
		assert_gt(sz_, 0);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x2830b
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2832a
movq %rdi, %r14
callq 0x1fee8
movq %rbx, %rax
shrq $0x3d, %rax
leaq (,%rbx,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x4030
movl (%r14), %ecx
movl %ecx, 0x4(%r14)
movq %rax, 0x8(%r14)
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8160(%rip), %rdi      # 0x30472
leaq 0x65e1(%rip), %rsi      # 0x2e8fa
leaq 0x81ad(%rip), %rcx      # 0x304cd
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x41c0
movq 0xec87(%rip), %rbx      # 0x36fb8
leaq 0x4ddd(%rip), %rsi      # 0x2d115
movq %rbx, %rdi
callq 0x4310
movq %rax, %rdi
xorl %esi, %esi
callq 0x40c0
leaq 0x4dda(%rip), %rsi      # 0x2d12b
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
xorl %esi, %esi
callq 0x4610
leaq 0x6fab(%rip), %rsi      # 0x2f315
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
callq 0x4150
leaq 0x6579(%rip), %r14      # 0x2e8fa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4310
leaq 0x6385(%rip), %rsi      # 0x2e718
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movl $0x3e9, %esi            # imm = 0x3E9
callq 0x4610
movq %rax, %rdi
callq 0x4150
leaq 0x6241(%rip), %rdi      # 0x2e5f8
leaq 0x810f(%rip), %rcx      # 0x304cd
movq %r14, %rsi
movl $0x3e9, %edx            # imm = 0x3E9
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::getPastNewline()
int getPastNewline() {
		int c = get();
		while(!isnewline(c) && c != -1) c = get();
		while(isnewline(c)) c = get();
		assert_neq(c, '\r');
		assert_neq(c, '\n');
		return c;
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x4801, %ebp           # imm = 0x4801
movq %rbx, %rdi
callq 0x213fa
leal 0x1(%rax), %ecx
cmpl $0xe, %ecx
ja 0x2b58d
btl %ecx, %ebp
jae 0x2b58d
jmp 0x2b5ac
movq %rbx, %rdi
callq 0x213fa
cmpl $0xd, %eax
je 0x2b5a4
cmpl $0xa, %eax
je 0x2b5a4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./filebuf.h
// Function: BitpairOutFileBuf::write(int)
void write(int bp) {
		assert_lt(bp, 4);
		assert_geq(bp, 0);
		buf_[cur_] |= (bp << bpPtr_);
		if(bpPtr_ == 6) {
			bpPtr_ = 0;
			cur_++;
			if(cur_ == BUF_SZ) {
				// Flush the buffer
				if(!fwrite((const void *)buf_, BUF_SZ, 1, out_)) {
					std::cerr << "Error writing to the reference index file (.4.ebwt)" << std::endl;
					throw 1;
				}
				// Reset to beginning of the buffer
				cur_ = 0;
			}
			// Initialize next octet to 0
			buf_[cur_] = 0;
		} else {
			bpPtr_ += 2;
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
cmpl $0x4, %esi
jge 0x2b641
testl %ebp, %ebp
js 0x2b6e5
movq %rdi, %rbx
movb 0x8(%rdi), %cl
shll %cl, %ebp
movq 0x10(%rdi), %rax
orb %bpl, 0x18(%rdi,%rax)
movl 0x8(%rdi), %eax
cmpl $0x6, %eax
jne 0x2b636
movl $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
cmpq $0x20000, %rax          # imm = 0x20000
jne 0x2b62b
leaq 0x18(%rbx), %rdi
movq (%rbx), %rcx
movl $0x20000, %esi          # imm = 0x20000
movl $0x1, %edx
callq 0x46b0
testq %rax, %rax
je 0x2b786
movq $0x0, 0x10(%rbx)
movq 0x10(%rbx), %rax
movb $0x0, 0x18(%rbx,%rax)
jmp 0x2b63c
addl $0x2, %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0xb970(%rip), %rbx      # 0x36fb8
leaq 0x1c15(%rip), %rsi      # 0x2d264
movq %rbx, %rdi
callq 0x4310
movq %rax, %rdi
movl %ebp, %esi
callq 0x4610
leaq 0x1c12(%rip), %rsi      # 0x2d27a
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movl $0x4, %esi
callq 0x4610
leaq 0x3c91(%rip), %rsi      # 0x2f315
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
callq 0x4150
leaq 0x3a77(%rip), %r14      # 0x2f112
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4310
leaq 0x306b(%rip), %rsi      # 0x2e718
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movl $0x228, %esi            # imm = 0x228
callq 0x4610
movq %rax, %rdi
callq 0x4150
leaq 0x2f27(%rip), %rdi      # 0x2e5f8
leaq 0x5ca8(%rip), %rcx      # 0x31380
movq %r14, %rsi
movl $0x228, %edx            # imm = 0x228
callq 0x41c0
movq 0xb8cc(%rip), %rbx      # 0x36fb8
leaq 0x1b2f(%rip), %rsi      # 0x2d222
movq %rbx, %rdi
callq 0x4310
movq %rax, %rdi
movl %ebp, %esi
callq 0x4610
leaq 0x1b2d(%rip), %rsi      # 0x2d239
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
xorl %esi, %esi
callq 0x4610
leaq 0x3bf0(%rip), %rsi      # 0x2f315
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
callq 0x4150
leaq 0x39d6(%rip), %r14      # 0x2f112
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4310
leaq 0x2fca(%rip), %rsi      # 0x2e718
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movl $0x229, %esi            # imm = 0x229
callq 0x4610
movq %rax, %rdi
callq 0x4150
leaq 0x2e86(%rip), %rdi      # 0x2e5f8
leaq 0x5c07(%rip), %rcx      # 0x31380
movq %r14, %rsi
movl $0x229, %edx            # imm = 0x229
callq 0x41c0
movq 0xb863(%rip), %rdi      # 0x36ff0
leaq 0x5c0f(%rip), %rsi      # 0x313a3
callq 0x4310
movq %rax, %rdi
callq 0x4150
movl $0x4, %edi
callq 0x4160
movl $0x1, (%rax)
movq 0xb7a0(%rip), %rsi      # 0x36f58
movq %rax, %rdi
xorl %edx, %edx
callq 0x45f0
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::reset()
void reset() {
		if(_inf != NULL) {
			_inf->clear();
			_inf->seekg(0, std::ios::beg);
		} else if(_ins != NULL) {
			_ins->clear();
			_ins->seekg(0, std::ios::beg);
		} else if (_zIn != NULL) {
			gzrewind(_zIn);
		} else {
			rewind(_in);
		}
		_cur = BUF_SZ;
		_buf_sz = BUF_SZ;
		_done = false;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x2b8a9
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x45e0
movq 0x10(%rbx), %rdi
jmp 0x2b8c4
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2b8e0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x45e0
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4460
movl $0x40000, %eax          # imm = 0x40000
movq %rax, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movb $0x0, 0x30(%rbx)
popq %rbx
retq
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2b8f0
callq 0x4380
jmp 0x2b8cd
movq (%rbx), %rdi
callq 0x4080
jmp 0x2b8cd
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/bt2_locks.cpp
// Function: mcs_lock::lock(mcs_lock::mcs_node&)
void mcs_lock::lock(mcs_node &node) {
	node.next = nullptr;

	mcs_node *pred = q.exchange(&node, std::memory_order_acq_rel);
	if (pred) {
		node.unlocked = false;
		pred->next.store(&node, std::memory_order_release);
		spin_while_eq(node.unlocked, false);
	}
	node.unlocked.load(std::memory_order_acquire);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
xorl %eax, %eax
xchgq %rax, (%rsi)
movq %rsi, %rax
xchgq %rax, (%rdi)
testq %rax, %rax
je 0x2c41f
leaq 0x8(%rbx), %rsi
xorl %ecx, %ecx
xchgb %cl, 0x8(%rbx)
movq %rbx, (%rax)
xorl %edx, %edx
callq 0x2c490
movb 0x8(%rbx), %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/bt2_locks.cpp
// Function: mcs_lock::unlock(mcs_lock::mcs_node&)
void mcs_lock::unlock(mcs_node &node) {
	if (!node.next.load(std::memory_order_acquire)) {
		mcs_node *node_ptr = &node;
		if (q.compare_exchange_strong(node_ptr,
					      (mcs_node *)nullptr,
					      std::memory_order_release))
			return;
		spin_while_eq(node.next, (mcs_node *)nullptr);
	}
	node.next.load(std::memory_order_acquire)->unlocked.store(true, std::memory_order_release);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rax
testq %rax, %rax
jne 0x2c446
xorl %ecx, %ecx
movq %rbx, %rax
lock
cmpxchgq %rcx, (%rdi)
je 0x2c44d
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2c4d8
movq (%rbx), %rax
movb $0x1, 0x8(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/fractalgen.cpp
// Function: eval(complex, unsigned int, complex)
unsigned eval(const complex comp, unsigned max,
              const complex arg)
{
    complex c = comp;
    for (unsigned i = 0; i < max; i++)
    {
        if (c.abs() > 2)
            return i;
        c = c * c + arg;
    }
    return max;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
testl %esi, %esi
je 0x24ef
movq %rdx, %r14
vmovsd (%rdi), %xmm1
vmovsd 0x8(%rdi), %xmm3
xorl %ebp, %ebp
vxorpd %xmm2, %xmm2, %xmm2
vmovsd 0xeb90(%rip), %xmm4     # 0x11008
vmulsd %xmm3, %xmm3, %xmm5
vmovapd %xmm1, %xmm0
vfmadd213sd %xmm5, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm5
vucomisd %xmm2, %xmm0
jb 0x2491
vsqrtsd %xmm0, %xmm0, %xmm0
jmp 0x24c6
vmovsd %xmm1, 0x18(%rsp)
vmovsd %xmm3, 0x10(%rsp)
vmovsd %xmm5, 0x8(%rsp)
callq 0x20f0
vmovsd 0x8(%rsp), %xmm5
vmovsd 0xeb52(%rip), %xmm4     # 0x11008
vmovsd 0x10(%rsp), %xmm3
vxorpd %xmm2, %xmm2, %xmm2
vmovsd 0x18(%rsp), %xmm1
vucomisd %xmm4, %xmm0
ja 0x24f1
vfmsub231sd %xmm1, %xmm1, %xmm5 # xmm5 = (xmm1 * xmm1) - xmm5
vmulsd %xmm3, %xmm1, %xmm0
vfmadd231sd %xmm1, %xmm3, %xmm0 # xmm0 = (xmm3 * xmm1) + xmm0
vaddsd (%r14), %xmm5, %xmm1
vaddsd 0x8(%r14), %xmm0, %xmm3
incl %ebp
cmpl %ebp, %ebx
jne 0x2478
movl %ebx, %ebp
jmp 0x24f1
xorl %ebp, %ebp
cmpl %ebx, %ebp
cmovbl %ebp, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/fractalgen.cpp
// Function: set_pixel(unsigned char, unsigned char, unsigned char, unsigned int, unsigned int, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int)
void set_pixel(unsigned char r, unsigned char g, unsigned char b,
               unsigned x, unsigned y, vector<unsigned char> &vec,
               unsigned height)
{
    unsigned index = (x + y * height) * 4;
    vec.at(index + 0) = r;
    vec.at(index + 1) = g;
    vec.at(index + 2) = b;
    vec.at(index + 3) = 0xff;
}

// Assembly:
pushq %rax
imull 0x10(%rsp), %r8d
addl %ecx, %r8d
shll $0x2, %r8d
movq (%r9), %rcx
movq 0x8(%r9), %rax
subq %rcx, %rax
cmpq %r8, %rax
jbe 0x256f
movb %dil, (%rcx,%r8)
movq %r8, %rax
orq $0x1, %rax
movq (%r9), %rdi
movq 0x8(%r9), %rcx
subq %rdi, %rcx
cmpq %rax, %rcx
jbe 0x257b
movb %sil, (%rdi,%rax)
movq %r8, %rsi
orq $0x2, %rsi
movq (%r9), %rcx
movq 0x8(%r9), %rax
subq %rcx, %rax
cmpq %rsi, %rax
jbe 0x258a
movb %dl, (%rcx,%rsi)
orq $0x3, %r8
movq (%r9), %rax
movq 0x8(%r9), %rdx
subq %rax, %rdx
cmpq %r8, %rdx
jbe 0x2596
movb $-0x1, (%rax,%r8)
popq %rax
retq
leaq 0xed36(%rip), %rdi      # 0x112ac
movq %r8, %rsi
jmp 0x2591
leaq 0xed2a(%rip), %rdi      # 0x112ac
movq %rax, %rsi
movq %rcx, %rdx
jmp 0x25a0
leaq 0xed1b(%rip), %rdi      # 0x112ac
movq %rax, %rdx
jmp 0x25a0
leaq 0xed0f(%rip), %rdi      # 0x112ac
movq %r8, %rsi
xorl %eax, %eax
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/fractalgen.cpp
// Function: htoi(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
unsigned char htoi(std::string str)
{
    if (str.size() != 2)
        return 0;
    unsigned char res = 0;
    unsigned char c = str.at(0);
    if (c >= '0' && c <= '9')
        res += (c - 0x30) * 16;
    else if (c >= 'a' && c <= 'f')
        res += (c - 'a' + 10) * 16;
    else if (c >= 'A' && c <= 'F')
        res += (c - 'A' + 10) * 16;
    else
        cout << "unknown hex char '" << c << "'.\n";

    c = str.at(1);
    if (c >= '0' && c <= '9')
        res += (c - 0x30) * 1;
    else if (c >= 'a' && c <= 'f')
        res += (c - 'a' + 10) * 1;
    else if (c >= 'A' && c <= 'F')
        res += (c - 'A' + 10) * 1;
    else
        cout << "unknown hex char '" << c << "'.\n";

    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x2, 0x8(%rdi)
jne 0x25cb
movq %rdi, %r14
movq (%rdi), %rax
movb (%rax), %bl
leal -0x30(%rbx), %eax
cmpb $0x9, %al
ja 0x25d2
shlb $0x4, %bl
jmp 0x262d
xorl %ebx, %ebx
jmp 0x26b4
leal -0x61(%rbx), %eax
cmpb $0x5, %al
jbe 0x25e0
leal -0x41(%rbx), %eax
cmpb $0x5, %al
ja 0x25e8
shlb $0x4, %bl
addb $-0x70, %bl
jmp 0x262d
movq 0x149e9(%rip), %r15     # 0x16fd8
leaq 0xea32(%rip), %rsi      # 0x11028
movl $0x12, %edx
movq %r15, %rdi
callq 0x2190
leaq 0xe(%rsp), %rsi
movb %bl, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x2190
leaq 0xeaf5(%rip), %rsi      # 0x11113
movl $0x3, %edx
movq %rax, %rdi
callq 0x2190
xorl %ebx, %ebx
movq 0x8(%r14), %rdx
cmpq $0x1, %rdx
jbe 0x26c0
movq (%r14), %rax
movb 0x1(%rax), %r15b
leal -0x30(%r15), %eax
cmpb $0x9, %al
ja 0x2650
addb %bl, %al
movl %eax, %ebx
jmp 0x26b4
leal -0x61(%r15), %eax
cmpb $0x5, %al
ja 0x2660
addb %r15b, %bl
addb $-0x57, %bl
jmp 0x26b4
leal -0x41(%r15), %eax
cmpb $0x5, %al
ja 0x2670
addb %r15b, %bl
addb $-0x37, %bl
jmp 0x26b4
movq 0x14961(%rip), %r14     # 0x16fd8
leaq 0xe9aa(%rip), %rsi      # 0x11028
movl $0x12, %edx
movq %r14, %rdi
callq 0x2190
leaq 0xf(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2190
leaq 0xea6c(%rip), %rsi      # 0x11113
movl $0x3, %edx
movq %rax, %rdi
callq 0x2190
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xec2f(%rip), %rdi      # 0x112f6
movl $0x1, %esi
xorl %eax, %eax
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_load_file(unsigned char**, unsigned long*, char const*)
unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename)
{
  long size = lodepng_filesize(filename);
  if (size < 0) return 78;
  *outsize = (size_t)size;

  *out = (unsigned char*)lodepng_malloc((size_t)size);
  if(!(*out) && size > 0) return 83; /*the above malloc failed*/

  return lodepng_buffer_file(*out, (size_t)size, filename);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rdi
callq 0x411c
testq %rax, %rax
js 0x4109
movq %rax, %r14
movq %rax, (%r12)
movq %rax, %rdi
callq 0x21e0
movq %rax, (%r15)
testq %rax, %rax
sete %dl
testq %r14, %r14
setne %sil
movl $0x53, %ecx
testb %dl, %sil
jne 0x410e
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x418a
movl $0x4e, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_filesize(char const*)
static long lodepng_filesize(const char* filename)
{
  FILE* file;
  long size;
  file = fopen(filename, "rb");
  if(!file) return -1;

  if(fseek(file, 0, SEEK_END) != 0)
  {
    fclose(file);
    return -1;
  }

  size = ftell(file);
  /* It may give LONG_MAX as directory size, this is invalid for us. */
  if(size == LONG_MAX) size = -1;

  fclose(file);
  return size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xf0c9(%rip), %rsi      # 0x131f0
callq 0x21a0
testq %rax, %rax
je 0x4178
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2170
movq $-0x1, %r14
testl %eax, %eax
jne 0x416e
movq %rbx, %rdi
callq 0x2030
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, %rax
movq $-0x1, %r14
cmovneq %rax, %r14
movq %rbx, %rdi
callq 0x2140
jmp 0x417f
movq $-0x1, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_buffer_file(unsigned char*, unsigned long, char const*)
static unsigned lodepng_buffer_file(unsigned char* out, size_t size, const char* filename)
{
  FILE* file;
  size_t readsize;
  file = fopen(filename, "rb");
  if(!file) return 78;

  readsize = fread(out, 1, size, file);
  fclose(file);

  if (readsize != size) return 78;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf054(%rip), %rsi      # 0x131f0
movq %rdx, %rdi
callq 0x21a0
testq %rax, %rax
je 0x41d9
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2200
movq %rax, %r14
movq %r15, %rdi
callq 0x2140
xorl %ecx, %ecx
cmpq %rbx, %r14
movl $0x4e, %eax
cmovel %ecx, %eax
jmp 0x41de
movl $0x4e, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_save_file(unsigned char const*, unsigned long, char const*)
unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename)
{
  FILE* file;
  file = fopen(filename, "wb" );
  if(!file) return 79;
  fwrite((char*)buffer , 1 , buffersize, file);
  fclose(file);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe10f(%rip), %rsi      # 0x12305
movq %rdx, %rdi
callq 0x21a0
testq %rax, %rax
je 0x4225
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x22c0
movq %r15, %rdi
callq 0x2140
xorl %eax, %eax
jmp 0x422a
movl $0x4f, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: bpmnode_create(BPMLists*, int, unsigned int, BPMNode*)
static BPMNode* bpmnode_create(BPMLists* lists, int weight, unsigned index, BPMNode* tail)
{
  unsigned i;
  BPMNode* result;

  /*memory full, so garbage collect*/
  if(lists->nextfree >= lists->numfree)
  {
    /*mark only those that are in use*/
    for(i = 0; i != lists->memsize; ++i) lists->memory[i].in_use = 0;
    for(i = 0; i != lists->listsize; ++i)
    {
      BPMNode* node;
      for(node = lists->chains0[i]; node != 0; node = node->tail) node->in_use = 1;
      for(node = lists->chains1[i]; node != 0; node = node->tail) node->in_use = 1;
    }
    /*collect those that are free*/
    lists->numfree = 0;
    for(i = 0; i != lists->memsize; ++i)
    {
      if(!lists->memory[i].in_use) lists->freelist[lists->numfree++] = &lists->memory[i];
    }
    lists->nextfree = 0;
  }

  result = lists->freelist[lists->nextfree++];
  result->weight = weight;
  result->index = index;
  result->tail = tail;
  return result;
}

// Assembly:
pushq %rbx
movl 0x14(%rdi), %eax
cmpl 0x10(%rdi), %eax
jb 0x4738
movl (%rdi), %eax
testq %rax, %rax
je 0x46a7
movq 0x8(%rdi), %r8
leaq 0xf(%rax), %r9
andq $-0x10, %r9
leaq -0x1(%rax), %r10
vpbroadcastq %r10, %zmm0
vpmovsxbq 0xdb67(%rip), %zmm1 # 0x121b0
vpmovsxbq 0xdb65(%rip), %zmm2 # 0x121b8
vpbroadcastq 0xdb43(%rip), %zmm3 # 0x121a0
vpbroadcastq 0xdb41(%rip), %zmm4 # 0x121a8
vpxor %xmm5, %xmm5, %xmm5
vpcmpleuq %zmm0, %zmm1, %k1
vpcmpleuq %zmm0, %zmm2, %k2
vpmullq %zmm3, %zmm1, %zmm6
vpmullq %zmm3, %zmm2, %zmm7
vpscatterqd %ymm5, 0x10(%r8,%zmm7) {%k2}
vpscatterqd %ymm5, 0x10(%r8,%zmm6) {%k1}
vpaddq %zmm4, %zmm2, %zmm2
vpaddq %zmm4, %zmm1, %zmm1
addq $-0x10, %r9
jne 0x466b
movl 0x20(%rdi), %r8d
testq %r8, %r8
je 0x46ef
movq 0x28(%rdi), %r9
movq 0x30(%rdi), %r10
xorl %r11d, %r11d
movq (%r9,%r11,8), %rbx
testq %rbx, %rbx
je 0x46d1
movl $0x1, 0x10(%rbx)
movq 0x8(%rbx), %rbx
jmp 0x46bf
movq (%r10,%r11,8), %rbx
testq %rbx, %rbx
je 0x46e7
movl $0x1, 0x10(%rbx)
movq 0x8(%rbx), %rbx
jmp 0x46d5
incq %r11
cmpq %r8, %r11
jne 0x46bb
movl $0x0, 0x10(%rdi)
testq %rax, %rax
je 0x4731
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
xorl %r8d, %r8d
movq 0x8(%rdi), %r9
cmpl $0x0, 0x10(%r9,%r8)
jne 0x4728
addq %r8, %r9
movq 0x18(%rdi), %r10
movl 0x10(%rdi), %r11d
leal 0x1(%r11), %ebx
movl %ebx, 0x10(%rdi)
movq %r9, (%r10,%r11,8)
addq $0x18, %r8
cmpq %r8, %rax
jne 0x4706
movl $0x0, 0x14(%rdi)
movq 0x18(%rdi), %rax
movl 0x14(%rdi), %r8d
leal 0x1(%r8), %r9d
movl %r9d, 0x14(%rdi)
movq (%rax,%r8,8), %rax
movl %esi, (%rax)
movl %edx, 0x4(%rax)
movq %rcx, 0x8(%rax)
popq %rbx
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: boundaryPM(BPMLists*, BPMNode*, unsigned long, int, int)
static void boundaryPM(BPMLists* lists, BPMNode* leaves, size_t numpresent, int c, int num)
{
  unsigned lastindex = lists->chains1[c]->index;

  if(c == 0)
  {
    if(lastindex >= numpresent) return;
    lists->chains0[c] = lists->chains1[c];
    lists->chains1[c] = bpmnode_create(lists, leaves[lastindex].weight, lastindex + 1, 0);
  }
  else
  {
    /*sum of the weights of the head nodes of the previous lookahead chains.*/
    int sum = lists->chains0[c - 1]->weight + lists->chains1[c - 1]->weight;
    lists->chains0[c] = lists->chains1[c];
    if(lastindex < numpresent && sum > leaves[lastindex].weight)
    {
      lists->chains1[c] = bpmnode_create(lists, leaves[lastindex].weight, lastindex + 1, lists->chains1[c]->tail);
      return;
    }
    lists->chains1[c] = bpmnode_create(lists, sum, lastindex, lists->chains1[c - 1]);
    /*in the end we are only interested in the chain of the last list, so no
    need to recurse if we're at the last one (this gives measurable speedup)*/
    if(num + 1 < (int)(2 * numpresent - 2))
    {
      boundaryPM(lists, leaves, numpresent, c - 1, num);
      boundaryPM(lists, leaves, numpresent, c - 1, num);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movslq %ecx, %rax
negl %ecx
movq %rcx, 0x20(%rsp)
leaq (,%rax,8), %r15
decl %eax
movq %rax, 0x18(%rsp)
xorl %r13d, %r13d
movq %r8, 0x10(%rsp)
leal 0x1(%r8), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rbx), %rsi
leaq (%rsi,%r15), %rax
movq (%rax,%r13,8), %rax
movl 0x4(%rax), %edx
cmpl %r13d, 0x20(%rsp)
je 0x4828
movq 0x28(%rbx), %rdi
movq 0x18(%rsp), %rcx
leaq (%rcx,%r13), %rbp
movslq %ebp, %rcx
movq (%rdi,%rcx,8), %r8
movq (%rsi,%rcx,8), %rsi
movl (%rsi), %esi
addl (%r8), %esi
addq %r15, %rdi
movq %rax, (%rdi,%r13,8)
cmpq %r12, %rdx
jae 0x47e5
leaq (%rdx,%rdx,2), %rax
movl (%r14,%rax,8), %eax
cmpl %eax, %esi
jg 0x4849
movq 0x30(%rbx), %rax
movq (%rax,%rcx,8), %rcx
movq %rbx, %rdi
callq 0x4615
movq 0x30(%rbx), %rcx
addq %r15, %rcx
movq %rax, (%rcx,%r13,8)
leal -0x2(%r12,%r12), %eax
cmpl %eax, 0xc(%rsp)
jge 0x486c
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movq 0x10(%rsp), %r8
callq 0x475a
decq %r13
jmp 0x479a
cmpq %r12, %rdx
jae 0x486c
movq 0x28(%rbx), %rcx
addq %r15, %rcx
movq %rax, (%rcx,%r13,8)
leaq (%rdx,%rdx,2), %rax
movl (%r14,%rax,8), %esi
incl %edx
movq %rbx, %rdi
xorl %ecx, %ecx
jmp 0x485f
incl %edx
movq 0x30(%rbx), %rcx
addq %r15, %rcx
movq (%rcx,%r13,8), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq 0x4615
addq 0x30(%rbx), %r15
movq %rax, (%r15,%r13,8)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_zlib_decompress(unsigned char**, unsigned long*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*)
unsigned lodepng_zlib_decompress(unsigned char** out, size_t* outsize, const unsigned char* in,
                                 size_t insize, const LodePNGDecompressSettings* settings)
{
  unsigned error = 0;
  unsigned CM, CINFO, FDICT;

  if(insize < 2) return 53; /*error, size of zlib data too small*/
  /*read information from zlib header*/
  if((in[0] * 256 + in[1]) % 31 != 0)
  {
    /*error: 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is supposed to be made that way*/
    return 24;
  }

  CM = in[0] & 15;
  CINFO = (in[0] >> 4) & 15;
  /*FCHECK = in[1] & 31;*/ /*FCHECK is already tested above*/
  FDICT = (in[1] >> 5) & 1;
  /*FLEVEL = (in[1] >> 6) & 3;*/ /*FLEVEL is not used here*/

  if(CM != 8 || CINFO > 7)
  {
    /*error: only compression method 8: inflate with sliding window of 32k is supported by the PNG spec*/
    return 25;
  }
  if(FDICT != 0)
  {
    /*error: the specification of PNG says about the zlib stream:
      "The additional flags shall not specify a preset dictionary."*/
    return 26;
  }

  error = inflate(out, outsize, in + 2, insize - 2, settings);
  if(error) return error;

  if(!settings->ignore_adler32)
  {
    unsigned ADLER32 = lodepng_read32bitInt(&in[insize - 4]);
    unsigned checksum = adler32(*out, (unsigned)(*outsize));
    if(checksum != ADLER32) return 58; /*error, adler checksum not correct, data must be corrupted*/
  }

  return 0; /*no error*/
}

// Assembly:
movl $0x35, %eax
cmpq $0x2, %rcx
jb 0x6f01
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movzbl (%rdx), %edx
movl %edx, %eax
shll $0x8, %eax
movzbl 0x1(%r15), %ecx
orl %ecx, %eax
imull $0xbdef7bdf, %eax, %esi # imm = 0xBDEF7BDF
movl $0x18, %eax
cmpl $0x8421084, %esi        # imm = 0x8421084
ja 0x6ef3
movl %edx, %eax
andl $0xf, %eax
cmpl $0x8, %eax
setne %al
testb %dl, %dl
sets %dl
orb %al, %dl
movl $0x19, %eax
jne 0x6ef3
movl $0x1a, %eax
testb $0x20, %cl
jne 0x6ef3
movq %r8, %r13
movq %rdi, %r12
leaq 0x2(%r15), %rdx
leaq -0x2(%r14), %rcx
movq 0x10(%r8), %rax
movq %rbx, %rsi
testq %rax, %rax
je 0x6ec4
movq %r13, %r8
callq *%rax
jmp 0x6ec9
callq 0x487b
testl %eax, %eax
jne 0x6ef3
cmpl $0x0, (%r13)
jne 0x6ef1
movbel -0x4(%r15,%r14), %ebp
movq (%r12), %rdi
movl (%rbx), %esi
callq 0x6f02
movl %eax, %ecx
movl $0x3a, %eax
cmpl %ebp, %ecx
jne 0x6ef3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: adler32(unsigned char const*, unsigned int)
static unsigned update_adler32(unsigned adler, const unsigned char* data, unsigned len)
{
   unsigned s1 = adler & 0xffff;
   unsigned s2 = (adler >> 16) & 0xffff;

  while(len > 0)
  {
    /*at least 5550 sums can be done before the sums overflow, saving a lot of module divisions*/
    unsigned amount = len > 5550 ? 5550 : len;
    len -= amount;
    while(amount > 0)
    {
      s1 += (*data++);
      s2 += s1;
      --amount;
    }
    s1 %= 65521;
    s2 %= 65521;
  }

  return (s2 << 16) | s1;
}

// Assembly:
testl %esi, %esi
je 0x6f8e
pushq %rbp
pushq %r14
pushq %rbx
movl $0x1, %ecx
xorl %eax, %eax
movl $0x15ae, %edx           # imm = 0x15AE
movl $0x15ae, %r8d           # imm = 0x15AE
movl $0x80078071, %r9d       # imm = 0x80078071
cmpl %edx, %esi
movl $0x15ae, %r10d          # imm = 0x15AE
cmovbl %esi, %r10d
leal -0x1(%r10), %r11d
movl %esi, %ebx
cmpq %r8, %rbx
cmovaeq %r8, %rbx
xorl %r14d, %r14d
movzbl (%rdi,%r14), %ebp
addl %ebp, %ecx
addl %ecx, %eax
incq %r14
cmpl %r14d, %ebx
jne 0x6f42
movl %ecx, %ebx
imulq %r9, %rbx
shrq $0x2f, %rbx
imull $0xfff1, %ebx, %ebx     # imm = 0xFFF1
subl %ebx, %ecx
movl %eax, %ebx
imulq %r9, %rbx
shrq $0x2f, %rbx
imull $0xfff1, %ebx, %ebx     # imm = 0xFFF1
subl %ebx, %eax
subl %r10d, %esi
movl %r11d, %r10d
leaq 0x1(%rdi,%r10), %rdi
jne 0x6f26
shll $0x10, %eax
orl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_crc32(unsigned char const*, unsigned long)
unsigned lodepng_crc32(const unsigned char* data, size_t length)
{
  unsigned r = 0xffffffffu;
  size_t i;
  for(i = 0; i < length; ++i)
  {
    r = lodepng_crc32_table[(r ^ data[i]) & 0xff] ^ (r >> 8);
  }
  return r ^ 0xffffffffu;
}

// Assembly:
testq %rsi, %rsi
je 0x72aa
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
leaq 0xa673(%rip), %rdx      # 0x11900
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x728d
notl %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_chunk_append(unsigned char**, unsigned long*, unsigned char const*)
unsigned lodepng_chunk_append(unsigned char** out, size_t* outlength, const unsigned char* chunk)
{
  unsigned i;
  unsigned total_chunk_length = lodepng_chunk_length(chunk) + 12;
  unsigned char *chunk_start, *new_buffer;
  size_t new_length = (*outlength) + total_chunk_length;
  if(new_length < total_chunk_length || new_length < (*outlength)) return 77; /*integer overflow happened*/

  new_buffer = (unsigned char*)lodepng_realloc(*out, new_length);
  if(!new_buffer) return 83; /*alloc fail*/
  (*out) = new_buffer;
  (*outlength) = new_length;
  chunk_start = &(*out)[new_length - total_chunk_length];

  for(i = 0; i != total_chunk_length; ++i) chunk_start[i] = chunk[i];

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movzbl (%rdx), %r13d
shll $0x18, %r13d
movzbl 0x1(%rdx), %r15d
shll $0x10, %r15d
leal (%r15,%r13), %eax
movzbl 0x2(%rdx), %r14d
shll $0x8, %r14d
orl %r14d, %eax
movzbl 0x3(%rdx), %ecx
leal 0xc(%rcx,%rax), %ebp
movq (%rsi), %rax
movq %rbp, %r12
addq %rax, %r12
movl $0x4d, %edx
jb 0x74bc
movq %rax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq (%rdi), %rdi
movq %r12, %rsi
callq 0x2260
testq %rax, %rax
je 0x74b7
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq 0x20(%rsp), %rcx
movq %r12, (%rcx)
xorl %edx, %edx
testl %ebp, %ebp
je 0x74bc
addq 0x8(%rsp), %rax
orl %r15d, %r13d
orl %r14d, %r13d
movq 0x10(%rsp), %rcx
leal 0xb(%rcx,%r13), %edx
incq %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2100
xorl %edx, %edx
jmp 0x74bc
movl $0x53, %edx
movl %edx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_chunk_create(unsigned char**, unsigned long*, unsigned int, char const*, unsigned char const*)
unsigned lodepng_chunk_create(unsigned char** out, size_t* outlength, unsigned length,
                              const char* type, const unsigned char* data)
{
  unsigned i;
  unsigned char *chunk, *new_buffer;
  size_t new_length = (*outlength) + length + 12;
  if(new_length < length + 12 || new_length < (*outlength)) return 77; /*integer overflow happened*/
  new_buffer = (unsigned char*)lodepng_realloc(*out, new_length);
  if(!new_buffer) return 83; /*alloc fail*/
  (*out) = new_buffer;
  (*outlength) = new_length;
  chunk = &(*out)[(*outlength) - length - 12];

  /*1: length*/
  lodepng_set32bitInt(chunk, (unsigned)length);

  /*2: chunk name (4 letters)*/
  chunk[4] = (unsigned char)type[0];
  chunk[5] = (unsigned char)type[1];
  chunk[6] = (unsigned char)type[2];
  chunk[7] = (unsigned char)type[3];

  /*3: the data*/
  for(i = 0; i != length; ++i) chunk[8 + i] = data[i];

  /*4: CRC (of the chunkname characters and the data)*/
  lodepng_chunk_generate_crc(chunk);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movl %edx, %r13d
leaq 0xc(%r13), %rbp
addq (%rsi), %rbp
setb %al
leal 0xc(%r14), %esi
cmpq %rsi, %rbp
setb %sil
orb %al, %sil
movl $0x4d, %eax
jne 0x7585
movq %r8, %rbx
movq %rdi, %r12
movq %rcx, (%rsp)
movq (%rdi), %rdi
movq %rbp, %rsi
callq 0x2260
testq %rax, %rax
je 0x7580
movq %rax, (%r12)
movq %rbp, (%r15)
subq %r13, %rbp
leaq -0xc(%rax,%rbp), %rdi
movq %r14, %rdx
movl %edx, %ecx
shrl $0x18, %ecx
movb %cl, -0xc(%rax,%rbp)
movl %edx, %ecx
shrl $0x10, %ecx
movb %cl, -0xb(%rax,%rbp)
movb %dh, -0xa(%rax,%rbp)
movb %dl, -0x9(%rax,%rbp)
movq (%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x8(%rax,%rbp)
testl %edx, %edx
je 0x7577
negq %r13
movl $0x8, %eax
movb -0x8(%rbx,%rax), %cl
movl %eax, %edx
movb %cl, (%rdi,%rdx)
leaq 0x1(%r13,%rax), %rcx
incq %rax
cmpq $0x8, %rcx
jne 0x7560
callq 0x73b5
xorl %eax, %eax
jmp 0x7585
movl $0x53, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_color_mode_copy(LodePNGColorMode*, LodePNGColorMode const*)
unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source)
{
  size_t i;
  lodepng_color_mode_cleanup(dest);
  *dest = *source;
  if(source->palette)
  {
    dest->palette = (unsigned char*)lodepng_malloc(1024);
    if(!dest->palette && source->palettesize) return 83; /*alloc fail*/
    for(i = 0; i != source->palettesize * 4; ++i) dest->palette[i] = source->palette[i];
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x760b
callq 0x21b0
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%r15)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
vmovups (%rbx), %ymm0
vmovups %ymm0, (%r14)
xorl %eax, %eax
cmpq $0x0, 0x8(%rbx)
je 0x7684
movl $0x400, %edi            # imm = 0x400
vzeroupper
callq 0x21e0
movq %rax, (%r15)
testq %rax, %rax
je 0x7678
movq 0x10(%rbx), %rcx
shlq $0x2, %rcx
movl $0x0, %eax
testq %rcx, %rcx
je 0x7684
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movb (%rdx,%rcx), %dl
movq (%r15), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
movq 0x10(%rbx), %rdx
shlq $0x2, %rdx
cmpq %rdx, %rcx
jne 0x7659
jmp 0x7684
movl $0x53, %eax
cmpq $0x0, 0x10(%rbx)
je 0x7643
popq %rbx
popq %r14
popq %r15
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_palette_add(LodePNGColorMode*, unsigned char, unsigned char, unsigned char, unsigned char)
unsigned lodepng_palette_add(LodePNGColorMode* info,
                             unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
  unsigned char* data;
  /*the same resize technique as C++ std::vectors is used, and here it's made so that for a palette with
  the max of 256 colors, it'll have the exact alloc size*/
  if(!info->palette) /*allocate palette if empty*/
  {
    /*room for 256 colors with 4 bytes each*/
    data = (unsigned char*)lodepng_realloc(info->palette, 1024);
    if(!data) return 83; /*alloc fail*/
    else info->palette = data;
  }
  info->palette[4 * info->palettesize + 0] = r;
  info->palette[4 * info->palettesize + 1] = g;
  info->palette[4 * info->palettesize + 2] = b;
  info->palette[4 * info->palettesize + 3] = a;
  ++info->palettesize;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
jne 0x76bd
movl $0x400, %edi            # imm = 0x400
callq 0x21e0
testq %rax, %rax
je 0x76fe
movq %rax, 0x8(%r14)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movb %r12b, (%rax,%rcx,4)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movb %r15b, 0x1(%rax,%rcx,4)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movb %bpl, 0x2(%rax,%rcx,4)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movb %bl, 0x3(%rax,%rcx,4)
incq 0x10(%r14)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x53, %eax
jmp 0x76f5
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_get_raw_size(unsigned int, unsigned int, LodePNGColorMode const*)
size_t lodepng_get_raw_size(unsigned w, unsigned h, const LodePNGColorMode* color)
{
  /*will not overflow for any color type if roughly w * h < 268435455*/
  size_t bpp = lodepng_get_bpp(color);
  size_t n = w * h;
  return ((n / 8) * bpp) + ((n & 7) * bpp + 7) / 8;
}

// Assembly:
movl %esi, %eax
movl (%rdx), %esi
movl 0x4(%rdx), %edx
xorl %ecx, %ecx
cmpq $0x6, %rsi
ja 0x77c7
leaq 0xa9c0(%rip), %rcx      # 0x12184
movl (%rcx,%rsi,4), %ecx
imull %edx, %ecx
imull %edi, %eax
movl %eax, %edx
shrl $0x3, %edx
imulq %rcx, %rdx
andl $0x7, %eax
imulq %rcx, %rax
addq $0x7, %rax
shrq $0x3, %rax
addq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_get_raw_size_lct(unsigned int, unsigned int, LodePNGColorType, unsigned int)
size_t lodepng_get_raw_size_lct(unsigned w, unsigned h, LodePNGColorType colortype, unsigned bitdepth)
{
  /*will not overflow for any color type if roughly w * h < 268435455*/
  size_t bpp = lodepng_get_bpp_lct(colortype, bitdepth);
  size_t n = w * h;
  return ((n / 8) * bpp) + ((n & 7) * bpp + 7) / 8;
}

// Assembly:
movl %esi, %eax
xorl %esi, %esi
cmpl $0x6, %edx
ja 0x77fe
movl %edx, %edx
leaq 0xa989(%rip), %rsi      # 0x12184
movl (%rsi,%rdx,4), %esi
imull %ecx, %esi
imull %edi, %eax
movl %eax, %ecx
shrl $0x3, %ecx
imulq %rsi, %rcx
andl $0x7, %eax
imulq %rsi, %rax
addq $0x7, %rax
shrq $0x3, %rax
addq %rcx, %rax
retq