LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/bzip2-1.0.6/compress.c
// Function: bsPutUInt32
static
void bsPutUInt32 ( EState* s, UInt32 u )
{
   bsW ( s, 8, (u >> 24) & 0xffL );
   bsW ( s, 8, (u >> 16) & 0xffL );
   bsW ( s, 8, (u >>  8) & 0xffL );
   bsW ( s, 8,  u        & 0xffL );
}

// Assembly:
movl %esi, %edx
shrl $0x18, %esi
movl 0x284(%rdi), %r9d
cmpl $0x7, %r9d
jle 0xb57f1
movl 0x280(%rdi), %eax
movl 0x74(%rdi), %ecx
shrl $0x18, %eax
movq 0x50(%rdi), %r8
movslq %ecx, %rcx
movb %al, (%r8,%rcx)
movl 0x74(%rdi), %ecx
incl %ecx
movl %ecx, 0x74(%rdi)
movl 0x280(%rdi), %eax
shll $0x8, %eax
movl %eax, 0x280(%rdi)
movl 0x284(%rdi), %r9d
leal -0x8(%r9), %r8d
movl %r8d, 0x284(%rdi)
cmpl $0xf, %r9d
jg 0xb57b2
jmp 0xb57fb
movl 0x280(%rdi), %eax
addl $0x8, %r9d
movl %r9d, %ecx
negb %cl
shll %cl, %esi
orl %eax, %esi
movl %esi, 0x280(%rdi)
movl %r9d, 0x284(%rdi)
movl %edx, %eax
shrl $0x10, %eax
movzbl %al, %r8d
cmpl $0x8, %r9d
jl 0xb585d
movl 0x74(%rdi), %eax
shrl $0x18, %esi
movq 0x50(%rdi), %rcx
cltq
movb %sil, (%rcx,%rax)
movl 0x74(%rdi), %eax
incl %eax
movl %eax, 0x74(%rdi)
movl 0x280(%rdi), %esi
shll $0x8, %esi
movl %esi, 0x280(%rdi)
movl 0x284(%rdi), %ecx
leal -0x8(%rcx), %r9d
movl %r9d, 0x284(%rdi)
cmpl $0xf, %ecx
jg 0xb5823
leal 0x8(%r9), %r10d
movb $0x18, %al
movb $0x18, %cl
subb %r9b, %cl
shll %cl, %r8d
orl %esi, %r8d
movl %r8d, 0x280(%rdi)
movl %r10d, 0x284(%rdi)
movzbl %dh, %esi
testl %r9d, %r9d
js 0xb58c8
movl 0x74(%rdi), %ecx
shrl $0x18, %r8d
movq 0x50(%rdi), %r9
movslq %ecx, %rcx
movb %r8b, (%r9,%rcx)
movl 0x74(%rdi), %ecx
incl %ecx
movl %ecx, 0x74(%rdi)
movl 0x280(%rdi), %r8d
shll $0x8, %r8d
movl %r8d, 0x280(%rdi)
movl 0x284(%rdi), %r9d
leal -0x8(%r9), %r10d
movl %r10d, 0x284(%rdi)
cmpl $0xf, %r9d
jg 0xb5887
leal 0x8(%r10), %r9d
subb %r10b, %al
movl %eax, %ecx
shll %cl, %esi
orl %r8d, %esi
movl %esi, 0x280(%rdi)
movl %r9d, 0x284(%rdi)
testl %r10d, %r10d
js 0xb5925
movl 0x74(%rdi), %eax
shrl $0x18, %esi
movq 0x50(%rdi), %rcx
cltq
movb %sil, (%rcx,%rax)
movl 0x74(%rdi), %eax
incl %eax
movl %eax, 0x74(%rdi)
movl 0x280(%rdi), %esi
shll $0x8, %esi
movl %esi, 0x280(%rdi)
movl 0x284(%rdi), %ecx
leal -0x8(%rcx), %r9d
movl %r9d, 0x284(%rdi)
cmpl $0xf, %ecx
jg 0xb58eb
movzbl %dl, %eax
movb $0x18, %cl
subb %r9b, %cl
shll %cl, %eax
leal 0x8(%r9), %ecx
orl %esi, %eax
movl %eax, 0x280(%rdi)
movl %ecx, 0x284(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/zlib-1.3.0.1/adler32.c
// Function: adler32_combine_
local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2) {
    unsigned long sum1;
    unsigned long sum2;
    unsigned rem;

    /* for negative len, return invalid adler32 as a clue for debugging */
    if (len2 < 0)
        return 0xffffffffUL;

    /* the derivation of this formula is left as an exercise for the reader */
    MOD63(len2);                /* assumes len2 >= 0 */
    rem = (unsigned)len2;
    sum1 = adler1 & 0xffff;
    sum2 = rem * sum1;
    MOD(sum2);
    sum1 += (adler2 & 0xffff) + BASE - 1;
    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
    if (sum2 >= BASE) sum2 -= BASE;
    return sum1 | (sum2 << 16);
}

// Assembly:
testq %rdx, %rdx
js 0xb99ff
movq %rdx, %rcx
movabsq $0xf00e10d2fc5cd, %rdx  # imm = 0xF00E10D2FC5CD
movq %rcx, %rax
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0xf, %rax
imulq $0xfff1, %rax, %rax     # imm = 0xFFF1
subq %rax, %rcx
movl $0xffff, %eax           # imm = 0xFFFF
movq %rdi, %rdx
andq %rax, %rdx
movq %rcx, %r8
imulq %rdx, %r8
movl $0x80078071, %r9d       # imm = 0x80078071
imulq %r8, %r9
shrq $0x2f, %r9
imull $0xfff1, %r9d, %r9d     # imm = 0xFFF1
subl %r9d, %r8d
andq %rsi, %rax
leaq (%rdx,%rax), %r9
addl $0xfff0, %r9d           # imm = 0xFFF0
shrl $0x10, %edi
shrl $0x10, %esi
addq %rdi, %rsi
subq %rcx, %rsi
addq %r8, %rsi
movl $0xfff1, %ecx           # imm = 0xFFF1
leaq (%rsi,%rcx), %rdi
cmpl $0xfff1, %r9d           # imm = 0xFFF1
leaq -0x1(%rdx,%rax), %rax
movl $0xfff0, %edx           # imm = 0xFFF0
cmovaeq %rax, %rdx
movq $-0xfff1, %rax          # imm = 0xFFFF000F
leaq (%rdx,%rax), %r8
cmpq %rcx, %rdx
cmovbq %rdx, %r8
addq %rax, %rsi
cmpq $0x1ffe2, %rdi          # imm = 0x1FFE2
cmovbq %rdi, %rsi
movq %rsi, %rdx
shlq $0x10, %rdx
movabsq $-0xfff10000, %rax      # imm = 0xFFFFFFFF000F0000
addq %rdx, %rax
cmpq %rcx, %rsi
cmovbq %rdx, %rax
orq %r8, %rax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/zlib-1.3.0.1/crc32.c
// Function: crc32_combine64
uLong ZEXPORT crc32_combine64(uLong crc1, uLong crc2, z_off64_t len2) {
#ifdef DYNAMIC_CRC_TABLE
    once(&made, make_crc_table);
#endif /* DYNAMIC_CRC_TABLE */
    return multmodp(x2nmodp(len2, 3), crc1) ^ (crc2 & 0xffffffff);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0xb9e3b
xorl %ecx, %ecx
movl $0x80000000, %edx       # imm = 0x80000000
testl %eax, %edx
je 0xb9e11
xorl %r14d, %ecx
leal -0x1(%rdx), %esi
testl %eax, %esi
je 0xb9e2c
shrl %edx
movl %r14d, %esi
shrl %esi
movl %esi, %edi
xorl $0xedb88320, %edi       # imm = 0xEDB88320
testb $0x1, %r14b
cmovel %esi, %edi
movl %edi, %r14d
jmp 0xb9e03
movl %ecx, %ecx
movl %ebx, %eax
xorq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/zlib-1.3.0.1/crc32.c
// Function: x2nmodp
local z_crc_t x2nmodp(z_off64_t n, unsigned k) {
    z_crc_t p;

    p = (z_crc_t)1 << 31;           /* x^0 == 1 */
    while (n) {
        if (n & 1)
            p = multmodp(x2n_table[k & 31], p);
        n >>= 1;
        k++;
    }
    return p;
}

// Assembly:
testq %rdi, %rdi
je 0xb9eb0
movl $0x3, %ecx
movl $0x80000000, %esi       # imm = 0x80000000
leaq 0x46eef(%rip), %rdx     # 0x100d40
testb $0x1, %dil
jne 0xb9e6e
movl %esi, %eax
movq %rdi, %r8
sarq %r8
incl %ecx
movl %eax, %esi
cmpq $0x1, %rdi
movq %r8, %rdi
ja 0xb9e51
jmp 0xb9eaf
movl %ecx, %eax
andl $0x1f, %eax
movl (%rdx,%rax,4), %r8d
xorl %eax, %eax
movl $0x80000000, %r9d       # imm = 0x80000000
testl %r8d, %r9d
je 0xb9e8f
xorl %esi, %eax
leal -0x1(%r9), %r10d
testl %r8d, %r10d
je 0xb9e59
shrl %r9d
movl %esi, %r10d
shrl %r10d
movl %r10d, %r11d
xorl $0xedb88320, %r11d      # imm = 0xEDB88320
testb $0x1, %sil
cmovel %r10d, %r11d
movl %r11d, %esi
jmp 0xb9e7f
retq
movl $0x80000000, %eax       # imm = 0x80000000
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_clone
GtAlphabet* gt_alphabet_clone(const GtAlphabet *alphabet)
{
  unsigned int i;
  GtAlphabet *newalpha;
  gt_assert(alphabet);

  newalpha = gt_malloc(sizeof *newalpha);
  newalpha->domainsize = alphabet->domainsize;
  newalpha->mapsize = alphabet->mapsize;
  newalpha->mappedwildcards = alphabet->mappedwildcards;
  newalpha->wildcardshow = alphabet->wildcardshow;
  newalpha->bitspersymbol = alphabet->bitspersymbol;
  newalpha->alphadef = gt_str_ref(alphabet->alphadef);
  newalpha->reference_count = 0;
  newalpha->refmutex = gt_mutex_new();
  for (i=0; i<=(unsigned int) GT_MAXALPHABETCHARACTER; i++)
  {
    newalpha->symbolmap[i] = alphabet->symbolmap[i];
  }
  newalpha->characters = gt_malloc(alphabet->mapsize * sizeof (GtUchar));
  for (i=0; i<newalpha->mapsize; i++)
  {
    newalpha->characters[i] = alphabet->characters[i];
  }
  newalpha->mapdomain = gt_malloc(alphabet->domainsize * sizeof (GtUchar));
  for (i=0; i<newalpha->domainsize; i++)
  {
    newalpha->mapdomain[i] = alphabet->mapdomain[i];
  }
  return newalpha;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xba01e
movq %rdi, %rbx
leaq 0x46eaf(%rip), %rsi     # 0x100dd2
movl $0x138, %edi            # imm = 0x138
movl $0x16e, %edx            # imm = 0x16E
callq 0x35862
movq %rax, %r14
movq (%rbx), %rax
movq %rax, (%r14)
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r14)
movb 0x14(%rbx), %al
movb %al, 0x14(%r14)
movl 0xc(%rbx), %eax
movl %eax, 0xc(%r14)
movq 0x130(%rbx), %rdi
callq 0x3bcaf
movq %rax, 0x130(%r14)
movl $0x0, 0x10(%r14)
callq 0x3cff6
movq %rax, 0x128(%r14)
movl $0x15, %eax
movb (%rbx,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x115, %rax            # imm = 0x115
jne 0xb9f7c
movl 0x4(%rbx), %edi
leaq 0x46e3a(%rip), %rsi     # 0x100dd2
movl $0x17b, %edx            # imm = 0x17B
callq 0x35862
movq %rax, 0x120(%r14)
cmpl $0x0, 0x4(%r14)
je 0xb9fd2
xorl %eax, %eax
movq 0x120(%rbx), %rcx
movb (%rcx,%rax), %cl
movq 0x120(%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
movl 0x4(%r14), %ecx
cmpq %rcx, %rax
jb 0xb9fb2
movl (%rbx), %edi
leaq 0x46df7(%rip), %rsi     # 0x100dd2
movl $0x180, %edx            # imm = 0x180
callq 0x35862
movq %rax, 0x118(%r14)
cmpl $0x0, (%r14)
je 0xba013
xorl %eax, %eax
movq 0x118(%rbx), %rcx
movb (%rcx,%rax), %cl
movq 0x118(%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
movl (%r14), %ecx
cmpq %rcx, %rax
jb 0xb9ff4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x27a4c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_ref
GtAlphabet* gt_alphabet_ref(GtAlphabet *alphabet)
{
  gt_assert(alphabet);
  gt_mutex_lock(alphabet->refmutex);
  alphabet->reference_count++;
  gt_mutex_unlock(alphabet->refmutex);
  return alphabet;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xba04c
movq %rdi, %rbx
movq 0x128(%rdi), %rdi
callq 0x3d043
incl 0x10(%rbx)
movq 0x128(%rbx), %rdi
callq 0x3d05e
movq %rbx, %rax
popq %rbx
retq
callq 0x27a85
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_equals
bool gt_alphabet_equals(const GtAlphabet *a, const GtAlphabet *b)
{
  gt_assert(a && b);
  if (a->domainsize != b->domainsize) return false;
  if (a->mapsize != b->mapsize) return false;
  if (a->mappedwildcards != b->mappedwildcards) return false;
  if (a->wildcardshow != b->wildcardshow) return false;
  if (memcmp(a->symbolmap, b->symbolmap,
             GT_MAXALPHABETCHARACTER * sizeof (GtUchar)))
    return false;
  if (memcmp(a->characters, b->characters,
             a->mapsize * sizeof (GtUchar)))
    return false;
  if (memcmp(a->mapdomain, b->mapdomain,
             a->domainsize * sizeof (GtUchar)))
    return false;
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xba0f0
movq %rsi, %rbx
testq %rsi, %rsi
je 0xba0f0
movq %rdi, %r14
movl (%rdi), %r15d
cmpl (%rbx), %r15d
jne 0xba0c5
movl 0x4(%r14), %r12d
cmpl 0x4(%rbx), %r12d
jne 0xba0c5
movl 0x8(%r14), %eax
cmpl 0x8(%rbx), %eax
jne 0xba0c5
movb 0x14(%r14), %al
cmpb 0x14(%rbx), %al
jne 0xba0c5
leaq 0x15(%r14), %rdi
leaq 0x15(%rbx), %rsi
movl $0xff, %edx
callq 0xb6b0
testl %eax, %eax
jne 0xba0c5
movq 0x120(%r14), %rdi
movq 0x120(%rbx), %rsi
movq %r12, %rdx
callq 0xb6b0
testl %eax, %eax
je 0xba0d3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x118(%r14), %rdi
movq 0x118(%rbx), %rsi
movq %r15, %rdx
callq 0xb6b0
testl %eax, %eax
sete %al
jmp 0xba0c7
callq 0x27abe
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_add_mapping
void gt_alphabet_add_mapping(GtAlphabet *alphabet, const char *characters)
{
  size_t i, num_of_characters;
  gt_assert(alphabet && characters);
  num_of_characters = strlen(characters);
  gt_assert(num_of_characters);
  alphabet->mapdomain = gt_realloc(alphabet->mapdomain,
                                   (size_t) alphabet->domainsize
                                      + num_of_characters);
  memcpy(alphabet->mapdomain + alphabet->domainsize, characters,
         num_of_characters);
  alphabet->domainsize += num_of_characters;
  alphabet->symbolmap[(int) characters[0]] = (GtUchar) alphabet->mapsize;
  alphabet->characters = gt_realloc(alphabet->characters,
                                    (size_t) alphabet->domainsize);
  alphabet->characters[alphabet->mapsize] = (GtUchar) characters[0];
  for (i = 0; i < num_of_characters; i++)
    alphabet->symbolmap[(int) characters[i]] = (GtUchar) alphabet->mapsize;
  alphabet->mapsize++;
  alphabet->bitspersymbol
    = gt_determinebitspervalue((GtUword) alphabet->mapsize);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xba1c6
movq %rsi, %r14
testq %rsi, %rsi
je 0xba1c6
movq %rdi, %rbx
movq %r14, %rdi
callq 0xb260
testq %rax, %rax
je 0xba1cb
movq %rax, %r15
movq 0x118(%rbx), %rdi
movl (%rbx), %esi
addq %rax, %rsi
leaq 0x46c96(%rip), %r12     # 0x100dd2
movq %r12, %rdx
movl $0x1ac, %ecx            # imm = 0x1AC
callq 0x35a9d
movq %rax, 0x118(%rbx)
movl (%rbx), %edi
addq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb520
addl %r15d, (%rbx)
movb 0x4(%rbx), %al
movsbq (%r14), %rcx
movb %al, 0x15(%rbx,%rcx)
movq 0x120(%rbx), %rdi
movl (%rbx), %esi
movq %r12, %rdx
movl $0x1b2, %ecx            # imm = 0x1B2
callq 0x35a9d
movq %rax, 0x120(%rbx)
movb (%r14), %cl
movl 0x4(%rbx), %edx
movb %cl, (%rax,%rdx)
xorl %eax, %eax
movb 0x4(%rbx), %cl
movsbq (%r14,%rax), %rdx
movb %cl, 0x15(%rbx,%rdx)
incq %rax
cmpq %rax, %r15
jne 0xba196
movl 0x4(%rbx), %edi
incl %edi
movl %edi, 0x4(%rbx)
callq 0x7a629
movl %eax, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x27af7
callq 0x27b30
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_add_wildcard
void gt_alphabet_add_wildcard(GtAlphabet *alphabet, char wildcard)
{
  gt_assert(alphabet);
  alphabet->mapdomain = gt_realloc(alphabet->mapdomain,
                                   (size_t) alphabet->domainsize + 1);
  alphabet->mapdomain[alphabet->domainsize] = (GtUchar) wildcard;
  alphabet->domainsize++;
  alphabet->symbolmap[(int) wildcard] = (GtUchar) GT_WILDCARD;
  if (alphabet->wildcardshow == (GtUchar) GT_UNDEFCHAR) {
    alphabet->wildcardshow = (GtUchar) wildcard;
    alphabet->mapsize++;
  }
  alphabet->mappedwildcards++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xba229
movl %esi, %ebp
movq %rdi, %rbx
movq 0x118(%rdi), %rdi
movl (%rbx), %esi
incq %rsi
leaq 0x46be2(%rip), %rdx     # 0x100dd2
movl $0x1bf, %ecx            # imm = 0x1BF
callq 0x35a9d
movq %rax, 0x118(%rbx)
movl (%rbx), %ecx
movb %bpl, (%rax,%rcx)
incl (%rbx)
movsbq %bpl, %rax
movb $-0x2, 0x15(%rbx,%rax)
cmpb $-0x3, 0x14(%rbx)
jne 0xba21f
movb %bpl, 0x14(%rbx)
incl 0x4(%rbx)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x27b69
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_new_from_sequence
GtAlphabet* gt_alphabet_new_from_sequence(const GtStrArray *filenametab,
                                          GtError *err)
{
  GtAlphabet *alpha;
  int had_err = 0;
  gt_error_check(err);

  alpha = gt_alphabet_new_empty();
  if (assign_protein_or_dna_alphabet(alpha,filenametab,err) != 0) {
    had_err = -1;
    gt_assert(gt_error_is_set(err));
  }
  if (had_err)
  {
    gt_alphabet_delete(alpha);
    return NULL;
  }
  return alpha;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0xba2b4
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xba340
leaq 0x46b7d(%rip), %rsi     # 0x100dd2
movl $0x138, %edi            # imm = 0x138
movl $0x269, %edx            # imm = 0x269
callq 0x35862
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
callq 0x3cff6
movq %rax, 0x128(%r14)
leaq 0x14(%r14), %rdi
movl $0x101, %edx            # imm = 0x101
movl $0xfd, %esi
callq 0xb2f0
movq $0x0, 0x130(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%r14)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
jmp 0xba317
leaq 0x46b17(%rip), %rsi     # 0x100dd2
movl $0x138, %edi            # imm = 0x138
movl $0x269, %edx            # imm = 0x269
callq 0x35862
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
callq 0x3cff6
movq %rax, 0x128(%r14)
leaq 0x14(%r14), %rdi
movl $0x101, %edx            # imm = 0x101
movl $0xfd, %esi
callq 0xb2f0
movq $0x0, 0x130(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%r14)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xba3aa
testl %eax, %eax
je 0xba337
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
je 0xba345
movq %r14, %rdi
callq 0xba400
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x27ba2
callq 0x27bdb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_new_empty
GtAlphabet* gt_alphabet_new_empty(void)
{
  GtAlphabet *a = gt_malloc(sizeof *a);
  a->domainsize = 0;
  a->mapsize = 0;
  a->mappedwildcards = 0;
  a->bitspersymbol = 0;
  a->reference_count = 0;
  a->refmutex = gt_mutex_new();
  a->wildcardshow = (GtUchar) GT_UNDEFCHAR;
  memset(a->symbolmap, (int) GT_UNDEFCHAR, (size_t) GT_MAXALPHABETCHARACTER+1);
  a->mapdomain = NULL;
  a->characters = NULL;
  a->alphadef = NULL;
  return a;
}

// Assembly:
pushq %rbx
leaq 0x46a80(%rip), %rsi     # 0x100dd2
movl $0x138, %edi            # imm = 0x138
movl $0x269, %edx            # imm = 0x269
callq 0x35862
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
callq 0x3cff6
movq %rax, 0x128(%rbx)
leaq 0x14(%rbx), %rdi
movl $0x101, %edx            # imm = 0x101
movl $0xfd, %esi
callq 0xb2f0
movq $0x0, 0x130(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: assign_protein_or_dna_alphabet
static int assign_protein_or_dna_alphabet(GtAlphabet *alpha,
                                          const GtStrArray *filenametab,
                                          GtError *err)
{
  int retval;

  gt_error_check(err);
  retval = gt_files_guess_if_protein_sequences(filenametab,err);
  if (retval < 0)
  {
    return -1;
  }
  if (retval == 1)
  {
    assign_protein_alphabet(alpha);
  } else
  {
    assign_dna_alphabet(alpha);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0xba3c9
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xba3fb
movq %r15, %rdi
movq %r14, %rsi
callq 0x76752
testl %eax, %eax
js 0xba3e7
movq %rbx, %rdi
cmpl $0x1, %eax
jne 0xba3ee
callq 0xba629
jmp 0xba3f3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xba3f5
callq 0xba51a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x27c14
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_delete
void gt_alphabet_delete(GtAlphabet *alphabet)
{
  if (!alphabet) return;
  gt_mutex_lock(alphabet->refmutex);
  if (alphabet->reference_count) {
    alphabet->reference_count--;
    gt_mutex_unlock(alphabet->refmutex);
    return;
  }
  gt_mutex_unlock(alphabet->refmutex);
  gt_free(alphabet->mapdomain);
  gt_free(alphabet->characters);
  if (alphabet->alphadef != NULL)
    gt_str_delete(alphabet->alphadef);
  gt_mutex_delete(alphabet->refmutex);
  gt_free(alphabet);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xba437
movq %rdi, %rbx
movq 0x128(%rdi), %rdi
callq 0x3d043
movl 0x10(%rbx), %eax
testl %eax, %eax
je 0xba43f
decl %eax
movl %eax, 0x10(%rbx)
movq 0x128(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d05e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x128(%rbx), %rdi
callq 0x3d05e
movq 0x118(%rbx), %rdi
leaq 0x46979(%rip), %r14     # 0x100dd2
movq %r14, %rsi
movl $0x444, %edx            # imm = 0x444
callq 0x35c27
movq 0x120(%rbx), %rdi
movq %r14, %rsi
movl $0x445, %edx            # imm = 0x445
callq 0x35c27
movq 0x130(%rbx), %rdi
testq %rdi, %rdi
je 0xba48b
callq 0x3c87b
movq 0x128(%rbx), %rdi
callq 0x3d021
leaq 0x46934(%rip), %rsi     # 0x100dd2
movq %rbx, %rdi
movl $0x449, %edx            # imm = 0x449
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: assign_dna_alphabet
static void assign_dna_alphabet(GtAlphabet *alpha)
{
  alpha->wildcardshow = (GtUchar) DNAWILDCARDS[0];
  alpha->mappedwildcards = (unsigned int) strlen(DNAWILDCARDS);
  alpha->domainsize = (unsigned int) strlen(DNAALPHABETDOMAIN);
  alpha->bitspersymbol = 3U; /* as we have to represent 4 + 2 characters */
  alpha->mapdomain = gt_malloc(sizeof (GtUchar) * alpha->domainsize);
  memcpy(alpha->mapdomain,(GtUchar *) DNAALPHABETDOMAIN,
         (size_t) alpha->domainsize);
  alpha->mapsize = MAPSIZEDNA;
  alpha->characters = gt_calloc((size_t) UCHAR_MAX+1, sizeof (GtUchar));
  memcpy(alpha->characters,"acgt",(size_t) (MAPSIZEDNA-1));
  alpha->characters[GT_WILDCARD] = (GtUchar) DNAWILDCARDS[0];
  alpha->characters[MAPSIZEDNA-1] = (GtUchar) DNAWILDCARDS[0];
  assign_dna_symbolmap(alpha->symbolmap);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x6e, %bpl
movb %bpl, 0x14(%rdi)
movabsq $0x300000016, %rax      # imm = 0x300000016
movq %rax, 0x8(%rdi)
movl $0x20, (%rdi)
leaq 0x4688f(%rip), %r14     # 0x100dd2
movl $0x20, %edi
movq %r14, %rsi
movl $0x1dd, %edx            # imm = 0x1DD
callq 0x35862
movq %rax, 0x118(%rbx)
movl (%rbx), %edx
leaq 0x46cf7(%rip), %rsi     # 0x10125c
movq %rax, %rdi
callq 0xb520
movl $0x5, 0x4(%rbx)
movl $0x100, %edi            # imm = 0x100
movl $0x1, %esi
movq %r14, %rdx
movl $0x1e1, %ecx            # imm = 0x1E1
callq 0x359a6
movq %rax, 0x120(%rbx)
movl $0x74676361, (%rax)     # imm = 0x74676361
movq 0x120(%rbx), %rax
movb %bpl, 0xfe(%rax)
movq 0x120(%rbx), %rax
movb %bpl, 0x4(%rax)
addq $0x15, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xbade1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: assign_protein_alphabet
static void assign_protein_alphabet(GtAlphabet *alpha)
{
  alpha->wildcardshow = (GtUchar) PROTEINWILDCARDS[0];
  alpha->domainsize = (unsigned int) strlen(PROTEINALPHABETDOMAIN);
  alpha->mappedwildcards = (unsigned int) strlen(PROTEINWILDCARDS);
  alpha->bitspersymbol = 5U; /* as we have to represent 20 + 2 characters */
  alpha->mapdomain = gt_malloc(sizeof (GtUchar) * alpha->domainsize);
  memcpy(alpha->mapdomain,
         (GtUchar *) PROTEINALPHABETDOMAIN,(size_t) alpha->domainsize);
  alpha->mapsize = MAPSIZEPROTEIN;
  alpha->characters = gt_calloc((size_t) UCHAR_MAX+1, sizeof (GtUchar));
  memcpy(alpha->characters,PROTEINUPPERAMINOACIDS,(size_t) (MAPSIZEPROTEIN-1));
  alpha->characters[GT_WILDCARD] = (GtUchar) PROTEINWILDCARDS[0];
  alpha->characters[MAPSIZEPROTEIN-1] = (GtUchar) PROTEINWILDCARDS[0];
  assignproteinsymbolmap(alpha->symbolmap);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x58, %bpl
movb %bpl, 0x14(%rdi)
movl $0x1c, (%rdi)
movabsq $0x500000008, %rax      # imm = 0x500000008
movq %rax, 0x8(%rdi)
leaq 0x46780(%rip), %r14     # 0x100dd2
movl $0x1c, %edi
movq %r14, %rsi
movl $0x220, %edx            # imm = 0x220
callq 0x35862
movq %rax, 0x118(%rbx)
movl (%rbx), %edx
leaq 0x46c09(%rip), %rsi     # 0x10127d
movq %rax, %rdi
callq 0xb520
movl $0x15, 0x4(%rbx)
movl $0x100, %edi            # imm = 0x100
movl $0x1, %esi
movq %r14, %rdx
movl $0x224, %ecx            # imm = 0x224
callq 0x359a6
movq %rax, 0x120(%rbx)
movups 0x46bf2(%rip), %xmm0    # 0x10129a
movups %xmm0, (%rax)
movl $0x434d4850, 0x10(%rax) # imm = 0x434D4850
movq 0x120(%rbx), %rax
movb %bpl, 0xfe(%rax)
movq 0x120(%rbx), %rax
movb %bpl, 0x14(%rax)
addq $0x15, %rbx
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movl $0xfd, %esi
callq 0xb2f0
xorl %eax, %eax
leaq 0x46bb0(%rip), %rcx     # 0x10129a
movsbq (%rax,%rcx), %rdx
movl %edx, %edx
movb %al, (%rbx,%rdx)
incq %rax
cmpq $0x14, %rax
jne 0xba6ea
xorl %eax, %eax
leaq 0x46b8b(%rip), %rcx     # 0x101291
movsbq (%rax,%rcx), %rdx
movl %edx, %edx
movb $-0x2, (%rbx,%rdx)
incq %rax
cmpq $0x8, %rax
jne 0xba706
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xba78a
testq %rsi, %rsi
je 0xba78a
movq %rdi, %rbx
movl $0x1388, %r15d          # imm = 0x1388
cmpq %r15, %rsi
cmovbq %rsi, %r15
xorl %r12d, %r12d
leaq 0x4675b(%rip), %r14     # 0x100ea6
movsbl (%rbx,%r12), %esi
movl $0x13, %edx
movq %r14, %rdi
callq 0xb710
testq %rax, %rax
jne 0xba77a
incq %r12
cmpq %r12, %r15
jne 0xba74b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xba4b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xba5c1
callq 0x27c4d
// File: /workspace/github_c_makefile_star2_O3/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 0xba9f1
movq %rsi, %rbx
testq %rsi, %rsi
je 0xba9f1
movq %rdi, %r14
callq 0x3b728
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0xba7f3
movq %r15, %rdi
callq 0x3bb5d
movq %rax, %r14
movq %r15, %rdi
callq 0x3bb86
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x3d320
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3c87b
callq 0x27e4e
// File: /workspace/github_c_makefile_star2_O3/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 0xbaa5e
movq %rcx, %rbx
movq %rdx, %r14
testq %rcx, %rcx
sete %al
testq %rdx, %rdx
setne %cl
orb %al, %cl
je 0xbaa5e
movq %rsi, %r15
testq %rdi, %rdi
je 0xbaa2b
movq 0x120(%rdi), %r12
jmp 0xbaa32
leaq 0x465c7(%rip), %r12     # 0x100ff9
testq %rbx, %rbx
je 0xbaa54
xorl %r13d, %r13d
movzbl (%r14,%r13), %eax
movzbl (%r12,%rax), %edi
movq %r15, %rsi
callq 0x3d29e
incq %r13
cmpq %r13, %rbx
jne 0xbaa3a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x27e87
// File: /workspace/github_c_makefile_star2_O3/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 %rax
testq %rcx, %rcx
je 0xbaac9
testq %rdi, %rdi
je 0xbaacf
leaq 0x14(%rdi), %rax
xorl %r8d, %r8d
movzbl (%rdx,%r8), %r9d
movq %rax, %r10
cmpl $0xfe, %r9d
je 0xbaaba
cmpl $0xff, %r9d
je 0xbaacf
movl 0x4(%rdi), %r10d
decl %r10d
cmpl %r9d, %r10d
jbe 0xbaad4
movl %r9d, %r10d
addq 0x120(%rdi), %r10
movb (%r10), %r9b
movb %r9b, (%rsi,%r8)
incq %r8
cmpq %r8, %rcx
jne 0xbaa8a
movb $0x0, (%rsi,%rcx)
popq %rax
retq
callq 0x27ef9
callq 0x27ec0
// File: /workspace/github_c_makefile_star2_O3/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 0xbab49
movq %rsi, %r14
testq %rsi, %rsi
je 0xbab49
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x1(%rdx), %rdi
leaq 0x462d2(%rip), %r12     # 0x100dd2
movq %r12, %rsi
movl $0x326, %edx            # imm = 0x326
callq 0x35862
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xbaa78
movq %r13, %rdi
callq 0x3b785
movq %rax, %rbx
movq %r13, %rdi
movq %r12, %rsi
movl $0x329, %edx            # imm = 0x329
callq 0x35c27
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x27f32
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
movq %rdi, %rsi
leaq 0x240(%rsp), %rdi
callq 0xbacb2
movl %eax, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xba629
leaq 0x140(%rsp), %rdi
movq %r14, %rsi
callq 0xbacb2
cmpl %eax, %ebx
jne 0xbac6e
movl %ebx, %ebx
leaq 0xf8(%rip), %r14        # 0xbad1b
leaq 0x240(%rsp), %r15
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0xbc80
leaq 0x140(%rsp), %r12
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0xbc80
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xb6b0
testl %eax, %eax
sete %bl
jmp 0xbac70
xorl %ebx, %ebx
movq 0x120(%rsp), %rdi
leaq 0x46153(%rip), %r14     # 0x100dd2
movq %r14, %rsi
movl $0x375, %edx            # imm = 0x375
callq 0x35c27
movq 0x128(%rsp), %rdi
movq %r14, %rsi
movl $0x376, %edx            # imm = 0x376
callq 0x35c27
movl %ebx, %eax
addq $0x348, %rsp            # imm = 0x348
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movl (%rsi), %ebp
movl 0x8(%rsi), %r12d
xorl %eax, %eax
cmpl %r12d, %ebp
je 0xbad12
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
callq 0xb6e0
movq %rax, %rcx
xorl %eax, %eax
movq (%rcx), %rsi
movq 0x118(%rbx), %rdx
movzbl (%rdx,%r15), %edx
movzwl (%rsi,%rdx,2), %esi
notl %esi
testl $0x108, %esi            # imm = 0x108
jne 0xbad05
movl %eax, %esi
incl %eax
movb %dl, (%r14,%rsi)
movl (%rbx), %ebp
movl 0x8(%rbx), %r12d
incq %r15
movl %ebp, %edx
subl %r12d, %edx
cmpq %rdx, %r15
jb 0xbacda
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
callq 0xbabd9
testb %al, %al
jne 0xbadc8
cmpl $0x5, 0x4(%rbx)
jne 0xbadc8
movq %rsp, %rdi
callq 0xbade1
callq 0xb6e0
movq (%rax), %r15
movb $0x61, %al
xorl %r12d, %r12d
leaq 0x4628d(%rip), %r13     # 0x100ff9
xorl %ebp, %ebp
movzbl %al, %r14d
movzwl (%r15,%r14,2), %eax
btl $0x8, %eax
jb 0xbad8d
btl $0x9, %eax
jae 0xbaddc
movl %r14d, %edi
callq 0xbbf0
jmp 0xbad95
movl %r14d, %edi
callq 0xb900
movb 0x15(%rbx,%r14), %cl
cmpb (%rsp,%r14), %cl
je 0xbadac
movzbl %al, %eax
movb 0x15(%rbx,%rax), %cl
cmpb (%rsp,%rax), %cl
jne 0xbadc0
movb 0x1(%r12,%r13), %al
incq %r12
testb %al, %al
sete %bpl
cmpq $0x4, %r12
jne 0xbad6e
movb $0x1, %al
testb $0x1, %bpl
jne 0xbadca
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x28088
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movl $0x100, %edx            # imm = 0x100
movl $0xfd, %esi
callq 0xb2f0
xorl %eax, %eax
movb %al, 0x61(%rbx)
movb %al, 0x41(%rbx)
movb $0x1, %cl
movb %cl, 0x63(%rbx)
movb %cl, 0x43(%rbx)
movb $0x2, %cl
movb %cl, 0x67(%rbx)
movb %cl, 0x47(%rbx)
movw $0x303, %cx             # imm = 0x303
movw %cx, 0x74(%rbx)
movw %cx, 0x54(%rbx)
leaq 0x46447(%rip), %rcx     # 0x101266
movsbq (%rax,%rcx), %rdx
movl %edx, %edx
movb $-0x2, (%rbx,%rdx)
incq %rax
cmpq $0x16, %rax
jne 0xbae1f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
testq %rdi, %rdi
je 0xbae9c
movzbl %sil, %eax
movl 0x4(%rdi), %ecx
movzbl %cl, %edx
decl %edx
cmpl %eax, %edx
je 0xbae94
cmpb $-0x2, %sil
je 0xbae94
cmpl $0xff, %eax
je 0xbaea1
decl %ecx
cmpl %eax, %ecx
jbe 0xbaea6
addq 0x120(%rdi), %rax
movq %rax, %rdi
jmp 0xbae98
addq $0x14, %rdi
movb (%rdi), %al
popq %rcx
retq
callq 0x281a5
callq 0x28133
callq 0x2816c
// File: /workspace/github_c_makefile_star2_O3/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 0xbaee5
testq %rsi, %rsi
je 0xbaee5
testq %rdx, %rdx
je 0xbaee5
testq %rcx, %rcx
je 0xbaede
xorl %eax, %eax
movsbq (%rdx,%rax), %r8
movb 0x15(%rdi,%r8), %r8b
cmpb $-0x3, %r8b
je 0xbaee0
movb %r8b, (%rsi,%rax)
incq %rax
cmpq %rax, %rcx
jne 0xbaec2
popq %rax
retq
callq 0x28217
callq 0x281de
// File: /workspace/github_c_makefile_star2_O3/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 0xbaf36
movq %rsi, %rbx
callq 0x3b785
movq %rax, %r14
leaq 0x4621b(%rip), %rsi     # 0x101120
movq %rax, %rdi
callq 0x3b7af
movq %r14, %rdi
callq 0x3bb5d
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbaf3b
movq %rax, %rbx
movq %r14, %rdi
callq 0x3c87b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x28250
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_new_from_file_no_suffix
GtAlphabet* gt_alphabet_new_from_file_no_suffix(const char *filename,
                                                GtError *err)
{
  GtStr *transpath = NULL;
  bool haserr = false;
  GtAlphabet *alpha;
  gt_assert(filename);
  gt_error_check(err);

  alpha = gt_alphabet_new_empty();
  if (!gt_file_exists(filename))
  {
    GtStr *prog;
    const char *progname = gt_error_get_progname(err);

    gt_assert(progname != NULL);
    prog = gt_str_new();
    gt_str_append_cstr_nt(prog, progname,
                          gt_cstr_length_up_to_char(progname, ' '));
    transpath = gt_get_gtdata_path(gt_str_get(prog), err);
    gt_str_delete(prog);
    gt_str_append_cstr(transpath, "/trans/");
    gt_str_append_cstr(transpath, filename);
  }

  if (read_symbolmap(alpha,
                     transpath == NULL ? filename : gt_str_get(transpath),
                     err) != 0)
  {
    haserr = true;
  }
  gt_str_delete(transpath);

  if (alpha == NULL)
  {
    haserr = true;
  }

  if (haserr)
  {
    gt_alphabet_delete((GtAlphabet*) alpha);
    return NULL;
  }
  return alpha;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xbb0b7
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0xbaf68
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xbb0c1
leaq 0x45e63(%rip), %rsi     # 0x100dd2
movl $0x138, %edi            # imm = 0x138
movl $0x269, %edx            # imm = 0x269
callq 0x35862
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
callq 0x3cff6
movq %rax, 0x128(%r14)
leaq 0x14(%r14), %rdi
movl $0x101, %edx            # imm = 0x101
movl $0xfd, %esi
callq 0xb2f0
movq $0x0, 0x130(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%r14)
movq %r15, %rdi
callq 0x76120
testb %al, %al
jne 0xbb054
movq %rbx, %rdi
callq 0x35072
testq %rax, %rax
je 0xbb0cb
movq %rax, %r12
callq 0x3b728
movq %rax, %r13
movq %r12, %rdi
movl $0x20, %esi
callq 0x729bc
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3b8d7
movq %r13, %rdi
callq 0x3bb5d
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd617c
movq %rax, %r12
movq %r13, %rdi
callq 0x3c87b
leaq 0x4615b(%rip), %rsi     # 0x10118a
movq %r12, %rdi
callq 0x3b7af
movq %r12, %rdi
movq %r15, %rsi
callq 0x3b7af
testq %r12, %r12
je 0xbb054
movq %r12, %rdi
callq 0x3bb5d
movq %rax, %r15
jmp 0xbb057
xorl %r12d, %r12d
testq %rbx, %rbx
je 0xbb068
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xbb0c6
movq %r15, %rdi
callq 0x3c90b
testq %rax, %rax
je 0xbb0bc
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0xbb1fe
movl %eax, %ebx
movq %r13, %rdi
callq 0x3cc00
movq %r12, %rdi
callq 0x3c87b
testl %ebx, %ebx
je 0xbb0aa
movq %r14, %rdi
callq 0xba400
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2836d
callq 0x28334
callq 0x28289
callq 0x282fb
callq 0x282c2
// File: /workspace/github_c_makefile_star2_O3/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 0xbb1ef
movq %rsi, %r14
testq %rsi, %rsi
je 0xbb1ef
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0xbb10b
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xbb1f4
movq %rbx, (%rsp)
leaq 0x45cbc(%rip), %rsi     # 0x100dd2
movl $0x138, %edi            # imm = 0x138
movl $0x269, %edx            # imm = 0x269
callq 0x35862
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
callq 0x3cff6
movq %rax, 0x128(%r12)
leaq 0x14(%r12), %rdi
movl $0x101, %edx            # imm = 0x101
movl $0xfd, %esi
callq 0xb2f0
movq $0x0, 0x130(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%r12)
callq 0x3c8cc
movq %rax, %r13
leaq -0x1(%r14), %rbp
xorl %ebx, %ebx
xorl %eax, %eax
cmpq %rbp, %rbx
je 0xbb18f
cmpb $0xa, (%r15,%rbx)
je 0xbb18f
incq %rbx
jmp 0xbb1a7
leaq (%r15,%rax), %rsi
movq %rbx, %rdx
subq %rax, %rdx
movq %r13, %rdi
callq 0x3c9df
incq %rbx
movq %rbx, %rax
cmpq %r14, %rbx
jne 0xbb17e
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq (%rsp), %rbx
movq %rbx, %rcx
callq 0xbb1fe
movl %eax, %ebp
movq %r13, %rdi
callq 0x3cc00
testl %ebp, %ebp
je 0xbb1dd
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
je 0xbb1f9
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x283a6
callq 0x283df
callq 0x28418
// File: /workspace/github_c_makefile_star2_O3/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 0xbb521
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xbb5a6
leaq 0x45bf8(%rip), %rsi     # 0x101120
leaq 0x45c77(%rip), %rdx     # 0x1011a6
leaq 0x4589c(%rip), %rcx     # 0x100dd2
movq %r15, %rdi
movl $0x429, %r8d            # imm = 0x429
movq %rbx, %r9
callq 0x7442f
movq %rax, %rbx
testq %rax, %rax
je 0xbb598
callq 0x3b728
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0xba7f3
movq %r15, %rdi
callq 0x3bb5d
movq %rax, %r14
movq %r15, %rdi
callq 0x3bb86
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x3d320
movq %rbx, %rdi
callq 0x74532
movq %r15, %rdi
callq 0x3c87b
xorl %eax, %eax
cmpq $0x1, %rbx
sbbl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x284c3
// File: /workspace/github_c_makefile_star2_O3/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 0xbb5cb
movq %r12, %rdi
callq 0x34fea
testb %al, %al
jne 0xbb72b
callq 0xba4b2
movq %rax, %rbx
callq 0xba5c1
movq %rax, %r14
movq %rbx, %rdi
callq 0xb9f0c
movq %rax, %r15
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xba051
testb %al, %al
je 0xbb651
movq %r14, %rdi
movq %r14, %rsi
callq 0xba051
testb %al, %al
je 0xbb678
movq %r15, %rdi
movq %r15, %rsi
callq 0xba051
testb %al, %al
je 0xbb69f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xba051
testb %al, %al
je 0xbb6f3
leaq 0x27b28(%rip), %rsi     # 0xe3159
leaq 0x45bd2(%rip), %rdx     # 0x10120a
leaq 0x45b6a(%rip), %rcx     # 0x1011a9
leaq 0x4578c(%rip), %r8      # 0x100dd2
movq %r12, %rdi
movl $0x45a, %r9d            # imm = 0x45A
jmp 0xbb6c4
leaq 0x27b01(%rip), %rsi     # 0xe3159
leaq 0x45b60(%rip), %rdx     # 0x1011bf
leaq 0x45b43(%rip), %rcx     # 0x1011a9
leaq 0x45765(%rip), %r8      # 0x100dd2
movq %r12, %rdi
movl $0x456, %r9d            # imm = 0x456
jmp 0xbb6c4
leaq 0x27ada(%rip), %rsi     # 0xe3159
leaq 0x45b52(%rip), %rdx     # 0x1011d8
leaq 0x45b1c(%rip), %rcx     # 0x1011a9
leaq 0x4573e(%rip), %r8      # 0x100dd2
movq %r12, %rdi
movl $0x457, %r9d            # imm = 0x457
jmp 0xbb6c4
leaq 0x27ab3(%rip), %rsi     # 0xe3159
leaq 0x45b44(%rip), %rdx     # 0x1011f1
leaq 0x45af5(%rip), %rcx     # 0x1011a9
leaq 0x45717(%rip), %r8      # 0x100dd2
movq %r12, %rdi
movl $0x458, %r9d            # imm = 0x458
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0xba400
movq %r14, %rdi
callq 0xba400
movq %r15, %rdi
callq 0xba400
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0xba051
xorl %ebp, %ebp
testb %al, %al
jne 0xbb6d0
leaq 0x27a4e(%rip), %rsi     # 0xe3159
leaq 0x45b12(%rip), %rdx     # 0x101224
leaq 0x45a90(%rip), %rcx     # 0x1011a9
leaq 0x456b2(%rip), %r8      # 0x100dd2
movq %r12, %rdi
movl $0x45b, %r9d            # imm = 0x45B
jmp 0xbb6c4
callq 0x284fc
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, %rbx
testq %rsi, %rsi
je 0xbb760
movq %rsi, %r14
movq %rsi, %rdi
callq 0x34fea
testb %al, %al
jne 0xbb78d
movq %rbx, %rdi
callq 0x3b785
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
jmp 0xbb772
movq %rbx, %rdi
callq 0x3b785
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xbb792
movq %rax, %r14
movq %rbx, %rdi
callq 0x3c87b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x28535