// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_select.c
// Function: gt_select_option_parser_new
static GtOptionParser* gt_select_option_parser_new(void *tool_arguments)
{
  SelectArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option, *contain_option, *overlap_option, *minaveragessp_option,
           *singleintron_option, *optiondroppedfile;
  gt_assert(arguments);

  static const char *filter_logic[] = {
    "AND",
    "OR",
    NULL
  };

  /* init */
  op = gt_option_parser_new("[option ...] [GFF3_file ...]",
                            "Select certain features (specified by the used "
                            "options) from given GFF3 file(s).");

  /* -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);

  /* -seqid */
  option = gt_option_new_string("seqid", "select feature with the given "
                                "sequence ID (all comments are selected). ",
                                arguments->seqid, NULL);
  gt_option_parser_add_option(op, option);

  /* -source */
  option = gt_option_new_string("source", "select feature with the given "
                                "source (the source is column 2 in regular "
                                "GFF3 lines)" , arguments->source, NULL);
  gt_option_parser_add_option(op, option);

  /* -contain */
  contain_option = gt_option_new_range("contain", "select all features which "
                                       "are contained in the given range",
                                       &arguments->contain_range, NULL);
  gt_option_parser_add_option(op, contain_option);

  /* -overlap */
  overlap_option = gt_option_new_range("overlap", "select all features which "
                                       "do overlap with the given range",
                                       &arguments->overlap_range, NULL);
  gt_option_parser_add_option(op, overlap_option);

  /* -strand */
  option = gt_option_new_string(GT_STRAND_OPT, "select all top-level features"
                                "(i.e., features without parents) whose strand "
                                "equals the given one (must be one of '"
                                GT_STRAND_CHARS"')", arguments->gt_strand_char,
                                NULL);
  gt_option_parser_add_option(op, option);

  /* -targetstrand */
  option = gt_option_new_string(TARGETGT_STRAND_OPT, "select all top-level "
                                "features (i.e., features without parents) "
                                "which have exactly one target attribute whose "
                                "strand equals the given one (must be one of '"
                                GT_STRAND_CHARS"')",
                                arguments->targetgt_strand_char, NULL);
  gt_option_parser_add_option(op, option);

  /* -targetbest */
  option = gt_option_new_bool("targetbest", "if multiple top-level features "
                             "(i.e., features without parents) with exactly "
                             "one target attribute have the same target_id, "
                             "keep only the feature with the best score. If "
                             "-"TARGETGT_STRAND_OPT" is used at the same time, "
                             "this option is applied after "
                             "-"TARGETGT_STRAND_OPT".\n"
                             "Memory consumption is proportional to the input "
                             "file size(s).", &arguments->targetbest, false);
  gt_option_parser_add_option(op, option);

  /* -hascds */
  option = gt_option_new_bool("hascds", "select all top-level features which "
                              "do have a CDS child", &arguments->has_CDS,
                              false);
  gt_option_parser_add_option(op, option);

  /* -maxgenelength */
  option = gt_option_new_uword_min("maxgenelength", "select genes up to the "
                                   "given maximum length",
                                   &arguments->max_gene_length, GT_UNDEF_UWORD,
                                   1);
  gt_option_parser_add_option(op, option);

  /* -maxgenenum */
  option = gt_option_new_uword("maxgenenum", "select the first genes up to the "
                               "given maximum number", &arguments->max_gene_num,
                               GT_UNDEF_UWORD);
  gt_option_parser_add_option(op, option);

  /* -mingenescore */
  option = gt_option_new_double("mingenescore", "select genes with the given "
                                "minimum score", &arguments->min_gene_score,
                                GT_UNDEF_DOUBLE);
  gt_option_parser_add_option(op, option);

  /* -maxgenescore */
  option = gt_option_new_double("maxgenescore", "select genes with the given "
                                "maximum score", &arguments->max_gene_score,
                                GT_UNDEF_DOUBLE);
  gt_option_parser_add_option(op, option);

  /* -minaveragessp */
  minaveragessp_option =
    gt_option_new_probability("minaveragessp",
                              "set the minimum average splice site probability",
                              &arguments->min_average_splice_site_prob,
                              GT_UNDEF_DOUBLE);
  gt_option_parser_add_option(op, minaveragessp_option);

  /* -singleintronfactor */
  singleintron_option =
    gt_option_new_double_min("singleintronfactor",
                             "factor to multiplicate the average splice site "
                             "probability with for single introns before "
                             "comparing it to the minimum average splice site "
                             "probability", &arguments->single_intron_factor,
                             1.0, 1.0);
  gt_option_is_development_option(singleintron_option);
  gt_option_parser_add_option(op, singleintron_option);

  /* -featurenum */
  option = gt_option_new_uword_min("featurenum",
                                   "select feature tree occurring "
                                   "at given position in input",
                                   &arguments->feature_num, GT_UNDEF_UWORD, 1);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  /* -filter_files */
  option = gt_option_new_filename_array("rule_files",
                                        "specify Lua filter rule files "
                                        "to be used for selection "
                                        "(terminate list with '--') ",
                                        arguments->filter_files);
  gt_option_parser_add_option(op, option);

  /* -filter_logic */
  option = gt_option_new_choice("rule_logic", "select how multiple Lua "
                                "files should be combined\nchoose from AND|OR",
                                arguments->filter_logic, filter_logic[0],
                                filter_logic);
  gt_option_parser_add_option(op, option);

  /* -nh_file */
  optiondroppedfile = gt_option_new_filename("dropped_file",
                                             "save non-selected features to "
                                             "file",
                                             arguments->dropped_file);
  gt_option_parser_add_option(op, optiondroppedfile);

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

  /* option exclusions */
  gt_option_exclude(contain_option, overlap_option);

  /* option implications */
  gt_option_imply(singleintron_option, minaveragessp_option);

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

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);

  return op;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x60743
