LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_range_min_max
GtOption* gt_option_new_range_min_max(const char *option_str,
                                      const char *description, GtRange *value,
                                      GtRange *default_value,
                                      GtUword min_value,
                                      GtUword max_value)
{
   GtOption *o = gt_option_new_range(option_str, description, value,
                                     default_value);
   o->min_value_set = true;
   o->min_value.ul = min_value;
   o->max_value_set = true;
   o->max_value.ul = max_value;
   return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
callq 0x39643
movw $0x101, 0x4b(%rax)      # imm = 0x101
movq %r14, 0x38(%rax)
movq %rbx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_string
GtOption* gt_option_new_string(const char *option_str, const char *description,
                               GtStr *value, const char *default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_STRING;
  o->default_value.s = default_value;
  gt_str_set(value, default_value);
  return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
callq 0x3921b
movq %rax, %r15
movl $0xc, (%rax)
movq %rbx, 0x20(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c0cc
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_filename
GtOption* gt_option_new_filename(const char *option_str,
                                 const char *description,
                                 GtStr *filename)
{
  GtOption *o = gt_option_new(option_str, description, filename);
  o->option_type = OPTION_FILENAME;
  o->default_value.s = NULL;
  gt_str_reset(filename);
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0x3921b
movq %rax, %r14
movl $0x3, (%rax)
movq $0x0, 0x20(%rax)
movq %rbx, %rdi
callq 0x3c49c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_choice
GtOption* gt_option_new_choice(const char *option_str, const char *description,
                               GtStr *value, const char *default_value,
                               const char **domain)
{
  GtOption *o;
#ifndef NDEBUG
  GtUword in_domain = 1;
  if (default_value) {
    while (domain[in_domain - 1] != NULL) {
      if (domain[in_domain - 1] == default_value) {
        in_domain = 0;
        break;
      }
      in_domain++;
    }
  }
  else
    in_domain = 0;
  gt_assert(!in_domain);
#endif

  o = gt_option_new_string(option_str, description, value, default_value);
  o->option_type = OPTION_CHOICE;
  o->domain = domain;

  return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
testq %rcx, %rcx
je 0x39771
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x397ad
movl $0x1, %eax
cmpq %r14, %rcx
je 0x3976a
movq (%rbx,%rax,8), %rcx
incq %rax
testq %rcx, %rcx
jne 0x39757
jmp 0x3976c
xorl %eax, %eax
testq %rax, %rax
jne 0x397ad
movq %r15, %rdx
callq 0x3921b
movq %rax, %r12
movl $0xc, (%rax)
movq %r14, 0x20(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c0cc
movl $0x1, (%r12)
movq %rbx, 0x30(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xd1b5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_is_mandatory_either
void gt_option_is_mandatory_either(GtOption *o, const GtOption *meo)
{
  gt_assert(o && meo);
  gt_assert(!o->mandatory_either_options);
  o->mandatory_either_options = gt_array_new(sizeof (GtOption*));
  gt_array_add(o->mandatory_either_options, meo);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x3981a
testq %rsi, %rsi
je 0x3981a
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
jne 0x3981f
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x60(%rbx)
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6ec0e
addq $0x10, %rsp
popq %rbx
retq
callq 0xd260
callq 0xd299
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_is_mandatory_either_3
void gt_option_is_mandatory_either_3(GtOption *o, const GtOption *meo_a,
                                     const GtOption *meo_b)
{
  gt_assert(o && meo_a && meo_b);
  gt_assert(!o->mandatory_either_options);
  o->mandatory_either_options = gt_array_new(sizeof (GtOption*));
  gt_array_add(o->mandatory_either_options, meo_a);
  gt_array_add(o->mandatory_either_options, meo_b);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
testq %rdi, %rdi
je 0x39882
testq %rsi, %rsi
je 0x39882
testq %rdx, %rdx
je 0x39882
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
jne 0x39887
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x60(%rbx)
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6ec0e
movq 0x60(%rbx), %rdi
movq %rsp, %rsi
movl $0x8, %edx
callq 0x6ec0e
addq $0x10, %rsp
popq %rbx
retq
callq 0xd2d2
callq 0xd30b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_is_mandatory_either_4
void gt_option_is_mandatory_either_4(GtOption *o, const GtOption *meo_a,
                                     const GtOption *meo_b,
                                     const GtOption *meo_c)
{
  gt_assert(o && meo_a && meo_b);
  gt_assert(!o->mandatory_either_options);
  o->mandatory_either_options = gt_array_new(sizeof (GtOption*));
  gt_array_add(o->mandatory_either_options, meo_a);
  gt_array_add(o->mandatory_either_options, meo_b);
  gt_array_add(o->mandatory_either_options, meo_c);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
testq %rdi, %rdi
je 0x39905
testq %rsi, %rsi
je 0x39905
testq %rdx, %rdx
je 0x39905
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
jne 0x3990a
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x60(%rbx)
leaq 0x18(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6ec0e
movq 0x60(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x6ec0e
movq 0x60(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x6ec0e
addq $0x20, %rsp
popq %rbx
retq
callq 0xd344
callq 0xd37d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_imply
void gt_option_imply(GtOption *o, const GtOption *implied_option)
{
  GtArray *option_array;
  gt_assert(o && implied_option);
  if (!o->implications)
    o->implications = gt_array_new(sizeof (GtArray*));
  option_array = gt_array_new(sizeof (GtOption*));
  gt_array_add(option_array, implied_option);
  gt_array_add(o->implications, option_array);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x3999a
testq %rsi, %rsi
je 0x3999a
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x3995d
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x50(%rbx)
movl $0x8, %edi
callq 0x6e93c
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6ec0e
movq 0x50(%rbx), %rdi
movl $0x8, %edx
movq %r14, %rsi
callq 0x6ec0e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0xd428
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_imply_either_2
void gt_option_imply_either_2(GtOption *o, const GtOption *io1,
                              const GtOption *io2)
{
  GtArray *option_array;
  gt_assert(o && io1 && io2);
  if (!o->implications)
    o->implications = gt_array_new(sizeof (GtArray*));
  option_array = gt_array_new(sizeof (GtOption*));
  gt_array_add(option_array, io1);
  gt_array_add(option_array, io2);
  gt_array_add(o->implications, option_array);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
testq %rdi, %rdi
je 0x39a23
testq %rsi, %rsi
je 0x39a23
testq %rdx, %rdx
je 0x39a23
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x399d6
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x50(%rbx)
movl $0x8, %edi
callq 0x6e93c
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6ec0e
movq (%r14), %rdi
movq %rsp, %rsi
movl $0x8, %edx
callq 0x6ec0e
movq 0x50(%rbx), %rdi
movl $0x8, %edx
movq %r14, %rsi
callq 0x6ec0e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0xd461
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_imply_either_3
void gt_option_imply_either_3(GtOption *o, const GtOption *io1,
                              const GtOption *io2, const GtOption *io3)
{
  GtArray *option_array;
  gt_assert(o && io1 && io2);
  if (!o->implications)
    o->implications = gt_array_new(sizeof (GtArray*));
  option_array = gt_array_new(sizeof (GtOption*));
  gt_array_add(option_array, io1);
  gt_array_add(option_array, io2);
  gt_array_add(option_array, io3);
  gt_array_add(o->implications, option_array);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
testq %rdi, %rdi
je 0x39aca
testq %rsi, %rsi
je 0x39aca
testq %rdx, %rdx
je 0x39aca
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x39a69
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x50(%rbx)
movl $0x8, %edi
callq 0x6e93c
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
leaq 0x18(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6ec0e
movq (%r14), %rdi
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x6ec0e
movq (%r14), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x6ec0e
movq 0x50(%rbx), %rdi
movl $0x8, %edx
movq %r14, %rsi
callq 0x6ec0e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0xd49a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_exclude
void gt_option_exclude(GtOption *o_a, GtOption *o_b)
{
  gt_assert(o_a && o_b);
  if (!o_a->exclusions)
    o_a->exclusions = gt_array_new(sizeof (GtOption*));
  if (!o_b->exclusions)
    o_b->exclusions = gt_array_new(sizeof (GtOption*));
  gt_array_add(o_a->exclusions, o_b);
  gt_array_add(o_b->exclusions, o_a);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x39b5d
testq %rsi, %rsi
je 0x39b5d
cmpq $0x0, 0x58(%rdi)
jne 0x39b04
movl $0x8, %edi
callq 0x6e93c
movq 0x10(%rsp), %rcx
movq %rax, 0x58(%rcx)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x39b23
movl $0x8, %edi
callq 0x6e93c
movq 0x8(%rsp), %rcx
movq %rax, 0x58(%rcx)
leaq 0x10(%rsp), %rbx
movq (%rbx), %rax
movq 0x58(%rax), %rdi
leaq 0x8(%rsp), %r14
movl $0x8, %edx
movq %r14, %rsi
callq 0x6ec0e
movq (%r14), %rax
movq 0x58(%rax), %rdi
movl $0x8, %edx
movq %rbx, %rsi
callq 0x6ec0e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0xd4d3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_parse_spacespec
int gt_option_parse_spacespec(GtUword *maximumspace,
                              const char *optname,
                              const GtStr *memlimit,
                              GtError *err)
{
  int had_err = 0;
  bool match = false;

  had_err = gt_grep(&match, "^[0-9]+(MB|GB)$", gt_str_get(memlimit), err);
  if (had_err || !match)
  {
    gt_error_set(err,"option -%s must have one positive "
                     "integer argument followed by one of "
                     "the keywords MB and GB",optname);
    had_err = -1;
  }
  if (!had_err)
  {
    int readint;
    char buffer[2+1];

    (void) sscanf(gt_str_get(memlimit), "%d%s", &readint, buffer);
    *maximumspace = (GtUword) readint;
    if (strcmp(buffer, "GB") == 0)
    {
      if (sizeof (GtUword) == (size_t) 4 && *maximumspace > 3UL)
      {
        gt_error_set(err,"option -%s: for 32bit binaries one cannot "
                         "specify more than 3 GB as maximum space",optname);
        had_err = -1;
      }
      if (had_err != 1)
      {
        *maximumspace <<= 30;
      }
    } else
    {
      if (strcmp(buffer, "MB") == 0)
      {
        if (sizeof (GtUword) == (size_t) 4 && *maximumspace > 4095UL)
        {
          gt_error_set(err,"option -%s: for 32bit binaries one cannot "
                           "specify more than 4095 MB as maximum space",
                           optname);
          had_err = -1;
        }
        if (!had_err)
        {
          *maximumspace <<= 20;
        }
      }
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r13
movb $0x0, (%r13)
movq %rdx, %rdi
callq 0x3c40b
leaq 0xa8827(%rip), %rsi     # 0xe23e6
movq %r13, %rdi
movq %rax, %rdx
movq %r12, %rcx
callq 0x76504
testl %eax, %eax
jne 0x39bde
cmpb $0x0, (%rsp)
je 0x39bde
xorl %ebp, %ebp
movb $0x1, %r13b
jmp 0x39bfa
leaq 0xa8811(%rip), %rsi     # 0xe23f6
xorl %r13d, %r13d
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %r13b, %r13b
je 0x39c69
movq %r14, %rdi
callq 0x3c40b
leaq 0xa8845(%rip), %rsi     # 0xe2453
leaq 0x4(%rsp), %r14
leaq 0x1(%rsp), %r15
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xb680
movslq (%r14), %rax
movq %rax, (%rbx)
movzwl (%r15), %ecx
xorl $0x4247, %ecx           # imm = 0x4247
movzbl 0x2(%r15), %edx
orw %cx, %dx
je 0x39c5e
movzwl 0x1(%rsp), %ecx
xorl $0x424d, %ecx           # imm = 0x424D
movzbl 0x3(%rsp), %edx
orw %cx, %dx
jne 0x39c69
movl $0x14, %ecx
jmp 0x39c63
movl $0x1e, %ecx
shlq %cl, %rax
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/parseutils.c
// Function: gt_parse_int
int gt_parse_int(int *out, const char *nptr)
{
  long lval;
  char *ep;
  gt_assert(out && nptr);
  errno = 0;
  lval = strtol(nptr, &ep, 10);
  if (nptr[0] == '\0' || *ep != '\0')
    return -1;
  if ((errno == ERANGE && (lval == LONG_MAX || lval == LONG_MIN)) ||
      (lval > INT_MAX || lval < INT_MIN)) {
    return -1;
  }
  *out = lval;
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x39d0e
movq %rsi, %r14
testq %rsi, %rsi
je 0x39d0e
movq %rdi, %rbx
callq 0xb060
movl $0x0, (%rax)
movq %rsp, %rsi
movq %r14, %rdi
movl $0xa, %edx
callq 0xb8a0
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x0, (%r14)
je 0x39d06
movq (%rsp), %rdx
cmpb $0x0, (%rdx)
setne %dl
movslq %ecx, %rsi
cmpq %rcx, %rsi
setne %sil
orb %dl, %sil
jne 0x39d06
movl %ecx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xd662
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/parseutils.c
// Function: gt_parse_uint
int gt_parse_uint(unsigned int *out, const char *nptr)
{
  GtUword ulval;
  char *ep;
  gt_assert(out && nptr);
  errno = 0;
  ulval = strtoul(nptr, &ep, 10);
  if (nptr[0] == '\0' || *ep != '\0')
    return -1;
  if ((errno == ERANGE && ulval == ULONG_MAX) || (ulval > UINT_MAX)) {
    return -1;
  }
  *out = ulval;
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x39d76
movq %rsi, %r14
testq %rsi, %rsi
je 0x39d76
movq %rdi, %rbx
callq 0xb060
movl $0x0, (%rax)
movq %rsp, %rsi
movq %r14, %rdi
movl $0xa, %edx
callq 0xb1c0
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x0, (%r14)
je 0x39d6e
movq (%rsp), %rdx
cmpb $0x0, (%rdx)
setne %dl
movq %rcx, %rsi
shrq $0x20, %rsi
setne %sil
orb %dl, %sil
jne 0x39d6e
movl %ecx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xd699
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/parseutils.c
// Function: gt_parse_word
int gt_parse_word(GtWord *out, const char *nptr)
{
  long lval;
  char *ep;
  gt_assert(out && nptr);
  errno = 0;
  lval = strtol(nptr, &ep, 10);
  if (nptr[0] == '\0' || *ep != '\0')
    return -1;
  if (errno == ERANGE && (lval == LONG_MAX || lval == LONG_MIN))
    return -1;
  *out = lval;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x39e01
movq %rsi, %r14
testq %rsi, %rsi
je 0x39e01
movq %rdi, %rbx
callq 0xb060
movq %rax, %r15
movl $0x0, (%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0xa, %edx
callq 0xb8a0
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x0, (%r14)
je 0x39df7
movq 0x8(%rsp), %rdx
cmpb $0x0, (%rdx)
jne 0x39df7
cmpl $0x22, (%r15)
sete %dl
movabsq $-0x7fffffffffffffff, %rsi # imm = 0x8000000000000001
addq %rcx, %rsi
cmpq $0x2, %rsi
setb %sil
testb %sil, %dl
jne 0x39df7
movq %rcx, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xd6d0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/parseutils.c
// Function: gt_parse_uword
int gt_parse_uword(GtUword *out, const char *nptr)
{
  GtUword ulval;
  char *ep;
  gt_assert(out && nptr);
  errno = 0;
  ulval = strtoul(nptr, &ep, 10);
  if (nptr[0] == '\0' || *ep != '\0')
    return -1;
  if (errno == ERANGE && ulval == ULONG_MAX)
    return -1;
  *out = ulval;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x39e7f
movq %rsi, %r14
testq %rsi, %rsi
je 0x39e7f
movq %rdi, %rbx
callq 0xb060
movq %rax, %r15
movl $0x0, (%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0xa, %edx
callq 0xb1c0
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x0, (%r14)
je 0x39e75
movq 0x8(%rsp), %rdx
cmpb $0x0, (%rdx)
jne 0x39e75
cmpl $0x22, (%r15)
sete %dl
cmpq $-0x1, %rcx
sete %sil
testb %sil, %dl
jne 0x39e75
movq %rcx, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xd707
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/parseutils.c
// Function: gt_parse_double
int gt_parse_double(double *out, const char *nptr)
{
  double dval;
  char *ep;
  gt_assert(out && nptr);
  errno = 0;
  dval = strtod(nptr, &ep);
  if (nptr[0] == '\0' || *ep != '\0')
    return -1;
  if (errno == ERANGE && (dval == 0 || dval == HUGE_VAL || dval == -HUGE_VAL))
    return -1;
  *out = dval;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x39f17
movq %rsi, %r14
testq %rsi, %rsi
je 0x39f17
movq %rdi, %rbx
callq 0xb060
movq %rax, %r15
movl $0x0, (%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xb490
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x0, (%r14)
je 0x39f0d
movq 0x8(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x39f0d
cmpl $0x22, (%r15)
jne 0x39f07
movq %xmm0, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
sete %dl
shlq %rcx
testq %rcx, %rcx
sete %cl
orb %dl, %cl
jne 0x39f0d
movsd 0xa8b1f(%rip), %xmm1    # 0xe2a20
ucomisd %xmm0, %xmm1
jae 0x39f0d
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xd73e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/parseutils.c
// Function: gt_parse_score
int gt_parse_score(bool *score_is_defined, float *score_value,
                   const char *score, unsigned int line_number,
                   const char *filename, GtError *err)
{
  gt_assert(score && filename);
  gt_error_check(err);

  if (strlen(score) == 1 && score[0] == '.')
    *score_is_defined = false;
  else if (sscanf(score, "%f", score_value) != 1) {
    gt_error_set(err, "could not parse score '%s' on line %u in file '%s'",
                 score, line_number, filename);
    return -1;
  }
  else
    *score_is_defined = true;

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x3a2a7
movq %r8, %rbx
testq %r8, %r8
je 0x3a2a7
movq %r9, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
testq %r9, %r9
je 0x3a23f
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x3a2ac
movq %r15, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x3a257
cmpb $0x2e, (%r15)
jne 0x3a257
xorl %ecx, %ecx
jmp 0x3a272
leaq 0xa7be6(%rip), %rsi     # 0xe1e44
movq %r15, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0xb680
movb $0x1, %cl
cmpl $0x1, %eax
jne 0x3a27a
movb %cl, (%r12)
xorl %eax, %eax
jmp 0x3a298
leaq 0xa8832(%rip), %rsi     # 0xe2ab3
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xd7e3
callq 0xd81c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/parseutils.c
// Function: gt_parse_strand
int gt_parse_strand(GtStrand *gt_strand_value, const char *strand,
                    unsigned int line_number, const char *filename,
                    GtError *err)
{
  gt_assert(strand && filename);
  gt_error_check(err);

  if (strlen(strand) != 1) {
    gt_error_set(err, "strand '%s' not one character long on line %u in file "
              "'%s'", strand, line_number, filename);
    *gt_strand_value = GT_STRAND_UNKNOWN;
    return -1;
  }
  if (strspn(strand, GT_STRAND_CHARS) != 1) {
    gt_error_set(err, "strand '%s' on line %u in file '%s' not a valid "
                 "character from the set '%s'", strand, line_number, filename,
                 GT_STRAND_CHARS);
    *gt_strand_value = GT_STRAND_UNKNOWN;
    return -1;
  }
  *gt_strand_value = gt_strand_get(strand[0]);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x3a370
movq %rcx, %r14
testq %rcx, %rcx
je 0x3a370
movq %r8, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
testq %r8, %r8
je 0x3a2ee
movq %r12, %rdi
callq 0x3566a
testb %al, %al
jne 0x3a375
movq %r15, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x3a320
leaq 0xa8841(%rip), %rsi     # 0xe2b44
movq %r15, %rdi
callq 0xb250
cmpq $0x1, %rax
jne 0x3a33b
movsbl (%r15), %edi
callq 0x3d5ec
movl %eax, %ecx
xorl %eax, %eax
jmp 0x3a365
leaq 0xa87e2(%rip), %rsi     # 0xe2b09
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x3559f
jmp 0x3a35b
leaq 0xa8807(%rip), %rsi     # 0xe2b49
leaq 0xa87fb(%rip), %r9      # 0xe2b44
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x3, %ecx
movl %ecx, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xd855
callq 0xd88e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/parseutils.c
// Function: gt_parse_phase
int gt_parse_phase(GtPhase *phase_value, const char *phase,
                   unsigned int line_number, const char *filename, GtError *err)
{
  gt_assert(phase && filename);
  gt_error_check(err);

  if (strlen(phase) != 1) {
    gt_error_set(err, "phase '%s' not one character long on line %u in file "
                 "'%s'", phase, line_number, filename);
    *phase_value = GT_PHASE_UNDEFINED;
    return -1;
  }
  if (strspn(phase, GT_PHASE_CHARS) != 1) {
    gt_error_set(err, "phase '%s' on line %u in file '%s' not a valid "
                "character from the set '%s'", phase, line_number, filename,
                GT_PHASE_CHARS);
    *phase_value = GT_PHASE_UNDEFINED;
    return -1;
  }
  *phase_value = gt_phase_get(phase[0]);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x3a439
movq %rcx, %r14
testq %rcx, %rcx
je 0x3a439
movq %r8, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
testq %r8, %r8
je 0x3a3b7
movq %r12, %rdi
callq 0x3566a
testb %al, %al
jne 0x3a43e
movq %r15, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x3a3e9
leaq 0xa8824(%rip), %rsi     # 0xe2bf0
movq %r15, %rdi
callq 0xb250
cmpq $0x1, %rax
jne 0x3a404
movsbl (%r15), %edi
callq 0x3a5f0
movl %eax, %ecx
xorl %eax, %eax
jmp 0x3a42e
leaq 0xa87c6(%rip), %rsi     # 0xe2bb6
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x3559f
jmp 0x3a424
leaq 0xa87ea(%rip), %rsi     # 0xe2bf5
leaq 0xa87de(%rip), %r9      # 0xe2bf0
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x3, %ecx
movl %ecx, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xd8c7
callq 0xd900
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
testq %r8, %r8
je 0x3a46d
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x3a4c9
testq %r15, %r15
je 0x3a4c4
testq %rbx, %rbx
je 0x3a4c4
leaq 0xca6b9(%rip), %rsi     # 0x104b37
xorl %r13d, %r13d
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xb680
cmpl $0x1, %eax
je 0x3a4b2
leaq 0xa87cc(%rip), %rsi     # 0xe2c66
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xd972
callq 0xd939
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/parseutils.c
// Function: gt_parse_description_range
int gt_parse_description_range(const char *description, GtRange *range)
{
  GtUword i, desclen;
  char *desc, *descptr;
  gt_assert(description && range);
  desc = gt_cstr_dup(description);
  desclen = strlen(desc);
  descptr = desc;
  /* ignore terminal '\n' */
  if (desclen && desc[desclen-1] == '\n') {
    desc[desclen-1] = '\0';
    desclen--;
  }
  /* ignore terminal '\r' */
  if (desclen && desc[desclen-1] == '\r') {
    desc[desclen-1] = '\0';
    desclen--;
  }
  /* find ':' */
  for (i = 0; i < desclen; i++) {
    if (desc[i] == ':')
      break;
  }
  if (i == desclen) {
    /* no ':' found */
    gt_free(descptr);
    return -1;
  }
  desc += i + 1;
  /* find '..' */
  i = 0;
  while (desc[i] != '\0') {
    if (desc[i-1] == '.' && desc[i] == '.')
      break;
    i++;
  }
  if (desc[i] == '\0') {
    /* no '..' found */
    gt_free(descptr);
    return -1;
  }
  /* parse range start */
  gt_assert(desc[i-1] == '.' && desc[i] == '.');
  desc[i-1] = '\0';
  if (gt_parse_uword(&range->start, desc)) {
    /* parsing failed */
    gt_free(descptr);
    return -1;
  }
  /* parse range end */
  desc += i + 1;
  if (gt_parse_uword(&range->end, desc)) {
    /* parsing failed */
    gt_free(descptr);
    return -1;
  }
  gt_free(descptr);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3a5e4
movq %rsi, %r14
testq %rsi, %rsi
je 0x3a5e4
callq 0x722dc
movq %rax, %rbx
movq %rax, %rdi
callq 0xb260
testq %rax, %rax
je 0x3a510
cmpb $0xa, -0x1(%rbx,%rax)
jne 0x3a512
movb $0x0, -0x1(%rbx,%rax)
decq %rax
jmp 0x3a512
xorl %eax, %eax
testq %rax, %rax
je 0x3a528
cmpb $0xd, -0x1(%rbx,%rax)
jne 0x3a52a
movb $0x0, -0x1(%rbx,%rax)
decq %rax
jmp 0x3a52a
xorl %eax, %eax
xorl %ecx, %ecx
testq %rax, %rax
je 0x3a542
cmpb $0x3a, (%rbx,%rcx)
je 0x3a542
incq %rcx
cmpq %rcx, %rax
jne 0x3a531
movq %rax, %rcx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0x15b, %edx            # imm = 0x15B
cmpq %rax, %rcx
je 0x3a5c8
movb 0x1(%rbx,%rcx), %al
movl $0x168, %edx            # imm = 0x168
testb %al, %al
je 0x3a5c8
leaq (%rbx,%rcx), %rsi
incq %rsi
leaq (%rcx,%rbx), %r15
addq $0x2, %r15
cmpb $0x2e, %al
jne 0x3a578
cmpb $0x2e, -0x2(%r15)
je 0x3a584
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x3a56d
jmp 0x3a5c8
cmpb $0x2e, -0x2(%r15)
jne 0x3a5e9
movb $0x0, -0x2(%r15)
movq %r14, %rdi
callq 0x39e0b
movl $0x170, %edx            # imm = 0x170
testl %eax, %eax
jne 0x3a5c8
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x39e0b
xorl %ebp, %ebp
xorl %ecx, %ecx
testl %eax, %eax
setne %bpl
sete %cl
leal (%rcx,%rcx,2), %edx
addl $0x177, %edx            # imm = 0x177
negl %ebp
leaq 0xa8472(%rip), %rsi     # 0xe2a41
movq %rbx, %rdi
callq 0x362a0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xd9ab
callq 0xd9e4
nop
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movl %edi, %ebx
leaq 0xa85f6(%rip), %rdi     # 0xe2bf0
movl $0x5, %edx
movl %ebx, %esi
callq 0xb710
testq %rax, %rax
je 0x3a631
addb $-0x2e, %bl
cmpb $0x5, %bl
jae 0x3a62c
movzbl %bl, %eax
movl $0x1d, %ecx
btl %eax, %ecx
jae 0x3a62c
leaq 0xa8985(%rip), %rcx     # 0xe2fac
movl (%rcx,%rax,4), %eax
popq %rbx
retq
callq 0xda1d
callq 0xda54
nop
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x1183af(%rip)    # 0x152a08
jne 0x3a695
movl $0x18, %edi
callq 0xb810
movq %rax, 0x11839c(%rip)    # 0x152a08
callq 0x363bb
movq 0x118390(%rip), %rcx    # 0x152a08
movq %rax, (%rcx)
movq $0x0, 0x8(%rcx)
callq 0x3d96a
movq 0x118379(%rip), %rcx    # 0x152a08
movq %rax, 0x10(%rcx)
popq %rax
retq
callq 0xda8b
// File: /workspace/github_c_makefile_star2_O1/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 0x118366(%rip), %rax    # 0x152a08
testq %rax, %rax
je 0x3a6d4
movq %rdi, %rbx
movq 0x10(%rax), %rdi
callq 0x3d9b7
movq 0x11834e(%rip), %rax    # 0x152a08
addq (%rax), %rbx
movq %rbx, (%rax)
cmpq 0x8(%rax), %rbx
jbe 0x3a6ca
movq %rbx, 0x8(%rax)
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x3d9d2
callq 0xdac2
// File: /workspace/github_c_makefile_star2_O1/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 0x118327(%rip), %rax    # 0x152a08
testq %rax, %rax
je 0x3a70b
movq %rdi, %rbx
cmpq %rdi, (%rax)
jb 0x3a70b
movq 0x10(%rax), %rdi
callq 0x3d9b7
movq 0x11830a(%rip), %rax    # 0x152a08
subq %rbx, (%rax)
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x3d9d2
callq 0xdaf9
// File: /workspace/github_c_makefile_star2_O1/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 0x3a88e
movq %rsi, %r12
testq %rsi, %rsi
je 0x3a88e
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
jle 0x3a839
movsbl %cl, %ebp
addq %r12, %r14
leaq 0x10(%rbx), %r13
movq %r12, %rdi
movl %ebp, %esi
callq 0xb210
testq %rax, %rax
je 0x3a839
movq %rax, %r15
movb $0x0, (%rax)
movq 0x8(%rbx), %rax
leaq 0x8(,%rax,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x3a819
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x73b98
movq %rax, (%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %r12, (%rax,%rcx,8)
incq %r15
movq %r15, %r12
cmpq %r14, %r15
jb 0x3a7e4
jmp 0x3a83c
movq %r12, %r15
movq 0x8(%rbx), %rax
leaq 0x10(,%rax,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x3a85d
leaq 0x10(%rbx), %rsi
movq (%rbx), %rdi
callq 0x73b98
movq %rax, (%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
incq %rdx
movq %rdx, 0x8(%rbx)
movq %r15, (%rax,%rcx,8)
movq (%rbx), %rax
movq $0x0, (%rax,%rdx,8)
je 0x3a893
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xdb9e
callq 0xdbd5
// File: /workspace/github_c_makefile_star2_O1/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 0x3a97c
movq %rsi, %r14
testq %rsi, %rsi
je 0x3a97c
movq %rdx, %r15
movq %rdi, %rbx
testq %rdx, %rdx
jle 0x3a95e
addq %r14, %r15
movsbl %cl, %ebp
leaq 0x10(%rbx), %r12
movq %r14, %rdi
movl %ebp, %esi
callq 0xb210
testq %rax, %rax
je 0x3a92b
movq %rax, %r13
movb $0x0, (%rax)
cmpq %r14, %rax
jbe 0x3a91e
movq 0x8(%rbx), %rax
leaq 0x10(,%rax,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x3a90b
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x73b98
movq %rax, (%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %r14, (%rax,%rcx,8)
incq %r13
movq %r13, %r14
cmpq %r15, %r13
jb 0x3a8d1
jmp 0x3a95e
movq 0x8(%rbx), %rax
leaq 0x10(,%rax,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x3a94b
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x73b98
movq %rax, (%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %r14, (%rax,%rcx,8)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xdc0c
// File: /workspace/github_c_makefile_star2_O1/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 0xa7525(%rip), %rbx     # 0xe3510
movl $0x20, %edi
movq %rbx, %rsi
movl $0x26, %edx
callq 0x35ee2
movq %rax, %r14
movl $0x1, %edi
movl $0x1, %esi
movq %rbx, %rdx
movl $0x27, %ecx
callq 0x3601f
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movq $0x1, 0x10(%r14)
movl $0x0, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3bfe0
movq %rax, %rbx
testq %r14, %r14
je 0x3c05c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c067
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3c0c7
movq %rsi, %r14
testq %rsi, %rsi
je 0x3c0c7
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 0x73b98
movq %rax, (%rbx)
movb (%r14), %cl
testb %cl, %cl
je 0x3c0bd
addq 0x8(%rbx), %rax
xorl %edx, %edx
movb %cl, (%rax,%rdx)
movb 0x1(%r14,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x3c0ae
addq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0xdd58
// File: /workspace/github_c_makefile_star2_O1/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 0x3c126
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3c119
movq %r14, %rdi
callq 0xb260
movq %rax, %r15
movq (%rbx), %rdi
leaq 0x10(%rbx), %rsi
leaq 0x1(%rax), %rdx
callq 0x73b98
movq %rax, (%rbx)
movb (%r14), %cl
testb %cl, %cl
je 0x3c11c
xorl %edx, %edx
movb %cl, (%rax,%rdx)
movb 0x1(%r14,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x3c108
jmp 0x3c11c
xorl %r15d, %r15d
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0xdd8f
// File: /workspace/github_c_makefile_star2_O1/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 0x3c180
movq %rsi, %r14
testq %rsi, %rsi
je 0x3c180
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 0x73b98
movq %rax, (%rbx)
addq 0x8(%rbx), %rax
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0xb520
movq 0x8(%r14), %rax
addq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xddc6
// File: /workspace/github_c_makefile_star2_O1/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 0x3c1d2
movq %rsi, %r15
testq %rsi, %rsi
je 0x3c1d2
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rsi
movq (%rdi), %rdi
movq 0x8(%r14), %rax
addq %rax, %rdx
incq %rdx
callq 0x73b98
movq %rax, (%r14)
addq 0x8(%r14), %rax
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xb520
addq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
callq 0xddfd
// File: /workspace/github_c_makefile_star2_O1/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 0x3c288
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %r12d
movabsq $-0x3333333333333333, %r15 # imm = 0xCCCCCCCCCCCCCCCD
cmpq $0xa, %rsi
jb 0x3c229
movl $0x1, %esi
movq %r14, %rcx
incl %esi
movq %rcx, %rax
mulq %r15
shrq $0x3, %rdx
cmpq $0x63, %rcx
movq %rdx, %rcx
ja 0x3c211
movl %esi, %r12d
leaq 0x10(%rbx), %rsi
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
leaq (%r12,%rax), %rdx
incq %rdx
callq 0x73b98
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
addq %r12, %rcx
addq %rax, %rcx
decq %rcx
movq %r14, %rax
mulq %r15
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %r14d, %esi
subl %eax, %esi
orb $0x30, %sil
movb %sil, (%rcx)
decq %rcx
cmpq $0x9, %r14
movq %rdx, %r14
ja 0x3c250
addq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xde34
// File: /workspace/github_c_makefile_star2_O1/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 0x3c2d2
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rdx
addq $0x2, %rdx
cmpq 0x10(%rdi), %rdx
jbe 0x3c2b8
leaq 0x10(%r14), %rsi
movq (%r14), %rdi
callq 0x73b98
movq %rax, (%r14)
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb %bl, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xde6b
// File: /workspace/github_c_makefile_star2_O1/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 0x3c31a
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xa72ce(%rip), %rdx     # 0xe35be
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
movb $0x1, %al
callq 0xba10
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x3c31f
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3c067
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
callq 0xdedd
callq 0xdea4
// File: /workspace/github_c_makefile_star2_O1/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 0x3c367
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xa72a9(%rip), %rdx     # 0xe35e6
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
movb $0x1, %al
callq 0xba10
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x3c36c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3c067
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
callq 0xdf4f
callq 0xdf16
// File: /workspace/github_c_makefile_star2_O1/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 0x3c3b4
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xc87ad(%rip), %rdx     # 0x104b37
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
xorl %eax, %eax
callq 0xba10
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x3c3b9
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3c067
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
callq 0xdfc1
callq 0xdf88
// File: /workspace/github_c_makefile_star2_O1/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 0x3c401
movl %esi, %ecx
movq %rdi, %rbx
leaq 0xa5b59(%rip), %rdx     # 0xe1f30
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
xorl %eax, %eax
callq 0xba10
cmpl $0x2000, %eax           # imm = 0x2000
jge 0x3c406
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3c067
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
retq
callq 0xe033
callq 0xdffa
// File: /workspace/github_c_makefile_star2_O1/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 0x3c497
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 0x3c487
subq %r14, %rax
jmp 0x3c48b
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xe117
// File: /workspace/github_c_makefile_star2_O1/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 0x3c4f6
testq %rsi, %rsi
je 0x3c4f6
cmpq %rsi, %rdi
je 0x3c4ed
movq (%rdi), %rax
testq %rax, %rax
je 0x3c4f1
cmpq $0x0, (%rsi)
je 0x3c4f1
movq 0x8(%rdi), %rcx
xorl %edx, %edx
movb %dl, (%rax,%rcx)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movb %dl, (%rax,%rcx)
movq (%rdi), %rdi
movq (%rsi), %rsi
popq %rax
jmp 0xb890
xorl %eax, %eax
popq %rcx
retq
callq 0xe1c2
callq 0xe189