// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gff3.c
// Function: gt_gff3_option_parser_new
static GtOptionParser* gt_gff3_option_parser_new(void *tool_arguments)
{
  GFF3Arguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *sort_option, *load_option, *strict_option, *tidy_option,
           *mergefeat_option, *addintrons_option, *offset_option,
           *offsetfile_option, *setsource_option, *sortlines_option,
           *sortnum_option, *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Parse, possibly "
                            "transform, and output GFF3 files.");

  /* -sort */
  sort_option = gt_option_new_bool("sort", "sort the GFF3 features (memory "
                                   "consumption is proportional to the input "
                                   "file size(s))",
                                   &arguments->sort, false);
  gt_option_parser_add_option(op, sort_option);

  /* -sortlines */
  sortlines_option = gt_option_new_bool("sortlines", "sort the GFF3 features "
                                        "on a strict line basis (not sorted as"
                                        "defined by GenomeTools)",
                                        &arguments->sortlines, false);
  gt_option_parser_add_option(op, sortlines_option);

  /* -sortnum */
  sortnum_option = gt_option_new_bool("sortnum", "enable natural numeric "
                                        "sorting for sequence regions (not "
                                        "sorted as defined by GenomeTools)",
                                        &arguments->sortnum, false);
  gt_option_parser_add_option(op, sortnum_option);
  gt_option_exclude(sortlines_option, sortnum_option);

  /* -strict */
  strict_option = gt_option_new_bool("strict", "be very strict during GFF3 "
                                     "parsing (stricter than the specification "
                                     "requires)", &arguments->strict, false);
  gt_option_is_development_option(strict_option);
  gt_option_parser_add_option(op, strict_option);

  /* -tidy */
  tidy_option = gt_option_new_bool("tidy", "try to tidy the GFF3 files up "
                                   "during parsing", &arguments->tidy, false);
  gt_option_parser_add_option(op, tidy_option);
  gt_option_exclude(strict_option, tidy_option);

  /* -retainids */
  option = gt_option_new_bool("retainids",
                              "when available, use the original IDs provided "
                              "in the source file\n"
                              "(memory consumption is proportional to the "
                              "input file size(s))", &arguments->retainids,
                              false);
  gt_option_parser_add_option(op, option);

  /* -checkids */
  option = gt_option_new_bool("checkids",
                              "make sure the ID attributes are unique "
                              "within the scope of each GFF3_file, as required "
                              "by GFF3 specification\n"
                              "(memory consumption is proportional to the "
                              "input file size(s)).\n"
                              "If features with the same "GT_GFF_PARENT" "
                              "attribute are not separated by a '"
                              GT_GFF_TERMINATOR"' line the GFF3 parser tries "
                              "to treat them as a multi-line feature. This "
                              "requires at least matching sequence IDs and "
                              "types.", &arguments->checkids, false);
  gt_option_parser_add_option(op, option);

  /* -addids */
  option = gt_option_new_bool("addids", "add missing \""
                              GT_GFF_SEQUENCE_REGION"\" lines automatically",
                              &arguments->addids, true);
  gt_option_parser_add_option(op, option);

  /* -fixregionboundaries */
  option = gt_option_new_bool("fixregionboundaries", "automatically adjust \""
                              GT_GFF_SEQUENCE_REGION"\" lines to contain all "
                              "their features (memory consumption is "
                              "proportional to the input file size(s))",
                              &arguments->fixboundaries, false);
  gt_option_parser_add_option(op, option);

  /* -mergefeat */
  mergefeat_option = gt_option_new_bool("mergefeat",
                                        "merge adjacent features of the same "
                                        "type", &arguments->mergefeat, false);
  gt_option_is_development_option(mergefeat_option);
  gt_option_imply(mergefeat_option, sort_option);
  gt_option_parser_add_option(op, mergefeat_option);

  /* -load */
  load_option = gt_option_new_bool("load", "load the GFF3 features into memory "
                                   "(requires space proportional to the input "
                                   "file size(s))",
                                   &arguments->load, false);
  gt_option_is_development_option(load_option);
  gt_option_parser_add_option(op, load_option);

  /* -addintrons */
  addintrons_option = gt_option_new_bool("addintrons", "add intron features "
                                         "between existing exon features",
                                         &arguments->addintrons, false);
  gt_option_parser_add_option(op, addintrons_option);

  /* -offset */
  offset_option = gt_option_new_word("offset", "transform all features by the "
                                     "given offset", &arguments->offset,
                                     GT_UNDEF_WORD);
  gt_option_parser_add_option(op, offset_option);

  /* -offsetfile */
  offsetfile_option = gt_option_new_filename("offsetfile", "transform all "
                                             "features by the offsets given in "
                                             "file", arguments->offsetfile);
  gt_option_parser_add_option(op, offsetfile_option);
  gt_option_exclude(offset_option, offsetfile_option);

  /* -setsource */
  setsource_option = gt_option_new_string("setsource", "set the 'source' "
                                          "value (2nd column) of each feature",
                                          arguments->newsource, NULL);
  gt_option_parser_add_option(op, setsource_option);

  /* typecheck options */
  gt_typecheck_info_register_options(arguments->tci, op);

  /* xrfcheck options */
  gt_xrfcheck_info_register_options(arguments->xci, op);

  /* -show */
  option = gt_option_new_bool("show", "show GFF3 output", &arguments->show,
                              true);
  gt_option_parser_add_option(op, option);

  /* -v */
  option = gt_option_new_verbose(&arguments->verbose);
  gt_option_parser_add_option(op, option);

  /* -width */
  option = gt_option_new_width(&arguments->width);
  gt_option_parser_add_option(op, option);

  /* output file options */
  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  /* set comment function */
  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);

  return op;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2d0a7