movq 0x5db88e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b58f7(%rip), %rsi    # 0x516013
leaq 0x51a43c(%rip), %rdx    # 0x57ab5f
leaq 0x4c7b41(%rip), %rcx    # 0x52826b
leaq 0x4c7b24(%rip), %r8     # 0x528255
movl $0x68, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x60745
leaq 0x4badf6(%rip), %rdi    # 0x51b542
leaq 0x4c7b38(%rip), %rsi    # 0x52828b
callq 0xf1420
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdx
addq $0x3, %rdx
leaq 0x55516e(%rip), %rdi    # 0x5b58db
leaq 0x4be466(%rip), %rsi    # 0x51ebda
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x4d0465(%rip), %rdi    # 0x530c04
leaq 0x4c7b36(%rip), %rsi    # 0x5282dc
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x4ef8c3(%rip), %rdi    # 0x550096
leaq 0x4c7b4a(%rip), %rsi    # 0x528324
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdx
addq $0x28, %rdx
leaq 0x4c7b71(%rip), %rdi    # 0x528378
leaq 0x4c7b72(%rip), %rsi    # 0x528380
xorl %eax, %eax
movl %eax, %ecx
callq 0xf68a0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdx
addq $0x38, %rdx
leaq 0x4e058e(%rip), %rdi    # 0x540dc9
leaq 0x4c7b79(%rip), %rsi    # 0x5283bb
xorl %eax, %eax
movl %eax, %ecx
callq 0xf68a0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdx
leaq 0x4c703f(%rip), %rdi    # 0x5278ae
leaq 0x4c7b7f(%rip), %rsi    # 0x5283f5
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rdx
leaq 0x504567(%rip), %rdi    # 0x564e0a
leaq 0x4c7bc3(%rip), %rsi    # 0x52846d
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdx
addq $0x2, %rdx
leaq 0x508700(%rip), %rdi    # 0x568fd7
leaq 0x4c7c30(%rip), %rsi    # 0x52850e
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdx
addq $0x1, %rdx
leaq 0x4c7d40(%rip), %rdi    # 0x528649
leaq 0x4c7d40(%rip), %rsi    # 0x528650
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdx
addq $0x50, %rdx
leaq 0x4c7d4d(%rip), %rdi    # 0x528688
leaq 0x4c7d54(%rip), %rsi    # 0x528696
movq $-0x1, %rcx
movl $0x1, %r8d
callq 0xf66b0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdx
addq $0x58, %rdx
leaq 0x4c7d4a(%rip), %rdi    # 0x5286c2
leaq 0x4c7d4e(%rip), %rsi    # 0x5286cd
movq $-0x1, %rcx
callq 0xf5fe0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdx
addq $0x68, %rdx
leaq 0x4c7d54(%rip), %rdi    # 0x528703
leaq 0x4c7d5a(%rip), %rsi    # 0x528710
movsd 0x4b8392(%rip), %xmm0   # 0x518d50
callq 0xf6160
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdx
addq $0x70, %rdx
leaq 0x4c7d53(%rip), %rdi    # 0x52873a
leaq 0x4c7d59(%rip), %rsi    # 0x528747
movsd 0x4b835a(%rip), %xmm0   # 0x518d50
callq 0xf6160
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdx
addq $0x78, %rdx
leaq 0x4c7d52(%rip), %rdi    # 0x528771
leaq 0x4c7d59(%rip), %rsi    # 0x52877f
movsd 0x4b8322(%rip), %xmm0   # 0x518d50
callq 0xf62c0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdx
addq $0x80, %rdx
leaq 0x4c7d55(%rip), %rdi    # 0x5287af
leaq 0x4c7d61(%rip), %rsi    # 0x5287c2
movsd 0x4b67d7(%rip), %xmm1   # 0x517240
movaps %xmm1, %xmm0
callq 0xf61d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf7040
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdx
addq $0x60, %rdx
leaq 0x4c7db9(%rip), %rdi    # 0x528858
leaq 0x4c7dbd(%rip), %rsi    # 0x528863
movq $-0x1, %rcx
movl $0x1, %r8d
callq 0xf66b0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xf7040
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rax
movq 0x98(%rax), %rdx
leaq 0x4c7db3(%rip), %rdi    # 0x52889c
leaq 0x4c7db7(%rip), %rsi    # 0x5288a7
callq 0xf6b00
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rax
movq 0xa0(%rax), %rdx
movq 0x5dbdf4(%rip), %rcx    # 0x63c910
leaq 0x4c7dd7(%rip), %rdi    # 0x5288fa
leaq 0x4c7ddb(%rip), %rsi    # 0x528905
leaq 0x5dbddf(%rip), %r8     # 0x63c910
callq 0xf6b30
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rax
movq 0xa8(%rax), %rdx
leaq 0x4c7dec(%rip), %rdi    # 0x528949
leaq 0x4c7df2(%rip), %rsi    # 0x528956
callq 0xf6aa0
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdi
callq 0xf5f90
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf7320
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf7090
movq 0x38(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq $0x90, %rdx
callq 0xf7d50
movq 0x30(%rsp), %rdi
leaq 0x1210fb(%rip), %rsi    # 0x181ce0
xorl %eax, %eax
movl %eax, %edx
callq 0xf1770
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)