LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_grep_desc_sequence_length
static int gt_encseq_col_grep_desc_sequence_length(GtSeqCol *sc,
                                                   GtUword *length,
                                                   GtStr *seqid,
                                                   GtError *err)
{
  GtUword filenum = 0, seqnum = 0;
  int had_err;
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(esc && length && seqid);
  had_err = gt_encseq_col_do_grep_desc(esc, &filenum, &seqnum, seqid, err);
  if (!had_err)
    *length = gt_seq_col_get_sequence_length(sc, filenum, seqnum);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
andq $0x0, 0x10(%rsp)
movq %rdi, %r14
andq $0x0, 0x8(%rsp)
callq 0xb9a4c
movq %rax, %rdi
movq %r14, %rsi
callq 0xbfaea
movq %rax, %r13
testq %r15, %r15
je 0xba0cc
movq %r15, %rdi
callq 0xc103
testb %al, %al
jne 0xba14d
testq %r12, %r12
je 0xba11f
testq %rbx, %rbx
je 0xba11f
testq %r13, %r13
je 0xba11f
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0xbac4c
movl %eax, %ebp
testl %eax, %eax
jne 0xba10e
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xbff73
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x73e92(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xff36(%rip), %rsi      # 0xca066
leaq 0x3724a(%rip), %rdx     # 0xf1381
leaq 0x3721b(%rip), %rcx     # 0xf1359
leaq 0x3706d(%rip), %r8      # 0xf11b2
movl $0xea, %r9d
jmp 0xba179
movq 0x73e64(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xff08(%rip), %rsi      # 0xca066
leaq 0x104f4(%rip), %rdx     # 0xca659
leaq 0x371ed(%rip), %rcx     # 0xf1359
leaq 0x3703f(%rip), %r8      # 0xf11b2
movl $0xe9, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_num_of_files
static GtUword gt_encseq_col_num_of_files(const GtSeqCol *sc)
{
  const GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_assert(esc);
  return gt_encseq_num_of_files(esc->encseq);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xb9a4c
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbfaea
testq %rax, %rax
je 0xba607
movq 0x8(%rax), %rdi
popq %rbx
jmp 0xab8a0
movq 0x739aa(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xfa4e(%rip), %rsi      # 0xca066
leaq 0x29800(%rip), %rdx     # 0xe3e1f
leaq 0x36dfb(%rip), %rcx     # 0xf1421
leaq 0x36b85(%rip), %r8      # 0xf11b2
movl $0x159, %r9d            # imm = 0x159
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xb9a4c
movq %rax, %rdi
movq %r14, %rsi
callq 0xbfaea
testq %rax, %rax
je 0xba70d
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xab8a0
cmpq %rbx, %rax
jbe 0xba70d
movq 0x8(%r14), %rdi
callq 0xab8a0
movq 0x8(%r14), %rdi
testq %rbx, %rbx
jne 0xba6a3
cmpq $0x1, %rax
jne 0xba6a3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa1f8d
callq 0xab8a0
decq %rax
movq 0x8(%r14), %rdi
cmpq %rbx, %rax
jne 0xba6cd
callq 0xa1f8d
movq %rax, %r15
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xb3692
subq %rax, %r15
jmp 0xba6fe
callq 0xab8a0
decq %rax
cmpq %rbx, %rax
jbe 0xba745
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xb3692
movq %rax, %r12
movq 0x8(%r14), %rdi
incq %rbx
movq %rbx, %rsi
callq 0xb3692
movq %rax, %r15
subq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x738a4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf948(%rip), %rsi      # 0xca066
leaq 0x36d17(%rip), %rdx     # 0xf143c
leaq 0x36d45(%rip), %rcx     # 0xf1471
leaq 0x36a7f(%rip), %r8      # 0xf11b2
movl $0x163, %r9d            # imm = 0x163
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x7386c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf910(%rip), %rsi      # 0xca066
leaq 0x36d2e(%rip), %rdx     # 0xf148b
leaq 0x36d0d(%rip), %rcx     # 0xf1471
leaq 0x36a47(%rip), %r8      # 0xf11b2
movl $0x16b, %r9d            # imm = 0x16B
jmp 0xba739
// File: /workspace/github_c_makefile_star2_O2/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 0xb9a4c
movq %rax, %rdi
movq %r15, %rsi
callq 0xbfaea
testq %rax, %rax
je 0xba7ca
movq %rax, %r15
movq 0x8(%rax), %rdi
callq 0xab8a0
cmpq %r14, %rax
jbe 0xba7ca
movq 0x8(%r15), %rdi
movq 0x10(%r15), %r15
movq %r14, %rsi
callq 0xb3692
addq %rax, %rbx
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xbf392
movq 0x737e7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf88b(%rip), %rsi      # 0xca066
leaq 0x36c5a(%rip), %rdx     # 0xf143c
leaq 0x36cd4(%rip), %rcx     # 0xf14bd
leaq 0x369c2(%rip), %r8      # 0xf11b2
movl $0x178, %r9d            # imm = 0x178
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xb9a4c
movq %rax, %rdi
movq %r15, %rsi
callq 0xbfaea
testq %rax, %rax
je 0xba8c9
movq %rax, %r15
movq 0x8(%rax), %rdi
callq 0xab8a0
cmpq %r13, %rax
jbe 0xba8c9
movq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0xb3692
movq %rax, %r13
addq %r12, %r13
movq 0x8(%r15), %rdi
callq 0xa1f8d
cmpq %rax, %r13
jae 0xba8f7
movq %rbx, %r12
subq %r14, %r12
jb 0xba925
movq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0xa6788
movq %rax, %r13
incq %r12
leaq 0x36921(%rip), %rdx     # 0xf11b2
pushq $0x1
popq %rsi
movq %r12, %rdi
movl $0x18d, %ecx            # imm = 0x18D
callq 0xce9a
movq %rax, %r12
movq 0x8(%r15), %rdi
addq %r13, %r14
addq %r13, %rbx
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xa3d89
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x736e8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf78c(%rip), %rsi      # 0xca066
leaq 0x36b5b(%rip), %rdx     # 0xf143c
leaq 0x36bf7(%rip), %rcx     # 0xf14df
leaq 0x368c3(%rip), %r8      # 0xf11b2
movl $0x188, %r9d            # imm = 0x188
jmp 0xba951
movq 0x736ba(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf75e(%rip), %rsi      # 0xca066
leaq 0x36beb(%rip), %rdx     # 0xf14fa
leaq 0x36bc9(%rip), %rcx     # 0xf14df
leaq 0x36895(%rip), %r8      # 0xf11b2
movl $0x18a, %r9d            # imm = 0x18A
jmp 0xba951
movq 0x7368c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf730(%rip), %rsi      # 0xca066
leaq 0x1fd61(%rip), %rdx     # 0xda69e
leaq 0x36b9b(%rip), %rcx     # 0xf14df
leaq 0x36867(%rip), %r8      # 0xf11b2
movl $0x18b, %r9d            # imm = 0x18B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xb9a4c
movq %rax, %rdi
movq %r14, %rsi
callq 0xbfaea
testq %rax, %rax
je 0xba9e7
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xab8a0
cmpq %r15, %rax
jbe 0xba9e7
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xb3692
movq %rax, %r15
addq %rbx, %r15
movq 0x8(%r14), %rdi
callq 0xa1f8d
cmpq %rax, %r15
jae 0xbaa15
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0xa7510
testq %rax, %rax
je 0xbaa43
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0xbaa43
movq %rax, %rdi
callq 0x4f920
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x735ca(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf66e(%rip), %rsi      # 0xca066
leaq 0x36a3d(%rip), %rdx     # 0xf143c
leaq 0x36b2c(%rip), %rcx     # 0xf1532
leaq 0x367a5(%rip), %r8      # 0xf11b2
movl $0x19a, %r9d            # imm = 0x19A
jmp 0xbaa6f
movq 0x7359c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf640(%rip), %rsi      # 0xca066
leaq 0x36acd(%rip), %rdx     # 0xf14fa
leaq 0x36afe(%rip), %rcx     # 0xf1532
leaq 0x36777(%rip), %r8      # 0xf11b2
movl $0x19c, %r9d            # imm = 0x19C
jmp 0xbaa6f
movq 0x7356e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf612(%rip), %rsi      # 0xca066
leaq 0x36af5(%rip), %rdx     # 0xf1550
leaq 0x36ad0(%rip), %rcx     # 0xf1532
leaq 0x36749(%rip), %r8      # 0xf11b2
movl $0x19e, %r9d            # imm = 0x19E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xb9a4c
movq %rax, %rdi
movq %r15, %rsi
callq 0xbfaea
testq %rax, %rax
je 0xbaacf
movq %rax, %r15
movq 0x8(%rax), %rdi
callq 0xab8a0
cmpq %r14, %rax
jbe 0xbaacf
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0xb3692
addq %rax, %rbx
movq 0x8(%r15), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa6b5f
movq 0x734e2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf586(%rip), %rsi      # 0xca066
leaq 0x36955(%rip), %rdx     # 0xf143c
leaq 0x36a76(%rip), %rcx     # 0xf1564
leaq 0x366bd(%rip), %r8      # 0xf11b2
movl $0x1a9, %r9d            # imm = 0x1A9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbab2a
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0xbabe6
testq %rbx, %rbx
je 0xbabb8
movq %rbx, %rdi
callq 0xa8041
testb %al, %al
je 0xbab95
callq 0xb9a4c
movq %rax, %rdi
callq 0xbfa22
movq %rax, %r15
callq 0xb9a4c
movq %rax, %rdi
movq %r15, %rsi
callq 0xbfaea
movq %rax, %r12
andq $0x0, 0x20(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa7fb4
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0xbac14
movq %rbx, %rdi
callq 0xa56aa
movq %rax, 0x8(%r12)
movb $0x0, 0x28(%r12)
jmp 0xbaba9
leaq 0x3665d(%rip), %rsi     # 0xf11f9
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0xc007
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x733f9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf49d(%rip), %rsi      # 0xca066
leaq 0x2bf46(%rip), %rdx     # 0xe6b16
leaq 0x36610(%rip), %rcx     # 0xf11e7
leaq 0x365d4(%rip), %r8      # 0xf11b2
movl $0x1cd, %r9d            # imm = 0x1CD
jmp 0xbac40
movq 0x733cb(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf46f(%rip), %rsi      # 0xca066
leaq 0xfa5b(%rip), %rdx      # 0xca659
leaq 0x365e2(%rip), %rcx     # 0xf11e7
leaq 0x365a6(%rip), %r8      # 0xf11b2
movl $0x1cc, %r9d            # imm = 0x1CC
jmp 0xbac40
movq 0x7339d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xf441(%rip), %rsi      # 0xca066
leaq 0x365f1(%rip), %rdx     # 0xf121d
leaq 0x365b4(%rip), %rcx     # 0xf11e7
leaq 0x36578(%rip), %r8      # 0xf11b2
movl $0x1d6, %r9d            # imm = 0x1D6
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbba0d
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0xbb9f8
callq 0x9b1c1
leaq 0x35b9e(%rip), %rsi     # 0xf159d
movq %rbx, %rdi
movl $0x115, %edx            # imm = 0x115
popq %rbx
jmp 0xd249
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xbc130
movq %rsi, %rdx
testq %rsi, %rsi
je 0xbc130
movq %rdi, %rbx
leaq 0x28995(%rip), %rdi     # 0xe4aa6
leaq 0x35947(%rip), %rsi     # 0xf1a5f
leaq 0x33cf1(%rip), %rcx     # 0xefe10
callq 0x10c6a
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0xde89
movq 0x71e81(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xdf25(%rip), %rsi      # 0xca066
leaq 0x358e2(%rip), %rdx     # 0xf1a2a
leaq 0x358ea(%rip), %rcx     # 0xf1a39
leaq 0x35897(%rip), %r8      # 0xf19ed
movl $0x17c, %r9d            # imm = 0x17C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbccd5
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x152db
movq 0x10(%rbx), %rdi
callq 0x152db
movq 0x8(%rbx), %rdi
callq 0x152db
movq 0x18(%rbx), %rdi
callq 0x152db
movq 0xc8(%rbx), %rdi
callq 0x1583a
cmpb $0x0, 0xda(%rbx)
jne 0xbccae
movq 0x20(%rbx), %rdi
callq 0x10842
cmpb $0x0, 0xdb(%rbx)
jne 0xbccc0
movq 0x28(%rbx), %rdi
callq 0x10842
leaq 0x34d26(%rip), %rsi     # 0xf19ed
movq %rbx, %rdi
movl $0x1be, %edx            # imm = 0x1BE
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbd83e
movq %rdi, %rcx
movq %rsp, %rdi
andl $0x0, 0x3(%rdi)
andl $0x0, (%rdi)
pushq $0x8
popq %r14
subq %rdx, %r14
pushq $0x1
popq %rsi
movq %r14, %rdx
callq 0x1650c
jmp 0xbd841
xorl %r14d, %r14d
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbe33e
movq %rsi, %r14
testq %rsi, %rsi
je 0xbe33e
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jae 0xbe2da
movq (%r15), %rax
jmp 0xbe2fd
addq $0xa, %rax
movq %rax, 0x8(%r15)
movq (%r15), %rdi
imulq $0x28, %rax, %rsi
leaq 0x34314(%rip), %rdx     # 0xf2604
movl $0x22f, %ecx            # imm = 0x22F
callq 0xcfc2
movq %rax, (%r15)
testq %rax, %rax
je 0xbe36c
movq 0x10(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r15)
imulq $0x28, %rcx, %rcx
movl $0xb, (%rax,%rcx)
movq %r14, 0x10(%rax,%rcx)
movq $0x70, 0x18(%rax,%rcx)
movq %rbx, 0x20(%rax,%rcx)
leaq 0x3456f(%rip), %rdx     # 0xf28a2
movq %rdx, 0x8(%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x6fc73(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd17(%rip), %rsi      # 0xca066
leaq 0x3440c(%rip), %rdx     # 0xf2762
leaq 0x34545(%rip), %rcx     # 0xf28a2
leaq 0x342a0(%rip), %r8      # 0xf2604
movl $0x22d, %r9d            # imm = 0x22D
jmp 0xbe398
movq 0x6fc45(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xbce9(%rip), %rsi      # 0xca066
leaq 0x34405(%rip), %rdx     # 0xf2789
leaq 0x34517(%rip), %rcx     # 0xf28a2
leaq 0x34272(%rip), %r8      # 0xf2604
movl $0x22f, %r9d            # imm = 0x22F
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbe528
movq %rsi, %r14
testq %rsi, %rsi
je 0xbe528
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jae 0xbe4c4
movq (%r15), %rax
jmp 0xbe4e7
addq $0xa, %rax
movq %rax, 0x8(%r15)
movq (%r15), %rdi
imulq $0x28, %rax, %rsi
leaq 0x3412a(%rip), %rdx     # 0xf2604
movl $0x241, %ecx            # imm = 0x241
callq 0xcfc2
movq %rax, (%r15)
testq %rax, %rax
je 0xbe556
movq 0x10(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r15)
imulq $0x28, %rcx, %rcx
movl $0x1, (%rax,%rcx)
movq %r14, 0x10(%rax,%rcx)
movq $0x10, 0x18(%rax,%rcx)
movq %rbx, 0x20(%rax,%rcx)
leaq 0x343c3(%rip), %rdx     # 0xf28e0
movq %rdx, 0x8(%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x6fa89(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xbb2d(%rip), %rsi      # 0xca066
leaq 0x34222(%rip), %rdx     # 0xf2762
leaq 0x34399(%rip), %rcx     # 0xf28e0
leaq 0x340b6(%rip), %r8      # 0xf2604
movl $0x23f, %r9d            # imm = 0x23F
jmp 0xbe582
movq 0x6fa5b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xbaff(%rip), %rsi      # 0xca066
leaq 0x3421b(%rip), %rdx     # 0xf2789
leaq 0x3436b(%rip), %rcx     # 0xf28e0
leaq 0x34088(%rip), %r8      # 0xf2604
movl $0x241, %r9d            # imm = 0x241
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x34210(%rip), %rsi     # 0xf2990
pushq $0x70
popq %rdi
movl $0xc4, %edx
callq 0xccb0
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 0x341d1(%rip), %xmm0    # 0xf2980
movups %xmm0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbe7df
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 0x341a5(%rip), %xmm0    # 0xf2980
movups %xmm0, (%rdi)
retq
pushq %rax
movq 0x6f7d1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xb875(%rip), %rsi      # 0xca066
leaq 0x31ff2(%rip), %rdx     # 0xf07ea
leaq 0x341a8(%rip), %rcx     # 0xf29a7
leaq 0x3418a(%rip), %r8      # 0xf2990
movl $0xcf, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbe88a
movq %rsi, %r15
testq %rsi, %rsi
je 0xbe88a
movq %rdx, %rbx
cmpq $0x41, %rdx
jae 0xbe88a
movq %rdi, %r14
cmpq $0x0, 0x60(%rdi)
je 0xbe85f
leaq 0x20(%r14), %rdi
movq %r14, %rsi
callq 0xbe8c2
movdqu (%r14), %xmm1
movdqu 0x10(%r14), %xmm0
paddd %xmm1, %xmm0
movdqu %xmm0, (%r14)
jmp 0xbe864
movdqu (%r14), %xmm0
movdqu %xmm0, 0x10(%r14)
leaq 0x20(%r14), %rdi
movl 0x68(%r14), %ecx
movq %r15, %rsi
movl %ebx, %edx
callq 0xbeb9a
movl %eax, 0x68(%r14)
addq %rbx, 0x60(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq 0x6f727(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xb7cb(%rip), %rsi      # 0xca066
leaq 0x3411a(%rip), %rdx     # 0xf29bc
leaq 0x3412e(%rip), %rcx     # 0xf29d7
leaq 0x340e0(%rip), %r8      # 0xf2990
movl $0xda, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbebe5
movl %ecx, %ebp
movl %ebx, %r12d
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rdx
callq 0xb520
addq %rsp, %r12
pushq $0x40
popq %rdx
subl %ebx, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0xb2f0
pushq $0x1
popq %rax
testl %ebp, %ebp
jne 0xbebe8
movb $-0x80, (%r12)
jmp 0xbebe8
movq %rsi, %r15
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0xbebfd
movl (%r15,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
jmp 0xbebea
cmpl $0x38, %ebx
pushq $0x2
popq %rcx
cmovll %ecx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
andq $0x0, (%rsp)
testq %rdi, %rdi
je 0xbf174
movq %rsi, %r14
testq %rsi, %rsi
je 0xbf174
movl %edx, %ebp
movq %rdi, %rbx
movq %r14, %rdi
callq 0x54940
testb %al, %al
je 0xbf19e
testb %bpl, %bpl
je 0xbf119
leaq 0x18d09(%rip), %rsi     # 0xd7e05
leaq 0x33aac(%rip), %rdx     # 0xf2baf
pushq $0x2f
popq %rcx
movq %r14, %rdi
callq 0x51a8b
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x51db1
leaq 0x33a8f(%rip), %rdx     # 0xf2baf
movq %rsp, %r15
pushq $0x32
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x52d19
movq %rax, 0x8(%rbx)
movq (%r15), %r14
imulq $0x21, 0x18(%rbx), %r15
cmpq %r15, %r14
je 0xbf163
movq %rax, %rdi
callq 0x530de
andq $0x0, 0x8(%rbx)
movq (%rbx), %rdi
callq 0x51e47
movq (%rbx), %rdi
callq 0x51cc9
andq $0x0, (%rbx)
cmpq %r15, %r14
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x6ee3d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xaee1(%rip), %rsi      # 0xca066
leaq 0x33b07(%rip), %rdx     # 0xf2c93
leaq 0x33b21(%rip), %rcx     # 0xf2cb4
leaq 0x33a15(%rip), %r8      # 0xf2baf
pushq $0x2b
jmp 0xbf1c6
movq 0x6ee13(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xaeb7(%rip), %rsi      # 0xca066
leaq 0x33b10(%rip), %rdx     # 0xf2cc6
leaq 0x33af7(%rip), %rcx     # 0xf2cb4
leaq 0x339eb(%rip), %r8      # 0xf2baf
pushq $0x2d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbf280
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0xbf205
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0xbf2ae
leaq 0x339a3(%rip), %rdx     # 0xf2baf
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
movl $0x92, %ecx
callq 0xce9a
movq %rax, %r15
movq %r12, 0x18(%rax)
movq %r14, %rdi
callq 0x54940
testb %al, %al
je 0xbf249
movzbl %bpl, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xbf0ba
testb %al, %al
je 0xbf249
movb $0x0, 0x28(%r15)
jmp 0xbf274
leaq 0x3395f(%rip), %rsi     # 0xf2baf
movq %r15, %rdi
movl $0x9a, %edx
callq 0xd249
leaq 0x3397d(%rip), %rsi     # 0xf2be1
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xc007
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x6ed31(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xadd5(%rip), %rsi      # 0xca066
leaq 0x3393e(%rip), %rdx     # 0xf2bd6
leaq 0x33923(%rip), %rcx     # 0xf2bc2
leaq 0x33909(%rip), %r8      # 0xf2baf
movl $0x8f, %r9d
jmp 0xbf2da
movq 0x6ed03(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xada7(%rip), %rsi      # 0xca066
leaq 0xb393(%rip), %rdx      # 0xca659
leaq 0x338f5(%rip), %rcx     # 0xf2bc2
leaq 0x338db(%rip), %r8      # 0xf2baf
movl $0x90, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbf310
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xbf316
decq %rax
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rdi
callq 0x530de
movq (%rbx), %rdi
callq 0x51e47
movq (%rbx), %rdi
callq 0x51cc9
movq 0x30(%rbx), %rdi
callq 0x563a7
cmpb $0x1, 0x28(%rbx)
jne 0xbf379
xorl %r15d, %r15d
leaq 0x33867(%rip), %r14     # 0xf2baf
movq 0x10(%rbx), %rdi
cmpq 0x18(%rbx), %r15
jae 0xbf368
movq (%rdi,%r15,8), %rdi
movq %r14, %rsi
movl $0xb8, %edx
callq 0xd249
incq %r15
jmp 0xbf348
leaq 0x33840(%rip), %rsi     # 0xf2baf
movl $0xb9, %edx
callq 0xd249
leaq 0x3382f(%rip), %rsi     # 0xf2baf
movq %rbx, %rdi
movl $0xbb, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xd249
// File: /workspace/github_c_makefile_star2_O2/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 0xbf3b5
cmpq %rsi, 0x18(%rdi)
jbe 0xbf3b5
cmpb $0x1, 0x28(%rdi)
jne 0xbf3ac
movq 0x10(%rdi), %rax
movq (%rax,%rsi,8), %rax
retq
imulq $0x21, %rsi, %rax
addq 0x8(%rdi), %rax
retq
pushq %rax
movq 0x6ebfb(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xac9f(%rip), %rsi      # 0xca066
leaq 0x33852(%rip), %rdx     # 0xf2c20
leaq 0x33871(%rip), %rcx     # 0xf2c46
leaq 0x337d3(%rip), %r8      # 0xf2baf
movl $0xc0, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbf46b
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbf46b
movq %rdi, %r14
movq 0x30(%rdi), %r12
testq %r12, %r12
jne 0xbf451
pushq $0x1
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x55da4
movq %rax, 0x30(%r14)
pushq $0x1
popq %r15
leaq -0x1(%r15), %rsi
movq 0x30(%r14), %r12
cmpq 0x18(%r14), %rsi
jae 0xbf44c
movq %r14, %rdi
callq 0xbf392
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x55f31
incq %r15
jmp 0xbf423
testq %r12, %r12
je 0xbf499
movq %r12, %rdi
movq %rbx, %rsi
callq 0x55ef6
decq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x6eb46(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xabea(%rip), %rsi      # 0xca066
leaq 0x337d2(%rip), %rdx     # 0xf2c55
leaq 0x337da(%rip), %rcx     # 0xf2c64
leaq 0x3371e(%rip), %r8      # 0xf2baf
movl $0xd4, %r9d
jmp 0xbf4c5
movq 0x6eb18(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xabbc(%rip), %rsi      # 0xca066
leaq 0x337c2(%rip), %rdx     # 0xf2c73
leaq 0x337ac(%rip), %rcx     # 0xf2c64
leaq 0x336f0(%rip), %r8      # 0xf2baf
movl $0xd7, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbf559
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpq %r12, %r14
je 0xbf54d
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1642f
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1640e
incq %r12
jmp 0xbf52d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x6ea58(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xaafc(%rip), %rsi      # 0xca066
leaq 0x3380b(%rip), %rdx     # 0xf2d7c
leaq 0x3382d(%rip), %rcx     # 0xf2da5
leaq 0x33630(%rip), %r8      # 0xf2baf
pushq $0x4e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xbf5be
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0xbf60b
leaq 0x6e6eb(%rip), %r12     # 0x12dcb0
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0xbf5e7
movq (%r12), %rsi
movq %r14, %rdi
callq 0xb880
testl %eax, %eax
je 0xbf5fc
incq %r15
addq $0x8, %r12
jmp 0xbf5c8
leaq 0x337f3(%rip), %rsi     # 0xf2de1
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x6e9a6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xaa4a(%rip), %rsi      # 0xca066
leaq 0xb036(%rip), %rdx      # 0xca659
leaq 0x33791(%rip), %rcx     # 0xf2dbb
leaq 0x3379c(%rip), %r8      # 0xf2dcd
pushq $0x24
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbf6aa
movq %rdx, %rbx
testq %rdx, %rdx
je 0xbf6aa
movq %rsi, %r14
movq %rdi, %r15
leaq 0x337bd(%rip), %rdx     # 0xf2e33
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
pushq $0x22
popq %rcx
callq 0xce9a
movq %rax, %r12
movq %r15, (%rax)
movq %r14, 0x18(%rax)
movq %rbx, %rdi
callq 0x9ad5a
movq %rax, 0x28(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x6e907(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa9ab(%rip), %rsi      # 0xca066
leaq 0x33756(%rip), %rdx     # 0xf2e18
leaq 0x3375f(%rip), %rcx     # 0xf2e28
leaq 0x33763(%rip), %r8      # 0xf2e33
pushq $0x21
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbf76a
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xbf75a
cmpb $0x1, 0x21(%rbx)
jne 0xbf75a
leaq 0x336e1(%rip), %rsi     # 0xf2e33
pushq $0x3a
popq %rdx
callq 0xd249
movq %r14, 0x8(%rbx)
movb $0x1, 0x21(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x6e847(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa8eb(%rip), %rsi      # 0xca066
leaq 0x18328(%rip), %rdx     # 0xd7aaa
leaq 0x336d0(%rip), %rcx     # 0xf2e59
leaq 0x336a3(%rip), %r8      # 0xf2e33
pushq $0x38
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbf872
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
jne 0xbf870
movq 0x18(%rbx), %rdi
incq %rdi
leaq 0x335f2(%rip), %rsi     # 0xf2e33
pushq $0x4f
popq %rdx
callq 0xccb0
movq %rax, 0x10(%rbx)
movq 0x28(%rbx), %rdi
movq (%rbx), %rdx
movq 0x18(%rbx), %rcx
movq %rax, %rsi
callq 0x9bf2d
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rbx), %rax
popq %rbx
retq
movq 0x6e73f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa7e3(%rip), %rsi      # 0xca066
leaq 0x18220(%rip), %rdx     # 0xd7aaa
leaq 0x3360a(%rip), %rcx     # 0xf2e9b
leaq 0x3359b(%rip), %r8      # 0xf2e33
pushq $0x4d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbf99b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0xbf94e
movq (%rbx), %rdi
leaq 0x334ed(%rip), %rsi     # 0xf2e33
pushq $0x67
popq %rdx
callq 0xd249
cmpb $0x1, 0x21(%rbx)
jne 0xbf967
movq 0x8(%rbx), %rdi
leaq 0x334d4(%rip), %rsi     # 0xf2e33
pushq $0x69
popq %rdx
callq 0xd249
movq 0x10(%rbx), %rdi
leaq 0x334c1(%rip), %r14     # 0xf2e33
pushq $0x6a
popq %rdx
movq %r14, %rsi
callq 0xd249
movq 0x28(%rbx), %rdi
callq 0x9b1c1
pushq $0x6c
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbfa4a
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xbfa4a
leaq 0x334a8(%rip), %rdx     # 0xf2ee2
pushq $0x1
popq %rdi
pushq $0x45
popq %rcx
callq 0xce9a
movq %rbx, (%rax)
popq %rbx
retq
movq 0x6e567(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa60b(%rip), %rsi      # 0xca066
leaq 0x139cb(%rip), %rdx     # 0xd342d
leaq 0x33467(%rip), %rcx     # 0xf2ed0
leaq 0x33472(%rip), %r8      # 0xf2ee2
pushq $0x44
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbfab2
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xbfab4
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xbfa9f
movq %rbx, %rdi
callq *%rax
leaq 0x3343c(%rip), %rsi     # 0xf2ee2
pushq $0x50
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0xd249
popq %rbx
retq
movq 0x6e4fd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa5a1(%rip), %rsi      # 0xca066
leaq 0x33429(%rip), %rdx     # 0xf2ef5
leaq 0x3342e(%rip), %rcx     # 0xf2f01
leaq 0x33408(%rip), %r8      # 0xf2ee2
pushq $0x4d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbfb9f
testq %rsi, %rsi
je 0xbfb9f
testq %r8, %r8
je 0xbfb9f
movq (%rdi), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xbfb9c
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e411(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa4b5(%rip), %rsi      # 0xca066
leaq 0x2b2ad(%rip), %rdx     # 0xeae65
leaq 0x333a7(%rip), %rcx     # 0xf2f66
leaq 0x3331c(%rip), %r8      # 0xf2ee2
pushq $0x63
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbfbf6
testq %rsi, %rsi
je 0xbfbf6
testq %rdx, %rdx
je 0xbfbf6
movq (%rdi), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0xbfbf3
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e3ba(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa45e(%rip), %rsi      # 0xca066
leaq 0x2b354(%rip), %rdx     # 0xeaf63
leaq 0x33365(%rip), %rcx     # 0xf2f7b
leaq 0x332c5(%rip), %r8      # 0xf2ee2
pushq $0x6c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbfc4d
testq %rsi, %rsi
je 0xbfc4d
testq %rdx, %rdx
je 0xbfc4d
movq (%rdi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xbfc4a
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e363(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa407(%rip), %rsi      # 0xca066
leaq 0x2b2cc(%rip), %rdx     # 0xeaf32
leaq 0x33327(%rip), %rcx     # 0xf2f94
leaq 0x3326e(%rip), %r8      # 0xf2ee2
pushq $0x75
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbfca4
testq %rsi, %rsi
je 0xbfca4
testq %rdx, %rdx
je 0xbfca4
movq (%rdi), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0xbfca1
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e30c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3b0(%rip), %rsi      # 0xca066
leaq 0x2b2e2(%rip), %rdx     # 0xeaf9f
leaq 0x332f1(%rip), %rcx     # 0xf2fb5
leaq 0x33217(%rip), %r8      # 0xf2ee2
pushq $0x7e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbfcfb
testq %rsi, %rsi
je 0xbfcfb
testq %r8, %r8
je 0xbfcfb
movq (%rdi), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0xbfcf8
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e2b5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa359(%rip), %rsi      # 0xca066
leaq 0x332c6(%rip), %rdx     # 0xf2fda
leaq 0x332d6(%rip), %rcx     # 0xf2ff1
leaq 0x331c0(%rip), %r8      # 0xf2ee2
movl $0x88, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300