LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_double
GtOption* gt_option_new_double(const char *option_str, const char *description,
                               double *value, double default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_DOUBLE;
  o->default_value.d = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
callq 0x389d7
movl $0x2, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_int
GtOption* gt_option_new_int(const char *option_str, const char *description,
                            int *value, int default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_INT;
  o->default_value.i = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
callq 0x389d7
movl $0x7, (%rax)
movl %ebx, 0x20(%rax)
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_int_min
GtOption* gt_option_new_int_min(const char *option_str, const char *description,
                                int *value, int default_value, int min_value)
{
  GtOption *o = gt_option_new_int(option_str, description, value,
                                  default_value);
  o->min_value_set = true;
  o->min_value.i = min_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
callq 0x389d7
movl $0x7, (%rax)
movl %ebp, 0x20(%rax)
movl %ebp, (%r14)
movb $0x1, 0x4b(%rax)
movl %ebx, 0x38(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_int_max
GtOption* gt_option_new_int_max(const char *option_str, const char *description,
                                int *value, int default_value, int max_value)
{
  GtOption *o = gt_option_new_int(option_str, description, value,
                                  default_value);
  o->max_value_set = true;
  o->max_value.i = max_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
callq 0x389d7
movl $0x7, (%rax)
movl %ebp, 0x20(%rax)
movl %ebp, (%r14)
movb $0x1, 0x4c(%rax)
movl %ebx, 0x40(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_int_min_max
GtOption* gt_option_new_int_min_max(const char *option_str,
                                    const char *description,
                                    int *value, int default_value,
                                    int min_value, int max_value)
{
  GtOption *o = gt_option_new_int(option_str, description, value,
                                  default_value);
  o->min_value_set = true;
  o->min_value.i = min_value;
  o->max_value_set = true;
  o->max_value.i = max_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
callq 0x389d7
movl $0x7, (%rax)
movl %r14d, 0x20(%rax)
movl %r14d, (%r15)
movw $0x101, 0x4b(%rax)      # imm = 0x101
movl %ebp, 0x38(%rax)
movl %ebx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uint
GtOption* gt_option_new_uint(const char *option_str, const char *description,
                             unsigned int *value, unsigned int default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_UINT;
  o->default_value.ui = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
callq 0x389d7
movl $0x8, (%rax)
movl %ebx, 0x20(%rax)
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uint_min
GtOption* gt_option_new_uint_min(const char *option_str,
                                 const char *description,
                                 unsigned int *value,
                                 unsigned int default_value,
                                 unsigned int min_value)
{
  GtOption *o = gt_option_new_uint(option_str, description, value,
                                   default_value);
  o->min_value_set = true;
  o->min_value.ui = min_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
callq 0x389d7
movl $0x8, (%rax)
movl %ebp, 0x20(%rax)
movl %ebp, (%r14)
movb $0x1, 0x4b(%rax)
movl %ebx, 0x38(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uint_max
GtOption* gt_option_new_uint_max(const char *option_str,
                                 const char *description,
                                 unsigned int *value,
                                 unsigned int default_value,
                                 unsigned int max_value)
{
  GtOption *o = gt_option_new_uint(option_str, description, value,
                                   default_value);
  o->max_value_set = true;
  o->max_value.ui = max_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
callq 0x389d7
movl $0x8, (%rax)
movl %ebp, 0x20(%rax)
movl %ebp, (%r14)
movb $0x1, 0x4c(%rax)
movl %ebx, 0x40(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uint_min_max
GtOption *gt_option_new_uint_min_max(const char *option_str,
                                     const char *description,
                                     unsigned int *value,
                                     unsigned int default_value,
                                     unsigned int min_value,
                                     unsigned int max_value)
{
  GtOption *o = gt_option_new_uint(option_str, description, value,
                                   default_value);
  o->min_value_set = true;
  o->min_value.i = min_value;
  o->max_value_set = true;
  o->max_value.i = max_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
callq 0x389d7
movl $0x8, (%rax)
movl %r14d, 0x20(%rax)
movl %r14d, (%r15)
movw $0x101, 0x4b(%rax)      # imm = 0x101
movl %ebp, 0x38(%rax)
movl %ebx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_word
GtOption* gt_option_new_word(const char *option_str, const char *description,
                             GtWord *value, GtWord default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_LONG;
  o->default_value.l = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
callq 0x389d7
movl $0x9, (%rax)
movq %rbx, 0x20(%rax)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uword_min
GtOption* gt_option_new_uword_min(const char *option_str,
                                  const char *description,
                                  GtUword *value,
                                  GtUword default_value,
                                  GtUword min_value)
{
  GtOption *o = gt_option_new_uword(option_str, description, value,
                                    default_value);
  o->min_value_set = true;
  o->min_value.ul = min_value;
  return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
callq 0x389d7
movl $0xa, (%rax)
movq %r14, 0x20(%rax)
movq %r14, (%r15)
movb $0x1, 0x4b(%rax)
movq %rbx, 0x38(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uword_min_max
GtOption *gt_option_new_uword_min_max(const char *option_str,
                                      const char *description,
                                      GtUword *value,
                                      GtUword default_value,
                                      GtUword min_value,
                                      GtUword max_value)
{
  GtOption *o = gt_option_new_uword(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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
callq 0x389d7
movl $0xa, (%rax)
movq %r15, 0x20(%rax)
movq %r15, (%r12)
movw $0x101, 0x4b(%rax)      # imm = 0x101
movq %r14, 0x38(%rax)
movq %rbx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_range
GtOption* gt_option_new_range(const char *option_str, const char *description,
                              GtRange *value, GtRange *default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_RANGE;
  o->default_value.r.start = default_value ? default_value->start
                                           : GT_UNDEF_UWORD;
  o->default_value.r.end   = default_value ? default_value->end
                                           : GT_UNDEF_UWORD;
  value->start = o->default_value.r.start;
  value->end   = o->default_value.r.end;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
callq 0x389d7
movl $0xb, (%rax)
testq %r14, %r14
je 0x38e26
movq (%r14), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%r14), %rdx
jmp 0x38e3c
movq $-0x1, 0x20(%rax)
movq $-0x1, %rcx
movq $-0x1, %rdx
movq %rdx, 0x28(%rax)
movq %rcx, (%rbx)
movq 0x28(%rax), %rcx
movq %rcx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x38dff
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_O3/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 0x389d7
movq %rax, %r15
movl $0xc, (%rax)
movq %rbx, 0x20(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b81e
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x389d7
movq %rax, %r14
movl $0x3, (%rax)
movq $0x0, 0x20(%rax)
movq %rbx, %rdi
callq 0x3bbee
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x38f2e
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x38f6a
movl $0x1, %eax
cmpq %r14, %rcx
je 0x38f2e
movq (%rbx,%rax,8), %rcx
incq %rax
testq %rcx, %rcx
jne 0x38f18
testq %rax, %rax
jne 0x38f6a
movq %r15, %rdx
callq 0x389d7
movq %rax, %r12
movl $0xc, (%rax)
movq %r14, 0x20(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b81e
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_O3/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 0x38fd7
testq %rsi, %rsi
je 0x38fd7
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
jne 0x38fdc
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x60(%rbx)
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6f240
addq $0x10, %rsp
popq %rbx
retq
callq 0xd260
callq 0xd299
// File: /workspace/github_c_makefile_star2_O3/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 0x3903f
testq %rsi, %rsi
je 0x3903f
testq %rdx, %rdx
je 0x3903f
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
jne 0x39044
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x60(%rbx)
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6f240
movq 0x60(%rbx), %rdi
movq %rsp, %rsi
movl $0x8, %edx
callq 0x6f240
addq $0x10, %rsp
popq %rbx
retq
callq 0xd2d2
callq 0xd30b
// File: /workspace/github_c_makefile_star2_O3/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 0x390c2
testq %rsi, %rsi
je 0x390c2
testq %rdx, %rdx
je 0x390c2
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
jne 0x390c7
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x60(%rbx)
leaq 0x18(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6f240
movq 0x60(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x6f240
movq 0x60(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x6f240
addq $0x20, %rsp
popq %rbx
retq
callq 0xd344
callq 0xd37d
// File: /workspace/github_c_makefile_star2_O3/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 0x39157
testq %rsi, %rsi
je 0x39157
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x3911a
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x50(%rbx)
movl $0x8, %edi
callq 0x6ef7c
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6f240
movq 0x50(%rbx), %rdi
movl $0x8, %edx
movq %r14, %rsi
callq 0x6f240
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0xd428
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
testq %rdi, %rdi
je 0x391ea
testq %rsi, %rsi
je 0x391ea
testq %rdx, %rdx
je 0x391ea
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x39196
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x50(%rbx)
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %rax, (%r15)
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6f240
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x6f240
movq 0x50(%rbx), %rdi
movl $0x8, %edx
movq %r15, %rsi
callq 0x6f240
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xd461
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
testq %rdi, %rdi
je 0x39299
testq %rsi, %rsi
je 0x39299
testq %rdx, %rdx
je 0x39299
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x39235
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x50(%rbx)
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %r15
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
movq %rax, %rdi
callq 0x6f240
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %r15, %rdi
callq 0x6f240
movq %rsp, %rsi
movl $0x8, %edx
movq %r15, %rdi
callq 0x6f240
movq 0x50(%rbx), %rdi
movl $0x8, %edx
movq %r14, %rsi
callq 0x6f240
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xd49a
// File: /workspace/github_c_makefile_star2_O3/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 0x39322
movq %rsi, %r14
testq %rsi, %rsi
je 0x39322
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
jne 0x392d9
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %rdi
movq %rax, 0x58(%rbx)
cmpq $0x0, 0x58(%r14)
jne 0x392f2
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x58(%r14)
movq 0x58(%rbx), %rdi
leaq 0x8(%rsp), %rbx
movl $0x8, %edx
movq %rbx, %rsi
callq 0x6f240
movq (%rbx), %rax
movq 0x58(%rax), %rdi
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x6f240
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0xd4d3
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movb $0x0, (%r13)
movq %rdx, %rdi
callq 0x3bb5d
leaq 0xa905e(%rip), %rsi     # 0xe23e6
movq %r13, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0x76a19
testl %eax, %eax
jne 0x39400
cmpb $0x0, 0x8(%rsp)
je 0x39400
movq %r12, %rdi
callq 0x3bb5d
leaq 0xa90a3(%rip), %rsi     # 0xe2453
leaq 0xc(%rsp), %r14
leaq 0x9(%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 0x39427
movzwl 0x9(%rsp), %ecx
xorl $0x424d, %ecx           # imm = 0x424D
movzbl 0xb(%rsp), %edx
orw %cx, %dx
jne 0x39432
movl $0x14, %ecx
jmp 0x3942c
leaq 0xa8fef(%rip), %rsi     # 0xe23f6
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x1e, %ecx
shlq %cl, %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x39419
// File: /workspace/github_c_makefile_star2_O3/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 0x394ca
movq %rsi, %r14
testq %rsi, %rsi
je 0x394ca
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 0x394c2
movq (%rsp), %rdx
cmpb $0x0, (%rdx)
setne %dl
movslq %ecx, %rsi
cmpq %rcx, %rsi
setne %sil
orb %dl, %sil
jne 0x394c2
movl %ecx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xd662
// File: /workspace/github_c_makefile_star2_O3/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 0x39532
movq %rsi, %r14
testq %rsi, %rsi
je 0x39532
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 0x3952a
movq (%rsp), %rdx
cmpb $0x0, (%rdx)
setne %dl
movq %rcx, %rsi
shrq $0x20, %rsi
setne %sil
orb %dl, %sil
jne 0x3952a
movl %ecx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xd699
// File: /workspace/github_c_makefile_star2_O3/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 0x395bd
movq %rsi, %r14
testq %rsi, %rsi
je 0x395bd
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 0x395b3
movq 0x8(%rsp), %rdx
cmpb $0x0, (%rdx)
jne 0x395b3
cmpl $0x22, (%r15)
sete %dl
movabsq $-0x7fffffffffffffff, %rsi # imm = 0x8000000000000001
addq %rcx, %rsi
cmpq $0x2, %rsi
setb %sil
testb %sil, %dl
jne 0x395b3
movq %rcx, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xd6d0
// File: /workspace/github_c_makefile_star2_O3/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 0x3963b
movq %rsi, %r14
testq %rsi, %rsi
je 0x3963b
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 0x39631
movq 0x8(%rsp), %rdx
cmpb $0x0, (%rdx)
jne 0x39631
cmpl $0x22, (%r15)
sete %dl
cmpq $-0x1, %rcx
sete %sil
testb %sil, %dl
jne 0x39631
movq %rcx, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xd707
// File: /workspace/github_c_makefile_star2_O3/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 0x396d3
movq %rsi, %r14
testq %rsi, %rsi
je 0x396d3
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 0x396c9
movq 0x8(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x396c9
cmpl $0x22, (%r15)
jne 0x396c3
movq %xmm0, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
sete %dl
shlq %rcx
testq %rcx, %rcx
sete %cl
orb %dl, %cl
jne 0x396c9
movsd 0xa9363(%rip), %xmm1    # 0xe2a20
ucomisd %xmm0, %xmm1
jae 0x396c9
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xd73e
// File: /workspace/github_c_makefile_star2_O3/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 0x39a3b
movq %r8, %rbx
testq %r8, %r8
je 0x39a3b
movq %r9, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
testq %r9, %r9
je 0x399d3
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x39a40
movq %r15, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x399eb
cmpb $0x2e, (%r15)
jne 0x399eb
xorl %ecx, %ecx
jmp 0x39a06
leaq 0xa8452(%rip), %rsi     # 0xe1e44
movq %r15, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0xb680
movb $0x1, %cl
cmpl $0x1, %eax
jne 0x39a0e
movb %cl, (%r12)
xorl %eax, %eax
jmp 0x39a2c
leaq 0xa909e(%rip), %rsi     # 0xe2ab3
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x34f1f
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_O3/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 0x39b04
movq %rcx, %r14
testq %rcx, %rcx
je 0x39b04
movq %r8, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
testq %r8, %r8
je 0x39a82
movq %r12, %rdi
callq 0x34fea
testb %al, %al
jne 0x39b09
movq %r15, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x39ab4
leaq 0xa90ad(%rip), %rsi     # 0xe2b44
movq %r15, %rdi
callq 0xb250
cmpq $0x1, %rax
jne 0x39acf
movsbl (%r15), %edi
callq 0x3cc78
movl %eax, %ecx
xorl %eax, %eax
jmp 0x39af9
leaq 0xa904e(%rip), %rsi     # 0xe2b09
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x34f1f
jmp 0x39aef
leaq 0xa9073(%rip), %rsi     # 0xe2b49
leaq 0xa9067(%rip), %r9      # 0xe2b44
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x34f1f
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_O3/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 0x39bcd
movq %rcx, %r14
testq %rcx, %rcx
je 0x39bcd
movq %r8, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
testq %r8, %r8
je 0x39b4b
movq %r12, %rdi
callq 0x34fea
testb %al, %al
jne 0x39bd2
movq %r15, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x39b7d
leaq 0xa9090(%rip), %rsi     # 0xe2bf0
movq %r15, %rdi
callq 0xb250
cmpq $0x1, %rax
jne 0x39b98
movsbl (%r15), %edi
callq 0x39d90
movl %eax, %ecx
xorl %eax, %eax
jmp 0x39bc2
leaq 0xa9032(%rip), %rsi     # 0xe2bb6
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x34f1f
jmp 0x39bb8
leaq 0xa9056(%rip), %rsi     # 0xe2bf5
leaq 0xa904a(%rip), %r9      # 0xe2bf0
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x34f1f
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_O3/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 0x39c01
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x39c5d
testq %r15, %r15
je 0x39c58
testq %rbx, %rbx
je 0x39c58
leaq 0xcadc0(%rip), %rsi     # 0x1049d2
xorl %r13d, %r13d
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xb680
cmpl $0x1, %eax
je 0x39c46
leaq 0xa9038(%rip), %rsi     # 0xe2c66
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x34f1f
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_O3/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x39d88
movq %rsi, %r14
testq %rsi, %rsi
je 0x39d88
callq 0x728c0
movq %rax, %rbx
movq %rax, %rdi
callq 0xb260
testq %rax, %rax
je 0x39cd2
movb -0x1(%rbx,%rax), %cl
cmpb $0xa, %cl
jne 0x39ca8
movb $0x0, -0x1(%rbx,%rax)
decq %rax
je 0x39cd2
movb -0x1(%rbx,%rax), %cl
cmpb $0xd, %cl
jne 0x39cb7
movb $0x0, -0x1(%rbx,%rax)
decq %rax
je 0x39cc9
xorl %ecx, %ecx
cmpb $0x3a, (%rbx,%rcx)
je 0x39ccd
incq %rcx
cmpq %rcx, %rax
jne 0x39cb9
jmp 0x39cd2
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rax, %rcx
jne 0x39cf1
leaq 0xa8d68(%rip), %rsi     # 0xe2a41
movq %rbx, %rdi
movl $0x15b, %edx            # imm = 0x15B
callq 0x35c27
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
movb 0x1(%rbx,%rcx), %al
testb %al, %al
je 0x39d1d
leaq (%rbx,%rcx), %rsi
incq %rsi
leaq (%rcx,%rbx), %r15
addq $0x2, %r15
cmpb $0x2e, %al
jne 0x39d13
cmpb $0x2e, -0x2(%r15)
je 0x39d2e
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x39d08
leaq 0xa8d1d(%rip), %rsi     # 0xe2a41
movq %rbx, %rdi
movl $0x168, %edx            # imm = 0x168
jmp 0x39ce1
movb $0x0, -0x2(%r15)
movq %r14, %rdi
callq 0x395c7
testl %eax, %eax
je 0x39d50
leaq 0xa8cfb(%rip), %rsi     # 0xe2a41
movq %rbx, %rdi
movl $0x170, %edx            # imm = 0x170
jmp 0x39ce1
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x395c7
leaq 0xa8cdb(%rip), %rsi     # 0xe2a41
movq %rbx, %rdi
testl %eax, %eax
je 0x39d77
movl $0x177, %edx            # imm = 0x177
jmp 0x39ce1
movl $0x17a, %edx            # imm = 0x17A
callq 0x35c27
xorl %eax, %eax
jmp 0x39ceb
callq 0xd9ab
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xa8e56(%rip), %rdi     # 0xe2bf0
movl $0x5, %edx
movl %ebx, %esi
callq 0xb710
testq %rax, %rax
je 0x39dd1
addb $-0x2e, %bl
cmpb $0x5, %bl
jae 0x39dcc
movzbl %bl, %eax
movl $0x1d, %ecx
btl %eax, %ecx
jae 0x39dcc
leaq 0xa91c5(%rip), %rcx     # 0xe2f8c
movl (%rcx,%rax,4), %eax
popq %rbx
retq
callq 0xd9e4
callq 0xda1b
nop
// File: /workspace/github_c_makefile_star2_O3/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, 0x118c0f(%rip)    # 0x152a08
jne 0x39e35
movl $0x18, %edi
callq 0xb810
movq %rax, 0x118bfc(%rip)    # 0x152a08
callq 0x35d42
movq 0x118bf0(%rip), %rcx    # 0x152a08
movq %rax, (%rcx)
movq $0x0, 0x8(%rcx)
callq 0x3cff6
movq 0x118bd9(%rip), %rcx    # 0x152a08
movq %rax, 0x10(%rcx)
popq %rax
retq
callq 0xda52
// File: /workspace/github_c_makefile_star2_O3/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 0x118bc6(%rip), %rax    # 0x152a08
testq %rax, %rax
je 0x39e74
movq %rdi, %rbx
movq 0x10(%rax), %rdi
callq 0x3d043
movq 0x118bae(%rip), %rax    # 0x152a08
addq (%rax), %rbx
movq %rbx, (%rax)
cmpq 0x8(%rax), %rbx
jbe 0x39e6a
movq %rbx, 0x8(%rax)
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x3d05e
callq 0xda89
// File: /workspace/github_c_makefile_star2_O3/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 0x118b87(%rip), %rax    # 0x152a08
testq %rax, %rax
je 0x39eab
movq %rdi, %rbx
cmpq %rdi, (%rax)
jb 0x39eab
movq 0x10(%rax), %rdi
callq 0x3d043
movq 0x118b6a(%rip), %rax    # 0x152a08
subq %rbx, (%rax)
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x3d05e
callq 0xdac0
// File: /workspace/github_c_makefile_star2_O3/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 0x3a02e
movq %rsi, %r12
testq %rsi, %rsi
je 0x3a02e
movq %rdx, %r15
movq %rdi, %rbx
testq %rdx, %rdx
jle 0x39fd9
movsbl %cl, %ebp
addq %r12, %r15
leaq 0x10(%rbx), %r13
movq %r12, %rdi
movl %ebp, %esi
callq 0xb210
testq %rax, %rax
je 0x39fd9
movq %rax, %r14
movb $0x0, (%rax)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x8(,%rcx,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x39fc0
movq %rax, %rdi
movq %r13, %rsi
callq 0x74134
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %r12, (%rax,%rcx,8)
incq %r14
movq %r14, %r12
cmpq %r15, %r14
jb 0x39f84
jmp 0x39fdc
movq %r12, %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x10(,%rcx,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x3a004
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x74134
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
incq %rdx
movq %rdx, 0x8(%rbx)
movq %r14, (%rax,%rcx,8)
movq (%rbx), %rax
movq $0x0, (%rax,%rdx,8)
je 0x3a033
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xdb65
callq 0xdb9c
// File: /workspace/github_c_makefile_star2_O3/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 0x3a11c
movq %rsi, %r14
testq %rsi, %rsi
je 0x3a11c
movq %rdx, %r15
movq %rdi, %rbx
testq %rdx, %rdx
jle 0x3a0fe
addq %r14, %r15
movsbl %cl, %ebp
leaq 0x10(%rbx), %r12
movq %r14, %rdi
movl %ebp, %esi
callq 0xb210
testq %rax, %rax
je 0x3a0cb
movq %rax, %r13
movb $0x0, (%rax)
cmpq %r14, %rax
jbe 0x3a0be
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x10(,%rcx,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x3a0b2
movq %rax, %rdi
movq %r12, %rsi
callq 0x74134
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %r14, (%rax,%rcx,8)
incq %r13
movq %r13, %r14
cmpq %r15, %r13
jb 0x3a071
jmp 0x3a0fe
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x10(,%rcx,8), %rdx
cmpq 0x10(%rbx), %rdx
jbe 0x3a0f2
movq %rax, %rdi
movq %r12, %rsi
callq 0x74134
movq %rax, (%rbx)
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 0xdbd3
// File: /workspace/github_c_makefile_star2_O3/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 0xa7dba(%rip), %rbx     # 0xe34ed
movl $0x20, %edi
movq %rbx, %rsi
movl $0x26, %edx
callq 0x35862
movq %rax, %r14
movl $0x1, %edi
movl $0x1, %esi
movq %rbx, %rdx
movl $0x27, %ecx
callq 0x359a6
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_O3/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 0x3b728
movq %rax, %rbx
testq %r14, %r14
je 0x3b7a4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b7af
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq