LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, %rax
leaq 0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x174a0
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rsi
callq 0x18a80
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x17733
movq -0x50(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x18b70
movb $0x1, -0x1(%rbp)
jmp 0x17737
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x17773
jmp 0x17792
leaq 0x3d27(%rip), %rdi      # 0x1b4a1
leaq 0x3c81(%rip), %rsi      # 0x1b402
movl $0x91, %edx
leaq 0x3d2a(%rip), %rcx      # 0x1b4b7
callq 0x3080
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x174e0
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x17848
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x17838
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x17690
jmp 0x1783a
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x177ca
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
shlq $0x3, %rsi
movq 0x8425(%rip), %rax      # 0x1fc80
movq %rax, -0x58(%rbp)
movq 0x8422(%rip), %rax      # 0x1fc88
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x170f0
movq -0x28(%rbp), %rdi
imulq $0x18, -0x18(%rbp), %rsi
movq 0x83f9(%rip), %rax      # 0x1fc80
movq %rax, -0x68(%rbp)
movq 0x83f6(%rip), %rax      # 0x1fc88
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0x170f0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: cphinton42[P]hinton-language/src/scope.h
// Function: Scope_Entry* set_find<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)>*, Atom, unsigned long)
T *set_find(Hash_Set<T,K,GK,H,Eq> *hs, K key, u64 hash)
{
    u64 slot = set_find_slot(hs, key, hash);
    if(hs->hashes[slot] == 0)
    {
        return nullptr;
    }
    else
    {
        return &hs->entries[slot];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rsi
callq 0x18a80
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x178fe
movq $0x0, -0x8(%rbp)
jmp 0x17912
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x17a77
movq $0x1, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
andq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x17aba
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17b48
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x28(%rbp), %rax
jne 0x17b25
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x38(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x17350
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0x17180
testb $0x1, %al
jne 0x17b1b
jmp 0x17b25
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17b48
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
andq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x17b43
jmp 0x17a9a
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x17b87
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x2, %rax
movq -0x10(%rbp), %rcx
imulq $0x3, (%rcx), %rcx
cmpq %rcx, %rax
jbe 0x17bec
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
shlq $0x2, %rsi
callq 0x18c20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x17df9
cmpq $0x0, -0x20(%rbp)
jne 0x17d64
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
imulq $0x18, 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x170f0
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x17df4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
imulq $0x18, 0x10(%rax), %rsi
imulq $0x18, -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x17e90
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x17daf
jmp 0x17dce
leaq 0x2a29(%rip), %rdi      # 0x1a7df
leaq 0x2a2c(%rip), %rsi      # 0x1a7e9
movl $0x129, %edx            # imm = 0x129
leaq 0x2a2c(%rip), %rcx      # 0x1a7f5
callq 0x3080
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jbe 0x17df2
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x17df4
jmp 0x17e89
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x17e05
jmp 0x17e24
leaq 0x2a29(%rip), %rdi      # 0x1a835
leaq 0x29d6(%rip), %rsi      # 0x1a7e9
movl $0x133, %edx            # imm = 0x133
leaq 0x29d6(%rip), %rcx      # 0x1a7f5
callq 0x3080
imulq $0x18, -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x170c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x17e5e
jmp 0x17e7d
leaq 0x297a(%rip), %rdi      # 0x1a7df
leaq 0x297d(%rip), %rsi      # 0x1a7e9
movl $0x136, %edx            # imm = 0x136
leaq 0x297d(%rip), %rcx      # 0x1a7f5
callq 0x3080
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: afinit[P]afin/contig.cpp
// Function: Contig::Contig()
Contig::Contig(){
  reads = 0;
  extension = 0;
  contig = "";
  contig_id = "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x10, %rdi
movq %rdi, -0x20(%rbp)
callq 0x4550
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x30(%rbp)
callq 0x4550
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x267e8(%rip), %rsi     # 0x2c1b8
callq 0x4520
jmp 0x59d7
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
leaq 0x267d2(%rip), %rsi     # 0x2c1b8
callq 0x4520
jmp 0x59ed
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x4270
movq -0x20(%rbp), %rdi
callq 0x4270
movq -0x10(%rbp), %rdi
callq 0x46c0
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x41b0
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x41b0
jmp 0x5bb2
movl $0xd8, %edi
callq 0x43d0
movq %rax, -0x40(%rbp)
jmp 0x5bc2
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
leaq 0x38aec(%rip), %rax     # 0x3e6c0
movl (%rax), %edx
callq 0x24a20
jmp 0x5bdd
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq 0x8(%rax), %rdi
callq 0x6430
jmp 0x5bfc
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
addq $0x50, %rsi
movq 0x8(%rax), %rdi
addq $0x50, %rdi
callq 0x6490
jmp 0x5c1b
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
addq $0x68, %rsi
movq 0x8(%rax), %rdi
addq $0x68, %rdi
callq 0x66e0
jmp 0x5c3a
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl 0xd0(%rcx), %edx
movq 0x8(%rax), %rcx
movl %edx, 0xd0(%rcx)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl 0xd4(%rcx), %edx
movq 0x8(%rax), %rcx
movl %edx, 0xd4(%rcx)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl 0x80(%rcx), %edx
movq 0x8(%rax), %rcx
movl %edx, 0x80(%rcx)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb 0x84(%rcx), %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x84(%rcx)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
addq $0x88, %rsi
movq 0x8(%rax), %rdi
addq $0x88, %rdi
callq 0x4060
jmp 0x5cc2
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
addq $0xa8, %rsi
movq 0x8(%rax), %rdi
addq $0xa8, %rdi
callq 0x4060
jmp 0x5ce7
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl 0xc8(%rcx), %ecx
movq 0x8(%rax), %rax
movl %ecx, 0xc8(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x5d43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x5d3a
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x43a0
movq -0x28(%rbp), %rdi
callq 0x4270
movq -0x38(%rbp), %rdi
callq 0x4270
movq -0x18(%rbp), %rdi
callq 0x46c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x6930
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6970
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x69b0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x69b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x18, %rdi
movq %rdi, -0x20(%rbp)
callq 0x4550
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x38(%rbp)
callq 0x4550
movq -0x30(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x28(%rbp)
callq 0x4550
movq -0x20(%rbp), %rdi
leaq 0x221d7(%rip), %rsi     # 0x2bd95
callq 0x4520
jmp 0x9bc5
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
leaq 0x225e4(%rip), %rsi     # 0x2c1b8
callq 0x4520
jmp 0x9bdb
movq -0x30(%rbp), %rdi
addq $0x58, %rdi
leaq 0x225ce(%rip), %rsi     # 0x2c1b8
callq 0x4520
jmp 0x9bf1
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x4270
movq -0x38(%rbp), %rdi
callq 0x4270
movq -0x20(%rbp), %rdi
callq 0x4270
movq -0x10(%rbp), %rdi
callq 0x46c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb970
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0xb0cf
jmp 0xb108
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x18(%rbp), %esi
callq 0x281a0
movq %rax, %rdi
xorl %esi, %esi
callq 0x5eb0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x18(%rbp), %esi
callq 0x281a0
movq %rax, %rdi
movl $0x1, %esi
callq 0x5eb0
jmp 0xb0bb
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x50, %rsi
leaq -0x20(%rbp), %rdi
callq 0xe9e0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xea20
jmp 0xb734
leaq -0x20(%rbp), %rdi
callq 0xea50
jmp 0xb73f
movq -0x38(%rbp), %rdi
addq $0x78, %rdi
callq 0x41f0
leaq -0x20(%rbp), %rdi
callq 0xeaa0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xeaa0
movq -0x28(%rbp), %rdi
callq 0x46c0
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
addq $0x50, %rsi
leaq -0x18(%rbp), %rdi
callq 0xe9e0
movq -0x30(%rbp), %rdi
callq 0xf820
movb %al, -0x31(%rbp)
jmp 0xb99f
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xb9a8
jmp 0xb9d2
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
leaq -0x18(%rbp), %rsi
callq 0x4150
jmp 0xb991
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xeaa0
jmp 0xba0d
movq -0x30(%rbp), %rdi
callq 0xf840
movq %rax, -0x40(%rbp)
jmp 0xb9e1
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
callq 0xf860
jmp 0xb9f5
movl -0x28(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xeaa0
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x46c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x4550
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4060
jmp 0xfa82
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, 0x4(%rax)
movb -0x15(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x28(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4270
movq -0x20(%rbp), %rdi
callq 0x46c0
nop
// File: 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
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x4550
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4060
jmp 0xfafb
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, 0x4(%rax)
movb $0x0, 0x28(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4270
movq -0x20(%rbp), %rdi
callq 0x46c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x15(%rbp)
je 0xfbb1
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
subl (%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xfbaf
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0x45e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xfbaf
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4770
movb (%rax), %al
movb %al, -0x1(%rbp)
jmp 0xfbfc
jmp 0xfbf8
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x45e0
movq -0x30(%rbp), %rcx
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
subl (%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xfbf6
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xfbf6
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0x24(%rbp), %rsi
callq 0x4770
movb (%rax), %al
movb %al, -0x1(%rbp)
jmp 0xfbfc
jmp 0xfbf8
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: afinit[P]afin/mismatch.cpp
// Function: Mismatch::Mismatch()
Mismatch::Mismatch(){
  score = 1.0;
  length = 0;
  index_i = 0;
  index_j = 0;
  end_i = 0;
  end_j = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x1c2bc(%rip), %xmm0    # 0x2c150
movsd %xmm0, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
cmpq $0x0, 0x2e658(%rip)     # 0x3e738
jne 0x1012d
movl $0x210, %edi            # imm = 0x210
callq 0x43d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x18(%rbp)
callq 0x100b0
jmp 0x100fd
movq -0x18(%rbp), %rax
movq %rax, 0x2e630(%rip)     # 0x3e738
leaq 0x2e631(%rip), %rdi     # 0x3e740
callq 0x4390
jmp 0x1012d
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
callq 0x43a0
jmp 0x1013a
movq 0x2e604(%rip), %rax     # 0x3e738
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x46c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x10, %edi
movl $0x20, %esi
callq 0x105f0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
movl %eax, %edx
callq 0x4540
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4030
testb $0x1, %al
jne 0x101a0
jmp 0x101d6
movq -0x20(%rbp), %rdi
movq 0x2de1d(%rip), %rax     # 0x3dfc8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x41a0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x1bf93(%rip), %rsi     # 0x2c158
movb $0x0, %al
callq 0x4580
movl $0x1, %edi
callq 0x4470
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x46e0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
leaq 0x1beeb(%rip), %rsi     # 0x2c1b8
callq 0x4530
jmp 0x102d4
leaq -0x12(%rbp), %rdi
callq 0x4420
xorl %eax, %eax
movl %eax, -0xc4(%rbp)
movl %eax, %edi
callq 0x4390
movq %rax, %rdi
movq 0x2e44a(%rip), %rsi     # 0x3e740
callq 0x4200
movl -0xc4(%rbp), %eax
cvttsd2si %xmm0, %ecx
movl %ecx, -0x94(%rbp)
movslq -0x94(%rbp), %rcx
movl %ecx, %edx
imulq $-0x6e5d4c3b, %rcx, %rcx # imm = 0x91A2B3C5
shrq $0x20, %rcx
addl %edx, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0xb, %ecx
addl %edx, %ecx
movl %ecx, -0x98(%rbp)
movslq -0x94(%rbp), %rdx
movl %edx, %ecx
imulq $-0x6e5d4c3b, %rdx, %rdx # imm = 0x91A2B3C5
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %esi
shrl $0x1f, %esi
sarl $0xb, %edx
addl %esi, %edx
imull $0xe10, %edx, %edx      # imm = 0xE10
subl %edx, %ecx
movl %ecx, -0x94(%rbp)
movslq -0x94(%rbp), %rcx
movl %ecx, %edx
imulq $-0x77777777, %rcx, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %edx, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
movl %ecx, -0x9c(%rbp)
movslq -0x94(%rbp), %rdx
movl %edx, %ecx
imulq $-0x77777777, %rdx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %esi
shrl $0x1f, %esi
sarl $0x5, %edx
addl %esi, %edx
imull $0x3c, %edx, %edx
subl %edx, %ecx
movl %ecx, -0x94(%rbp)
movl -0x98(%rbp), %edx
movl -0x9c(%rbp), %ecx
movl -0x94(%rbp), %r8d
leaq 0x1bdef(%rip), %rsi     # 0x2c1b9
leaq -0x90(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x40b0
movq -0xb0(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x4520
jmp 0x103f2
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1043b
jmp 0x1042f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4420
jmp 0x1044b
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4270
jmp 0x1044b
movq -0xb0(%rbp), %rdi
callq 0x4270
movq -0xb8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x46c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x2e26e(%rip), %rax     # 0x3e6f4
cmpl $0x0, (%rax)
je 0x10530
movq -0x68(%rbp), %rsi
movq %rsi, %rax
addq $0x10, %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x10280
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x4370
movq %rax, -0x78(%rbp)
jmp 0x104c4
movq -0x78(%rbp), %rdi
leaq 0x1bce8(%rip), %rsi     # 0x2c1b7
callq 0x43c0
movq %rax, -0x90(%rbp)
jmp 0x104dd
movq -0x70(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x4370
movq %rax, -0x98(%rbp)
jmp 0x104f6
movq -0x98(%rbp), %rdi
movq 0x2da8c(%rip), %rsi     # 0x3df90
callq 0x43f0
jmp 0x1050b
leaq -0x30(%rbp), %rdi
callq 0x4270
jmp 0x10530
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4270
jmp 0x105e5
leaq 0x2e1b9(%rip), %rax     # 0x3e6f0
cmpl $0x0, (%rax)
je 0x105dc
movq -0x68(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x10280
movq -0xa8(%rbp), %rsi
movq 0x2da5e(%rip), %rdi     # 0x3dfc0
callq 0x4370
movq %rax, -0xa0(%rbp)
jmp 0x10570
movq -0xa0(%rbp), %rdi
leaq 0x1bc39(%rip), %rsi     # 0x2c1b7
callq 0x43c0
movq %rax, -0xb0(%rbp)
jmp 0x1058c
movq -0x70(%rbp), %rsi
movq -0xb0(%rbp), %rdi
callq 0x4370
movq %rax, -0xb8(%rbp)
jmp 0x105a5
movq -0xb8(%rbp), %rdi
movq 0x2d9dd(%rip), %rsi     # 0x3df90
callq 0x43f0
jmp 0x105ba
leaq -0x60(%rbp), %rdi
callq 0x4270
jmp 0x105dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4270
jmp 0x105e5
addq $0xc0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x46c0
nop
// File: 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
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x11380
movq -0x40(%rbp), %rax
leaq 0x2d574(%rip), %rcx     # 0x3dd00
movq %rcx, (%rax)
movl $0x4000, 0x8(%rax)      # imm = 0x4000
addq $0x10, %rax
movq %rax, -0x38(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x46e0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x1b9fe(%rip), %rsi     # 0x2c1b8
callq 0x4530
jmp 0x107c1
leaq -0x11(%rbp), %rdi
callq 0x4420
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0xa8, %rdi
movq %rdi, -0x50(%rbp)
callq 0x41b0
jmp 0x107e4
movq -0x48(%rbp), %rdi
callq 0x41a0
movq %rax, %rdi
leaq 0x1b9fc(%rip), %rsi     # 0x2c1f3
callq 0x4450
movq %rax, -0x58(%rbp)
jmp 0x10802
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0xa0(%rax)
movq %rax, %rdi
addq $0x30, %rdi
movq $0x0, 0x70(%rax)
movq $0x0, 0x78(%rax)
movq $0x0, 0x80(%rax)
movl $0x0, 0x38(%rax)
movl 0x8(%rax), %ecx
movl %ecx, 0x50(%rax)
movq $0x0, 0x30(%rax)
leaq 0x1b9a7(%rip), %rdx     # 0x2c1f6
movl $0x2f, %esi
movl $0x70, %ecx
callq 0x4350
movl %eax, -0x5c(%rbp)
jmp 0x10863
movq -0x40(%rbp), %rax
movl -0x5c(%rbp), %ecx
movl %ecx, 0xc(%rax)
cmpl $0x0, 0xc(%rax)
je 0x108bc
movq -0x40(%rbp), %rdi
callq 0x108e0
jmp 0x1087e
jmp 0x108bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x4420
jmp 0x108cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x108c2
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4270
jmp 0x108c2
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4270
movq -0x20(%rbp), %rdi
callq 0x46c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rcx, -0xb0(%rbp)
movq %rdx, -0xa8(%rbp)
movq %rdi, %rax
movq -0xa8(%rbp), %rdi
movq %rax, -0xa0(%rbp)
movq %rax, %rdx
movq %rdx, -0x98(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x45e0
cmpq $0x5, %rax
jb 0x11495
movq -0xa8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x5, %edx
leaq 0x1a6f4(%rip), %rcx     # 0x2bb4a
callq 0x4510
cmpl $0x0, %eax
jne 0x11495
movq -0xa8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x5, %edx
movq $-0x1, %rcx
callq 0x43e0
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4480
leaq -0x40(%rbp), %rdi
callq 0x4270
movq -0xa8(%rbp), %rdi
callq 0x45e0
cmpq $0x5, %rax
jb 0x114fd
movq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x5, %edx
leaq 0x1a68c(%rip), %rcx     # 0x2bb4a
callq 0x4510
cmpl $0x0, %eax
jne 0x114fd
movq -0xb0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movl $0x5, %edx
movq $-0x1, %rcx
callq 0x43e0
movq -0xb0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4480
leaq -0x60(%rbp), %rdi
callq 0x4270
movq -0xa8(%rbp), %rsi
leaq 0x1ae75(%rip), %rdx     # 0x2c380
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xb230
movq -0xa0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
callq 0x6a10
jmp 0x11537
leaq -0x80(%rbp), %rdi
callq 0x4270
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4270
movq -0x88(%rbp), %rdi
callq 0x46c0
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
callq 0x45e0
cmpq $0x0, %rax
jne 0x1254b
movsd 0x19c0f(%rip), %xmm0    # 0x2c150
movsd %xmm0, -0x8(%rbp)
jmp 0x1266a
movl $0x0, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x45e0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x12618
movq -0x40(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x4770
movq -0x38(%rbp), %rdi
movsbl (%rax), %eax
movl %eax, -0x54(%rbp)
movslq -0x28(%rbp), %rsi
callq 0x4770
movq %rax, %rcx
movl -0x54(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x125a9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x40(%rbp), %rdi
cvtsi2sdl -0x24(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
callq 0x45e0
movsd -0x60(%rbp), %xmm0
movq %rax, %xmm1
movaps 0x19d93(%rip), %xmm2    # 0x2c360
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x19d97(%rip), %xmm2    # 0x2c370
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
leaq 0x2c10d(%rip), %rax     # 0x3e700
ucomisd (%rax), %xmm0
jbe 0x12608
movsd 0x19b4f(%rip), %xmm0    # 0x2c150
movsd %xmm0, -0x8(%rbp)
jmp 0x1266a
jmp 0x1260a
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x12552
movq -0x40(%rbp), %rdi
cvtsi2sdl -0x24(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
callq 0x45e0
movsd -0x68(%rbp), %xmm0
movq %rax, %xmm1
movaps 0x19d24(%rip), %xmm2    # 0x2c360
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x19d28(%rip), %xmm2    # 0x2c370
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
addq $0x28, %rdi
callq 0x8960
movq %rax, %rcx
movl -0x3c(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x13152
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x28, %rdi
callq 0x8960
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x13142
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movslq -0xc(%rbp), %rsi
callq 0x153d0
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x153d0
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cmpl (%rcx), %eax
jne 0x13132
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x58(%rbp)
addq $0x28, %rdi
callq 0x97b0
movq %rax, -0x28(%rbp)
movslq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x99d0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x15460
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x153f0
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13134
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13088
jmp 0x13144
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1305b
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0x28, %rdi
callq 0x8960
movq %rax, %rcx
movl -0x24(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x13285
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
addq $0x28, %rdi
callq 0x8960
movq %rax, %rcx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jge 0x1320f
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movslq -0x18(%rbp), %rsi
callq 0x153d0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0x153d0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x13202
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x13204
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x131ae
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x13275
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x153d0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0xc(%rbp)
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0x153d0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x34(%rbp)
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x153d0
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rdi
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0x153d0
movl -0x30(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x13277
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1317b
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x13040
movq -0x18(%rbp), %rdi
callq 0x13160
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x8960
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x132f9
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
movslq -0xc(%rbp), %rsi
callq 0x153d0
movq -0x20(%rbp), %rdi
movl (%rax), %esi
callq 0x281f0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x132c5
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x154a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x20(%rax)
je 0x17535
movq -0x10(%rbp), %rdi
callq 0x17550
jmp 0x1753e
movq -0x10(%rbp), %rdi
callq 0x17940
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x74e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x17e9c
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x17f50
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %esi
movb 0x20(%rax), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xfb40
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x17e8f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x17e91
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x17e35
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x2438d(%rip), %rdi     # 0x3e748
callq 0x1b790
movq %rax, %rsi
leaq 0x24396(%rip), %rdi     # 0x3e760
callq 0x1b700
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x2437b(%rip), %rdi     # 0x3e760
callq 0x1b7b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1a420
movslq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0xc(%rbp), %rsi
leaq 0x24357(%rip), %rdi     # 0x3e760
callq 0x1b7d0
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a3d6
leaq 0x24339(%rip), %rdi     # 0x3e760
callq 0x1b8d0
movq %rax, -0x18(%rbp)
leaq 0x24329(%rip), %rdi     # 0x3e760
callq 0x1b900
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x99d(%rip), %rcx       # 0x1adf0
callq 0x1b7f0
addq $0x40, %rsp
popq %rbp
retq
nop