LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::ftabLo(unsigned long*, unsigned long*, unsigned long, unsigned long, unsigned long, unsigned long)
static TIndexOffU ftabLo(TIndexOffU *ftab,
			TIndexOffU *eftab,
			TIndexOffU len,
			TIndexOffU ftabLen,
			TIndexOffU eftabLen,
			TIndexOffU i)
	{
		assert_lt(i, ftabLen);
		if(ftab[i] <= len) {
			return ftab[i];
		} else {
			TIndexOffU efIdx = ftab[i] ^ OFF_MASK;
			assert_lt(efIdx*2+1, eftabLen);
			return eftab[efIdx*2];
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x234a3
movq 0x26bcb(%rip), %rdi     # 0x49fc0
leaq 0x1be4b(%rip), %rsi     # 0x3f247
callq 0x5360
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x1be46(%rip), %rsi     # 0x3f25d
callq 0x5360
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x1e186(%rip), %rsi     # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x26b3f(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x26b73(%rip), %rdi     # 0x49fc0
leaq 0x1bc69(%rip), %rsi     # 0x3f0bd
callq 0x5360
movq %rax, %rdi
leaq 0x1d327(%rip), %rsi     # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x402, %esi            # imm = 0x402
callq 0x5750
movq %rax, %rdi
movq 0x26b01(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x1d1df(%rip), %rdi     # 0x4066a
leaq 0x1bc2b(%rip), %rsi     # 0x3f0bd
movl $0x402, %edx            # imm = 0x402
leaq 0x1cc25(%rip), %rcx     # 0x400c3
callq 0x51e0
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
ja 0x234ca
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x235c2
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
xorq $-0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shlq %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
jb 0x235af
movq 0x26ac6(%rip), %rdi     # 0x49fc0
leaq 0x1bd46(%rip), %rsi     # 0x3f247
callq 0x5360
movq %rax, %rdi
movq -0x40(%rbp), %rsi
shlq %rsi
addq $0x1, %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x1bd3a(%rip), %rsi     # 0x3f25d
callq 0x5360
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x1e07a(%rip), %rsi     # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x26a33(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x26a67(%rip), %rdi     # 0x49fc0
leaq 0x1bb5d(%rip), %rsi     # 0x3f0bd
callq 0x5360
movq %rax, %rdi
leaq 0x1d21b(%rip), %rsi     # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x407, %esi            # imm = 0x407
callq 0x5750
movq %rax, %rdi
movq 0x269f5(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x1d0d3(%rip), %rdi     # 0x4066a
leaq 0x1bb1f(%rip), %rsi     # 0x3f0bd
movl $0x407, %edx            # imm = 0x407
leaq 0x1cb19(%rip), %rcx     # 0x400c3
callq 0x51e0
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
shlq %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: USE_POPCNT_GENERIC::pop64(unsigned long)
inline static int pop64(uint64_t x) {
   x = x - ((x >> 1) & 0x5555555555555555llu);
   x = (x & 0x3333333333333333llu) + ((x >> 2) & 0x3333333333333333llu);
   x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0Fllu;
   x = x + (x >> 8);
   x = x + (x >> 16);
   x = x + (x >> 32);
   return x & 0x3F;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq %rcx
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movabsq $0x3333333333333333, %rax # imm = 0x3333333333333333
andq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x2, %rcx
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x4, %rcx
addq %rcx, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x8, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x10, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x20, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $0x3f, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::repOk(EbwtParams const&) const
bool repOk(const EbwtParams& eh) const {
		assert(_eh.repOk());
		if(isInMemory()) {
			return inMemoryRepOk(eh);
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x108, %rdi            # imm = 0x108
callq 0x1bfc0
testb $0x1, %al
jne 0x2af2a
jmp 0x2af2c
jmp 0x2af4b
leaq 0x14d0a(%rip), %rdi     # 0x3fc3d
leaq 0x14183(%rip), %rsi     # 0x3f0bd
movl $0x49f, %edx            # imm = 0x49F
leaq 0x157d2(%rip), %rcx     # 0x40718
callq 0x51e0
movq -0x20(%rbp), %rdi
callq 0x18060
testb $0x1, %al
jne 0x2af5a
jmp 0x2af6e
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2af80
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2af72
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./ref_read.h
// Function: RefRecord::RefRecord(_IO_FILE*, bool)
RefRecord(FILE *in, bool swap) {
		assert(in != NULL);
		if(!fread(&off, OFF_SIZE, 1, in)) {
			cerr << "Error reading RefRecord offset from FILE" << endl;
			throw 1;
		}
		if(swap) off = endianSwapU(off);
		if(!fread(&len, OFF_SIZE, 1, in)) {
			cerr << "Error reading RefRecord offset from FILE" << endl;
			throw 1;
		}
		if(swap) len = endianSwapU(len);
		first = fgetc(in) ? true : false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2bec8
jmp 0x2bee7
leaq 0x154ee(%rip), %rdi     # 0x413bd
leaq 0x14f54(%rip), %rsi     # 0x40e2a
movl $0x40, %edx
leaq 0x14f55(%rip), %rcx     # 0x40e37
callq 0x51e0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x5600
cmpq $0x0, %rax
jne 0x2bf49
movq 0x1e0e5(%rip), %rdi     # 0x49ff0
leaq 0x14f48(%rip), %rsi     # 0x40e5a
callq 0x5360
movq %rax, %rdi
movq 0x1e05f(%rip), %rsi     # 0x49f80
callq 0x53c0
movl $0x4, %edi
callq 0x5180
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x1e030(%rip), %rsi     # 0x49f70
xorl %eax, %eax
movl %eax, %edx
callq 0x5720
testb $0x1, -0x11(%rbp)
je 0x2bf65
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xe4b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x5600
cmpq $0x0, %rax
jne 0x2bfcb
movq 0x1e063(%rip), %rdi     # 0x49ff0
leaq 0x14ec6(%rip), %rsi     # 0x40e5a
callq 0x5360
movq %rax, %rdi
movq 0x1dfdd(%rip), %rsi     # 0x49f80
callq 0x53c0
movl $0x4, %edi
callq 0x5180
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x1dfae(%rip), %rsi     # 0x49f70
xorl %eax, %eax
movl %eax, %edx
callq 0x5720
testb $0x1, -0x11(%rbp)
je 0x2bfe9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xe4b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x5650
movl %eax, %edx
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
negl %edx
sbbl %ecx, %ecx
andb $0x1, %cl
movb %cl, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./ds.h
// Function: EList<RefRecord, 128>::expandCopy(unsigned long)
void expandCopy(size_t thresh) {
		if(thresh <= sz_) return;
		size_t newsz = (sz_ * 2)+1;
		while(newsz < thresh) newsz *= 2;
		expandCopyExact(newsz);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
ja 0x2cbd4
jmp 0x2cc0b
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2cbfe
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
jmp 0x2cbe7
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2cd50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./ds.h
// Function: EList<SString<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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x48(%rbp)
callq 0x5030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2e21b
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x19450
jmp 0x2e206
movq -0x60(%rbp), %rcx
movq -0x68(%rbp), %rax
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0x2e1f7
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2e22c
jmp 0x2e297
leaq 0x12b30(%rip), %rdi     # 0x40d63
leaq 0x12732(%rip), %rsi     # 0x4096c
movl $0x39c, %edx            # imm = 0x39C
leaq 0x12fb3(%rip), %rcx     # 0x411f9
callq 0x51e0
movq -0x30(%rbp), %rcx
movq %rax, %rsi
movq -0x68(%rbp), %rax
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
cmpq %rax, %rcx
movq %rax, -0x70(%rbp)
je 0x2e288
movq -0x70(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x78(%rbp)
callq 0x196d0
movq -0x30(%rbp), %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x70(%rbp)
jne 0x2e266
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x5830
jmp 0x2e2ad
movq -0x50(%rbp), %rax
movl (%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./ds.h
// Function: EList<RefRecord, 128>::expandCopyExact(unsigned long)
void expandCopyExact(size_t newsz) {
		if(newsz <= sz_) return;
		T* tmp = alloc(newsz);
		assert(tmp != NULL);
		size_t cur = cur_;
		if(list_ != NULL) {
 			for(size_t i = 0; i < cur_; i++) {
				// Note: operator= is used
				tmp[i] = list_[i];
			}
			free();
		}
		list_ = tmp;
		sz_ = newsz;
		cur_ = cur;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
ja 0x2cd77
jmp 0x2ce3c
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2cc20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2cd91
jmp 0x2cdb0
leaq 0x13fcb(%rip), %rdi     # 0x40d63
leaq 0x13bcd(%rip), %rsi     # 0x4096c
movl $0x3c8, %edx            # imm = 0x3C8
leaq 0x14000(%rip), %rcx     # 0x40dab
callq 0x51e0
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x2ce20
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x2ce17
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
imulq $0x18, -0x28(%rbp), %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movb 0x10(%rcx), %cl
movb %cl, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2cdcb
movq -0x30(%rbp), %rdi
callq 0x2ce50
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SString<char>::install(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void install(const std::basic_string<T>& b) {
		size_t sz = b.length();
		if(sz == 0) return;
		resize(sz);
		memcpy(cs_, b.c_str(), sz * sizeof(T));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5610
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2e7ae
jmp 0x2e7e4
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x189a0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5150
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
shlq $0x0, %rdx
callq 0x5290
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
testb $0x1, -0x19(%rbp)
jne 0x2ed0b
movq -0x28(%rbp), %rdi
callq 0x2efe0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x132f0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x2ece9
cmpl $0x3e, -0x20(%rbp)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2ecf2
jmp 0x2ed09
movq -0x28(%rbp), %rdi
callq 0x2f2b0
movq -0x28(%rbp), %rdi
callq 0x2efe0
movl %eax, -0x20(%rbp)
jmp 0x2eccb
jmp 0x2ed3e
movq -0x28(%rbp), %rdi
callq 0x2efe0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x132f0
testb $0x1, %al
jne 0x2ed25
jmp 0x2ed3c
movq -0x28(%rbp), %rdi
callq 0x2f2b0
movq -0x28(%rbp), %rdi
callq 0x2efe0
movl %eax, -0x20(%rbp)
jmp 0x2ed17
jmp 0x2ed3e
jmp 0x2ed40
movl -0x20(%rbp), %edi
callq 0x13330
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x2a(%rbp)
jne 0x2ed5e
cmpl $-0x1, -0x20(%rbp)
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x2ed67
jmp 0x2ed8c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x2f2b0
movq -0x28(%rbp), %rdi
callq 0x2efe0
movl %eax, -0x20(%rbp)
jmp 0x2ed40
jmp 0x2ed8e
jmp 0x2ed90
movl -0x20(%rbp), %edi
callq 0x5060
cmpl $0x0, %eax
je 0x2edb4
movq -0x28(%rbp), %rdi
callq 0x2f2b0
movq -0x28(%rbp), %rdi
callq 0x2efe0
movl %eax, -0x20(%rbp)
jmp 0x2ed90
cmpl $0x3e, -0x20(%rbp)
je 0x2edc0
cmpl $-0x1, -0x20(%rbp)
jne 0x2edc2
jmp 0x2ede7
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x2f2b0
movq -0x28(%rbp), %rdi
callq 0x2efe0
movl %eax, -0x20(%rbp)
jmp 0x2ed8e
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, (%rcx)
movb %al, -0xd(%rbp)
jne 0x2f2fe
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x8(%rcx)
movb %al, -0xd(%rbp)
jne 0x2f2fe
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x10(%rcx)
movb %al, -0xd(%rbp)
jne 0x2f2fe
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x2f307
jmp 0x2f309
jmp 0x2f328
leaq 0x12050(%rip), %rdi     # 0x41360
leaq 0x12085(%rip), %rsi     # 0x4139c
movl $0x7d, %edx
leaq 0x120a5(%rip), %rcx     # 0x413c8
callq 0x51e0
movq -0x18(%rbp), %rdi
callq 0x2efe0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x2f37e
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
cmpq $0x2000, 0x40038(%rax) # imm = 0x2000
jae 0x2f37c
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movb %cl, %dl
movq 0x40038(%rax), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x40038(%rax)
movb %dl, 0x40040(%rax,%rcx)
jmp 0x2f37e
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::init()
void init() {
		_in = NULL;
		_zIn = NULL;
		_inf = NULL;
		_ins = NULL;
		_cur = _buf_sz = BUF_SZ;
		_done = false;
		_lastn_cur = 0;
		// no need to clear _buf[]
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x40000, 0x28(%rax)    # imm = 0x40000
movq $0x40000, 0x20(%rax)    # imm = 0x40000
movb $0x0, 0x30(%rax)
movq $0x0, 0x40038(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x2f41b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1aba0(%rip), %rcx     # 0x49fa8
cmpq (%rcx), %rax
je 0x2f41b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5370
jmp 0x2f455
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2f435
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x50a0
jmp 0x2f453
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2f44f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x56f0
jmp 0x2f451
jmp 0x2f451
jmp 0x2f453
jmp 0x2f455
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./processor_support.h
// Function: ProcessorSupport::POPCNTenabled()
bool POPCNTenabled()
    {
    // from: Intel® 64 and IA-32 Architectures Software Developer’s Manual, 325462-036US,March 2013
    //Before an application attempts to use the POPCNT instruction, it must check that the
    //processor supports SSE4.2
    //“(if CPUID.01H:ECX.SSE4_2[bit 20] = 1) and POPCNT (if CPUID.01H:ECX.POPCNT[bit 23] = 1)”
    //
    // see p.272 of http://download.intel.com/products/processor/manual/253667.pdf available at
    // http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html
    // Also http://en.wikipedia.org/wiki/SSE4 talks about available on Intel & AMD processors

    regs_t regs;

    try {
#if ( defined(USING_INTEL_COMPILER) || defined(USING_MSC_COMPILER) )
        __cpuid((int *) &regs,0); // test if __cpuid() works, if not catch the exception
        __cpuid((int *) &regs,0x1); // POPCNT bit is bit 23 in ECX
#elif defined(USING_GCC_COMPILER)
        __get_cpuid(0x1, &regs.EAX, &regs.EBX, &regs.ECX, &regs.EDX);
#else
        std::cerr << "ERROR: please define __cpuid() for this build.\n";
        assert(0);
#endif
        if( !( (regs.ECX & BIT(20)) && (regs.ECX & BIT(23)) ) ) return false;
    }
    catch (int e) {
        return false;
    }
    return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x1c(%rbp), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x14(%rbp), %r8
movl $0x1, %edi
leaq -0x20(%rbp), %rsi
callq 0x14000
jmp 0x2f8b8
movl -0x18(%rbp), %eax
andl $0x100000, %eax         # imm = 0x100000
cmpl $0x0, %eax
je 0x2f8d2
movl -0x18(%rbp), %eax
andl $0x800000, %eax         # imm = 0x800000
cmpl $0x0, %eax
jne 0x2f909
movb $0x0, -0x1(%rbp)
jmp 0x2f90f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2f91a
movq -0x28(%rbp), %rdi
callq 0x5140
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movb $0x0, -0x1(%rbp)
callq 0x56a0
jmp 0x2f90f
jmp 0x2f90b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: EbwtParams::setOffRate(int)
void setOffRate(int __offRate) {
		_offRate = __offRate;
		_offMask = OFF_MASK << _offRate;
		_offsLen = (_bwtLen + (1 << _offRate) - 1) >> _offRate;
		_offsSz = (uint64_t) _offsLen*OFF_SIZE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x2c(%rax)
movl 0x2c(%rax), %ecx
movq $-0x1, %rdx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x30(%rax)
movq 0x8(%rax), %rdx
movl 0x2c(%rax), %ecx
movl $0x1, %esi
shll %cl, %esi
movl %esi, %ecx
movslq %ecx, %rcx
addq %rcx, %rdx
subq $0x1, %rdx
movl 0x2c(%rax), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x60(%rax)
movq 0x60(%rax), %rcx
shlq $0x3, %rcx
movq %rcx, 0x68(%rax)
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: EbwtParams::setIsaRate(int)
void setIsaRate(int __isaRate) {
		_isaRate = __isaRate;
		_isaMask = OFF_MASK << _isaRate;
		_isaLen = (_bwtLen + (1 << _isaRate) - 1) >> _isaRate;
		_isaSz = (uint64_t)_isaLen*OFF_SIZE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x38(%rax)
movl 0x38(%rax), %ecx
movq $-0x1, %rdx
shlq %cl, %rdx
movq %rdx, %rcx
movl %ecx, 0x3c(%rax)
movq 0x8(%rax), %rdx
movl 0x38(%rax), %ecx
movl $0x1, %esi
shll %cl, %esi
movl %esi, %ecx
movslq %ecx, %rcx
addq %rcx, %rdx
subq $0x1, %rdx
movl 0x38(%rax), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x70(%rax)
movq 0x70(%rax), %rcx
shlq $0x3, %rcx
movq %rcx, 0x78(%rax)
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::loadIntoMemory(int, bool, bool)
void loadIntoMemory(
		int needEntireReverse,
		bool loadNames,
		bool verbose)
	{
		readIntoMemory(
			needEntireReverse, // require reverse index to be concatenated reference reversed
			false,      // stop after loading the header portion?
			NULL,       // params
			false,      // mmSweep
			loadNames,  // loadNames
			verbose);   // startVerbose
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %cl
movb %cl, -0xd(%rbp)
andb $0x1, %al
movb %al, -0xe(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movb -0xd(%rbp), %r9b
movb -0xe(%rbp), %al
xorl %r8d, %r8d
xorl %ecx, %ecx
andb $0x1, %r9b
andb $0x1, %al
movl %r8d, %edx
movzbl %r9b, %r9d
movzbl %al, %eax
movl %eax, (%rsp)
callq 0x9900
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x18060
testb $0x1, %al
jne 0x301bf
jmp 0x301c1
jmp 0x301e0
leaq 0xeee8(%rip), %rdi      # 0x3f0b0
leaq 0xeeee(%rip), %rsi      # 0x3f0bd
movl $0x3ad, %edx            # imm = 0x3AD
leaq 0x11ad7(%rip), %rcx     # 0x41cb2
callq 0x51e0
movq -0x10(%rbp), %rax
testb $0x1, 0xd0(%rax)
jne 0x302e3
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3020f
movq -0x18(%rbp), %rdi
callq 0x5510
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x3022d
movq -0x20(%rbp), %rdi
callq 0x5510
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3024b
movq -0x28(%rbp), %rdi
callq 0x5510
movq -0x10(%rbp), %rax
testb $0x1, 0xd1(%rax)
jne 0x30278
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x30276
movq -0x30(%rbp), %rdi
callq 0x5510
jmp 0x30278
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x30296
movq -0x38(%rbp), %rdi
callq 0x5510
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x302b4
movq -0x40(%rbp), %rdi
callq 0x5510
movq -0x10(%rbp), %rax
testb $0x1, 0xd1(%rax)
jne 0x302e1
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x302df
movq -0x48(%rbp), %rdi
callq 0x5510
jmp 0x302e1
jmp 0x302e3
movq -0x10(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq $0x0, 0xa8(%rax)
movq $0x0, 0xb0(%rax)
movq $0x0, 0xb8(%rax)
movq $0x0, 0xc0(%rax)
movq $0x0, 0x98(%rax)
movq $0x0, 0xc8(%rax)
movq $-0x1, 0x70(%rax)
movq $-0x1, 0x78(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./diff_sample.h
// Function: DifferenceCoverSample<S2bDnaString>::isCovered(unsigned long) const
bool DifferenceCoverSample<TStr>::isCovered(TIndexOffU i) const {
	assert(built());
	uint32_t modi = this->modv(i);
	assert_lt(modi, _dInv.size());
	return _dInv[modi] != 0xffffffff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x36a40
testb $0x1, %al
jne 0x36ac3
jmp 0x36ac5
jmp 0x36ae4
leaq 0xb7d0(%rip), %rdi      # 0x4229c
leaq 0xb7d1(%rip), %rsi      # 0x422a4
movl $0x3ec, %edx            # imm = 0x3EC
leaq 0xb906(%rip), %rcx      # 0x423e5
callq 0x51e0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x36a70
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x98, %rdi
callq 0x2c260
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jb 0x36be3
movq 0x1349e(%rip), %rdi     # 0x49fc0
leaq 0x871e(%rip), %rsi      # 0x3f247
callq 0x5360
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x5530
movq %rax, %rdi
leaq 0x871a(%rip), %rsi      # 0x3f25d
callq 0x5360
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x98, %rdi
callq 0x2c260
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0xaa46(%rip), %rsi      # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x133ff(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x13433(%rip), %rdi     # 0x49fc0
leaq 0xb710(%rip), %rsi      # 0x422a4
callq 0x5360
movq %rax, %rdi
leaq 0x9be7(%rip), %rsi      # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x3ee, %esi            # imm = 0x3EE
callq 0x5750
movq %rax, %rdi
movq 0x133c1(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x9a9f(%rip), %rdi      # 0x4066a
leaq 0xb6d2(%rip), %rsi      # 0x422a4
movl $0x3ee, %edx            # imm = 0x3EE
leaq 0xb807(%rip), %rcx      # 0x423e5
callq 0x51e0
movq -0x20(%rbp), %rdi
addq $0x98, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2fa20
cmpl $-0x1, (%rax)
setne %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
jb 0x36d2f
movq 0x13343(%rip), %rdi     # 0x49fc0
leaq 0x85c3(%rip), %rsi      # 0x3f247
callq 0x5360
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x85be(%rip), %rsi      # 0x3f25d
callq 0x5360
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0xa8fa(%rip), %rsi      # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x132b3(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x132e7(%rip), %rdi     # 0x49fc0
leaq 0xb761(%rip), %rsi      # 0x42441
callq 0x5360
movq %rax, %rdi
leaq 0x9a9b(%rip), %rsi      # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x474, %esi            # imm = 0x474
callq 0x5750
movq %rax, %rdi
movq 0x13275(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x9953(%rip), %rdi      # 0x4066a
leaq 0xb723(%rip), %rsi      # 0x42441
movl $0x474, %edx            # imm = 0x474
leaq 0xb74f(%rip), %rcx      # 0x42479
callq 0x51e0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x4, %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
andq $0xf, %rcx
shlq %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rbp), %rcx
shrl %cl, %eax
andl $0x3, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x36f23
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x36f23
movq -0x18(%rbp), %rdi
callq 0x37070
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
ja 0x36f3f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x36f66
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0x36f5a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x370d0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x37a01
jmp 0x37a20
leaq 0xaddf(%rip), %rdi      # 0x427e7
leaq 0x8f5d(%rip), %rsi      # 0x4096c
movl $0x3dc, %edx            # imm = 0x3DC
leaq 0xadda(%rip), %rcx      # 0x427f5
callq 0x51e0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
ja 0x37a30
jmp 0x37a67
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x37a5a
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
jmp 0x37a43
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x37a70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x37a91
jmp 0x37ab0
leaq 0xad4f(%rip), %rdi      # 0x427e7
leaq 0x8ecd(%rip), %rsi      # 0x4096c
movl $0x3e8, %edx            # imm = 0x3E8
leaq 0xad97(%rip), %rcx      # 0x42842
callq 0x51e0
cmpq $0x0, -0x10(%rbp)
ja 0x37b6e
movq 0x124fe(%rip), %rdi     # 0x49fc0
leaq 0x762f(%rip), %rsi      # 0x3f0f8
callq 0x5360
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x762a(%rip), %rsi      # 0x3f10e
callq 0x5360
movq %rax, %rdi
xorl %esi, %esi
callq 0x5750
movq %rax, %rdi
leaq 0x9abb(%rip), %rsi      # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x12474(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x124a8(%rip), %rdi     # 0x49fc0
leaq 0x8e4d(%rip), %rsi      # 0x4096c
callq 0x5360
movq %rax, %rdi
leaq 0x8c5c(%rip), %rsi      # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x3e9, %esi            # imm = 0x3E9
callq 0x5750
movq %rax, %rdi
movq 0x12436(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x8b14(%rip), %rdi      # 0x4066a
leaq 0x8e0f(%rip), %rsi      # 0x4096c
movl $0x3e9, %edx            # imm = 0x3E9
leaq 0xacd9(%rip), %rcx      # 0x42842
callq 0x51e0
movq -0x20(%rbp), %rdi
callq 0x2d360
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2d200
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x37b91
jmp 0x37bb0
leaq 0x91cb(%rip), %rdi      # 0x40d63
leaq 0x8dcd(%rip), %rsi      # 0x4096c
movl $0x3ec, %edx            # imm = 0x3EC
leaq 0xac97(%rip), %rcx      # 0x42842
callq 0x51e0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x10(%rax)
ja 0x37c86
movq 0x123ea(%rip), %rdi     # 0x49fc0
leaq 0x751b(%rip), %rsi      # 0x3f0f8
callq 0x5360
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x50c0
movq %rax, %rdi
leaq 0x7512(%rip), %rsi      # 0x3f10e
callq 0x5360
movq %rax, %rdi
xorl %esi, %esi
callq 0x5750
movq %rax, %rdi
leaq 0x99a3(%rip), %rsi      # 0x415b8
callq 0x5360
movq %rax, %rdi
movq 0x1235c(%rip), %rsi     # 0x49f80
callq 0x53c0
movq 0x12390(%rip), %rdi     # 0x49fc0
leaq 0x8d35(%rip), %rsi      # 0x4096c
callq 0x5360
movq %rax, %rdi
leaq 0x8b44(%rip), %rsi      # 0x4078a
callq 0x5360
movq %rax, %rdi
movl $0x3ef, %esi            # imm = 0x3EF
callq 0x5750
movq %rax, %rdi
movq 0x1231e(%rip), %rsi     # 0x49f80
callq 0x53c0
leaq 0x89fc(%rip), %rdi      # 0x4066a
leaq 0x8cf7(%rip), %rsi      # 0x4096c
movl $0x3ef, %edx            # imm = 0x3EF
leaq 0xabc1(%rip), %rcx      # 0x42842
callq 0x51e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x3cd06
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x5700
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x5550
jmp 0x3cd66
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3cd3c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x5700
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x5550
jmp 0x3cd64
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3cd56
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5450
jmp 0x3cd62
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5080
jmp 0x3cd64
jmp 0x3cd66
movq -0x10(%rbp), %rax
movq $0x40000, 0x20(%rax)    # imm = 0x40000
movq $0x40000, 0x28(%rax)    # imm = 0x40000
movb $0x0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3dac0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x3daf0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3d8e6
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0x3dbb0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3, %edx
callq 0x3dbe0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
xorl %edx, %edx
callq 0x3dc70
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x2, %esi
callq 0x3dcd0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x3dd50
cmpq $0x0, %rax
jne 0x3d963
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x3, %ecx
callq 0x3ddd0
testb $0x1, %al
jne 0x3d950
jmp 0x3d952
jmp 0x3d987
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e380
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x3dd50
movq %rax, %rdi
addq $0x8, %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0x3e3d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./bt2_locks.h
// Function: cpu_backoff::pause()
inline void pause() {
		if (count <= LOOPS_BEFORE_YIELD) {
			for (int32_t i = 0; i < count; i++) {
#ifdef __aarch64__
				__asm__ __volatile__("yield" ::: "memory");
#elif __ppc__
				__asm__ __volatile__("or 27,27,27" ::: "memory");
#elif __x86_64__
				__asm__ __volatile__("pause;");
#else
				// do nothing
#endif
			}
			count *= 2;
		} else {
			sched_yield();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x10, (%rax)
jg 0x3e4d4
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3e4c8
pause
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3e4b0
movq -0x18(%rbp), %rax
movl (%rax), %ecx
shll %ecx
movl %ecx, (%rax)
jmp 0x3e4d9
callq 0x55d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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:
subq $0x68, %rsp
movl %esi, %eax
movq %rdi, %rsi
movq %rdx, 0x8(%rsp)
movq %rsi, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x57c0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x54(%rsp), %eax
jae 0x367c
leaq 0x38(%rsp), %rdi
callq 0x57f0
vmovsd 0x189de(%rip), %xmm1    # 0x1c008
vucomisd %xmm1, %xmm0
jbe 0x363a
movl 0x34(%rsp), %eax
movl %eax, 0x64(%rsp)
jmp 0x3684
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %rdx, %rsi
callq 0x5820
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5870
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x58c0
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x360e
movl 0x54(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movb %dl, %al
movb %sil, %dl
movb %dil, %sil
movl 0x30(%rsp), %edi
movb %sil, 0x27(%rsp)
movb %dl, 0x26(%rsp)
movb %al, 0x25(%rsp)
movl %ecx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movq %r9, 0x10(%rsp)
movl 0x20(%rsp), %eax
movl 0x1c(%rsp), %ecx
imull 0x30(%rsp), %ecx
addl %ecx, %eax
shll $0x2, %eax
movl %eax, 0xc(%rsp)
movb 0x27(%rsp), %al
movb %al, 0x9(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x0, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5920
movb 0x9(%rsp), %cl
movb %cl, (%rax)
movb 0x26(%rsp), %al
movb %al, 0xa(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5920
movb 0xa(%rsp), %cl
movb %cl, (%rax)
movb 0x25(%rsp), %al
movb %al, 0xb(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5920
movb 0xb(%rsp), %cl
movb %cl, (%rax)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x3, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5920
movb $-0x1, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/./complex.hpp
// Function: complex::operator=(complex const&)
complex& operator=(const complex& rhs)
    {
        if (this == &rhs)
            return *this;
        a = rhs.a;
        b = rhs.b;
        return *this;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq -0x18(%rsp), %rax
jne 0x58e7
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x590d
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
vmovsd (%rcx), %xmm0
vmovsd %xmm0, (%rax)
movq -0x18(%rsp), %rcx
vmovsd 0x8(%rcx), %xmm0
vmovsd %xmm0, 0x8(%rax)
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: phillip-h[P]fractal-gen/./complex.hpp
// Function: complex::operator*=(complex const&)
complex& operator*=(const complex& rhs)
    {
        double tmp_a = (a * rhs.a) - (b * rhs.b);
        double tmp_b = (b * rhs.a) + (a * rhs.b);
        a = tmp_a;
        b = tmp_b;
        return *this;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
vmovsd (%rax), %xmm1
movq -0x10(%rsp), %rcx
vmovsd (%rcx), %xmm0
vmovsd 0x8(%rax), %xmm2
movq -0x10(%rsp), %rcx
vmulsd 0x8(%rcx), %xmm2, %xmm2
vmovq %xmm2, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
vmovq %rcx, %xmm2
vfmadd213sd %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
vmovsd %xmm0, -0x18(%rsp)
vmovsd 0x8(%rax), %xmm1
movq -0x10(%rsp), %rcx
vmovsd (%rcx), %xmm0
vmovsd (%rax), %xmm2
movq -0x10(%rsp), %rcx
vmulsd 0x8(%rcx), %xmm2, %xmm2
vfmadd213sd %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
vmovsd %xmm0, -0x20(%rsp)
vmovsd -0x18(%rsp), %xmm0
vmovsd %xmm0, (%rax)
vmovsd -0x20(%rsp), %xmm0
vmovsd %xmm0, 0x8(%rax)
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x6c20
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jge 0x6bb2
movl $0x4e, 0x24(%rsp)
jmp 0x6c08
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rdi
callq 0x6cd0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x6bee
cmpq $0x0, (%rsp)
jle 0x6bee
movl $0x53, 0x24(%rsp)
jmp 0x6c08
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x6ce0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x16b2b(%rip), %rsi     # 0x1d760
callq 0x3250
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x6c52
movq $-0x1, 0x20(%rsp)
jmp 0x6cbc
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3240
cmpl $0x0, %eax
je 0x6c7f
movq 0x10(%rsp), %rdi
callq 0x31d0
movq $-0x1, 0x20(%rsp)
jmp 0x6cbc
movq 0x10(%rsp), %rdi
callq 0x3030
movq %rax, 0x8(%rsp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, 0x8(%rsp)
jne 0x6ca8
movq $-0x1, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x31d0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x16a61(%rip), %rsi     # 0x1d760
callq 0x3250
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x6d1b
movl $0x4e, 0x34(%rsp)
jmp 0x6d61
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %esi
callq 0x32f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x31d0
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x6d59
movl $0x4e, 0x34(%rsp)
jmp 0x6d61
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x15ae6(%rip), %rsi     # 0x1c875
callq 0x3250
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x6da9
movl $0x4f, 0x24(%rsp)
jmp 0x6dd2
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq (%rsp), %rcx
movl $0x1, %esi
callq 0x33f0
movq (%rsp), %rdi
callq 0x31d0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)