LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/contig.cpp
// Function: Contig::Contig(Contig const&)
Contig::Contig( const Contig& rhs ) : reads(rhs.reads), contig(rhs.contig), contig_id(rhs.contig_id){
  extension = new Extension( reads, extend_len );
  extension->matches = rhs.extension->matches;
  extension->ATCG = rhs.extension->ATCG;
  extension->missed_bp = rhs.extension->missed_bp;
  extension->missed_bp_tot = rhs.extension->missed_bp_tot;
  extension->missed_bp_avg = rhs.extension->missed_bp_avg;
  extension->start = rhs.extension->start;
  extension->back = rhs.extension->back;
  extension->contig = rhs.extension->contig;
  extension->exten_seq = rhs.extension->exten_seq;
  extension->pos_mult = rhs.extension->pos_mult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %rax
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x4410
leaq 0x30(%r15), %r14
leaq 0x30(%r12), %rsi
movq %r14, %rdi
callq 0x4410
movl $0xd8, %edi
callq 0x4320
movq %rax, %r13
movq (%r15), %rsi
leaq 0x1626a(%rip), %rax     # 0x1b620
movl (%rax), %edx
movq %r13, %rdi
callq 0xf364
movq %r13, 0x8(%r15)
movq 0x8(%r12), %rsi
movq %r13, %rdi
callq 0x586a
movq 0x8(%r12), %rsi
addq $0x50, %rsi
movq 0x8(%r15), %rdi
addq $0x50, %rdi
callq 0x58aa
movq 0x8(%r12), %rsi
addq $0x68, %rsi
movq 0x8(%r15), %rdi
addq $0x68, %rdi
callq 0x597c
movq 0x8(%r12), %rsi
movl 0xd0(%rsi), %eax
movq 0x8(%r15), %rdi
movl %eax, 0xd0(%rdi)
movl 0xd4(%rsi), %eax
movl %eax, 0xd4(%rdi)
movl 0x80(%rsi), %eax
movl %eax, 0x80(%rdi)
movb 0x84(%rsi), %al
movb %al, 0x84(%rdi)
movl $0x88, %eax
addq %rax, %rsi
addq %rax, %rdi
callq 0x41d0
movl $0xa8, %edi
movq 0x8(%r12), %rsi
addq %rdi, %rsi
addq 0x8(%r15), %rdi
callq 0x41d0
movq 0x8(%r12), %rax
movl 0xc8(%rax), %eax
movq 0x8(%r15), %rcx
movl %eax, 0xc8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r13, %rdi
callq 0x42f0
jmp 0x5495
movq %rax, %r15
jmp 0x549d
movq %rax, %r15
movq %r14, %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4160
movq %r15, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/process.cpp
// Function: Process::Process()
Process::Process(){
  outfile = "afin_out";
  readsfiles = "";
  contigsfiles = "";
  reads = 0;
  contigs = 0;
  fuse = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
xorl %eax, %eax
movb %al, 0x28(%rdi)
leaq 0x38(%rdi), %r15
leaq 0x48(%rdi), %rcx
movq %rcx, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movb %al, 0x48(%rdi)
leaq 0x58(%rdi), %r12
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0xc8d6(%rip), %rsi      # 0x12c09
movq %rbx, %rdi
callq 0x4600
leaq 0xcc0a(%rip), %rsi      # 0x12f4c
movq %r15, %rdi
callq 0x4600
leaq 0xcbfb(%rip), %rsi      # 0x12f4c
movq %r12, %rdi
callq 0x4600
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x4160
movq %r15, %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4160
movq %r14, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/process.cpp
// Function: Process::thread_worker(Queue<int>&, unsigned int)
void Process::thread_worker( Queue<int>& q, unsigned int id) {
  for (;;) {
    auto item = q.pop();
    if( item == -1 ){
      break;
    }
    else{
      contigs->get_contig_ref(item)->extend( false );
      contigs->get_contig_ref(item)->extend( true );
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r15
movq %rbx, %rdi
callq 0x72ba
cmpl $-0x1, %eax
je 0x6f69
movl %eax, %r12d
movq 0x8(%r14), %rdi
movl %eax, %esi
callq 0x107ca
movq %rax, %rdi
xorl %esi, %esi
callq 0x556c
movq 0x8(%r14), %rdi
movl %r12d, %esi
callq 0x107ca
movq %rax, %rdi
movl %r15d, %esi
callq 0x556c
jmp 0x6f2b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/./process.hpp
// Function: Queue<int>::push(int const&)
void Queue<T>::push( const T& item ){
  unique_lock<mutex> mlock( mtx );
  qu.push( item );
  mlock.unlock();
  cv.notify_one();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rdi), %rsi
leaq -0x20(%rbp), %rdi
callq 0x7b02
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ba0
leaq -0x20(%rbp), %rdi
callq 0x7b22
addq $0x78, %rbx
movq %rbx, %rdi
callq 0x4190
leaq -0x20(%rbp), %rdi
callq 0x7b52
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x7b52
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/./process.hpp
// Function: Queue<int>::pop()
T Queue<T>::pop(){
  unique_lock<mutex> mlock( mtx );
  while( qu.empty() ){
    cv.wait(mlock);
  }

  auto item = qu.front();
  qu.pop();
  return item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x50(%rdi), %rsi
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x7b02
leaq 0x78(%rbx), %r15
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
jne 0x72f5
movq %r15, %rdi
movq %r14, %rsi
callq 0x4100
jmp 0x72de
movl (%rax), %r14d
movq %rbx, %rdi
callq 0x7ede
leaq -0x28(%rbp), %rdi
callq 0x7b52
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/read.cpp
// Function: Read::Read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, bool)
Read::Read( string read, int match, bool rev ){
  this->read = read;
  start = match;
  misses = 0;
  this->rev = rev;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
leaq 0x8(%rdi), %r12
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %r12, %rdi
callq 0x41d0
movl %r15d, (%r14)
andl $0x0, 0x4(%r14)
movb %bl, 0x28(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/read.cpp
// Function: Read::Read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
Read::Read( string read, int match ){
  this->read = read;
  start = match;
  misses = 0;
  rev = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %rbx, %rdi
callq 0x41d0
movl %r15d, (%r14)
andl $0x0, 0x4(%r14)
movb $0x0, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4160
movq %r14, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/read.cpp
// Function: Read::get_pos(int, bool)
char Read::get_pos( int pos, bool back ){
  if( back ){
    int read_pos = pos - start;
    if( read_pos >=0 && read_pos < read.length() ){
      return read[ read_pos ];
    }
  }
  else{
    int len = read.length();
    int read_pos = len - start + pos;
    if( read_pos >= 0 && read_pos < len ){
      return read[ read_pos ];
    }
  }

  return -1; 
}

// Assembly:
testl %edx, %edx
je 0x8001
subl (%rdi), %esi
movb $-0x1, %al
js 0x8000
cmpq %rsi, 0x10(%rdi)
ja 0x801c
retq
movl 0x10(%rdi), %eax
movl %eax, %ecx
subl (%rdi), %ecx
addl %esi, %ecx
sets %dl
cmpl %eax, %ecx
setge %sil
movb $-0x1, %al
orb %dl, %sil
jne 0x8000
movl %ecx, %esi
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movb (%rax,%rsi), %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/revcomp.cpp
// Function: revcomp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string revcomp( string str ){
  string rc(str);
  int len = str.length();
  int i;

  for( i=0; i<len; i++ ){
    switch( str[i] ){
      case 'A':
        rc[ len - i - 1 ] = 'T';
        break;
      case 'T':
        rc[ len - i - 1 ] = 'A';
        break;
      case 'G':
        rc[ len - i - 1 ] = 'C';
        break;
      case 'C':
        rc[ len - i - 1 ] = 'G';
        break;
      case 'N':
        rc[ len - i - 1 ] = 'N';
        break;
      case 't':
        rc[ len - i - 1 ] = 'A';
        break;
      case 'a':
        rc[ len - i - 1 ] = 'T';
        break;
      case 'c':
        rc[ len - i - 1 ] = 'G';
        break;
      case 'g':
        rc[ len - i - 1 ] = 'C';
        break;
      default:
        printf( "Incorrect character present in string.\n" );
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movabsq $-0x100000000, %rbx     # imm = 0xFFFFFFFF00000000
movq %rdi, -0x30(%rbp)
callq 0x4410
movq 0x8(%r14), %r13
xorl %r15d, %r15d
testl %r13d, %r13d
movl $0x0, %r12d
cmovgl %r13d, %r12d
shlq $0x20, %r13
addq %rbx, %r13
cmpq %r15, %r12
je 0x8121
movq (%r14), %rax
movzbl (%rax,%r15), %eax
cmpl $0x74, %eax
je 0x80bd
cmpl $0x43, %eax
je 0x80e5
cmpl $0x47, %eax
je 0x80d1
cmpl $0x4e, %eax
je 0x80f9
cmpl $0x54, %eax
je 0x80bd
cmpl $0x61, %eax
je 0x80a9
cmpl $0x63, %eax
je 0x80e5
cmpl $0x67, %eax
je 0x80d1
cmpl $0x41, %eax
jne 0x810d
movq %r13, %rax
sarq $0x20, %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movb $0x54, (%rcx,%rax)
jmp 0x8119
movq %r13, %rax
sarq $0x20, %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movb $0x41, (%rcx,%rax)
jmp 0x8119
movq %r13, %rax
sarq $0x20, %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movb $0x43, (%rcx,%rax)
jmp 0x8119
movq %r13, %rax
sarq $0x20, %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movb $0x47, (%rcx,%rax)
jmp 0x8119
movq %r13, %rax
sarq $0x20, %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movb $0x4e, (%rcx,%rax)
jmp 0x8119
leaq 0xadb1(%rip), %rdi      # 0x12ec5
callq 0x44d0
incq %r15
jmp 0x8068
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/log.cpp
// Function: Log::Inst()
Log* Log::Inst(){
  if( !p_Inst ){
    p_Inst = new Log;
    // initialize timer
    time( &timer );
  }

  return p_Inst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x1348c(%rip), %rax     # 0x1b698
testq %rax, %rax
jne 0x8240
movl $0x210, %edi            # imm = 0x210
callq 0x4320
movq %rax, %rbx
movq %rax, %rdi
callq 0x4370
movq %rbx, 0x1346b(%rip)     # 0x1b698
leaq 0x1346c(%rip), %rdi     # 0x1b6a0
callq 0x42e0
movq 0x13458(%rip), %rax     # 0x1b698
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x42f0
movq %r14, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/log.cpp
// Function: Log::open_log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::open_log( string logfile ){
  log_fs.open( logfile, fstream::out | fstream::trunc );

  // ensure logfile has opened properly
  if( log_fs.fail() ){
    fprintf( stderr, "Error: Could not open logfile '%s'. Check permissions for logfile location", logfile.c_str() );
    exit(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x30
popq %rdx
callq 0x4400
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x8281
popq %rbx
popq %r14
popq %rbp
retq
movq 0x12d40(%rip), %rax     # 0x1afc8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0xac57(%rip), %rsi      # 0x12eec
xorl %eax, %eax
callq 0x4450
pushq $0x1
popq %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/log.cpp
// Function: Log::get_time[abi:cxx11]()
string Log::get_time(){
  string curr_time = "";
  char buffer[100];

  int t_now = difftime( time(0), timer );   // get time now
  
  int t_hour = t_now / 3600;
  t_now = t_now % 3600;

  int t_min = t_now / 60;
  t_now = t_now % 60;

  // format time in xxx:xx:xx
  sprintf( buffer, "%d:%.2d:%.2d", t_hour, t_min, t_now);
  curr_time = buffer;

  return curr_time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0xac21(%rip), %rsi      # 0x12f4c
leaq -0x80(%rbp), %rdx
callq 0x4120
xorl %edi, %edi
callq 0x42e0
movq 0x1335e(%rip), %rsi     # 0x1b6a0
movq %rax, %rdi
callq 0x41a0
cvttsd2si %xmm0, %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %eax, %r9d
movl %edx, %eax
movw $0x3c, %cx
cwtd
idivw %cx
movswl %ax, %ecx
movswl %dx, %r8d
leaq 0xabdb(%rip), %rsi      # 0x12f4d
leaq -0x80(%rbp), %r14
movq %r14, %rdi
movl %r9d, %edx
xorl %eax, %eax
callq 0x4070
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4600
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4160
movq %r14, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/log.cpp
// Function: Log::log_it(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::log_it( string note ){
  if( log_output ){
    log_fs << get_time() << "\t" << note << endl;
  }
  if( screen_output ){
    cout << get_time() << "\t" << note << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x1328f(%rip), %rax     # 0x1b654
cmpl $0x0, (%rax)
je 0x8413
movq %rdi, %r14
addq $0x10, %r14
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x8316
movq %r14, %rdi
movq %r15, %rsi
callq 0x42c0
leaq 0xab5c(%rip), %rsi      # 0x12f4b
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movq %rbx, %rsi
callq 0x42c0
movq %rax, %rdi
callq 0x4180
leaq -0x38(%rbp), %rdi
callq 0x4160
leaq 0x13236(%rip), %rax     # 0x1b650
cmpl $0x0, (%rax)
je 0x8465
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x8316
movq 0x12b8e(%rip), %rdi     # 0x1afc0
movq %r14, %rsi
callq 0x42c0
leaq 0xab0a(%rip), %rsi      # 0x12f4b
movq %rax, %rdi
callq 0x4310
movq %rax, %rdi
movq %rbx, %rsi
callq 0x42c0
movq %rax, %rdi
callq 0x4180
leaq -0x38(%rbp), %rdi
callq 0x4160
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8472
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/gzip.cpp
// Function: Gzip::Gzip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Gzip::Gzip( string filename ): BUFF_SIZE(16384), buffer(""), filename(filename){
  fp = fopen( filename.c_str(), "rb" );
  
  /* allocate inflate state */
  zs.zalloc = Z_NULL;
  zs.zfree = Z_NULL;
  zs.opaque = Z_NULL;
  zs.avail_in = 0;
  zs.avail_out = BUFF_SIZE;
  zs.next_in = Z_NULL;
  status = inflateInit2(&zs, 32+MAX_WBITS);

  if (status != Z_OK)
    zerr();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r12
movq %rdi, %r14
leaq 0x127e0(%rip), %rax     # 0x1ad28
movq %rax, (%rdi)
movl $0x4000, 0x8(%rdi)      # imm = 0x4000
leaq 0x10(%rdi), %rbx
leaq 0xa9ef(%rip), %rsi      # 0x12f4c
leaq -0x21(%rbp), %rdx
movq %rbx, %rdi
callq 0x4120
leaq 0xa8(%r14), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x4410
movq (%r12), %rdi
leaq 0xaa01(%rip), %rsi      # 0x12f87
callq 0x4360
movq %rax, 0xa0(%r14)
andl $0x0, 0x38(%r14)
leaq 0x30(%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r14)
andq $0x0, 0x80(%r14)
movl 0x8(%r14), %eax
movl %eax, 0x50(%r14)
andq $0x0, 0x30(%r14)
leaq 0xa9cb(%rip), %rdx      # 0x12f8a
pushq $0x2f
popq %rsi
pushq $0x70
popq %rcx
callq 0x42a0
movl %eax, 0xc(%r14)
testl %eax, %eax
je 0x85da
movq %r14, %rdi
callq 0x8608
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x85f7
movq %rax, %r14
movq %r15, %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4160
movq %r14, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/gzip.cpp
// Function: Gzip::fill_buffer()
void Gzip::fill_buffer(){
  unsigned char in[BUFF_SIZE];
  unsigned char out[BUFF_SIZE];
  int next_pos = 0;
  unsigned int char_in = 0;

  // read in data from gzipd file
  zs.avail_in = fread(in, 1, BUFF_SIZE, fp);

  // handle read errors
  if (ferror(fp)) {
    (void)inflateEnd(&zs);
    status = Z_ERRNO;
    return;
  }

  // handle data error
  if (zs.avail_in == 0){
    status = Z_DATA_ERROR;
    return;
  }

  // set next_in pointer to data from fread
  zs.next_in = in;
  do{
    zs.avail_out = BUFF_SIZE;
    zs.next_out = out;

    // decompress data
    status = inflate(&zs, Z_NO_FLUSH);

    // check for errors
    switch (status) {
      case Z_BUF_ERROR:
        status = Z_OK;
        return;
      case Z_NEED_DICT:
        status = Z_DATA_ERROR;     /* and fall through */
      case Z_DATA_ERROR:
      case Z_MEM_ERROR:
        (void)inflateEnd(&zs);
        zerr();
        return;
    }

    int have = BUFF_SIZE - zs.avail_out;
    char out_str[have+1];
    strncpy( out_str, (char*)out, have );
    out_str[have] = '\0';

    // append data to buffer
    buffer.append( out_str );
  }while( zs.avail_out == 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq 0x8(%rdi), %rdx
movl %edx, %eax
movq %rsp, %r12
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
movq %rsp, %r14
subq %rax, %r14
movq %r14, %rsp
movq 0xa0(%rdi), %rcx
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x44a0
movq %rax, %r13
leaq 0x30(%rbx), %r15
movl %r13d, 0x38(%rbx)
movq 0xa0(%rbx), %rdi
callq 0x45e0
testl %eax, %eax
je 0x8932
movq %r15, %rdi
callq 0x4340
orl $-0x1, 0xc(%rbx)
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r13d, %r13d
je 0x89c5
movq %r12, 0x30(%rbx)
leaq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %r15, -0x38(%rbp)
movl 0x8(%rbx), %eax
movl %eax, 0x50(%rbx)
movq %r14, 0x48(%rbx)
movq %r15, %rdi
xorl %esi, %esi
callq 0x4280
movl %eax, 0xc(%rbx)
leal 0x4(%rax), %ecx
cmpl $0x2, %ecx
jb 0x89e1
cmpl $0x2, %eax
je 0x89da
cmpl $-0x5, %eax
je 0x89d1
movl 0x8(%rbx), %eax
subl 0x50(%rbx), %eax
movq %rsp, %r15
leal 0x1(%rax), %ecx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %r13
subq %rcx, %r13
movq %r13, %rsp
movslq %eax, %r12
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x41b0
movb $0x0, (%r12,%r13)
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x45f0
movq %r15, %rsp
movq -0x38(%rbp), %r15
cmpl $0x0, 0x50(%rbx)
je 0x894b
jmp 0x8923
movl $0xfffffffd, 0xc(%rbx)  # imm = 0xFFFFFFFD
jmp 0x8923
andl $0x0, 0xc(%rbx)
jmp 0x8923
movl $0xfffffffd, 0xc(%rbx)  # imm = 0xFFFFFFFD
movq %r15, %rdi
callq 0x4340
movq %rbx, %rdi
callq 0x8608
jmp 0x8923
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/gzip.cpp
// Function: Gzip::getline[abi:cxx11]()
string Gzip::getline(){
  size_t next_pos = 0;
  string line( "" );

  // check if buffer has a full line in it, if not, fill_buffer
  while((next_pos = buffer.find( '\n' )) == string::npos && status == Z_OK ){
    fill_buffer();
  }

  // if last line in file, store results for return
  if( status == Z_STREAM_END && next_pos == string::npos ){
    line = buffer;
    buffer = "";

    (void)inflateEnd(&zs);
  }
  // protect against errors
  else if( status != Z_OK && status != Z_STREAM_END ){
    (void)inflateEnd(&zs);
    zerr();
    return "";
  }
  // parse out next line in buffer
  else{
    line = buffer.substr( 0, next_pos );
    buffer.erase( 0, next_pos+1 );
  }

  return line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa538(%rip), %rsi      # 0x12f4c
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x4120
leaq 0x10(%r14), %r15
pushq $0xa
popq %r13
movq %r15, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x43d0
movq %rax, %r12
movl 0xc(%r14), %eax
cmpq $-0x1, %r12
jne 0x8a51
testl %eax, %eax
jne 0x8a51
movq %r14, %rdi
callq 0x88b6
jmp 0x8a29
cmpq $-0x1, %r12
setne %cl
cmpl $0x1, %eax
setne %dl
orb %cl, %dl
jne 0x8a8b
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x41d0
leaq 0xa4d7(%rip), %rsi      # 0x12f4c
movq %r15, %rdi
callq 0x4600
addq $0x30, %r14
movq %r14, %rdi
callq 0x4340
jmp 0x8ac9
cmpl $0x2, %eax
jae 0x8b07
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x4330
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %r14
movq %r14, %rsi
callq 0x4390
movq %r14, %rdi
callq 0x4160
incq %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x40b0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x8aea
movq %rdx, (%rbx)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x8af0
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, -0x48(%rbp)
andq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
jmp 0x8b2b
leaq 0x30(%r14), %rdi
callq 0x4340
movq %r14, %rdi
callq 0x8608
leaq 0xa42d(%rip), %rsi      # 0x12f4c
leaq -0x68(%rbp), %rdx
movq %rbx, %rdi
callq 0x4120
leaq -0x48(%rbp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8b4c
jmp 0x8b4c
jmp 0x8b4c
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/fusion.cpp
// Function: Fusion::get_fused_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Fusion::get_fused_id( string contig1_id, string contig2_id ){
  if( contig1_id.length() >= 5 && contig1_id.compare( 0, 5, "fused" ) == 0 ){
    contig1_id = contig1_id.substr( 5 );
  }
  
  if( contig1_id.length() >= 5 && contig2_id.compare( 0, 5, "fused" ) == 0 ){
    contig2_id = contig2_id.substr( 5 );
  }
    
  return contig1_id+"_<>_"+contig2_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
cmpq $0x5, 0x8(%rdx)
jb 0x8c26
leaq 0x9e18(%rip), %rcx      # 0x129be
pushq $0x5
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x43f0
testl %eax, %eax
jne 0x8bdf
leaq -0x40(%rbp), %r12
pushq $0x5
popq %rdx
pushq $-0x1
popq %rcx
movq %r12, %rdi
movq %r15, %rsi
callq 0x4330
movq %r15, %rdi
movq %r12, %rsi
callq 0x4390
movq %r12, %rdi
callq 0x4160
cmpq $0x5, 0x8(%r15)
jb 0x8c26
leaq 0x9dd1(%rip), %rcx      # 0x129be
pushq $0x5
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x43f0
testl %eax, %eax
jne 0x8c26
leaq -0x40(%rbp), %r12
pushq $0x5
popq %rdx
pushq $-0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x4330
movq %r14, %rdi
movq %r12, %rsi
callq 0x4390
movq %r12, %rdi
callq 0x4160
leaq 0xa4e3(%rip), %rdx      # 0x13110
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6fc3
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5a47
leaq -0x40(%rbp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/fusion.cpp
// Function: Fusion::mismatch_score(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double Fusion::mismatch_score( string contig_sub_a, string contig_sub_b ){
  int mismatch = 0;

  // protect against division by zero
  if( contig_sub_a.length() == 0 ){
    return 1.0;
  }

  for( int i=0; i<contig_sub_a.length(); i++ ){
    if( contig_sub_a[i] != contig_sub_b[i] ){
      mismatch++;
    }
    // bail when too many mismatches have been tallied.. avoid excessive processing
    if( double(mismatch) /contig_sub_a.length() > mismatch_threshold ){
      return 1.0;
    }
  }

  double score = double(mismatch) / contig_sub_a.length();
  return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rax
movsd 0x9b02(%rip), %xmm0     # 0x130e8
testq %rax, %rax
je 0x9653
movq %rax, %xmm2
punpckldq 0x9af8(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x9b00(%rip), %xmm2     # 0x13100
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
leaq 0x1204d(%rip), %rcx     # 0x1b660
movsd (%rcx), %xmm2
movq (%rsi), %rcx
movq (%rdx), %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpq %rsi, %rax
je 0x964b
movb (%rcx,%rsi), %r8b
xorl %r9d, %r9d
cmpb (%rdx,%rsi), %r8b
setne %r9b
addl %r9d, %edi
cvtsi2sd %edi, %xmm3
divsd %xmm1, %xmm3
incq %rsi
ucomisd %xmm2, %xmm3
jbe 0x9621
jmp 0x9653
cvtsi2sd %edi, %xmm0
divsd %xmm1, %xmm0
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/fusion.cpp
// Function: Fusion::dedup_removals()
void Fusion::dedup_removals(){
  for( int i=0; i<(int)contig_remove_list.size()-1; i++ ){
    for( int j=i+1; j<contig_remove_list.size(); j++ ){
      if( contig_remove_list[i] == contig_remove_list[j] ){
        contig_remove_list.erase( contig_remove_list.begin() + j );
        j--;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
xorl %r12d, %r12d
movq %rcx, %rdx
subq %rax, %rdx
shlq $0x1e, %rdx
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
addq %rsi, %rdx
sarq $0x20, %rdx
cmpq %rdx, %r12
jge 0x9b45
leaq 0x1(%r12), %r13
movl %r13d, %edx
movslq %edx, %r15
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x2, %rsi
cmpq %r15, %rsi
jbe 0x9b40
movl (%rax,%r12,4), %esi
cmpl (%rax,%r15,4), %esi
jne 0x9b3c
leaq (%rax,%r15,4), %rsi
movq %r14, %rdi
callq 0xaeae
decl %r15d
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movl %r15d, %edx
incl %edx
jmp 0x9b06
movq %r13, %r12
jmp 0x9ade
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/fusion.cpp
// Function: Fusion::sort_removals()
void Fusion::sort_removals(){
  int plc_hld;
  for( int i=0; i<(int)contig_remove_list.size()-1; i++ ){
    int low_idx = i;
    for( int j=i+1; j<(int)contig_remove_list.size(); j++ ){
      if( contig_remove_list[j] < contig_remove_list[low_idx] ){
        low_idx = j;
      }
    }
    if( low_idx != i ){
      plc_hld = contig_remove_list[i];
      contig_remove_list[i] = contig_remove_list[low_idx];
      contig_remove_list[low_idx] = plc_hld;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rdx
subq %rax, %rdx
shrq $0x2, %rdx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
decl %ecx
movl %edx, %edx
movabsq $0x1, %rsi
xorl %edi, %edi
cmpq %rcx, %rdi
je 0x9bce
movq %rsi, %r8
movl %edi, %r9d
movslq %r9d, %r10
cmpq %r8, %rdx
je 0x9bae
movl (%rax,%r8,4), %ebx
movl %r8d, %r11d
cmpl (%rax,%r10,4), %ebx
jl 0x9ba6
movl %r9d, %r11d
incq %r8
movl %r11d, %r9d
jmp 0x9b8e
movl %r9d, %r8d
cmpq %r8, %rdi
je 0x9bc6
movl (%rax,%rdi,4), %r8d
movl (%rax,%r10,4), %r9d
movl %r9d, (%rax,%rdi,4)
movl %r8d, (%rax,%r10,4)
incq %rdi
incq %rsi
jmp 0x9b83
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/fusion.cpp
// Function: Fusion::process_removals()
void Fusion::process_removals(){
  dedup_removals();
  sort_removals();
  for( int i=(int)contig_remove_list.size()-1; i>=0; i-- ){
    contigs->remove_contig( contig_remove_list[i] );
  }
  contig_remove_list.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x9abe
movq %rbx, %rdi
callq 0x9b54
movq 0x30(%rbx), %rax
subq 0x28(%rbx), %rax
shrq $0x2, %rax
movl %eax, %r14d
testl %r14d, %r14d
jle 0x9c13
movq (%rbx), %rdi
movq 0x28(%rbx), %rax
movl -0x4(%rax,%r14,4), %esi
decq %r14
callq 0x107fa
jmp 0x9bf8
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x9c21
movq %rax, 0x30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/fusion.cpp
// Function: Fusion::sort_matches()
void Fusion::sort_matches(){
  Mismatch temp_mim;

  // sort by overlap length
  for( int i=0; i<match_list.size(); i++ ){
    for( int j=i; j<match_list.size(); j++ ){
      if( match_list[i].get_length() < match_list[j].get_length() ){
        temp_mim = match_list[i];
        match_list[i] = match_list[j];
        match_list[j] = temp_mim;
      }
    }
  }

  // sort by score
  for( int i=0; i<match_list.size(); i++ ){
    for( int j=i; j<match_list.size(); j++ ){
      if( match_list[i].get_score() > match_list[j].get_score() ){
        temp_mim = match_list[i];
        match_list[i] = match_list[j];
        match_list[j] = temp_mim;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %rdi
callq 0x8134
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rax
xorl %r13d, %r13d
xorl %r15d, %r15d
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x5, %rcx
cmpq %r15, %rcx
jbe 0xa24e
movq %r13, -0x30(%rbp)
movq %r15, %r12
movq %r15, -0x38(%rbp)
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x5, %rcx
cmpq %r12, %rcx
jbe 0xa23e
shlq $0x5, %r15
addq %r15, %rdi
callq 0x81c0
movl %eax, %r14d
movq 0x10(%rbx), %rdi
addq %r13, %rdi
callq 0x81c0
cmpl %eax, %r14d
jge 0xa226
movq 0x10(%rbx), %rax
movups (%rax,%r15), %xmm0
movups 0xc(%rax,%r15), %xmm1
movups %xmm1, -0x54(%rbp)
movaps %xmm0, -0x60(%rbp)
movups (%rax,%r13), %xmm0
movups 0xc(%rax,%r13), %xmm1
movups %xmm1, 0xc(%rax,%r15)
movups %xmm0, (%rax,%r15)
movq 0x10(%rbx), %rax
movups -0x54(%rbp), %xmm0
movups %xmm0, 0xc(%rax,%r13)
movaps -0x60(%rbp), %xmm0
movups %xmm0, (%rax,%r13)
incq %r12
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rax
addq $0x20, %r13
movq -0x38(%rbp), %r15
jmp 0xa1b3
incq %r15
movq -0x30(%rbp), %r13
addq $0x20, %r13
jmp 0xa195
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x5, %rcx
movq %r12, -0x30(%rbp)
movq %r14, %r13
cmpq %r14, %rcx
ja 0xa2f5
jmp 0xa318
movq %r14, %r15
shlq $0x5, %r15
addq %r15, %rdi
callq 0x81b6
movsd %xmm0, -0x38(%rbp)
movq 0x10(%rbx), %rdi
addq %r12, %rdi
callq 0x81b6
movsd -0x38(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xa2e6
movq 0x10(%rbx), %rax
movups (%rax,%r15), %xmm0
movups 0xc(%rax,%r15), %xmm1
movups %xmm1, -0x54(%rbp)
movaps %xmm0, -0x60(%rbp)
movups (%rax,%r12), %xmm0
movupd 0xc(%rax,%r12), %xmm1
movupd %xmm1, 0xc(%rax,%r15)
movups %xmm0, (%rax,%r15)
movq 0x10(%rbx), %rax
movups -0x54(%rbp), %xmm0
movups %xmm0, 0xc(%rax,%r12)
movapd -0x60(%rbp), %xmm0
movupd %xmm0, (%rax,%r12)
incq %r13
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rax
addq $0x20, %r12
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x5, %rcx
cmpq %r13, %rcx
ja 0xa273
incq %r14
movq -0x30(%rbp), %r12
addq $0x20, %r12
jmp 0xa254
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/fusion.cpp
// Function: Fusion::clean_matches()
void Fusion::clean_matches(){
  for( int i=0; i<(int)match_list.size()-1; i++ ){
    int index_i = match_list[i].get_index_i();
    int end_i = match_list[i].get_end_i();
    int index_j = match_list[i].get_index_j();
    int end_j = match_list[i].get_end_j();
    for( int j=i+1; j<match_list.size(); j++ ){
      if( match_list[j].get_index_i() == index_i && match_list[j].get_end_i() == end_i ){
        match_list.erase( match_list.begin() + j );
        j--;
      }
      else if( match_list[j].get_index_j() == index_i && match_list[j].get_end_j() == end_i ){
        match_list.erase( match_list.begin() + j );
        j--;
      }
      else if( match_list[j].get_index_j() == index_j && match_list[j].get_end_j() == end_j ){
        match_list.erase( match_list.begin() + j );
        j--;
      }
      else if( match_list[j].get_index_i() == index_j && match_list[j].get_end_i() == end_j ){
        match_list.erase( match_list.begin() + j );
        j--;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rax
xorl %r13d, %r13d
subq %rdi, %rax
shlq $0x1b, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rcx, %rax
sarq $0x20, %rax
cmpq %rax, %r13
jge 0xa470
movq %r13, %r12
shlq $0x5, %r12
addq %r12, %rdi
callq 0x81ca
movl %eax, %r15d
movq (%r14), %rdi
addq %r12, %rdi
callq 0x81de
movl %eax, -0x30(%rbp)
movq (%r14), %rdi
addq %r12, %rdi
callq 0x81d4
movl %eax, -0x34(%rbp)
addq (%r14), %r12
movq %r12, %rdi
callq 0x81e8
movl %eax, -0x2c(%rbp)
incq %r13
movq %r13, -0x40(%rbp)
movslq %r13d, %r12
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rax
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x5, %rcx
cmpq %r12, %rcx
jbe 0xa467
shlq $0x5, %r12
addq %r12, %rdi
callq 0x81ca
cmpl %r15d, %eax
jne 0xa3ee
movq (%r14), %rdi
addq %r12, %rdi
callq 0x81de
cmpl -0x30(%rbp), %eax
je 0xa44e
movq (%r14), %rdi
addq %r12, %rdi
callq 0x81d4
cmpl %r15d, %eax
jne 0xa40e
movq (%r14), %rdi
addq %r12, %rdi
callq 0x81e8
cmpl -0x30(%rbp), %eax
je 0xa44e
movq (%r14), %rdi
addq %r12, %rdi
callq 0x81d4
cmpl -0x34(%rbp), %eax
jne 0xa42e
movq (%r14), %rdi
addq %r12, %rdi
callq 0x81e8
cmpl -0x2c(%rbp), %eax
je 0xa44e
movq (%r14), %rdi
addq %r12, %rdi
callq 0x81ca
cmpl -0x34(%rbp), %eax
jne 0xa45f
movq (%r14), %rdi
addq %r12, %rdi
callq 0x81de
cmpl -0x2c(%rbp), %eax
jne 0xa45f
addq (%r14), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xaf14
decl %r13d
incl %r13d
jmp 0xa3af
movq -0x40(%rbp), %r13
jmp 0xa34b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/match.cpp
// Function: Match::start_match()
void Match::start_match(){
  if( back ){
    match_contig_rr();
  }
  else{
    match_contig_fr();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x20(%rdi)
jne 0xb530
popq %rbp
jmp 0xb536
popq %rbp
jmp 0xb76e
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/match.cpp
// Function: Match::check_cov(int)
int Match::check_cov( int pos ){
  int cov = 0;

  for( int i=0; i<matchlist.size(); i++ ){
    if( matchlist[i].get_pos( pos, back ) != -1 ){
      cov++;
    }
  }
  return cov;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
cqto
pushq $0x30
popq %rcx
idivq %rcx
cmpq %r13, %rax
jbe 0xba8c
addq %r12, %rdi
movzbl 0x20(%r14), %edx
movl %ebx, %esi
callq 0x7ff0
xorl %ecx, %ecx
cmpb $-0x1, %al
setne %cl
addl %ecx, %r15d
incq %r13
addq $0x30, %r12
jmp 0xba52
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/readlist.cpp
// Function: Readlist::Readlist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Readlist::Readlist( string readsfiles ){
  Log::Inst()->log_it( "Begin add_reads()" );
  add_reads( readsfiles );

  Log::Inst()->log_it( "Begin sort_reads()" );
  sort_reads();
  
  Log::Inst()->log_it( "Begin sort_rc()" );
  sort_rc();
  
  Log::Inst()->log_it( "Begin create_reads_range()" );
  create_read_range();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
callq 0x81fe
movq %rax, %r15
leaq 0x7406(%rip), %rsi      # 0x131f0
leaq -0xc0(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x4120
leaq -0xc0(%rbp), %rsi
movq %r15, %rdi
callq 0x83ae
leaq -0xc0(%rbp), %rdi
callq 0x4160
leaq -0xa0(%rbp), %rdi
movq %r14, %rsi
callq 0x4410
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq 0xbf4c
leaq -0xa0(%rbp), %rdi
callq 0x4160
callq 0x81fe
movq %rax, %r14
leaq 0x73b4(%rip), %rsi      # 0x13202
leaq -0x80(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x4120
leaq -0x80(%rbp), %rsi
movq %r14, %rdi
callq 0x83ae
leaq -0x80(%rbp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0xc816
callq 0x81fe
movq %rax, %r14
leaq 0x738e(%rip), %rsi      # 0x13215
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x4120
leaq -0x60(%rbp), %rsi
movq %r14, %rdi
callq 0x83ae
leaq -0x60(%rbp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0xc836
callq 0x81fe
movq %rax, %r14
leaq 0x7365(%rip), %rsi      # 0x13225
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x4120
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x83ae
leaq -0x40(%rbp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0xc89a
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
jmp 0xbf2f
jmp 0xbf38
movq %rax, %r14
leaq -0x60(%rbp), %rdi
jmp 0xbf2f
jmp 0xbf38
movq %rax, %r14
leaq -0x80(%rbp), %rdi
jmp 0xbf2f
jmp 0xbf38
movq %rax, %r14
leaq -0xa0(%rbp), %rdi
jmp 0xbf2f
movq %rax, %r14
leaq -0xc0(%rbp), %rdi
callq 0x4160
jmp 0xbf3b
jmp 0xbf38
movq %rax, %r14
movq %rbx, %rdi
callq 0x732c
movq %r14, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/readlist.cpp
// Function: Readlist::sort_rc()
void Readlist::sort_rc(){
  rc_reflist.resize( rlist.size() );
  
  // initialize the rc_reflist with indices equal to their own as a beginning point
  for( int i=0; i<rc_reflist.size(); i++ ){
    rc_reflist[i]=i;
  }

  // sort
  merge_sort( rc_reflist.begin(), rc_reflist.end(), cmp_rc );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xee6a(%rip), %rsi      # 0x1b6b0
subq 0xee5b(%rip), %rsi      # 0x1b6a8
sarq $0x5, %rsi
leaq 0xee68(%rip), %rdi      # 0x1b6c0
callq 0xd186
movq 0xee64(%rip), %rdx      # 0x1b6c8
movq 0xee55(%rip), %rsi      # 0x1b6c0
movq %rdx, %rax
subq %rsi, %rax
sarq $0x3, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0xc885
movq %rcx, (%rsi,%rcx,8)
incq %rcx
jmp 0xc877
leaq 0x4d0(%rip), %rcx       # 0xcd5c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd1be
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/readlist.cpp
// Function: Readlist::cmp_rc(int, int)
bool Readlist::cmp_rc( const int ind1, const int ind2 ){
  string str1 = rlist[ind1].substr( rlist[ind1].length()-max_sort_char, max_sort_char );
  str1 = revcomp( str1 );
  string str2 = rlist[ind2].substr( rlist[ind2].length()-max_sort_char, max_sort_char );
  str2 = revcomp( str2 );

  return (str1.compare( str2 ) < 0 ); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %esi, %ebx
movslq %edi, %rax
movq 0xe930(%rip), %rcx      # 0x1b6a8
shlq $0x5, %rax
leaq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
leaq 0xe898(%rip), %r15      # 0x1b624
movslq (%r15), %rcx
subq %rcx, %rdx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x4330
leaq -0x98(%rbp), %rdi
movq %r14, %rsi
callq 0x4410
leaq -0x38(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x802c
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %r14
movq %r14, %rsi
callq 0x4390
movq %r14, %rdi
callq 0x4160
leaq -0x98(%rbp), %rdi
callq 0x4160
movslq %ebx, %rax
movq 0xe8bd(%rip), %rcx      # 0x1b6a8
shlq $0x5, %rax
leaq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movslq (%r15), %rcx
subq %rcx, %rdx
leaq -0x38(%rbp), %rdi
callq 0x4330
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4410
leaq -0xb8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x802c
leaq -0x38(%rbp), %rbx
leaq -0xb8(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4390
movq %r14, %rdi
callq 0x4160
leaq -0x78(%rbp), %rdi
callq 0x4160
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x4030
movl %eax, %ebx
leaq -0x38(%rbp), %rdi
callq 0x4160
leaq -0x58(%rbp), %rdi
callq 0x4160
shrl $0x1f, %ebx
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xce8e
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x4160
jmp 0xce91
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0xcea3
jmp 0xceaa
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x4160
jmp 0xcead
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/readlist.cpp
// Function: Readlist::get_read_range(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
tuple<long,long,long,long> Readlist::get_read_range( string read_seg ){
  try{
    return read_range.at(read_seg);
  }
  catch( const out_of_range& e ){
    return make_tuple( -1,-1,-1,-1 );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xf314
movdqu (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rbx)
movdqu %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x4130
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, (%rbx)
movdqu %xmm0, 0x10(%rbx)
callq 0x4530
jmp 0xcf4c
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/readlist.cpp
// Function: Readlist::homopolymer_check(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Readlist::homopolymer_check( string seq ){
  int i = 0;
  if( seq[0] == 'A' ){
    for( i=1; i<seq.length(); i++ ){
      if( seq[i] != 'A' ){
        break;
      }
    }
  }
  else if( seq[0] == 'T' ){
    for( i=1; i<seq.length(); i++ ){
      if( seq[i] != 'T' ){
        break;
      }
    }
  }
  else if( seq[0] == 'C' ){
    for( i=1; i<seq.length(); i++ ){
      if( seq[i] != 'C' ){
        break;
      }
    }
  }
  else if( seq[0] == 'G' ){
    for( i=1; i<seq.length(); i++ ){
      if( seq[i] != 'G' ){
        break;
      }
    }
  }
  if( i == seq.length() ){
    return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movq 0x8(%rsi), %rax
movzbl (%rdx), %ecx
cmpl $0x41, %ecx
je 0xd00f
cmpl $0x43, %ecx
je 0xcfc5
cmpl $0x54, %ecx
je 0xcfea
cmpl $0x47, %ecx
jne 0xd039
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
movabsq $0x1, %rsi
cmpq %rsi, %rax
jbe 0xd03b
cmpb $0x47, (%rdx,%rsi)
jne 0xd034
incq %rsi
jmp 0xcfb1
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
movabsq $0x1, %rsi
cmpq %rsi, %rax
jbe 0xd03b
cmpb $0x43, (%rdx,%rsi)
jne 0xd034
incq %rsi
jmp 0xcfda
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
movabsq $0x1, %rsi
cmpq %rsi, %rax
jbe 0xd03b
cmpb $0x54, (%rdx,%rsi)
jne 0xd034
incq %rsi
jmp 0xcfff
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
movabsq $0x1, %rsi
cmpq %rsi, %rax
jbe 0xd03b
cmpb $0x41, (%rdx,%rsi)
jne 0xd034
incq %rsi
jmp 0xd024
movq %rsi, %rcx
jmp 0xd03b
xorl %ecx, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
sete %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/readlist.cpp
// Function: void Readlist::merge_sort<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, bool (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, bool (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>))
void Readlist::merge_sort( Iter first, Iter last, Order order ){
  if (last - first > 1){
    Iter middle = first + (last - first)/2;
    merge_sort( first, middle, order );
    merge_sort( middle, last, order );
    inplace_merge( first, middle, last, order );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
subq %rsi, %r12
sarq $0x5, %r12
cmpq $0x1, %r12
jle 0xd177
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
shlq $0x4, %r12
andq $-0x20, %r12
addq %rsi, %r12
movq %r12, %rdx
callq 0xd10a
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xd10a
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd39f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/extension.cpp
// Function: Extension::Extension(Readlist*, int)
Extension::Extension( Readlist *reads, int len ) : reads(reads), len(len), matches(Match(reads)){
  start = -1;
  missed_bp_tot = 0;
  missed_bp_avg = 0;
  back = false;
  contig = "";
  exten_seq = "";
  pos_mult = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %rbx
callq 0xb318
movq %r14, 0x48(%rbx)
leaq 0x50(%rbx), %r14
leaq 0x88(%rbx), %r15
leaq 0x98(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movq %rax, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
xorl %eax, %eax
movb %al, 0x98(%rbx)
leaq 0xa8(%rbx), %r12
leaq 0xb8(%rbx), %rcx
movq %rcx, 0xa8(%rbx)
andq $0x0, 0xb0(%rbx)
movb %al, 0xb8(%rbx)
movl %r13d, 0xcc(%rbx)
orl $-0x1, 0x80(%rbx)
andq $0x0, 0xd0(%rbx)
movb %al, 0x84(%rbx)
leaq 0x3b4a(%rip), %rsi      # 0x12f4c
movq %r15, %rdi
callq 0x4600
leaq 0x3b3b(%rip), %rsi      # 0x12f4c
movq %r12, %rdi
callq 0x4600
orl $-0x1, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x30(%rbp)
leaq 0x68(%rbx), %r13
movq %r12, %rdi
callq 0x4160
movq %r15, %rdi
callq 0x4160
movq %r13, %rdi
callq 0x5b30
movq %r14, %rdi
callq 0x5ad2
movq %rbx, %rdi
callq 0x5afe
movq -0x30(%rbp), %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/afinit[P]afin/extension.cpp
// Function: Extension::Extension(Readlist*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Extension::Extension( Readlist *reads, int len, string contig ) : reads(reads), len(len), matches(Match(reads,contig)){
  start = -1;
  missed_bp_tot = 0;
  missed_bp_avg = 0;
  back = false;
  contig = "";
  exten_seq = "";
  pos_mult = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x58(%rbp), %r13
movq %r13, %rdi
movq %rcx, %rsi
callq 0x4410
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xb384
leaq -0x58(%rbp), %rdi
callq 0x4160
movq %r15, 0x48(%rbx)
leaq 0x50(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0x68(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0x88(%rbx), %r13
leaq 0x98(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movq %rax, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
xorl %eax, %eax
movb %al, 0x98(%rbx)
leaq 0xa8(%rbx), %r15
leaq 0xb8(%rbx), %rcx
movq %rcx, 0xa8(%rbx)
andq $0x0, 0xb0(%rbx)
movb %al, 0xb8(%rbx)
movl %r14d, 0xcc(%rbx)
orl $-0x1, 0x80(%rbx)
andq $0x0, 0xd0(%rbx)
movb %al, 0x84(%rbx)
leaq 0x3a13(%rip), %rsi      # 0x12f4c
movq %r12, %rdi
callq 0x4600
leaq 0x3a04(%rip), %rsi      # 0x12f4c
movq %r15, %rdi
callq 0x4600
orl $-0x1, 0xc8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x4160
jmp 0xf5a1
movq %rax, %r14
movq %r15, %rdi
callq 0x4160
movq %r13, %rdi
callq 0x4160
movq -0x30(%rbp), %rdi
callq 0x5b30
movq -0x38(%rbp), %rdi
callq 0x5ad2
movq %rbx, %rdi
callq 0x5afe
movq %r14, %rdi
callq 0x4590
nop