movq %rdi, %rbx
leaq 0x2bd77e(%rip), %rdi    # 0x2ea4f9
leaq 0x2c0bf4(%rip), %rsi    # 0x2ed976
callq 0x97df5
movq %rax, %r14
leaq 0x31be16(%rip), %rdi    # 0x348ba7
leaq 0x2c0c10(%rip), %rsi    # 0x2ed9a8
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x1(%rbx), %rdx
leaq 0x2c0c43(%rip), %rdi    # 0x2ed9fe
leaq 0x2c0c46(%rip), %rsi    # 0x2eda08
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x2(%rbx), %rdx
leaq 0x2c0c7a(%rip), %rdi    # 0x2eda5c
leaq 0x2c0c7b(%rip), %rsi    # 0x2eda64
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r12, %rdi
movq %r13, %rsi
callq 0x9b38d
leaq 0xa(%rbx), %rdx
leaq 0x2f30f1(%rip), %rdi    # 0x31ff05
leaq 0x2c0ca4(%rip), %rsi    # 0x2edabf
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r12
movq %rax, %rdi
callq 0x9b10a
movq %r14, %rdi
movq %r12, %rsi
callq 0x97f31
leaq 0xb(%rbx), %rdx
leaq 0x2f3088(%rip), %rdi    # 0x31fecb
leaq 0x2c0cc3(%rip), %rsi    # 0x2edb0d
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r12, %rdi
movq %r13, %rsi
callq 0x9b38d
leaq 0x4(%rbx), %rdx
leaq 0x353936(%rip), %rdi    # 0x3807ab
leaq 0x2c0cbe(%rip), %rsi    # 0x2edb3a
xorl %ecx, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x5(%rbx), %rdx
leaq 0x2c0d21(%rip), %rdi    # 0x2edbba
leaq 0x2c0d23(%rip), %rsi    # 0x2edbc3
xorl %ecx, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x6(%rbx), %rdx
leaq 0x2c0e75(%rip), %rdi    # 0x2edd32
leaq 0x2c0e75(%rip), %rsi    # 0x2edd39
pushq $0x1
popq %rbp
movl %ebp, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0xd(%rbx), %rdx
leaq 0x2c0e89(%rip), %rdi    # 0x2edd6d
leaq 0x2c0e96(%rip), %rsi    # 0x2edd81
xorl %ecx, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x7(%rbx), %rdx
leaq 0x2b88bd(%rip), %rdi    # 0x2e57c5
leaq 0x2c0efe(%rip), %rsi    # 0x2ede0d
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r12
movq %rax, %rdi
callq 0x9b10a
movq %r12, %rdi
movq %r15, %rsi
callq 0x9b14d
movq %r14, %rdi
movq %r12, %rsi
callq 0x97f31
leaq 0x3(%rbx), %rdx
leaq 0x353338(%rip), %rdi    # 0x38027a
leaq 0x2c0eed(%rip), %rsi    # 0x2ede36
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rax, %rdi
callq 0x9b10a
movq %r14, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x8(%rbx), %rdx
leaq 0x2c0f20(%rip), %rdi    # 0x2ede91
leaq 0x2c0f24(%rip), %rsi    # 0x2ede9c
xorl %ecx, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x10(%rbx), %rdx
leaq 0x2db1b1(%rip), %rdi    # 0x308146
leaq 0x2c0f33(%rip), %rsi    # 0x2edecf
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
callq 0x9ac34
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x18(%rbx), %rdx
leaq 0x2f26ed(%rip), %rdi    # 0x31f6b1
leaq 0x2c0f2f(%rip), %rsi    # 0x2edefa
callq 0x9ad51
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
movq %r12, %rsi
callq 0x9b38d
movq 0x20(%rbx), %rdx
leaq 0x2c0f3a(%rip), %rdi    # 0x2edf2e
leaq 0x2c0f3d(%rip), %rsi    # 0x2edf38
xorl %ecx, %ecx
callq 0x9ad12
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x12ac0d
movq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x12e448
leaq 0xc(%rbx), %rdx
leaq 0x323967(%rip), %rdi    # 0x350997
leaq 0x2c0f35(%rip), %rsi    # 0x2edf6c
movl %ebp, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x9(%rbx), %rdi
callq 0x9a9b6
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x28(%rbx), %rdi
callq 0x9a9ce
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x40(%rbx), %rdi
addq $0x48, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9b6d7
leaq 0xba461(%rip), %rsi     # 0xe74ec
movq %r14, %rdi
xorl %edx, %edx
callq 0x98045
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40aeba(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b7f5b(%rip), %rsi    # 0x2e5013
leaq 0x31b594(%rip), %rdx    # 0x348653
leaq 0x2c0896(%rip), %rcx    # 0x2ed95c
leaq 0x2c087b(%rip), %r8     # 0x2ed948
pushq $0x62
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390