LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xd2f61
movq %rax, %rdi
movq %r15, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xd3a97
movq %rax, %r15
movq 0x8(%rax), %rdi
callq 0xc6fb7
cmpq %r13, %rax
jbe 0xd3a97
movq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0xcd955
movq %rax, %r13
addq %r12, %r13
movq 0x8(%r15), %rdi
callq 0xbef6c
cmpq %rax, %r13
jae 0xd3a9c
movq %rbx, %r12
subq %r14, %r12
jb 0xd3aa1
movq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0xc2a64
movq %rax, %r13
incq %r12
leaq 0x34681(%rip), %rdx     # 0x1080de
movl $0x1, %esi
movq %r12, %rdi
movl $0x18d, %ecx            # imm = 0x18D
callq 0x3601f
movq %rax, %r12
movq 0x8(%r15), %rdi
addq %r13, %r14
addq %r13, %rbx
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xc05ff
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x30a6a
callq 0x309f8
callq 0x30a31
// File: /workspace/github_c_makefile_star2_O1/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 0xd2f61
movq %rax, %rdi
movq %r14, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xd3b30
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xc6fb7
cmpq %r15, %rax
jbe 0xd3b30
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xcd955
movq %rax, %r15
addq %rbx, %r15
movq 0x8(%r14), %rdi
callq 0xbef6c
cmpq %rax, %r15
jae 0xd3b35
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0xc3523
testq %rax, %rax
je 0xd3b3a
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0xd3b3a
movq %rax, %rdi
callq 0x7231f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x30b15
callq 0x30aa3
callq 0x30adc
// File: /workspace/github_c_makefile_star2_O1/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 0xd2f61
movq %rax, %rdi
movq %r15, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xd3b93
movq %rax, %r15
movq 0x8(%rax), %rdi
callq 0xc6fb7
cmpq %r14, %rax
jbe 0xd3b93
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0xcd955
addq %rax, %rbx
movq 0x8(%r15), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xc2d57
callq 0x30b4e
// File: /workspace/github_c_makefile_star2_O1/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 0xd3bbb
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xd3c4d
testq %rbx, %rbx
je 0xd3c48
movq %rbx, %rdi
callq 0xc3c47
testb %al, %al
je 0xd3c25
callq 0xd2f61
movq %rax, %rdi
callq 0xd7a22
movq %rax, %r15
callq 0xd2f61
movq %rax, %rdi
movq %r15, %rsi
callq 0xd7a8e
movq %rax, %r12
movq $0x0, 0x20(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc3c16
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0xd3c52
movq %rbx, %rdi
callq 0xc1cd3
movq %rax, 0x8(%r12)
movb $0x0, 0x28(%r12)
jmp 0xd3c39
leaq 0x344f9(%rip), %rsi     # 0x108125
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x3559f
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x30bf9
callq 0x30b87
callq 0x30bc0
// File: /workspace/github_c_makefile_star2_O1/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 0xd4cb3
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0xd4c9e
callq 0xb9301
leaq 0x33824(%rip), %rsi     # 0x1084c9
movq %rbx, %rdi
movl $0x115, %edx            # imm = 0x115
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd5373
movq %rsi, %rdx
testq %rsi, %rsi
je 0xd5373
movq %rdi, %rbx
leaq 0x264d2(%rip), %rdi     # 0xfb826
leaq 0x33630(%rip), %rsi     # 0x10898b
leaq 0x319b6(%rip), %rcx     # 0x106d18
callq 0x396b7
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x36a40
callq 0x31180
// File: /workspace/github_c_makefile_star2_O1/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 0xd56ba
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3d1eb
movq 0x10(%rbx), %rdi
callq 0x3d1eb
movq 0x8(%rbx), %rdi
callq 0x3d1eb
movq 0x18(%rbx), %rdi
callq 0x3d1eb
movq 0xc8(%rbx), %rdi
callq 0x3d573
cmpb $0x0, 0xda(%rbx)
jne 0xd5693
movq 0x20(%rbx), %rdi
callq 0x390b6
cmpb $0x0, 0xdb(%rbx)
jne 0xd56a5
movq 0x28(%rbx), %rdi
callq 0x390b6
leaq 0x3326d(%rip), %rsi     # 0x108919
movq %rbx, %rdi
movl $0x1be, %edx            # imm = 0x1BE
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/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
andq $0x7, %rdx
je 0xd60d4
movq %rdi, %rcx
xorl %eax, %eax
movq %rsp, %rdi
movl %eax, 0x3(%rdi)
movl %eax, (%rdi)
movl $0x8, %r14d
subq %rdx, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x3dc94
movq %r14, (%rbx)
jmp 0xd60db
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd68d8
movq %rsi, %r14
testq %rsi, %rsi
je 0xd68d8
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jb 0xd6894
leaq 0xa(%rax), %rcx
movq %rcx, 0x8(%r15)
movq (%r15), %rdi
leaq 0x50(,%rax,8), %rax
leaq (%rax,%rax,4), %rsi
leaq 0x32ca9(%rip), %rdx     # 0x109530
movl $0x22f, %ecx            # imm = 0x22F
callq 0x36116
movq %rax, (%r15)
movq (%r15), %rax
testq %rax, %rax
je 0xd68dd
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 0x32f01(%rip), %rdx     # 0x1097ce
movq %rdx, 0x8(%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
callq 0x32227
callq 0x32260
// File: /workspace/github_c_makefile_star2_O1/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 0xd6a16
movq %rsi, %r14
testq %rsi, %rsi
je 0xd6a16
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jb 0xd69d2
leaq 0xa(%rax), %rcx
movq %rcx, 0x8(%r15)
movq (%r15), %rdi
leaq 0x50(,%rax,8), %rax
leaq (%rax,%rax,4), %rsi
leaq 0x32b6b(%rip), %rdx     # 0x109530
movl $0x241, %ecx            # imm = 0x241
callq 0x36116
movq %rax, (%r15)
movq (%r15), %rax
testq %rax, %rax
je 0xd6a1b
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 0x32e01(%rip), %rdx     # 0x10980c
movq %rdx, 0x8(%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
callq 0x3230b
callq 0x32344
// File: /workspace/github_c_makefile_star2_O1/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 0x32d58(%rip), %rsi     # 0x1098c0
movl $0x70, %edi
movl $0xc4, %edx
callq 0x35ee2
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 0x32d17(%rip), %xmm0    # 0x1098b0
movups %xmm0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd6bc9
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 0x32ceb(%rip), %xmm0    # 0x1098b0
movups %xmm0, (%rdi)
retq
pushq %rax
callq 0x32461
// File: /workspace/github_c_makefile_star2_O1/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 0xd6c3d
movq %rsi, %r15
testq %rsi, %rsi
je 0xd6c3d
movq %rdx, %rbx
cmpq $0x41, %rdx
jae 0xd6c3d
movq %rdi, %r14
cmpq $0x0, 0x60(%rdi)
je 0xd6c14
leaq 0x20(%r14), %rdi
movq %r14, %rsi
callq 0xd6c42
movdqu (%r14), %xmm0
movdqu 0x10(%r14), %xmm1
paddd %xmm0, %xmm1
movdqu %xmm1, (%r14)
movups (%r14), %xmm0
movups %xmm0, 0x10(%r14)
leaq 0x20(%r14), %rdi
movl 0x68(%r14), %ecx
movq %r15, %rsi
movl %ebx, %edx
callq 0xd6f52
movl %eax, 0x68(%r14)
addq %rbx, 0x60(%r14)
popq %rbx
popq %r14
popq %r15
retq
callq 0x3249a
// File: /workspace/github_c_makefile_star2_O1/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 0xd6f9f
movl %ecx, %ebp
movl %ebx, %r12d
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rdx
callq 0xb520
leaq (%rsp,%r12), %rdi
movl $0x40, %edx
subl %ebx, %edx
xorl %esi, %esi
callq 0xb2f0
movl $0x1, %eax
testl %ebp, %ebp
jne 0xd6fa2
movb $-0x80, (%rsp,%r12)
jmp 0xd6fa2
movq %rsi, %r15
xorl %ecx, %ecx
movl (%r15,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
cmpq $0x10, %rcx
jne 0xd6fa4
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_O1/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 0xd716e
movq %rsi, %r14
testq %rsi, %rsi
je 0xd716e
movq %rdx, %rbx
movq %rdi, %r15
cmpl $0x2, 0x68(%rdi)
je 0xd704a
cmpq $0x0, 0x60(%r15)
je 0xd7023
leaq 0x20(%r15), %rdi
movq %r15, %rsi
callq 0xd6c42
movdqu (%r15), %xmm0
movdqu 0x10(%r15), %xmm1
paddd %xmm0, %xmm1
movdqu %xmm1, (%r15)
movups (%r15), %xmm0
movups %xmm0, 0x10(%r15)
leaq 0x20(%r15), %rdi
movl 0x68(%r15), %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xd6f52
movl %eax, 0x68(%r15)
cmpl $0x2, %eax
jne 0xd7173
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 0xd6c42
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 0xd7087
testq %rbx, %rbx
je 0xd715f
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 0x32839(%rip), %rdx     # 0x109955
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 0xd7163
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x324d3
callq 0x3250c
// File: /workspace/github_c_makefile_star2_O1/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 0xd74a7
movq %rsi, %r14
testq %rsi, %rsi
je 0xd74a7
movl %edx, %ebp
movq %rdi, %rbx
movq %r14, %rdi
callq 0x75bdc
testb %al, %al
je 0xd74ac
testb %bpl, %bpl
je 0xd743c
leaq 0x17a8b(%rip), %rsi     # 0xeeea8
leaq 0x326bb(%rip), %rdx     # 0x109adf
movq %r14, %rdi
movl $0x2f, %ecx
callq 0x73e59
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x74020
leaq 0x3269c(%rip), %rdx     # 0x109adf
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x32, %ecx
callq 0x74999
movq %rax, 0x8(%rbx)
movq (%r15), %r14
movq 0x18(%rbx), %rcx
movq %rcx, %r15
shlq $0x5, %r15
addq %rcx, %r15
cmpq %r15, %r14
je 0xd7494
movq %rax, %rdi
callq 0x74bae
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
movq (%rbx), %rdi
callq 0x74050
movq (%rbx), %rdi
callq 0x73f9e
movq %r12, (%rbx)
cmpq %r15, %r14
sete %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x325ea
callq 0x32621
// File: /workspace/github_c_makefile_star2_O1/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 0xd7561
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0xd74e2
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xd7566
leaq 0x325f6(%rip), %rdx     # 0x109adf
movl $0x1, %edi
movl $0x38, %esi
movl $0x92, %ecx
callq 0x3601f
movq %rax, %r15
movq %r12, 0x18(%rax)
movq %r14, %rdi
callq 0x75bdc
testb %al, %al
je 0xd752a
movzbl %bpl, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xd73d2
testb %al, %al
je 0xd752a
movb $0x0, 0x28(%r15)
jmp 0xd7555
leaq 0x325ae(%rip), %rsi     # 0x109adf
movq %r15, %rdi
movl $0x9a, %edx
callq 0x362a0
leaq 0x325cc(%rip), %rsi     # 0x109b11
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3559f
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x32691
callq 0x32658
// File: /workspace/github_c_makefile_star2_O1/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 0xd7598
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xd759e
decq %rax
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rdi
callq 0x74bae
movq (%rbx), %rdi
callq 0x74050
movq (%rbx), %rdi
callq 0x73f9e
movq 0x30(%rbx), %rdi
callq 0x77675
cmpb $0x1, 0x28(%rbx)
jne 0xd760a
cmpq $0x0, 0x18(%rbx)
je 0xd75f5
xorl %r15d, %r15d
leaq 0x32508(%rip), %r14     # 0x109adf
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
movl $0xb8, %edx
callq 0x362a0
incq %r15
cmpq 0x18(%rbx), %r15
jb 0xd75d7
movq 0x10(%rbx), %rdi
leaq 0x324df(%rip), %rsi     # 0x109adf
movl $0xb9, %edx
callq 0x362a0
leaq 0x324ce(%rip), %rsi     # 0x109adf
movq %rbx, %rdi
movl $0xbb, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x362a0
// File: /workspace/github_c_makefile_star2_O1/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 0xd764c
cmpq %rsi, 0x18(%rdi)
jbe 0xd764c
cmpb $0x1, 0x28(%rdi)
jne 0xd763d
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 0x326ca
// File: /workspace/github_c_makefile_star2_O1/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 0xd76d3
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd76d3
movq %rdi, %r14
cmpq $0x0, 0x30(%rdi)
jne 0xd76b3
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x76f28
movq %rax, 0x30(%r14)
cmpq $0x0, 0x18(%r14)
je 0xd76b3
xorl %r15d, %r15d
movq 0x30(%r14), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0xd7623
incq %r15
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x77144
cmpq 0x18(%r14), %r15
jb 0xd768d
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0xd76d8
movq %rbx, %rsi
callq 0x77109
decq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x32703
callq 0x3273c
// File: /workspace/github_c_makefile_star2_O1/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 0xd7735
movq %rsi, %r14
testq %rsi, %rsi
je 0xd7729
movq %rdx, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x3dc24
xorl %edi, %edi
movq %rbx, %rsi
callq 0x3dc12
incq %r12
cmpq %r12, %r14
jne 0xd770b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x327ae
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xd776a
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xd77b7
leaq 0x7954f(%rip), %r12     # 0x150cc0
xorl %r15d, %r15d
movq (%r12), %rsi
movq %r14, %rdi
callq 0xb890
testl %eax, %eax
je 0xd77a8
incq %r15
addq $0x8, %r12
cmpq $0x4, %r15
jne 0xd7774
leaq 0x32579(%rip), %rsi     # 0x109d11
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x327e5
// File: /workspace/github_c_makefile_star2_O1/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 0xd7828
movq %rdx, %rbx
testq %rdx, %rdx
je 0xd7828
movq %rsi, %r14
movq %rdi, %r15
leaq 0x32575(%rip), %rdx     # 0x109d63
movl $0x1, %edi
movl $0x30, %esi
movl $0x22, %ecx
callq 0x3601f
movq %rax, %r12
movq %r15, (%rax)
movq %r14, 0x18(%rax)
movq %rbx, %rdi
callq 0xb8fab
movq %rax, 0x28(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3281c
// File: /workspace/github_c_makefile_star2_O1/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 0xd7888
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xd7878
cmpb $0x1, 0x21(%rbx)
jne 0xd7878
leaq 0x324f5(%rip), %rsi     # 0x109d63
movl $0x3a, %edx
callq 0x362a0
movq %r14, 0x8(%rbx)
movb $0x1, 0x21(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x3288a
// File: /workspace/github_c_makefile_star2_O1/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 0xd78fd
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0xd78f7
movq 0x18(%rbx), %rdi
incq %rdi
leaq 0x32499(%rip), %rsi     # 0x109d63
movl $0x4f, %edx
callq 0x35ee2
movq %rax, 0x10(%rbx)
movq 0x28(%rbx), %rdi
movq (%rbx), %rdx
movq 0x18(%rbx), %rcx
movq %rax, %rsi
callq 0xb9d97
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rbx), %rax
popq %rbx
retq
callq 0x3292f
// File: /workspace/github_c_makefile_star2_O1/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 0xd799b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0xd7948
movq (%rbx), %rdi
leaq 0x32425(%rip), %rsi     # 0x109d63
movl $0x67, %edx
callq 0x362a0
cmpb $0x1, 0x21(%rbx)
jne 0xd7963
movq 0x8(%rbx), %rdi
leaq 0x3240a(%rip), %rsi     # 0x109d63
movl $0x69, %edx
callq 0x362a0
movq 0x10(%rbx), %rdi
leaq 0x323f5(%rip), %r14     # 0x109d63
movq %r14, %rsi
movl $0x6a, %edx
callq 0x362a0
movq 0x28(%rbx), %rdi
callq 0xb9301
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6c, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_class_new
const GtSeqColClass* gt_seq_col_class_new(size_t size,
                                          GtSeqColFreeFunc free,
                                          GtSeqColEnableMatchDescStartFunc
                                                        enable_match_desc_start,
                                          GtSeqColGrepDescFunc grep_desc,
                                          GtSeqColGrepDescDescFunc
                                                                 grep_desc_desc,
                                          GtSeqColGrepDescMD5Func grep_desc_md5,
                                          GtSeqColGrepDescSeqlenFunc
                                                               grep_desc_seqlen,
                                          GtSeqColMD5ToSeqFunc md5_to_seq,
                                          GtSeqColMD5ToDescFunc md5_to_desc,
                                          GtSeqColMD5ToSeqlenFunc md5_to_seqlen,
                                          GtSeqColNumFilesFunc num_files,
                                          GtSeqColNumSeqsFunc num_seqs,
                                          GtSeqColGetMD5Func get_md5,
                                          GtSeqColGetSeqFunc get_seq,
                                          GtSeqColGetDescFunc get_desc,
                                          GtSeqColGetSeqlenFunc get_seqlen)
{
  GtSeqColClass *c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->enable_match_desc_start = enable_match_desc_start;
  c_class->grep_desc = grep_desc;
  c_class->grep_desc_desc = grep_desc_desc;
  c_class->grep_desc_md5 = grep_desc_md5;
  c_class->grep_desc_seqlen = grep_desc_seqlen;
  c_class->md5_to_desc = md5_to_desc;
  c_class->md5_to_seq = md5_to_seq;
  c_class->md5_to_seqlen = md5_to_seqlen;
  c_class->num_files = num_files;
  c_class->num_seqs = num_seqs;
  c_class->get_md5 = get_md5;
  c_class->get_seq = get_seq;
  c_class->get_desc = get_desc;
  c_class->get_seqlen = get_seqlen;
  return c_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl $0x80, %edi
callq 0x71ca4
movq %rbp, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x30(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x40(%rax)
movups 0x58(%rsp), %xmm0
movups %xmm0, 0x48(%rax)
movups 0x68(%rsp), %xmm0
movups %xmm0, 0x58(%rax)
movups 0x78(%rsp), %xmm0
movups %xmm0, 0x68(%rax)
movq 0x88(%rsp), %rcx
movq %rcx, 0x78(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd7a4e
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xd7a4e
leaq 0x323d8(%rip), %rdx     # 0x109e12
movl $0x1, %edi
movl $0x45, %ecx
callq 0x3601f
movq %rbx, (%rax)
popq %rbx
retq
callq 0x329d4
// File: /workspace/github_c_makefile_star2_O1/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 0xd7a87
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xd7a89
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xd7a72
movq %rbx, %rdi
callq *%rax
leaq 0x32399(%rip), %rsi     # 0x109e12
movq %rbx, %rdi
movl $0x50, %edx
popq %rbx
jmp 0x362a0
popq %rbx
retq
callq 0x32a0b
// File: /workspace/github_c_makefile_star2_O1/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 0xd7ae1
testq %rsi, %rsi
je 0xd7ae1
testq %r8, %r8
je 0xd7ae1
movq (%rdi), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xd7ade
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32ab0
// File: /workspace/github_c_makefile_star2_O1/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 0xd7b07
testq %rsi, %rsi
je 0xd7b07
testq %rdx, %rdx
je 0xd7b07
movq (%rdi), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0xd7b04
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32ae7
// File: /workspace/github_c_makefile_star2_O1/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 0xd7b2d
testq %rsi, %rsi
je 0xd7b2d
testq %rdx, %rdx
je 0xd7b2d
movq (%rdi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xd7b2a
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32b1e
// File: /workspace/github_c_makefile_star2_O1/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 0xd7b53
testq %rsi, %rsi
je 0xd7b53
testq %rdx, %rdx
je 0xd7b53
movq (%rdi), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0xd7b50
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32b55
// File: /workspace/github_c_makefile_star2_O1/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 0xd7b79
testq %rsi, %rsi
je 0xd7b79
testq %r8, %r8
je 0xd7b79
movq (%rdi), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0xd7b76
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32b8c
// File: /workspace/github_c_makefile_star2_O1/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 0xd7b9f
testq %rsi, %rsi
je 0xd7b9f
testq %rdx, %rdx
je 0xd7b9f
movq (%rdi), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0xd7b9c
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32bc5
// File: /workspace/github_c_makefile_star2_O1/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 0xd7bc5
testq %rsi, %rsi
je 0xd7bc5
testq %rdx, %rdx
je 0xd7bc5
movq (%rdi), %rax
movq 0x48(%rax), %rax
testq %rax, %rax
je 0xd7bc2
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32bfe
// File: /workspace/github_c_makefile_star2_O1/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 0xd7be1
movq (%rdi), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0xd7bde
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32c37
// File: /workspace/github_c_makefile_star2_O1/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 0xd7bfd
movq (%rdi), %rax
movq 0x58(%rax), %rax
testq %rax, %rax
je 0xd7bfa
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32c70
// File: /workspace/github_c_makefile_star2_O1/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 0xd7c19
movq (%rdi), %rax
movq 0x60(%rax), %rax
testq %rax, %rax
je 0xd7c16
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32ca9
// File: /workspace/github_c_makefile_star2_O1/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 0xd7c35
movq (%rdi), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0xd7c32
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32ce2
// File: /workspace/github_c_makefile_star2_O1/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 0xd7c53
movq (%rdi), %rax
cmpq $0x0, 0x68(%rax)
je 0xd7c50
movq 0x70(%rax), %rax
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32d1b
// File: /workspace/github_c_makefile_star2_O1/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 0xd7c6f
movq (%rdi), %rax
movq 0x78(%rax), %rax
testq %rax, %rax
je 0xd7c6c
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x32d54
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xd7d5c
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd7d5c
movq %rdx, %r15
testq %rdx, %rdx
je 0xd7d5c
movq %rdi, %r14
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x77109
testq %rax, %rax
jne 0xd7d61
leaq 0x32327(%rip), %rsi     # 0x10a046
movl $0x10, %edi
movl $0x34, %edx
callq 0x35ee2
movq %rax, %r12
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq (%r14), %r14
movq %rbx, %rdi
callq 0x722dc
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x77144
callq 0x32dc4
callq 0x32dfb
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x78d1a(%rip), %r14     # 0x150ce0
movq %r14, %rdi
callq 0x7f134
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x7f396
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
// File: /workspace/github_c_makefile_star2_O1/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 0x836fe
movl $0x8, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0x4, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0x2, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0xb, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0xf, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0x7, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0x1, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0xd, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0x3, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0x14, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0x15, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0x16, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0xa, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0xc, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0x1f, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0x18, %edi
movq %rbx, %rsi
callq 0x836fe
movl $0x19, %edi
movq %rbx, %rsi
popq %rbx
jmp 0x836fe
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/sig.c
// Function: gt_sig_unregister_all
void gt_sig_unregister_all(void)
{
  /* POSIX */
  (void) gt_xsignal(SIGABRT, SIG_DFL);
  (void) gt_xsignal(SIGFPE, SIG_DFL);
  (void) gt_xsignal(SIGILL, SIG_DFL);
  (void) gt_xsignal(SIGINT, SIG_DFL);
  (void) gt_xsignal(SIGSEGV, SIG_DFL);
  (void) gt_xsignal(SIGTERM, SIG_DFL);
#ifndef _WIN32
  (void) gt_xsignal(SIGBUS, SIG_DFL);
  (void) gt_xsignal(SIGHUP, SIG_DFL);
  (void) gt_xsignal(SIGPIPE, SIG_DFL);
  (void) gt_xsignal(SIGQUIT, SIG_DFL);
  (void) gt_xsignal(SIGTSTP, SIG_DFL);
  (void) gt_xsignal(SIGTTIN, SIG_DFL);
  (void) gt_xsignal(SIGTTOU, SIG_DFL);
  (void) gt_xsignal(SIGUSR1, SIG_DFL);
  (void) gt_xsignal(SIGUSR2, SIG_DFL);
  (void) gt_xsignal(SIGSYS, SIG_DFL);
  (void) gt_xsignal(SIGXCPU, SIG_DFL);
  (void) gt_xsignal(SIGXFSZ, SIG_DFL);
#endif

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

// Assembly:
pushq %rax
movl $0x6, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x8, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x4, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x2, %edi
xorl %esi, %esi
callq 0x836fe
movl $0xb, %edi
xorl %esi, %esi
callq 0x836fe
movl $0xf, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x7, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x1, %edi
xorl %esi, %esi
callq 0x836fe
movl $0xd, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x3, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x14, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x15, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x16, %edi
xorl %esi, %esi
callq 0x836fe
movl $0xa, %edi
xorl %esi, %esi
callq 0x836fe
movl $0xc, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x1f, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x18, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x19, %edi
xorl %esi, %esi
popq %rax
jmp 0x836fe
nopl (%rax)