LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20d06
movl %eax, %r15d
movl %eax, %edi
callq 0x4060
testl %ebp, %ebp
je 0x207f4
testl %eax, %eax
je 0x2082f
cmpl $0xa, %r15d
je 0x2082f
cmpl $0xd, %r15d
je 0x2082f
movq %r14, %rdi
callq 0x20ecc
movq %r14, %rdi
callq 0x20d06
movl %eax, %r15d
movl %eax, %edi
callq 0x4060
jmp 0x207c8
testl %eax, %eax
setne %al
cmpl $0xd, %r15d
setne %cl
cmpl $0xa, %r15d
setne %dl
cmpl $0x3e, %r15d
je 0x20813
andb %dl, %cl
andb %al, %cl
je 0x2082f
movq %r14, %rdi
callq 0x20ecc
movq %r14, %rdi
callq 0x20d06
movl %eax, %r15d
movl %eax, %edi
callq 0x4060
jmp 0x207f4
xorl %r13d, %r13d
movl $0x4801, %ebp           # imm = 0x4801
leal 0x1(%r15), %eax
cmpl $0xe, %eax
ja 0x20845
btl %eax, %ebp
jb 0x20865
movq (%r12), %rax
movb %r15b, (%rax,%r13)
incq %r13
movq %r14, %rdi
callq 0x20ecc
movq %r14, %rdi
callq 0x20d06
movl %eax, %r15d
jmp 0x20837
xorl %ebx, %ebx
leaq 0x180d2(%rip), %r13     # 0x38940
movl %r15d, %edi
callq 0x4060
testl %eax, %eax
je 0x20891
movq %r14, %rdi
callq 0x20ecc
movq %r14, %rdi
callq 0x20d06
movl %eax, %r15d
movl %eax, %edi
jmp 0x20871
cmpl $-0x1, %r15d
je 0x208d0
cmpl $0x3e, %r15d
je 0x208d0
movslq %r15d, %rax
movb (%r13,%rax), %bpl
leaq 0x1(%rbx), %r12
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x10430
movb %bpl, (%rax)
movq %r14, %rdi
callq 0x20ecc
movq %r14, %rdi
callq 0x20d06
movl %eax, %r15d
movq %r12, %rbx
jmp 0x2086e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20d06
movl %eax, %r12d
movl %eax, %edi
callq 0x4060
testl %ebp, %ebp
je 0x20ac6
testl %eax, %eax
je 0x20b01
cmpl $0xa, %r12d
je 0x20b01
cmpl $0xd, %r12d
je 0x20b01
movq %r14, %rdi
callq 0x20ecc
movq %r14, %rdi
callq 0x20d06
movl %eax, %r12d
movl %eax, %edi
callq 0x4060
jmp 0x20a9a
testl %eax, %eax
setne %al
cmpl $0xd, %r12d
setne %cl
cmpl $0xa, %r12d
setne %dl
cmpl $0x3e, %r12d
je 0x20ae5
andb %dl, %cl
andb %al, %cl
je 0x20b01
movq %r14, %rdi
callq 0x20ecc
movq %r14, %rdi
callq 0x20d06
movl %eax, %r12d
movl %eax, %edi
callq 0x4060
jmp 0x20ac6
movl $0x4801, %ebp           # imm = 0x4801
leal 0x1(%r12), %eax
cmpl $0xe, %eax
ja 0x20b15
btl %eax, %ebp
jb 0x20b43
incq (%r15)
movq %r14, %rdi
callq 0x20ecc
movq %r14, %rdi
callq 0x20d06
movl %eax, %r12d
jmp 0x20b06
incq (%rbx)
movq %r14, %rdi
callq 0x20ecc
movq %r14, %rdi
callq 0x20d06
movl %eax, %r12d
movl %r12d, %edi
callq 0x4060
testl %eax, %eax
je 0x20b66
movq %r14, %rdi
callq 0x20ecc
movq %r14, %rdi
callq 0x20d06
movl %eax, %r12d
movl %eax, %edi
jmp 0x20b46
cmpl $-0x1, %r12d
je 0x20b72
cmpl $0x3e, %r12d
jne 0x20b2d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movdqu (%rdi), %xmm0
movdqu 0x10(%rdi), %xmm1
por %xmm0, %xmm1
pxor %xmm0, %xmm0
pcmpeqd %xmm1, %xmm0
movmskps %xmm0, %eax
xorl $0xf, %eax
je 0x20f1f
movq %rdi, %rbx
callq 0x20d06
cmpl $-0x1, %eax
je 0x20f1d
incq 0x20(%rbx)
movq 0x40038(%rbx), %rcx
cmpq $0x1fff, %rcx           # imm = 0x1FFF
ja 0x20f1d
leaq 0x1(%rcx), %rdx
movq %rdx, 0x40038(%rbx)
movb %al, 0x40040(%rbx,%rcx)
popq %rbx
retq
leaq 0xd240(%rip), %rdi      # 0x2e166
leaq 0xd275(%rip), %rsi      # 0x2e1a2
leaq 0xd29a(%rip), %rcx      # 0x2e1ce
movl $0x7d, %edx
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20f5a
movq 0x1604b(%rip), %rcx     # 0x36f98
cmpq (%rcx), %rax
je 0x20f5a
movq %rax, %rdi
jmp 0x4320
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x20f6b
movq %rax, %rdi
jmp 0x4090
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x45d0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf948
testb %al, %al
je 0x215f3
cmpb $0x0, 0xd0(%rbx)
jne 0x215c1
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x21549
callq 0x4420
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x2155a
callq 0x4420
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x2156b
callq 0x4420
cmpb $0x0, 0xd1(%rbx)
jne 0x21585
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x21585
callq 0x4420
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x21596
callq 0x4420
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x215a7
callq 0x4420
cmpb $0x0, 0xd1(%rbx)
jne 0x215c1
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x215c1
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 0xab63(%rip), %rdi      # 0x2c15d
leaq 0xab69(%rip), %rsi      # 0x2c16a
leaq 0xd47e(%rip), %rcx      # 0x2ea86
movl $0x3ad, %edx            # imm = 0x3AD
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26f23
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 0x1008e(%rip), %rbx     # 0x36fb8
leaq 0x53c3(%rip), %rsi      # 0x2c2f4
movq %rbx, %rdi
callq 0x4310
movq %rax, %rdi
movq %r15, %rsi
callq 0x40c0
leaq 0x53bf(%rip), %rsi      # 0x2c30a
movq %rax, %rdi
callq 0x4310
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x40c0
leaq 0x743f(%rip), %rsi      # 0x2e3a5
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
callq 0x4150
leaq 0x8231(%rip), %r14      # 0x2f1ae
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4310
leaq 0x6819(%rip), %rsi      # 0x2d7a8
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movl $0x474, %esi            # imm = 0x474
callq 0x4610
movq %rax, %rdi
callq 0x4150
leaq 0x66d5(%rip), %rdi      # 0x2d688
leaq 0x822c(%rip), %rcx      # 0x2f1e6
movq %r14, %rsi
movl $0x474, %edx            # imm = 0x474
callq 0x41c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x270b0
cmpq $0x0, 0x8(%r14)
jne 0x270b0
movq %r14, %rdi
callq 0x27166
movq 0x10(%r14), %rax
cmpq %rbx, 0x18(%r14)
setb %cl
cmpq %rbx, %rax
setb %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x270e3
leaq 0x1(,%rax,2), %rax
movq %rax, %rsi
addq %rax, %rax
cmpq %rbx, %rsi
jb 0x270d0
movq %r14, %rdi
callq 0x27212
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27810
movq 0x10(%rdi), %rax
cmpq %rsi, %rax
jae 0x2780f
leaq 0x1(,%rax,2), %rcx
movq %rcx, %rax
addq %rcx, %rcx
cmpq %rsi, %rax
jb 0x277fc
movq %rax, %rsi
jmp 0x27830
retq
pushq %rax
leaq 0x7cea(%rip), %rdi      # 0x2f502
leaq 0x616b(%rip), %rsi      # 0x2d98a
leaq 0x7cea(%rip), %rcx      # 0x2f510
movl $0x3dc, %edx            # imm = 0x3DC
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27881
movq %rsi, %rbx
testq %rsi, %rsi
je 0x278a0
movq %rdi, %r14
callq 0x1f9be
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 0x7c7a(%rip), %rdi      # 0x2f502
leaq 0x60fb(%rip), %rsi      # 0x2d98a
leaq 0x7cc7(%rip), %rcx      # 0x2f55d
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x41c0
movq 0xf711(%rip), %rbx      # 0x36fb8
leaq 0x48f7(%rip), %rsi      # 0x2c1a5
movq %rbx, %rdi
callq 0x4310
movq %rax, %rdi
xorl %esi, %esi
callq 0x40c0
leaq 0x48f4(%rip), %rsi      # 0x2c1bb
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
xorl %esi, %esi
callq 0x4610
leaq 0x6ac5(%rip), %rsi      # 0x2e3a5
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
callq 0x4150
leaq 0x6093(%rip), %r14      # 0x2d98a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4310
leaq 0x5e9f(%rip), %rsi      # 0x2d7a8
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movl $0x3e9, %esi            # imm = 0x3E9
callq 0x4610
movq %rax, %rdi
callq 0x4150
leaq 0x5d5b(%rip), %rdi      # 0x2d688
leaq 0x7c29(%rip), %rcx      # 0x2f55d
movq %r14, %rsi
movl $0x3e9, %edx            # imm = 0x3E9
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20ecc
leal 0x1(%rax), %ecx
cmpl $0xe, %ecx
ja 0x2aa23
btl %ecx, %ebp
jae 0x2aa23
jmp 0x2aa42
movq %rbx, %rdi
callq 0x20ecc
cmpl $0xd, %eax
je 0x2aa3a
cmpl $0xa, %eax
je 0x2aa3a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2aad8
testl %ebp, %ebp
js 0x2ab7c
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 0x2aacd
leaq 0x18(%rbx), %r14
movl $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
cmpq $0x20000, %rax          # imm = 0x20000
jne 0x2aac6
movq (%rbx), %rcx
movl $0x20000, %esi          # imm = 0x20000
movl $0x1, %edx
movq %r14, %rdi
callq 0x46b0
testq %rax, %rax
je 0x2ac1d
movq $0x0, 0x10(%rbx)
xorl %eax, %eax
movb $0x0, (%r14,%rax)
jmp 0x2aad3
addl $0x2, %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0xc4d9(%rip), %rbx      # 0x36fb8
leaq 0x180e(%rip), %rsi      # 0x2c2f4
movq %rbx, %rdi
callq 0x4310
movq %rax, %rdi
movl %ebp, %esi
callq 0x4610
leaq 0x180b(%rip), %rsi      # 0x2c30a
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movl $0x4, %esi
callq 0x4610
leaq 0x388a(%rip), %rsi      # 0x2e3a5
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
callq 0x4150
leaq 0x3670(%rip), %r14      # 0x2e1a2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4310
leaq 0x2c64(%rip), %rsi      # 0x2d7a8
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movl $0x228, %esi            # imm = 0x228
callq 0x4610
movq %rax, %rdi
callq 0x4150
leaq 0x2b20(%rip), %rdi      # 0x2d688
leaq 0x58a1(%rip), %rcx      # 0x30410
movq %r14, %rsi
movl $0x228, %edx            # imm = 0x228
callq 0x41c0
movq 0xc435(%rip), %rbx      # 0x36fb8
leaq 0x1728(%rip), %rsi      # 0x2c2b2
movq %rbx, %rdi
callq 0x4310
movq %rax, %rdi
movl %ebp, %esi
callq 0x4610
leaq 0x1726(%rip), %rsi      # 0x2c2c9
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
xorl %esi, %esi
callq 0x4610
leaq 0x37e9(%rip), %rsi      # 0x2e3a5
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
callq 0x4150
leaq 0x35cf(%rip), %r14      # 0x2e1a2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4310
leaq 0x2bc3(%rip), %rsi      # 0x2d7a8
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movl $0x229, %esi            # imm = 0x229
callq 0x4610
movq %rax, %rdi
callq 0x4150
leaq 0x2a7f(%rip), %rdi      # 0x2d688
leaq 0x5800(%rip), %rcx      # 0x30410
movq %r14, %rsi
movl $0x229, %edx            # imm = 0x229
callq 0x41c0
movq 0xc3cc(%rip), %rdi      # 0x36ff0
leaq 0x5808(%rip), %rsi      # 0x30433
callq 0x4310
movq %rax, %rdi
callq 0x4150
movl $0x4, %edi
callq 0x4160
movl $0x1, (%rax)
movq 0xc309(%rip), %rsi      # 0x36f58
movq %rax, %rdi
xorl %edx, %edx
callq 0x45f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ad41
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x45e0
movq 0x10(%rbx), %rdi
jmp 0x2ad5c
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2ad78
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 0x2ad88
callq 0x4380
jmp 0x2ad65
movq (%rbx), %rdi
callq 0x4080
jmp 0x2ad65
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b8b7
leaq 0x8(%rbx), %rsi
xorl %ecx, %ecx
xchgb %cl, 0x8(%rbx)
movq %rbx, (%rax)
xorl %edx, %edx
callq 0x2b928
movb 0x8(%rbx), %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b8de
xorl %ecx, %ecx
movq %rbx, %rax
lock
cmpxchgq %rcx, (%rdi)
je 0x2b8e5
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2b970
movq (%rbx), %rax
movb $0x1, 0x8(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %esi, %esi
je 0x249a
vmovsd (%rdi), %xmm0
vmovsd 0x8(%rdi), %xmm2
vmovsd 0xeba7(%rip), %xmm1     # 0x11008
xorl %eax, %eax
vmulsd %xmm2, %xmm2, %xmm3
vmovapd %xmm0, %xmm4
vfmadd213sd %xmm3, %xmm0, %xmm4 # xmm4 = (xmm0 * xmm4) + xmm3
vsqrtsd %xmm4, %xmm4, %xmm4
vucomisd %xmm1, %xmm4
ja 0x249c
vmulsd %xmm2, %xmm0, %xmm4
vfmsub231sd %xmm0, %xmm0, %xmm3 # xmm3 = (xmm0 * xmm0) - xmm3
incl %eax
vfmadd231sd %xmm0, %xmm2, %xmm4 # xmm4 = (xmm2 * xmm0) + xmm4
vaddsd (%rdx), %xmm3, %xmm0
vaddsd 0x8(%rdx), %xmm4, %xmm2
cmpl %eax, %esi
jne 0x2463
movl %esi, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x8(%r9), %rax
addl %ecx, %r8d
movq (%r9), %rcx
shll $0x2, %r8d
subq %rcx, %rax
cmpq %r8, %rax
jbe 0x250b
movb %dil, (%rcx,%r8)
movq %r8, %rax
orq $0x1, %rax
movq (%r9), %rdi
movq 0x8(%r9), %rcx
subq %rdi, %rcx
cmpq %rax, %rcx
jbe 0x2517
movb %sil, (%rdi,%rax)
movq %r8, %rsi
orq $0x2, %rsi
movq (%r9), %rcx
movq 0x8(%r9), %rax
subq %rcx, %rax
cmpq %rsi, %rax
jbe 0x2526
movb %dl, (%rcx,%rsi)
orq $0x3, %r8
movq (%r9), %rax
movq 0x8(%r9), %rdx
subq %rax, %rdx
cmpq %r8, %rdx
jbe 0x2532
movb $-0x1, (%rax,%r8)
popq %rax
retq
leaq 0xed92(%rip), %rdi      # 0x112a4
movq %r8, %rsi
jmp 0x252d
leaq 0xed86(%rip), %rdi      # 0x112a4
movq %rax, %rsi
movq %rcx, %rdx
jmp 0x253c
leaq 0xed77(%rip), %rdi      # 0x112a4
movq %rax, %rdx
jmp 0x253c
leaq 0xed6b(%rip), %rdi      # 0x112a4
movq %r8, %rsi
xorl %eax, %eax
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2567
movq (%rdi), %rax
movq %rdi, %r14
movb (%rax), %bl
leal -0x30(%rbx), %eax
cmpb $0x9, %al
ja 0x256e
shlb $0x4, %bl
jmp 0x25d7
xorl %ebx, %ebx
jmp 0x2650
leal -0x61(%rbx), %eax
cmpb $0x5, %al
jbe 0x257c
leal -0x41(%rbx), %eax
cmpb $0x5, %al
ja 0x2584
shlb $0x4, %bl
addb $-0x70, %bl
jmp 0x25d7
movq 0x14a4d(%rip), %r15     # 0x16fd8
leaq 0xea8e(%rip), %rsi      # 0x11020
movl $0x12, %edx
movq %r15, %rdi
callq 0x2190
leaq 0xe(%rsp), %rsi
movl $0x1, %edx
movq %r15, %rdi
movb %bl, (%rsi)
callq 0x2190
leaq 0xeb51(%rip), %rsi      # 0x1110b
movl $0x3, %edx
movq %rax, %rdi
callq 0x2190
movq 0x8(%r14), %rdx
cmpq $0x1, %rdx
jbe 0x265c
xorl %ebx, %ebx
movq (%r14), %rax
movb 0x1(%rax), %r15b
leal -0x30(%r15), %eax
cmpb $0x9, %al
ja 0x25ec
addb %bl, %al
movl %eax, %ebx
jmp 0x2650
leal -0x61(%r15), %eax
cmpb $0x5, %al
ja 0x25fc
addb %r15b, %bl
addb $-0x57, %bl
jmp 0x2650
leal -0x41(%r15), %eax
cmpb $0x5, %al
ja 0x260c
addb %r15b, %bl
addb $-0x37, %bl
jmp 0x2650
movq 0x149c5(%rip), %r14     # 0x16fd8
leaq 0xea06(%rip), %rsi      # 0x11020
movl $0x12, %edx
movq %r14, %rdi
callq 0x2190
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
movb %r15b, (%rsi)
callq 0x2190
leaq 0xeac8(%rip), %rsi      # 0x1110b
movl $0x3, %edx
movq %rax, %rdi
callq 0x2190
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xec8b(%rip), %rdi      # 0x112ee
movl $0x1, %esi
xorl %eax, %eax
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %r15
movq %rdx, %rdi
movq %rdx, %rbx
movq %rsi, %r12
callq 0x40e4
testq %rax, %rax
js 0x40d1
movq %rax, %rdi
movq %rax, %r14
movq %rax, (%r12)
callq 0x21e0
testq %rax, %rax
movl $0x53, %ecx
movq %rax, (%r15)
sete %dl
testq %r14, %r14
setne %sil
testb %dl, %sil
jne 0x40d6
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4152
movl $0x4e, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf161(%rip), %rsi      # 0x13250
callq 0x21a0
testq %rax, %rax
je 0x4140
movl $0x2, %edx
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2170
movq $-0x1, %r14
testl %eax, %eax
jne 0x4136
movq %rbx, %rdi
callq 0x2030
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq $-0x1, %r14
cmpq %rcx, %rax
cmovneq %rax, %r14
movq %rbx, %rdi
callq 0x2140
jmp 0x4147
movq $-0x1, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0xf0ef(%rip), %rsi      # 0x13250
movq %rdi, %r14
movq %rdx, %rdi
callq 0x21a0
testq %rax, %rax
je 0x41a1
movl $0x1, %esi
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2200
movq %r15, %rdi
movq %rax, %r14
callq 0x2140
xorl %ecx, %ecx
cmpq %rbx, %r14
movl $0x4e, %eax
cmovel %ecx, %eax
jmp 0x41a6
movl $0x4e, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0xe1aa(%rip), %rsi      # 0x12365
movq %rdi, %r14
movq %rdx, %rdi
callq 0x21a0
testq %rax, %rax
je 0x41ed
movl $0x1, %esi
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x22c0
movq %r15, %rdi
callq 0x2140
xorl %eax, %eax
jmp 0x41f2
movl $0x4f, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x472c
movl (%rdi), %eax
testq %rax, %rax
je 0x469e
vpmovsxbq 0xdbd6(%rip), %zmm1 # 0x12200
vpmovsxbq 0xdbbc(%rip), %zmm2 # 0x121f0
vpbroadcastq 0xdba2(%rip), %zmm3 # 0x121e0
vpbroadcastq 0xdbb0(%rip), %zmm4 # 0x121f8
movq 0x8(%rdi), %r8
leaq 0xf(%rax), %r9
leaq -0x1(%rax), %r10
vpxor %xmm5, %xmm5, %xmm5
andq $-0x10, %r9
vpbroadcastq %r10, %zmm0
vpmullq %zmm3, %zmm1, %zmm6
vpmullq %zmm3, %zmm2, %zmm7
vpcmpleuq %zmm0, %zmm2, %k2
vpcmpleuq %zmm0, %zmm1, %k1
vpaddq %zmm4, %zmm2, %zmm2
vpaddq %zmm4, %zmm1, %zmm1
addq $-0x10, %r9
vpscatterqd %ymm5, 0x10(%r8,%zmm7) {%k2}
vpscatterqd %ymm5, 0x10(%r8,%zmm6) {%k1}
jne 0x4662
movl 0x20(%rdi), %r8d
testq %r8, %r8
je 0x46e6
movq 0x28(%rdi), %r9
movq 0x30(%rdi), %r10
xorl %r11d, %r11d
movq (%r9,%r11,8), %rbx
testq %rbx, %rbx
je 0x46c8
movl $0x1, 0x10(%rbx)
movq 0x8(%rbx), %rbx
jmp 0x46b6
movq (%r10,%r11,8), %rbx
testq %rbx, %rbx
je 0x46de
movl $0x1, 0x10(%rbx)
movq 0x8(%rbx), %rbx
jmp 0x46cc
incq %r11
cmpq %r8, %r11
jne 0x46b2
movl $0x0, 0x10(%rdi)
testq %rax, %rax
je 0x472a
shlq $0x3, %rax
xorl %r8d, %r8d
xorl %r9d, %r9d
leaq (%rax,%rax,2), %rax
movq 0x8(%rdi), %r10
cmpl $0x0, 0x10(%r10,%r8)
jne 0x4721
movq 0x18(%rdi), %r11
movl %r9d, %ebx
incl %r9d
addq %r8, %r10
movl %r9d, 0x10(%rdi)
movq %r10, (%r11,%rbx,8)
addq $0x18, %r8
cmpq %r8, %rax
jne 0x4700
xorl %eax, %eax
movq 0x18(%rdi), %r8
leal 0x1(%rax), %r9d
movl %eax, %eax
movl %r9d, 0x14(%rdi)
movq (%r8,%rax,8), %rax
movl %esi, (%rax)
movl %edx, 0x4(%rax)
movq %rcx, 0x8(%rax)
popq %rbx
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x18, %rsp
movq %rdx, %r15
movq 0x30(%rdi), %rdx
movslq %ecx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx,%r13,8), %rax
movl 0x4(%rax), %ecx
testl %r13d, %r13d
je 0x483c
leal 0x1(%r8), %esi
leal -0x2(%r15,%r15), %edi
leaq (,%r13,8), %r12
xorl %ebp, %ebp
movq %r8, 0x10(%rsp)
movl %esi, 0x4(%rsp)
leal -0x1(%r13), %esi
movl %edi, (%rsp)
movq %rsi, 0x8(%rsp)
movq 0x28(%rbx), %rdi
addq %r12, %rdx
movq -0x8(%rdx,%rbp,8), %rdx
addq %r12, %rdi
movq -0x8(%rdi,%rbp,8), %r8
movl (%rdx), %esi
movl %ecx, %edx
addl (%r8), %esi
movq %rax, (%rdi,%rbp,8)
cmpq %r15, %rdx
jae 0x47d6
leaq (%rdx,%rdx,2), %rax
movl (%r14,%rax,8), %eax
cmpl %eax, %esi
jg 0x4864
movq 0x30(%rbx), %rax
movq %rbx, %rdi
addq %r12, %rax
movq -0x8(%rax,%rbp,8), %rcx
callq 0x460c
movq 0x30(%rbx), %rcx
addq %r12, %rcx
movq %rax, (%rcx,%rbp,8)
movl (%rsp), %ecx
cmpl %ecx, 0x4(%rsp)
jge 0x4887
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
leal (%rax,%rbp), %ecx
callq 0x474c
movq 0x30(%rbx), %rdx
movq %r13, %rsi
leaq (%rdx,%r12), %rax
movq -0x8(%rax,%rbp,8), %rax
decq %rbp
addq %rbp, %rsi
movl 0x4(%rax), %ecx
jne 0x47a2
movl %ecx, %ecx
cmpq %r15, %rcx
jae 0x4887
movq 0x28(%rbx), %rdx
xorl %r13d, %r13d
movq %rbx, %rdi
movq %rax, (%rdx)
leaq (%rcx,%rcx,2), %rax
leal 0x1(%rcx), %edx
xorl %ecx, %ecx
movl (%r14,%rax,8), %esi
callq 0x460c
jmp 0x487f
addq 0x30(%rbx), %r12
incl %edx
movq %rbx, %rdi
movl %eax, %esi
movq (%r12,%rbp,8), %rcx
movq 0x8(%rcx), %rcx
callq 0x460c
addq %rbp, %r13
movq 0x30(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x72b9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq 0xa6a6(%rip), %rdx      # 0x11940
xorl %ecx, %ecx
movb (%rdi,%rcx), %r8b
incq %rcx
xorb %al, %r8b
shrl $0x8, %eax
movzbl %r8b, %r8d
xorl (%rdx,%r8,4), %eax
cmpq %rcx, %rsi
jne 0x729c
notl %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movzbl (%rdx), %r13d
movzbl 0x1(%rdx), %r15d
movzbl 0x2(%rdx), %r14d
movzbl 0x3(%rdx), %ecx
movq %rdx, %rbx
movl $0x4d, %edx
shll $0x18, %r13d
shll $0x10, %r15d
shll $0x8, %r14d
leal (%r15,%r13), %eax
orl %r14d, %eax
leal 0xc(%rcx,%rax), %ebp
movq (%rsi), %rax
movq %rbp, %r12
addq %rax, %r12
jb 0x74cb
movq %rdi, 0x18(%rsp)
movq (%rdi), %rdi
movq %rsi, 0x20(%rsp)
movq %r12, %rsi
movq %rax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
callq 0x2260
testq %rax, %rax
je 0x74c6
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rsi
xorl %edx, %edx
movq %rax, (%rcx)
movq %r12, (%rsi)
testl %ebp, %ebp
je 0x74cb
movq 0x10(%rsp), %rcx
orl %r15d, %r13d
addq 0x8(%rsp), %rax
movq %rbx, %rsi
orl %r14d, %r13d
leal 0xb(%rcx,%r13), %edx
movq %rax, %rdi
incq %rdx
callq 0x2100
xorl %edx, %edx
jmp 0x74cb
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_O3/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, %r13d
leaq 0xc(%r13), %rbp
addq (%rsi), %rbp
movl %edx, %r14d
movq %rsi, %r15
leal 0xc(%r14), %esi
setb %al
cmpq %rsi, %rbp
setb %sil
orb %al, %sil
movl $0x4d, %eax
jne 0x7594
movq %rdi, %r12
movq (%rdi), %rdi
movq %rbp, %rsi
movq %r8, %rbx
movq %rcx, (%rsp)
callq 0x2260
testq %rax, %rax
je 0x758f
movq %rax, (%r12)
movq %rbp, (%r15)
subq %r13, %rbp
movq %r14, %rdx
movl %edx, %ecx
shrl $0x18, %ecx
movb %cl, -0xc(%rax,%rbp)
movl %edx, %ecx
shrl $0x10, %ecx
leaq -0xc(%rax,%rbp), %rdi
movb %cl, -0xb(%rax,%rbp)
movq (%rsp), %rcx
movb %dh, -0xa(%rax,%rbp)
movb %dl, -0x9(%rax,%rbp)
movl (%rcx), %ecx
movl %ecx, -0x8(%rax,%rbp)
testl %edx, %edx
je 0x7586
negq %r13
movl $0x8, %eax
movb -0x8(%rbx,%rax), %cl
movl %eax, %edx
movb %cl, (%rdi,%rdx)
leaq 0x1(%r13,%rax), %rdx
incq %rax
cmpq $0x8, %rdx
jne 0x756f
callq 0x73c4
xorl %eax, %eax
jmp 0x7594
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_O3/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 %rdi, %r14
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %rdi
movq %rsi, %rbx
testq %rdi, %rdi
je 0x761a
callq 0x21b0
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%r15)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
vmovups (%rbx), %ymm0
vmovups %ymm0, (%r14)
xorl %r14d, %r14d
cmpq $0x0, 0x8(%rbx)
je 0x7693
movl $0x400, %edi            # imm = 0x400
vzeroupper
callq 0x21e0
movq %rax, (%r15)
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x7684
shlq $0x2, %rcx
testq %rcx, %rcx
je 0x7693
xorl %r14d, %r14d
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movq (%r15), %rdx
movb (%rcx,%rax), %cl
movb %cl, (%rdx,%rax)
incq %rax
movq 0x10(%rbx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
jne 0x7665
jmp 0x7693
xorl %eax, %eax
testq %rcx, %rcx
movl $0x53, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x8(%rdi), %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
testq %rax, %rax
jne 0x76d1
movl $0x400, %edi            # imm = 0x400
callq 0x21e0
testq %rax, %rax
je 0x770e
movq %rax, 0x8(%r14)
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 0x7705
// File: /workspace/github_cpp_makefile_star2_O3/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 0x77d7
leaq 0xa9f0(%rip), %rcx      # 0x121c4
movl (%rcx,%rsi,4), %ecx
imull %edi, %eax
imull %edx, %ecx
movl %eax, %edx
andl $0x7, %eax
shrl $0x3, %edx
imulq %rcx, %rax
imulq %rcx, %rdx
addq $0x7, %rax
shrq $0x3, %rax
addq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x780e
leaq 0xa9bb(%rip), %rsi      # 0x121c4
movl %edx, %edx
movl (%rsi,%rdx,4), %esi
imull %edi, %eax
imull %ecx, %esi
movl %eax, %ecx
andl $0x7, %eax
shrl $0x3, %ecx
imulq %rsi, %rax
imulq %rsi, %rcx
addq $0x7, %rax
shrq $0x3, %rax
addq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: LodePNGText_cleanup(LodePNGInfo*)
static void LodePNGText_cleanup(LodePNGInfo* info)
{
  size_t i;
  for(i = 0; i != info->text_num; ++i)
  {
    string_cleanup(&info->text_keys[i]);
    string_cleanup(&info->text_strings[i]);
  }
  lodepng_free(info->text_keys);
  lodepng_free(info->text_strings);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x48(%rdi)
movq %rdi, %rbx
je 0x7875
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x50(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
movq 0x58(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
incq %r15
cmpq 0x48(%rbx), %r15
jne 0x784a
movq 0x50(%rbx), %rdi
callq 0x21b0
movq 0x58(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_add_text(LodePNGInfo*, char const*, char const*)
unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str)
{
  char** new_keys = (char**)(lodepng_realloc(info->text_keys, sizeof(char*) * (info->text_num + 1)));
  char** new_strings = (char**)(lodepng_realloc(info->text_strings, sizeof(char*) * (info->text_num + 1)));
  if(!new_keys || !new_strings)
  {
    lodepng_free(new_keys);
    lodepng_free(new_strings);
    return 83; /*alloc fail*/
  }

  ++info->text_num;
  info->text_keys = new_keys;
  info->text_strings = new_strings;

  string_init(&info->text_keys[info->text_num - 1]);
  string_set(&info->text_keys[info->text_num - 1], key);

  string_init(&info->text_strings[info->text_num - 1]);
  string_set(&info->text_strings[info->text_num - 1], str);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x48(%rdi), %rax
movq %rdi, %r14
movq 0x50(%rdi), %rdi
movq %rsi, %r15
movq %rdx, %rbx
leaq 0x8(,%rax,8), %rsi
callq 0x2260
movq %rax, %r12
movq 0x48(%r14), %rax
movq 0x58(%r14), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2260
testq %r12, %r12
movq %rax, %r13
setne %al
testq %r13, %r13
setne %cl
testb %cl, %al
je 0x796b
movq %rbx, (%rsp)
movq 0x48(%r14), %rbx
movl $0x1, %edi
leaq 0x1(%rbx), %rbp
movq %rbp, 0x48(%r14)
movq %r12, 0x50(%r14)
movq %r13, 0x58(%r14)
movq $0x0, (%r12,%rbx,8)
callq 0x21e0
testq %rax, %rax
je 0x7920
movb $0x0, (%rax)
movq %rax, (%r12,%rbx,8)
leaq -0x8(%r12,%rbp,8), %rdi
movq %r15, %rsi
callq 0x798f
movq 0x48(%r14), %rbx
movq 0x58(%r14), %r15
movl $0x1, %edi
movq $0x0, -0x8(%r15,%rbx,8)
callq 0x21e0
testq %rax, %rax
je 0x7955
movb $0x0, (%rax)
movq %rax, -0x8(%r15,%rbx,8)
movq 0x58(%r14), %rax
movq (%rsp), %rsi
leaq -0x8(%rax,%rbx,8), %rdi
callq 0x798f
xorl %eax, %eax
jmp 0x7980
movq %r12, %rdi
callq 0x21b0
movq %r13, %rdi
callq 0x21b0
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_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: string_set(char**, char const*)
static void string_set(char** out, const char* in)
{
  size_t insize = strlen(in), i;
  if(string_resize(out, insize))
  {
    for(i = 0; i != insize; ++i)
    {
      (*out)[i] = in[i];
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rsi, %rbx
callq 0x2090
movq (%r14), %rdi
leaq 0x1(%rax), %rsi
movq %rax, %r15
callq 0x2260
testq %rax, %rax
je 0x79d6
movb $0x0, (%rax,%r15)
movq %rax, (%r14)
testq %r15, %r15
je 0x79d6
xorl %eax, %eax
movb (%rbx,%rax), %cl
movq (%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %r15
jne 0x79c5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: LodePNGIText_cleanup(LodePNGInfo*)
static void LodePNGIText_cleanup(LodePNGInfo* info)
{
  size_t i;
  for(i = 0; i != info->itext_num; ++i)
  {
    string_cleanup(&info->itext_keys[i]);
    string_cleanup(&info->itext_langtags[i]);
    string_cleanup(&info->itext_transkeys[i]);
    string_cleanup(&info->itext_strings[i]);
  }
  lodepng_free(info->itext_keys);
  lodepng_free(info->itext_langtags);
  lodepng_free(info->itext_transkeys);
  lodepng_free(info->itext_strings);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x60(%rdi)
movq %rdi, %rbx
je 0x7a46
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x68(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
movq 0x70(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
movq 0x78(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
movq 0x80(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
incq %r15
cmpq 0x60(%rbx), %r15
jne 0x79f6
movq 0x68(%rbx), %rdi
callq 0x21b0
movq 0x70(%rbx), %rdi
callq 0x21b0
movq 0x78(%rbx), %rdi
callq 0x21b0
movq 0x80(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_info_cleanup(LodePNGInfo*)
void lodepng_info_cleanup(LodePNGInfo* info)
{
  lodepng_color_mode_cleanup(&info->color);
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  LodePNGText_cleanup(info);
  LodePNGIText_cleanup(info);

  LodePNGUnknownChunks_cleanup(info);
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x7cdd
callq 0x21b0
vxorps %xmm0, %xmm0, %xmm0
movq %rbx, %rdi
vmovups %xmm0, (%r14)
callq 0x7832
movq %rbx, %rdi
callq 0x79de
xorl %r14d, %r14d
movq 0xb8(%rbx,%r14,8), %rdi
callq 0x21b0
incq %r14
cmpq $0x3, %r14
jne 0x7cf9
addq $0x8, %rsp
popq %rbx
popq %r14
retq