LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: seqdelivercharViaequallength
static GtUchar seqdelivercharViaequallength(GtEncseqReader *esr)
{
  GtUword twobits = EXTRACTENCODEDCHAR(esr->encseq->twobitencoding,
                                             esr->currentpos);

  if (twobits != (GtUword) esr->encseq->leastprobablecharacter ||
      !issinglepositioninseparatorViaequallength(esr) || esr->currentpos == 0)
    return (GtUchar) twobits;
  return (GtUchar) GT_SEPARATOR;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x280(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
shrq $0x5, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rdx
andq $0x1f, %rdx
movl $0x1f, %ecx
subq %rdx, %rcx
shlq %rcx
shrq %cl, %rax
andq $0x3, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movl 0x170(%rcx), %ecx
cmpq %rcx, %rax
jne 0x1396ef
movq 0x8(%rsp), %rdi
callq 0x13d0e0
testb $0x1, %al
jne 0x1396e3
jmp 0x1396ef
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1396f9
movq (%rsp), %rax
movb %al, 0x17(%rsp)
jmp 0x1396fe
movb $-0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: seqdelivercharViabitaccessSpecial
static GtUchar seqdelivercharViabitaccessSpecial(GtEncseqReader *esr)
{
  GtUword twobits = EXTRACTENCODEDCHAR(esr->encseq->twobitencoding,
                                             esr->currentpos);
  if (twobits > 1UL || !GT_ISIBITSET(esr->encseq->specialbits, esr->currentpos))
    return (GtUchar) twobits;
  return (twobits == (GtUword) GT_TWOBITS_FOR_SEPARATOR)
           ? (GtUchar) GT_SEPARATOR
           : (GtUchar) GT_WILDCARD;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq 0x280(%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
shrq $0x5, %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rdx
andq $0x1f, %rdx
movl $0x1f, %ecx
subq %rdx, %rcx
shlq %rcx
shrq %cl, %rax
andq $0x3, %rax
movq %rax, -0x18(%rsp)
cmpq $0x1, -0x18(%rsp)
ja 0x13a217
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq 0x2b0(%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x13a222
movq -0x18(%rsp), %rax
movb %al, -0x1(%rsp)
jmp 0x13a23c
movq -0x18(%rsp), %rdx
movl $0xfe, %eax
movl $0xff, %ecx
cmpq $0x1, %rdx
cmovel %ecx, %eax
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: containsspecialViatables
static bool containsspecialViatables(const GtEncseq *encseq,
                                     GtReadmode readmode,
                                     GtEncseqReader *esr,
                                     GtUword startpos,
                                     GtUword len)
{
  bool cspecial = false;

  gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, startpos);
  if (encseq->has_wildcardranges) {
    cspecial = containsSWViatables(encseq, esr, startpos, len,
                                   SWtable_wildcardrange);
  }
  if (!cspecial && encseq->numofdbsequences > 1UL) {
    cspecial = containsSWViatables(encseq, esr, startpos, len,
                                   SWtable_ssptab);
  }
  return cspecial;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0x115f90
movq 0x30(%rsp), %rax
testb $0x1, 0x29(%rax)
je 0x13b1e6
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
xorl %r8d, %r8d
callq 0x13d290
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
jne 0x13b21e
movq 0x30(%rsp), %rax
cmpq $0x1, 0x40(%rax)
jbe 0x13b21e
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0x13d290
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackarray.h
// Function: bitpackarray_store_uint32
static inline void
bitpackarray_store_uint32(BitPackArray *array, BitOffset index, uint32_t val)
{
  gt_assert(array && index < array->numElems
            && array->bitsPerElem <= sizeof (val)*CHAR_BIT);
  gt_bsStoreUInt32(array->store,
                   array->bitsPerElem * index,
                   array->bitsPerElem,
                   val);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x13cab8
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x13cab8
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
cmpq $0x20, %rax
jbe 0x13caf0
movq 0x77519(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x2159d(%rip), %rsi     # 0x15e066
leaq 0x4dd04(%rip), %rdx     # 0x18a7d4
leaq 0x4dd4d(%rip), %rcx     # 0x18a824
leaq 0x4bf1c(%rip), %r8      # 0x1889fa
movl $0x6c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x13caf2
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %esi
imulq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %edx
movl 0x4(%rsp), %ecx
callq 0x156dc0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: issinglepositioninseparatorViaequallength
static bool issinglepositioninseparatorViaequallength(GtEncseqReader *esr)
{
  if (esr->currentpos != esr->nextseparatorpos)
   return false;
  singlepositioninseparatorViaequallength_updatestate(esr);
  return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
je 0x13d104
movb $0x0, 0x17(%rsp)
jmp 0x13d113
movq 0x8(%rsp), %rdi
callq 0x1155f0
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq_access_type.c
// Function: gt_encseq_access_type_get
GtEncseqAccessType gt_encseq_access_type_get(const char *str)
{
  size_t i;

  for (i=0; i<sizeof (wpa)/sizeof (wpa[0]); i++)
  {
    gt_assert(i == 0 || wpa[i-1].sat < wpa[i].sat);
    if (strcmp(str,wpa[i].name) == 0)
    {
      return wpa[i].sat;
    }
  }
  return GT_ACCESS_TYPE_UNDEFINED;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x7, (%rsp)
jae 0x13e91f
jmp 0x13e85e
cmpq $0x0, (%rsp)
je 0x13e8cb
movq (%rsp), %rcx
subq $0x1, %rcx
leaq 0x7756c(%rip), %rax     # 0x1b5de0
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq (%rsp), %rdx
leaq 0x77558(%rip), %rcx     # 0x1b5de0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jb 0x13e8cb
movq 0x7573e(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1f7c2(%rip), %rsi     # 0x15e066
leaq 0x4c3a7(%rip), %rdx     # 0x18ac52
leaq 0x4c3c4(%rip), %rcx     # 0x18ac76
leaq 0x4c37b(%rip), %r8      # 0x18ac34
movl $0x40, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x13e8cd
movq 0x8(%rsp), %rdi
movq (%rsp), %rcx
leaq 0x77503(%rip), %rax     # 0x1b5de0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0xb850
cmpl $0x0, %eax
jne 0x13e90c
movq (%rsp), %rcx
leaq 0x774e3(%rip), %rax     # 0x1b5de0
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x13e927
jmp 0x13e90e
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x13e851
movl $0x7, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_class
const GtSeqColClass* gt_encseq_col_class(void)
{
  static const GtSeqColClass *esc_class = NULL;
  gt_class_alloc_lock_enter();
  if (!esc_class) {
      esc_class = gt_seq_col_class_new(sizeof (GtEncseqCol),
                                       gt_encseq_col_delete,
                                       gt_encseq_col_enable_match_desc_start,
                                       gt_encseq_col_grep_desc,
                                       gt_encseq_col_grep_desc_desc,
                                       gt_encseq_col_grep_desc_md5,
                                       gt_encseq_col_grep_desc_sequence_length,
                                       gt_encseq_col_md5_to_seq,
                                       gt_encseq_col_md5_to_description,
                                       gt_encseq_col_md5_to_sequence_length,
                                       gt_encseq_col_num_of_files,
                                       gt_encseq_col_num_of_seqs,
                                       gt_encseq_col_get_md5_fingerprint,
                                       gt_encseq_col_get_sequence,
                                       gt_encseq_col_get_description,
                                       gt_encseq_col_get_sequence_length);
  }
  gt_class_alloc_lock_leave();
  return esc_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
callq 0x7b730
cmpq $0x0, 0x77425(%rip)     # 0x1b6670
jne 0x13f310
movl $0x30, %edi
leaq 0xd3(%rip), %rsi        # 0x13f330
leaq 0x13c(%rip), %rdx       # 0x13f3a0
leaq 0x365(%rip), %rcx       # 0x13f5d0
leaq 0x54e(%rip), %r8        # 0x13f7c0
leaq 0x6a7(%rip), %r9        # 0x13f920
leaq 0x7e0(%rip), %rax       # 0x13fa60
movq %rax, 0x58(%rsp)
leaq 0x914(%rip), %rbp       # 0x13fba0
leaq 0xc2d(%rip), %r13       # 0x13fec0
leaq -0x2aa(%rip), %r12      # 0x13eff0
leaq 0xf0f(%rip), %r15       # 0x1401b0
leaq 0xf88(%rip), %r14       # 0x140230
leaq 0x1161(%rip), %rbx      # 0x140410
leaq 0x122a(%rip), %r11      # 0x1404e0
leaq 0x13f3(%rip), %r10      # 0x1406b0
leaq 0x157c(%rip), %rax      # 0x140840
movq %rax, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rax
movq %rbp, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r11, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rax, 0x48(%rsp)
callq 0x14a0e0
movq %rax, 0x77360(%rip)     # 0x1b6670
callq 0x7b790
movq 0x77354(%rip), %rax     # 0x1b6670
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_delete
static void gt_encseq_col_delete(GtSeqCol *sc)
{
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  if (!esc) return;
  gt_seq_info_cache_delete(esc->grep_cache);
  gt_hashmap_delete(esc->duplicates);
  gt_md5_tab_delete(esc->md5_tab);
  gt_encseq_delete(esc->encseq);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x13f230
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x14a350
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x13f35a
jmp 0x13f392
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x14ad40
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x86cc0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x149660
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x118250
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_grep_desc_desc
static int gt_encseq_col_grep_desc_desc(GtSeqCol *sc, GtStr *desc,
                                        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 && desc && seqid);
  had_err = gt_encseq_col_do_grep_desc(esc, &filenum, &seqnum, seqid, err);
  if (!had_err) {
    char *mydesc = gt_seq_col_get_description(sc, filenum, seqnum);
    if (mydesc)
      gt_str_append_cstr(desc, mydesc);
    gt_free(mydesc);
  }
  return had_err;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x13f230
movq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0x14a350
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x13f851
movq 0x28(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x13f819
jmp 0x13f851
movq 0x747b8(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1e83c(%rip), %rsi     # 0x15e066
leaq 0x1ee17(%rip), %rdx     # 0x15e648
leaq 0x4b7bb(%rip), %rcx     # 0x18aff3
leaq 0x4b66f(%rip), %r8      # 0x18aeae
movl $0xd4, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x13f853
jmp 0x13f855
cmpq $0x0, 0x8(%rsp)
je 0x13f86d
cmpq $0x0, 0x38(%rsp)
je 0x13f86d
cmpq $0x0, 0x30(%rsp)
jne 0x13f8a5
movq 0x74764(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1e7e8(%rip), %rsi     # 0x15e066
leaq 0x4b78b(%rip), %rdx     # 0x18b010
leaq 0x4b767(%rip), %rcx     # 0x18aff3
leaq 0x4b61b(%rip), %r8      # 0x18aeae
movl $0xd5, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x13f8a7
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x140ab0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x13f912
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x14abc0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x13f8fd
movq 0x38(%rsp), %rdi
movq (%rsp), %rsi
callq 0x18fb0
movq (%rsp), %rdi
leaq 0x4b5a6(%rip), %rsi     # 0x18aeae
movl $0xdb, %edx
callq 0xdab0
movl 0x14(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_grep_desc_md5
static int gt_encseq_col_grep_desc_md5(GtSeqCol *sc, const char **md5,
                                       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 && md5 && seqid);
  had_err = gt_encseq_col_do_grep_desc(esc, &filenum, &seqnum, seqid, err);
  if (!had_err)
    *md5 = gt_seq_col_get_md5_fingerprint(sc, filenum, seqnum);
  return had_err;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x13f230
movq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0x14a350
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x13f9b1
movq 0x28(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x13f979
jmp 0x13f9b1
movq 0x74658(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1e6dc(%rip), %rsi     # 0x15e066
leaq 0x1ecb7(%rip), %rdx     # 0x15e648
leaq 0x4b68d(%rip), %rcx     # 0x18b025
leaq 0x4b50f(%rip), %r8      # 0x18aeae
movl $0xc5, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x13f9b3
jmp 0x13f9b5
cmpq $0x0, 0x8(%rsp)
je 0x13f9cd
cmpq $0x0, 0x38(%rsp)
je 0x13f9cd
cmpq $0x0, 0x30(%rsp)
jne 0x13fa05
movq 0x74604(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1e688(%rip), %rsi     # 0x15e066
leaq 0x4b65c(%rip), %rdx     # 0x18b041
leaq 0x4b639(%rip), %rcx     # 0x18b025
leaq 0x4b4bb(%rip), %r8      # 0x18aeae
movl $0xc6, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x13fa07
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x140ab0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x13fa4f
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x14aa70
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movl 0x14(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x13f230
movq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0x14a350
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x13faf1
movq 0x28(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x13fab9
jmp 0x13faf1
movq 0x74518(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1e59c(%rip), %rsi     # 0x15e066
leaq 0x1eb77(%rip), %rdx     # 0x15e648
leaq 0x4b57d(%rip), %rcx     # 0x18b055
leaq 0x4b3cf(%rip), %r8      # 0x18aeae
movl $0xe9, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x13faf3
jmp 0x13faf5
cmpq $0x0, 0x8(%rsp)
je 0x13fb0d
cmpq $0x0, 0x38(%rsp)
je 0x13fb0d
cmpq $0x0, 0x30(%rsp)
jne 0x13fb45
movq 0x744c4(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1e548(%rip), %rsi     # 0x15e066
leaq 0x4b558(%rip), %rdx     # 0x18b07d
leaq 0x4b529(%rip), %rcx     # 0x18b055
leaq 0x4b37b(%rip), %r8      # 0x18aeae
movl $0xea, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x13fb47
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x140ab0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x13fb8f
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x14ac60
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movl 0x14(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
callq 0x13f230
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x14a350
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x140467
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x121fd0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jb 0x14049f
movq 0x73b6a(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1dbee(%rip), %rsi     # 0x15e066
leaq 0x4acb9(%rip), %rdx     # 0x18b138
leaq 0x4ad33(%rip), %rcx     # 0x18b1b9
leaq 0x4aa21(%rip), %r8      # 0x18aeae
movl $0x178, %r9d            # imm = 0x178
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1404a1
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x12cea0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq 0x20(%rsp), %rsi
callq 0x149760
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
callq 0x13f230
movq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0x14a350
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x140707
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x121fd0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x14073f
movq 0x738ca(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1d94e(%rip), %rsi     # 0x15e066
leaq 0x4aa19(%rip), %rdx     # 0x18b138
leaq 0x4ab08(%rip), %rcx     # 0x18b22e
leaq 0x4a781(%rip), %r8      # 0x18aeae
movl $0x19a, %r9d            # imm = 0x19A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x140741
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x12cea0
addq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x113f30
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jb 0x1407b9
movq 0x73850(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1d8d4(%rip), %rsi     # 0x15e066
leaq 0x4aa5d(%rip), %rdx     # 0x18b1f6
leaq 0x4aa8e(%rip), %rcx     # 0x18b22e
leaq 0x4a707(%rip), %r8      # 0x18aeae
movl $0x19c, %r9d            # imm = 0x19C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1407bb
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x11bd20
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1407e8
cmpq $0x0, 0x10(%rsp)
ja 0x140820
movq 0x737e9(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1d86d(%rip), %rsi     # 0x15e066
leaq 0x4aa4c(%rip), %rdx     # 0x18b24c
leaq 0x4aa27(%rip), %rcx     # 0x18b22e
leaq 0x4a6a0(%rip), %r8      # 0x18aeae
movl $0x19e, %r9d            # imm = 0x19E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x140822
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x7c4a0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
callq 0x13f230
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x14a350
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x140897
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x121fd0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x1408cf
movq 0x7373a(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1d7be(%rip), %rsi     # 0x15e066
leaq 0x4a889(%rip), %rdx     # 0x18b138
leaq 0x4a9aa(%rip), %rcx     # 0x18b260
leaq 0x4a5f1(%rip), %r8      # 0x18aeae
movl $0x1a9, %r9d            # imm = 0x1A9
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1408d1
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x12cea0
addq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11abd0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x14096e
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x140936
jmp 0x14096e
movq 0x7369b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1d71f(%rip), %rsi     # 0x15e066
leaq 0x1dcfa(%rip), %rdx     # 0x15e648
leaq 0x4a58e(%rip), %rcx     # 0x18aee3
leaq 0x4a552(%rip), %r8      # 0x18aeae
movl $0x1cc, %r9d            # imm = 0x1CC
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x140970
jmp 0x140972
cmpq $0x0, 0x18(%rsp)
jne 0x1409b2
movq 0x73657(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1d6db(%rip), %rsi     # 0x15e066
leaq 0x3b344(%rip), %rdx     # 0x17bcd6
leaq 0x4a54a(%rip), %rcx     # 0x18aee3
leaq 0x4a50e(%rip), %r8      # 0x18aeae
movl $0x1cd, %r9d            # imm = 0x1CD
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1409b4
movq 0x18(%rsp), %rdi
callq 0x11d300
testb $0x1, %al
jne 0x1409e3
movq 0x10(%rsp), %rdi
leaq 0x4a527(%rip), %rsi     # 0x18aef5
movb $0x0, %al
callq 0xc0d0
movq $0x0, 0x20(%rsp)
jmp 0x140a9d
callq 0x13f230
movq %rax, %rdi
callq 0x14a230
movq %rax, 0x8(%rsp)
callq 0x13f230
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x14a350
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11d240
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x140a74
movq 0x73595(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1d619(%rip), %rsi     # 0x15e066
leaq 0x4a4c5(%rip), %rdx     # 0x18af19
leaq 0x4a488(%rip), %rcx     # 0x18aee3
leaq 0x4a44c(%rip), %r8      # 0x18aeae
movl $0x1d6, %r9d            # imm = 0x1D6
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x140a76
movq 0x18(%rsp), %rdi
callq 0x118da0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movb $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq_metadata.c
// Function: gt_encseq_metadata_new
GtEncseqMetadata* gt_encseq_metadata_new(const char *indexname, GtError *err)
{
  int had_err = 0;
  GtEncseqMetadata *encseq_metadata;
  gt_assert(indexname);
  encseq_metadata = gt_malloc(sizeof (GtEncseqMetadata));
  encseq_metadata->alpha = NULL;
  encseq_metadata->customalphabet = false;
  had_err = readfirstvaluesfromfile(encseq_metadata, indexname, err);
  if (had_err) {
    gt_assert(gt_error_is_set(err));
    gt_free(encseq_metadata);
    encseq_metadata = NULL;
  }
  return encseq_metadata;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x141106
movq 0x72f03(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1cf87(%rip), %rsi     # 0x15e066
leaq 0x46604(%rip), %rdx     # 0x1876ea
leaq 0x4a195(%rip), %rcx     # 0x18b282
leaq 0x4a1a5(%rip), %r8      # 0x18b299
movl $0xb5, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x141108
movl $0xc8, %edi
leaq 0x4a185(%rip), %rsi     # 0x18b299
movl $0xb6, %edx
callq 0xd2e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x48(%rax)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x1411d0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x1411c1
jmp 0x14115a
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x1411a0
movq 0x72e69(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1ceed(%rip), %rsi     # 0x15e066
leaq 0x498b8(%rip), %rdx     # 0x18aa38
leaq 0x4a0fb(%rip), %rcx     # 0x18b282
leaq 0x4a10b(%rip), %r8      # 0x18b299
movl $0xbb, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1411a2
movq 0x8(%rsp), %rdi
leaq 0x4a0eb(%rip), %rsi     # 0x18b299
movl $0xbc, %edx
callq 0xdab0
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x142d8e
jmp 0x142dbb
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x142da6
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x1098b0
movq (%rsp), %rdi
leaq 0x484e8(%rip), %rsi     # 0x18b299
movl $0x115, %edx            # imm = 0x115
callq 0xdab0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq_options.c
// Function: gt_encseq_options_register_encoding
GtEncseqOptions* gt_encseq_options_register_encoding(GtOptionParser *op,
                                                     GtStr *indexname,
                                                     GtStrArray *indb)
{
  gt_assert(op != NULL);
  return gt_encseq_options_register_generic(op,
                                            GT_ENCSEQ_OPTS_ENCODE,
                                            indexname,
                                            indb);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x142e12
movq 0x711f7(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1b27b(%rip), %rsi     # 0x15e066
leaq 0x488c8(%rip), %rdx     # 0x18b6ba
leaq 0x488cc(%rip), %rcx     # 0x18b6c5
leaq 0x488e9(%rip), %r8      # 0x18b6e9
movl $0x168, %r9d            # imm = 0x168
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x142e14
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
xorl %esi, %esi
callq 0x142e30
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq_options.c
// Function: gt_encseq_options_register_loading
GtEncseqOptions* gt_encseq_options_register_loading(GtOptionParser *op,
                                                    GtStr *indexname)
{
  gt_assert(op != NULL);
  return gt_encseq_options_register_generic(op,
                                            GT_ENCSEQ_OPTS_LOAD,
                                            indexname,
                                            NULL);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x14363e
movq 0x709cb(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1aa4f(%rip), %rsi     # 0x15e066
leaq 0x4809c(%rip), %rdx     # 0x18b6ba
leaq 0x480de(%rip), %rcx     # 0x18b703
leaq 0x480bd(%rip), %r8      # 0x18b6e9
movl $0x172, %r9d            # imm = 0x172
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x143640
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x142e30
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x14367e
cmpq $0x0, 0x8(%rsp)
jne 0x1436b6
movq 0x70953(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1a9d7(%rip), %rsi     # 0x15e066
leaq 0x48090(%rip), %rdx     # 0x18b726
leaq 0x48098(%rip), %rcx     # 0x18b735
leaq 0x48045(%rip), %r8      # 0x18b6e9
movl $0x17c, %r9d            # imm = 0x17C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1436b8
movq 0x8(%rsp), %rdx
leaq 0x3653a(%rip), %rdi     # 0x179bfe
leaq 0x48090(%rip), %rsi     # 0x18b75b
leaq 0x46346(%rip), %rcx     # 0x189a18
callq 0x13ef0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xeb00
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x144571
jmp 0x1445fd
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1afc0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1afc0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1afc0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1afc0
movq (%rsp), %rax
movq 0xc8(%rax), %rdi
callq 0x1b780
movq (%rsp), %rax
testb $0x1, 0xda(%rax)
jne 0x1445ce
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x132f0
movq (%rsp), %rax
testb $0x1, 0xdb(%rax)
jne 0x1445e8
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x132f0
movq (%rsp), %rdi
leaq 0x470f6(%rip), %rsi     # 0x18b6e9
movl $0x1be, %edx            # imm = 0x1BE
callq 0xdab0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/mapspec.c
// Function: detexpectedaccordingtomapspec
static uint64_t detexpectedaccordingtomapspec(const GtArrayGtMapspecification
                                              *mapspectable)
{
  uint64_t sumup = 0;
  GtMapspecification *mapspecptr;

  for (mapspecptr = mapspectable->spaceGtMapspecification;
       mapspecptr < mapspectable->spaceGtMapspecification +
                    mapspectable->nextfreeGtMapspecification; mapspecptr++)
  {
    sumup += (uint64_t) mapspecptr->sizeofunit *
             (uint64_t) mapspecptr->numofunits;
    if (sumup % GT_WORDSIZE_INBYTES > 0)
    {
      sumup += (GT_WORDSIZE_INBYTES - (sumup % GT_WORDSIZE_INBYTES));
    }
  }
  return sumup;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
movq -0x8(%rsp), %rdx
imulq $0x28, 0x10(%rdx), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x145df3
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rsp), %rcx
imulq 0x20(%rcx), %rax
addq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jbe 0x145de1
movq -0x10(%rsp), %rcx
andq $0x7, %rcx
movl $0x8, %eax
subq %rcx, %rax
addq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
jmp 0x145de3
movq -0x18(%rsp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rsp)
jmp 0x145d7b
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jbe 0x145e76
leaq 0x11(%rsp), %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0xb2d0
movq 0x20(%rsp), %rcx
andq $0x7, %rcx
movl $0x8, %eax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
leaq 0x11(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rcx
movl $0x1, %esi
callq 0x1cab0
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x145e82
movq 0x28(%rsp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movl $0x70, %edi
leaq 0x44a76(%rip), %rsi     # 0x18c703
movl $0xc4, %edx
callq 0xd2e0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, 0x60(%rax)
movq (%rsp), %rax
movl $0x0, 0x68(%rax)
movq (%rsp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xb2d0
movq (%rsp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0xb2d0
movq (%rsp), %rdi
callq 0x147cf0
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_encoder.c
// Function: inic_digest
static void inic_digest(WORD32 *d) {
  d[0] = 0x67452301;
  d[1] = 0xEFCDAB89;
  d[2] = 0x98BADCFE;
  d[3] = 0x10325476;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x67452301, (%rax)     # imm = 0x67452301
movq -0x8(%rsp), %rax
movl $0xefcdab89, 0x4(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rsp), %rax
movl $0x98badcfe, 0x8(%rax)  # imm = 0x98BADCFE
movq -0x8(%rsp), %rax
movl $0x10325476, 0xc(%rax)  # imm = 0x10325476
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x147d74
movq 0x6c295(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x16319(%rip), %rsi     # 0x15e066
leaq 0x42795(%rip), %rdx     # 0x18a4e9
leaq 0x449bf(%rip), %rcx     # 0x18c71a
leaq 0x449a1(%rip), %r8      # 0x18c703
movl $0xcf, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x147d76
movq (%rsp), %rax
movq $0x0, 0x60(%rax)
movq (%rsp), %rax
movl $0x0, 0x68(%rax)
movq (%rsp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xb2d0
movq (%rsp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0xb2d0
movq (%rsp), %rdi
callq 0x147cf0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x147de9
cmpq $0x0, 0x8(%rsp)
je 0x147de9
cmpq $0x41, (%rsp)
jb 0x147e21
movq 0x6c1e8(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1626c(%rip), %rsi     # 0x15e066
leaq 0x4492e(%rip), %rdx     # 0x18c72f
leaq 0x44942(%rip), %rcx     # 0x18c74a
leaq 0x448f4(%rip), %r8      # 0x18c703
movl $0xda, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x147e23
movq 0x10(%rsp), %rax
cmpq $0x0, 0x60(%rax)
jbe 0x147e8c
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rsi
callq 0x147f10
movq 0x10(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x10(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movl 0x14(%rax), %ecx
movq 0x10(%rsp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
movq 0x10(%rsp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %ecx
movq 0x10(%rsp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rax
movl %eax, %edx
movq 0x10(%rsp), %rax
movl 0x68(%rax), %ecx
callq 0x1488a0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x68(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
cmpl $0x40, 0x54(%rsp)
jge 0x148915
movq %rsp, %rdi
movq 0x58(%rsp), %rsi
movslq 0x54(%rsp), %rdx
callq 0xb500
movq %rsp, %rdi
movslq 0x54(%rsp), %rax
addq %rax, %rdi
movl $0x40, %eax
subl 0x54(%rsp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0xb2d0
cmpl $0x0, 0x50(%rsp)
jne 0x148905
movslq 0x54(%rsp), %rax
movb $-0x80, (%rsp,%rax)
movl $0x1, 0x4c(%rsp)
movq %rsp, %rax
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x148ea0
cmpl $0x37, 0x54(%rsp)
jg 0x148933
movl $0x2, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_encoder.c
// Function: word32tobytes
static void word32tobytes (const WORD32 *input, char *output) {
  int j = 0;
  while (j<4*4) {
    WORD32 v = *input++;
    output[j++] = (char)(v & 0xff); v >>= 8;
    output[j++] = (char)(v & 0xff); v >>= 8;
    output[j++] = (char)(v & 0xff); v >>= 8;
    output[j++] = (char)(v & 0xff);
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x10, -0x14(%rsp)
jge 0x148e66
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rsp)
movl (%rax), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x148d92
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/md5_encoder.c
// Function: bytestoword32
static void bytestoword32 (WORD32 *x, const char *pt) {
  int i;
  for (i=0; i<16; i++) {
    int j=i*4;
    x[i] = (((WORD32)(unsigned char)pt[j+3] << 8 |
           (WORD32)(unsigned char)pt[j+2]) << 8 |
           (WORD32)(unsigned char)pt[j+1]) << 8 |
           (WORD32)(unsigned char)pt[j];
  }

}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x10, -0x14(%rsp)
jge 0x148f37
movl -0x14(%rsp), %eax
shll $0x2, %eax
movl %eax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
shll $0x8, %edx
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
orl %eax, %edx
shll $0x8, %edx
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
orl %eax, %edx
shll $0x8, %edx
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
orl %eax, %edx
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x148eb2
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movb $0x1, 0x16(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x149194
cmpq $0x0, 0x18(%rsp)
jne 0x1491cc
movq 0x6ae3d(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14ec1(%rip), %rsi     # 0x15e066
leaq 0x43857(%rip), %rdx     # 0x18ca03
leaq 0x43871(%rip), %rcx     # 0x18ca24
leaq 0x43765(%rip), %r8      # 0x18c91f
movl $0x2b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1491ce
jmp 0x1491d0
movq 0x18(%rsp), %rdi
callq 0x84330
testb $0x1, %al
jne 0x149216
movq 0x6adf3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14e77(%rip), %rsi     # 0x15e066
leaq 0x43840(%rip), %rdx     # 0x18ca36
leaq 0x43827(%rip), %rcx     # 0x18ca24
leaq 0x4371b(%rip), %r8      # 0x18c91f
movl $0x2d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x149218
testb $0x1, 0x17(%rsp)
je 0x149254
movq 0x18(%rsp), %rdi
leaq 0x22fe1(%rip), %rsi     # 0x16c20c
leaq 0x436ed(%rip), %rdx     # 0x18c91f
movl $0x2f, %ecx
callq 0x7f9b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x7ff30
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x436ba(%rip), %rdx     # 0x18c91f
movl $0x32, %ecx
callq 0x814c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
imulq $0x21, 0x18(%rcx), %rcx
cmpq %rcx, %rax
je 0x1492d5
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x81a80
movq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x7fff0
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x7fd50
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x16(%rsp)
movb 0x16(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq