LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_append_cstr
void gt_str_append_cstr(GtStr *dest, const char *cstr)
{
  size_t cstrlen;
  char *destptr;
  gt_assert(dest && cstr);
  cstrlen = strlen(cstr);
  dest->cstr = gt_dynalloc(dest->cstr, &dest->allocated,
                           (dest->length + cstrlen + 1) * sizeof (char));
  destptr = dest->cstr + dest->length;
  while (*cstr != '\0')
    *destptr++ = *cstr++;
  dest->length += cstrlen;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3b819
movq %rsi, %r14
testq %rsi, %rsi
je 0x3b819
movq %rdi, %rbx
movq %r14, %rdi
callq 0xb260
movq %rax, %r15
leaq 0x10(%rbx), %rsi
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
leaq (%r15,%rax), %rdx
incq %rdx
callq 0x74134
movq %rax, (%rbx)
movq 0x8(%rbx), %rdx
movb (%r14), %cl
testb %cl, %cl
je 0x3b80c
addq %rdx, %rax
xorl %edx, %edx
movb %cl, (%rax,%rdx)
movb 0x1(%r14,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x3b7f9
movq 0x8(%rbx), %rdx
addq %r15, %rdx
movq %rdx, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0xdd1f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_set
void gt_str_set(GtStr *s, const char *cstr)
{
  size_t cstrlen;
  char *sptr;
  gt_assert(s);
  if (!cstr)
    s->length = 0;
  else {
    cstrlen = strlen(cstr);
    s->cstr = gt_dynalloc(s->cstr, &s->allocated,
                          (cstrlen + 1) * sizeof (char));
    sptr = s->cstr;
    while (*cstr != '\0') *sptr++ = *cstr++;
    s->length = cstrlen;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3b878
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3b86b
movq %r14, %rdi
callq 0xb260
movq %rax, %r15
movq (%rbx), %rdi
leaq 0x10(%rbx), %rsi
leaq 0x1(%rax), %rdx
callq 0x74134
movq %rax, (%rbx)
movb (%r14), %cl
testb %cl, %cl
je 0x3b86e
xorl %edx, %edx
movb %cl, (%rax,%rdx)
movb 0x1(%r14,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x3b85a
jmp 0x3b86e
xorl %r15d, %r15d
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0xdd56
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_append_str
void gt_str_append_str(GtStr *dest, const GtStr* src)
{
  gt_assert(dest && src);
  dest->cstr = gt_dynalloc(dest->cstr, &dest->allocated,
                           (dest->length + src->length + 1) * sizeof (char));
  memcpy(dest->cstr + dest->length, src->cstr, src->length);
  dest->length += src->length;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3b8d2
movq %rsi, %r14
testq %rsi, %rsi
je 0x3b8d2
movq %rdi, %rbx
leaq 0x10(%rdi), %rsi
movq (%rdi), %rdi
movq 0x8(%rbx), %rax
movq 0x8(%r14), %rcx
leaq (%rax,%rcx), %rdx
incq %rdx
callq 0x74134
movq %rax, (%rbx)
addq 0x8(%rbx), %rax
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0xb520
movq 0x8(%r14), %rax
addq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xdd8d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_append_cstr_nt
void gt_str_append_cstr_nt(GtStr *dest, const char *cstr, GtUword length)
{
  gt_assert(dest && cstr);
  dest->cstr = gt_dynalloc(dest->cstr, &dest->allocated,
                           (dest->length + length + 1) * sizeof (char));
  memcpy(dest->cstr + dest->length, cstr, length);
  dest->length += length;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3b924
movq %rsi, %r15
testq %rsi, %rsi
je 0x3b924
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rsi
movq (%rdi), %rdi
movq 0x8(%r14), %rax
addq %rax, %rdx
incq %rdx
callq 0x74134
movq %rax, (%r14)
addq 0x8(%r14), %rax
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xb520
addq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
callq 0xddc4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_append_uword
void gt_str_append_uword(GtStr *dest, GtUword uword)
{
  unsigned int ulength = 1;
  GtUword q = uword;
  char *s;
  gt_assert(dest);
  /* determine length of uword */
  while (q > 9) {
    ulength++;
    q /= 10;
  }
  /* make sure the string is long enough */
  dest->cstr = gt_dynalloc(dest->cstr, &dest->allocated,
                           (dest->length + ulength + 1) * sizeof (char));
 /* format */
  s = dest->cstr + dest->length + ulength;
  do {
    *--s = '0' + (uword % 10);
    uword /= 10;
  }
  while (uword); /* handles uword == 0 */
  dest->length += ulength;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3b9da
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %r12d
movabsq $-0x3333333333333333, %r15 # imm = 0xCCCCCCCCCCCCCCCD
cmpq $0xa, %rsi
jb 0x3b97b
movl $0x1, %esi
movq %r14, %rcx
incl %esi
movq %rcx, %rax
mulq %r15
shrq $0x3, %rdx
cmpq $0x63, %rcx
movq %rdx, %rcx
ja 0x3b963
movl %esi, %r12d
leaq 0x10(%rbx), %rsi
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
leaq (%r12,%rax), %rdx
incq %rdx
callq 0x74134
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
addq %r12, %rcx
addq %rax, %rcx
decq %rcx
movq %r14, %rax
mulq %r15
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %r14d, %esi
subl %eax, %esi
orb $0x30, %sil
movb %sil, (%rcx)
decq %rcx
cmpq $0x9, %r14
movq %rdx, %r14
ja 0x3b9a2
addq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xddfb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_append_char
void gt_str_append_char(GtStr *dest, char c)
{
  gt_assert(dest);
  if (dest->length + 2 > dest->allocated) {
    dest->cstr = gt_dynalloc(dest->cstr, &dest->allocated,
                             (dest->length + 2) * sizeof (char));
  }
  dest->cstr[dest->length++] = c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3ba24
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq 0x2(%rcx), %rdx
cmpq 0x10(%rdi), %rdx
jbe 0x3ba11
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x74134
movq %rax, (%r14)
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb %bl, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xde32
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_append_sci_double
void gt_str_append_sci_double(GtStr *dest, double d, int precision)
{
  char buf[BUFSIZ];
  GT_UNUSED int rval;
  gt_assert(dest != NULL);
  rval = snprintf(buf, BUFSIZ, "%.*e", precision, d);
  gt_assert(rval < BUFSIZ);
  gt_str_append_cstr(dest, buf);
}

// Assembly:
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
testq %rdi, %rdi
je 0x3ba6c
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xa7b59(%rip), %rdx     # 0xe359b
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
movb $0x1, %al
callq 0xba10
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x3ba71
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3b7af
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
callq 0xdea4
callq 0xde6b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_append_double
void gt_str_append_double(GtStr *dest, double d, int precision)
{
  char buf[BUFSIZ];
  GT_UNUSED int rval;
  gt_assert(dest);
  rval = snprintf(buf, BUFSIZ, "%.*f", precision, d);
  gt_assert(rval < BUFSIZ);
  gt_str_append_cstr(dest, buf);
}

// Assembly:
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
testq %rdi, %rdi
je 0x3bab9
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xa7b34(%rip), %rdx     # 0xe35c3
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
movb $0x1, %al
callq 0xba10
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x3babe
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3b7af
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
callq 0xdf16
callq 0xdedd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_append_int
void gt_str_append_int(GtStr *dest, int intval)
{
  char buf[BUFSIZ];
  GT_UNUSED int rval;
  gt_assert(dest);
  rval = snprintf(buf, BUFSIZ, "%d", intval);
  gt_assert(rval < BUFSIZ);
  gt_str_append_cstr(dest, buf);
}

// Assembly:
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
testq %rdi, %rdi
je 0x3bb06
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xc8ef6(%rip), %rdx     # 0x1049d2
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
xorl %eax, %eax
callq 0xba10
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x3bb0b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3b7af
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
callq 0xdf88
callq 0xdf4f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_append_uint
void gt_str_append_uint(GtStr *dest, unsigned int uint)
{
  char buf[BUFSIZ];
  GT_UNUSED int rval;
  gt_assert(dest);
  rval = snprintf(buf, BUFSIZ, "%u", uint);
  gt_assert(rval < BUFSIZ);
  gt_str_append_cstr(dest, buf);
}

// Assembly:
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
testq %rdi, %rdi
je 0x3bb53
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xa6407(%rip), %rdx     # 0xe1f30
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
xorl %eax, %eax
callq 0xba10
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x3bb58
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3b7af
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
callq 0xdffa
callq 0xdfc1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_clip_suffix
void gt_str_clip_suffix(GtStr *s, char c)
{
  char *found;
  gt_assert(s != NULL);
  s->cstr[s->length] = '\0';
  found = strchr(s->cstr, (int) c);
  s->length = (found != NULL) ? (GtUword) (found - s->cstr) : s->length;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3bbe9
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movb $0x0, (%rax,%rcx)
movq (%rdi), %r14
movsbl %sil, %esi
movq %r14, %rdi
callq 0xb210
testq %rax, %rax
je 0x3bbd9
subq %r14, %rax
jmp 0x3bbdd
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xe0de
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_cmp
int gt_str_cmp(const GtStr *s1, const GtStr *s2)
{
  gt_assert(s1 && s2);
  if (s1 == s2)
    return 0; /* a string is equal to itself */
  gt_assert(s1->cstr && s2->cstr);
  s1->cstr[s1->length] = '\0';
  s2->cstr[s2->length] = '\0';
  return strcmp(s1->cstr, s2->cstr);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3bc48
testq %rsi, %rsi
je 0x3bc48
cmpq %rsi, %rdi
je 0x3bc3f
movq (%rdi), %rax
testq %rax, %rax
je 0x3bc43
cmpq $0x0, (%rsi)
je 0x3bc43
movq 0x8(%rdi), %rcx
xorl %edx, %edx
movb %dl, (%rax,%rcx)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movb %dl, (%rax,%rcx)
movq (%rdi), %rdi
movq (%rsi), %rsi
popq %rax
jmp 0xb890
xorl %eax, %eax
popq %rcx
retq
callq 0xe189
callq 0xe150
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_clone
GtStr* gt_str_clone(const GtStr *s)
{
  GtStr *s_copy;
  gt_assert(s);
  s_copy = gt_malloc(sizeof *s_copy);
  s->cstr[s->length] = '\0';
  s_copy->cstr = gt_cstr_dup(s->cstr);
  s_copy->length = s->length;
  s_copy->allocated = s->length + 1;
  s_copy->reference_count = 0;
  return s_copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3bcaa
movq %rdi, %rbx
leaq 0xa788d(%rip), %rsi     # 0xe34ed
movl $0x20, %edi
movl $0xee, %edx
callq 0x35862
movq %rax, %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq (%rbx), %rdi
callq 0x728c0
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
incq %rax
movq %rax, 0x10(%r14)
movl $0x0, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xe1c2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str.c
// Function: gt_str_delete
void gt_str_delete(GtStr *s)
{
  if (!s) return;           /* return without action if 's' is NULL */
  if (s->reference_count) { /* there are multiple references to this string */
    s->reference_count--;   /* decrement the reference counter */
    return;                 /* return without freeing the object */
  }
  gt_free(s->cstr);         /* free the stored the C string */
  gt_free(s);               /* free the actual string object */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3c893
movq %rdi, %rbx
movl 0x18(%rdi), %eax
testl %eax, %eax
je 0x3c89b
decl %eax
movl %eax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
leaq 0xa6c48(%rip), %r14     # 0xe34ed
movq %r14, %rsi
movl $0x1d8, %edx            # imm = 0x1D8
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1d9, %edx            # imm = 0x1D9
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_new
GtStrArray* gt_str_array_new(void)
{
  GtStrArray *sa = gt_malloc(sizeof *sa);
  sa->strings = gt_array_new(sizeof (GtStr*));
  sa->reference_count = 0;
  return sa;
}

// Assembly:
pushq %rbx
leaq 0xa7074(%rip), %rsi     # 0xe3948
movl $0x10, %edi
movl $0x1d, %edx
callq 0x35862
movq %rax, %rbx
movl $0x8, %edi
callq 0x6ef7c
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_new_file
GtStrArray* gt_str_array_new_file(const char *path)
{
  GtStrArray *filecontent;
  GtFile *fpin;
  GtStr *line;
  fpin = gt_file_xopen(path, "r");
  gt_assert(fpin);
  line = gt_str_new();
  filecontent = gt_str_array_new();
  while (gt_str_read_next_line_generic(line, fpin) != EOF) {
    gt_str_array_add_cstr(filecontent, gt_str_get(line));
    gt_str_reset(line);
  }
  gt_str_delete(line);
  gt_file_delete(fpin);
  return filecontent;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xb2546(%rip), %rsi     # 0xeee5d
callq 0x75bec
testq %rax, %rax
je 0x3c9a0
movq %rax, %rbx
callq 0x3b728
movq %rax, %r14
leaq 0xa7015(%rip), %rsi     # 0xe3948
movl $0x10, %edi
movl $0x1d, %edx
callq 0x35862
movq %rax, %r15
movl $0x8, %edi
callq 0x6ef7c
movq %rax, (%r15)
movl $0x0, 0x8(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3bde8
cmpl $-0x1, %eax
je 0x3c987
movq %r14, %rdi
callq 0x3bb5d
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c9a5
movq %r14, %rdi
callq 0x3bbee
jmp 0x3c95a
movq %r14, %rdi
callq 0x3c87b
movq %rbx, %rdi
callq 0x760c0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xe2a6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_add_cstr
void gt_str_array_add_cstr(GtStrArray *sa, const char *cstr)
{
  GtStr *str;
  gt_assert(sa && cstr);
  str = gt_str_new_cstr(cstr);
  gt_array_add(sa->strings, str);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x3c9da
testq %rsi, %rsi
je 0x3c9da
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3b785
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rdi
movl $0x8, %edx
callq 0x6f240
addq $0x10, %rsp
popq %rbx
retq
callq 0xe2dd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_add_cstr_nt
void gt_str_array_add_cstr_nt(GtStrArray *sa, const char *cstr,
                             GtUword length)
{
  GtStr *str;
  gt_assert(sa && cstr);
  str = gt_str_new();
  gt_str_append_cstr_nt(str, cstr, length);
  gt_array_add(sa->strings, str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3ca30
movq %rsi, %r15
testq %rsi, %rsi
je 0x3ca30
movq %rdx, %r14
movq %rdi, %rbx
callq 0x3b728
movq %rsp, %r12
movq %rax, (%r12)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3b8d7
movq (%rbx), %rdi
movl $0x8, %edx
movq %r12, %rsi
callq 0x6f240
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xe314
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_add
void gt_str_array_add(GtStrArray *sa, const GtStr *str)
{
  GtStr *clone;
  gt_assert(sa && str);
  clone = gt_str_clone(str);
  gt_array_add(sa->strings, clone);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x3ca6a
testq %rsi, %rsi
je 0x3ca6a
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3bc4d
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rdi
movl $0x8, %edx
callq 0x6f240
addq $0x10, %rsp
popq %rbx
retq
callq 0xe34b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_set_cstr
void gt_str_array_set_cstr(GtStrArray *sa, GtUword strnum,
                           const char *cstr)
{
  GtStr *str;
  gt_assert(sa && strnum < gt_array_size(sa->strings) && cstr);
  str = *(GtStr**) gt_array_get(sa->strings, strnum);
  gt_str_set(str, cstr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3cb21
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x6f310
testq %rbx, %rbx
je 0x3cb21
cmpq %r14, %rax
jbe 0x3cb21
movq (%r15), %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3b81e
callq 0xe3f0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_set
void gt_str_array_set(GtStrArray *sa, GtUword strnum, const GtStr *instr)
{
  GtStr *str;
  gt_assert(sa && strnum < gt_array_size(sa->strings) && instr);
  str = *(GtStr**) gt_array_get(sa->strings, strnum);
  gt_str_set(str, gt_str_get(instr));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3cb71
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x6f310
testq %rbx, %rbx
je 0x3cb71
cmpq %r14, %rax
jbe 0x3cb71
movq (%r15), %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %r14
movq %rbx, %rdi
callq 0x3bb5d
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3b81e
callq 0xe427
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_set_size
void gt_str_array_set_size(GtStrArray *sa, GtUword size)
{
  GtUword i;
  gt_assert(sa && size <= gt_array_size(sa->strings));
  for (i = size; i < gt_array_size(sa->strings); i++)
    gt_str_delete(*(GtStr**) gt_array_get(sa->strings, i));
  gt_array_set_size(sa->strings, size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3cbd6
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x6f310
cmpq %rbx, %rax
jb 0x3cbd6
movq (%r14), %rdi
callq 0x6f310
cmpq %rbx, %rax
jbe 0x3cbc6
movq %rbx, %r15
movq (%r14), %rdi
movq %r15, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x3c87b
incq %r15
movq (%r14), %rdi
callq 0x6f310
cmpq %rax, %r15
jb 0x3cba3
movq (%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6f32d
callq 0xe45e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_delete
void gt_str_array_delete(GtStrArray *sa)
{
  GtUword i;
  if (!sa) return;
  if (sa->reference_count) {
    sa->reference_count--;
    return;
  }
  for (i = 0; i < gt_array_size(sa->strings); i++)
    gt_str_delete(*(GtStr**) gt_array_get(sa->strings, i));
  gt_array_delete(sa->strings);
  gt_free(sa);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3cc18
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x3cc20
decl %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
callq 0x6f310
testq %rax, %rax
je 0x3cc53
xorl %r14d, %r14d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x3c87b
incq %r14
movq (%rbx), %rdi
callq 0x6f310
cmpq %rax, %r14
jb 0x3cc30
movq (%rbx), %rdi
callq 0x6f768
leaq 0xa6ce6(%rip), %rsi     # 0xe3948
movq %rbx, %rdi
movl $0x93, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/strand.c
// Function: gt_strand_join
GtStrand gt_strand_join(GtStrand strand_a, GtStrand strand_b)
{
  switch (strand_b) {
    case GT_STRAND_FORWARD:
      gt_assert(strand_a != GT_STRAND_REVERSE);
      return GT_STRAND_FORWARD;
    case GT_STRAND_REVERSE:
      gt_assert(strand_a != GT_STRAND_FORWARD);
      return GT_STRAND_REVERSE;
    case GT_STRAND_BOTH: break;
    case GT_STRAND_UNKNOWN:
      /* strand_a == GT_STRAND_FORWARD -> stays the same */
      /* strand_a == GT_STRAND_REVERSE -> stays the same */
      /* strand_a == GT_STRAND_UNKNOWN -> stays the same */
      if (strand_a == GT_STRAND_BOTH)
        return GT_STRAND_UNKNOWN;
      break;
    default: gt_assert(0);
  }
  return strand_a;
}

// Assembly:
pushq %rax
cmpl $0x3, %esi
ja 0x3cd01
movl %esi, %eax
leaq 0xa6e35(%rip), %rcx     # 0xe3b08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
cmpl $0x1, %edi
jne 0x3ccff
callq 0xe573
movl $0x3, %eax
cmpl $0x2, %edi
je 0x3ccff
movl %edi, %eax
jmp 0x3ccff
movl $0x1, %eax
testl %edi, %edi
je 0x3cd06
popq %rcx
retq
callq 0xe5aa
callq 0xe53c
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/symbol.c
// Function: gt_symbol_init
void gt_symbol_init(void)
{
  if (!symbols)
    symbols = gt_cstr_table_new();
  if (!symbol_mutex)
    symbol_mutex = gt_mutex_new();
}

// Assembly:
pushq %rax
cmpq $0x0, 0x115d03(%rip)    # 0x152a18
jne 0x3cd23
callq 0x72f00
movq %rax, 0x115cf5(%rip)    # 0x152a18
cmpq $0x0, 0x115cf5(%rip)    # 0x152a20
jne 0x3cd39
callq 0x3cff6
movq %rax, 0x115ce7(%rip)    # 0x152a20
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/symbol.c
// Function: gt_symbol
const char* gt_symbol(const char *cstr)
{
  const char *symbol;
  if (!cstr)
    return NULL;
  gt_mutex_lock(symbol_mutex);
  if (!(symbol = gt_cstr_table_get(symbols, cstr))) {
    gt_cstr_table_add(symbols, cstr);
    symbol = gt_cstr_table_get(symbols, cstr);
  }
  gt_mutex_unlock(symbol_mutex);
  return symbol;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3cd99
movq %rdi, %rbx
movq 0x115cd2(%rip), %rdi    # 0x152a20
callq 0x3d043
movq 0x115cbe(%rip), %rdi    # 0x152a18
movq %rbx, %rsi
callq 0x72fc5
movq %rax, %r14
testq %rax, %rax
jne 0x3cd8b
movq 0x115ca7(%rip), %rdi    # 0x152a18
movq %rbx, %rsi
callq 0x72f66
movq 0x115c98(%rip), %rdi    # 0x152a18
movq %rbx, %rsi
callq 0x72fc5
movq %rax, %r14
movq 0x115c8e(%rip), %rdi    # 0x152a20
callq 0x3d05e
jmp 0x3cd9c
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/symbol.c
// Function: test_symbol
static void* test_symbol(GT_UNUSED void *data)
{
  GtStr *symbol;
  GtUword i;
  symbol = gt_str_new();
  for (i = 0; i < NUMBER_OF_SYMBOLS; i++) {
    gt_str_reset(symbol);
    gt_str_append_uword(symbol, gt_rand_max(MAX_SYMBOL));
    gt_symbol(gt_str_get(symbol));
    gt_assert(!strcmp(gt_symbol(gt_str_get(symbol)), gt_str_get(symbol)));
  }
  gt_str_delete(symbol);
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x2710, %r15d          # imm = 0x2710
callq 0x3b728
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3bbee
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x7a51d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b92e
movq %rbx, %rdi
callq 0x3bb5d
movq %rax, %rdi
callq 0x3cd3b
movq %rbx, %rdi
callq 0x3bb5d
movq %rax, %rdi
callq 0x3cd3b
movq %rax, %r14
movq %rbx, %rdi
callq 0x3bb5d
movq %r14, %rdi
movq %rax, %rsi
callq 0xb890
testl %eax, %eax
jne 0x3ce6c
decq %r15
jne 0x3ce00
movq %rbx, %rdi
callq 0x3c87b
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xe618
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/thread.c
// Function: gt_thread_new
GtThread* gt_thread_new(GtThreadFunc function, void *data, GtError *err)
{
  GtThread *thread;
  int rval;
  gt_error_check(err);
  gt_assert(function);
  thread = gt_malloc(sizeof (pthread_t));
  rval = pthread_create((pthread_t*) thread, NULL, function, data);
  if (rval) {
    gt_error_set(err, "cannot create thread: %s", strerror(rval));
    gt_free(thread);
    return NULL;
  }
  return thread;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rdx, %rdx
je 0x3ce96
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x3cf0e
testq %r12, %r12
je 0x3cf09
leaq 0xa6d71(%rip), %rsi     # 0xe3c13
movl $0x8, %edi
movl $0x25, %edx
callq 0x35862
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0xbbb0
testl %eax, %eax
je 0x3cefa
movl %eax, %edi
callq 0xb1d0
leaq 0xa6d4f(%rip), %rsi     # 0xe3c25
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x34f1f
leaq 0xa6d29(%rip), %rsi     # 0xe3c13
movq %r14, %rdi
movl $0x29, %edx
callq 0x35c27
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xe686
callq 0xe64f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/thread.c
// Function: gt_thread_join
void gt_thread_join(GtThread *thread)
{
  GT_UNUSED int rval;
  gt_assert(thread);
  rval = pthread_join(*(pthread_t*) thread, NULL);
  gt_assert(!rval); /* XXX */
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3cf29
movq (%rdi), %rdi
xorl %esi, %esi
callq 0xb5b0
testl %eax, %eax
jne 0x3cf2e
popq %rax
retq
callq 0xe6f4
callq 0xe6bd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/thread.c
// Function: gt_rwlock_new
GtRWLock* gt_rwlock_new(void)
{
  GtRWLock *rwlock;
  GT_UNUSED int rval;
  /* XXX: can we use gt_malloc() here? */
  rwlock = thread_xmalloc(sizeof (pthread_rwlock_t), __FILE__, __LINE__);
  /* initialize read/write lock with default attributes */
  rval = pthread_rwlock_init((pthread_rwlock_t*) rwlock, NULL);
  gt_assert(!rval);
  return rwlock;
}

// Assembly:
pushq %rbx
movl $0x38, %edi
movl $0x48, %esi
callq 0x3cf5e
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0xb480
testl %eax, %eax
jne 0x3cf59
movq %rbx, %rax
popq %rbx
retq
callq 0xe72b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/thread.c
// Function: gt_rwlock_delete
void gt_rwlock_delete(GtRWLock *rwlock)
{
  GT_UNUSED int rval;
  if (!rwlock) return;
  rval = pthread_rwlock_destroy((pthread_rwlock_t*) rwlock);
  gt_assert(!rval);
  free(rwlock);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3cf9e
movq %rdi, %rbx
callq 0xba90
testl %eax, %eax
jne 0x3cfa0
movq %rbx, %rdi
popq %rbx
jmp 0xb790
popq %rbx
retq
callq 0xe7c0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/thread.c
// Function: gt_rwlock_rdlock_func
void gt_rwlock_rdlock_func(GtRWLock *rwlock)
{
  GT_UNUSED int rval;
  gt_assert(rwlock);
  rval = pthread_rwlock_rdlock((pthread_rwlock_t*) rwlock);
  gt_assert(!rval);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3cfb6
callq 0xb5d0
testl %eax, %eax
jne 0x3cfbb
popq %rax
retq
callq 0xe82e
callq 0xe7f7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/thread.c
// Function: gt_rwlock_wrlock_func
void gt_rwlock_wrlock_func(GtRWLock *rwlock)
{
  GT_UNUSED int rval;
  gt_assert(rwlock);
  rval = pthread_rwlock_wrlock((pthread_rwlock_t*) rwlock);
  gt_assert(!rval);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3cfd1
callq 0xb950
testl %eax, %eax
jne 0x3cfd6
popq %rax
retq
callq 0xe89c
callq 0xe865
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/thread.c
// Function: gt_rwlock_unlock_func
void gt_rwlock_unlock_func(GtRWLock *rwlock)
{
  GT_UNUSED int rval;
  gt_assert(rwlock);
  rval = pthread_rwlock_unlock((pthread_rwlock_t*) rwlock);
  gt_assert(!rval);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3cfec
callq 0xb800
testl %eax, %eax
jne 0x3cff1
popq %rax
retq
callq 0xe90a
callq 0xe8d3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/thread.c
// Function: gt_mutex_new
GtMutex* gt_mutex_new(void)
{
  GtMutex *mutex;
  GT_UNUSED int rval;
  /* XXX: can we use gt_malloc() here? */
  mutex = thread_xmalloc(sizeof (pthread_mutex_t), __FILE__, __LINE__);
  /* initialize mutex with default attributes */
  rval = pthread_mutex_init((pthread_mutex_t*) mutex, NULL);
  gt_assert(!rval);
  return mutex;
}

// Assembly:
pushq %rbx
movl $0x28, %edi
movl $0x75, %esi
callq 0x3cf5e
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0xb930
testl %eax, %eax
jne 0x3d01c
movq %rbx, %rax
popq %rbx
retq
callq 0xe941
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/thread.c
// Function: gt_mutex_delete
void gt_mutex_delete(GtMutex *mutex)
{
  GT_UNUSED int rval;
  if (!mutex) return;
  rval = pthread_mutex_destroy((pthread_mutex_t*) mutex);
  gt_assert(!rval);
  free(mutex);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3d03c
movq %rdi, %rbx
callq 0xb750
testl %eax, %eax
jne 0x3d03e
movq %rbx, %rdi
popq %rbx
jmp 0xb790
popq %rbx
retq
callq 0xe978
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/thread.c
// Function: gt_mutex_lock_func
void gt_mutex_lock_func(GtMutex *mutex)
{
  GT_UNUSED int rval;
  gt_assert(mutex);
  rval = pthread_mutex_lock((pthread_mutex_t*) mutex);
  gt_assert(!rval);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3d054
callq 0xb920
testl %eax, %eax
jne 0x3d059
popq %rax
retq
callq 0xe9ea
callq 0xe9b1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/thread.c
// Function: gt_mutex_unlock_func
void gt_mutex_unlock_func(GtMutex *mutex)
{
  GT_UNUSED int rval;
  gt_assert(mutex);
  rval = pthread_mutex_unlock((pthread_mutex_t*) mutex);
  gt_assert(!rval);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3d06f
callq 0xb470
testl %eax, %eax
jne 0x3d074
popq %rax
retq
callq 0xea5c
callq 0xea23
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/versionfunc.c
// Function: gt_versionfunc
void gt_versionfunc(const char *progname)
{
  printf("%s (GenomeTools) %s\n", progname, GT_VERSION);
  printf("Copyright (c) 2003-2023 G. Gremme, S. Steinbiss, S. Kurtz, and "
         "CONTRIBUTORS\n");
  printf("Copyright (c) 2003-2023 Center for Bioinformatics, University of "
         "Hamburg\n");
  printf("See LICENSE file or http://genometools.org/license.html for license "
         "details.\n\n");
  printf("Used compiler: %s\n", GT_CC);
  printf("Compile flags: %s\n", GT_CFLAGS);
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0xa6c84(%rip), %rdi     # 0xe3d1f
leaq 0xa4ada(%rip), %rdx     # 0xe1b7c
xorl %eax, %eax
callq 0xb070
leaq 0xa6db0(%rip), %rdi     # 0xe3e60
callq 0xb9c0
leaq 0xa6df0(%rip), %rdi     # 0xe3eac
callq 0xb9c0
leaq 0xa6e2d(%rip), %rdi     # 0xe3ef5
callq 0xb9c0
leaq 0xa6c60(%rip), %rdi     # 0xe3d34
leaq 0xa6c6c(%rip), %rsi     # 0xe3d47
xorl %eax, %eax
callq 0xb070
leaq 0xa6ccc(%rip), %rdi     # 0xe3db5
leaq 0xa6cd8(%rip), %rsi     # 0xe3dc8
xorl %eax, %eax
popq %rcx
jmp 0xb070
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/xansi.c
// Function: gt_xfgetc
int gt_xfgetc(FILE *stream)
{
  int cc;
  if ((cc = fgetc(stream)) == EOF) {
    if (ferror(stream)) {
      perror("cannot read char");
      exit(EXIT_FAILURE);
    }
  }
  return cc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xb9e0
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x3d236
movq %r14, %rdi
callq 0xbc30
testl %eax, %eax
jne 0x3d240
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xeb13
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/xansi.c
// Function: gt_xfgets
char* gt_xfgets(char *s, int size, FILE *stream)
{
  char *str;
  if ((str = fgets(s, size, stream)) == NULL) {
    if (ferror(stream)) {
      perror("cannot read string");
      exit(EXIT_FAILURE);
    }
  }
  return str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0xb9f0
movq %rax, %r14
testq %rax, %rax
jne 0x3d265
movq %rbx, %rdi
callq 0xbc30
testl %eax, %eax
jne 0x3d270
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xeb28
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/xansi.c
// Function: gt_xfputs
void gt_xfputs(const char *str, FILE *stream)
{
  gt_assert(str);
  if (fputs(str, stream) == EOF) {
    perror("cannot fputs to stream");
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3d2c2
callq 0xb730
cmpl $-0x1, %eax
je 0x3d2c7
popq %rax
retq
callq 0xebb8
callq 0xeba3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/xansi.c
// Function: gt_xfread
size_t gt_xfread(void *ptr, size_t size, size_t nmemb, FILE *stream)
{
  size_t rval;
  if ((rval = fread(ptr, size, nmemb, stream)) < nmemb) {
    if (ferror(stream)) {
      perror("cannot read from stream");
      exit(EXIT_FAILURE);
    }
  }
  return rval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
callq 0xb940
movq %rax, %r14
cmpq %r15, %rax
jae 0x3d2f0
movq %rbx, %rdi
callq 0xbc30
testl %eax, %eax
jne 0x3d2f9
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xebef
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/xansi.c
// Function: gt_xfwrite
void gt_xfwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
{
  GtUword itemsperblock = (1 << 30) / size,
                itemstowrite = nmemb,
                itemswritten = 0;
  while (itemstowrite >= itemsperblock) {
    if (fwrite((char*) ptr + (size * itemswritten), size,
               itemsperblock, stream) != itemsperblock) {
      perror("cannot write to stream");
      exit(EXIT_FAILURE);
    }
    itemstowrite -= itemsperblock;
    itemswritten += itemsperblock;
  }
  if (itemstowrite > 0) {
    if (fwrite((char*)ptr + (size * itemswritten), size,
               itemstowrite, stream) != itemstowrite) {
      perror("cannot write to stream");
      exit(EXIT_FAILURE);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorl %ebp, %ebp
movl $0x40000000, %eax       # imm = 0x40000000
xorl %edx, %edx
divq %rsi
cmpq %rbx, %rax
ja 0x3d375
movq %rax, %r13
xorl %ebp, %ebp
movq %rbp, %rdi
imulq %r15, %rdi
addq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xbcb0
cmpq %r13, %rax
jne 0x3d3a6
subq %r13, %rbx
addq %r13, %rbp
cmpq %r13, %rbx
jae 0x3d34d
testq %rbx, %rbx
je 0x3d397
imulq %r15, %rbp
addq %rbp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xbcb0
cmpq %rbx, %rax
jne 0x3d3ab
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xec2e
callq 0xec43
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/yarandom.c
// Function: gt_ya_random
unsigned int
gt_ya_random (void)
{
  register int ret;
  gt_mutex_lock(mutex);
  ret = a[i1] + a[i2];
  a[i1] = ret;
  if (++i1 >= VectorSize) i1 = 0;
  if (++i2 >= VectorSize) i2 = 0;
  gt_mutex_unlock(mutex);
  return ret;
}

// Assembly:
pushq %rbx
movq 0x115604(%rip), %rdi    # 0x152a30
callq 0x3d043
movslq 0x1156e4(%rip), %rax    # 0x152b1c
leaq 0x115601(%rip), %rcx    # 0x152a40
movslq 0x1156da(%rip), %rdx    # 0x152b20
movl (%rcx,%rdx,4), %ebx
addl (%rcx,%rax,4), %ebx
leal 0x1(%rax), %esi
xorl %edi, %edi
cmpq $0x36, %rax
cmovgel %edi, %esi
leal 0x1(%rdx), %r8d
cmpq $0x36, %rdx
movl %ebx, (%rcx,%rax,4)
movl %esi, 0x1156b3(%rip)    # 0x152b1c
cmovgel %edi, %r8d
movl %r8d, 0x1156ac(%rip)    # 0x152b20
movq 0x1155b5(%rip), %rdi    # 0x152a30
callq 0x3d05e
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/yarandom.c
// Function: gt_ya_rand_init
unsigned int
gt_ya_rand_init(unsigned int seed)
{
  unsigned int generated_seed;
  int i;
  if (!mutex)
    mutex = gt_mutex_new();
  if (seed == 0)
    {
      struct timeval tp;
      struct timezone tzp;
      gettimeofday(&tp, &tzp);
      /* ignore overflow */
      seed = (999*tp.tv_sec) + (1001*tp.tv_usec) + (1003 * getpid());
    }
  generated_seed = seed;

  /* allow to call gt_ya_rand_init() multiple times */
  for (i = 0; i < VectorSize; i++)
    a[i] = a_source[i];

  a[0] += seed;
  for (i = 1; i < VectorSize; i++)
    {
      seed = a[i-1]*1001 + seed*999;
      a[i] += seed;
    }

  i1 = a[0] % VectorSize;
  i2 = (i1 + 024) % VectorSize;
  return generated_seed;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
cmpq $0x0, 0x11559a(%rip)    # 0x152a30
jne 0x3d4a4
callq 0x3cff6
movq %rax, 0x11558c(%rip)    # 0x152a30
testl %ebx, %ebx
jne 0x3d4d6
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xba20
imull $0x3e7, (%rbx), %eax    # imm = 0x3E7
imull $0x3e9, 0x8(%rbx), %ebp # imm = 0x3E9
addl %eax, %ebp
callq 0xb910
imull $0x3eb, %eax, %ebx      # imm = 0x3EB
addl %ebp, %ebx
leaq 0x115563(%rip), %r14    # 0x152a40
leaq 0xa6c3c(%rip), %rsi     # 0xe4120
movl $0xdc, %edx
movq %r14, %rdi
callq 0xb520
leal -0x147f0c9a(%rbx), %eax
movl %eax, 0x115543(%rip)    # 0x152a40
movl $0x1, %ecx
movl %eax, %esi
movl %ebx, %edx
imull $0x3e9, %esi, %esi      # imm = 0x3E9
imull $0x3e7, %edx, %edx      # imm = 0x3E7
addl %esi, %edx
movl (%r14,%rcx,4), %esi
addl %edx, %esi
movl %esi, (%r14,%rcx,4)
incq %rcx
cmpq $0x37, %rcx
jne 0x3d506
movl %eax, %ecx
imulq $0x29e4129f, %rcx, %rcx # imm = 0x29E4129F
shrq $0x20, %rcx
movl %eax, %edx
subl %ecx, %edx
shrl %edx
addl %ecx, %edx
shrl $0x5, %edx
imull $0x37, %edx, %ecx
movl %eax, %edx
subl %ecx, %edx
movl %edx, 0x1155d0(%rip)    # 0x152b1c
leal 0x14(%rdx), %esi
negl %ecx
cmpl $0x23, %edx
leal -0x23(%rax,%rcx), %eax
cmovbl %esi, %eax
movl %eax, 0x1155bf(%rip)    # 0x152b20
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_create
GtFeatureIndex* gt_feature_index_create(const GtFeatureIndexClass *fic)
{
  GtFeatureIndex *fi;
  gt_assert(fic && fic->size);
  fi = gt_calloc(1, fic->size);
  fi->c_class = fic;
  fi->pvt = gt_calloc(1, sizeof (GtFeatureIndexMembers));
  fi->pvt->lock = gt_rwlock_new();
  return fi;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3d666
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x3d666
leaq 0xa6c08(%rip), %r14     # 0xe4225
movl $0x1, %edi
movq %r14, %rdx
movl $0x68, %ecx
callq 0x359a6
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x10, %esi
movq %r14, %rdx
movl $0x6a, %ecx
callq 0x359a6
movq %rax, 0x8(%r15)
callq 0x3cf33
movq 0x8(%r15), %rcx
movq %rax, 0x8(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xed0b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_ref
GtFeatureIndex* gt_feature_index_ref(GtFeatureIndex *fi)
{
  gt_assert(fi);
  gt_rwlock_wrlock(fi->pvt->lock);
  fi->pvt->reference_count++;
  gt_rwlock_unlock(fi->pvt->lock);
  return fi;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3d695
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq 0x8(%rbx), %rax
incl (%rax)
movq 0x8(%rax), %rdi
callq 0x3cfdb
movq %rbx, %rax
popq %rbx
retq
callq 0xed42
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_delete
void gt_feature_index_delete(GtFeatureIndex *fi)
{
  if (!fi) return;
  gt_rwlock_wrlock(fi->pvt->lock);
  if (fi->pvt->reference_count) {
    fi->pvt->reference_count--;
    gt_rwlock_unlock(fi->pvt->lock);
    return;
  }
  gt_assert(fi->c_class);
  if (fi->c_class->free)
    fi->c_class->free(fi);
  gt_rwlock_unlock(fi->pvt->lock);
  gt_rwlock_delete(fi->pvt->lock);
  gt_free(fi->pvt);
  gt_free(fi);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3d6d1
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq 0x8(%rbx), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x3d6d9
decl %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x3d738
movq 0x60(%rcx), %rcx
testq %rcx, %rcx
je 0x3d6f3
movq %rbx, %rdi
callq *%rcx
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cf83
movq 0x8(%rbx), %rdi
leaq 0xa6b11(%rip), %r14     # 0xe4225
movq %r14, %rsi
movl $0x86, %edx
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x87, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
callq 0xed79
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_add_region_node
int  gt_feature_index_add_region_node(GtFeatureIndex *feature_index,
                                      GtRegionNode *region_node,
                                      GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && region_node);
  gt_rwlock_wrlock(feature_index->pvt->lock);
  ret = feature_index->c_class->add_region_node(feature_index, region_node,
                                                err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3d795
movq %rsi, %r15
testq %rsi, %rsi
je 0x3d795
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3d795
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x8(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xedb2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_add_feature_node
int  gt_feature_index_add_feature_node(GtFeatureIndex *feature_index,
                                       GtFeatureNode *feature_node,
                                       GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && feature_node);
  gt_rwlock_wrlock(feature_index->pvt->lock);
  ret = feature_index->c_class->add_feature_node(feature_index, feature_node,
                                                 err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3d7f2
movq %rsi, %r15
testq %rsi, %rsi
je 0x3d7f2
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3d7f2
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xedeb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_remove_node
int  gt_feature_index_remove_node(GtFeatureIndex *feature_index,
                                  GtFeatureNode *node, GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && node);
  gt_rwlock_wrlock(feature_index->pvt->lock);
  ret = feature_index->c_class->remove_node(feature_index, node, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3d84f
movq %rsi, %r15
testq %rsi, %rsi
je 0x3d84f
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3d84f
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x18(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xee24
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_add_gff3file
int gt_feature_index_add_gff3file(GtFeatureIndex *feature_index,
                                  const char *gff3file, GtError *err)
{
  GtNodeStream *gff3_in_stream;
  GtGenomeNode *gn;
  GtArray *tmp;
  int had_err = 0;
  GtUword i;
  gt_error_check(err);
  gt_assert(feature_index && gff3file);
  tmp = gt_array_new(sizeof (GtGenomeNode*));
  gff3_in_stream = gt_gff3_in_stream_new_unsorted(1, &gff3file);
  while (!(had_err = gt_node_stream_next(gff3_in_stream, &gn, err)) && gn)
    gt_array_add(tmp, gn);
  if (!had_err) {
    GtNodeVisitor *feature_visitor = gt_feature_visitor_new(feature_index);
    for (i=0;i<gt_array_size(tmp);i++) {
      gn = *(GtGenomeNode**) gt_array_get(tmp, i);
      /* no need to lock, add_*_node() is synchronized */
      had_err = gt_genome_node_accept(gn, feature_visitor, NULL);
      gt_assert(!had_err); /* cannot happen */
    }
    gt_node_visitor_delete(feature_visitor);
  }
  gt_node_stream_delete(gff3_in_stream);
  for (i=0;i<gt_array_size(tmp);i++)
    gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(tmp, i));
  gt_array_delete(tmp);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, 0x10(%rsp)
testq %rdx, %rdx
je 0x3d885
movq %r12, %rdi
callq 0x34fea
testb %al, %al
jne 0x3d9c3
testq %r15, %r15
je 0x3d9be
testq %rbx, %rbx
je 0x3d9be
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movl $0x1, %edi
callq 0x425d7
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x48d7c
movl %eax, %ebp
testl %eax, %eax
sete %al
jne 0x3d90b
cmpq $0x0, 0x8(%rsp)
je 0x3d90b
leaq 0x8(%rsp), %r13
movl $0x8, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6f240
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x48d7c
movl %eax, %ebp
testl %eax, %eax
sete %al
jne 0x3d90b
cmpq $0x0, 0x8(%rsp)
jne 0x3d8dc
testb %al, %al
je 0x3d965
movq %r15, %rdi
callq 0x412bf
movq %rax, %r15
movq %rbx, %rdi
callq 0x6f310
testq %rax, %rax
je 0x3d95b
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6f037
movq (%rax), %rdi
movq %rdi, 0x8(%rsp)
movq %r15, %rsi
xorl %edx, %edx
callq 0x41698
testl %eax, %eax
jne 0x3d9b9
incq %r12
movq %rbx, %rdi
callq 0x6f310
cmpq %rax, %r12
jb 0x3d92a
movq %r15, %rdi
callq 0x49206
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x48d02
movq %rbx, %rdi
callq 0x6f310
testq %rax, %rax
je 0x3d9a0
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x4210c
incq %r14
movq %rbx, %rdi
callq 0x6f310
cmpq %rax, %r14
jb 0x3d97d
movq %rbx, %rdi
callq 0x6f768
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xeecf
callq 0xee96
callq 0xee5d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_get_features_for_seqid
GtArray* gt_feature_index_get_features_for_seqid(GtFeatureIndex *fi,
                                                 const char *seqid,
                                                 GtError *err)
{
  GtArray *arr;
  gt_assert(fi && fi->c_class && seqid);
  gt_rwlock_rdlock(fi->pvt->lock);
  arr = fi->c_class->get_features_for_seqid(fi, seqid, err);
  gt_rwlock_unlock(fi->pvt->lock);
  return arr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3da1b
movq %rsi, %r15
testq %rsi, %rsi
je 0x3da1b
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3da1b
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x20(%rax)
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xef08