LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/spacepeak.c
// Function: gt_spacepeak_add
void gt_spacepeak_add(GtUword size)
{
  gt_assert(peaklogger);
  gt_mutex_lock(peaklogger->mutex);
  peaklogger->current += size;
  if (peaklogger->current > peaklogger->max)
    peaklogger->max = peaklogger->current;
  gt_mutex_unlock(peaklogger->mutex);
}

// Assembly:
pushq %rbx
movq 0x11d6e2(%rip), %rax    # 0x12f9f8
testq %rax, %rax
je 0x12348
movq %rdi, %rbx
movq 0x10(%rax), %rdi
callq 0x16028
movq 0x11d6ca(%rip), %rax    # 0x12f9f8
addq (%rax), %rbx
movq %rbx, (%rax)
cmpq 0x8(%rax), %rbx
jbe 0x1233e
movq %rbx, 0x8(%rax)
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x1609f
movq 0x11bc69(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb7d0d(%rip), %rsi     # 0xca066
leaq 0xb9c41(%rip), %rdx     # 0xcbfa1
leaq 0xb9c6c(%rip), %rcx     # 0xcbfd3
leaq 0xb9c50(%rip), %r8      # 0xcbfbe
pushq $0x2c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/spacepeak.c
// Function: gt_spacepeak_free
void gt_spacepeak_free(GtUword size)
{
  gt_assert(peaklogger && size <= peaklogger->current);
  gt_mutex_lock(peaklogger->mutex);
  peaklogger->current -= size;
  gt_mutex_unlock(peaklogger->mutex);
}

// Assembly:
pushq %rbx
movq 0x11d672(%rip), %rax    # 0x12f9f8
testq %rax, %rax
je 0x123b0
movq %rdi, %rbx
cmpq %rdi, (%rax)
jb 0x123b0
movq 0x10(%rax), %rdi
callq 0x16028
movq 0x11d655(%rip), %rax    # 0x12f9f8
subq %rbx, (%rax)
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x1609f
movq 0x11bc01(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb7ca5(%rip), %rsi     # 0xca066
leaq 0xb9c1c(%rip), %rdx     # 0xcbfe4
leaq 0xb9c3f(%rip), %rcx     # 0xcc00e
leaq 0xb9be8(%rip), %r8      # 0xcbfbe
pushq $0x36
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/splitter.c
// Function: gt_splitter_split
void gt_splitter_split(GtSplitter *s, char *string, GtUword length,
                       char delimiter)
{

  char *end_of_token, *string_index = string;

  gt_assert(s && string);

  /* splitting */
  while (string_index < string + length &&
         (end_of_token = strchr(string_index, delimiter))) {
    gt_assert(end_of_token);
    *end_of_token = '\0';
    if ((s->num_of_tokens + 1) * sizeof (char*) > s->allocated)
      s->tokens = gt_dynalloc(s->tokens, &s->allocated,
                              (s->num_of_tokens + 1) * sizeof (char*));
    s->tokens[s->num_of_tokens++] = string_index;
    string_index = end_of_token + 1;
  }

  /* save last token */
  if ((s->num_of_tokens + 2) * sizeof (char*) > s->allocated)
    s->tokens = gt_dynalloc(s->tokens, &s->allocated,
                            (s->num_of_tokens + 2) * sizeof (char*));
  s->tokens[s->num_of_tokens++] = string_index;
  s->tokens[s->num_of_tokens]   = NULL;

  gt_assert(s->num_of_tokens);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x125b5
movq %rsi, %r14
testq %rsi, %rsi
je 0x125b5
movq %rdx, %r15
movq %rdi, %rbx
movsbl %cl, %ebp
addq %r14, %r15
leaq 0x10(%rdi), %r12
cmpq %r15, %r14
jae 0x12566
movq %r14, %rdi
movl %ebp, %esi
callq 0xb210
testq %rax, %rax
je 0x12566
movq %rax, %r13
movb $0x0, (%rax)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x8(,%rcx,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x12552
movq %rax, %rdi
movq %r12, %rsi
callq 0x516a0
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %r14, (%rax,%rcx,8)
incq %r13
movq %r13, %r14
jmp 0x12511
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x10(,%rcx,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x1258d
movq %rax, %rdi
movq %r12, %rsi
callq 0x516a0
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %r14, (%rax,%rcx,8)
movq (%rbx), %rax
andq $0x0, (%rax,%rdx,8)
incq %rcx
je 0x125df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x11b9fc(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb7aa0(%rip), %rsi     # 0xca066
leaq 0xb9aca(%rip), %rdx     # 0xcc097
leaq 0xb9acf(%rip), %rcx     # 0xcc0a3
leaq 0xb9aa8(%rip), %r8      # 0xcc083
pushq $0x2c
jmp 0x12607
movq 0x11b9d2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb7a76(%rip), %rsi     # 0xca066
leaq 0xb9b02(%rip), %rdx     # 0xcc0f9
leaq 0xb9aa5(%rip), %rcx     # 0xcc0a3
leaq 0xb9a7e(%rip), %r8      # 0xcc083
pushq $0x41
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/splitter.c
// Function: gt_splitter_split_non_empty
void gt_splitter_split_non_empty(GtSplitter *s, char *string, GtUword length,
                                 char delimiter)
{

  char *end_of_token, *string_index = string;

  gt_assert(s && string);

  /* splitting */
  while (string_index < string + length &&
         (end_of_token = strchr(string_index, delimiter))) {
    gt_assert(end_of_token);
    *end_of_token = '\0';
    /* skip empty token */
    if (end_of_token > string_index) {
      if ((s->num_of_tokens + 2) * sizeof (*s->tokens) > s->allocated)
        s->tokens = gt_dynalloc(s->tokens, &s->allocated,
                                (s->num_of_tokens + 2) * sizeof (*s->tokens));
      s->tokens[s->num_of_tokens++] = string_index;
    }
    string_index = end_of_token + 1;
  }

  /* save last token if not empty*/
  if (string_index < string + length) {
    if ((s->num_of_tokens + 2) * sizeof (*s->tokens) > s->allocated)
      s->tokens = gt_dynalloc(s->tokens, &s->allocated,
                              (s->num_of_tokens + 2) * sizeof (*s->tokens));
    s->tokens[s->num_of_tokens++] = string_index;
  }
  s->tokens[s->num_of_tokens] = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x126ef
movq %rsi, %r14
testq %rsi, %rsi
je 0x126ef
movq %rdx, %r15
movq %rdi, %rbx
addq %r14, %r15
movsbl %cl, %ebp
leaq 0x10(%rdi), %r12
cmpq %r15, %r14
jae 0x1269f
movq %r14, %rdi
movl %ebp, %esi
callq 0xb210
testq %rax, %rax
je 0x126a5
movq %rax, %r13
movb $0x0, (%rax)
cmpq %r14, %rax
jbe 0x12697
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x10(,%rcx,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x1268b
movq %rax, %rdi
movq %r12, %rsi
callq 0x516a0
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %r14, (%rax,%rcx,8)
incq %r13
movq %r13, %r14
jmp 0x12645
movq 0x8(%rbx), %rdx
jmp 0x126d8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x10(,%rcx,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x126cc
movq %rax, %rdi
movq %r12, %rsi
callq 0x516a0
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %r14, (%rax,%rcx,8)
movq (%rbx), %rax
andq $0x0, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x11b8c2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb7966(%rip), %rsi     # 0xca066
leaq 0xb9990(%rip), %rdx     # 0xcc097
leaq 0xb99a7(%rip), %rcx     # 0xcc0b5
leaq 0xb996e(%rip), %r8      # 0xcc083
pushq $0x4a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/str.c
// Function: gt_str_new
GtStr* gt_str_new(void)
{
  GtStr *s = gt_malloc(sizeof *s);      /* create new string object */
  s->cstr = gt_calloc(1, sizeof (char)); /* init string with '\0' */
  s->length = 0;                         /* set the initial length */
  s->allocated = 1;                      /* set allocated space */
  s->reference_count = 0;                /* set reference count */
  return s;                              /* return new string object */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xb8786(%rip), %rbx     # 0xcc4ed
pushq $0x20
popq %rdi
pushq $0x26
popq %rdx
movq %rbx, %rsi
callq 0xccb0
movq %rax, %r14
pushq $0x1
popq %rdi
pushq $0x27
popq %rcx
movq %rdi, %rsi
movq %rbx, %rdx
callq 0xce9a
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
movq $0x1, 0x10(%r14)
andl $0x0, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/str.c
// Function: gt_str_new_cstr
GtStr* gt_str_new_cstr(const char *cstr)
{
  GtStr *s = gt_str_new();
  if (cstr)
    gt_str_append_cstr(s, cstr);
  return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x13d5c
movq %rax, %rbx
testq %r14, %r14
je 0x13dc8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13dd3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13e2d
movq %rsi, %r14
testq %rsi, %rsi
je 0x13e2d
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 0x516a0
movq %rax, (%rbx)
addq 0x8(%rbx), %rax
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
testb %dl, %dl
je 0x13e23
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x13e13
addq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x11a184(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb6228(%rip), %rsi     # 0xca066
leaq 0xb86e0(%rip), %rdx     # 0xcc525
leaq 0xb86e6(%rip), %rcx     # 0xcc532
leaq 0xb869a(%rip), %r8      # 0xcc4ed
pushq $0x54
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x13eb5
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x13ea8
movq %r14, %rdi
callq 0xb260
movq %rax, %r15
movq (%rbx), %rdi
leaq 0x10(%rbx), %rsi
leaq 0x1(%rax), %rdx
callq 0x516a0
movq %rax, (%rbx)
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
testb %dl, %dl
je 0x13eab
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x13e98
xorl %r15d, %r15d
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x11a0fc(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb61a0(%rip), %rsi     # 0xca066
leaq 0xc3bdd(%rip), %rdx     # 0xd7aaa
leaq 0xb8628(%rip), %rcx     # 0xcc4fc
leaq 0xb8612(%rip), %r8      # 0xcc4ed
pushq $0x3a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x13f40
movq %rsi, %r14
testq %rsi, %rsi
je 0x13f40
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 0x516a0
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
movq 0x11a071(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb6115(%rip), %rsi     # 0xca066
leaq 0xb85af(%rip), %rdx     # 0xcc507
leaq 0xb85b4(%rip), %rcx     # 0xcc513
leaq 0xb8587(%rip), %r8      # 0xcc4ed
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x13fc3
movq %rsi, %r15
testq %rsi, %rsi
je 0x13fc3
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rsi
movq (%rdi), %rdi
movq 0x8(%r14), %rax
addq %rax, %rdx
incq %rdx
callq 0x516a0
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
movq 0x119fee(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb6092(%rip), %rsi     # 0xca066
leaq 0xb854a(%rip), %rdx     # 0xcc525
leaq 0xb8563(%rip), %rcx     # 0xcc545
leaq 0xb8504(%rip), %r8      # 0xcc4ed
pushq $0x60
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1407b
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rcx
pushq $0xa
popq %r15
movq %rsi, %rax
cmpq $0xa, %rax
jb 0x1402a
incl %ecx
xorl %edx, %edx
divq %r15
jmp 0x1401b
leaq 0x10(%rbx), %rsi
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movl %ecx, %r12d
leaq (%r12,%rax), %rdx
incq %rdx
callq 0x516a0
movq %rax, (%rbx)
addq 0x8(%rbx), %rax
leaq (%r12,%rax), %rcx
decq %rcx
movq %r14, %rax
xorl %edx, %edx
divq %r15
orb $0x30, %dl
movb %dl, (%rcx)
decq %rcx
cmpq $0x9, %r14
movq %rax, %r14
ja 0x14052
addq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x119f36(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5fda(%rip), %rsi     # 0xca066
leaq 0xd613b(%rip), %rdx     # 0xea1ce
leaq 0xb84c1(%rip), %rcx     # 0xcc55b
leaq 0xb844c(%rip), %r8      # 0xcc4ed
pushq $0x72
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x140f6
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq 0x2(%rcx), %rdx
cmpq 0x10(%rdi), %rdx
jbe 0x140e3
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x516a0
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
movq 0x119ebb(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5f5f(%rip), %rsi     # 0xca066
leaq 0xd60c0(%rip), %rdx     # 0xea1ce
leaq 0xb845a(%rip), %rcx     # 0xcc56f
leaq 0xb83d1(%rip), %r8      # 0xcc4ed
movl $0x87, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x14171
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xb8454(%rip), %rdx     # 0xcc59b
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
movb $0x1, %al
callq 0xba00
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x1419f
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x13dd3
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
movq 0x119e40(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5ee4(%rip), %rsi     # 0xca066
leaq 0xdace5(%rip), %rdx     # 0xeee6e
leaq 0xb83f2(%rip), %rcx     # 0xcc582
leaq 0xb8356(%rip), %r8      # 0xcc4ed
movl $0x93, %r9d
jmp 0x141cb
movq 0x119e12(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5eb6(%rip), %rsi     # 0xca066
leaq 0xb83e9(%rip), %rdx     # 0xcc5a0
leaq 0xb83c4(%rip), %rcx     # 0xcc582
leaq 0xb8328(%rip), %r8      # 0xcc4ed
movl $0x95, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1421a
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xb83d3(%rip), %rdx     # 0xcc5c3
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
movb $0x1, %al
callq 0xba00
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x14248
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x13dd3
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
movq 0x119d97(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5e3b(%rip), %rsi     # 0xca066
leaq 0xd5f9c(%rip), %rdx     # 0xea1ce
leaq 0xb8375(%rip), %rcx     # 0xcc5ae
leaq 0xb82ad(%rip), %r8      # 0xcc4ed
movl $0x9d, %r9d
jmp 0x14274
movq 0x119d69(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5e0d(%rip), %rsi     # 0xca066
leaq 0xb8340(%rip), %rdx     # 0xcc5a0
leaq 0xb8347(%rip), %rcx     # 0xcc5ae
leaq 0xb827f(%rip), %r8      # 0xcc4ed
movl $0x9f, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x142c3
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xd99b9(%rip), %rdx     # 0xedc52
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
xorl %eax, %eax
callq 0xba00
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x142f1
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x13dd3
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
movq 0x119cee(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5d92(%rip), %rsi     # 0xca066
leaq 0xd5ef3(%rip), %rdx     # 0xea1ce
leaq 0xb82e6(%rip), %rcx     # 0xcc5c8
leaq 0xb8204(%rip), %r8      # 0xcc4ed
movl $0xa7, %r9d
jmp 0x1431d
movq 0x119cc0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5d64(%rip), %rsi     # 0xca066
leaq 0xb8297(%rip), %rdx     # 0xcc5a0
leaq 0xb82b8(%rip), %rcx     # 0xcc5c8
leaq 0xb81d6(%rip), %r8      # 0xcc4ed
movl $0xa9, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1436c
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xb6bee(%rip), %rdx     # 0xcaf30
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
xorl %eax, %eax
callq 0xba00
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x1439a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x13dd3
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
movq 0x119c45(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5ce9(%rip), %rsi     # 0xca066
leaq 0xd5e4a(%rip), %rdx     # 0xea1ce
leaq 0xb824f(%rip), %rcx     # 0xcc5da
leaq 0xb815b(%rip), %r8      # 0xcc4ed
movl $0xb1, %r9d
jmp 0x143c6
movq 0x119c17(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5cbb(%rip), %rsi     # 0xca066
leaq 0xb81ee(%rip), %rdx     # 0xcc5a0
leaq 0xb8221(%rip), %rcx     # 0xcc5da
leaq 0xb812d(%rip), %r8      # 0xcc4ed
movl $0xb3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x144f7
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 0x144e7
subq %r14, %rax
jmp 0x144eb
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x119aba(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5b5e(%rip), %rsi     # 0xca066
leaq 0xd622b(%rip), %rdx     # 0xea73a
leaq 0xb811c(%rip), %rcx     # 0xcc632
leaq 0xb7fd0(%rip), %r8      # 0xcc4ed
movl $0xd2, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x145e2
testq %rsi, %rsi
je 0x145e2
cmpq %rsi, %rdi
je 0x145b0
movq (%rdi), %rax
testq %rax, %rax
je 0x145b4
cmpq $0x0, (%rsi)
je 0x145b4
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 0xb880
xorl %eax, %eax
popq %rcx
retq
movq 0x1199fd(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5aa1(%rip), %rsi     # 0xca066
leaq 0xb809a(%rip), %rdx     # 0xcc666
leaq 0xb8088(%rip), %rcx     # 0xcc65b
leaq 0xb7f13(%rip), %r8      # 0xcc4ed
movl $0xe4, %r9d
jmp 0x1460e
movq 0x1199cf(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb5a73(%rip), %rsi     # 0xca066
leaq 0xb8058(%rip), %rdx     # 0xcc652
leaq 0xb805a(%rip), %rcx     # 0xcc65b
leaq 0xb7ee5(%rip), %r8      # 0xcc4ed
movl $0xe1, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x14672
movq %rdi, %rbx
leaq 0xb7ec0(%rip), %rsi     # 0xcc4ed
pushq $0x20
popq %rdi
movl $0xee, %edx
callq 0xccb0
movq %rax, %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq (%rbx), %rdi
callq 0x4f8ae
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
incq %rax
movq %rax, 0x10(%r14)
andl $0x0, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x11993f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb59e3(%rip), %rsi     # 0xca066
leaq 0xc3420(%rip), %rdx     # 0xd7aaa
leaq 0xb7fea(%rip), %rcx     # 0xcc67b
leaq 0xb7e55(%rip), %r8      # 0xcc4ed
movl $0xed, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x152f3
movq %rdi, %rbx
movl 0x18(%rdi), %eax
testl %eax, %eax
je 0x152fb
decl %eax
movl %eax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
leaq 0xb71e8(%rip), %r14     # 0xcc4ed
movq %r14, %rsi
movl $0x1d8, %edx            # imm = 0x1D8
callq 0xd249
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1d9, %edx            # imm = 0x1D9
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0xb7614(%rip), %rsi     # 0xcc948
pushq $0x10
popq %rdi
pushq $0x1d
popq %rdx
callq 0xccb0
movq %rax, %rbx
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, (%rbx)
andl $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc2a97(%rip), %rsi     # 0xd7e05
callq 0x540ec
testq %rax, %rax
je 0x153d1
movq %rax, %rbx
callq 0x13d5c
movq %rax, %r15
callq 0x1532c
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x14814
cmpl $-0x1, %eax
je 0x153b8
movq %r15, %rdi
callq 0x143d2
movq %r14, %rdi
movq %rax, %rsi
callq 0x15407
movq %r15, %rdi
callq 0x1452f
jmp 0x1538b
movq %r15, %rdi
callq 0x152db
movq %rbx, %rdi
callq 0x548ae
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x118be0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb4c84(%rip), %rsi     # 0xca066
leaq 0xb72a4(%rip), %rdx     # 0xcc68d
leaq 0xb756d(%rip), %rcx     # 0xcc95d
leaq 0xb7551(%rip), %r8      # 0xcc948
pushq $0x30
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1543a
testq %rsi, %rsi
je 0x1543a
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x13da9
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rdi
pushq $0x8
popq %rdx
callq 0x4b801
addq $0x10, %rsp
popq %rbx
retq
movq 0x118b77(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb4c1b(%rip), %rsi     # 0xca066
leaq 0xb7521(%rip), %rdx     # 0xcc973
leaq 0xb7525(%rip), %rcx     # 0xcc97e
leaq 0xb74e8(%rip), %r8      # 0xcc948
pushq $0x3f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x154bf
movq %rsi, %r15
testq %rsi, %rsi
je 0x154bf
movq %rdx, %r14
movq %rdi, %rbx
callq 0x13d5c
movq %rsp, %r12
movq %rax, (%r12)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x13f76
movq (%rbx), %rdi
pushq $0x8
popq %rdx
movq %r12, %rsi
callq 0x4b801
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x118af2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb4b96(%rip), %rsi     # 0xca066
leaq 0xb749c(%rip), %rdx     # 0xcc973
leaq 0xb74b6(%rip), %rcx     # 0xcc994
leaq 0xb7463(%rip), %r8      # 0xcc948
pushq $0x48
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x15528
testq %rsi, %rsi
je 0x15528
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1461a
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rdi
pushq $0x8
popq %rdx
callq 0x4b801
addq $0x10, %rsp
popq %rbx
retq
movq 0x118a89(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb4b2d(%rip), %rsi     # 0xca066
leaq 0xb746d(%rip), %rdx     # 0xcc9ad
leaq 0xb7470(%rip), %rcx     # 0xcc9b7
leaq 0xb73fa(%rip), %r8      # 0xcc948
pushq $0x51
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x15672
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x4b988
testq %rbx, %rbx
je 0x15672
cmpq %r14, %rax
jbe 0x15672
movq (%r15), %rdi
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x13e63
movq 0x11893f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb49e3(%rip), %rsi     # 0xca066
leaq 0xb738e(%rip), %rdx     # 0xcca18
leaq 0xb73b9(%rip), %rcx     # 0xcca4a
leaq 0xb72b0(%rip), %r8      # 0xcc948
pushq $0x66
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x156f3
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x4b988
testq %rbx, %rbx
je 0x156f3
cmpq %r14, %rax
jbe 0x156f3
movq (%r15), %rdi
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %r14
movq %rbx, %rdi
callq 0x143d2
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x13e63
movq 0x1188be(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb4962(%rip), %rsi     # 0xca066
leaq 0xb7355(%rip), %rdx     # 0xcca60
leaq 0xb7381(%rip), %rcx     # 0xcca93
leaq 0xb722f(%rip), %r8      # 0xcc948
pushq $0x6e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1577b
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x4b988
cmpq %rbx, %rax
jb 0x1577b
movq %rbx, %r15
movq (%r14), %rdi
callq 0x4b988
movq (%r14), %rdi
cmpq %rax, %r15
jae 0x1576e
movq %r15, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x152db
incq %r15
jmp 0x15749
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4b9d8
movq 0x118836(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb48da(%rip), %rsi     # 0xca066
leaq 0xb7311(%rip), %rdx     # 0xccaa4
leaq 0xb7333(%rip), %rcx     # 0xccacd
leaq 0xb71a7(%rip), %r8      # 0xcc948
pushq $0x76
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x15852
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x1585a
decl %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x4b988
movq (%rbx), %rdi
cmpq %rax, %r14
jae 0x15882
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x152db
incq %r14
jmp 0x1585d
callq 0x4c19d
leaq 0xb70ba(%rip), %rsi     # 0xcc948
movq %rbx, %rdi
movl $0x93, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x15974
movl %esi, %eax
leaq 0xb71e5(%rip), %rcx     # 0xccb08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x1, %edi
movl $0x0, %edi
jne 0x15970
movq 0x11867b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb471f(%rip), %rsi     # 0xca066
leaq 0xb71ed(%rip), %rdx     # 0xccb3b
leaq 0xb7204(%rip), %rcx     # 0xccb59
leaq 0xb71cd(%rip), %r8      # 0xccb29
pushq $0x33
jmp 0x159c6
testl %edi, %edi
je 0x1599e
pushq $0x1
jmp 0x1596f
cmpl $0x2, %edi
jne 0x15970
pushq $0x3
popq %rdi
movl %edi, %eax
popq %rcx
retq
movq 0x11863d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb46e1(%rip), %rsi     # 0xca066
leaq 0xc5cb5(%rip), %rdx     # 0xdb641
leaq 0xb71c6(%rip), %rcx     # 0xccb59
leaq 0xb718f(%rip), %r8      # 0xccb29
pushq $0x40
jmp 0x159c6
movq 0x118613(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb46b7(%rip), %rsi     # 0xca066
leaq 0xb71b2(%rip), %rdx     # 0xccb68
leaq 0xb719c(%rip), %rcx     # 0xccb59
leaq 0xb7165(%rip), %r8      # 0xccb29
pushq $0x36
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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, 0x11a02b(%rip)    # 0x12fa08
jne 0x159eb
callq 0x5005c
movq %rax, 0x11a01d(%rip)    # 0x12fa08
cmpq $0x0, 0x11a01d(%rip)    # 0x12fa10
jne 0x15a01
callq 0x15f7b
movq %rax, 0x11a00f(%rip)    # 0x12fa10
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15a61
movq %rdi, %rbx
movq 0x119ffa(%rip), %rdi    # 0x12fa10
callq 0x16028
movq 0x119fe6(%rip), %rdi    # 0x12fa08
movq %rbx, %rsi
callq 0x5018a
movq %rax, %r14
testq %rax, %rax
jne 0x15a53
movq 0x119fcf(%rip), %rdi    # 0x12fa08
movq %rbx, %rsi
callq 0x500bc
movq 0x119fc0(%rip), %rdi    # 0x12fa08
movq %rbx, %rsi
callq 0x5018a
movq %rax, %r14
movq 0x119fb6(%rip), %rdi    # 0x12fa10
callq 0x1609f
jmp 0x15a64
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x2711, %r15d          # imm = 0x2711
callq 0x13d5c
movq %rax, %rbx
decq %r15
je 0x15b8f
movq %rbx, %rdi
callq 0x1452f
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x58dd2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13ffe
movq %rbx, %rdi
callq 0x143d2
movq %rax, %rdi
callq 0x15a03
movq %rbx, %rdi
callq 0x143d2
movq %rax, %rdi
callq 0x15a03
movq %rax, %r14
movq %rbx, %rdi
callq 0x143d2
movq %r14, %rdi
movq %rax, %rsi
callq 0xb880
testl %eax, %eax
je 0x15af9
movq 0x118458(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb44fc(%rip), %rsi     # 0xca066
leaq 0xb704d(%rip), %rdx     # 0xccbbe
leaq 0xb7081(%rip), %rcx     # 0xccbf9
leaq 0xb702d(%rip), %r8      # 0xccbac
pushq $0x45
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq %rbx, %rdi
callq 0x152db
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x15bc6
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x15c5d
testq %r12, %r12
je 0x15c33
leaq 0xb7041(%rip), %rsi     # 0xccc13
pushq $0x8
popq %rdi
pushq $0x25
popq %rdx
callq 0xccb0
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0xbba0
testl %eax, %eax
je 0x15c24
movl %eax, %edi
callq 0xb1d0
leaq 0xb7023(%rip), %rsi     # 0xccc25
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xc007
leaq 0xb6ffd(%rip), %rsi     # 0xccc13
pushq $0x29
popq %rdx
movq %r14, %rdi
callq 0xd249
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x11837e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb4422(%rip), %rsi     # 0xca066
leaq 0xc1ed5(%rip), %rdx     # 0xd7b20
leaq 0xb6fb3(%rip), %rcx     # 0xccc05
leaq 0xb6fba(%rip), %r8      # 0xccc13
pushq $0x24
jmp 0x15c85
movq 0x118354(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb43f8(%rip), %rsi     # 0xca066
leaq 0xb49e4(%rip), %rdx     # 0xca659
leaq 0xb6f89(%rip), %rcx     # 0xccc05
leaq 0xb6f90(%rip), %r8      # 0xccc13
pushq $0x23
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x15ca9
movq (%rdi), %rdi
xorl %esi, %esi
callq 0xb5b0
testl %eax, %eax
jne 0x15cd3
popq %rax
retq
movq 0x118308(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb43ac(%rip), %rsi     # 0xca066
leaq 0xb4b2d(%rip), %rdx     # 0xca7ee
leaq 0xb6f76(%rip), %rcx     # 0xccc3e
leaq 0xb6f44(%rip), %r8      # 0xccc13
pushq $0x32
jmp 0x15cfb
movq 0x1182de(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb4382(%rip), %rsi     # 0xca066
leaq 0xb4dfc(%rip), %rdx     # 0xcaae7
leaq 0xb6f4c(%rip), %rcx     # 0xccc3e
leaq 0xb6f1a(%rip), %r8      # 0xccc13
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x38
popq %rdi
pushq $0x48
popq %rsi
callq 0x15d61
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0xb480
testl %eax, %eax
jne 0x15d2b
movq %rbx, %rax
popq %rbx
retq
movq 0x118286(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb432a(%rip), %rsi     # 0xca066
leaq 0xb4da4(%rip), %rdx     # 0xcaae7
leaq 0xb6f03(%rip), %rcx     # 0xccc4d
leaq 0xb6ec2(%rip), %r8      # 0xccc13
pushq $0x4b
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/thread.c
// Function: thread_xmalloc
static void* thread_xmalloc(size_t size, const char *filename, int line)
{
  void *p;
  if ((p = malloc(size)) == NULL) {
    fprintf(stderr, "cannot malloc("GT_ZU") memory: %s\n", size,
            strerror(errno));
    fprintf(stderr, "attempted on line %d in file \"%s\"\n", line, filename);
    exit(EXIT_FAILURE);
  }
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0xbce8
testq %rax, %rax
je 0x15d84
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x11822d(%rip), %r12    # 0x12dfb8
movq (%r12), %r15
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0xb6f5e(%rip), %rsi     # 0xccd00
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb8c0
movq (%r12), %rdi
leaq 0xb476a(%rip), %rsi     # 0xca527
leaq 0xb6e4f(%rip), %rcx     # 0xccc13
movl %ebx, %edx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/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 0x15df0
movq %rdi, %rbx
callq 0xba80
testl %eax, %eax
jne 0x15df2
movq %rbx, %rdi
popq %rbx
jmp 0xb790
popq %rbx
retq
movq 0x1181bf(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb4263(%rip), %rsi     # 0xca066
leaq 0xb4cdd(%rip), %rdx     # 0xcaae7
leaq 0xb6e4a(%rip), %rcx     # 0xccc5b
leaq 0xb6dfb(%rip), %r8      # 0xccc13
pushq $0x54
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x15e39
callq 0xb5d0
testl %eax, %eax
jne 0x15e63
popq %rax
retq
movq 0x118178(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb421c(%rip), %rsi     # 0xca066
leaq 0xb6e1b(%rip), %rdx     # 0xccc6c
leaq 0xb6e1b(%rip), %rcx     # 0xccc73
leaq 0xb6db4(%rip), %r8      # 0xccc13
pushq $0x5b
jmp 0x15e8b
movq 0x11814e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb41f2(%rip), %rsi     # 0xca066
leaq 0xb4c6c(%rip), %rdx     # 0xcaae7
leaq 0xb6df1(%rip), %rcx     # 0xccc73
leaq 0xb6d8a(%rip), %r8      # 0xccc13
pushq $0x5d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x15eaa
callq 0xb940
testl %eax, %eax
jne 0x15ed4
popq %rax
retq
movq 0x118107(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb41ab(%rip), %rsi     # 0xca066
leaq 0xb6daa(%rip), %rdx     # 0xccc6c
leaq 0xb6dc0(%rip), %rcx     # 0xccc89
leaq 0xb6d43(%rip), %r8      # 0xccc13
pushq $0x63
jmp 0x15efc
movq 0x1180dd(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb4181(%rip), %rsi     # 0xca066
leaq 0xb4bfb(%rip), %rdx     # 0xcaae7
leaq 0xb6d96(%rip), %rcx     # 0xccc89
leaq 0xb6d19(%rip), %r8      # 0xccc13
pushq $0x65
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x15f1b
callq 0xb800
testl %eax, %eax
jne 0x15f45
popq %rax
retq
movq 0x118096(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb413a(%rip), %rsi     # 0xca066
leaq 0xb6d39(%rip), %rdx     # 0xccc6c
leaq 0xb6d65(%rip), %rcx     # 0xccc9f
leaq 0xb6cd2(%rip), %r8      # 0xccc13
pushq $0x6b
jmp 0x15f6d
movq 0x11806c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb4110(%rip), %rsi     # 0xca066
leaq 0xb4b8a(%rip), %rdx     # 0xcaae7
leaq 0xb6d3b(%rip), %rcx     # 0xccc9f
leaq 0xb6ca8(%rip), %r8      # 0xccc13
pushq $0x6d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x28
popq %rdi
pushq $0x75
popq %rsi
callq 0x15d61
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0xb920
testl %eax, %eax
jne 0x15f9d
movq %rbx, %rax
popq %rbx
retq
movq 0x118014(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb40b8(%rip), %rsi     # 0xca066
leaq 0xb4b32(%rip), %rdx     # 0xcaae7
leaq 0xb6cf9(%rip), %rcx     # 0xcccb5
leaq 0xb6c50(%rip), %r8      # 0xccc13
pushq $0x78
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300