LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/cphinton42[P]hinton-language/src/scope.cpp
// Function: atomize_string(Atom_Table*, Array<char>)
Atom atomize_string(Atom_Table *at, String str)
{
    u64 hash = fnv1a_64(str);
    
    u64 slot = set_find_slot(&at->atom_set, str, hash);
    if(at->atom_set.hashes[slot] == 0)
    {
        String *new_str = pool_alloc(String, &at->atom_pool);
        assert(new_str);
        new_str->count = str.count;
        new_str->data = pool_alloc(byte, str.count, &at->atom_pool);
        copy_memory(new_str->data, str.data, str.count);
        
        Atom result = {new_str};
        set_insert_into_slot(&at->atom_set, slot, hash, result);
        
        return result;
    }
    else
    {
        return at->atom_set.entries[slot];
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movabsq $-0x340d631b7bdddcdb, %rcx # imm = 0xCBF29CE484222325
testq %rsi, %rsi
je 0x9aa2
xorl %eax, %eax
movabsq $0x100000001b3, %rdx    # imm = 0x100000001B3
movsbq (%r15,%rax), %r12
xorq %rcx, %r12
imulq %rdx, %r12
incq %rax
movq %r12, %rcx
cmpq %rax, %r14
jne 0x9a89
jmp 0x9aa5
movq %rcx, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xee87
movq %rax, %r13
movq 0x10(%rbx), %rax
cmpq $0x0, (%rax,%r13,8)
je 0x9ace
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rbp
jmp 0x9b1a
leaq 0x20(%rbx), %rdi
movl $0x10, %esi
movq %rdi, (%rsp)
callq 0x95e6
testq %rax, %rax
je 0x9b2c
movq %rax, %rbp
movq %r14, (%rax)
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x95e6
movq %rax, 0x8(%rbp)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x30a0
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0xef1f
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7851(%rip), %rdi      # 0x11384
leaq 0x7852(%rip), %rsi      # 0x1138c
leaq 0x7859(%rip), %rcx      # 0x1139a
movl $0x52, %edx
callq 0x3080
// File: /workspace/github_cpp_makefile_star2_O1/cphinton42[P]hinton-language/src/stb/stb_sprintf.h
// Function: stbsp_vsnprintf
STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va )
{
  stbsp__context c;
  int l;

  if ( count == 0 )
    return 0;

  c.buf = buf;
  c.count = count;

  STB_SPRINTF_DECORATE( vsprintfcb )( stbsp__clamp_callback, &c, stbsp__clamp_callback(0,&c,0), fmt, va );
  
  // zero-terminate
  l = (int)( c.buf - buf );
  if ( l >= count ) // should never be greater, only equal (or less) than count
    l = count - 1;
  buf[l] = 0;

  return l;
}

// Assembly:
testl %esi, %esi
je 0xca0f
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rcx, %r8
movq %rdx, %rcx
movl %esi, %r14d
movq %rdi, %rbx
movq %rdi, (%rsp)
movl %esi, 0x8(%rsp)
movl %esi, %eax
sarl $0x1f, %eax
andl %esi, %eax
je 0xc9fa
cltq
leaq (%rbx,%rax), %rdx
movq %rdx, (%rsp)
movl %r14d, %edx
subl %eax, %edx
movl %edx, 0x8(%rsp)
movl 0x8(%rsp), %eax
testl %eax, %eax
jle 0xca12
cmpl $0x200, %eax            # imm = 0x200
jl 0xca16
movq (%rsp), %rdx
jmp 0xca1b
xorl %eax, %eax
retq
xorl %edx, %edx
jmp 0xca1b
leaq 0xc(%rsp), %rdx
leaq 0x2e(%rip), %rdi        # 0xca50
movq %rsp, %r15
movq %r15, %rsi
callq 0xa1c9
movl (%r15), %ecx
subl %ebx, %ecx
leal -0x1(%r14), %eax
cmpl %r14d, %ecx
cmovll %ecx, %eax
movslq %eax, %rcx
movb $0x0, (%rbx,%rcx)
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cphinton42[P]hinton-language/src/stb/stb_sprintf.h
// Function: stbsp__clamp_callback(char*, void*, int)
static char * stbsp__clamp_callback( char * buf, void * user, int len )
{
  stbsp__context * c = (stbsp__context*)user;

  if ( len > c->count ) len = c->count;

  if (len)
  {
    if ( buf != c->buf )
    {
      char * s, * d, * se;
      d = c->buf; s = buf; se = buf+len;
      do{ *d++ = *s++; } while (s<se);
    }
    c->buf += len;
    c->count -= len;
  }
  
  if ( c->count <= 0 ) return 0;
  return ( c->count >= STB_SPRINTF_MIN ) ? c->buf : c->tmp; // go direct into buffer if you can
}

// Assembly:
movq %rsi, %rax
movl 0x8(%rsi), %ecx
cmpl %edx, %ecx
cmovll %ecx, %edx
testl %edx, %edx
je 0xca85
movq (%rax), %rcx
movslq %edx, %rsi
cmpq %rdi, %rcx
je 0xca7f
leaq (%rdi,%rsi), %r8
movb (%rdi), %r9b
incq %rdi
movb %r9b, (%rcx)
incq %rcx
cmpq %r8, %rdi
jb 0xca6e
addq %rsi, (%rax)
subl %edx, 0x8(%rax)
movl 0x8(%rax), %ecx
testl %ecx, %ecx
jle 0xca98
cmpl $0x200, %ecx            # imm = 0x200
jl 0xca9b
movq (%rax), %rax
retq
xorl %eax, %eax
retq
addq $0xc, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/cphinton42[P]hinton-language/src/basic.h
// Function: void array_add<Decl_AST*>(Dynamic_Array<Decl_AST*>*, Decl_AST*, Allocator)
void array_add(Dynamic_Array<T> *arr, T element, Allocator a)
{
    if(arr->count == arr->allocated)
    {
        u64 new_size = 4 * arr->allocated;
        if(new_size == 0)
        {
            new_size = 4;
        }
        array_resize(arr, new_size, a);
    }
    
    (*arr)[arr->count] = element;
    ++arr->count;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rax, (%rdi)
jne 0xeb9b
shlq $0x2, %rax
testq %rax, %rax
movl $0x4, %esi
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0xf540
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %r14, (%rcx,%rax,8)
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/cphinton42[P]hinton-language/src/scope.h
// Function: void init_hash_set<Scope_Entry, Atom, &get_key(Scope_Entry&), &compute_hash64(Atom), &operator==(Atom, Atom)>(Hash_Set<Scope_Entry, Atom, &get_key(Scope_Entry&), &compute_hash64(Atom), &operator==(Atom, Atom)>*, unsigned long)
void init_hash_set(Hash_Set<T,K,GK,H,Eq> *hs, u64 initial_size)
{
    hs->set_size = initial_size;
    hs->count = 0;
    
    if(initial_size > 0)
    {
        // TODO: could replace with SOA allocation
        hs->hashes = mem_alloc(u64, initial_size);
        hs->entries = mem_alloc(T, initial_size);
        
        assert(hs->hashes);
        assert(hs->entries);
        
        zero_memory(hs->hashes, initial_size);
    }
    else
    {
        hs->hashes = nullptr;
        hs->entries = nullptr;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, (%rdi)
movq $0x0, 0x8(%rdi)
testq %rsi, %rsi
je 0xec23
movq %rsi, %rbx
shlq $0x3, %rbx
movq 0x6f9a(%rip), %rdi      # 0x15b70
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq *0x6f83(%rip)           # 0x15b68
movq %rax, 0x10(%r14)
leaq (%rbx,%rbx,2), %r8
movq 0x6f7c(%rip), %rdi      # 0x15b70
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x6f68(%rip)           # 0x15b68
movq %rax, 0x18(%r14)
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xec33
testq %rax, %rax
je 0xec52
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3060
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x362d(%rip), %rdi      # 0x12267
leaq 0x3631(%rip), %rsi      # 0x12272
leaq 0x3636(%rip), %rcx      # 0x1227e
movl $0x6d, %edx
callq 0x3080
leaq 0x36ac(%rip), %rdi      # 0x12305
leaq 0x3612(%rip), %rsi      # 0x12272
leaq 0x3617(%rip), %rcx      # 0x1227e
movl $0x6e, %edx
callq 0x3080
// File: /workspace/github_cpp_makefile_star2_O1/cphinton42[P]hinton-language/src/scope.h
// Function: bool set_insert<Scope_Entry, Atom, &get_key(Scope_Entry&), &compute_hash64(Atom), &operator==(Atom, Atom)>(Hash_Set<Scope_Entry, Atom, &get_key(Scope_Entry&), &compute_hash64(Atom), &operator==(Atom, Atom)>*, Scope_Entry, unsigned long)
bool set_insert(Hash_Set<T,K,GK,H,Eq> *hs, T entry, u64 hash)
{
    u64 slot = set_find_slot(hs, GK(entry), hash);
    if(hs->hashes[slot] == 0)
    {
        set_insert_into_slot(hs, slot, hash, entry);
        return true;
    }
    else
    {
        return false;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0xf63a
movq 0x10(%rbx), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
jne 0xeceb
leaq 0x20(%rsp), %rdx
cmpq $0x1, %r14
adcq $0x0, %r14
movq %r14, (%rcx,%rax,8)
movq 0x18(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movq 0x10(%rdx), %rsi
movq %rsi, 0x10(%rcx,%rax,8)
movups (%rdx), %xmm0
movups %xmm0, (%rcx,%rax,8)
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
leaq 0x4(,%rax,4), %rax
leaq (%rsi,%rsi,2), %rcx
cmpq %rcx, %rax
jbe 0xeceb
shlq $0x2, %rsi
movq %rbx, %rdi
callq 0xecf7
testq %r15, %r15
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cphinton42[P]hinton-language/src/scope.h
// Function: void set_resize<Scope_Entry, Atom, &get_key(Scope_Entry&), &compute_hash64(Atom), &operator==(Atom, Atom)>(Hash_Set<Scope_Entry, Atom, &get_key(Scope_Entry&), &compute_hash64(Atom), &operator==(Atom, Atom)>*, unsigned long)
void set_resize(Hash_Set<T,K,GK,H,Eq> *hs, u64 new_size)
{
    assert(new_size >= hs->count);
    
    u64 old_size = hs->set_size;
    u64 *old_hashes = hs->hashes;
    T *old_entries = hs->entries;
    
    init_hash_set(hs, new_size);
    
    for(u64 i = 0; i < old_size; ++i)
    {
        if(old_hashes[i] != 0)
        {
            set_insert(hs, old_entries[i], old_hashes[i]);
        }
    }
    
    mem_dealloc(old_hashes, old_size);
    mem_dealloc(old_entries, old_size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq %rsi, 0x8(%rdi)
ja 0xeda9
movq %rdi, %r12
movq (%rdi), %r14
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %rbx
callq 0xebb1
testq %r14, %r14
je 0xed5d
xorl %r13d, %r13d
movq %rbx, %rbp
cmpq $0x0, (%r15,%r13,8)
je 0xed51
movq (%r15,%r13,8), %rsi
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsp)
movups (%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0xec71
incq %r13
addq $0x18, %rbp
cmpq %r13, %r14
jne 0xed2d
shlq $0x3, %r14
movq 0x6e08(%rip), %rdi      # 0x15b70
movl $0x2, %esi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
callq *0x6dec(%rip)           # 0x15b68
leaq (%r14,%r14,2), %rcx
movq 0x6de1(%rip), %rax      # 0x15b68
movq 0x6de2(%rip), %rdi      # 0x15b70
movl $0x2, %esi
movq %rbx, %rdx
xorl %r8d, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0x3561(%rip), %rdi      # 0x12311
leaq 0x34bb(%rip), %rsi      # 0x12272
leaq 0x3569(%rip), %rcx      # 0x12327
movl $0x91, %edx
callq 0x3080
// File: /workspace/github_cpp_makefile_star2_O1/cphinton42[P]hinton-language/src/scope.h
// Function: unsigned long set_find_slot<Atom, Array<char>, &get_str(Atom&), &fnv1a_64(Array<char>), &bool operator==<char>(Array<Atom>, Array<Atom>)>(Hash_Set<Atom, Array<char>, &get_str(Atom&), &fnv1a_64(Array<char>), &bool operator==<char>(Array<Atom>, Array<Atom>)>*, Array<char>, unsigned long)
u64 set_find_slot(Hash_Set<T,K,GK,H,Eq> *hs, K key, u64 hash)
{
    if(hash == 0)
    {
        hash = 1;
    }
    
    u64 mask = hs->set_size - 1;
    u64 idx = hash & mask;
    u64 inc = 0;
    
    while(true)
    {
        if(hs->hashes[idx] == 0)
        {
            return idx;
        }
        else if(hs->hashes[idx] == hash && Eq(GK(hs->entries[idx]), key))
        {
            return idx;
        }
        else
        {
            ++inc;
            idx = (idx + inc) & mask;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movq (%rdi), %r8
movq 0x10(%rdi), %r9
decq %r8
movq %rcx, %rax
andq %r8, %rax
movq (%r9,%rax,8), %r11
testq %r11, %r11
je 0xef18
xorl %r10d, %r10d
cmpq %rcx, %r11
jne 0xef03
movq 0x18(%rdi), %r11
movq (%r11,%rax,8), %rbx
movq (%rbx), %r11
cmpq %rsi, %r11
jne 0xef03
testq %r11, %r11
sete %bpl
je 0xeefe
movq 0x8(%rbx), %rbx
movb (%rbx), %r14b
cmpb (%rdx), %r14b
jne 0xeefe
movl $0x1, %r15d
movq %r15, %r14
cmpq %r15, %r11
je 0xeef7
movb (%rbx,%r14), %bpl
leaq 0x1(%r14), %r15
cmpb (%rdx,%r14), %bpl
je 0xeee1
cmpq %r11, %r14
setae %bpl
testb %bpl, %bpl
jne 0xef18
addq %r10, %rax
incq %rax
incq %r10
andq %r8, %rax
movq (%r9,%rax,8), %r11
testq %r11, %r11
jne 0xeeb1
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cphinton42[P]hinton-language/src/scope.h
// Function: void set_insert_into_slot<Atom, Array<char>, &get_str(Atom&), &fnv1a_64(Array<char>), &bool operator==<char>(Array<Atom>, Array<Atom>)>(Hash_Set<Atom, Array<char>, &get_str(Atom&), &fnv1a_64(Array<char>), &bool operator==<char>(Array<Atom>, Array<Atom>)>*, unsigned long, unsigned long, Atom)
void set_insert_into_slot(Hash_Set<T,K,GK,H,Eq> *hs, u64 slot, u64 hash, T entry)
{
    if(hash == 0)
    {
        hash = 1;
    }
    hs->hashes[slot] = hash;
    hs->entries[slot] = entry;
    ++hs->count;
    if(4*hs->count > 3*hs->set_size)
    {
        set_resize(hs, 4*hs->set_size);
    }
}

// Assembly:
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq 0x10(%rdi), %rax
movq %rdx, (%rax,%rsi,8)
movq 0x18(%rdi), %rax
movq %rcx, (%rax,%rsi,8)
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
leaq 0x4(,%rax,4), %rax
leaq (%rsi,%rsi,2), %rcx
cmpq %rcx, %rax
jbe 0xef60
shlq $0x2, %rsi
jmp 0xf687
retq
// File: /workspace/github_cpp_makefile_star2_O1/cphinton42[P]hinton-language/src/basic.h
// Function: void array_resize<Job>(Dynamic_Array<Job>*, unsigned long, Allocator)
void array_resize(Dynamic_Array<T> *arr, u64 new_size, Allocator a)
{
    // TODO: take more care with OOM errors?
    if(arr->data)
    {
        if(new_size == 0)
        {
            mem_dealloc(arr->data, arr->allocated, a);
            arr->count = 0;
            arr->data = nullptr;
            arr->allocated = 0;
        }
        else
        {
            arr->data = mem_resize(arr->data, arr->allocated, new_size, a);
            assert(arr->data);
            arr->allocated = new_size;
            if(arr->count > new_size)
            {
                arr->count = new_size;
            }
        }
    }
    else
    {
        assert(arr->count == 0);
        
        arr->data = mem_alloc(T, new_size, a);
        assert(arr->data);
        arr->allocated = new_size;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0xf012
movq 0x10(%rbx), %rsi
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %r9
testq %r14, %r14
je 0xf03e
leaq (,%r14,8), %rsi
leaq (%rsi,%rsi,2), %r8
movq %rcx, %rdi
movl $0x1, %esi
movq %r9, %rcx
callq *%rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xf064
movq %r14, 0x10(%rbx)
cmpq %r14, (%rbx)
jbe 0xf05c
movq %r14, (%rbx)
jmp 0xf05c
cmpq $0x0, (%rbx)
jne 0xf083
leaq (,%r14,8), %rdx
leaq (%rdx,%rdx,2), %r8
movq %rcx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xf0a2
movq %r14, 0x10(%rbx)
jmp 0xf05c
movq %rcx, %rdi
movl $0x2, %esi
movq %r9, %rcx
xorl %r8d, %r8d
callq *%rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2622(%rip), %rdi      # 0x1168d
leaq 0x2625(%rip), %rsi      # 0x11697
leaq 0x262a(%rip), %rcx      # 0x116a3
movl $0x129, %edx            # imm = 0x129
callq 0x3080
leaq 0x2659(%rip), %rdi      # 0x116e3
leaq 0x2606(%rip), %rsi      # 0x11697
leaq 0x260b(%rip), %rcx      # 0x116a3
movl $0x133, %edx            # imm = 0x133
callq 0x3080
leaq 0x25e4(%rip), %rdi      # 0x1168d
leaq 0x25e7(%rip), %rsi      # 0x11697
leaq 0x25ec(%rip), %rcx      # 0x116a3
movl $0x136, %edx            # imm = 0x136
callq 0x3080
// File: /workspace/github_cpp_makefile_star2_O1/afinit[P]afin/contig.cpp
// Function: Contig::Contig()
Contig::Contig(){
  reads = 0;
  extension = 0;
  contig = "";
  contig_id = "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x40(%rdi), %r13
movq %r13, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x106d2(%rip), %rcx     # 0x15f4c
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x44f0
movq 0x38(%r15), %rdx
leaq 0x106b8(%rip), %rcx     # 0x15f4c
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x44f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x58c0
callq 0x42f0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x58cd
callq 0x42f0
movq %r15, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, (%rdi)
addq $0x10, %rdi
leaq 0x20(%r14), %rax
movq %rax, -0x38(%rbp)
movq %rax, 0x10(%r14)
movq 0x10(%rsi), %rsi
movq 0x18(%r15), %rdx
addq %rsi, %rdx
movq %rdi, -0x40(%rbp)
callq 0x6876
leaq 0x30(%r14), %r12
leaq 0x40(%r14), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x30(%r14)
movq 0x30(%r15), %rsi
movq 0x38(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x6876
movl $0xd8, %edi
callq 0x4310
movq %rax, %r13
movq (%r14), %rsi
leaq 0x17b45(%rip), %rax     # 0x1d610
movl (%rax), %edx
movq %r13, %rdi
callq 0x12380
movq %r13, 0x8(%r14)
movq 0x8(%r15), %rbx
movq (%rbx), %rax
movq %rax, (%r13)
leaq 0x8(%r13), %rdi
leaq 0x8(%rbx), %rsi
callq 0x6452
movb 0x20(%rbx), %al
movb %al, 0x20(%r13)
addq $0x28, %r13
addq $0x28, %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x41c0
movq 0x8(%r15), %rsi
addq $0x50, %rsi
movq 0x8(%r14), %rdi
addq $0x50, %rdi
callq 0x610a
movq 0x8(%r15), %rsi
addq $0x68, %rsi
movq 0x8(%r14), %rdi
addq $0x68, %rdi
callq 0x6274
movq 0x8(%r15), %rsi
movl 0xd0(%rsi), %eax
movq 0x8(%r14), %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 0x41c0
movl $0xa8, %edi
movq 0x8(%r15), %rsi
addq %rdi, %rsi
addq 0x8(%r14), %rdi
callq 0x41c0
movq 0x8(%r15), %rax
movl 0xc8(%rax), %eax
movq 0x8(%r14), %rcx
movl %eax, 0xc8(%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, %rdi
callq 0x42f0
jmp 0x5bca
movq %rax, %r14
jmp 0x5bd9
movq %rax, %r14
movq (%r12), %rdi
cmpq -0x30(%rbp), %rdi
je 0x5bd9
callq 0x42f0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0x5beb
callq 0x42f0
movq %r14, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/afinit[P]afin/contig.cpp
// Function: swap(Contig&, Contig&)
void swap( Contig& data1, Contig& data2 ){
  using std::swap;

  swap( data1.extension, data2.extension );
  swap( data1.reads, data2.reads );
  swap( data1.contig, data2.contig );
  swap( data1.contig_id, data2.contig_id );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x8(%rsi)
movq (%rdi), %rax
movq (%rsi), %rcx
movq %rcx, (%rdi)
movq %rax, (%rsi)
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x4240
addq $0x30, %r14
addq $0x30, %rbx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x4240
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
addq $0x18, %rdi
leaq 0x28(%r15), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x18(%r15)
xorl %eax, %eax
movq %rax, 0x20(%r15)
movb %al, 0x28(%r15)
leaq 0x38(%r15), %r14
leaq 0x48(%r15), %r13
movq %r13, 0x38(%r15)
movq %rax, 0x40(%r15)
movb %al, 0x48(%r15)
leaq 0x58(%r15), %r12
leaq 0x68(%r15), %rbx
movq %rbx, 0x58(%r15)
movq %rax, 0x60(%r15)
movb %al, 0x68(%r15)
leaq 0xefde(%rip), %rcx      # 0x15c33
movl $0x8, %r8d
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
xorl %edx, %edx
callq 0x44f0
movq 0x40(%r15), %rdx
leaq 0xf2d9(%rip), %rcx      # 0x15f4c
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x44f0
movq 0x60(%r15), %rdx
leaq 0xf2c1(%rip), %rcx      # 0x15f4c
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x44f0
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r12), %rdi
cmpq %rbx, %rdi
je 0x6cc7
callq 0x42f0
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x6cd4
callq 0x42f0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x6ce6
callq 0x42f0
movq %r15, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x899a
cmpl $-0x1, %eax
je 0x8811
movl %eax, %r15d
movq 0x8(%r14), %rdi
movl %r15d, %esi
callq 0x13c72
movq %rax, %rdi
xorl %esi, %esi
callq 0x5cd6
movq 0x8(%r14), %rdi
movl %r15d, %esi
callq 0x13c72
movq %rax, %rdi
movl $0x1, %esi
callq 0x5cd6
movq %rbx, %rdi
callq 0x899a
movl %eax, %r15d
cmpl $-0x1, %eax
jne 0x87d2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rdi), %rax
leaq -0x28(%rbp), %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x8ffe
movb $0x1, 0x8(%r15)
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x891a
movl (%r14), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x8925
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9044
leaq -0x28(%rbp), %rdi
callq 0x8fb2
addq $0x78, %rbx
movq %rbx, %rdi
callq 0x4180
leaq -0x28(%rbp), %rdi
callq 0x8fe4
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x8fe4
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
leaq -0x28(%rbp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x8ffe
movb $0x1, 0x8(%r14)
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
jne 0x89ee
leaq 0x78(%rbx), %r14
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x40e0
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x89d9
movl (%rax), %r14d
movq %rbx, %rdi
callq 0x92f6
leaq -0x28(%rbp), %rdi
callq 0x8fe4
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
leaq 0x8(%rdi), %r12
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %r12, %rdi
callq 0x41c0
movl %r15d, (%r14)
movl $0x0, 0x4(%r14)
movb %bl, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x93b1
callq 0x42f0
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %edx, %r15d
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %rbx, %rdi
callq 0x41c0
movl %r15d, (%r14)
movl $0x0, 0x4(%r14)
movb $0x0, 0x28(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x9414
callq 0x42f0
movq %r14, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
je 0x943d
subl (%rdi), %esi
movb $0x1, %cl
js 0x9465
movl %esi, %edx
cmpq %rdx, 0x10(%rdi)
jbe 0x9465
movq 0x8(%rdi), %rax
movb (%rax,%rdx), %al
xorl %ecx, %ecx
jmp 0x9465
movl 0x10(%rdi), %eax
movl %eax, %edx
subl (%rdi), %edx
addl %esi, %edx
sets %sil
cmpl %eax, %edx
setge %cl
orb %sil, %cl
jne 0x945d
movl %edx, %eax
movq 0x8(%rdi), %rdx
movb (%rdx,%rax), %al
testb %cl, %cl
je 0x9463
movb $-0x1, %al
popq %rbp
retq
testb %cl, %cl
jne 0x9461
jmp 0x9463
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x6876
movq 0x8(%r14), %r12
testl %r12d, %r12d
jle 0x9545
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq 0xca11(%rip), %r15      # 0x15ec5
movq (%r14), %rax
movzbl (%rax,%r13), %eax
cmpl $0x53, %eax
jle 0x94d7
cmpl $0x62, %eax
jle 0x9506
cmpl $0x63, %eax
je 0x94e6
cmpl $0x67, %eax
je 0x9526
cmpl $0x74, %eax
je 0x951b
jmp 0x9531
cmpl $0x46, %eax
jg 0x94f1
cmpl $0x41, %eax
je 0x9510
cmpl $0x43, %eax
jne 0x9531
movq (%rbx), %rax
movb $0x47, -0x1(%rax,%r12)
jmp 0x9539
cmpl $0x47, %eax
je 0x9526
cmpl $0x4e, %eax
jne 0x9531
movq (%rbx), %rax
movb $0x4e, -0x1(%rax,%r12)
jmp 0x9539
cmpl $0x54, %eax
je 0x951b
cmpl $0x61, %eax
jne 0x9531
movq (%rbx), %rax
movb $0x54, -0x1(%rax,%r12)
jmp 0x9539
movq (%rbx), %rax
movb $0x41, -0x1(%rax,%r12)
jmp 0x9539
movq (%rbx), %rax
movb $0x43, -0x1(%rax,%r12)
jmp 0x9539
movq %r15, %rdi
callq 0x44e0
incq %r13
decq %r12
jne 0x94b4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x14053(%rip)     # 0x1d688
jne 0x965f
movl $0x210, %edi            # imm = 0x210
callq 0x4310
movq %rax, %rbx
movq %rax, %rdi
callq 0x4390
movq %rbx, 0x14035(%rip)     # 0x1d688
leaq 0x14036(%rip), %rdi     # 0x1d690
callq 0x42e0
movq 0x14022(%rip), %rax     # 0x1d688
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_O1/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
movl $0x30, %edx
callq 0x4410
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x96a9
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x4732
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0xc7ca(%rip), %rdx      # 0x15f4c
movq %rdx, %rsi
callq 0x6b5c
xorl %edi, %edi
callq 0x42e0
movq 0x13ef8(%rip), %rsi     # 0x1d690
movq %rax, %rdi
callq 0x4190
cvttsd2si %xmm0, %eax
cltq
imulq $-0x6e5d4c3b, %rax, %rdx # imm = 0x91A2B3C5
shrq $0x20, %rdx
addl %eax, %edx
movl %edx, %ecx
shrl $0x1f, %ecx
sarl $0xb, %edx
addl %ecx, %edx
imull $0xe10, %edx, %ecx      # imm = 0xE10
subl %ecx, %eax
movslq %eax, %r8
imulq $-0x77777777, %r8, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %r8d, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
sarl $0x5, %ecx
addl %eax, %ecx
imull $0x3c, %ecx, %eax
subl %eax, %r8d
leaq 0xc760(%rip), %rsi      # 0x15f4d
leaq -0x90(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0x4140
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x44f0
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x983d
callq 0x42f0
movq %r14, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13de7(%rip), %rax     # 0x1d644
cmpl $0x0, (%rax)
je 0x98ea
movq %rdi, %r14
addq $0x10, %r14
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x9762
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x4360
movq %rax, %r14
leaq 0xc6b9(%rip), %rsi      # 0x15f4b
movl $0x1, %edx
movq %rax, %rdi
callq 0x4360
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x4360
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4300
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4210
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x98ea
callq 0x42f0
leaq 0x13d4f(%rip), %rax     # 0x1d640
cmpl $0x0, (%rax)
je 0x997b
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x9762
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x136ac(%rip), %rdi     # 0x1cfc0
callq 0x4360
movq %rax, %r14
leaq 0xc628(%rip), %rsi      # 0x15f4b
movl $0x1, %edx
movq %rax, %rdi
callq 0x4360
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x4360
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4210
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x997b
callq 0x42f0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9988
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x999d
callq 0x42f0
movq %rbx, %rdi
callq 0x4590
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
leaq 0x13289(%rip), %rax     # 0x1cd18
movq %rax, (%rdi)
movl $0x4000, 0x8(%rdi)      # imm = 0x4000
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x10(%rdi)
leaq 0xc49c(%rip), %rdx      # 0x15f4c
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6b5c
leaq 0xa8(%r14), %r15
leaq 0xb8(%r14), %r13
movq %r13, 0xa8(%r14)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x6876
movq (%r12), %rdi
leaq 0xc498(%rip), %rsi      # 0x15f87
callq 0x4380
movq %rax, 0xa0(%r14)
leaq 0x30(%r14), %rdi
movl $0x0, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r14)
xorl %eax, %eax
movq %rax, 0x80(%r14)
movl 0x8(%r14), %ecx
movl %ecx, 0x50(%r14)
movq %rax, 0x30(%r14)
leaq 0xc45f(%rip), %rdx      # 0x15f8a
movl $0x2f, %esi
movl $0x70, %ecx
callq 0x42b0
movl %eax, 0xc(%r14)
testl %eax, %eax
je 0x9b4a
movq %r14, %rdi
callq 0x9b84
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x9b6e
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x9b6e
callq 0x42f0
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x9b7c
callq 0x42f0
movq %r14, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %esi
movq %r12, %rdi
callq 0x44b0
movq %rax, %r13
leaq 0x30(%rbx), %r15
movl %r13d, 0x38(%rbx)
movq 0xa0(%rbx), %rdi
callq 0x45e0
testl %eax, %eax
je 0x9f3d
movq %r15, %rdi
callq 0x4340
movl $0xffffffff, 0xc(%rbx)  # imm = 0xFFFFFFFF
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r13d, %r13d
je 0x9fd0
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 0x9fef
cmpl $0x2, %eax
je 0x9fe8
cmpl $-0x5, %eax
je 0x9fdc
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 0x41a0
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 0x9f56
jmp 0x9f2e
movl $0xfffffffd, 0xc(%rbx)  # imm = 0xFFFFFFFD
jmp 0x9f2e
movl $0x0, 0xc(%rbx)
jmp 0x9f2e
movl $0xfffffffd, 0xc(%rbx)  # imm = 0xFFFFFFFD
movq %r15, %rdi
callq 0x4340
movq %rbx, %rdi
callq 0x9b84
jmp 0x9f2e
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xbf22(%rip), %rdx      # 0x15f4c
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0x6b5c
leaq 0x10(%r15), %r14
movq %r14, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x43e0
movq %rax, %r12
movl 0xc(%r15), %eax
cmpq $-0x1, %r12
jne 0xa064
testl %eax, %eax
jne 0xa064
movq %r15, %rdi
callq 0x9ebc
jmp 0xa03a
cmpq $-0x1, %r12
setne %cl
cmpl $0x1, %eax
setne %dl
orb %cl, %dl
jne 0xa0a7
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x41c0
movq 0x18(%r15), %rdx
leaq 0xbec0(%rip), %rcx      # 0x15f4c
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x44f0
addq $0x30, %r15
movq %r15, %rdi
callq 0x4340
jmp 0xa0f2
cmpl $0x2, %eax
jae 0xa131
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x4330
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %r15
movq %r15, %rsi
callq 0x43b0
movq (%r15), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0xa0e2
callq 0x42f0
incq %r12
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x40a0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x48(%rbp), %rcx
cmpq %r13, %rcx
je 0xa10f
movq %rcx, (%rbx)
movq -0x38(%rbp), %rax
movq %rax, 0x10(%rbx)
jmp 0xa117
movups (%r13), %xmm0
movups %xmm0, (%rax)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%rbx)
movq %r13, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
jmp 0xa15b
leaq 0x30(%r15), %rdi
callq 0x4340
movq %r15, %rdi
callq 0x9b84
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xbdfc(%rip), %rdx      # 0x15f4c
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6b5c
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xa169
callq 0x42f0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa181
jmp 0xa181
jmp 0xa181
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xa192
callq 0x42f0
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa229
leaq 0xb7e0(%rip), %rcx      # 0x159be
movl $0x5, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x4400
testl %eax, %eax
jne 0xa229
leaq -0x40(%rbp), %r12
movl $0x5, %edx
movq %r12, %rdi
movq %r15, %rsi
movq $-0x1, %rcx
callq 0x4330
movq %r15, %rdi
movq %r12, %rsi
callq 0x43b0
movq (%r12), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0xa229
callq 0x42f0
cmpq $0x5, 0x8(%r15)
jb 0xa282
leaq 0xb787(%rip), %rcx      # 0x159be
movl $0x5, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4400
testl %eax, %eax
jne 0xa282
leaq -0x40(%rbp), %r12
movl $0x5, %edx
movq %r12, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x4330
movq %r14, %rdi
movq %r12, %rsi
callq 0x43b0
movq (%r12), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0xa282
callq 0x42f0
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x6876
leaq 0xbe68(%rip), %rsi      # 0x16110
movq %r15, %rdi
callq 0x45f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x40(%rbp), %rdi
callq 0x40f0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xa2e2
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xa2e8
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xa30d
callq 0x42f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa31f
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xa330
callq 0x42f0
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rax, %rax
je 0xb1d6
movq (%rsi), %rsi
movq (%rdx), %rdx
movq %rax, %xmm0
punpckldq 0xafa6(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xafae(%rip), %xmm0     # 0x16100
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
leaq 0x124eb(%rip), %rcx     # 0x1d650
movsd (%rcx), %xmm0
movb (%rsi), %dil
xorl %ecx, %ecx
cmpb (%rdx), %dil
setne %dil
jne 0xb17d
xorpd %xmm2, %xmm2
jmp 0xb185
movsd 0xaf63(%rip), %xmm2     # 0x160e8
movb %dil, %cl
divsd %xmm1, %xmm2
movb $0x1, %dil
ucomisd %xmm0, %xmm2
ja 0xb1d1
movl $0x1, %r8d
movq %r8, %rdi
cmpq %r8, %rax
je 0xb1ca
movb (%rsi,%rdi), %r8b
xorl %r9d, %r9d
cmpb (%rdx,%rdi), %r8b
setne %r9b
addl %r9d, %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
divsd %xmm1, %xmm2
leaq 0x1(%rdi), %r8
ucomisd %xmm0, %xmm2
jbe 0xb19b
cmpq %rdi, %rax
seta %dil
testb %dil, %dil
je 0xb1e0
movsd 0xaf0a(%rip), %xmm0     # 0x160e8
jmp 0xb1eb
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd %xmm1, %xmm0
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl $0x2, %ecx
jl 0xb954
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leal -0x1(%rcx), %edx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl $0x1, %esi
xorl %edi, %edi
movq %rdi, %r8
incq %rdi
movq %rsi, %r9
movl %r8d, %r11d
movl (%rax,%r9,4), %ebx
movslq %r11d, %r14
movl %r9d, %r10d
cmpl (%rax,%r14,4), %ebx
jl 0xb922
movl %r11d, %r10d
incq %r9
movl %r10d, %r11d
cmpq %r9, %rcx
jne 0xb90f
movl %r10d, %r9d
cmpq %r9, %r8
je 0xb948
movl (%rax,%r8,4), %r9d
movslq %r10d, %r10
movl (%rax,%r10,4), %r11d
movl %r11d, (%rax,%r8,4)
movl %r9d, (%rax,%r10,4)
incq %rsi
cmpq %rdx, %rdi
jne 0xb903
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb818
movq %rbx, %rdi
callq 0xb8d8
movq 0x30(%rbx), %r14
subq 0x28(%rbx), %r14
shrq $0x2, %r14
testl %r14d, %r14d
jle 0xb9a2
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
incq %r14
movq (%rbx), %rdi
movq 0x28(%rbx), %rax
movl -0x8(%rax,%r14,4), %esi
callq 0x13ca0
decq %r14
cmpq $0x1, %r14
jg 0xb988
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0xb9b0
movq %rax, 0x30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop