LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/tre-ast.c
// Function: tre_ast_new_catenation
tre_ast_node_t *
tre_ast_new_catenation(tre_mem_t mem, tre_ast_node_t *left,
		       tre_ast_node_t *right)
{
  tre_ast_node_t *node;

  node = tre_ast_new_node(mem, CATENATION, sizeof(tre_catenation_t));
  if (node == NULL)
    return NULL;
  ((tre_catenation_t *)node->obj)->left = left;
  ((tre_catenation_t *)node->obj)->right = right;
  node->num_submatches = left->num_submatches + right->num_submatches;

  return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl $0x10, %edx
movl $0x1, %esi
callq 0xb27c0
testq %rax, %rax
je 0xb2941
movq 0x8(%rax), %rcx
movq %rbx, (%rcx)
movq %r14, 0x8(%rcx)
movl 0x18(%r14), %ecx
addl 0x18(%rbx), %ecx
movl %ecx, 0x18(%rax)
jmp 0xb2943
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl %esi, %r8d
shrl $0x18, %r8d
movl 0x284(%rdi), %r9d
cmpl $0x8, %r9d
jl 0xb5c87
movb 0x283(%rdi), %al
movq 0x50(%rdi), %rcx
movslq 0x74(%rdi), %rsi
movb %al, (%rcx,%rsi)
incl 0x74(%rdi)
shll $0x8, 0x280(%rdi)
movl 0x284(%rdi), %eax
leal -0x8(%rax), %r9d
movl %r9d, 0x284(%rdi)
cmpl $0xf, %eax
jg 0xb5c56
leal 0x8(%r9), %esi
movb $0x18, %al
movb $0x18, %cl
subb %r9b, %cl
shll %cl, %r8d
orl %r8d, 0x280(%rdi)
movl %esi, 0x284(%rdi)
movl %edx, %ecx
shrl $0x10, %ecx
movzbl %cl, %r8d
cmpl $0x7ffffff7, %r9d       # imm = 0x7FFFFFF7
ja 0xb5ce4
movb 0x283(%rdi), %cl
movq 0x50(%rdi), %rsi
movslq 0x74(%rdi), %r9
movb %cl, (%rsi,%r9)
incl 0x74(%rdi)
shll $0x8, 0x280(%rdi)
movl 0x284(%rdi), %ecx
leal -0x8(%rcx), %esi
movl %esi, 0x284(%rdi)
cmpl $0xf, %ecx
jg 0xb5cb4
subb %sil, %al
movl %eax, %ecx
shll %cl, %r8d
orl %r8d, 0x280(%rdi)
leal 0x8(%rsi), %r8d
movl %r8d, 0x284(%rdi)
movzbl %dh, %eax
cmpl $0x7ffffff7, %esi       # imm = 0x7FFFFFF7
ja 0xb5d3b
movb 0x283(%rdi), %cl
movq 0x50(%rdi), %rsi
movslq 0x74(%rdi), %r8
movb %cl, (%rsi,%r8)
incl 0x74(%rdi)
shll $0x8, 0x280(%rdi)
movl 0x284(%rdi), %ecx
leal -0x8(%rcx), %r8d
movl %r8d, 0x284(%rdi)
cmpl $0xf, %ecx
jg 0xb5d09
movb $0x18, %cl
subb %r8b, %cl
shll %cl, %eax
orl %eax, 0x280(%rdi)
leal 0x8(%r8), %eax
movb $0x18, %cl
movl %eax, 0x284(%rdi)
cmpl $0x7ffffff7, %r8d       # imm = 0x7FFFFFF7
ja 0xb5d8d
movb 0x283(%rdi), %al
movq 0x50(%rdi), %rsi
movslq 0x74(%rdi), %r8
movb %al, (%rsi,%r8)
incl 0x74(%rdi)
shll $0x8, 0x280(%rdi)
movl 0x284(%rdi), %esi
leal -0x8(%rsi), %eax
movl %eax, 0x284(%rdi)
cmpl $0xf, %esi
jg 0xb5d5d
movzbl %dl, %edx
leal 0x8(%rax), %esi
subb %al, %cl
shll %cl, %edx
orl %edx, 0x280(%rdi)
movl %esi, 0x284(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb8986
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, %r9d           # imm = 0xFFFF
movq %rdi, %r10
andq %r9, %r10
movq %rcx, %r8
imulq %r10, %r8
movabsq $0x1000f00e10d30, %rdx  # imm = 0x1000F00E10D30
movq %r8, %rax
mulq %rdx
imulq $0xfff1, %rdx, %rax     # imm = 0xFFF1
subq %rax, %r8
andq %rsi, %r9
leaq (%r10,%r9), %rax
addl $0xfff0, %eax           # 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), %rdx
cmpl $0xfff1, %eax           # imm = 0xFFF1
leaq -0x1(%r10,%r9), %rax
movl $0xfff0, %edi           # imm = 0xFFF0
cmovaeq %rax, %rdi
movq $-0xfff1, %rax          # imm = 0xFFFF000F
leaq (%rdi,%rax), %r8
cmpq %rcx, %rdi
cmovbq %rdi, %r8
addq %rax, %rsi
cmpq $0x1ffe2, %rdx          # imm = 0x1FFE2
cmovbq %rdx, %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_O1/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 0xb8dc3
xorl %ecx, %ecx
movl $0x80000000, %edx       # imm = 0x80000000
testl %eax, %edx
je 0xb8d99
xorl %r14d, %ecx
leal -0x1(%rdx), %esi
testl %eax, %esi
je 0xb8db4
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 0xb8d8b
movl %ecx, %ecx
movl %ebx, %eax
xorq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb8e38
movl $0x3, %ecx
movl $0x80000000, %esi       # imm = 0x80000000
leaq 0x47fc7(%rip), %rdx     # 0x100da0
testb $0x1, %dil
jne 0xb8df6
movl %esi, %eax
movq %rdi, %r8
sarq %r8
incl %ecx
movl %eax, %esi
cmpq $0x1, %rdi
movq %r8, %rdi
ja 0xb8dd9
jmp 0xb8e37
movl %ecx, %eax
andl $0x1f, %eax
movl (%rdx,%rax,4), %r8d
xorl %eax, %eax
movl $0x80000000, %r9d       # imm = 0x80000000
testl %r8d, %r9d
je 0xb8e17
xorl %esi, %eax
leal -0x1(%r9), %r10d
testl %r8d, %r10d
je 0xb8de1
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 0xb8e07
retq
movl $0x80000000, %eax       # imm = 0x80000000
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb8fa6
movq %rdi, %rbx
leaq 0x47f87(%rip), %rsi     # 0x100e32
movl $0x138, %edi            # imm = 0x138
movl $0x16e, %edx            # imm = 0x16E
callq 0x35ee2
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 0x3c561
movq %rax, 0x130(%r14)
movl $0x0, 0x10(%r14)
callq 0x3d96a
movq %rax, 0x128(%r14)
movl $0x15, %eax
movb (%rbx,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x115, %rax            # imm = 0x115
jne 0xb8f04
movl 0x4(%rbx), %edi
leaq 0x47f12(%rip), %rsi     # 0x100e32
movl $0x17b, %edx            # imm = 0x17B
callq 0x35ee2
movq %rax, 0x120(%r14)
cmpl $0x0, 0x4(%r14)
je 0xb8f5a
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 0xb8f3a
movl (%rbx), %edi
leaq 0x47ecf(%rip), %rsi     # 0x100e32
movl $0x180, %edx            # imm = 0x180
callq 0x35ee2
movq %rax, 0x118(%r14)
cmpl $0x0, (%r14)
je 0xb8f9b
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 0xb8f7c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x27b9c
// File: /workspace/github_c_makefile_star2_O1/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 0xb8fd4
movq %rdi, %rbx
movq 0x128(%rdi), %rdi
callq 0x3d9b7
incl 0x10(%rbx)
movq 0x128(%rbx), %rdi
callq 0x3d9d2
movq %rbx, %rax
popq %rbx
retq
callq 0x27bd5
// File: /workspace/github_c_makefile_star2_O1/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 0xb9078
movq %rsi, %rbx
testq %rsi, %rsi
je 0xb9078
movq %rdi, %r14
movl (%rdi), %r15d
cmpl (%rbx), %r15d
jne 0xb904d
movl 0x4(%r14), %r12d
cmpl 0x4(%rbx), %r12d
jne 0xb904d
movl 0x8(%r14), %eax
cmpl 0x8(%rbx), %eax
jne 0xb904d
movb 0x14(%r14), %al
cmpb 0x14(%rbx), %al
jne 0xb904d
leaq 0x15(%r14), %rdi
leaq 0x15(%rbx), %rsi
movl $0xff, %edx
callq 0xb6b0
testl %eax, %eax
jne 0xb904d
movq 0x120(%r14), %rdi
movq 0x120(%rbx), %rsi
movq %r12, %rdx
callq 0xb6b0
testl %eax, %eax
je 0xb905b
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 0xb904f
callq 0x27c0e
// File: /workspace/github_c_makefile_star2_O1/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 0xb914e
movq %rsi, %r14
testq %rsi, %rsi
je 0xb914e
movq %rdi, %rbx
movq %r14, %rdi
callq 0xb260
testq %rax, %rax
je 0xb9153
movq %rax, %r15
movq 0x118(%rbx), %rdi
movl (%rbx), %esi
addq %rax, %rsi
leaq 0x47d6e(%rip), %r12     # 0x100e32
movq %r12, %rdx
movl $0x1ac, %ecx            # imm = 0x1AC
callq 0x36116
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 0x36116
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 0xb911e
movl 0x4(%rbx), %edi
incl %edi
movl %edi, 0x4(%rbx)
callq 0x7a294
movl %eax, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x27c47
callq 0x27c80
// File: /workspace/github_c_makefile_star2_O1/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 0xb91b1
movl %esi, %ebp
movq %rdi, %rbx
movq 0x118(%rdi), %rdi
movl (%rbx), %esi
incq %rsi
leaq 0x47cba(%rip), %rdx     # 0x100e32
movl $0x1bf, %ecx            # imm = 0x1BF
callq 0x36116
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 0xb91a7
movb %bpl, 0x14(%rbx)
incl 0x4(%rbx)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x27cb9
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0xb91d8
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xb9292
leaq 0x47c53(%rip), %rsi     # 0x100e32
movl $0x138, %edi            # imm = 0x138
movl $0x269, %edx            # imm = 0x269
callq 0x35ee2
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
callq 0x3d96a
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)
testq %rbx, %rbx
je 0xb9244
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xb9297
movq %r15, %rdi
movq %rbx, %rsi
callq 0x76240
testl %eax, %eax
js 0xb926d
movl %eax, %ebp
movq %r14, %rdi
cmpl $0x1, %eax
jne 0xb9264
callq 0xb953e
jmp 0xb9269
callq 0xb9425
testl %ebp, %ebp
jns 0xb9284
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
je 0xb929c
movq %r14, %rdi
callq 0xb9301
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x27cf2
callq 0x27d2b
callq 0x27d64
// File: /workspace/github_c_makefile_star2_O1/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 0x47b89(%rip), %rsi     # 0x100e32
movl $0x138, %edi            # imm = 0x138
movl $0x269, %edx            # imm = 0x269
callq 0x35ee2
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
callq 0x3d96a
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_O1/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 0xb9338
movq %rdi, %rbx
movq 0x128(%rdi), %rdi
callq 0x3d9b7
movl 0x10(%rbx), %eax
testl %eax, %eax
je 0xb9340
decl %eax
movl %eax, 0x10(%rbx)
movq 0x128(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d9d2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x128(%rbx), %rdi
callq 0x3d9d2
movq 0x118(%rbx), %rdi
leaq 0x47ad8(%rip), %r14     # 0x100e32
movq %r14, %rsi
movl $0x444, %edx            # imm = 0x444
callq 0x362a0
movq 0x120(%rbx), %rdi
movq %r14, %rsi
movl $0x445, %edx            # imm = 0x445
callq 0x362a0
movq 0x130(%rbx), %rdi
testq %rdi, %rdi
je 0xb938c
callq 0x3d1eb
movq 0x128(%rbx), %rdi
callq 0x3d995
leaq 0x47a93(%rip), %rsi     # 0x100e32
movq %rbx, %rdi
movl $0x449, %edx            # imm = 0x449
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
// File: /workspace/github_c_makefile_star2_O1/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 0x479e4(%rip), %r14     # 0x100e32
movl $0x20, %edi
movq %r14, %rsi
movl $0x1dd, %edx            # imm = 0x1DD
callq 0x35ee2
movq %rax, 0x118(%rbx)
movl (%rbx), %edx
leaq 0x47e78(%rip), %rsi     # 0x1012e8
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 0x3601f
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 0xb9ccd
// File: /workspace/github_c_makefile_star2_O1/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 0x478cb(%rip), %r14     # 0x100e32
movl $0x1c, %edi
movq %r14, %rsi
movl $0x220, %edx            # imm = 0x220
callq 0x35ee2
movq %rax, 0x118(%rbx)
movl (%rbx), %edx
leaq 0x47d80(%rip), %rsi     # 0x101309
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 0x3601f
movq %rax, 0x120(%rbx)
movups 0x47d69(%rip), %xmm0    # 0x101326
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 0x47d27(%rip), %rcx     # 0x101326
movsbq (%rax,%rcx), %rdx
movl %edx, %edx
movb %al, (%rbx,%rdx)
incq %rax
cmpq $0x14, %rax
jne 0xb95ff
xorl %eax, %eax
leaq 0x47d02(%rip), %rcx     # 0x10131d
movsbq (%rax,%rcx), %rdx
movl %edx, %edx
movb $-0x2, (%rbx,%rdx)
incq %rax
cmpq $0x8, %rax
jne 0xb961b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb969f
testq %rsi, %rsi
je 0xb969f
movq %rdi, %rbx
movl $0x1388, %r15d          # imm = 0x1388
cmpq %r15, %rsi
cmovbq %rsi, %r15
xorl %r12d, %r12d
leaq 0x478d2(%rip), %r14     # 0x100f32
movsbl (%rbx,%r12), %esi
movl $0x13, %edx
movq %r14, %rdi
callq 0xb710
testq %rax, %rax
jne 0xb968f
incq %r12
cmpq %r12, %r15
jne 0xb9660
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb93b3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb94cc
callq 0x27e0f
// File: /workspace/github_c_makefile_star2_O1/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 0xb98ea
movq %rsi, %rbx
testq %rsi, %rsi
je 0xb98ea
movq %rdi, %r14
callq 0x3bfe0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0xb9708
movq %r15, %rdi
callq 0x3c40b
movq %rax, %r14
movq %r15, %rdi
callq 0x3c434
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x3dc94
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3d1eb
callq 0x28010
// File: /workspace/github_c_makefile_star2_O1/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 0xb9957
movq %rcx, %rbx
movq %rdx, %r14
testq %rcx, %rcx
sete %al
testq %rdx, %rdx
setne %cl
orb %al, %cl
je 0xb9957
movq %rsi, %r15
testq %rdi, %rdi
je 0xb9924
movq 0x120(%rdi), %r12
jmp 0xb992b
leaq 0x4775a(%rip), %r12     # 0x101085
testq %rbx, %rbx
je 0xb994d
xorl %r13d, %r13d
movzbl (%r14,%r13), %eax
movzbl (%r12,%rax), %edi
movq %r15, %rsi
callq 0x3dc12
incq %r13
cmpq %r13, %rbx
jne 0xb9933
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x28049
// File: /workspace/github_c_makefile_star2_O1/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 0xb99c2
testq %rdi, %rdi
je 0xb99c8
leaq 0x14(%rdi), %rax
xorl %r8d, %r8d
movzbl (%rdx,%r8), %r9d
movq %rax, %r10
cmpl $0xfe, %r9d
je 0xb99b3
cmpl $0xff, %r9d
je 0xb99c8
movl 0x4(%rdi), %r10d
decl %r10d
cmpl %r9d, %r10d
jbe 0xb99cd
movl %r9d, %r10d
addq 0x120(%rdi), %r10
movb (%r10), %r9b
movb %r9b, (%rsi,%r8)
incq %r8
cmpq %r8, %rcx
jne 0xb9983
movb $0x0, (%rsi,%rcx)
popq %rax
retq
callq 0x280bb
callq 0x28082
// File: /workspace/github_c_makefile_star2_O1/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 0xb9a42
movq %rsi, %r14
testq %rsi, %rsi
je 0xb9a42
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x1(%rdx), %rdi
leaq 0x47439(%rip), %r12     # 0x100e32
movq %r12, %rsi
movl $0x326, %edx            # imm = 0x326
callq 0x35ee2
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xb9971
movq %r13, %rdi
callq 0x3c03d
movq %rax, %rbx
movq %r13, %rdi
movq %r12, %rsi
movl $0x329, %edx            # imm = 0x329
callq 0x362a0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x280f4
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x340, %rsp            # imm = 0x340
movq %rdi, %rsi
leaq 0x240(%rsp), %rdi
callq 0xb9bae
movl %eax, %ebp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xb953e
leaq 0x140(%rsp), %rdi
movq %rbx, %rsi
callq 0xb9bae
cmpl %eax, %ebp
jne 0xb9b69
movl %eax, %ebx
movl %ebp, %esi
leaq 0xe8(%rip), %r14        # 0xb9c07
leaq 0x240(%rsp), %r15
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0xbc80
movl %ebx, %ebx
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 0xb9b6b
xorl %ebx, %ebx
movq 0x120(%rsp), %rdi
leaq 0x472b8(%rip), %r14     # 0x100e32
movq %r14, %rsi
movl $0x375, %edx            # imm = 0x375
callq 0x362a0
movq 0x128(%rsp), %rdi
movq %r14, %rsi
movl $0x376, %edx            # imm = 0x376
callq 0x362a0
movl %ebx, %eax
addq $0x340, %rsp            # imm = 0x340
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %ecx
xorl %eax, %eax
cmpl 0x8(%rsi), %ecx
je 0xb9c06
pushq %r15
pushq %r14
pushq %rbx
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 0xb9bf4
movl %eax, %esi
incl %eax
movb %dl, (%r14,%rsi)
incq %r15
movl (%rbx), %edx
subl 0x8(%rbx), %edx
cmpq %rdx, %r15
jb 0xb9bcf
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb9ad2
testb %al, %al
jne 0xb9cb4
cmpl $0x5, 0x4(%rbx)
jne 0xb9cb4
movq %rsp, %rdi
callq 0xb9ccd
callq 0xb6e0
movq (%rax), %r15
movb $0x61, %al
xorl %r12d, %r12d
leaq 0x4742d(%rip), %r13     # 0x101085
xorl %ebp, %ebp
movzbl %al, %r14d
movzwl (%r15,%r14,2), %eax
btl $0x8, %eax
jb 0xb9c79
btl $0x9, %eax
jae 0xb9cc8
movl %r14d, %edi
callq 0xbbf0
jmp 0xb9c81
movl %r14d, %edi
callq 0xb900
movb 0x15(%rbx,%r14), %cl
cmpb (%rsp,%r14), %cl
je 0xb9c98
movzbl %al, %eax
movb 0x15(%rbx,%rax), %cl
cmpb (%rsp,%rax), %cl
jne 0xb9cac
movb 0x1(%r12,%r13), %al
incq %r12
testb %al, %al
sete %bpl
cmpq $0x4, %r12
jne 0xb9c5a
movb $0x1, %al
testb $0x1, %bpl
jne 0xb9cb6
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2824a
// File: /workspace/github_c_makefile_star2_O1/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 0x475e7(%rip), %rcx     # 0x1012f2
movsbq (%rax,%rcx), %rdx
movl %edx, %edx
movb $-0x2, (%rbx,%rdx)
incq %rax
cmpq $0x16, %rax
jne 0xb9d0b
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb9d88
movzbl %sil, %eax
movl 0x4(%rdi), %ecx
movzbl %cl, %edx
decl %edx
cmpl %eax, %edx
je 0xb9d80
cmpb $-0x2, %sil
je 0xb9d80
cmpl $0xff, %eax
je 0xb9d8d
decl %ecx
cmpl %eax, %ecx
jbe 0xb9d92
addq 0x120(%rdi), %rax
movq %rax, %rdi
jmp 0xb9d84
addq $0x14, %rdi
movb (%rdi), %al
popq %rcx
retq
callq 0x28367
callq 0x282f5
callq 0x2832e
// File: /workspace/github_c_makefile_star2_O1/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 0xb9dd1
testq %rsi, %rsi
je 0xb9dd1
testq %rdx, %rdx
je 0xb9dd1
testq %rcx, %rcx
je 0xb9dca
xorl %eax, %eax
movsbq (%rdx,%rax), %r8
movb 0x15(%rdi,%r8), %r8b
cmpb $-0x3, %r8b
je 0xb9dcc
movb %r8b, (%rsi,%rax)
incq %rax
cmpq %rax, %rcx
jne 0xb9dae
popq %rax
retq
callq 0x283d9
callq 0x283a0
// File: /workspace/github_c_makefile_star2_O1/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 0xb9e22
movq %rsi, %rbx
callq 0x3c03d
movq %rax, %r14
leaq 0x473bb(%rip), %rsi     # 0x1011ac
movq %rax, %rdi
callq 0x3c067
movq %r14, %rdi
callq 0x3c40b
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb9e27
movq %rax, %rbx
movq %r14, %rdi
callq 0x3d1eb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x28412
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb9fa9
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0xb9e56
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xb9fb3
leaq 0x46fd5(%rip), %rsi     # 0x100e32
movl $0x138, %edi            # imm = 0x138
movl $0x269, %edx            # imm = 0x269
callq 0x35ee2
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
callq 0x3d96a
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 %r15, %rdi
callq 0x75bdc
testb %al, %al
je 0xb9ec1
xorl %r12d, %r12d
jmp 0xb9f30
movq %r14, %rdi
callq 0x356f2
testq %rax, %rax
je 0xb9fbd
movq %rax, %r12
callq 0x3bfe0
movq %rax, %r13
movq %r12, %rdi
movl $0x20, %esi
callq 0x723d8
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3c185
movq %r13, %rdi
callq 0x3c40b
movq %rax, %rdi
movq %r14, %rsi
callq 0xd5a14
movq %rax, %r12
movq %r13, %rdi
callq 0x3d1eb
leaq 0x472f9(%rip), %rsi     # 0x101216
movq %r12, %rdi
callq 0x3c067
movq %r12, %rdi
movq %r15, %rsi
callq 0x3c067
testq %r12, %r12
je 0xb9f40
movq %r12, %rdi
callq 0x3c40b
movq %rax, %r15
testq %r14, %r14
je 0xb9f51
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xb9fb8
movq %r15, %rdi
callq 0x3d27e
testq %rax, %rax
je 0xb9fae
movq %rax, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0xba0f4
movl %eax, %ebp
movq %r13, %rdi
callq 0x3d573
movq %r12, %rdi
callq 0x3d1eb
testq %rbx, %rbx
je 0xb9f8d
testl %ebp, %ebp
je 0xb9f97
movq %rbx, %rdi
callq 0xb9301
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2852f
callq 0x284f6
callq 0x2844b
callq 0x284bd
callq 0x28484
// File: /workspace/github_c_makefile_star2_O1/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 0xba0e5
movq %rsi, %r14
testq %rsi, %rsi
je 0xba0e5
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0xb9ffd
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xba0ea
movq %rbx, (%rsp)
leaq 0x46e2a(%rip), %rsi     # 0x100e32
movl $0x138, %edi            # imm = 0x138
movl $0x269, %edx            # imm = 0x269
callq 0x35ee2
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
callq 0x3d96a
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 0x3d23c
movq %rax, %r13
leaq -0x1(%r14), %rbp
cmpq $0x1, %r14
adcq $0x0, %r14
xorl %ebx, %ebx
xorl %eax, %eax
cmpq %rbx, %rbp
je 0xba084
cmpb $0xa, (%r15,%rbx)
jne 0xba09a
leaq (%r15,%rax), %rsi
movq %rbx, %rdx
subq %rax, %rdx
movq %r13, %rdi
callq 0x3d352
leaq 0x1(%rbx), %rax
incq %rbx
cmpq %rbx, %r14
jne 0xba078
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq (%rsp), %rbx
movq %rbx, %rcx
callq 0xba0f4
movl %eax, %ebp
movq %r13, %rdi
callq 0x3d573
testl %ebp, %ebp
je 0xba0d3
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
je 0xba0ef
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x28568
callq 0x285a1
callq 0x285da
// File: /workspace/github_c_makefile_star2_O1/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 0xba48e
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xba513
leaq 0x46d17(%rip), %rsi     # 0x1011ac
leaq 0x46d96(%rip), %rdx     # 0x101232
leaq 0x4698f(%rip), %rcx     # 0x100e32
movq %r15, %rdi
movl $0x429, %r8d            # imm = 0x429
movq %rbx, %r9
callq 0x73e9b
movq %rax, %rbx
testq %rax, %rax
je 0xba505
callq 0x3bfe0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0xb9708
movq %r15, %rdi
callq 0x3c40b
movq %rax, %r14
movq %r15, %rdi
callq 0x3c434
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x3dc94
movq %rbx, %rdi
callq 0x73f9e
movq %r15, %rdi
callq 0x3d1eb
xorl %eax, %eax
cmpq $0x1, %rbx
sbbl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x28685
// File: /workspace/github_c_makefile_star2_O1/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 0xba538
movq %r12, %rdi
callq 0x3566a
testb %al, %al
jne 0xba698
callq 0xb93b3
movq %rax, %rbx
callq 0xb94cc
movq %rax, %r14
movq %rbx, %rdi
callq 0xb8e94
movq %rax, %r15
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xb8fd9
testb %al, %al
je 0xba5be
movq %r14, %rdi
movq %r14, %rsi
callq 0xb8fd9
testb %al, %al
je 0xba5e5
movq %r15, %rdi
movq %r15, %rsi
callq 0xb8fd9
testb %al, %al
je 0xba60c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb8fd9
testb %al, %al
je 0xba660
leaq 0x28bdb(%rip), %rsi     # 0xe3179
leaq 0x46cf1(%rip), %rdx     # 0x101296
leaq 0x46c89(%rip), %rcx     # 0x101235
leaq 0x4687f(%rip), %r8      # 0x100e32
movq %r12, %rdi
movl $0x45a, %r9d            # imm = 0x45A
jmp 0xba631
leaq 0x28bb4(%rip), %rsi     # 0xe3179
leaq 0x46c7f(%rip), %rdx     # 0x10124b
leaq 0x46c62(%rip), %rcx     # 0x101235
leaq 0x46858(%rip), %r8      # 0x100e32
movq %r12, %rdi
movl $0x456, %r9d            # imm = 0x456
jmp 0xba631
leaq 0x28b8d(%rip), %rsi     # 0xe3179
leaq 0x46c71(%rip), %rdx     # 0x101264
leaq 0x46c3b(%rip), %rcx     # 0x101235
leaq 0x46831(%rip), %r8      # 0x100e32
movq %r12, %rdi
movl $0x457, %r9d            # imm = 0x457
jmp 0xba631
leaq 0x28b66(%rip), %rsi     # 0xe3179
leaq 0x46c63(%rip), %rdx     # 0x10127d
leaq 0x46c14(%rip), %rcx     # 0x101235
leaq 0x4680a(%rip), %r8      # 0x100e32
movq %r12, %rdi
movl $0x458, %r9d            # imm = 0x458
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0xb9301
movq %r14, %rdi
callq 0xb9301
movq %r15, %rdi
callq 0xb9301
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb8fd9
xorl %ebp, %ebp
testb %al, %al
jne 0xba63d
leaq 0x28b01(%rip), %rsi     # 0xe3179
leaq 0x46c31(%rip), %rdx     # 0x1012b0
leaq 0x46baf(%rip), %rcx     # 0x101235
leaq 0x467a5(%rip), %r8      # 0x100e32
movq %r12, %rdi
movl $0x45b, %r9d            # imm = 0x45B
jmp 0xba631
callq 0x286be
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xba6bb
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xba6e9
movq %r14, %rdi
callq 0x3c03d
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xba6ee
movq %rax, %rbx
movq %r14, %rdi
callq 0x3d1eb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x286f7
// File: /workspace/github_c_makefile_star2_O1/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 0xbabc8
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xbabf9
movq %r14, %rdi
callq 0x3c03d
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0xba6ee
movq %rax, %rbx
movq %r14, %rdi
callq 0x3d1eb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x288f4