LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/parseutils.c
// Function: gt_parse_int_line
int gt_parse_int_line(int *int_value, const char *integer,
                      unsigned int line_number, const char *filename,
                      GtError *err)
{
  gt_error_check(err);
  gt_assert(integer && filename);

  if (sscanf(integer, "%d", int_value) != 1) {
    gt_error_set(err, "could not parse integer '%s' on line %u in file '%s'",
              integer, line_number, filename);
    return -1;
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1620c
movq 0x8(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x161d4
jmp 0x1620c
movq 0x19ddfd(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x147e81(%rip), %rsi    # 0x15e066
leaq 0x14845c(%rip), %rdx    # 0x15e648
leaq 0x149a3d(%rip), %rcx    # 0x15fc30
leaq 0x149837(%rip), %r8     # 0x15fa31
movl $0x137, %r9d            # imm = 0x137
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1620e
jmp 0x16210
cmpq $0x0, 0x20(%rsp)
je 0x16220
cmpq $0x0, 0x10(%rsp)
jne 0x16258
movq 0x19ddb1(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x147e35(%rip), %rsi    # 0x15e066
leaq 0x149a0a(%rip), %rdx    # 0x15fc42
leaq 0x1499f1(%rip), %rcx    # 0x15fc30
leaq 0x1497eb(%rip), %r8     # 0x15fa31
movl $0x138, %r9d            # imm = 0x138
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1625a
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x1714e9(%rip), %rsi    # 0x187754
movb $0x0, %al
callq 0xb660
cmpl $0x1, %eax
je 0x162a2
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %r8
leaq 0x1499c5(%rip), %rsi    # 0x15fc56
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x162aa
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/phase.c
// Function: gt_phase_get
GtPhase gt_phase_get(char phase_char)
{
  gt_assert(strchr(GT_PHASE_CHARS, phase_char));
  switch (phase_char) {
    case '0': return GT_PHASE_ZERO;
    case '1': return GT_PHASE_ONE;
    case '2': return GT_PHASE_TWO;
    default : gt_assert(0); /*@fallthrough@*/
    case '.': return GT_PHASE_UNDEFINED;
  }
}

// Assembly:
subq $0x18, %rsp
movb %dil, %al
movb %al, 0x13(%rsp)
movsbl 0x13(%rsp), %esi
leaq 0x1495d9(%rip), %rdi    # 0x15fbe0
callq 0xb1f0
cmpq $0x0, %rax
jne 0x1664a
movq 0x19d9bf(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x147a43(%rip), %rsi    # 0x15e066
leaq 0x149946(%rip), %rdx    # 0x15ff70
leaq 0x149962(%rip), %rcx    # 0x15ff93
leaq 0x149968(%rip), %r8     # 0x15ffa0
movl $0x18, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1664c
movsbl 0x13(%rsp), %eax
addl $-0x2e, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x4, %eax
ja 0x16693
movq 0x8(%rsp), %rax
leaq 0x1498f0(%rip), %rcx    # 0x15ff5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, 0x14(%rsp)
jmp 0x166d5
movl $0x1, 0x14(%rsp)
jmp 0x166d5
movl $0x2, 0x14(%rsp)
jmp 0x166d5
jmp 0x16695
movq 0x19d93c(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1479c0(%rip), %rsi    # 0x15e066
leaq 0x15980e(%rip), %rdx    # 0x16febb
leaq 0x1498df(%rip), %rcx    # 0x15ff93
leaq 0x1498e5(%rip), %r8     # 0x15ffa0
movl $0x1d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
movl $0x3, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/spacepeak.c
// Function: gt_spacepeak_init
void gt_spacepeak_init(void)
{
  gt_assert(!peaklogger);
  peaklogger = malloc(sizeof (GtSpacepeakLogger));
  peaklogger->current = gt_ma_get_space_current();
  peaklogger->max = 0;
  peaklogger->mutex = gt_mutex_new();
}

// Assembly:
pushq %rax
jmp 0x16713
cmpq $0x0, 0x19fbcd(%rip)    # 0x1b62e8
je 0x16755
movq 0x19d8b4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x147938(%rip), %rsi    # 0x15e066
leaq 0x14987c(%rip), %rdx    # 0x15ffb1
leaq 0x149881(%rip), %rcx    # 0x15ffbd
leaq 0x14988c(%rip), %r8     # 0x15ffcf
movl $0x23, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x16757
movl $0x18, %edi
callq 0xbcb8
movq %rax, 0x19fb80(%rip)    # 0x1b62e8
callq 0xdd70
movq %rax, %rcx
movq 0x19fb71(%rip), %rax    # 0x1b62e8
movq %rcx, (%rax)
movq 0x19fb67(%rip), %rax    # 0x1b62e8
movq $0x0, 0x8(%rax)
callq 0x1c240
movq %rax, %rcx
movq 0x19fb50(%rip), %rax    # 0x1b62e8
movq %rcx, 0x10(%rax)
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, 0x19fb3b(%rip)    # 0x1b62e8
jne 0x167e7
movq 0x19d822(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1478a6(%rip), %rsi    # 0x15e066
leaq 0x1497eb(%rip), %rdx    # 0x15ffb2
leaq 0x149816(%rip), %rcx    # 0x15ffe4
leaq 0x1497fa(%rip), %r8     # 0x15ffcf
movl $0x2c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x167e9
movq 0x19faf8(%rip), %rax    # 0x1b62e8
movq 0x10(%rax), %rdi
callq 0x1c340
movq (%rsp), %rcx
movq 0x19fae4(%rip), %rax    # 0x1b62e8
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x19fad7(%rip), %rax    # 0x1b62e8
movq (%rax), %rax
movq 0x19facd(%rip), %rcx    # 0x1b62e8
cmpq 0x8(%rcx), %rax
jbe 0x16836
movq 0x19fac0(%rip), %rax    # 0x1b62e8
movq (%rax), %rcx
movq 0x19fab6(%rip), %rax    # 0x1b62e8
movq %rcx, 0x8(%rax)
movq 0x19faab(%rip), %rax    # 0x1b62e8
movq 0x10(%rax), %rdi
callq 0x1c3e0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, 0x19fa8b(%rip)    # 0x1b62e8
je 0x1686f
movq (%rsp), %rax
movq 0x19fa7e(%rip), %rcx    # 0x1b62e8
cmpq (%rcx), %rax
jbe 0x168a7
movq 0x19d762(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1477e6(%rip), %rsi    # 0x15e066
leaq 0x14976e(%rip), %rdx    # 0x15fff5
leaq 0x149791(%rip), %rcx    # 0x16001f
leaq 0x14973a(%rip), %r8     # 0x15ffcf
movl $0x36, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x168a9
movq 0x19fa38(%rip), %rax    # 0x1b62e8
movq 0x10(%rax), %rdi
callq 0x1c340
movq (%rsp), %rdx
movq 0x19fa24(%rip), %rax    # 0x1b62e8
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq 0x19fa14(%rip), %rax    # 0x1b62e8
movq 0x10(%rax), %rdi
callq 0x1c3e0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x20, %edi
leaq 0x147601(%rip), %rsi    # 0x16050e
movl $0x26, %edx
callq 0xd2e0
movq %rax, (%rsp)
movl $0x1, %esi
leaq 0x1475e7(%rip), %rdx    # 0x16050e
movl $0x27, %ecx
movq %rsi, %rdi
callq 0xd5b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x1, 0x10(%rax)
movq (%rsp), %rax
movl $0x0, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x18f00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x18f9a
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x18fb0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x18fce
cmpq $0x0, 0x18(%rsp)
jne 0x19006
movq 0x19b003(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x145087(%rip), %rsi    # 0x15e066
leaq 0x147560(%rip), %rdx    # 0x160546
leaq 0x147566(%rip), %rcx    # 0x160553
leaq 0x14751a(%rip), %r8     # 0x16050e
movl $0x54, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19008
movq 0x18(%rsp), %rdi
callq 0xb240
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
addq $0x10, %rsi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdx
addq 0x10(%rsp), %rdx
addq $0x1, %rdx
shlq $0x0, %rdx
callq 0x7f2b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
addq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x19099
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movb (%rax), %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
jmp 0x19064
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x190fe
movq 0x19af0b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x144f8f(%rip), %rsi    # 0x15e066
leaq 0x152dd0(%rip), %rdx    # 0x16beae
leaq 0x147438(%rip), %rcx    # 0x16051d
leaq 0x147422(%rip), %r8     # 0x16050e
movl $0x3a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19100
cmpq $0x0, 0x18(%rsp)
jne 0x1911a
movq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x191a7
movq 0x18(%rsp), %rdi
callq 0xb240
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
addq $0x10, %rsi
movq 0x10(%rsp), %rdx
addq $0x1, %rdx
shlq $0x0, %rdx
callq 0x7f2b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x19199
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movb (%rax), %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
jmp 0x19164
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x191ce
cmpq $0x0, 0x8(%rsp)
jne 0x19206
movq 0x19ae03(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x144e87(%rip), %rsi    # 0x15e066
leaq 0x147342(%rip), %rdx    # 0x160528
leaq 0x147347(%rip), %rcx    # 0x160534
leaq 0x14731a(%rip), %r8     # 0x16050e
movl $0x49, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19208
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rsp), %rax
addq 0x8(%rax), %rdx
addq $0x1, %rdx
shlq $0x0, %rdx
callq 0x7f2b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
addq 0x8(%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0xb500
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x192b2
cmpq $0x0, 0x8(%rsp)
jne 0x192ea
movq 0x19ad1f(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x144da3(%rip), %rsi    # 0x15e066
leaq 0x14727c(%rip), %rdx    # 0x160546
leaq 0x147295(%rip), %rcx    # 0x160566
leaq 0x147236(%rip), %r8     # 0x16050e
movl $0x60, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x192ec
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
addq (%rsp), %rdx
addq $0x1, %rdx
shlq $0x0, %rdx
callq 0x7f2b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
addq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xb500
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x193f0
movq 0x19ac19(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x144c9d(%rip), %rsi    # 0x15e066
leaq 0x16a7fe(%rip), %rdx    # 0x183bce
leaq 0x1471a5(%rip), %rcx    # 0x16057c
leaq 0x147130(%rip), %r8     # 0x16050e
movl $0x72, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x193f2
jmp 0x193f4
cmpq $0x9, 0x8(%rsp)
jbe 0x1941d
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x8(%rsp)
jmp 0x193f4
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
addq $0x10, %rsi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdx
movl 0x14(%rsp), %eax
addq %rax, %rdx
addq $0x1, %rdx
shlq $0x0, %rdx
callq 0x7f2b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
addq 0x8(%rcx), %rax
movl 0x14(%rsp), %ecx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x30, %rdx
movb %dl, %cl
movq (%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rsp)
movb %cl, -0x1(%rax)
movq 0x18(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x19472
movl 0x14(%rsp), %eax
movl %eax, %ecx
movq 0x20(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x19520
movq 0x19aae9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x144b6d(%rip), %rsi    # 0x15e066
leaq 0x16a6ce(%rip), %rdx    # 0x183bce
leaq 0x147089(%rip), %rcx    # 0x160590
leaq 0x147000(%rip), %r8     # 0x16050e
movl $0x87, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19522
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x2, %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x1956c
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
addq $0x2, %rdx
shlq $0x0, %rdx
callq 0x7f2b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movb 0xf(%rsp), %dl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, 0x2020(%rsp)
movsd %xmm0, 0x2018(%rsp)
movl %esi, 0x2014(%rsp)
cmpq $0x0, 0x2020(%rsp)
jne 0x19602
movq 0x19aa07(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x144a8b(%rip), %rsi    # 0x15e066
leaq 0x16f38e(%rip), %rdx    # 0x188970
leaq 0x146fba(%rip), %rcx    # 0x1605a3
leaq 0x146f1e(%rip), %r8     # 0x16050e
movl $0x93, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19604
leaq 0x10(%rsp), %rdi
movl 0x2014(%rsp), %ecx
movsd 0x2018(%rsp), %xmm0
movl $0x2000, %esi           # imm = 0x2000
leaq 0x146f97(%rip), %rdx    # 0x1605bc
movb $0x1, %al
callq 0xb9d0
movl %eax, 0xc(%rsp)
cmpl $0x2000, 0xc(%rsp)      # imm = 0x2000
jl 0x19672
movq 0x19a997(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x144a1b(%rip), %rsi    # 0x15e066
leaq 0x146f6f(%rip), %rdx    # 0x1605c1
leaq 0x146f4a(%rip), %rcx    # 0x1605a3
leaq 0x146eae(%rip), %r8     # 0x16050e
movl $0x95, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19674
movq 0x2020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x18fb0
addq $0x2028, %rsp           # imm = 0x2028
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, 0x2020(%rsp)
movsd %xmm0, 0x2018(%rsp)
movl %esi, 0x2014(%rsp)
cmpq $0x0, 0x2020(%rsp)
jne 0x196f2
movq 0x19a917(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14499b(%rip), %rsi    # 0x15e066
leaq 0x16a4fc(%rip), %rdx    # 0x183bce
leaq 0x146ef6(%rip), %rcx    # 0x1605cf
leaq 0x146e2e(%rip), %r8     # 0x16050e
movl $0x9d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x196f4
leaq 0x10(%rsp), %rdi
movl 0x2014(%rsp), %ecx
movsd 0x2018(%rsp), %xmm0
movl $0x2000, %esi           # imm = 0x2000
leaq 0x146ecf(%rip), %rdx    # 0x1605e4
movb $0x1, %al
callq 0xb9d0
movl %eax, 0xc(%rsp)
cmpl $0x2000, 0xc(%rsp)      # imm = 0x2000
jl 0x19762
movq 0x19a8a7(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14492b(%rip), %rsi    # 0x15e066
leaq 0x146e7f(%rip), %rdx    # 0x1605c1
leaq 0x146e86(%rip), %rcx    # 0x1605cf
leaq 0x146dbe(%rip), %r8     # 0x16050e
movl $0x9f, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19764
movq 0x2020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x18fb0
addq $0x2028, %rsp           # imm = 0x2028
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, 0x2020(%rsp)
movl %esi, 0x201c(%rsp)
cmpq $0x0, 0x2020(%rsp)
jne 0x197d9
movq 0x19a830(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1448b4(%rip), %rsi    # 0x15e066
leaq 0x16a415(%rip), %rdx    # 0x183bce
leaq 0x146e29(%rip), %rcx    # 0x1605e9
leaq 0x146d47(%rip), %r8     # 0x16050e
movl $0xa7, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x197db
leaq 0x10(%rsp), %rdi
movl 0x201c(%rsp), %ecx
movl $0x2000, %esi           # imm = 0x2000
leaq 0x16df61(%rip), %rdx    # 0x187754
movb $0x0, %al
callq 0xb9d0
movl %eax, 0xc(%rsp)
cmpl $0x2000, 0xc(%rsp)      # imm = 0x2000
jl 0x19840
movq 0x19a7c9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14484d(%rip), %rsi    # 0x15e066
leaq 0x146da1(%rip), %rdx    # 0x1605c1
leaq 0x146dc2(%rip), %rcx    # 0x1605e9
leaq 0x146ce0(%rip), %r8     # 0x16050e
movl $0xa9, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19842
movq 0x2020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x18fb0
addq $0x2028, %rsp           # imm = 0x2028
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, 0x2020(%rsp)
movl %esi, 0x201c(%rsp)
cmpq $0x0, 0x2020(%rsp)
jne 0x198b9
movq 0x19a750(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1447d4(%rip), %rsi    # 0x15e066
leaq 0x16a335(%rip), %rdx    # 0x183bce
leaq 0x146d5b(%rip), %rcx    # 0x1605fb
leaq 0x146c67(%rip), %r8     # 0x16050e
movl $0xb1, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x198bb
leaq 0x10(%rsp), %rdi
movl 0x201c(%rsp), %ecx
movl $0x2000, %esi           # imm = 0x2000
leaq 0x1455ef(%rip), %rdx    # 0x15eec2
movb $0x0, %al
callq 0xb9d0
movl %eax, 0xc(%rsp)
cmpl $0x2000, 0xc(%rsp)      # imm = 0x2000
jl 0x19920
movq 0x19a6e9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14476d(%rip), %rsi    # 0x15e066
leaq 0x146cc1(%rip), %rdx    # 0x1605c1
leaq 0x146cf4(%rip), %rcx    # 0x1605fb
leaq 0x146c00(%rip), %r8     # 0x16050e
movl $0xb3, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19922
movq 0x2020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x18fb0
addq $0x2028, %rsp           # imm = 0x2028
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x19b00
movq 0x19a509(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14458d(%rip), %rsi    # 0x15e066
leaq 0x16a65a(%rip), %rdx    # 0x18413a
leaq 0x146b6c(%rip), %rcx    # 0x160653
leaq 0x146a20(%rip), %r8     # 0x16050e
movl $0xd2, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19b02
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movsbl 0x1f(%rsp), %esi
callq 0xb1f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x19b4d
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x19b5b
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x19bec
cmpq $0x0, (%rsp)
jne 0x19c24
movq 0x19a3e5(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x144469(%rip), %rsi    # 0x15e066
leaq 0x146a6f(%rip), %rdx    # 0x160673
leaq 0x146a71(%rip), %rcx    # 0x16067c
leaq 0x1468fc(%rip), %r8     # 0x16050e
movl $0xe1, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19c26
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jne 0x19c3e
movl $0x0, 0x14(%rsp)
jmp 0x19ccf
jmp 0x19c40
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x19c55
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0x19c8d
movq 0x19a37c(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x144400(%rip), %rsi    # 0x15e066
leaq 0x146a1a(%rip), %rdx    # 0x160687
leaq 0x146a08(%rip), %rcx    # 0x16067c
leaq 0x146893(%rip), %r8     # 0x16050e
movl $0xe4, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19c8f
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
callq 0xb850
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x19d29
movq 0x19a2e0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x144364(%rip), %rsi    # 0x15e066
leaq 0x1521a5(%rip), %rdx    # 0x16beae
leaq 0x14698c(%rip), %rcx    # 0x16069c
leaq 0x1467f7(%rip), %r8     # 0x16050e
movl $0xed, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x19d2b
movl $0x20, %edi
leaq 0x1467d7(%rip), %rsi    # 0x16050e
movl $0xee, %edx
callq 0xd2e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x7c400
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1afce
jmp 0x1b014
movq (%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x1afe7
movq (%rsp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x1b014
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x145519(%rip), %rsi    # 0x16050e
movl $0x1d8, %edx            # imm = 0x1D8
callq 0xdab0
movq (%rsp), %rdi
leaq 0x145504(%rip), %rsi    # 0x16050e
movl $0x1d9, %edx            # imm = 0x1D9
callq 0xdab0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x10, %edi
leaq 0x14593c(%rip), %rsi    # 0x160969
movl $0x1d, %edx
callq 0xd2e0
movq %rax, (%rsp)
movl $0x8, %edi
callq 0x75ab0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movq (%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x151157(%rip), %rsi    # 0x16c20c
callq 0x834c0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1b0ff
movq 0x198f0a(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x142f8e(%rip), %rsi    # 0x15e066
leaq 0x1455cf(%rip), %rdx    # 0x1606ae
leaq 0x145898(%rip), %rcx    # 0x16097e
leaq 0x14587c(%rip), %r8     # 0x160969
movl $0x30, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1b101
callq 0x18f00
movq %rax, 0x8(%rsp)
callq 0x1b020
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1a150
cmpl $-0x1, %eax
je 0x1b154
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x19940
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x1b180
movq 0x8(%rsp), %rdi
callq 0x19b70
jmp 0x1b115
movq 0x8(%rsp), %rdi
callq 0x1afc0
movq 0x10(%rsp), %rdi
callq 0x83f40
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1b223
cmpq $0x0, 0x18(%rsp)
jne 0x1b25b
movq 0x198dae(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x142e32(%rip), %rsi    # 0x15e066
leaq 0x145759(%rip), %rdx    # 0x160994
leaq 0x145773(%rip), %rcx    # 0x1609b5
leaq 0x145720(%rip), %r8     # 0x160969
movl $0x48, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1b25d
callq 0x18f00
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x19290
movq 0x20(%rsp), %rax
movq (%rax), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1b60a
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x1b642
movq 0x1989c7(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x142a4b(%rip), %rsi    # 0x15e066
leaq 0x1454a3(%rip), %rdx    # 0x160ac5
leaq 0x1454c5(%rip), %rcx    # 0x160aee
leaq 0x145339(%rip), %r8     # 0x160969
movl $0x76, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1b644
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x1b69a
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x75c80
movq (%rax), %rdi
callq 0x1afc0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1b64e
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x76510
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1b796
jmp 0x1b829
movq 0x10(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x1b7b1
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x1b829
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x1b806
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x75c80
movq (%rax), %rdi
callq 0x1afc0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1b7ba
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x770a0
movq 0x10(%rsp), %rdi
leaq 0x14514a(%rip), %rsi    # 0x160969
movl $0x93, %edx
callq 0xdab0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/strand.c
// Function: gt_strand_get
GtStrand gt_strand_get(char strand_char)
{
  switch (strand_char) {
    case '+': return GT_STRAND_FORWARD;
    case '-': return GT_STRAND_REVERSE;
    case '.': return GT_STRAND_BOTH;
    case '?': return GT_STRAND_UNKNOWN;
    default:  return GT_NUM_OF_STRAND_TYPES;
  }
}

// Assembly:
movb %dil, %al
movb %al, -0x5(%rsp)
movsbl -0x5(%rsp), %eax
addl $-0x2b, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rsp)
subl $0x14, %eax
ja 0x1b888
movq -0x10(%rsp), %rax
leaq 0x1452d5(%rip), %rcx    # 0x160b2c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rsp)
jmp 0x1b890
movl $0x1, -0x4(%rsp)
jmp 0x1b890
movl $0x2, -0x4(%rsp)
jmp 0x1b890
movl $0x3, -0x4(%rsp)
jmp 0x1b890
movl $0x4, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/strand.c
// Function: gt_strand_invert
GtStrand gt_strand_invert(GtStrand s) {
  switch (s) {
    case GT_STRAND_FORWARD:
      return GT_STRAND_REVERSE;
    case GT_STRAND_REVERSE:
      return GT_STRAND_FORWARD;
    case GT_STRAND_BOTH:
      return GT_STRAND_BOTH;
    case GT_STRAND_UNKNOWN:
      return GT_STRAND_UNKNOWN;
    default: gt_assert(0);
  }
  return GT_NUM_OF_STRAND_TYPES; /* should not happen */
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x3, %rax
ja 0x1b8f4
movq 0x8(%rsp), %rax
leaq 0x1452bd(%rip), %rcx    # 0x160b80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x14(%rsp)
jmp 0x1b92e
movl $0x0, 0x14(%rsp)
jmp 0x1b92e
movl $0x2, 0x14(%rsp)
jmp 0x1b92e
movl $0x3, 0x14(%rsp)
jmp 0x1b92e
jmp 0x1b8f6
movq 0x1986db(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14275f(%rip), %rsi    # 0x15e066
leaq 0x1545ad(%rip), %rdx    # 0x16febb
leaq 0x14528b(%rip), %rcx    # 0x160ba0
leaq 0x145295(%rip), %r8     # 0x160bb1
movl $0x2a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x1ba24
movq (%rsp), %rax
leaq 0x145227(%rip), %rcx    # 0x160b90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x1b974
cmpl $0x1, 0x10(%rsp)
jne 0x1b9b3
movq 0x198656(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1426da(%rip), %rsi    # 0x15e066
leaq 0x145230(%rip), %rdx    # 0x160bc3
leaq 0x145247(%rip), %rcx    # 0x160be1
leaq 0x145210(%rip), %r8     # 0x160bb1
movl $0x33, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1b9b5
movl $0x0, 0x14(%rsp)
jmp 0x1ba66
jmp 0x1b9c4
cmpl $0x0, 0x10(%rsp)
jne 0x1ba03
movq 0x198606(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14268a(%rip), %rsi    # 0x15e066
leaq 0x14520d(%rip), %rdx    # 0x160bf0
leaq 0x1451f7(%rip), %rcx    # 0x160be1
leaq 0x1451c0(%rip), %r8     # 0x160bb1
movl $0x36, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1ba05
movl $0x1, 0x14(%rsp)
jmp 0x1ba66
jmp 0x1ba5e
cmpl $0x2, 0x10(%rsp)
jne 0x1ba22
movl $0x3, 0x14(%rsp)
jmp 0x1ba66
jmp 0x1ba5e
jmp 0x1ba26
movq 0x1985ab(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14262f(%rip), %rsi    # 0x15e066
leaq 0x15447d(%rip), %rdx    # 0x16febb
leaq 0x14519c(%rip), %rcx    # 0x160be1
leaq 0x145165(%rip), %r8     # 0x160bb1
movl $0x40, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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, 0x19a87f(%rip)    # 0x1b62f8
jne 0x1ba87
callq 0x7d020
movq %rax, 0x19a871(%rip)    # 0x1b62f8
cmpq $0x0, 0x19a871(%rip)    # 0x1b6300
jne 0x1ba9d
callq 0x1c240
movq %rax, 0x19a863(%rip)    # 0x1b6300
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1babc
movq $0x0, 0x10(%rsp)
jmp 0x1bb1e
movq 0x19a83d(%rip), %rdi    # 0x1b6300
callq 0x1c340
movq 0x19a829(%rip), %rdi    # 0x1b62f8
movq 0x8(%rsp), %rsi
callq 0x7d1d0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x1bb09
movq 0x19a80e(%rip), %rdi    # 0x1b62f8
movq 0x8(%rsp), %rsi
callq 0x7d0b0
movq 0x19a7fd(%rip), %rdi    # 0x1b62f8
movq 0x8(%rsp), %rsi
callq 0x7d1d0
movq %rax, (%rsp)
movq 0x19a7f0(%rip), %rdi    # 0x1b6300
callq 0x1c3e0
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0x18f00
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x2710, 0x10(%rsp)     # imm = 0x2710
jae 0x1bca8
movq 0x18(%rsp), %rdi
callq 0x19b70
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x8c3c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x19390
movq 0x18(%rsp), %rdi
callq 0x19940
movq %rax, %rdi
callq 0x1baa0
movq 0x18(%rsp), %rdi
callq 0x19940
movq %rax, %rdi
callq 0x1baa0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x19940
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xb850
cmpl $0x0, %eax
je 0x1bc91
movq 0x198378(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1423fc(%rip), %rsi    # 0x15e066
leaq 0x144fc3(%rip), %rdx    # 0x160c34
leaq 0x144ff7(%rip), %rcx    # 0x160c6f
leaq 0x144fa3(%rip), %r8     # 0x160c22
movl $0x45, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1bc93
jmp 0x1bc95
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1bbdc
movq 0x18(%rsp), %rdi
callq 0x1afc0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1bd23
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x1bceb
jmp 0x1bd23
movq 0x1982e6(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14236a(%rip), %rsi    # 0x15e066
leaq 0x142945(%rip), %rdx    # 0x15e648
leaq 0x144f71(%rip), %rcx    # 0x160c7b
leaq 0x144f78(%rip), %r8     # 0x160c89
movl $0x23, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1bd25
jmp 0x1bd27
cmpq $0x0, 0x28(%rsp)
jne 0x1bd67
movq 0x1982a2(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x142326(%rip), %rsi    # 0x15e066
leaq 0x1501dd(%rip), %rdx    # 0x16bf24
leaq 0x144f2d(%rip), %rcx    # 0x160c7b
leaq 0x144f34(%rip), %r8     # 0x160c89
movl $0x24, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1bd69
movl $0x8, %edi
leaq 0x144f14(%rip), %rsi    # 0x160c89
movl $0x25, %edx
callq 0xd2e0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0xbb70
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x1bdef
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %edi
callq 0xb1b0
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x144ed4(%rip), %rsi    # 0x160c9b
movb $0x0, %al
callq 0xc0d0
movq 0x10(%rsp), %rdi
leaq 0x144eaf(%rip), %rsi    # 0x160c89
movl $0x29, %edx
callq 0xdab0
movq $0x0, 0x30(%rsp)
jmp 0x1bdf9
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x38, %edi
leaq 0x144db9(%rip), %rsi    # 0x160c89
movl $0x48, %edx
callq 0x1bf40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb460
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x1bf30
movq 0x1980d9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14215d(%rip), %rsi    # 0x15e066
leaq 0x142b69(%rip), %rdx    # 0x15ea79
leaq 0x144dac(%rip), %rcx    # 0x160cc3
leaq 0x144d6b(%rip), %r8     # 0x160c89
movl $0x4b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1bf32
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0xbcb8
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0x1bfd2
movq 0x19806a(%rip), %rax    # 0x1b3fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xb060
movl (%rax), %edi
callq 0xb1b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x144dd6(%rip), %rsi    # 0x160d76
movb $0x0, %al
callq 0xb890
movq 0x19802a(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %rcx
leaq 0x14255e(%rip), %rsi    # 0x15e51f
movb $0x0, %al
callq 0xb890
movl $0x1, %edi
callq 0xb780
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1bff3
jmp 0x1c04c
movq 0x10(%rsp), %rdi
callq 0xba50
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x1c040
movq 0x197fc9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14204d(%rip), %rsi    # 0x15e066
leaq 0x142a59(%rip), %rdx    # 0x15ea79
leaq 0x144caa(%rip), %rcx    # 0x160cd1
leaq 0x144c5b(%rip), %r8     # 0x160c89
movl $0x54, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1c042
movq 0x10(%rsp), %rdi
callq 0xb760
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x28, %edi
leaq 0x144a39(%rip), %rsi    # 0x160c89
movl $0x75, %edx
callq 0x1bf40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb8f0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x1c2b0
movq 0x197d59(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x141ddd(%rip), %rsi    # 0x15e066
leaq 0x1427e9(%rip), %rdx    # 0x15ea79
leaq 0x144a94(%rip), %rcx    # 0x160d2b
leaq 0x1449eb(%rip), %r8     # 0x160c89
movl $0x78, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1c2b2
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)