LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/option.c
// Function: optional_arg
static bool optional_arg(GtOption *o, int argnum, int argc, const char **argv)
{
  gt_assert(o);
  if (o->argument_is_optional &&
      (argnum + 1 >= argc || argv[argnum + 1][0] == '-' ||
       !strcmp(argv[argnum + 1], "--"))) {
    return true;
  }
  return false;
}

// Assembly:
testq %rdi, %rdi
je 0x10046
cmpb $0x1, 0x4f(%rdi)
jne 0x10043
incl %esi
movb $0x1, %al
cmpl %edx, %esi
jge 0x10045
movslq %esi, %rdx
movq (%rcx,%rdx,8), %rcx
cmpb $0x2d, (%rcx)
je 0x10045
xorl %eax, %eax
retq
pushq %rax
movq 0x11df6a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xba00e(%rip), %rsi     # 0xca066
leaq 0xbdb15(%rip), %rdx     # 0xcdb74
leaq 0xbb5a5(%rip), %rcx     # 0xcb60b
leaq 0xba899(%rip), %r8      # 0xca906
movl $0x2e5, %r9d            # imm = 0x2E5
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/option.c
// Function: check_missing_argument_and_minus_sign
static int check_missing_argument_and_minus_sign(int argnum, int argc,
                                                 GtStr *option,
                                                 const char **argv,
                                                 GtError *err)
{
  gt_error_check(err);
  if (argnum + 1 >= argc || (argv[argnum+1][0] == '-'
                               && argv[argnum+1][1] != '\0')) {
    gt_error_set(err, "missing argument to option \"-%s\"", gt_str_get(option));
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %r12d
movl %edi, %ebp
testq %r8, %r8
je 0x100a6
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x100e9
incl %ebp
cmpl %r12d, %ebp
jge 0x100c1
movslq %ebp, %rax
movq (%r15,%rax,8), %rcx
xorl %eax, %eax
cmpb $0x2d, (%rcx)
jne 0x100e0
cmpb $0x0, 0x1(%rcx)
je 0x100e0
movq %r14, %rdi
callq 0x143d2
leaq 0xbb027(%rip), %rsi     # 0xcb0f7
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x11dec8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb9f6c(%rip), %rsi     # 0xca066
leaq 0xba558(%rip), %rdx     # 0xca659
leaq 0xbb510(%rip), %rcx     # 0xcb618
leaq 0xba7f7(%rip), %r8      # 0xca906
movl $0x2fe, %r9d            # imm = 0x2FE
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/option.c
// Function: check_missing_argument
static int check_missing_argument(int argnum, int argc, GtStr *option,
                                  GtError *err)
{
  gt_error_check(err);
  if (argnum + 1 >= argc) {
    gt_error_set(err, "missing argument to option \"-%s\"", gt_str_get(option));
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %r15d
testq %rcx, %rcx
je 0x10144
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x10178
incl %r15d
xorl %eax, %eax
cmpl %ebp, %r15d
jl 0x1016d
movq %r14, %rdi
callq 0x143d2
leaq 0xbaf9a(%rip), %rsi     # 0xcb0f7
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x11de39(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb9edd(%rip), %rsi     # 0xca066
leaq 0xba4c9(%rip), %rdx     # 0xca659
leaq 0xbb4a7(%rip), %rcx     # 0xcb63e
leaq 0xba768(%rip), %r8      # 0xca906
movl $0x2f1, %r9d            # imm = 0x2F1
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/option.c
// Function: gt_option_parser_delete
void gt_option_parser_delete(GtOptionParser *op)
{
  GtUword i;
  if (!op) return;
  gt_free(op->progname);
  gt_free(op->synopsis);
  gt_free(op->one_liner);
  for (i = 0; i < gt_array_size(op->options); i++)
    gt_option_delete(*(GtOption**) gt_array_get(op->options, i));
  gt_array_delete(op->options);
  gt_array_delete(op->hooks);
  gt_hashmap_delete(op->optionindex);
  gt_free(op);
}

// Assembly:
testq %rdi, %rdi
je 0x10841
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xba150(%rip), %r14     # 0xca906
movq %r14, %rsi
movl $0x5c9, %edx            # imm = 0x5C9
callq 0xd249
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x5ca, %edx            # imm = 0x5CA
callq 0xd249
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x5cb, %edx            # imm = 0x5CB
callq 0xd249
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
callq 0x4b988
movq 0x18(%rbx), %rdi
cmpq %rax, %r14
jae 0x1080f
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x10842
incq %r14
jmp 0x107e8
callq 0x4c19d
movq 0x20(%rbx), %rdi
callq 0x4c19d
movq 0x58(%rbx), %rdi
callq 0x563a7
leaq 0xba0d9(%rip), %rsi     # 0xca906
movq %rbx, %rdi
movl $0x5d1, %edx            # imm = 0x5D1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/option.c
// Function: gt_option_delete
void gt_option_delete(GtOption *o)
{
  GtUword i;
  if (!o) return;
  if (o->reference_count) {
    o->reference_count--;
    return;
  }
  gt_str_delete(o->option_str);
  gt_str_delete(o->description);
  for (i = 0; i < gt_array_size(o->implications); i++)
    gt_array_delete(*(GtArray**) gt_array_get(o->implications, i));
  gt_array_delete(o->implications);
  gt_array_delete(o->exclusions);
  gt_array_delete(o->mandatory_either_options);
  gt_free(o);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1085a
movq %rdi, %rbx
movl 0x68(%rdi), %eax
testl %eax, %eax
je 0x10862
decl %eax
movl %eax, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rdi
callq 0x152db
movq 0x10(%rbx), %rdi
callq 0x152db
xorl %r14d, %r14d
movq 0x50(%rbx), %rdi
callq 0x4b988
movq 0x50(%rbx), %rdi
cmpq %rax, %r14
jae 0x1089e
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x4c19d
incq %r14
jmp 0x10877
callq 0x4c19d
movq 0x58(%rbx), %rdi
callq 0x4c19d
movq 0x60(%rbx), %rdi
callq 0x4c19d
leaq 0xba04a(%rip), %rsi     # 0xca906
movq %rbx, %rdi
movl $0x7c1, %edx            # imm = 0x7C1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_bool
GtOption* gt_option_new_bool(const char *option_str, const char *description,
                             bool *value, bool default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_BOOL;
  o->default_value.b = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
callq 0x10962
andl $0x0, (%rax)
movb %bl, 0x20(%rax)
movb %bl, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uword
GtOption* gt_option_new_uword(const char *option_str, const char *description,
                              GtUword *value, GtUword default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_ULONG;
  o->default_value.ul = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
callq 0x10962
movl $0xa, (%rax)
movq %rbx, 0x20(%rax)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/option.c
// Function: gt_option_new
static GtOption *gt_option_new(const char *option_str, const char *description,
                               void *value)
{
  GtOption *o = gt_calloc(1, sizeof (GtOption));
  gt_assert(option_str && strlen(option_str));
  gt_assert("an option string should not start with '-', this is added "
            "automatically"  && option_str[0] != '-');
  o->option_str = gt_str_new_cstr(option_str);
  o->description = gt_str_new_cstr(description);
  o->value = value;
  return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xb9f8c(%rip), %rdx     # 0xca906
pushq $0x1
popq %rdi
pushq $0x70
popq %rsi
pushq $0x7d
popq %rcx
callq 0xce9a
testq %r15, %r15
je 0x109cb
movq %rax, %r12
movzbl (%r15), %eax
cmpl $0x2d, %eax
je 0x109f7
testl %eax, %eax
je 0x109cb
movq %r15, %rdi
callq 0x13da9
movq %rax, 0x8(%r12)
movq %r14, %rdi
callq 0x13da9
movq %rax, 0x10(%r12)
movq %rbx, 0x18(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x11d5e6(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb968a(%rip), %rsi     # 0xca066
leaq 0xbafa3(%rip), %rdx     # 0xcb986
leaq 0xbafbd(%rip), %rcx     # 0xcb9a7
leaq 0xb9f15(%rip), %r8      # 0xca906
pushq $0x7e
popq %r9
jmp 0x10a23
movq 0x11d5ba(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb965e(%rip), %rsi     # 0xca066
leaq 0xbafa6(%rip), %rdx     # 0xcb9b5
leaq 0xbaf91(%rip), %rcx     # 0xcb9a7
leaq 0xb9ee9(%rip), %r8      # 0xca906
movl $0x80, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x10962
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_O2/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 0x10962
movl $0x7, (%rax)
movl %ebx, 0x20(%rax)
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
callq 0x10abe
movw $0x101, 0x4b(%rax)      # imm = 0x101
movl %ebp, 0x38(%rax)
movl %ebx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10962
movl $0x8, (%rax)
movl %ebx, 0x20(%rax)
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10962
movl $0x9, (%rax)
movq %rbx, 0x20(%rax)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10962
movl $0xb, (%rax)
testq %r14, %r14
je 0x10c23
movq (%r14), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%r14), %rdx
jmp 0x10c2e
orq $-0x1, 0x20(%rax)
pushq $-0x1
popq %rcx
movq %rcx, %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_O2/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 0x10bfc
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_O2/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 0x10962
movq %rax, %r15
movl $0xc, (%rax)
movq %rbx, 0x20(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13e63
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10962
movq %rax, %r14
movl $0x3, (%rax)
andq $0x0, 0x20(%rax)
movq %rbx, %rdi
callq 0x1452f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %r8, %rbx
testq %rcx, %rcx
je 0x10cff
xorl %eax, %eax
movq (%rbx,%rax,8), %r8
testq %r8, %r8
je 0x10cf9
cmpq %rcx, %r8
je 0x10cff
incq %rax
jmp 0x10ce6
cmpq $-0x1, %rax
jne 0x10d10
callq 0x10c6a
movl $0x1, (%rax)
movq %rbx, 0x30(%rax)
popq %rbx
retq
movq 0x11d2a1(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb9345(%rip), %rsi     # 0xca066
leaq 0xba4d5(%rip), %rdx     # 0xcb1fd
leaq 0xba4d9(%rip), %rcx     # 0xcb208
leaq 0xb9bd0(%rip), %r8      # 0xca906
movl $0x72f, %r9d            # imm = 0x72F
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rdi, %rdi
je 0x10e14
testq %rsi, %rsi
je 0x10e14
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
jne 0x10e42
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x4b380
movq %rax, 0x60(%rbx)
movq %rsp, %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x4b801
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x11d19d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb9241(%rip), %rsi     # 0xca066
leaq 0xba41b(%rip), %rdx     # 0xcb247
leaq 0xba41d(%rip), %rcx     # 0xcb250
leaq 0xb9acc(%rip), %r8      # 0xca906
movl $0x747, %r9d            # imm = 0x747
jmp 0x10e6e
movq 0x11d16f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb9213(%rip), %rsi     # 0xca066
leaq 0xba414(%rip), %rdx     # 0xcb26e
leaq 0xba3ef(%rip), %rcx     # 0xcb250
leaq 0xb9a9e(%rip), %r8      # 0xca906
movl $0x748, %r9d            # imm = 0x748
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
testq %rdi, %rdi
je 0x10edd
testq %rsi, %rsi
je 0x10edd
testq %rdx, %rdx
je 0x10edd
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
jne 0x10f0b
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x4b380
movq %rax, 0x60(%rbx)
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x4b801
movq 0x60(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x4b801
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x11d0d4(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb9178(%rip), %rsi     # 0xca066
leaq 0xba396(%rip), %rdx     # 0xcb28b
leaq 0xba3a3(%rip), %rcx     # 0xcb29f
leaq 0xb9a03(%rip), %r8      # 0xca906
movl $0x750, %r9d            # imm = 0x750
jmp 0x10f37
movq 0x11d0a6(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb914a(%rip), %rsi     # 0xca066
leaq 0xba34b(%rip), %rdx     # 0xcb26e
leaq 0xba375(%rip), %rcx     # 0xcb29f
leaq 0xb99d5(%rip), %r8      # 0xca906
movl $0x751, %r9d            # imm = 0x751
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
testq %rdi, %rdi
je 0x10fb9
testq %rsi, %rsi
je 0x10fb9
testq %rdx, %rdx
je 0x10fb9
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
jne 0x10fe7
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x4b380
movq %rax, 0x60(%rbx)
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x4b801
movq 0x60(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x4b801
movq 0x60(%rbx), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x4b801
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x11cff8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb909c(%rip), %rsi     # 0xca066
leaq 0xba2ba(%rip), %rdx     # 0xcb28b
leaq 0xba2e7(%rip), %rcx     # 0xcb2bf
leaq 0xb9927(%rip), %r8      # 0xca906
movl $0x75b, %r9d            # imm = 0x75B
jmp 0x11013
movq 0x11cfca(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb906e(%rip), %rsi     # 0xca066
leaq 0xba26f(%rip), %rdx     # 0xcb26e
leaq 0xba2b9(%rip), %rcx     # 0xcb2bf
leaq 0xb98f9(%rip), %r8      # 0xca906
movl $0x75c, %r9d            # imm = 0x75C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, (%rsp)
testq %rdi, %rdi
je 0x1110d
testq %rsi, %rsi
je 0x1110d
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x110d2
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x50(%rbx)
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x4b380
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rsp, %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x4b801
movq 0x50(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4b801
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x11cea4(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb8f48(%rip), %rsi     # 0xca066
leaq 0xba1f7(%rip), %rdx     # 0xcb31c
leaq 0xba204(%rip), %rcx     # 0xcb330
leaq 0xb97d3(%rip), %r8      # 0xca906
movl $0x772, %r9d            # imm = 0x772
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
testq %rdi, %rdi
je 0x111cf
testq %rsi, %rsi
je 0x111cf
testq %rdx, %rdx
je 0x111cf
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x1117e
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x50(%rbx)
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x4b380
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x4b801
movq %rsp, %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4b801
movq 0x50(%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4b801
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x11cde2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb8e86(%rip), %rsi     # 0xca066
leaq 0xba159(%rip), %rdx     # 0xcb340
leaq 0xba162(%rip), %rcx     # 0xcb350
leaq 0xb9711(%rip), %r8      # 0xca906
movl $0x77e, %r9d            # imm = 0x77E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
testq %rdi, %rdi
je 0x112ad
testq %rsi, %rsi
je 0x112ad
testq %rdx, %rdx
je 0x112ad
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x1124a
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x50(%rbx)
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x4b380
movq %rax, %r15
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x4b801
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4b801
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4b801
movq 0x50(%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4b801
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x11cd04(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb8da8(%rip), %rsi     # 0xca066
leaq 0xba07b(%rip), %rdx     # 0xcb340
leaq 0xba09d(%rip), %rcx     # 0xcb369
leaq 0xb9633(%rip), %r8      # 0xca906
movl $0x78b, %r9d            # imm = 0x78B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x11365
movq %rsi, %r14
testq %rsi, %rsi
je 0x11365
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
jne 0x1131e
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, %rdi
movq %rax, 0x58(%rbx)
cmpq $0x0, 0x58(%r14)
jne 0x11335
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x58(%r14)
movq 0x58(%rbx), %rdi
leaq 0x8(%rsp), %rbx
pushq $0x8
popq %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4b801
movq (%rbx), %rax
movq 0x58(%rax), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x4b801
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x11cc4c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb8cf0(%rip), %rsi     # 0xca066
leaq 0xba005(%rip), %rdx     # 0xcb382
leaq 0xba009(%rip), %rcx     # 0xcb38d
leaq 0xb957b(%rip), %r8      # 0xca906
movl $0x797, %r9d            # imm = 0x797
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x143d2
leaq 0xb9f4f(%rip), %rsi     # 0xcb3e6
movq %r13, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0x554b5
testl %eax, %eax
jne 0x11511
cmpb $0x0, 0x8(%rsp)
je 0x11511
movq %r12, %rdi
callq 0x143d2
leaq 0xb9f94(%rip), %rsi     # 0xcb453
leaq 0xc(%rsp), %r14
leaq 0x9(%rsp), %r15
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xb680
movslq (%r14), %r14
movq %r14, (%rbx)
leaq 0xb9f6a(%rip), %rsi     # 0xcb450
pushq $0x3
popq %rdx
movq %r15, %rdi
callq 0xb6b0
testl %eax, %eax
je 0x11536
leaq 0xb9f5c(%rip), %rsi     # 0xcb458
leaq 0x9(%rsp), %rdi
pushq $0x3
popq %rdx
callq 0xb6b0
testl %eax, %eax
jne 0x1153f
pushq $0x14
jmp 0x11538
leaq 0xb9ede(%rip), %rsi     # 0xcb3f6
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x1e
popq %rcx
shlq %cl, %r14
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x11528
// File: /workspace/github_c_makefile_star2_O2/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 0x11667
movq %rsi, %r14
testq %rsi, %rsi
je 0x11667
movq %rdi, %rbx
callq 0xb060
andl $0x0, (%rax)
movq %rsp, %rsi
pushq $0xa
popq %rdx
movq %r14, %rdi
callq 0xb890
movq %rax, %rcx
pushq $-0x1
popq %rax
cmpb $0x0, (%r14)
je 0x1165f
movq (%rsp), %rdx
cmpb $0x0, (%rdx)
setne %dl
movslq %ecx, %rsi
cmpq %rcx, %rsi
setne %sil
orb %dl, %sil
jne 0x1165f
movl %ecx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x11c94a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb89ee(%rip), %rsi     # 0xca066
leaq 0xba3a9(%rip), %rdx     # 0xcba28
leaq 0xba3ae(%rip), %rcx     # 0xcba34
leaq 0xba3b4(%rip), %r8      # 0xcba41
pushq $0x20
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x116f9
movq %rsi, %r14
testq %rsi, %rsi
je 0x116f9
movq %rdi, %rbx
callq 0xb060
andl $0x0, (%rax)
movq %rsp, %rsi
pushq $0xa
popq %rdx
movq %r14, %rdi
callq 0xb1c0
movq %rax, %rcx
pushq $-0x1
popq %rax
cmpb $0x0, (%r14)
je 0x116f1
movq (%rsp), %rdx
cmpb $0x0, (%rdx)
setne %dl
movq %rcx, %rsi
shrq $0x20, %rsi
setne %sil
orb %dl, %sil
jne 0x116f1
movl %ecx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x11c8b8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb895c(%rip), %rsi     # 0xca066
leaq 0xba317(%rip), %rdx     # 0xcba28
leaq 0xba33f(%rip), %rcx     # 0xcba57
leaq 0xba322(%rip), %r8      # 0xcba41
pushq $0x31
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x117ae
movq %rsi, %r14
testq %rsi, %rsi
je 0x117ae
movq %rdi, %rbx
callq 0xb060
movq %rax, %r15
andl $0x0, (%rax)
leaq 0x8(%rsp), %rsi
pushq $0xa
popq %rdx
movq %r14, %rdi
callq 0xb890
movq %rax, %rcx
pushq $-0x1
popq %rax
cmpb $0x0, (%r14)
je 0x117a4
movq 0x8(%rsp), %rdx
cmpb $0x0, (%rdx)
jne 0x117a4
cmpl $0x22, (%r15)
sete %dl
movabsq $-0x7fffffffffffffff, %rsi # imm = 0x8000000000000001
addq %rcx, %rsi
cmpq $0x2, %rsi
setb %sil
testb %sil, %dl
jne 0x117a4
movq %rcx, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x11c803(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb88a7(%rip), %rsi     # 0xca066
leaq 0xba262(%rip), %rdx     # 0xcba28
leaq 0xba298(%rip), %rcx     # 0xcba65
leaq 0xba26d(%rip), %r8      # 0xcba41
pushq $0x46
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x11856
movq %rsi, %r14
testq %rsi, %rsi
je 0x11856
movq %rdi, %rbx
callq 0xb060
movq %rax, %r15
andl $0x0, (%rax)
leaq 0x8(%rsp), %rsi
pushq $0xa
popq %rdx
movq %r14, %rdi
callq 0xb1c0
movq %rax, %rcx
pushq $-0x1
popq %rax
cmpb $0x0, (%r14)
je 0x1184c
movq 0x8(%rsp), %rdx
cmpb $0x0, (%rdx)
jne 0x1184c
cmpl $0x22, (%r15)
sete %dl
cmpq $-0x1, %rcx
sete %sil
testb %sil, %dl
jne 0x1184c
movq %rcx, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x11c75b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb87ff(%rip), %rsi     # 0xca066
leaq 0xba1ba(%rip), %rdx     # 0xcba28
leaq 0xba1fe(%rip), %rcx     # 0xcba73
leaq 0xba1c5(%rip), %r8      # 0xcba41
pushq $0x5a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x11916
movq %rsi, %r14
testq %rsi, %rsi
je 0x11916
movq %rdi, %rbx
callq 0xb060
movq %rax, %r15
andl $0x0, (%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xb490
pushq $-0x1
popq %rax
cmpb $0x0, (%r14)
je 0x1190c
movq 0x8(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x1190c
cmpl $0x22, (%r15)
jne 0x11906
movq %xmm0, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
sete %dl
shlq %rcx
testq %rcx, %rcx
sete %cl
orb %dl, %cl
jne 0x1190c
movsd 0xba120(%rip), %xmm1    # 0xcba20
ucomisd %xmm0, %xmm1
jae 0x1190c
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x11c69b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb873f(%rip), %rsi     # 0xca066
leaq 0xba0fa(%rip), %rdx     # 0xcba28
leaq 0xba14d(%rip), %rcx     # 0xcba82
leaq 0xba105(%rip), %r8      # 0xcba41
pushq $0x69
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x11cf6
movq %r8, %rbx
testq %r8, %r8
je 0x11cf6
movq %r9, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
testq %r9, %r9
je 0x11c90
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x11d24
movq %r15, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x11ca8
cmpb $0x2e, (%r15)
jne 0x11ca8
xorl %ecx, %ecx
jmp 0x11cc3
leaq 0xb9195(%rip), %rsi     # 0xcae44
movq %r15, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0xb680
movb $0x1, %cl
cmpl $0x1, %eax
jne 0x11ccb
movb %cl, (%r12)
xorl %eax, %eax
jmp 0x11ce7
leaq 0xb9de1(%rip), %rsi     # 0xcbab3
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x11c2bb(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb835f(%rip), %rsi     # 0xca066
leaq 0xb9d84(%rip), %rdx     # 0xcba92
leaq 0xb9d8f(%rip), %rcx     # 0xcbaa4
leaq 0xb9d25(%rip), %r8      # 0xcba41
movl $0xf4, %r9d
jmp 0x11d50
movq 0x11c28d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb8331(%rip), %rsi     # 0xca066
leaq 0xb891d(%rip), %rdx     # 0xca659
leaq 0xb9d61(%rip), %rcx     # 0xcbaa4
leaq 0xb9cf7(%rip), %r8      # 0xcba41
movl $0xf5, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x11e17
movq %rcx, %r14
testq %rcx, %rcx
je 0x11e17
movq %r8, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
testq %r8, %r8
je 0x11d99
movq %r12, %rdi
callq 0xc103
testb %al, %al
jne 0x11e45
movq %r15, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x11dcb
leaq 0xb9d96(%rip), %rsi     # 0xcbb44
movq %r15, %rdi
callq 0xb250
cmpq $0x1, %rax
jne 0x11de6
movsbl (%r15), %edi
callq 0x158a4
movl %eax, %ecx
xorl %eax, %eax
jmp 0x11e0c
leaq 0xb9d37(%rip), %rsi     # 0xcbb09
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0xc007
jmp 0x11e06
leaq 0xb9d5c(%rip), %rsi     # 0xcbb49
leaq 0xb9d50(%rip), %r9      # 0xcbb44
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
pushq $0x3
popq %rcx
movl %ecx, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x11c19a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb823e(%rip), %rsi     # 0xca066
leaq 0xb9cb7(%rip), %rdx     # 0xcbae6
leaq 0xb9cc3(%rip), %rcx     # 0xcbaf9
leaq 0xb9c04(%rip), %r8      # 0xcba41
movl $0x108, %r9d            # imm = 0x108
jmp 0x11e71
movq 0x11c16c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb8210(%rip), %rsi     # 0xca066
leaq 0xb87fc(%rip), %rdx     # 0xca659
leaq 0xb9c95(%rip), %rcx     # 0xcbaf9
leaq 0xb9bd6(%rip), %r8      # 0xcba41
movl $0x109, %r9d            # imm = 0x109
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x11f38
movq %rcx, %r14
testq %rcx, %rcx
je 0x11f38
movq %r8, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
testq %r8, %r8
je 0x11eba
movq %r12, %rdi
callq 0xc103
testb %al, %al
jne 0x11f66
movq %r15, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x11eec
leaq 0xb9d21(%rip), %rsi     # 0xcbbf0
movq %r15, %rdi
callq 0xb250
cmpq $0x1, %rax
jne 0x11f07
movsbl (%r15), %edi
callq 0x121e8
movl %eax, %ecx
xorl %eax, %eax
jmp 0x11f2d
leaq 0xb9cc3(%rip), %rsi     # 0xcbbb6
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0xc007
jmp 0x11f27
leaq 0xb9ce7(%rip), %rsi     # 0xcbbf5
leaq 0xb9cdb(%rip), %r9      # 0xcbbf0
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
pushq $0x3
popq %rcx
movl %ecx, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x11c079(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb811d(%rip), %rsi     # 0xca066
leaq 0xb9c45(%rip), %rdx     # 0xcbb95
leaq 0xb9c50(%rip), %rcx     # 0xcbba7
leaq 0xb9ae3(%rip), %r8      # 0xcba41
movl $0x11f, %r9d            # imm = 0x11F
jmp 0x11f92
movq 0x11c04b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb80ef(%rip), %rsi     # 0xca066
leaq 0xb86db(%rip), %rdx     # 0xca659
leaq 0xb9c22(%rip), %rcx     # 0xcbba7
leaq 0xb9ab5(%rip), %r8      # 0xcba41
movl $0x120, %r9d            # imm = 0x120
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x11fcc
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x1204f
testq %r15, %r15
je 0x12021
testq %rbx, %rbx
je 0x12021
leaq 0xdbc75(%rip), %rsi     # 0xedc52
xorl %r13d, %r13d
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xb680
cmpl $0x1, %eax
je 0x1200f
leaq 0xb9c6d(%rip), %rsi     # 0xcbc66
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %r13
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x11bf90(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb8034(%rip), %rsi     # 0xca066
leaq 0xb9c19(%rip), %rdx     # 0xcbc52
leaq 0xb9c00(%rip), %rcx     # 0xcbc40
leaq 0xb99fa(%rip), %r8      # 0xcba41
movl $0x138, %r9d            # imm = 0x138
jmp 0x1207b
movq 0x11bf62(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb8006(%rip), %rsi     # 0xca066
leaq 0xb85f2(%rip), %rdx     # 0xca659
leaq 0xb9bd2(%rip), %rcx     # 0xcbc40
leaq 0xb99cc(%rip), %r8      # 0xcba41
movl $0x137, %r9d            # imm = 0x137
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xb99fe(%rip), %rdi     # 0xcbbf0
pushq $0x5
popq %rdx
movl %ebx, %esi
callq 0xb710
testq %rax, %rax
je 0x1224a
addb $-0x2e, %bl
cmpb $0x5, %bl
jae 0x12220
pushq $0x1d
popq %rcx
movzbl %bl, %eax
btl %eax, %ecx
jae 0x12220
leaq 0xb9d71(%rip), %rcx     # 0xcbf8c
movl (%rcx,%rax,4), %eax
popq %rbx
retq
movq 0x11bd91(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb7e35(%rip), %rsi     # 0xca066
leaq 0xc9409(%rip), %rdx     # 0xdb641
leaq 0xb9d2c(%rip), %rcx     # 0xcbf6b
leaq 0xb9d32(%rip), %r8      # 0xcbf78
pushq $0x1d
jmp 0x12272
movq 0x11bd67(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb7e0b(%rip), %rsi     # 0xca066
leaq 0xb9ce6(%rip), %rdx     # 0xcbf48
leaq 0xb9d02(%rip), %rcx     # 0xcbf6b
leaq 0xb9d08(%rip), %r8      # 0xcbf78
pushq $0x18
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/spacepeak.c
// Function: gt_spacepeak_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, 0x11d757(%rip)    # 0x12f9f8
jne 0x122d8
pushq $0x18
popq %rdi
callq 0xbce8
movq %rax, 0x11d746(%rip)    # 0x12f9f8
callq 0xd484
movq 0x11d73a(%rip), %rcx    # 0x12f9f8
movq %rax, (%rcx)
andq $0x0, 0x8(%rcx)
callq 0x15f7b
movq 0x11d726(%rip), %rcx    # 0x12f9f8
movq %rax, 0x10(%rcx)
popq %rax
retq
movq 0x11bcd9(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb7d7d(%rip), %rsi     # 0xca066
leaq 0xb9cb0(%rip), %rdx     # 0xcbfa0
leaq 0xb9cb5(%rip), %rcx     # 0xcbfac
leaq 0xb9cc0(%rip), %r8      # 0xcbfbe
pushq $0x23
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300