LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/fastqreader.cpp
// Function: FastqReader::getBytes(unsigned long&, unsigned long&)
void FastqReader::getBytes(size_t& bytesRead, size_t& bytesTotal) {
	if(mZipped) {
		bytesRead = gzoffset(mZipFile);
	} else {
		bytesRead = ftell(mFile);//mFile.tellg();
	}

	// use another ifstream to not affect current reader
	ifstream is(mFilename);
	is.seekg (0, is.end);
	bytesTotal = is.tellg();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x1, 0x30(%rdi)
jne 0x39cc
movq 0x20(%r14), %rdi
callq 0x3180
jmp 0x39d5
movq 0x28(%r14), %rdi
callq 0x3030
movq %rax, (%r15)
leaq 0x8(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3470
pushq $0x2
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x3370
leaq 0x8(%rsp), %rdi
callq 0x34d0
movq %rax, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x30b0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3a1e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x34e0
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/fastqreader.cpp
// Function: FastqReader::clearLineBreaks(char*)
void FastqReader::clearLineBreaks(char* line) {

	// trim \n, \r or \r\n in the tail
	int readed = strlen(line);
	if(readed >=2 ){
		if(line[readed-1] == '\n' || line[readed-1] == '\r'){
			line[readed-1] = '\0';
			if(line[readed-2] == '\r')
				line[readed-2] = '\0';
		}
	}
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x3120
cmpl $0x2, %eax
jl 0x3a6b
leal -0x1(%rax), %ecx
movzbl (%rbx,%rcx), %edx
cmpl $0xd, %edx
je 0x3a56
cmpl $0xa, %edx
jne 0x3a6b
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movb $0x0, (%rbx,%rcx)
addl %edx, %eax
cmpb $0xd, (%rbx,%rax)
jne 0x3a6b
movb $0x0, (%rbx,%rax)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/fastqreader.cpp
// Function: FastqReader::eof()
bool FastqReader::eof() {
	if (mZipped) {
		return gzeof(mZipFile);
	} else {
		return feof(mFile);//mFile.eof();
	}
}

// Assembly:
pushq %rax
cmpb $0x1, 0x30(%rdi)
jne 0x3c0c
movq 0x20(%rdi), %rdi
callq 0x30e0
jmp 0x3c15
movq 0x28(%rdi), %rdi
callq 0x3430
testl %eax, %eax
setne %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/fastqreader.cpp
// Function: FastqReader::isZipFastq(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool FastqReader::isZipFastq(string filename) {
	if (ends_with(filename, ".fastq.gz"))
		return true;
	else if (ends_with(filename, ".fq.gz"))
		return true;
	else if (ends_with(filename, ".fasta.gz"))
		return true;
	else if (ends_with(filename, ".fa.gz"))
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x60c2(%rip), %rsi      # 0xa042
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44ab
movl %eax, %r14d
leaq 0x10(%rsp), %rdi
callq 0x3568
movb $0x1, %bpl
testb %r14b, %r14b
jne 0x404e
leaq 0x60cd(%rip), %rsi      # 0xa089
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44ab
movl %eax, %r14d
leaq 0x10(%rsp), %rdi
callq 0x3568
testb %r14b, %r14b
jne 0x404e
leaq 0x605b(%rip), %rsi      # 0xa04c
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44ab
movl %eax, %r14d
leaq 0x10(%rsp), %rdi
callq 0x3568
testb %r14b, %r14b
jne 0x404e
leaq 0x6030(%rip), %rsi      # 0xa056
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44ab
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x3568
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4065
jmp 0x4074
jmp 0x4065
jmp 0x4074
jmp 0x4065
jmp 0x4074
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3568
jmp 0x4077
movq %rax, %rbx
movq %rbx, %rdi
callq 0x34e0
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/fastqreader.cpp
// Function: FastqReader::isFastq(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool FastqReader::isFastq(string filename) {
	if (ends_with(filename, ".fastq"))
		return true;
	else if (ends_with(filename, ".fq"))
		return true;
	else if (ends_with(filename, ".fasta"))
		return true;
	else if (ends_with(filename, ".fa"))
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x5fcb(%rip), %rsi      # 0xa05d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44ab
movl %eax, %r14d
leaq 0x10(%rsp), %rdi
callq 0x3568
movb $0x1, %bpl
testb %r14b, %r14b
jne 0x4160
leaq 0x5fac(%rip), %rsi      # 0xa07a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44ab
movl %eax, %r14d
leaq 0x10(%rsp), %rdi
callq 0x3568
testb %r14b, %r14b
jne 0x4160
leaq 0x5f61(%rip), %rsi      # 0xa064
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44ab
movl %eax, %r14d
leaq 0x10(%rsp), %rdi
callq 0x3568
testb %r14b, %r14b
jne 0x4160
leaq 0x5f33(%rip), %rsi      # 0xa06b
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44ab
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x3568
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4177
jmp 0x4186
jmp 0x4177
jmp 0x4186
jmp 0x4177
jmp 0x4186
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3568
jmp 0x4189
movq %rax, %rbx
movq %rbx, %rdi
callq 0x34e0
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/fastqreader.cpp
// Function: FastqReader::test()
bool FastqReader::test(){
	FastqReader reader1("testdata/R1.fq");
	FastqReader reader2("testdata/R1.fq.gz");
	Read* r1 = NULL;
	Read* r2 = NULL;
	while(true){
		r1=reader1.read();
		r2=reader2.read();
		if(r1 == NULL || r2 == NULL)
			break;
		if(r1->mSeq.mStr != r2->mSeq.mStr){
			return false;
		}
		delete r1;
		delete r2;
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
leaq 0x5ec3(%rip), %rsi      # 0xa06f
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x44ec
leaq 0xa0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x378c
leaq 0x30(%rsp), %rdi
callq 0x3568
leaq 0x5e9b(%rip), %rsi      # 0xa07e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x378c
leaq 0x10(%rsp), %rdi
callq 0x3568
leaq 0xa0(%rsp), %rbx
leaq 0x50(%rsp), %r14
movq %rbx, %rdi
callq 0x3c1c
movq %rax, %r12
movq %r14, %rdi
callq 0x3c1c
movq %rax, %r15
testq %r12, %r12
sete %al
testq %r15, %r15
sete %bpl
orb %al, %bpl
jne 0x4283
leaq 0x20(%r12), %rdi
leaq 0x20(%r15), %rsi
callq 0x45dc
testb %al, %al
jne 0x4283
movq %r12, %rdi
callq 0x45e6
movl $0x88, %esi
movq %r12, %rdi
callq 0x3290
movq %r15, %rdi
callq 0x45e6
movl $0x88, %esi
movq %r15, %rdi
callq 0x3290
jmp 0x421d
leaq 0x50(%rsp), %rdi
callq 0x38ea
leaq 0xa0(%rsp), %rdi
callq 0x38ea
movl %ebp, %eax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3568
jmp 0x42e1
movq %rax, %rbx
jmp 0x42e1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3568
jmp 0x42ee
movq %rax, %rbx
jmp 0x42ee
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x38ea
leaq 0xa0(%rsp), %rdi
callq 0x38ea
movq %rbx, %rdi
callq 0x34e0
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/fastqreader.cpp
// Function: FastqReaderPair::FastqReaderPair(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, bool, bool)
FastqReaderPair::FastqReaderPair(string leftName, string rightName, bool hasQuality, bool phred64, bool interleaved){
	mInterleaved = interleaved;
	mLeft = new FastqReader(leftName, hasQuality, phred64);
	if(mInterleaved)
		mRight = NULL;
	else
		mRight = new FastqReader(rightName, hasQuality, phred64);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
movb %r9b, 0x10(%rdi)
pushq $0x50
popq %rdi
callq 0x3280
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x3380
movzbl %bpl, %ebp
movzbl %r12b, %r12d
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x378c
movq %rbx, (%r14)
leaq 0x28(%rsp), %rdi
callq 0x3568
cmpb $0x1, 0x10(%r14)
jne 0x436b
andq $0x0, 0x8(%r14)
jmp 0x43a3
pushq $0x50
popq %rdi
callq 0x3280
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x3380
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x378c
movq %rbx, 0x8(%r14)
leaq 0x8(%rsp), %rdi
callq 0x3568
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x43c6
jmp 0x43cd
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3568
jmp 0x43d0
movq %rax, %r14
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x3290
movq %r14, %rdi
callq 0x34e0
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/fastqreader.cpp
// Function: FastqReaderPair::~FastqReaderPair()
FastqReaderPair::~FastqReaderPair(){
	if(mLeft){
		delete mLeft;
		mLeft = NULL;
	}
	if(mRight){
		delete mRight;
		mRight = NULL;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x440a
movq %r14, %rdi
callq 0x38ea
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x3290
andq $0x0, (%rbx)
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x442b
movq %r14, %rdi
callq 0x38ea
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x3290
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/fastqreader.cpp
// Function: FastqReaderPair::read()
ReadPair* FastqReaderPair::read(){
	Read* l = mLeft->read();
	Read* r = NULL;
	if(mInterleaved)
		r = mLeft->read();
	else
		r = mRight->read();
	if(!l || !r){
		return NULL;
	} else {
		return new ReadPair(l, r);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x3c1c
movq %rax, %rbx
movzbl 0x10(%r14), %eax
xorl $0x1, %eax
movq (%r14,%rax,8), %rdi
callq 0x3c1c
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x4481
movq %rax, %r15
testq %rax, %rax
je 0x4481
pushq $0x10
popq %rdi
callq 0x3280
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x8d72
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x3290
movq %rbx, %rdi
callq 0x34e0
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/cmdline.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const& cmdline::parser::get<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const T &get(const std::string &name) const {
    if (options.count(name)==0) throw cmdline_error("there is no flag: --"+name);
    const option_with_value<T> *p=dynamic_cast<const option_with_value<T>*>(options.find(name)->second);
    if (p==NULL) throw cmdline_error("type mismatch flag '"+name+"'");
    return p->get();
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x50a4
testq %rax, %rax
je 0x4f8e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a36
movq 0x40(%rax), %rdi
testq %rdi, %rdi
je 0x4f33
leaq 0xad35(%rip), %rsi      # 0xfc48
leaq 0xadce(%rip), %rdx      # 0xfce8
xorl %ecx, %ecx
callq 0x32e0
testq %rax, %rax
je 0x4f33
addq $0x78, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x3150
movq %rax, %rbx
leaq 0x53a0(%rip), %rsi      # 0xa2e5
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x4566
leaq 0x555f(%rip), %rdx      # 0xa4b8
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x657e
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5ac0
xorl %ebp, %ebp
leaq 0xac1b(%rip), %rsi      # 0xfb98
leaq 0xb72(%rip), %rdx       # 0x5af6
movq %rbx, %rdi
callq 0x34b0
jmp 0x4fd1
pushq $0x28
popq %rdi
callq 0x3150
movq %rax, %rbx
leaq 0x5220(%rip), %rsi      # 0xa1c0
movq %rsp, %rdi
movq %r14, %rdx
callq 0x4566
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5ac0
xorl %ebp, %ebp
leaq 0xabd6(%rip), %rsi      # 0xfb98
leaq 0xb2d(%rip), %rdx       # 0x5af6
movq %rbx, %rdi
callq 0x34b0
movq %rax, %r14
movq %rsp, %rdi
callq 0x3568
jmp 0x4fe4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
jmp 0x4ff1
movq %rax, %r14
movq %rsp, %rdi
callq 0x3568
testb %bpl, %bpl
jne 0x5002
jmp 0x500a
jmp 0x4fff
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x34e0
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/cmdline.h
// Function: cmdline::parser::check(int, bool)
void check(int argc, bool ok){
    if ((argc==1 && !ok) || exist("help")){
      std::cerr<<usage();
      exit(0);
    }

    if (!ok){
      std::cerr<<error()<<std::endl<<usage();
      exit(1);
    }
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %ebp, %eax
xorb $0x1, %al
cmpl $0x1, %esi
sete %cl
testb %al, %cl
jne 0x5200
leaq 0x4fae(%rip), %rsi      # 0xa178
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x44ec
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x61a8
movl %eax, %r14d
movq %rsp, %rdi
callq 0x3568
testb %r14b, %r14b
jne 0x5200
testb %bpl, %bpl
je 0x522c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6246
movq 0xaddb(%rip), %rdi      # 0xfff0
movq %r14, %rsi
callq 0x3220
movq %rsp, %rdi
callq 0x3568
xorl %edi, %edi
callq 0x3320
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x64cc
movq 0xadaf(%rip), %rdi      # 0xfff0
movq %r14, %rsi
callq 0x3220
movq %rax, %rdi
callq 0x3140
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x6246
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x3220
leaq 0x20(%rsp), %rdi
callq 0x3568
movq %rsp, %rdi
callq 0x3568
pushq $0x1
popq %rdi
callq 0x3320
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3568
jmp 0x52a0
jmp 0x529d
jmp 0x529d
jmp 0x529d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3568
jmp 0x52ad
movq %rax, %rbx
movq %rbx, %rdi
callq 0x34e0
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/cmdline.h
// Function: cmdline::parser::set_option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void set_option(const std::string &name, const std::string &value){
    if (options.count(name)==0){
      errors.push_back("undefined option: --"+name);
      return;
    }
    if (!options[name]->set(value)){
      errors.push_back("option value is invalid: --"+name+"="+value);
      return;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x50a4
testq %rax, %rax
je 0x666d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5b6e
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
jne 0x66a0
leaq 0x3caf(%rip), %rsi      # 0xa2b7
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x4566
leaq 0x454f(%rip), %rdx      # 0xab6e
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x657e
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x6cd7
addq $0xa0, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x680c
leaq 0x8(%rsp), %rdi
callq 0x3568
leaq 0x28(%rsp), %rdi
callq 0x3568
leaq 0x48(%rsp), %rdi
jmp 0x669b
addq $0xa0, %rbx
leaq 0x3bcc(%rip), %rsi      # 0xa247
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0x4566
movq %rbx, %rdi
movq %r14, %rsi
callq 0x680c
leaq 0x8(%rsp), %rdi
callq 0x3568
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3568
jmp 0x66be
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3568
jmp 0x66cd
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x66dc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3568
movq %rbx, %rdi
callq 0x34e0
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/cmdline.h
// Function: cmdline::parser::set_option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void set_option(const std::string &name){
    if (options.count(name)==0){
      errors.push_back("undefined option: --"+name);
      return;
    }
    if (!options[name]->set()){
      errors.push_back("option needs value: --"+name);
      return;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x50a4
testq %rax, %rax
je 0x6744
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b6e
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x6773
addq $0xa0, %rbx
leaq 0x3b33(%rip), %rsi      # 0xa25c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x4566
movq %rbx, %rdi
movq %r15, %rsi
callq 0x680c
jmp 0x676b
addq $0xa0, %rbx
leaq 0x3af5(%rip), %rsi      # 0xa247
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x4566
movq %rbx, %rdi
movq %r15, %rsi
callq 0x680c
movq %rsp, %rdi
callq 0x3568
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x677f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3568
movq %rbx, %rdi
callq 0x34e0
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/cmdline.h
// Function: cmdline::parser::option_with_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::full_description(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string full_description(const std::string &desc){
      return
        desc+" ("+detail::readable_typename<T>()+
        (need?"":" [="+detail::default_value<T>(def)+"]")
        +")";
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3101(%rip), %rax      # 0xa2d3
leaq 0xa0(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x740f
leaq 0x80(%rsp), %rdi
callq 0x7447
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x73a8
movb 0x29(%r14), %bpl
cmpb $0x1, %bpl
jne 0x722f
leaq 0x392b(%rip), %rsi      # 0xab4b
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x44ec
jmp 0x7277
addq $0x58, %r14
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x3380
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3380
leaq 0x3080(%rip), %rsi      # 0xa2d6
movq %rsp, %rdi
leaq 0x60(%rsp), %rdx
callq 0x6792
leaq 0x3070(%rip), %rdx      # 0xa2da
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x657e
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x73a8
leaq 0x3044(%rip), %rdx      # 0xa2dc
leaq 0xe0(%rsp), %rsi
movq %rbx, %rdi
callq 0x657e
leaq 0xe0(%rsp), %rdi
callq 0x3568
leaq 0x20(%rsp), %rdi
callq 0x3568
testb %bpl, %bpl
jne 0x72e0
movq %rsp, %rdi
callq 0x3568
leaq 0x60(%rsp), %rdi
callq 0x3568
leaq 0x40(%rsp), %rdi
callq 0x3568
leaq 0xc0(%rsp), %rdi
callq 0x3568
leaq 0x80(%rsp), %rdi
callq 0x3568
leaq 0xa0(%rsp), %rdi
callq 0x3568
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
jmp 0x7350
movq %rax, %rbx
jmp 0x7358
movq %rax, %rbx
jmp 0x7362
jmp 0x7327
movq %rax, %rbx
jmp 0x736c
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x3568
jmp 0x7341
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3568
testb %bpl, %bpl
jne 0x736c
movq %rsp, %rdi
callq 0x3568
leaq 0x60(%rsp), %rdi
callq 0x3568
leaq 0x40(%rsp), %rdi
callq 0x3568
leaq 0xc0(%rsp), %rdi
callq 0x3568
leaq 0x80(%rsp), %rdi
callq 0x3568
leaq 0xa0(%rsp), %rdi
callq 0x3568
movq %rbx, %rdi
callq 0x34e0
movq %rax, %rbx
jmp 0x7379
movq %rax, %rbx
jmp 0x7386
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/options.cpp
// Function: Options::validate()
bool Options::validate() {
    if(in1.empty()) {
        error_exit("read1 input should be specified by --in1");
    } else {
        check_file_valid(in1);
    }

    if(in2.empty()) {
        error_exit("read2 input should be specified by --in2");
    } else {
        check_file_valid(in2);
    }

    return true;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x7657
movq %rbx, %rdi
callq 0x76e6
jmp 0x7681
leaq 0x2dd9(%rip), %rsi      # 0xa437
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x10(%rsp), %rdi
callq 0x4534
leaq 0x10(%rsp), %rdi
callq 0x3568
cmpq $0x0, 0x28(%rbx)
je 0x7696
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x76e6
jmp 0x76c0
leaq 0x2dc3(%rip), %rsi      # 0xa460
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x10(%rsp), %rdi
callq 0x4534
leaq 0x10(%rsp), %rdi
callq 0x3568
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
retq
jmp 0x76ca
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3568
jmp 0x76de
jmp 0x76db
movq %rax, %rbx
movq %rbx, %rdi
callq 0x34e0
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/util.h
// Function: check_file_valid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void check_file_valid(const  string& s) {
    if(!file_exists(s)){
        cerr << "ERROR: file '" << s << "' doesn't exist, quit now" << endl;
        exit(-1);
    }
    if(is_directory(s)){
        cerr << "ERROR: '" << s << "' is a folder, not a file, quit now" << endl;
        exit(-1);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x7765
testb %al, %al
je 0x7701
movq %rbx, %rdi
callq 0x7790
testb %al, %al
jne 0x7728
popq %rbx
retq
movq 0x88e8(%rip), %rdi      # 0xfff0
leaq 0x2d7a(%rip), %rsi      # 0xa489
callq 0x3260
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3220
leaq 0x2d71(%rip), %rsi      # 0xa497
jmp 0x774d
movq 0x88c1(%rip), %rdi      # 0xfff0
leaq 0x2d7b(%rip), %rsi      # 0xa4b1
callq 0x3260
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3220
leaq 0x2d6d(%rip), %rsi      # 0xa4ba
movq %rax, %rdi
callq 0x3260
movq %rax, %rdi
callq 0x3140
pushq $-0x1
popq %rdi
callq 0x3320
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/util.h
// Function: file_exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool file_exists(const  string& s)
{
    bool exists = false;
    if(s.length() > 0) {
        struct stat status;
        int result = stat( s.c_str(), &status );
        if(result == 0) {
            exists = true;
        }
    }
    return exists;
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x778d
subq $0x98, %rsp
movq (%rdi), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3230
testl %eax, %eax
sete %al
addq $0x98, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::Read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
Read::Read(string name, string seq, string strand, string quality, bool phred64){
	mName = name;
	mSeq = Sequence(seq);
	mStrand = strand;
	mQuality = quality;
	mHasQuality = true;
	if(phred64)
		convertPhred64To33();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, 0x4(%rsp)
movq %r8, %r13
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %rbp
movq %rsi, %r12
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x96d4
leaq 0x40(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
xorl %eax, %eax
movb %al, 0x50(%rbx)
leaq 0x60(%rbx), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x70(%rbx), %rcx
movq %rcx, 0x60(%rbx)
andq $0x0, 0x68(%rbx)
movb %al, 0x70(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3170
leaq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x3380
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x96e6
leaq 0x38(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x3330
movq %r12, %rdi
callq 0x3568
leaq 0x18(%rsp), %rdi
callq 0x3568
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x3170
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x3170
movb $0x1, 0x80(%rbx)
cmpb $0x0, 0x4(%rsp)
je 0x808f
movq %rbx, %rdi
callq 0x80e4
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x3568
jmp 0x80b7
jmp 0x80b4
movq %rax, %r15
jmp 0x80d3
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0x3568
movq 0x10(%rsp), %rdi
callq 0x3568
movq %r14, %rdi
callq 0x3568
movq %rbx, %rdi
callq 0x3568
movq %r15, %rdi
callq 0x34e0
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::Read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Read::Read(string name, string seq, string strand){
	mName = name;
	mSeq = Sequence(seq);
	mStrand = strand;
	mHasQuality = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r13
movq %rsi, %rbp
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x96d4
leaq 0x40(%rbx), %r15
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
xorl %eax, %eax
movb %al, 0x50(%rbx)
leaq 0x70(%rbx), %rcx
movq %rcx, 0x60(%rbx)
andq $0x0, 0x68(%rbx)
movb %al, 0x70(%rbx)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3170
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x3380
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x96e6
leaq 0x28(%rsp), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x3330
movq %r13, %rdi
callq 0x3568
leaq 0x8(%rsp), %rdi
callq 0x3568
movq %r15, %rdi
movq %r12, %rsi
callq 0x3170
movb $0x0, 0x80(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x3568
jmp 0x81ed
jmp 0x81ea
movq %rax, %r12
jmp 0x8206
movq %rax, %r12
leaq 0x60(%rbx), %rdi
callq 0x3568
movq %r15, %rdi
callq 0x3568
movq %r14, %rdi
callq 0x3568
movq %rbx, %rdi
callq 0x3568
movq %r12, %rdi
callq 0x34e0
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::Read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Sequence, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
Read::Read(string name, Sequence seq, string strand, string quality, bool phred64){
	mName = name;
	mSeq = seq;
	mStrand = strand;
	mQuality = quality;
	mHasQuality = true;
	if(phred64)
		convertPhred64To33();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r15
movq %rsi, %r12
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x96d4
leaq 0x40(%rbx), %rdx
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
xorl %eax, %eax
movb %al, 0x50(%rbx)
leaq 0x60(%rbx), %rbp
leaq 0x70(%rbx), %rcx
movq %rcx, 0x60(%rbx)
andq $0x0, 0x68(%rbx)
movb %al, 0x70(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq %rdx, %r12
callq 0x3170
movq %r14, %rdi
movq %r15, %rsi
callq 0x3170
movq %r12, %rdi
movq %r13, %rsi
callq 0x3170
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x3170
movb $0x1, 0x80(%rbx)
cmpb $0x0, 0xc(%rsp)
je 0x82d5
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x80e4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x8304
movq %rax, %r15
movq %rbp, %rdi
callq 0x3568
movq %r12, %rdi
callq 0x3568
movq %r14, %rdi
callq 0x3568
movq %rbx, %rdi
callq 0x3568
movq %r15, %rdi
callq 0x34e0
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::Read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Sequence, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Read::Read(string name, Sequence seq, string strand){
	mName = name;
	mSeq = seq;
	mStrand = strand;
	mHasQuality = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %rbp
movq %rsi, %r13
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x96d4
leaq 0x40(%rbx), %r12
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
xorl %eax, %eax
movb %al, 0x50(%rbx)
leaq 0x60(%rbx), %rcx
movq %rcx, (%rsp)
leaq 0x70(%rbx), %rcx
movq %rcx, 0x60(%rbx)
andq $0x0, 0x68(%rbx)
movb %al, 0x70(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3170
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3170
movq %r12, %rdi
movq %r15, %rsi
callq 0x3170
movb $0x0, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x83cd
movq %rax, %r15
movq (%rsp), %rdi
callq 0x3568
movq %r12, %rdi
callq 0x3568
movq %r14, %rdi
callq 0x3568
movq %rbx, %rdi
callq 0x3568
movq %r15, %rdi
callq 0x34e0
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::Read(Read&)
Read::Read(Read &r) {
	mName = r.mName;
	mSeq = r.mSeq;
	mStrand = r.mStrand;
	mQuality = r.mQuality;
	mHasQuality = r.mHasQuality;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x96d4
leaq 0x40(%rbx), %r12
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
xorl %eax, %eax
movb %al, 0x50(%rbx)
leaq 0x60(%rbx), %r13
leaq 0x70(%rbx), %rcx
movq %rcx, 0x60(%rbx)
andq $0x0, 0x68(%rbx)
movb %al, 0x70(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3170
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x3170
leaq 0x40(%r15), %rsi
movq %r12, %rdi
callq 0x3170
leaq 0x60(%r15), %rsi
movq %r13, %rdi
callq 0x3170
movb 0x80(%r15), %al
movb %al, 0x80(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x8499
movq %rax, %r15
movq %r13, %rdi
callq 0x3568
movq %r12, %rdi
callq 0x3568
movq %r14, %rdi
callq 0x3568
movq %rbx, %rdi
callq 0x3568
movq %r15, %rdi
callq 0x34e0
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::print()
void Read::print(){
	std::cerr << mName << endl;
	std::cerr << mSeq.mStr << endl;
	std::cerr << mStrand << endl;
	if(mHasQuality)
		std::cerr << mQuality << endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7b38(%rip), %r14      # 0xfff0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3220
movq %rax, %rdi
callq 0x3140
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x3220
movq %rax, %rdi
callq 0x3140
leaq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x3220
movq %rax, %rdi
callq 0x3140
cmpb $0x1, 0x80(%rbx)
jne 0x851e
addq $0x60, %rbx
movq 0x7ae9(%rip), %rdi      # 0xfff0
movq %rbx, %rsi
callq 0x3220
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3140
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::printFile(std::basic_ofstream<char, std::char_traits<char>>&)
void Read::printFile(ofstream& file){
	file << mName << endl;
	file << mSeq.mStr << endl;
	file << mStrand << endl;
	if(mHasQuality)
		file << mQuality << endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x3220
movq %rax, %rdi
callq 0x3140
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x3220
movq %rax, %rdi
callq 0x3140
leaq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x3220
movq %rax, %rdi
callq 0x3140
cmpb $0x1, 0x80(%r14)
jne 0x8593
addq $0x60, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3220
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3140
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::reverseComplement()
Read* Read::reverseComplement(){
	Sequence seq = ~mSeq;
	string qual;
	qual.assign(mQuality.rbegin(), mQuality.rend());
	string strand = (mStrand=="+") ? "-" : "+";
	return new Read(mName, seq, strand, qual);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %r14
leaq 0x20(%rdi), %rsi
leaq 0xd8(%rsp), %rdi
callq 0x9812
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x60(%r14), %rax
movq 0x68(%r14), %rcx
addq %rax, %rcx
leaq 0xd0(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0xc8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x8(%rsp), %rdi
callq 0x94be
leaq 0x40(%r14), %rdi
leaq 0x20f8(%rip), %rbx      # 0xa6f9
movq %rbx, %rsi
callq 0x4527
leaq 0x1be7(%rip), %rsi      # 0xa1f7
testb %al, %al
cmoveq %rbx, %rsi
leaq 0xa8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x44ec
movl $0x88, %edi
callq 0x3280
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
callq 0x3380
leaq 0x68(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x3380
leaq 0x48(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x3380
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3380
leaq 0x88(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x8216
leaq 0x28(%rsp), %rdi
callq 0x3568
leaq 0x48(%rsp), %rdi
callq 0x3568
leaq 0x68(%rsp), %rdi
callq 0x3568
leaq 0x88(%rsp), %rdi
callq 0x3568
leaq 0xa8(%rsp), %rdi
callq 0x3568
leaq 0x8(%rsp), %rdi
callq 0x3568
leaq 0xd8(%rsp), %rdi
callq 0x3568
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3568
jmp 0x8709
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3568
jmp 0x8718
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x3568
jmp 0x8727
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x3568
jmp 0x8739
movq %rax, %r14
movl $0x88, %esi
movq %rbx, %rdi
callq 0x3290
leaq 0xa8(%rsp), %rdi
callq 0x3568
jmp 0x875f
movq %rax, %r14
jmp 0x8746
jmp 0x875c
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3568
leaq 0xd8(%rsp), %rdi
callq 0x3568
movq %r14, %rdi
callq 0x34e0
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::changeToReverseComplement()
void Read::changeToReverseComplement() {
	int len = length();
	for(int i=0; i<len/2; i++) {
		// swap quality
		char tmp = mQuality[i];
		mQuality[i] = mQuality[len-i-1];
		mQuality[len-i-1] = tmp;

		// swap seq
		tmp = mSeq.mStr[i];
		mSeq.mStr[i] = mSeq.mStr[len-i-1];
		mSeq.mStr[len-i-1] = tmp;
	}

	// make complement
	for(int c=0;c<len;c++){
        char base = mSeq.mStr[c];
        switch(base){
            case 'A':
            case 'a':
                mSeq.mStr[c] = 'T';
                break;
            case 'T':
            case 't':
                mSeq.mStr[c] = 'A';
                break;
            case 'C':
            case 'c':
                mSeq.mStr[c] = 'G';
                break;
            case 'G':
            case 'g':
                mSeq.mStr[c] = 'C';
                break;
            default:
                mSeq.mStr[c] = 'N';
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x972e
movl %eax, %ecx
pushq $0x2
popq %rsi
cltd
idivl %esi
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
leal -0x1(%rcx), %esi
cmpq %rdx, %rax
je 0x87e2
movq 0x60(%r14), %rdi
movb (%rdi,%rdx), %r8b
movslq %esi, %rsi
movb (%rdi,%rsi), %r9b
movb %r9b, (%rdi,%rdx)
movq 0x60(%r14), %rdi
movb %r8b, (%rdi,%rsi)
movq 0x20(%r14), %rdi
movb (%rdi,%rdx), %r8b
movb (%rdi,%rsi), %r9b
movb %r9b, (%rdi,%rdx)
movq 0x20(%r14), %rdi
movb %r8b, (%rdi,%rsi)
incq %rdx
decl %esi
jmp 0x87a3
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
cmpq %rax, %rcx
je 0x883b
movq (%rbx), %rdx
movzbl (%rdx,%rax), %edi
movb $0x54, %sil
cmpl $0x41, %edi
je 0x8832
cmpl $0x43, %edi
je 0x8825
cmpl $0x47, %edi
je 0x882a
cmpl $0x74, %edi
je 0x8820
cmpl $0x61, %edi
je 0x8832
cmpl $0x63, %edi
je 0x8825
cmpl $0x67, %edi
je 0x882a
cmpl $0x54, %edi
jne 0x882f
movb $0x41, %sil
jmp 0x8832
movb $0x47, %sil
jmp 0x8832
movb $0x43, %sil
jmp 0x8832
movb $0x4e, %sil
movb %sil, (%rdx,%rax)
incq %rax
jmp 0x87e9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::resize(int)
void Read::resize(int len) {
	if(len > length() || len<0)
		return ;
	mSeq.mStr.resize(len);
	mQuality.resize(len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x972e
testl %ebp, %ebp
js 0x8895
cmpl %ebp, %eax
jl 0x8895
movl %ebp, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x3390
addq $0x60, %rbx
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3390
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::lastIndex[abi:cxx11]()
string Read::lastIndex(){
	int len = mName.length();
	if(len<5)
		return "";
	for(int i=len-3;i>=0;i--){
		if(mName[i]==':' || mName[i]=='+'){
			return mName.substr(i+1, len-i);
		}
	}
	return "";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x4, %eax
jg 0x894c
leaq 0x2206(%rip), %rsi      # 0xab4b
leaq 0xf(%rsp), %rdx
jmp 0x8994
leal -0x3(%rax), %edi
movq (%rsi), %rcx
leal -0x2(%rax), %edx
movslq %edi, %rdi
testl %edi, %edi
js 0x8988
movl %edi, %r8d
movzbl (%rcx,%r8), %r8d
cmpl $0x3a, %r8d
je 0x8978
cmpl $0x2b, %r8d
je 0x8978
decq %rdx
decq %rdi
jmp 0x8958
movslq %eax, %rcx
subq %rdi, %rcx
movq %rbx, %rdi
callq 0x32a0
jmp 0x899c
leaq 0x21bc(%rip), %rsi      # 0xab4b
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x44ec
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::firstIndex[abi:cxx11]()
string Read::firstIndex(){
	int len = mName.length();
	int end = len;
	if(len<5)
		return "";
	for(int i=len-3;i>=0;i--){
		if(mName[i]=='+')
			end = i-1;
		if(mName[i]==':'){
			return mName.substr(i+1, end-i);
		}
	}
	return "";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %edi
cmpl $0x4, %edi
jg 0x89c4
leaq 0x218e(%rip), %rsi      # 0xab4b
leaq 0xf(%rsp), %rdx
jmp 0x8a1d
leal -0x3(%rdi), %ecx
movq (%rsi), %rax
leal -0x2(%rdi), %edx
incq %rdx
movslq %ecx, %rcx
leal -0x4(%rdi), %r8d
testl %ecx, %ecx
js 0x8a11
movl %edi, %r9d
movl %ecx, %edi
movb (%rax,%rdi), %r10b
cmpb $0x2b, %r10b
movl %r9d, %edi
cmovel %r8d, %edi
decq %rdx
decq %rcx
decl %r8d
cmpb $0x3a, %r10b
jne 0x89d7
movslq %r9d, %rax
notq %rcx
addq %rax, %rcx
movq %rbx, %rdi
callq 0x32a0
jmp 0x8a25
leaq 0x2133(%rip), %rsi      # 0xab4b
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x44ec
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::lowQualCount(int)
int Read::lowQualCount(int qual){
	int count = 0;
	for(int q=0;q<mQuality.size();q++){
		if(mQuality[q] < qual + 33)
			count++;
	}
	return count;
}

// Assembly:
movq 0x60(%rdi), %rcx
movq 0x68(%rdi), %rdx
addl $0x21, %esi
xorl %edi, %edi
xorl %eax, %eax
cmpq %rdi, %rdx
je 0x8a59
movsbl (%rcx,%rdi), %r8d
xorl %r9d, %r9d
cmpl %r8d, %esi
setg %r9b
addl %r9d, %eax
incq %rdi
jmp 0x8a3d
retq
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::toString[abi:cxx11](bool)
string Read::toString(bool lineBreak) {
	if(lineBreak)
		return mName + "\n" + mSeq.mStr + "\n" + mStrand + "\n" + mQuality + "\n";
	else 
		return mName + mSeq.mStr + mStrand + mQuality;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x8b47
leaq 0x20cf(%rip), %rdx      # 0xab4a
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x740f
leaq 0x20(%r14), %rdx
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x6cd7
leaq 0x20a4(%rip), %rdx      # 0xab4a
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x657e
leaq 0x40(%r14), %rdx
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x6cd7
leaq 0x2078(%rip), %rdx      # 0xab4a
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x657e
addq $0x60, %r14
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x6cd7
leaq 0x204b(%rip), %rdx      # 0xab4a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x657e
movq %rsp, %rdi
callq 0x3568
leaq 0x20(%rsp), %rdi
callq 0x3568
leaq 0x80(%rsp), %rdi
callq 0x3568
leaq 0x60(%rsp), %rdi
callq 0x3568
leaq 0x40(%rsp), %rdi
callq 0x3568
leaq 0xa0(%rsp), %rdi
jmp 0x8b89
leaq 0x20(%r14), %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x94f2
leaq 0x40(%r14), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x6cd7
addq $0x60, %r14
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6cd7
movq %rsp, %rdi
callq 0x3568
leaq 0x20(%rsp), %rdi
callq 0x3568
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3568
jmp 0x8bae
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3568
jmp 0x8bbd
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x3568
jmp 0x8bcf
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x3568
jmp 0x8beb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3568
jmp 0x8c02
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3568
leaq 0xa0(%rsp), %rdi
jmp 0x8c07
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3568
movq %rbx, %rdi
callq 0x34e0
movq %rax, %rbx
jmp 0x8bf5
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: Read::test()
bool Read::test(){
	Read r("@NS500713:64:HFKJJBGXY:1:11101:20469:1097 1:N:0:TATAGCCT+GGTCCCGA",
		"CTCTTGGACTCTAACACTGTTTTTTCTTATGAAAACACAGGAGTGATGACTAGTTGAGTGCATTCTTATGAGACTCATAGTCATTCTATGATGTAGTTTTCCTTAGGAGGACATTTTTTACATGAAATTATTAACCTAAATAGAGTTGATC",
		"+",
		"AAAAA6EEEEEEEEEEEEEEEEE#EEEEEEEEEEEEEEEEE/EEEEEEEEEEEEEEEEAEEEAEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE<EEEEAEEEEEEEEEEEEEEEAEEE/EEEEEEEEEEAAEAEAAEEEAEEAA");
	string idx = r.lastIndex();
	return idx == "GGTCCCGA";
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
leaq 0x1ad1(%rip), %rsi      # 0xa6fb
leaq 0x70(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x44ec
leaq 0x1afa(%rip), %rsi      # 0xa73d
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x44ec
leaq 0x1aa0(%rip), %rsi      # 0xa6f9
leaq 0x30(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x44ec
leaq 0x1b66(%rip), %rsi      # 0xa7d5
leaq 0x10(%rsp), %rdi
leaq 0xd(%rsp), %rdx
callq 0x44ec
leaq 0xb0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
xorl %r9d, %r9d
callq 0x7fa4
leaq 0x10(%rsp), %rdi
callq 0x3568
leaq 0x30(%rsp), %rdi
callq 0x3568
leaq 0x50(%rsp), %rdi
callq 0x3568
leaq 0x70(%rsp), %rdi
callq 0x3568
leaq 0x90(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x892e
leaq 0x1a4e(%rip), %rsi      # 0xa734
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0x4527
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3568
leaq 0xb0(%rsp), %rdi
callq 0x45e6
movl %ebp, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x45e6
jmp 0x8d6a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3568
jmp 0x8d3d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3568
jmp 0x8d4c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3568
jmp 0x8d5b
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x3568
jmp 0x8d6a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x34e0
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/read.cpp
// Function: ReadPair::~ReadPair()
ReadPair::~ReadPair(){
	if(mLeft){
		delete mLeft;
		mLeft = NULL;
	}
	if(mRight){
		delete mRight;
		mRight = NULL;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x8da2
movq %r14, %rdi
callq 0x45e6
movl $0x88, %esi
movq %r14, %rdi
callq 0x3290
andq $0x0, (%rbx)
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x8dc5
movq %r14, %rdi
callq 0x45e6
movl $0x88, %esi
movq %r14, %rdi
callq 0x3290
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/sequence.cpp
// Function: Sequence::reverseComplement()
Sequence Sequence::reverseComplement(){
    string str(mStr.length(), 0);
    for(int c=0;c<mStr.length();c++){
        char base = mStr[c];
        switch(base){
            case 'A':
            case 'a':
                str[mStr.length()-c-1] = 'T';
                break;
            case 'T':
            case 't':
                str[mStr.length()-c-1] = 'A';
                break;
            case 'C':
            case 'c':
                str[mStr.length()-c-1] = 'G';
                break;
            case 'G':
            case 'g':
                str[mStr.length()-c-1] = 'C';
                break;
            default:
                str[mStr.length()-c-1] = 'N';
        }
    }
    return Sequence(str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rsp, %rdi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x32f0
pushq $-0x1
popq %rax
movq 0x8(%r14), %rcx
cmpq %r15, %rcx
jbe 0x97b6
movq (%r14), %rdx
movzbl (%rdx,%r15), %esi
movb $0x54, %dl
cmpl $0x41, %esi
je 0x97a7
cmpl $0x43, %esi
je 0x979d
cmpl $0x47, %esi
je 0x97a1
cmpl $0x74, %esi
je 0x9799
cmpl $0x61, %esi
je 0x97a7
cmpl $0x63, %esi
je 0x979d
cmpl $0x67, %esi
je 0x97a1
cmpl $0x54, %esi
jne 0x97a5
movb $0x41, %dl
jmp 0x97a7
movb $0x47, %dl
jmp 0x97a7
movb $0x43, %dl
jmp 0x97a7
movb $0x4e, %dl
addq (%rsp), %rcx
movb %dl, (%rax,%rcx)
incq %r15
decq %rax
jmp 0x975e
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x3380
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x96e6
leaq 0x20(%rsp), %rdi
callq 0x3568
movq %rsp, %rdi
callq 0x3568
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3568
jmp 0x9801
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3568
movq %rbx, %rdi
callq 0x34e0
nop
// File: /workspace/github_c_makefile_star2_O2/OpenGene[P]pecheck/src/sequence.cpp
// Function: Sequence::test()
bool Sequence::test(){
    Sequence s("AAAATTTTCCCCGGGG");
    Sequence rc = ~s;
    if (s.mStr != "AAAATTTTCCCCGGGG" ){
        cerr << "Failed in reverseComplement() expect AAAATTTTCCCCGGGG, but get "<< s.mStr;
        return false;
    }
    if (rc.mStr != "CCCCGGGGAAAATTTT" ){
        cerr << "Failed in reverseComplement() expect CCCCGGGGAAAATTTT, but get "<< rc.mStr;
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x68, %rsp
leaq 0x126a(%rip), %rsi      # 0xaa97
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x44ec
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x96e6
leaq 0x48(%rsp), %rdi
callq 0x3568
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x9732
leaq 0x122c(%rip), %rsi      # 0xaa97
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x952a
testb %al, %al
je 0x9891
movq 0x676d(%rip), %rdi      # 0xfff0
leaq 0x121e(%rip), %rsi      # 0xaaa8
callq 0x3260
jmp 0x98bf
leaq 0x1250(%rip), %rsi      # 0xaae8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x952a
movb $0x1, %bpl
testb %al, %al
je 0x98cc
movq 0x673d(%rip), %rdi      # 0xfff0
leaq 0x123f(%rip), %rsi      # 0xaaf9
callq 0x3260
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3220
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0x3568
leaq 0x28(%rsp), %rdi
callq 0x3568
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x990a
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x990f
movq %rax, %rbx
jmp 0x9914
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3568
leaq 0x28(%rsp), %rdi
callq 0x3568
movq %rbx, %rdi
callq 0x34e0