LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_guess
GtAlphabet* gt_alphabet_guess(const char *sequence, GtUword seqlen)
{
  GtUword i;
  gt_assert(sequence && seqlen);
  for (i = 0;
       i < seqlen && i < (GtUword) ALPHABET_GUESS_MAX_LENGTH;
        i++) {
    if (strchr(ALPHABET_GUESS_PROTEIN_CHARS, sequence[i]) != NULL)
      return gt_alphabet_new_protein();
  }
  return gt_alphabet_new_dna();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x9b51c
testq %rsi, %rsi
je 0x9b51c
movq %rdi, %rbx
movl $0x1388, %r12d          # imm = 0x1388
cmpq %r12, %rsi
cmovbq %rsi, %r12
xorl %r13d, %r13d
leaq 0x4ec43(%rip), %r14     # 0xea122
pushq $0x13
popq %r15
cmpq %r13, %r12
je 0x9b50e
movsbl (%rbx,%r13), %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0xb710
incq %r13
testq %rax, %rax
je 0x9b4e3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9b369
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9b273
movq 0x92a95(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2eb39(%rip), %rsi     # 0xca066
leaq 0x4ebc9(%rip), %rdx     # 0xea0fd
leaq 0x4ebd5(%rip), %rcx     # 0xea110
leaq 0x4eae0(%rip), %r8      # 0xea022
movl $0x27b, %r9d            # imm = 0x27B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_output
void gt_alphabet_output(const GtAlphabet *alphabet, FILE *fpout)
{
  GtStr *buf;
  gt_assert(alphabet && fpout);
  buf = gt_str_new();
  gt_alphabet_to_str(alphabet, buf);
  gt_xfwrite(gt_str_get(buf), sizeof (char), (size_t) gt_str_length(buf),
             fpout);
  gt_str_delete(buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x9b913
movq %rsi, %rbx
testq %rsi, %rsi
je 0x9b913
movq %rdi, %r14
callq 0x13d5c
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x9b6ea
movq %r15, %rdi
callq 0x143d2
movq %rax, %r14
movq %r15, %rdi
callq 0x14461
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x1650c
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x152db
movq 0x9269e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2e742(%rip), %rsi     # 0xca066
leaq 0x4e8dd(%rip), %rdx     # 0xea208
leaq 0x4e8e8(%rip), %rcx     # 0xea21a
leaq 0x4e6e9(%rip), %r8      # 0xea022
movl $0x2e6, %r9d            # imm = 0x2E6
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_decode_seq_to_fp
void gt_alphabet_decode_seq_to_fp(const GtAlphabet *alphabet, FILE *fpout,
                                  const GtUchar *src, GtUword len)
{
  GtUword i;
  const GtUchar *characters;
  gt_assert(fpout != NULL && (len == 0 || src != NULL));

  if (alphabet == NULL)
  {
    characters = (const GtUchar *) "acgt";
  } else
  {
    characters = alphabet->characters;
  }
  for (i = 0; i < len; i++)
  {
    gt_xfputc((int) characters[(int) src[i]],fpout);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x9b9b0
movq %rcx, %rbx
movq %rdx, %r14
testq %rcx, %rcx
sete %al
testq %rdx, %rdx
setne %cl
orb %al, %cl
je 0x9b9b0
movq %rsi, %r15
testq %rdi, %rdi
je 0x9b980
movq 0x120(%rdi), %r12
jmp 0x9b987
leaq 0x4e8ee(%rip), %r12     # 0xea275
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x9b9a6
movzbl (%r14,%r13), %eax
movzbl (%r12,%rax), %edi
movq %r15, %rsi
callq 0x1640e
incq %r13
jmp 0x9b98a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x92601(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2e6a5(%rip), %rsi     # 0xca066
leaq 0x4e865(%rip), %rdx     # 0xea22d
leaq 0x4e889(%rip), %rcx     # 0xea258
leaq 0x4e64c(%rip), %r8      # 0xea022
movl $0x2f3, %r9d            # imm = 0x2F3
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_decode_seq_to_cstr
void gt_alphabet_decode_seq_to_cstr(const GtAlphabet *alphabet, char *dest,
                                    const GtUchar *src, GtUword len)
{
  GtUword i;

  for (i = 0; i < len; i++)
  {
    dest[i] = converttoprettysymbol(alphabet, (GtUchar) src[i]);
  }
  dest[len] = '\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x9ba30
movzbl (%r15,%r13), %esi
movq %r12, %rdi
callq 0x9ba3f
movb %al, (%r14,%r13)
incq %r13
jmp 0x9ba15
movb $0x0, (%r14,%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: converttoprettysymbol
static inline char converttoprettysymbol(const GtAlphabet *alphabet,
                                         GtUchar currentchar)
{
  gt_assert(alphabet != NULL && currentchar != (GtUchar) GT_SEPARATOR);
  if (currentchar < (GtUchar) GT_WILDCARD)
  {
    gt_assert((unsigned int) currentchar < alphabet->mapsize-1);
    return (char) alphabet->characters[(int) currentchar];
  } else return (char) alphabet->wildcardshow;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x9ba72
cmpb $-0x1, %sil
je 0x9ba72
cmpb $-0x3, %sil
ja 0x9ba67
movl 0x4(%rdi), %eax
decl %eax
cmpl %esi, %eax
jbe 0x9baa0
movzbl %sil, %eax
addq 0x120(%rdi), %rax
jmp 0x9ba6e
addq $0x14, %rdi
movq %rdi, %rax
movb (%rax), %al
popq %rcx
retq
movq 0x9253f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2e5e3(%rip), %rsi     # 0xca066
leaq 0x4eaa1(%rip), %rdx     # 0xea52b
leaq 0x4ead4(%rip), %rcx     # 0xea565
leaq 0x4e58a(%rip), %r8      # 0xea022
movl $0x30b, %r9d            # imm = 0x30B
jmp 0x9bacc
movq 0x92511(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2e5b5(%rip), %rsi     # 0xca066
leaq 0x4eac3(%rip), %rdx     # 0xea57b
leaq 0x4eaa6(%rip), %rcx     # 0xea565
leaq 0x4e55c(%rip), %r8      # 0xea022
movl $0x30e, %r9d            # imm = 0x30E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_decode_seq_to_str
GtStr* gt_alphabet_decode_seq_to_str(const GtAlphabet *alphabet,
                                     const GtUchar *src,
                                     GtUword len)
{
  char *buffer;
  GtStr *ret;
  gt_assert(alphabet && src);
  buffer = gt_malloc(sizeof (char) * len+1);
  gt_alphabet_decode_seq_to_cstr(alphabet, buffer, src, len);
  ret = gt_str_new_cstr(buffer);
  gt_free(buffer);
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x9bb48
movq %rsi, %r14
testq %rsi, %rsi
je 0x9bb48
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x1(%rdx), %rdi
leaq 0x4e523(%rip), %r12     # 0xea022
movq %r12, %rsi
movl $0x326, %edx            # imm = 0x326
callq 0xccb0
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x9b9fd
movq %r13, %rdi
callq 0x13da9
movq %rax, %rbx
movq %r13, %rdi
movq %r12, %rsi
movl $0x329, %edx            # imm = 0x329
callq 0xd249
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x92469(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2e50d(%rip), %rsi     # 0xca066
leaq 0x4e71a(%rip), %rdx     # 0xea27a
leaq 0x4e723(%rip), %rcx     # 0xea28a
leaq 0x4e4b4(%rip), %r8      # 0xea022
movl $0x325, %r9d            # imm = 0x325
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_is_protein
bool gt_alphabet_is_protein(const GtAlphabet *alphabet)
{
  GtAlphabet proteinalphabet;
  unsigned int reduceddomainsize1, reduceddomainsize2;
  bool isprot;
  GtUchar domainbuf1[GT_MAXALPHABETCHARACTER+1],
        domainbuf2[GT_MAXALPHABETCHARACTER+1];

  reduceddomainsize1 = removelowercaseproteinchars(&domainbuf1[0],alphabet);
  assign_protein_alphabet(&proteinalphabet);
  reduceddomainsize2 = removelowercaseproteinchars(&domainbuf2[0],
                                                   &proteinalphabet);
  if (reduceddomainsize1 == reduceddomainsize2)
  {
    qsort(&domainbuf1[0],(size_t) reduceddomainsize1,sizeof (char),comparechar);
    qsort(&domainbuf2[0],(size_t) reduceddomainsize2,sizeof (char),comparechar);
    if (memcmp((const void *) domainbuf1,(const void *) domainbuf2,
               reduceddomainsize2 * sizeof (GtUchar)) == 0)
    {
      isprot = true;
    } else
    {
      isprot = false;
    }
  } else
  {
    isprot = false;
  }
  gt_free(proteinalphabet.mapdomain);
  gt_free(proteinalphabet.characters);
  return isprot;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x340, %rsp            # imm = 0x340
movq %rdi, %rsi
leaq 0x240(%rsp), %rdi
callq 0x9bcc0
movl %eax, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x9b3bc
leaq 0x140(%rsp), %rdi
movq %r14, %rsi
callq 0x9bcc0
cmpl %eax, %ebx
jne 0x9bc7a
movl %ebx, %ebx
leaq 0xe8(%rip), %r14        # 0x9bd17
leaq 0x240(%rsp), %r15
pushq $0x1
popq %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xbc70
leaq 0x140(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xbc70
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xb6b0
testl %eax, %eax
sete %bl
jmp 0x9bc7c
xorl %ebx, %ebx
movq 0x120(%rsp), %rdi
leaq 0x4e397(%rip), %r14     # 0xea022
movq %r14, %rsi
movl $0x375, %edx            # imm = 0x375
callq 0xd249
movq 0x128(%rsp), %rdi
movq %r14, %rsi
movl $0x376, %edx            # imm = 0x376
callq 0xd249
movl %ebx, %eax
addq $0x340, %rsp            # imm = 0x340
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: removelowercaseproteinchars
static unsigned int removelowercaseproteinchars(GtUchar *domainbuf,
                                                const GtAlphabet *alpha)
{
  unsigned int i, j = 0;

  for (i=0; i< alpha->domainsize - alpha->mappedwildcards; i++)
  {
    if (isalnum((int) alpha->mapdomain[i]) &&
        isupper((int) alpha->mapdomain[i]))
    {
      domainbuf[j++] = alpha->mapdomain[i];
    }
  }
  return j;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %ebp, %ebp
movl (%rbx), %eax
subl 0x8(%rbx), %eax
cmpq %rax, %r15
jae 0x9bd0a
callq 0xb6e0
movq (%rax), %rcx
movq 0x118(%rbx), %rax
movzbl (%rax,%r15), %eax
movzwl (%rcx,%rax,2), %ecx
notl %ecx
testw $0x108, %cx             # imm = 0x108
jne 0x9bd05
movl %ebp, %ecx
incl %ebp
movb %al, (%r14,%rcx)
incq %r15
jmp 0x9bcd2
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_is_dna
bool gt_alphabet_is_dna(const GtAlphabet *alphabet)
{
  if (gt_alphabet_is_protein(alphabet))
  {
    return false;
  }
  if (alphabet->mapsize == MAPSIZEDNA)
  {
    GtUchar dnasymbolmap[GT_MAXALPHABETCHARACTER+1];

    assign_dna_symbolmap(&dnasymbolmap[0]);
    if (check_symbolmap(alphabet->symbolmap,&dnasymbolmap[0],"acgt"))
    {
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
callq 0x9bbe3
testb %al, %al
jne 0x9bdb0
cmpl $0x5, 0x4(%rbx)
jne 0x9bdb0
movq %rsp, %rdi
callq 0x9bdfd
xorl %r15d, %r15d
leaq 0x4e51c(%rip), %r12     # 0xea275
movzbl (%r15,%r12), %r14d
cmpq $0x4, %r15
je 0x9bdab
callq 0xb6e0
movq (%rax), %rax
movzwl (%rax,%r14,2), %eax
btl $0x8, %eax
jb 0x9bd87
btl $0x9, %eax
jae 0x9bdc5
movl %r14d, %edi
callq 0xbbe0
jmp 0x9bd8f
movl %r14d, %edi
callq 0xb8f0
movb 0x15(%rbx,%r14), %cl
cmpb (%rsp,%r14), %cl
je 0x9bda6
movzbl %al, %eax
movb 0x15(%rbx,%rax), %cl
cmpb (%rsp,%rax), %cl
jne 0x9bdab
incq %r15
jmp 0x9bd59
testl %r14d, %r14d
je 0x9bdc1
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x9bdb2
movq 0x921ec(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2e290(%rip), %rsi     # 0xca066
leaq 0x4e7cf(%rip), %rdx     # 0xea5ac
leaq 0x4e7db(%rip), %rcx     # 0xea5bf
leaq 0x4e237(%rip), %r8      # 0xea022
movl $0x389, %r9d            # imm = 0x389
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: assign_dna_symbolmap
static void assign_dna_symbolmap(GtUchar *symbolmap)
{
  unsigned int cnum;

  for (cnum=0; cnum<=(unsigned int) GT_MAXALPHABETCHARACTER; cnum++)
  {
    symbolmap[cnum] = (GtUchar) GT_UNDEFCHAR;
  }
  symbolmap[(unsigned int) 'a'] = (GtUchar) 0;
  symbolmap[(unsigned int) 'A'] = (GtUchar) 0;
  symbolmap[(unsigned int) 'c'] = (GtUchar) 1;
  symbolmap[(unsigned int) 'C'] = (GtUchar) 1;
  symbolmap[(unsigned int) 'g'] = (GtUchar) 2;
  symbolmap[(unsigned int) 'G'] = (GtUchar) 2;
  symbolmap[(unsigned int) 't'] = (GtUchar) 3;
  symbolmap[(unsigned int) 'T'] = (GtUchar) 3;
  symbolmap[(unsigned int) 'u'] = (GtUchar) 3;
  symbolmap[(unsigned int) 'U'] = (GtUchar) 3;
  for (cnum=0; DNAWILDCARDS[cnum] != '\0'; cnum++)
  {
    symbolmap[(unsigned int) DNAWILDCARDS[cnum]] = (GtUchar) GT_WILDCARD;
  }
}

// Assembly:
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x9be10
movb $-0x3, (%rdi,%rax)
incq %rax
jmp 0x9bdff
xorl %eax, %eax
movb %al, 0x61(%rdi)
movb %al, 0x41(%rdi)
movb $0x1, %cl
movb %cl, 0x63(%rdi)
movb %cl, 0x43(%rdi)
movb $0x2, %cl
movb %cl, 0x67(%rdi)
movb %cl, 0x47(%rdi)
movw $0x303, %cx             # imm = 0x303
movw %cx, 0x74(%rdi)
movw %cx, 0x54(%rdi)
leaq 0x4e6a7(%rip), %rcx     # 0xea4e2
cmpq $0x16, %rax
je 0x9be51
movsbq (%rax,%rcx), %rdx
movl %edx, %edx
movb $-0x2, (%rdi,%rdx)
incq %rax
jmp 0x9be3b
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_decode
char gt_alphabet_decode(const GtAlphabet *alphabet, GtUchar c)
{
  gt_assert(alphabet);
  if (c == (GtUchar) alphabet->mapsize - 1)
    return (char) alphabet->wildcardshow;
  return converttoprettysymbol(alphabet, c);
}

// Assembly:
testq %rdi, %rdi
je 0x9bef4
movzbl %sil, %esi
movzbl 0x4(%rdi), %eax
decl %eax
cmpl %esi, %eax
jne 0x9beef
movb 0x14(%rdi), %al
retq
jmp 0x9ba3f
pushq %rax
movq 0x920bc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2e160(%rip), %rsi     # 0xca066
leaq 0x47a0b(%rip), %rdx     # 0xe3918
leaq 0x4e411(%rip), %rcx     # 0xea325
leaq 0x4e107(%rip), %r8      # 0xea022
movl $0x3b8, %r9d            # imm = 0x3B8
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_encode_seq
void gt_alphabet_encode_seq(const GtAlphabet *alphabet, GtUchar *out,
                            const char *in, GtUword length)
{
  GtUword i;
  gt_assert(alphabet && out && in);
  for (i = 0; i < length; i++) {
    GtUchar cc = alphabet->symbolmap[(int) in[i]];
    gt_assert(cc != (GtUchar) GT_UNDEFCHAR);
    out[i] = cc;
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x9bf97
testq %rsi, %rsi
je 0x9bf97
testq %rdx, %rdx
je 0x9bf97
xorl %eax, %eax
cmpq %rax, %rcx
je 0x9bf5d
movsbq (%rdx,%rax), %r8
movb 0x15(%rdi,%r8), %r8b
cmpb $-0x3, %r8b
je 0x9bf5f
movb %r8b, (%rsi,%rax)
incq %rax
jmp 0x9bf3f
popq %rax
retq
movq 0x92052(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2e0f6(%rip), %rsi     # 0xca066
leaq 0x4e3ee(%rip), %rdx     # 0xea365
leaq 0x4e3d0(%rip), %rcx     # 0xea34e
leaq 0x4e09d(%rip), %r8      # 0xea022
movl $0x3c5, %r9d            # imm = 0x3C5
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x9201a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2e0be(%rip), %rsi     # 0xca066
leaq 0x4e389(%rip), %rdx     # 0xea338
leaq 0x4e398(%rip), %rcx     # 0xea34e
leaq 0x4e065(%rip), %r8      # 0xea022
movl $0x3c2, %r9d            # imm = 0x3C2
jmp 0x9bf8b
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_new_from_file
GtAlphabet *gt_alphabet_new_from_file(const char *filename,
                                      GtError *err)
{
  GtStr *tmpfilename;
  GtAlphabet *a;
  gt_assert(filename);
  tmpfilename = gt_str_new_cstr(filename);
  gt_str_append_cstr(tmpfilename, GT_ALPHABETFILESUFFIX);
  a = gt_alphabet_new_from_file_no_suffix(gt_str_get(tmpfilename), err);
  gt_str_delete(tmpfilename);
  return a;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9c011
movq %rsi, %rbx
callq 0x13da9
movq %rax, %r14
leaq 0x4e3bc(%rip), %rsi     # 0xea39c
movq %rax, %rdi
callq 0x13dd3
movq %r14, %rdi
callq 0x143d2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x9c049
movq %rax, %rbx
movq %r14, %rdi
callq 0x152db
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x91fa0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2e044(%rip), %rsi     # 0xca066
leaq 0x38f87(%rip), %rdx     # 0xd4fb0
leaq 0x4e352(%rip), %rcx     # 0xea382
leaq 0x4dfeb(%rip), %r8      # 0xea022
movl $0x3cf, %r9d            # imm = 0x3CF
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_new_from_string
GtAlphabet* gt_alphabet_new_from_string(const char *alphadef, GtUword len,
                                        GtError *err)
{
  GtUword i, j;
  GtStrArray *sa;
  GtAlphabet *alpha;
  gt_assert(alphadef && len > 0);
  gt_error_check(err);

  alpha = gt_alphabet_new_empty();
  gt_assert(alphadef);

  sa = gt_str_array_new();
  j = 0;
  for (i = 0; i < len; i++) {
    if (alphadef[i] == '\n' || i == len - 1) {
      gt_str_array_add_cstr_nt(sa, alphadef+j, i - j);
      j = i+1;
    }
  }
  if (read_symbolmap_from_lines(alpha, NULL, sa, err) != 0) {
    gt_str_array_delete(sa);
    gt_assert(gt_error_is_set(err));
    return NULL;
  }
  gt_str_array_delete(sa);
  return alpha;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9c33c
movq %rsi, %r14
testq %rsi, %rsi
je 0x9c33c
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x9c2ac
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x9c36a
movq %rbx, (%rsp)
callq 0x9b167
movq %rax, %r12
callq 0x1532c
movq %rax, %r13
leaq -0x1(%r14), %rbp
xorl %eax, %eax
movq %rax, %rbx
cmpq %r14, %rbx
je 0x9c2f9
cmpq %rbp, %rbx
je 0x9c2df
cmpb $0xa, (%r15,%rbx)
je 0x9c2df
incq %rbx
jmp 0x9c2c9
leaq (%r15,%rax), %rsi
movq %rbx, %rdx
subq %rax, %rdx
movq %r13, %rdi
callq 0x15470
incq %rbx
movq %rbx, %rax
jmp 0x9c2c9
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq (%rsp), %rbx
movq %rbx, %rcx
callq 0x9c3d0
movl %eax, %ebp
movq %r13, %rdi
callq 0x1583a
testl %ebp, %ebp
je 0x9c32a
movq %rbx, %rdi
callq 0xc103
testb %al, %al
je 0x9c398
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x91c75(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2dd19(%rip), %rsi     # 0xca066
leaq 0x4e04d(%rip), %rdx     # 0xea3a1
leaq 0x4e05a(%rip), %rcx     # 0xea3b5
leaq 0x4dcc0(%rip), %r8      # 0xea022
movl $0x3dd, %r9d            # imm = 0x3DD
jmp 0x9c3c4
movq 0x91c47(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2dceb(%rip), %rsi     # 0xca066
leaq 0x2e2d7(%rip), %rdx     # 0xca659
leaq 0x4e02c(%rip), %rcx     # 0xea3b5
leaq 0x4dc92(%rip), %r8      # 0xea022
movl $0x3de, %r9d            # imm = 0x3DE
jmp 0x9c3c4
movq 0x91c19(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2dcbd(%rip), %rsi     # 0xca066
leaq 0x54989(%rip), %rdx     # 0xf0d39
leaq 0x4dffe(%rip), %rcx     # 0xea3b5
leaq 0x4dc64(%rip), %r8      # 0xea022
movl $0x3ed, %r9d            # imm = 0x3ED
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_to_file
int gt_alphabet_to_file(const GtAlphabet *alphabet, const char *indexname,
                        GtError *err)
{
  FILE *al1fp;
  bool haserr = false;

  gt_error_check(err);
  al1fp = gt_fa_fopen_with_suffix(indexname,GT_ALPHABETFILESUFFIX,"wb",err);
  if (al1fp == NULL)
  {
    haserr = true;
  }
  if (!haserr)
  {
    GtStr *buf = gt_str_new();
    gt_alphabet_to_str(alphabet, buf);
    gt_xfwrite(gt_str_get(buf), sizeof (char), (size_t) gt_str_length(buf),
               al1fp);
    gt_fa_xfclose(al1fp);
    gt_str_delete(buf);
  }
  return haserr ? -1 : 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x9c735
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x9c7b8
leaq 0x4dc60(%rip), %rsi     # 0xea39c
leaq 0x4dcdf(%rip), %rdx     # 0xea422
leaq 0x4d8d8(%rip), %rcx     # 0xea022
movq %r15, %rdi
movl $0x429, %r8d            # imm = 0x429
movq %rbx, %r9
callq 0x51b2d
movq %rax, %rbx
testq %rax, %rax
je 0x9c7aa
callq 0x13d5c
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x9b6ea
movq %r15, %rdi
callq 0x143d2
movq %rax, %r14
movq %r15, %rdi
callq 0x14461
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x1650c
movq %rbx, %rdi
callq 0x51cc9
movq %r15, %rdi
callq 0x152db
xorl %eax, %eax
cmpq $0x1, %rbx
sbbl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x917f9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2d89d(%rip), %rsi     # 0xca066
leaq 0x2de89(%rip), %rdx     # 0xca659
leaq 0x4dc37(%rip), %rcx     # 0xea40e
leaq 0x4d844(%rip), %r8      # 0xea022
movl $0x428, %r9d            # imm = 0x428
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_unit_test
int gt_alphabet_unit_test(GtError *err)
{
  int had_err = 0;
  GtAlphabet *a, *b, *c;
  gt_error_check(err);

  a = gt_alphabet_new_dna();
  b = gt_alphabet_new_protein();
  c = gt_alphabet_clone(a);

  gt_ensure(gt_alphabet_equals(a, a));
  gt_ensure(gt_alphabet_equals(b, b));
  gt_ensure(gt_alphabet_equals(c, c));

  gt_ensure(!gt_alphabet_equals(a, b));
  gt_ensure(gt_alphabet_equals(a, c));

  gt_alphabet_delete(a);
  gt_alphabet_delete(b);
  gt_alphabet_delete(c);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r12
testq %rdi, %rdi
je 0x9c810
movq %r12, %rdi
callq 0xc103
testb %al, %al
jne 0x9c96e
callq 0x9b273
movq %rax, %rbx
callq 0x9b369
movq %rax, %r14
movq %rbx, %rdi
callq 0x9ac1c
movq %rax, %r15
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x9adbb
testb %al, %al
je 0x9c896
movq %r14, %rdi
movq %r14, %rsi
callq 0x9adbb
testb %al, %al
je 0x9c8bd
movq %r15, %rdi
movq %r15, %rsi
callq 0x9adbb
testb %al, %al
je 0x9c8e4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9adbb
testb %al, %al
je 0x9c936
leaq 0x2f8e3(%rip), %rsi     # 0xcc159
leaq 0x4dc09(%rip), %rdx     # 0xea486
leaq 0x4dba1(%rip), %rcx     # 0xea425
leaq 0x4d797(%rip), %r8      # 0xea022
movq %r12, %rdi
movl $0x45a, %r9d            # imm = 0x45A
jmp 0x9c909
leaq 0x2f8bc(%rip), %rsi     # 0xcc159
leaq 0x4db97(%rip), %rdx     # 0xea43b
leaq 0x4db7a(%rip), %rcx     # 0xea425
leaq 0x4d770(%rip), %r8      # 0xea022
movq %r12, %rdi
movl $0x456, %r9d            # imm = 0x456
jmp 0x9c909
leaq 0x2f895(%rip), %rsi     # 0xcc159
leaq 0x4db89(%rip), %rdx     # 0xea454
leaq 0x4db53(%rip), %rcx     # 0xea425
leaq 0x4d749(%rip), %r8      # 0xea022
movq %r12, %rdi
movl $0x457, %r9d            # imm = 0x457
jmp 0x9c909
leaq 0x2f86e(%rip), %rsi     # 0xcc159
leaq 0x4db7b(%rip), %rdx     # 0xea46d
leaq 0x4db2c(%rip), %rcx     # 0xea425
leaq 0x4d722(%rip), %r8      # 0xea022
movq %r12, %rdi
movl $0x458, %r9d            # imm = 0x458
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rbp
movq %rbx, %rdi
callq 0x9b1c1
movq %r14, %rdi
callq 0x9b1c1
movq %r15, %rdi
callq 0x9b1c1
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9adbb
xorl %ebp, %ebp
testb %al, %al
jne 0x9c913
leaq 0x2f80b(%rip), %rsi     # 0xcc159
leaq 0x4db4b(%rip), %rdx     # 0xea4a0
leaq 0x4dac9(%rip), %rcx     # 0xea425
leaq 0x4d6bf(%rip), %r8      # 0xea022
movq %r12, %rdi
movl $0x45b, %r9d            # imm = 0x45B
jmp 0x9c909
movq 0x91643(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2d6e7(%rip), %rsi     # 0xca066
leaq 0x2dcd3(%rip), %rdx     # 0xca659
leaq 0x4da98(%rip), %rcx     # 0xea425
leaq 0x4d68e(%rip), %r8      # 0xea022
movl $0x450, %r9d            # imm = 0x450
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_new
GtBioseq* gt_bioseq_new(const char *sequence_file, GtError *err)
{
  GtBioseq *bs;
  GtStr *seqfile;
  gt_error_check(err);
  seqfile = gt_str_new_cstr(sequence_file);
  bs = bioseq_new_with_recreate_and_type(seqfile, false, err);
  gt_str_delete(seqfile);
  return bs;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x9c9c3
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x9c9f1
movq %r14, %rdi
callq 0x13da9
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x9ca29
movq %rax, %rbx
movq %r14, %rdi
callq 0x152db
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x915c0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2d664(%rip), %rsi     # 0xca066
leaq 0x2dc50(%rip), %rdx     # 0xca659
leaq 0x4dd34(%rip), %rcx     # 0xea744
leaq 0x4dd3b(%rip), %r8      # 0xea752
movl $0xfd, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_new_recreate
GtBioseq* gt_bioseq_new_recreate(const char *sequence_file, GtError *err)
{
  GtBioseq *bs;
  GtStr *seqfile;
  gt_error_check(err);
  seqfile = gt_str_new_cstr(sequence_file);
  bs = bioseq_new_with_recreate_and_type(seqfile, true, err);
  gt_str_delete(seqfile);
  return bs;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x9d056
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x9d085
movq %r14, %rdi
callq 0x13da9
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x9ca29
movq %rax, %rbx
movq %r14, %rdi
callq 0x152db
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x90f2c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2cfd0(%rip), %rsi     # 0xca066
leaq 0x2d5bc(%rip), %rdx     # 0xca659
leaq 0x4d6c0(%rip), %rcx     # 0xea764
leaq 0x4d6a7(%rip), %r8      # 0xea752
movl $0x108, %r9d            # imm = 0x108
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_delete
void gt_bioseq_delete(GtBioseq *bs)
{
  GtUword i;
  if (!bs) return;
  gt_str_delete(bs->sequence_file);
  gt_md5_tab_delete(bs->md5_tab);
  if (bs->descriptions) {
    for (i = 0; i < gt_encseq_num_of_sequences(bs->encseq); i++) {
      gt_free(bs->descriptions[i]);
    }
    gt_free(bs->descriptions);
  }
  gt_encseq_delete(bs->encseq);
  if (bs->use_stdin)
    remove_bioseq_files(bs);
  gt_free(bs);
}

// Assembly:
testq %rdi, %rdi
je 0x9d20b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x152db
movq 0x28(%rbx), %rdi
callq 0xbf2f3
cmpq $0x0, 0x18(%rbx)
je 0x9d134
xorl %r15d, %r15d
leaq 0x4d657(%rip), %r14     # 0xea752
movq 0x20(%rbx), %rdi
callq 0xa1f8d
movq 0x18(%rbx), %rdi
cmpq %rax, %r15
jae 0x9d123
movq (%rdi,%r15,8), %rdi
movq %r14, %rsi
movl $0x11c, %edx            # imm = 0x11C
callq 0xd249
incq %r15
jmp 0x9d0fb
leaq 0x4d628(%rip), %rsi     # 0xea752
movl $0x11e, %edx            # imm = 0x11E
callq 0xd249
movq 0x20(%rbx), %rdi
callq 0xa4fe9
cmpb $0x1, (%rbx)
jne 0x9d1f2
leaq 0x4db30(%rip), %rdi     # 0xeac7d
callq 0x13da9
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x13ffe
movq %r14, %rdi
callq 0x143d2
leaq 0x4db15(%rip), %rdi     # 0xeac84
movq %rax, %rsi
callq 0x9e2a4
movq %r14, %rdi
callq 0x143d2
leaq 0x4db12(%rip), %rdi     # 0xeac98
movq %rax, %rsi
callq 0x9e2a4
movq %r14, %rdi
callq 0x143d2
leaq 0x4db3c(%rip), %rdi     # 0xeacd9
movq %rax, %rsi
callq 0x9e2a4
movq %r14, %rdi
callq 0x143d2
leaq 0x4dada(%rip), %rdi     # 0xeac8e
movq %rax, %rsi
callq 0x9e2a4
movq %r14, %rdi
callq 0x143d2
leaq 0x4dac8(%rip), %rdi     # 0xeac93
movq %rax, %rsi
callq 0x9e2a4
movq %r14, %rdi
callq 0x143d2
leaq 0x4daa7(%rip), %rdi     # 0xeac89
movq %rax, %rsi
callq 0x9e2a4
movq %r14, %rdi
callq 0x152db
leaq 0x4d559(%rip), %rsi     # 0xea752
movq %rbx, %rdi
movl $0x123, %edx            # imm = 0x123
popq %rbx
popq %r14
popq %r15
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_seq
GtSeq* gt_bioseq_get_seq(GtBioseq *bs, GtUword idx)
{
  GtSeq *seq;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  seq = gt_seq_new_own(gt_bioseq_get_sequence(bs, idx),
                       gt_bioseq_get_sequence_length(bs, idx),
                       gt_encseq_alphabet(bs->encseq));
  gt_seq_set_description(seq, gt_bioseq_get_description(bs, idx));
  return seq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9d2d3
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xa1f8d
cmpq %rbx, %rax
jbe 0x9d301
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9d339
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9d431
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xa6ec9
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xbf6e0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9d478
movq %r15, %rdi
movq %rax, %rsi
callq 0xbf6ec
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x90cde(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2cd82(%rip), %rsi     # 0xca066
leaq 0x4912c(%rip), %rdx     # 0xe6417
leaq 0x4d4a0(%rip), %rcx     # 0xea792
leaq 0x4d459(%rip), %r8      # 0xea752
movl $0x12f, %r9d            # imm = 0x12F
jmp 0x9d32d
movq 0x90cb0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2cd54(%rip), %rsi     # 0xca066
leaq 0x4d48b(%rip), %rdx     # 0xea7a4
leaq 0x4d472(%rip), %rcx     # 0xea792
leaq 0x4d42b(%rip), %r8      # 0xea752
movl $0x130, %r9d            # imm = 0x130
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_sequence
char* gt_bioseq_get_sequence(const GtBioseq *bs, GtUword idx)
{
  char *out;
  GtUword startpos;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  out = gt_calloc(gt_encseq_seqlength(bs->encseq, idx) + 1, sizeof (char));
  startpos = gt_encseq_seqstartpos(bs->encseq, idx);
  gt_encseq_extract_decoded(bs->encseq, out, startpos,
                            startpos
                              + gt_encseq_seqlength(bs->encseq, idx) - 1);
  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9d3cb
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xa1f8d
cmpq %rbx, %rax
jbe 0x9d3f9
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xa6b5f
leaq 0x1(%rax), %rdi
leaq 0x4d3d9(%rip), %rdx     # 0xea752
pushq $0x1
popq %rsi
movl $0x176, %ecx            # imm = 0x176
callq 0xce9a
movq %rax, %r15
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xa6788
movq %rax, %r12
movq 0x20(%r14), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa6b5f
leaq (%r12,%rax), %rcx
decq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xa3d89
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x90be6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2cc8a(%rip), %rsi     # 0xca066
leaq 0x49034(%rip), %rdx     # 0xe6417
leaq 0x4d4a3(%rip), %rcx     # 0xea88d
leaq 0x4d361(%rip), %r8      # 0xea752
movl $0x174, %r9d            # imm = 0x174
jmp 0x9d425
movq 0x90bb8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2cc5c(%rip), %rsi     # 0xca066
leaq 0x4d393(%rip), %rdx     # 0xea7a4
leaq 0x4d475(%rip), %rcx     # 0xea88d
leaq 0x4d333(%rip), %r8      # 0xea752
movl $0x175, %r9d            # imm = 0x175
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_description
const char* gt_bioseq_get_description(GtBioseq *bs, GtUword idx)
{
  const char *desc;
  char *mydesc;
  GtUword desclen;
  gt_assert(bs && bs->encseq);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  if (!(mydesc = bs->descriptions[idx])) {
    desc = gt_encseq_description(bs->encseq, &desclen, idx);
    mydesc = gt_calloc(desclen + 1, sizeof (char));
    strncpy(mydesc, desc, desclen);
    bs->descriptions[idx] = mydesc;
  }
  return (const char*) mydesc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x9d515
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x9d515
movq %rsi, %rbx
callq 0xa1f8d
cmpq %rbx, %rax
jbe 0x9d543
movq 0x18(%r14), %rax
movq (%rax,%rbx,8), %r15
testq %r15, %r15
jne 0x9d504
movq 0x20(%r14), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
movq %rbx, %rdx
callq 0xa7510
movq %rax, %r13
movq (%r12), %rdi
incq %rdi
leaq 0x4d275(%rip), %rdx     # 0xea752
pushq $0x1
popq %rsi
movl $0x150, %ecx            # imm = 0x150
callq 0xce9a
movq %rax, %r15
movq (%r12), %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0xb2d0
movq 0x18(%r14), %rax
movq %r15, (%rax,%rbx,8)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x90a9c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2cb40(%rip), %rsi     # 0xca066
leaq 0x4d2f3(%rip), %rdx     # 0xea820
leaq 0x4d2fd(%rip), %rcx     # 0xea831
leaq 0x4d217(%rip), %r8      # 0xea752
movl $0x14c, %r9d            # imm = 0x14C
jmp 0x9d56f
movq 0x90a6e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2cb12(%rip), %rsi     # 0xca066
leaq 0x4d249(%rip), %rdx     # 0xea7a4
leaq 0x4d2cf(%rip), %rcx     # 0xea831
leaq 0x4d1e9(%rip), %r8      # 0xea752
movl $0x14d, %r9d            # imm = 0x14D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_seq_range
GtSeq* gt_bioseq_get_seq_range(GtBioseq *bs, GtUword idx,
                               GtUword start, GtUword end)
{
  GtSeq *seq;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  gt_assert(end >= start);
  gt_assert(end - start + 1 > gt_encseq_seqlength(bs->encseq, idx));
  seq = gt_seq_new_own(gt_bioseq_get_sequence_range(bs, idx, start, end),
                       end - start + 1,
                       gt_encseq_alphabet(bs->encseq));
  gt_seq_set_description(seq, gt_bioseq_get_description(bs, idx));
  return seq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x9d620
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xa1f8d
cmpq %rbx, %rax
jbe 0x9d651
movq %r15, %r13
subq %r12, %r13
jb 0x9d67f
incq %r13
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xa6b5f
cmpq %rax, %r13
jbe 0x9d6ad
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x9d6e5
movq %rax, %r15
movq 0x20(%r14), %rdi
callq 0xa6ec9
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xbf6e0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9d478
movq %r15, %rdi
movq %rax, %rsi
callq 0xbf6ec
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x90991(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ca35(%rip), %rsi     # 0xca066
leaq 0x48ddf(%rip), %rdx     # 0xe6417
leaq 0x4d192(%rip), %rcx     # 0xea7d1
leaq 0x4d10c(%rip), %r8      # 0xea752
movl $0x13c, %r9d            # imm = 0x13C
jmp 0x9d6d9
movq 0x90960(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ca04(%rip), %rsi     # 0xca066
leaq 0x4d13b(%rip), %rdx     # 0xea7a4
leaq 0x4d161(%rip), %rcx     # 0xea7d1
leaq 0x4d0db(%rip), %r8      # 0xea752
movl $0x13d, %r9d            # imm = 0x13D
jmp 0x9d6d9
movq 0x90932(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c9d6(%rip), %rsi     # 0xca066
leaq 0x4d25a(%rip), %rdx     # 0xea8f1
leaq 0x4d133(%rip), %rcx     # 0xea7d1
leaq 0x4d0ad(%rip), %r8      # 0xea752
movl $0x13e, %r9d            # imm = 0x13E
jmp 0x9d6d9
movq 0x90904(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c9a8(%rip), %rsi     # 0xca066
leaq 0x4d124(%rip), %rdx     # 0xea7e9
leaq 0x4d105(%rip), %rcx     # 0xea7d1
leaq 0x4d07f(%rip), %r8      # 0xea752
movl $0x13f, %r9d            # imm = 0x13F
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_sequence_range
char* gt_bioseq_get_sequence_range(const GtBioseq *bs, GtUword idx,
                                   GtUword start, GtUword end)
{
  char *out;
  GtUword startpos;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq) && end >= start);
  out = gt_calloc((end - start + 1) + 1, sizeof (char));
  startpos = gt_encseq_seqstartpos(bs->encseq, idx);
  gt_encseq_extract_decoded(bs->encseq, out, startpos + start, startpos + end);
  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x9d761
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x20(%rdi), %rdi
callq 0xa1f8d
movq %rbx, %rdi
subq %r14, %rdi
jb 0x9d78f
cmpq %r12, %rax
jbe 0x9d78f
addq $0x2, %rdi
leaq 0x4d032(%rip), %rdx     # 0xea752
pushq $0x1
popq %rsi
movl $0x185, %ecx            # imm = 0x185
callq 0xce9a
movq %rax, %r13
movq 0x20(%r15), %rdi
movq %r12, %rsi
callq 0xa6788
movq 0x20(%r15), %rdi
addq %rax, %r14
addq %rax, %rbx
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xa3d89
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x90850(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c8f4(%rip), %rsi     # 0xca066
leaq 0x48c9e(%rip), %rdx     # 0xe6417
leaq 0x4d124(%rip), %rcx     # 0xea8a4
leaq 0x4cfcb(%rip), %r8      # 0xea752
movl $0x183, %r9d            # imm = 0x183
jmp 0x9d7bb
movq 0x90822(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c8c6(%rip), %rsi     # 0xca066
leaq 0x4d11a(%rip), %rdx     # 0xea8c1
leaq 0x4d0f6(%rip), %rcx     # 0xea8a4
leaq 0x4cf9d(%rip), %r8      # 0xea752
movl $0x184, %r9d            # imm = 0x184
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_char
char gt_bioseq_get_char(const GtBioseq *bs, GtUword index,
                        GtUword position)
{
  GtUword startpos;
  gt_assert(bs);
  gt_assert(index < gt_encseq_num_of_sequences(bs->encseq));
  startpos = gt_encseq_seqstartpos(bs->encseq, index);
  return gt_encseq_get_decoded_char(bs->encseq, startpos + position,
                                    GT_READMODE_FORWARD);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x9d80a
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xa1f8d
cmpq %r15, %rax
jbe 0x9d838
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xa6788
movq 0x20(%r14), %rdi
addq %rax, %rbx
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xa23a8
movq 0x907a7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c84b(%rip), %rsi     # 0xca066
leaq 0x48bf5(%rip), %rdx     # 0xe6417
leaq 0x4d022(%rip), %rcx     # 0xea84b
leaq 0x4cf22(%rip), %r8      # 0xea752
movl $0x15b, %r9d            # imm = 0x15B
jmp 0x9d864
movq 0x90779(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c81d(%rip), %rsi     # 0xca066
leaq 0x4d00e(%rip), %rdx     # 0xea85e
leaq 0x4cff4(%rip), %rcx     # 0xea84b
leaq 0x4cef4(%rip), %r8      # 0xea752
movl $0x15c, %r9d            # imm = 0x15C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_seq_has_wildcards
bool gt_bioseq_seq_has_wildcards(const GtBioseq* bioseq,
                                 GtUword idx) {
  bool has_wildcard = false;
  GtUword length = gt_encseq_seqlength(bioseq->encseq, idx),
          seqstart = gt_encseq_seqstartpos(bioseq->encseq, idx),
          i;
  for (i = 0; !has_wildcard && i < length; ++i) {
    has_wildcard = gt_encseq_position_is_wildcard(bioseq->encseq,
                                                  seqstart + i,
                                                  GT_READMODE_FORWARD);
  }
  return has_wildcard;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xa6b5f
movq %rax, %r14
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0xa6788
movq %rax, %r15
xorl %eax, %eax
xorl %r12d, %r12d
testb $0x1, %al
jne 0x9d8bb
cmpq %r14, %r12
jae 0x9d8bb
movq 0x20(%rbx), %rdi
leaq (%r15,%r12), %rsi
xorl %edx, %edx
callq 0xa27b5
incq %r12
jmp 0x9d89e
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_encoded_char
GtUchar gt_bioseq_get_encoded_char(const GtBioseq *bs, GtUword index,
                                   GtUword position)
{
  GtUword startpos;
  gt_assert(bs);
  gt_assert(index < gt_encseq_num_of_sequences(bs->encseq));
  startpos = gt_encseq_seqstartpos(bs->encseq, index);
  return gt_encseq_get_encoded_char(bs->encseq, startpos + position,
                                    GT_READMODE_FORWARD);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x9d90c
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xa1f8d
cmpq %r15, %rax
jbe 0x9d93a
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xa6788
movq 0x20(%r14), %rdi
addq %rax, %rbx
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xa1fd0
movq 0x906a5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c749(%rip), %rsi     # 0xca066
leaq 0x48af3(%rip), %rdx     # 0xe6417
leaq 0x4cfd3(%rip), %rcx     # 0xea8fe
leaq 0x4ce20(%rip), %r8      # 0xea752
movl $0x18f, %r9d            # imm = 0x18F
jmp 0x9d966
movq 0x90677(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c71b(%rip), %rsi     # 0xca066
leaq 0x4cf0c(%rip), %rdx     # 0xea85e
leaq 0x4cfa5(%rip), %rcx     # 0xea8fe
leaq 0x4cdf2(%rip), %r8      # 0xea752
movl $0x190, %r9d            # imm = 0x190
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_encoded_sequence
void gt_bioseq_get_encoded_sequence(const GtBioseq *bs, GtUchar *out,
                                    GtUword idx)
{
  GtUword startpos;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  startpos = gt_encseq_seqstartpos(bs->encseq, idx);
  gt_encseq_extract_encoded(bs->encseq, out, startpos,
                            startpos
                              + gt_encseq_seqlength(bs->encseq, idx) - 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9d9d4
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x20(%rdi), %rdi
callq 0xa1f8d
cmpq %r14, %rax
jbe 0x9da02
movq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0xa6788
movq %rax, %r12
movq 0x20(%r15), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa6b5f
leaq (%r12,%rax), %rcx
decq %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa3bb6
movq 0x905dd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c681(%rip), %rsi     # 0xca066
leaq 0x48a2b(%rip), %rdx     # 0xe6417
leaq 0x4cf26(%rip), %rcx     # 0xea919
leaq 0x4cd58(%rip), %r8      # 0xea752
movl $0x19a, %r9d            # imm = 0x19A
jmp 0x9da2e
movq 0x905af(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c653(%rip), %rsi     # 0xca066
leaq 0x4cd8a(%rip), %rdx     # 0xea7a4
leaq 0x4cef8(%rip), %rcx     # 0xea919
leaq 0x4cd2a(%rip), %r8      # 0xea752
movl $0x19b, %r9d            # imm = 0x19B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_encoded_sequence_range
void gt_bioseq_get_encoded_sequence_range(const GtBioseq *bs, GtUchar *out,
                                          GtUword idx,
                                          GtUword start,
                                          GtUword end)
{
  GtUword startpos;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq) && end >= start);
  startpos = gt_encseq_seqstartpos(bs->encseq, idx);
  gt_encseq_extract_encoded(bs->encseq, out, startpos + start, startpos + end);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x9da99
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rdi), %rdi
callq 0xa1f8d
cmpq %r14, %rbx
jb 0x9dac7
cmpq %r13, %rax
jbe 0x9dac7
movq 0x20(%r12), %rdi
movq %r13, %rsi
callq 0xa6788
movq 0x20(%r12), %rdi
addq %rax, %r14
addq %rax, %rbx
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xa3bb6
movq 0x90518(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c5bc(%rip), %rsi     # 0xca066
leaq 0x48966(%rip), %rdx     # 0xe6417
leaq 0x4ce80(%rip), %rcx     # 0xea938
leaq 0x4cc93(%rip), %r8      # 0xea752
movl $0x1a8, %r9d            # imm = 0x1A8
jmp 0x9daf3
movq 0x904ea(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c58e(%rip), %rsi     # 0xca066
leaq 0x4cde2(%rip), %rdx     # 0xea8c1
leaq 0x4ce52(%rip), %rcx     # 0xea938
leaq 0x4cc65(%rip), %r8      # 0xea752
movl $0x1a9, %r9d            # imm = 0x1A9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_md5_fingerprint
const char* gt_bioseq_get_md5_fingerprint(GtBioseq *bs, GtUword idx)
{
  gt_assert(bs && idx < gt_bioseq_number_of_sequences(bs));
  if (!bs->md5_tab) {
    bs->md5_tab = gt_encseq_get_md5_tab(bs->encseq, NULL);
  }
  gt_assert(gt_md5_tab_get(bs->md5_tab, idx));
  return gt_md5_tab_get(bs->md5_tab, idx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9db53
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9dbb9
cmpq %rbx, %rax
jbe 0x9db53
movq 0x28(%r14), %rdi
testq %rdi, %rdi
jne 0x9db33
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0xa7fb4
movq %rax, %rdi
movq %rax, 0x28(%r14)
movq %rbx, %rsi
callq 0xbf392
testq %rax, %rax
je 0x9db81
movq 0x28(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbf392
movq 0x9045e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c502(%rip), %rsi     # 0xca066
leaq 0x4cdf2(%rip), %rdx     # 0xea95d
leaq 0x4ce19(%rip), %rcx     # 0xea98b
leaq 0x4cbd9(%rip), %r8      # 0xea752
movl $0x1b0, %r9d            # imm = 0x1B0
jmp 0x9dbad
movq 0x90430(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c4d4(%rip), %rsi     # 0xca066
leaq 0x4ce10(%rip), %rdx     # 0xea9a9
leaq 0x4cdeb(%rip), %rcx     # 0xea98b
leaq 0x4cbab(%rip), %r8      # 0xea752
movl $0x1b4, %r9d            # imm = 0x1B4
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_md5_to_index
GtUword gt_bioseq_md5_to_index(GtBioseq *bs, const char *md5)
{
  gt_assert(bs && md5 && gt_encseq_has_md5_support(bs->encseq));
  if (!bs->md5_tab) {
    bs->md5_tab = gt_encseq_get_md5_tab(bs->encseq, NULL);
  }
  return gt_md5_tab_map(bs->md5_tab, md5);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9dcfc
movq %rsi, %rbx
testq %rsi, %rsi
je 0x9dcfc
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xa8041
testb %al, %al
je 0x9dcfc
movq 0x28(%r14), %rdi
testq %rdi, %rdi
jne 0x9dced
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0xa7fb4
movq %rax, %rdi
movq %rax, 0x28(%r14)
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbf3ee
movq 0x902b5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c359(%rip), %rsi     # 0xca066
leaq 0x4cd20(%rip), %rdx     # 0xeaa34
leaq 0x4cd4c(%rip), %rcx     # 0xeaa67
leaq 0x4ca30(%rip), %r8      # 0xea752
movl $0x1d4, %r9d            # imm = 0x1D4
xorl %eax, %eax
callq 0xb8c0
callq 0xb300