LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_num_of_seqs
static GtUword gt_encseq_col_num_of_seqs(const GtSeqCol *sc,
                                               GtUword filenum)
{
  GtEncseqCol *esc;
  /* XXX cache function evaluated values */
  esc = gt_encseq_col_cast(sc);
  gt_assert(esc && filenum < gt_encseq_num_of_files(esc->encseq));
  if (gt_encseq_num_of_files(esc->encseq) == 1 && filenum == 0)
    return gt_encseq_num_of_sequences(esc->encseq);
  else if (filenum == gt_encseq_num_of_files(esc->encseq) - 1) {
    return (gt_encseq_num_of_sequences(esc->encseq)
              - gt_encseq_filenum_first_seqnum(esc->encseq, filenum));
  } else {
    GtUword firstpos, nextpos;
    gt_assert(filenum < gt_encseq_num_of_files(esc->encseq) - 1);
    firstpos = gt_encseq_filenum_first_seqnum(esc->encseq, filenum);
    nextpos = gt_encseq_filenum_first_seqnum(esc->encseq, filenum + 1);
    return nextpos - firstpos;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd3d78
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8196
testq %rax, %rax
je 0xd473c
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xc7f91
cmpq %rbx, %rax
jbe 0xd473c
movq 0x8(%r14), %rdi
callq 0xc7f91
movq 0x8(%r14), %rdi
testq %rbx, %rbx
jne 0xd46d2
cmpq $0x1, %rax
jne 0xd46d2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbff74
callq 0xc7f91
decq %rax
movq 0x8(%r14), %rdi
cmpq %rbx, %rax
jne 0xd46fc
callq 0xbff74
movq %rax, %r15
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xce880
subq %rax, %r15
jmp 0xd472d
callq 0xc7f91
decq %rax
cmpq %rbx, %rax
jbe 0xd4741
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xce880
movq %rax, %r12
movq 0x8(%r14), %rdi
incq %rbx
movq %rbx, %rsi
callq 0xce880
movq %rax, %r15
subq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x30389
callq 0x30350
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_get_md5_fingerprint
static const char* gt_encseq_col_get_md5_fingerprint(const GtSeqCol *sc,
                                                     GtUword filenum,
                                                     GtUword seqnum)
{
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_assert(esc && filenum < gt_encseq_num_of_files(esc->encseq));
  return gt_md5_tab_get(esc->md5_tab,
                        gt_encseq_filenum_first_seqnum(esc->encseq,
                                                       filenum) + seqnum);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xd3d78
movq %rax, %rdi
movq %r15, %rsi
callq 0xd8196
testq %rax, %rax
je 0xd479d
movq %rax, %r15
movq 0x8(%rax), %rdi
callq 0xc7f91
cmpq %r14, %rax
jbe 0xd479d
movq 0x8(%r15), %rdi
movq 0x10(%r15), %r15
movq %r14, %rsi
callq 0xce880
addq %rax, %rbx
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd7d20
callq 0x303c2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_get_sequence
static char* gt_encseq_col_get_sequence(const GtSeqCol *sc,
                                        GtUword filenum,
                                        GtUword seqnum,
                                        GtUword start,
                                        GtUword end)
{
  GtEncseqCol *esc;
  char *out;
  GtUword encseq_seqnum, startpos;
  esc = gt_encseq_col_cast(sc);
  gt_assert(esc && filenum < gt_encseq_num_of_files(esc->encseq));
  encseq_seqnum = gt_encseq_filenum_first_seqnum(esc->encseq, filenum) + seqnum;
  gt_assert(encseq_seqnum < gt_encseq_num_of_sequences(esc->encseq));
  gt_assert(start <= end);
  startpos = gt_encseq_seqstartpos(esc->encseq, encseq_seqnum);
  out = gt_calloc(end - start + 1, sizeof (char));
  gt_encseq_extract_decoded(esc->encseq, out, startpos + start, startpos + end);
  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
callq 0xd3d78
movq %rax, %rdi
movq %r15, %rsi
callq 0xd8196
testq %rax, %rax
je 0xd485f
movq %rax, %r15
movq 0x8(%rax), %rdi
callq 0xc7f91
cmpq %r13, %rax
jbe 0xd485f
movq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0xce880
movq %rax, %r13
addq %r12, %r13
movq 0x8(%r15), %rdi
callq 0xbff74
cmpq %rax, %r13
jae 0xd4864
movq %rbx, %r12
subq %r14, %r12
jb 0xd4869
movq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0xc3ab6
movq %rax, %r13
incq %r12
leaq 0x336e1(%rip), %rdx     # 0x107f06
movl $0x1, %esi
movq %r12, %rdi
movl $0x18d, %ecx            # imm = 0x18D
callq 0x359a6
movq %rax, %r12
movq 0x8(%r15), %rdi
addq %r13, %r14
addq %r13, %rbx
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xc1686
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3046d
callq 0x303fb
callq 0x30434
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_get_description
static char* gt_encseq_col_get_description(const GtSeqCol *sc,
                                           GtUword filenum,
                                           GtUword seqnum)
{
  GtEncseqCol *esc;
  const char *desc;
  GtUword encseq_seqnum, desclen;
  esc = gt_encseq_col_cast(sc);
  gt_assert(esc && filenum < gt_encseq_num_of_files(esc->encseq));
  encseq_seqnum = gt_encseq_filenum_first_seqnum(esc->encseq, filenum) + seqnum;
  gt_assert(encseq_seqnum < gt_encseq_num_of_sequences(esc->encseq));
  desc = gt_encseq_description(esc->encseq, &desclen, encseq_seqnum);
  gt_assert(desc && desclen > 0);
  return gt_cstr_dup_nt(desc, desclen);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xd3d78
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8196
testq %rax, %rax
je 0xd48f8
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xc7f91
cmpq %r15, %rax
jbe 0xd48f8
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xce880
movq %rax, %r15
addq %rbx, %r15
movq 0x8(%r14), %rdi
callq 0xbff74
cmpq %rax, %r15
jae 0xd48fd
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0xc4566
testq %rax, %rax
je 0xd4902
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0xd4902
movq %rax, %rdi
callq 0x72903
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x30518
callq 0x304a6
callq 0x304df
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_get_sequence_length
static GtUword gt_encseq_col_get_sequence_length(const GtSeqCol *sc,
                                                       GtUword filenum,
                                                       GtUword seqnum)
{
  GtEncseqCol *esc;
  GtUword encseq_seqnum;
  esc = gt_encseq_col_cast(sc);
  gt_assert(esc && filenum < gt_encseq_num_of_files(esc->encseq));
  encseq_seqnum = gt_encseq_filenum_first_seqnum(esc->encseq, filenum) + seqnum;
  return gt_encseq_seqlength(esc->encseq, encseq_seqnum);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xd3d78
movq %rax, %rdi
movq %r15, %rsi
callq 0xd8196
testq %rax, %rax
je 0xd495b
movq %rax, %r15
movq 0x8(%rax), %rdi
callq 0xc7f91
cmpq %r14, %rax
jbe 0xd495b
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0xce880
addq %rax, %rbx
movq 0x8(%r15), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xc3d9a
callq 0x30551
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_new
GtSeqCol* gt_encseq_col_new(GtEncseq *encseq, GtError *err)
{
  GtSeqCol *sc;
  GtEncseqCol *esc;
  gt_error_check(err);
  gt_assert(encseq);
  if (!gt_encseq_has_md5_support(encseq)) {
    gt_error_set(err, "encoded sequence has no MD5 support");
    return NULL;
  }
  sc = gt_seq_col_create(gt_encseq_col_class());
  esc = gt_encseq_col_cast(sc);
  esc->duplicates = NULL;
  esc->md5_tab = gt_encseq_get_md5_tab(encseq, err);
  gt_assert(esc->md5_tab);
  esc->encseq = gt_encseq_ref(encseq);
  esc->matchstart = false;
  return sc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0xd4983
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xd4a15
testq %rbx, %rbx
je 0xd4a10
movq %rbx, %rdi
callq 0xc4c8c
testb %al, %al
je 0xd49ed
callq 0xd3d78
movq %rax, %rdi
callq 0xd812a
movq %rax, %r15
callq 0xd3d78
movq %rax, %rdi
movq %r15, %rsi
callq 0xd8196
movq %rax, %r12
movq $0x0, 0x20(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc4c5b
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0xd4a1a
movq %rbx, %rdi
callq 0xc2d86
movq %rax, 0x8(%r12)
movb $0x0, 0x28(%r12)
jmp 0xd4a01
leaq 0x33559(%rip), %rsi     # 0x107f4d
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x34f1f
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x305fc
callq 0x3058a
callq 0x305c3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq_metadata.c
// Function: gt_encseq_metadata_delete
void gt_encseq_metadata_delete(GtEncseqMetadata *emd)
{
  if (emd == NULL) return;
  if (emd->alpha != NULL)
    gt_alphabet_delete(emd->alpha);
  gt_free(emd);
}

// Assembly:
testq %rdi, %rdi
je 0xd541b
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0xd5406
callq 0xba400
leaq 0x32ee4(%rip), %rsi     # 0x1082f1
movq %rbx, %rdi
movl $0x115, %edx            # imm = 0x115
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq_options.c
// Function: gt_encseq_options_add_readmode_option
void gt_encseq_options_add_readmode_option(GtOptionParser *op, GtStr *readmode)
{
  GtOption *optiondir;
  gt_assert(op && readmode);
  optiondir = gt_option_new_string("dir", "specify reading direction "
                                          "(fwd, cpl, rev, rcl)",
                                   readmode, "fwd");
  gt_option_parser_add_option(op, optiondir);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xd5adb
movq %rsi, %rdx
testq %rsi, %rsi
je 0xd5adb
movq %rdi, %rbx
leaq 0x25cda(%rip), %rdi     # 0xfb796
leaq 0x32cf0(%rip), %rsi     # 0x1087b3
leaq 0x31097(%rip), %rcx     # 0x106b61
callq 0x38e78
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x363c8
callq 0x30b83
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq_options.c
// Function: gt_encseq_options_delete
void gt_encseq_options_delete(GtEncseqOptions *oi)
{
  if (oi == NULL) return;
  gt_str_delete(oi->indexname);
  gt_str_delete(oi->smap);
  gt_str_delete(oi->sat);
  gt_str_delete(oi->dir);
  gt_str_array_delete(oi->db);
  if (!oi->withdb) {
    gt_option_delete(oi->optiondb);
  }
  if (!oi->withindexname) {
    gt_option_delete(oi->optionindexname);
  }
  gt_free(oi);
}

// Assembly:
testq %rdi, %rdi
je 0xd5e22
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3c87b
movq 0x10(%rbx), %rdi
callq 0x3c87b
movq 0x8(%rbx), %rdi
callq 0x3c87b
movq 0x18(%rbx), %rdi
callq 0x3c87b
movq 0xc8(%rbx), %rdi
callq 0x3cc00
cmpb $0x0, 0xda(%rbx)
jne 0xd5dfb
movq 0x20(%rbx), %rdi
callq 0x38872
cmpb $0x0, 0xdb(%rbx)
jne 0xd5e0d
movq 0x28(%rbx), %rdi
callq 0x38872
leaq 0x3292d(%rip), %rsi     # 0x108741
movq %rbx, %rdi
movl $0x1be, %edx            # imm = 0x1BE
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mapspec.c
// Function: gt_mapspec_pad
int gt_mapspec_pad(FILE *fp, GtUword *bytes_written,
                   GtUword byteoffset, GT_UNUSED GtError *err)
{
  if (byteoffset % (GtUword) GT_WORDSIZE_INBYTES > 0)
  {
    GtUchar padbuffer[GT_WORDSIZE_INBYTES-1] = {0};

    size_t padunits = GT_WORDSIZE_INBYTES - (byteoffset % GT_WORDSIZE_INBYTES);
    gt_xfwrite(padbuffer,sizeof (GtUchar),padunits,fp);
    *bytes_written = (GtUword) padunits;
  } else
  {
    *bytes_written = 0;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %r14d, %r14d
andq $0x7, %rdx
je 0xd67be
movq %rdi, %rcx
movq %rsp, %rdi
movl %r14d, 0x3(%rdi)
movl %r14d, (%rdi)
movl $0x8, %r14d
subq %rdx, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x3d320
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mapspec.c
// Function: gt_mapspec_add_specialcharinfo_ptr
void gt_mapspec_add_specialcharinfo_ptr(GtMapspec *mapspec,
                                        GtSpecialcharinfo **ptr,
                                        GtUword n)
{
  GtMapspecification *mapspecptr;
  gt_assert(mapspec && ptr);
  NEWMAPSPEC(mapspec, ptr, GtSpecialcharinfoType, sizeof (GtSpecialcharinfo),
             n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd6fed
movq %rsi, %r14
testq %rsi, %rsi
je 0xd6fed
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jae 0xd6f81
movq (%r15), %rax
jmp 0xd6fac
leaq 0xa(%rax), %rcx
movq %rcx, 0x8(%r15)
movq (%r15), %rdi
leaq 0x50(,%rax,8), %rax
leaq (%rax,%rax,4), %rsi
leaq 0x323b9(%rip), %rdx     # 0x109358
movl $0x22f, %ecx            # imm = 0x22F
callq 0x35a9d
movq %rax, (%r15)
testq %rax, %rax
je 0xd6ff2
movq 0x10(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r15)
leaq (%rcx,%rcx,4), %rcx
movl $0xb, (%rax,%rcx,8)
movq %r14, 0x10(%rax,%rcx,8)
movq $0x70, 0x18(%rax,%rcx,8)
movq %rbx, 0x20(%rax,%rcx,8)
leaq 0x32614(%rip), %rdx     # 0x1095f6
movq %rdx, 0x8(%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
callq 0x31c2a
callq 0x31c63
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mapspec.c
// Function: gt_mapspec_add_filelengthvalues_ptr
void gt_mapspec_add_filelengthvalues_ptr(GtMapspec *mapspec,
                                         GtFilelengthvalues **ptr,
                                         GtUword n)
{
  GtMapspecification *mapspecptr;
  gt_assert(mapspec && ptr);
  NEWMAPSPEC(mapspec, ptr, GtFilelengthvaluesType,
             sizeof (GtFilelengthvalues), n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd7137
movq %rsi, %r14
testq %rsi, %rsi
je 0xd7137
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jae 0xd70cb
movq (%r15), %rax
jmp 0xd70f6
leaq 0xa(%rax), %rcx
movq %rcx, 0x8(%r15)
movq (%r15), %rdi
leaq 0x50(,%rax,8), %rax
leaq (%rax,%rax,4), %rsi
leaq 0x3226f(%rip), %rdx     # 0x109358
movl $0x241, %ecx            # imm = 0x241
callq 0x35a9d
movq %rax, (%r15)
testq %rax, %rax
je 0xd713c
movq 0x10(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r15)
leaq (%rcx,%rcx,4), %rcx
movl $0x1, (%rax,%rcx,8)
movq %r14, 0x10(%rax,%rcx,8)
movq $0x10, 0x18(%rax,%rcx,8)
movq %rbx, 0x20(%rax,%rcx,8)
leaq 0x32508(%rip), %rdx     # 0x109634
movq %rdx, 0x8(%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
callq 0x31d0e
callq 0x31d47
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_encoder.c
// Function: gt_md5_encoder_new
GtMD5Encoder* gt_md5_encoder_new()
{
  GtMD5Encoder *enc = gt_malloc(sizeof (GtMD5Encoder));
  enc->len = 0;
  enc->status = 0;
  memset(enc->d_old, 0, sizeof (WORD32)*4);
  memset(enc->wbuff, 0, sizeof (WORD32)*16);
  inic_digest(enc->d);
  return enc;
}

// Assembly:
pushq %rax
leaq 0x3244c(%rip), %rsi     # 0x1096e0
movl $0x70, %edi
movl $0xc4, %edx
callq 0x35862
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x5c(%rax)
movaps 0x3240b(%rip), %xmm0    # 0x1096d0
movups %xmm0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_encoder.c
// Function: gt_md5_encoder_reset
void gt_md5_encoder_reset(GtMD5Encoder *enc)
{
  gt_assert(enc);
  enc->len = 0;
  enc->status = 0;
  memset(enc->d_old, 0, sizeof (WORD32)*4);
  memset(enc->wbuff, 0, sizeof (WORD32)*16);
  inic_digest(enc->d);
}

// Assembly:
testq %rdi, %rdi
je 0xd72f5
xorps %xmm0, %xmm0
movups %xmm0, 0x5c(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movaps 0x323df(%rip), %xmm0    # 0x1096d0
movups %xmm0, (%rdi)
retq
pushq %rax
callq 0x31e64
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_encoder.c
// Function: gt_md5_encoder_add_block
void gt_md5_encoder_add_block(GtMD5Encoder *enc, const char *message,
                              GtUword len)
{
  gt_assert(enc && message && len < 65);
  if (enc->len > 0) {
    digest(enc->wbuff, enc->d);
    enc->d[0]+=enc->d_old[0]; enc->d[1]+=enc->d_old[1];
    enc->d[2]+=enc->d_old[2]; enc->d[3]+=enc->d_old[3];
  }
  enc->d_old[0]=enc->d[0]; enc->d_old[1]=enc->d[1];
  enc->d_old[2]=enc->d[2]; enc->d_old[3]=enc->d[3];
  enc->status = converte(enc->wbuff, message, len, enc->status);
  enc->len += len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd736d
movq %rsi, %r15
testq %rsi, %rsi
je 0xd736d
movq %rdx, %rbx
cmpq $0x41, %rdx
jae 0xd736d
movq %rdi, %r14
cmpq $0x0, 0x60(%rdi)
je 0xd7342
leaq 0x20(%r14), %rdi
movq %r14, %rsi
callq 0xd7372
movdqu (%r14), %xmm1
movdqu 0x10(%r14), %xmm0
paddd %xmm1, %xmm0
movdqu %xmm0, (%r14)
jmp 0xd7347
movdqu (%r14), %xmm0
movdqu %xmm0, 0x10(%r14)
leaq 0x20(%r14), %rdi
movl 0x68(%r14), %ecx
movq %r15, %rsi
movl %ebx, %edx
callq 0xd7648
movl %eax, 0x68(%r14)
addq %rbx, 0x60(%r14)
popq %rbx
popq %r14
popq %r15
retq
callq 0x31e9d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_encoder.c
// Function: converte
static int converte (WORD32 *x, const char *pt, int num, int old_status) {
  int new_status = 0;
  char buff[64];
  if (num<64) {
    memcpy(buff, pt, num);  /* to avoid changing original string */
    memset(buff+num, 0, 64-num);
    if (old_status == 0)
      buff[num] = '\200';
    new_status = 1;
    pt = buff;
  }
  bytestoword32(x, pt);
  if (num <= (64 - 9))
    new_status = 2;
  return new_status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
movq %rdi, %r14
xorl %eax, %eax
cmpl $0x3f, %edx
jg 0xd7697
movl %ecx, %ebp
movl %ebx, %r12d
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rdx
callq 0xb520
addq %rsp, %r12
movl $0x40, %edx
subl %ebx, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0xb2f0
movl $0x1, %eax
testl %ebp, %ebp
jne 0xd769a
movb $-0x80, (%r12)
jmp 0xd769a
movq %rsi, %r15
xorl %ecx, %ecx
movl (%r15,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
cmpq $0x10, %rcx
jne 0xd769c
cmpl $0x38, %ebx
movl $0x2, %ecx
cmovll %ecx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_encoder.c
// Function: gt_md5_encoder_finish
void gt_md5_encoder_finish(GtMD5Encoder *enc, unsigned char *output,
                           char *outstr)
{
  gt_assert(enc && output);
  if (enc->status != 2) {
    if (enc->len > 0) {
      digest(enc->wbuff, enc->d);
      enc->d[0]+=enc->d_old[0]; enc->d[1]+=enc->d_old[1];
      enc->d[2]+=enc->d_old[2]; enc->d[3]+=enc->d_old[3];
    }
    enc->d_old[0]=enc->d[0]; enc->d_old[1]=enc->d[1];
    enc->d_old[2]=enc->d[2]; enc->d_old[3]=enc->d[3];
    enc->status = converte(enc->wbuff, NULL, 0, enc->status);
    gt_assert(enc->status == 2);
  }
  put_length(enc->wbuff, enc->len);
  digest(enc->wbuff, enc->d);
  enc->d[0]+=enc->d_old[0]; enc->d[1]+=enc->d_old[1];
  enc->d[2]+=enc->d_old[2]; enc->d[3]+=enc->d_old[3];
  word32tobytes(enc->d, (char*) output);
  if (outstr) {
    snprintf(outstr, 33,
             "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
             output[0], output[1], output[2], output[3], output[4], output[5],
             output[6], output[7], output[8], output[9], output[10], output[11],
             output[12], output[13], output[14], output[15]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0xd786c
movq %rsi, %r14
testq %rsi, %rsi
je 0xd786c
movq %rdx, %rbx
movq %rdi, %r15
movl 0x68(%rdi), %ecx
cmpl $0x2, %ecx
je 0xd7748
cmpq $0x0, 0x60(%r15)
je 0xd7723
leaq 0x20(%r15), %rdi
movq %r15, %rsi
callq 0xd7372
movdqu (%r15), %xmm1
movdqu 0x10(%r15), %xmm0
paddd %xmm1, %xmm0
movdqu %xmm0, (%r15)
movl 0x68(%r15), %ecx
jmp 0xd7728
movdqu (%r15), %xmm0
movdqu %xmm0, 0x10(%r15)
leaq 0x20(%r15), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd7648
movl %eax, 0x68(%r15)
cmpl $0x2, %eax
jne 0xd7871
leaq 0x20(%r15), %rdi
movl 0x60(%r15), %eax
leal (,%rax,8), %ecx
movl %ecx, 0x58(%r15)
shrl $0x1d, %eax
movl %eax, 0x5c(%r15)
movq %r15, %rsi
callq 0xd7372
movdqu (%r15), %xmm0
movdqu 0x10(%r15), %xmm1
paddd %xmm0, %xmm1
movdqu %xmm1, (%r15)
movq $-0x4, %rax
movl 0x4(%r15,%rax), %ecx
movl %ecx, 0x4(%r14,%rax)
addq $0x4, %rax
cmpq $0xc, %rax
jb 0xd7785
testq %rbx, %rbx
je 0xd785d
movzbl (%r14), %ecx
movzbl 0x1(%r14), %r8d
movzbl 0x2(%r14), %r9d
movzbl 0x3(%r14), %eax
movq %rax, 0x30(%rsp)
movzbl 0x4(%r14), %eax
movq %rax, 0x28(%rsp)
movzbl 0x5(%r14), %eax
movq %rax, 0x20(%rsp)
movzbl 0x6(%r14), %eax
movq %rax, 0x18(%rsp)
movzbl 0x7(%r14), %eax
movq %rax, 0x10(%rsp)
movzbl 0x8(%r14), %eax
movq %rax, 0x8(%rsp)
movzbl 0x9(%r14), %r10d
movzbl 0xa(%r14), %r11d
movzbl 0xb(%r14), %r15d
movzbl 0xc(%r14), %r12d
movzbl 0xd(%r14), %r13d
movzbl 0xe(%r14), %ebp
movzbl 0xf(%r14), %r14d
subq $0x8, %rsp
leaq 0x31f5b(%rip), %rdx     # 0x109775
movl $0x21, %esi
movq %rbx, %rdi
xorl %eax, %eax
pushq %r14
pushq %rbp
pushq %r13
pushq %r12
pushq %r15
pushq %r11
pushq %r10
pushq 0x48(%rsp)
pushq 0x58(%rsp)
pushq 0x68(%rsp)
pushq 0x78(%rsp)
pushq 0x88(%rsp)
pushq 0x98(%rsp)
callq 0xba10
addq $0xa8, %rsp
jmp 0xd7861
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x31ed6
callq 0x31f0f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_tab.c
// Function: read_fingerprints
static bool read_fingerprints(GtMD5Tab *md5_tab,
                              const char *fingerprints_filename,
                              bool use_file_locking)
{
  bool reading_succeeded = true;
  size_t len = 0;
  gt_assert(md5_tab && fingerprints_filename);
  /* open file */
  gt_assert(gt_file_exists(fingerprints_filename));
  if (use_file_locking) {
    md5_tab->fingerprints_file = gt_fa_xfopen(fingerprints_filename, "r");
    gt_fa_lock_shared(md5_tab->fingerprints_file);
  }
  md5_tab->fingerprints = gt_fa_xmmap_read(fingerprints_filename, &len);
  if (len != md5_tab->num_of_md5s * 33) {
    gt_fa_xmunmap(md5_tab->fingerprints);
    md5_tab->fingerprints = NULL;
    gt_fa_unlock(md5_tab->fingerprints_file);
    gt_fa_xfclose(md5_tab->fingerprints_file);
    md5_tab->fingerprints_file = NULL;
    reading_succeeded = false;
  }
  return reading_succeeded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0xd7ba7
movq %rsi, %r14
testq %rsi, %rsi
je 0xd7ba7
movl %edx, %ebp
movq %rdi, %rbx
movq %r14, %rdi
callq 0x76120
testb %al, %al
je 0xd7bac
testb %bpl, %bpl
je 0xd7b3c
leaq 0x17340(%rip), %rsi     # 0xeee5d
leaq 0x31ddb(%rip), %rdx     # 0x1098ff
movq %r14, %rdi
movl $0x2f, %ecx
callq 0x743ed
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x745b4
leaq 0x31dbc(%rip), %rdx     # 0x1098ff
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x32, %ecx
callq 0x74ee3
movq %rax, 0x8(%rbx)
movq (%r15), %r14
movq 0x18(%rbx), %rcx
movq %rcx, %r15
shlq $0x5, %r15
addq %rcx, %r15
cmpq %r15, %r14
je 0xd7b94
movq %rax, %rdi
callq 0x750ec
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
movq (%rbx), %rdi
callq 0x745e4
movq (%rbx), %rdi
callq 0x74532
movq %r12, (%rbx)
cmpq %r15, %r14
sete %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x31fed
callq 0x32024
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_tab.c
// Function: gt_md5_tab_new_from_cache_file
GtMD5Tab* gt_md5_tab_new_from_cache_file(const char *cache_file,
                                         GtUword num_of_seqs,
                                         bool use_file_locking,
                                         GtError *err)
{
  GtMD5Tab *md5_tab;
  bool reading_succeeded = false;
  gt_assert(cache_file);
  gt_error_check(err);

  md5_tab = gt_calloc(1, sizeof *md5_tab);
  md5_tab->num_of_md5s = num_of_seqs;
  if (gt_file_exists(cache_file)) {
    reading_succeeded = read_fingerprints(md5_tab,
                                          cache_file,
                                          use_file_locking);
  }
  if (!reading_succeeded) {
    gt_free(md5_tab);
    gt_error_set(err, "could not read fingerprints file \"%s\" or "
                      "invalid file contents", cache_file);
    return NULL;
  }
  md5_tab->owns_md5s = false;
  return md5_tab;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xd7c61
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0xd7be2
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xd7c66
leaq 0x31d16(%rip), %rdx     # 0x1098ff
movl $0x1, %edi
movl $0x38, %esi
movl $0x92, %ecx
callq 0x359a6
movq %rax, %r15
movq %r12, 0x18(%rax)
movq %r14, %rdi
callq 0x76120
testb %al, %al
je 0xd7c2a
movzbl %bpl, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xd7ad2
testb %al, %al
je 0xd7c2a
movb $0x0, 0x28(%r15)
jmp 0xd7c55
leaq 0x31cce(%rip), %rsi     # 0x1098ff
movq %r15, %rdi
movl $0x9a, %edx
callq 0x35c27
leaq 0x31cec(%rip), %rsi     # 0x109931
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x34f1f
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x32094
callq 0x3205b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_tab.c
// Function: gt_md5_tab_delete
void gt_md5_tab_delete(GtMD5Tab *md5_tab)
{
  GtUword i;
  if (!md5_tab) return;
  if (md5_tab->reference_count) {
    md5_tab->reference_count--;
    return;
  }
  gt_fa_xmunmap(md5_tab->fingerprints);
  gt_fa_unlock(md5_tab->fingerprints_file);
  gt_fa_xfclose(md5_tab->fingerprints_file);
  gt_hashmap_delete(md5_tab->md5map);
  if (md5_tab->owns_md5s) {
    for (i = 0; i < md5_tab->num_of_md5s; i++)
      gt_free(md5_tab->md5_fingerprints[i]);
    gt_free(md5_tab->md5_fingerprints);
  }
  gt_free(md5_tab);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd7c95
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xd7c9b
decq %rax
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rdi
callq 0x750ec
movq (%rbx), %rdi
callq 0x745e4
movq (%rbx), %rdi
callq 0x74532
movq 0x30(%rbx), %rdi
callq 0x77bab
cmpb $0x1, 0x28(%rbx)
jne 0xd7d07
cmpq $0x0, 0x18(%rbx)
je 0xd7cf2
xorl %r15d, %r15d
leaq 0x31c2b(%rip), %r14     # 0x1098ff
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
movl $0xb8, %edx
callq 0x35c27
incq %r15
cmpq 0x18(%rbx), %r15
jb 0xd7cd4
movq 0x10(%rbx), %rdi
leaq 0x31c02(%rip), %rsi     # 0x1098ff
movl $0xb9, %edx
callq 0x35c27
leaq 0x31bf1(%rip), %rsi     # 0x1098ff
movq %rbx, %rdi
movl $0xbb, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x35c27
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_tab.c
// Function: gt_md5_tab_get
const char* gt_md5_tab_get(const GtMD5Tab *md5_tab, GtUword idx)
{
  gt_assert(md5_tab && idx < md5_tab->num_of_md5s);
  if (md5_tab->owns_md5s)
    return md5_tab->md5_fingerprints[idx];
 return md5_tab->fingerprints + idx * 33;
}

// Assembly:
testq %rdi, %rdi
je 0xd7d49
cmpq %rsi, 0x18(%rdi)
jbe 0xd7d49
cmpb $0x1, 0x28(%rdi)
jne 0xd7d3a
movq 0x10(%rdi), %rax
movq (%rax,%rsi,8), %rax
retq
movq %rsi, %rax
shlq $0x5, %rax
addq %rsi, %rax
addq 0x8(%rdi), %rax
retq
pushq %rax
callq 0x320cd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_tab.c
// Function: gt_md5_tab_map
GtUword gt_md5_tab_map(GtMD5Tab *md5_tab, const char *md5)
{
  const char *value;
  gt_assert(md5_tab && md5);
  if (!md5_tab->md5map)
    build_md5map(md5_tab);
  gt_assert(md5_tab->md5map);
  value = gt_hashmap_get(md5_tab->md5map, md5);
  if (value)
    return ((GtUword) value) - 1;
  return GT_UNDEF_UWORD;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd7dd7
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd7dd7
movq %rdi, %r14
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
jne 0xd7dc0
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7740c
movq %rax, 0x30(%r14)
cmpq $0x0, 0x18(%r14)
je 0xd7db8
xorl %r15d, %r15d
movq 0x30(%r14), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0xd7d20
incq %r15
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x77628
cmpq 0x18(%r14), %r15
jb 0xd7d8c
movq 0x30(%r14), %rdi
jmp 0xd7dbb
movq %rax, %rdi
testq %rdi, %rdi
je 0xd7ddc
movq %rbx, %rsi
callq 0x775ed
decq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x32106
callq 0x3213f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_tab.c
// Function: dump_md5_fingerprints
static void dump_md5_fingerprints(char **md5_fingerprints,
                                  GtUword num_of_md5s, FILE *outfp)
{
  GtUword i;
  gt_assert(md5_fingerprints && num_of_md5s && outfp);
  for (i = 0; i < num_of_md5s; i++) {
    gt_xfputs(md5_fingerprints[i], outfp);
    gt_xfputc('\0', outfp);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xd7e39
movq %rsi, %r14
testq %rsi, %rsi
je 0xd7e2d
movq %rdx, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x3d2b0
xorl %edi, %edi
movq %rbx, %rsi
callq 0x3d29e
incq %r12
cmpq %r12, %r14
jne 0xd7e0f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x321b1
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/readmode.c
// Function: gt_readmode_parse
int gt_readmode_parse(const char *string, GtError *err)
{
  size_t i;

  gt_error_check(err);
  for (i=0; i<sizeof (readmodes)/sizeof (readmodes[0]); i++)
  {
    if (strcmp(string,readmodes[i]) == 0)
    {
      return (int) i;
    }
  }
  gt_error_set(err,"unknown readmode, must be fwd or rev or cpl or rcl");
  return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xd7e6e
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xd7ebb
leaq 0x78e4b(%rip), %r12     # 0x150cc0
xorl %r15d, %r15d
movq (%r12), %rsi
movq %r14, %rdi
callq 0xb890
testl %eax, %eax
je 0xd7eac
incq %r15
addq $0x8, %r12
cmpq $0x4, %r15
jne 0xd7e78
leaq 0x31c95(%rip), %rsi     # 0x109b31
movq %rbx, %rdi
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x321e8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq.c
// Function: gt_seq_new
GtSeq* gt_seq_new(const char *seq, GtUword seqlen, GtAlphabet *seqalpha)
{
  GtSeq *s;
  gt_assert(seq && seqalpha);
  s = gt_calloc(1, sizeof (GtSeq));
  s->seq = (char*) seq;
  s->seqlen = seqlen;
  s->seqalpha = gt_alphabet_ref(seqalpha);
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd7f2c
movq %rdx, %rbx
testq %rdx, %rdx
je 0xd7f2c
movq %rsi, %r14
movq %rdi, %r15
leaq 0x31c91(%rip), %rdx     # 0x109b83
movl $0x1, %edi
movl $0x30, %esi
movl $0x22, %ecx
callq 0x359a6
movq %rax, %r12
movq %r15, (%rax)
movq %r14, 0x18(%rax)
movq %rbx, %rdi
callq 0xba023
movq %rax, 0x28(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3221f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq.c
// Function: gt_seq_set_description_own
void gt_seq_set_description_own(GtSeq *s, char *desc)
{
  gt_assert(s);
  if (s->description && s->own_description)
    gt_free(s->description);
  s->description = desc;
  s->own_description = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd7f8c
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xd7f7c
cmpb $0x1, 0x21(%rbx)
jne 0xd7f7c
leaq 0x31c11(%rip), %rsi     # 0x109b83
movl $0x3a, %edx
callq 0x35c27
movq %r14, 0x8(%rbx)
movb $0x1, 0x21(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x3228d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq.c
// Function: gt_seq_get_encoded
const GtUchar* gt_seq_get_encoded(GtSeq *s)
{
  gt_assert(s);
  if (!s->encoded_seq) {
    s->encoded_seq = gt_malloc(sizeof (char) * (s->seqlen+1));
    gt_alphabet_encode_seq(s->seqalpha, s->encoded_seq, (char*) s->seq,
                           s->seqlen);
    s->encoded_seq[s->seqlen] = '\0';
  }
  return s->encoded_seq;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xd8003
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
jne 0xd8001
movq 0x18(%rbx), %rdi
incq %rdi
leaq 0x31bb3(%rip), %rsi     # 0x109b83
movl $0x4f, %edx
callq 0x35862
movq %rax, 0x10(%rbx)
movq 0x28(%rbx), %rdi
movq (%rbx), %rdx
movq 0x18(%rbx), %rcx
movq %rax, %rsi
callq 0xbaeab
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rbx), %rax
popq %rbx
retq
callq 0x32332
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq.c
// Function: gt_seq_delete
void gt_seq_delete(GtSeq *s)
{
  if (!s) return;
  if (s->own_seq)
    gt_free(s->seq);
  if (s->own_description)
    gt_free(s->description);
  gt_free(s->encoded_seq);
  gt_alphabet_delete(s->seqalpha);
  gt_free(s);
}

// Assembly:
testq %rdi, %rdi
je 0xd80a1
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0xd804e
movq (%rbx), %rdi
leaq 0x31b3f(%rip), %rsi     # 0x109b83
movl $0x67, %edx
callq 0x35c27
cmpb $0x1, 0x21(%rbx)
jne 0xd8069
movq 0x8(%rbx), %rdi
leaq 0x31b24(%rip), %rsi     # 0x109b83
movl $0x69, %edx
callq 0x35c27
movq 0x10(%rbx), %rdi
leaq 0x31b0f(%rip), %r14     # 0x109b83
movq %r14, %rsi
movl $0x6a, %edx
callq 0x35c27
movq 0x28(%rbx), %rdi
callq 0xba400
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6c, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_create
GtSeqCol* gt_seq_col_create(const GtSeqColClass *cc)
{
  GtSeqCol *c;
  gt_assert(cc && cc->size);
  c = gt_calloc(1, cc->size);
  c->c_class = cc;
  return c;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xd8156
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xd8156
leaq 0x31af0(%rip), %rdx     # 0x109c32
movl $0x1, %edi
movl $0x45, %ecx
callq 0x359a6
movq %rbx, (%rax)
popq %rbx
retq
callq 0x323d7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_delete
void gt_seq_col_delete(GtSeqCol *sc)
{
  if (!sc) return;
  gt_assert(sc->c_class);
  if (sc->c_class->free)
    sc->c_class->free(sc);
  gt_free(sc);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xd818f
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xd8191
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xd817a
movq %rbx, %rdi
callq *%rax
leaq 0x31ab1(%rip), %rsi     # 0x109c32
movq %rbx, %rdi
movl $0x50, %edx
popq %rbx
jmp 0x35c27
popq %rbx
retq
callq 0x3240e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_grep_desc
int gt_seq_col_grep_desc(GtSeqCol *sc, char **seq, GtUword start,
                         GtUword end, GtStr *seqid, GtError *err)
{
  gt_assert(sc && seq && seqid);
  if (sc->c_class->grep_desc)
    return sc->c_class->grep_desc(sc, seq, start, end, seqid, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd81e9
testq %rsi, %rsi
je 0xd81e9
testq %r8, %r8
je 0xd81e9
movq (%rdi), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xd81e6
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x324b3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_grep_desc_md5
int gt_seq_col_grep_desc_md5(GtSeqCol *sc, const char **md5, GtStr *seqid,
                             GtError *err)
{
  gt_assert(sc && md5 && seqid);
  if (sc->c_class->grep_desc_md5)
    return sc->c_class->grep_desc_md5(sc, md5, seqid, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd820f
testq %rsi, %rsi
je 0xd820f
testq %rdx, %rdx
je 0xd820f
movq (%rdi), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0xd820c
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x324ea
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_grep_desc_description
int gt_seq_col_grep_desc_description(GtSeqCol *sc, GtStr *desc, GtStr *seqid,
                                     GtError *err)
{
  gt_assert(sc && desc && seqid);
  if (sc->c_class->grep_desc_desc)
    return sc->c_class->grep_desc_desc(sc, desc, seqid, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd8235
testq %rsi, %rsi
je 0xd8235
testq %rdx, %rdx
je 0xd8235
movq (%rdi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xd8232
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32521
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_grep_desc_sequence_length
int gt_seq_col_grep_desc_sequence_length(GtSeqCol *sc, GtUword *length,
                                         GtStr *seqid, GtError *err)
{
  gt_assert(sc && length && seqid);
  if (sc->c_class->grep_desc_seqlen)
    return sc->c_class->grep_desc_seqlen(sc, length, seqid, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd825b
testq %rsi, %rsi
je 0xd825b
testq %rdx, %rdx
je 0xd825b
movq (%rdi), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0xd8258
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32558
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_md5_to_seq
int gt_seq_col_md5_to_seq(GtSeqCol *sc, char **seq,
                          GtUword start, GtUword end,
                          GtStr *md5_seqid, GtError *err)
{
  gt_assert(sc && seq && md5_seqid);
  if (sc->c_class->md5_to_seq)
    return sc->c_class->md5_to_seq(sc, seq, start, end, md5_seqid, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd8281
testq %rsi, %rsi
je 0xd8281
testq %r8, %r8
je 0xd8281
movq (%rdi), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0xd827e
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x3258f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_md5_to_description
int gt_seq_col_md5_to_description(GtSeqCol *sc, GtStr *desc, GtStr *md5_seqid,
                                  GtError *err)
{
  gt_assert(sc && desc && md5_seqid);
  if (sc->c_class->md5_to_desc)
    return sc->c_class->md5_to_desc(sc, desc, md5_seqid, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd82a7
testq %rsi, %rsi
je 0xd82a7
testq %rdx, %rdx
je 0xd82a7
movq (%rdi), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0xd82a4
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x325c8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_md5_to_sequence_length
int gt_seq_col_md5_to_sequence_length(GtSeqCol *sc, GtUword *len,
                                      GtStr *md5_seqid, GtError *err)
{
  gt_assert(sc && len && md5_seqid);
  if (sc->c_class->md5_to_seqlen)
    return sc->c_class->md5_to_seqlen(sc, len, md5_seqid, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd82cd
testq %rsi, %rsi
je 0xd82cd
testq %rdx, %rdx
je 0xd82cd
movq (%rdi), %rax
movq 0x48(%rax), %rax
testq %rax, %rax
je 0xd82ca
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32601
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_num_of_files
GtUword gt_seq_col_num_of_files(const GtSeqCol *sc)
{
  gt_assert(sc);
  if (sc->c_class->num_files)
    return sc->c_class->num_files(sc);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd82e9
movq (%rdi), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0xd82e6
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x3263a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_num_of_seqs
GtUword gt_seq_col_num_of_seqs(const GtSeqCol *sc, GtUword filenum)
{
 gt_assert(sc);
  if (sc->c_class->num_seqs)
    return sc->c_class->num_seqs(sc, filenum);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd8305
movq (%rdi), %rax
movq 0x58(%rax), %rax
testq %rax, %rax
je 0xd8302
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32673
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_md5_fingerprint
const char* gt_seq_col_get_md5_fingerprint(const GtSeqCol *sc,
                                           GtUword filenum,
                                           GtUword seqnum)
{
  gt_assert(sc);
  if (sc->c_class->get_md5)
    return sc->c_class->get_md5(sc, filenum, seqnum);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd8321
movq (%rdi), %rax
movq 0x60(%rax), %rax
testq %rax, %rax
je 0xd831e
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x326ac
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_sequence
char* gt_seq_col_get_sequence(const GtSeqCol *sc, GtUword filenum,
                              GtUword seqnum,GtUword start,
                              GtUword end)
{
  gt_assert(sc);
  if (sc->c_class->get_seq)
    return sc->c_class->get_seq(sc, filenum, seqnum, start, end);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd833d
movq (%rdi), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0xd833a
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x326e5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_description
char* gt_seq_col_get_description(const GtSeqCol *sc, GtUword filenum,
                                 GtUword seqnum)
{
  gt_assert(sc);
  if (sc->c_class->get_seq)
    return sc->c_class->get_desc(sc, filenum, seqnum);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd835b
movq (%rdi), %rax
cmpq $0x0, 0x68(%rax)
je 0xd8358
movq 0x70(%rax), %rax
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x3271e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_sequence_length
GtUword gt_seq_col_get_sequence_length(const GtSeqCol *sc,
                                             GtUword filenum,
                                             GtUword seqnum)
{
  gt_assert(sc);
  if (sc->c_class->get_seqlen)
    return sc->c_class->get_seqlen(sc, filenum, seqnum);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd8377
movq (%rdi), %rax
movq 0x78(%rax), %rax
testq %rax, %rax
je 0xd8374
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32757
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_info_cache.c
// Function: gt_seq_info_cache_add
void gt_seq_info_cache_add(GtSeqInfoCache *sic, const char *key,
                           const GtSeqInfo *si)
{
  GtSeqInfo *si_dup;
  gt_assert(sic && key && si);
  gt_assert(!gt_seq_info_cache_get(sic, key));
  si_dup = gt_malloc(sizeof *si_dup);
  si_dup->filenum = si->filenum;
  si_dup->seqnum = si->seqnum;
  gt_hashmap_add(sic->cache, gt_cstr_dup(key), si_dup);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd8464
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd8464
movq %rdx, %r15
testq %rdx, %rdx
je 0xd8464
movq %rdi, %r14
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x775ed
testq %rax, %rax
jne 0xd8469
leaq 0x31a3f(%rip), %rsi     # 0x109e66
movl $0x10, %edi
movl $0x34, %edx
callq 0x35862
movq %rax, %r12
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq (%r14), %r14
movq %rbx, %rdi
callq 0x728c0
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x77628
callq 0x327c7
callq 0x327fe
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_plain.c
// Function: gt_sequence_buffer_plain_new
GtSequenceBuffer* gt_sequence_buffer_plain_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferPlain *sbf;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_plain_class());
  sbf = gt_sequence_buffer_plain_cast(sb);
  sb->pvt->filenametab = sequences;
  sb->pvt->filenum = 0;
  sbf->firstseqinfile = true;
  sbf->nextfile = true;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->complete = false;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x7863c(%rip), %r14     # 0x150ce0
movq %r14, %rdi
callq 0x7f1bc
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x7f41e
movq 0x8(%r15), %rcx
movq %rbx, 0x70(%rcx)
movl $0x0, (%rcx)
movw $0x101, 0x10(%rax)      # imm = 0x101
movb $0x0, 0x18(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rcx)
movq $0x0, 0x60(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sig.c
// Function: gt_sig_register_all
void gt_sig_register_all(void (*func)(int sigraised))
{
  /* POSIX */
  (void) gt_xsignal(SIGABRT, func);
  (void) gt_xsignal(SIGFPE, func);
  (void) gt_xsignal(SIGILL, func);
  (void) gt_xsignal(SIGINT, func);
  (void) gt_xsignal(SIGSEGV, func);
  (void) gt_xsignal(SIGTERM, func);
#ifndef _WIN32
  (void) gt_xsignal(SIGBUS, func);
  (void) gt_xsignal(SIGHUP, func);
  (void) gt_xsignal(SIGPIPE, func);
  (void) gt_xsignal(SIGQUIT, func);
  (void) gt_xsignal(SIGTSTP, func);
  (void) gt_xsignal(SIGTTIN, func);
  (void) gt_xsignal(SIGTTOU, func);
  (void) gt_xsignal(SIGUSR1, func);
  (void) gt_xsignal(SIGUSR2, func);
  (void) gt_xsignal(SIGSYS, func);
  (void) gt_xsignal(SIGXCPU, func);
  (void) gt_xsignal(SIGXFSZ, func);
#endif

  /* OpenBSD */
#ifdef SIGEMT
  (void) gt_xsignal(SIGEMT, func);
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x6, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x8, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x4, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x2, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0xb, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0xf, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x7, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x1, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0xd, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x3, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x14, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x15, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x16, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0xa, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0xc, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x1f, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x18, %edi
movq %rbx, %rsi
callq 0x832e6
movl $0x19, %edi
movq %rbx, %rsi
popq %rbx
jmp 0x832e6