// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_compress.c
// Function: gt_condenseq_compress_option_parser_new
static GtOptionParser*
gt_condenseq_compress_option_parser_new(void *tool_arguments)
{
  GtCondenseqCompressArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option,
           *option_fraction;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[options] INPUTENCSEQ",
                            "Compresses a GtEncseq to a UniqueEncseq.");

  /* -indexname */
  option = gt_option_new_string("indexname",
                                "path and basename of files to store",
                                arguments->indexname, NULL);
  gt_option_parser_add_option(op, option);

  /* -kmersize */
  option = gt_option_new_uint_min("kmersize",
                                  "kmer-size used for the seeds, default "
                                  "depends on alphabet size",
                                  &arguments->kmersize, GT_UNDEF_UINT, 2U);
  gt_option_parser_add_option(op, option);

  /* -windowsize */
  option = gt_option_new_uint("windowsize",
                              "Size of window in which to search for hit pairs "
                              "of kmers, has to be larger than kmersize" ,
                              &arguments->windowsize, GT_UNDEF_UINT);
  gt_option_parser_add_option(op, option);

  /* -initsize */
  option = gt_option_new_uword("initsize",
                               "length of initial unique database in bases, "
                               "should be larger than -alignlength",
                               &arguments->initsize, GT_UNDEF_UWORD);
  gt_option_parser_add_option(op, option);

  /* -alignlength */
  option = gt_option_new_uword("alignlength",
                               "required minimal length of an xdrop-alignment, "
                               "should be larger than -windowsize",
                               &arguments->minalignlength, GT_UNDEF_UWORD);
  gt_option_parser_add_option(op, option);

  /* -cutoff */
  option = gt_option_new_uword("cutoff",
                               "if a kmer is found more often than this value "
                               "it will be ignored for alignment searches. "
                               "Setting this to 0 will disable cutoffs, "
                               "leaving it undefined will use a cutoff based "
                               "on the mean number of occurrences of a k-word.",
                               &arguments->cutoff_value, GT_UNDEF_UWORD);
  gt_option_is_extended_option(option);
  gt_option_parser_add_option(op, option);

  /* -fraction */
  option_fraction = gt_option_new_uword("fraction",
                               "when cutoffs aren'd disabled and no specific "
                               "value is set the mean number of occurrences "
                               "of each kmer divided by -fraction will be used "
                               "as cutoff",
                               &arguments->fraction, (GtUword) 2);
  gt_option_is_extended_option(option_fraction);
  gt_option_exclude(option, option_fraction);
  gt_option_parser_add_option(op, option_fraction);

  /* -disable_prune */
  option = gt_option_new_bool("disable_prune",
                              "when cutoffs and this option are set, "
                              "the database will still save every kmer, even "
                              "though only cutoff many kmers will be used.",
                              &arguments->prune, false);
  gt_option_is_extended_option(option);
  gt_option_parser_add_option(op, option);

  /* -mat */
  option = gt_option_new_int("mat",
                             "matchscore for extension-alignment, "
                             "requirements: mat > mis, mat > 2ins, mat > 2del",
                             &arguments->scores.mat, 2);
  gt_option_is_extended_option(option);
  gt_option_parser_add_option(op, option);

  /* -mis */
  option = gt_option_new_int("mis",
                             "mismatchscore for extension-alignment, ",
                             &arguments->scores.mis, -1);
  gt_option_is_extended_option(option);
  gt_option_parser_add_option(op, option);

  /* -ins */
  option = gt_option_new_int("ins",
                             "insertionscore for extension-alignment",
                             &arguments->scores.ins, -2);
  gt_option_is_extended_option(option);
  gt_option_parser_add_option(op, option);

  /* -del */
  option = gt_option_new_int("del",
                             "deletionscore for extension-alignment",
                             &arguments->scores.del, -2);
  gt_option_is_extended_option(option);
  gt_option_parser_add_option(op, option);

  /* -xdrop */
  option = gt_option_new_word("xdrop",
                              "xdrop score for extension-alignment",
                              &arguments->xdrop, (GtWord) 3);
  gt_option_is_extended_option(option);
  gt_option_parser_add_option(op, option);

  /* -brute_force */
  option = gt_option_new_bool("brute_force", "disable filtering of seeds. "
                              "Incompatible with -diagonals yes "
                              "or -full_diags yes. For benchmarking use.",
                              &arguments->brute, false);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  /* -diagonals */
  option = gt_option_new_bool("diagonals", "use sparse diagonals. "
                              "Incompatible with -brute_force yes. "
                              "Disabling both diagonals will result in simple "
                              "filtering of seed positions.",
                              &arguments->diags, false);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  /* -full_diags */
  option = gt_option_new_bool("full_diags", "use full (time efficient "
                              "space inefficient) diagonals. "
                              "Incompatible with -brute_force yes. "
                              "Disabling both diagonals will result in simple "
                              "filtering of seed positions.",
                              &arguments->full_diags, false);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  /* -clean_percent */
  option = gt_option_new_uint("diags_clean",
                              "Percentage of sparse diagonals that is allowed "
                              "to be marked as deletable. Sensible default is "
                              "set." ,
                              &arguments->clean_percent, GT_UNDEF_UINT);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  /* -verbose */
  option = gt_option_new_bool("verbose", "enable verbose output",
                              &arguments->verbose, false);
  gt_option_parser_add_option(op, option);

  /* -kdb*/
  option = gt_option_new_bool("kdb", "prints out the kmer database (frequency "
                              "of each kmer), if -verbose each startposition "
                              "will be shown instead",
                              &arguments->kdb, false);
  gt_option_parser_add_option(op, option);

  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9ebd3
movq %rdi, %rbx
leaq 0x2a9d6b(%rip), %rdi    # 0x3485b2
leaq 0x2a9d7a(%rip), %rsi    # 0x3485c8
callq 0x107bfe
movq %rax, %r14
movq 0x8(%rbx), %rdx
leaq 0x2c72cc(%rip), %rdi    # 0x365b2d
leaq 0x2a9d89(%rip), %rsi    # 0x3485f1
xorl %ecx, %ecx
callq 0x10a770
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x48(%rbx), %rdx
leaq 0x3437ec(%rip), %rdi    # 0x3e2071
leaq 0x2a9d89(%rip), %rsi    # 0x348615
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x2, %r8d
callq 0x10a51f
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x4c(%rbx), %rdx
leaq 0x2a9e99(%rip), %rdi    # 0x34874b
leaq 0x2a9d9b(%rip), %rsi    # 0x348654
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x10a4fd
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x38(%rbx), %rdx
leaq 0x2a9dd4(%rip), %rdi    # 0x3486ad
leaq 0x2a9dd6(%rip), %rsi    # 0x3486b6
movq $-0x1, %rcx
callq 0x10a2ab
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x20(%rbx), %rdx
leaq 0x2a9df7(%rip), %rdi    # 0x3486f9
leaq 0x2a9dfc(%rip), %rsi    # 0x348705
movq $-0x1, %rcx
callq 0x10a2ab
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x28(%rbx), %rdx
leaq 0x2a9f93(%rip), %rdi    # 0x3488be
leaq 0x2a9e24(%rip), %rsi    # 0x348756
movq $-0x1, %rcx
callq 0x10a2ab
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x30(%rbx), %rdx
leaq 0x2daf53(%rip), %rdi    # 0x3798b2
leaq 0x2a9ecd(%rip), %rsi    # 0x348833
movl $0x2, %ecx
callq 0x10a2ab
movq %rax, %r12
movq %rax, %rdi
callq 0x10a9c4
movq %r15, %rdi
movq %r12, %rsi
callq 0x10ab96
movq %r14, %rdi
movq %r12, %rsi
callq 0x107cc0
leaq 0x59(%rbx), %rdx
leaq 0x2e6996(%rip), %rdi    # 0x385332
leaq 0x2a9f22(%rip), %rsi    # 0x3488c5
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x10(%rbx), %rdx
leaq 0x2bd1ec(%rip), %rdi    # 0x35bbb7
leaq 0x2a9f73(%rip), %rsi    # 0x348945
movl $0x2, %ecx
callq 0x10a44d
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x14(%rbx), %rdx
leaq 0x320407(%rip), %rdi    # 0x3bee04
leaq 0x2a9f95(%rip), %rsi    # 0x348999
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x10a44d
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x18(%rbx), %rdx
leaq 0x300177(%rip), %rdi    # 0x39eba6
leaq 0x2bed79(%rip), %rsi    # 0x35d7af
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x10a44d
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x1c(%rbx), %rdx
leaq 0x31e6b2(%rip), %rdi    # 0x3bd113
leaq 0x2bed76(%rip), %rsi    # 0x35d7de
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x10a44d
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x40(%rbx), %rdx
leaq 0x2db2a6(%rip), %rdi    # 0x379d39
leaq 0x2a9f27(%rip), %rsi    # 0x3489c1
movl $0x3, %ecx
callq 0x10a5ad
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x56(%rbx), %rdx
leaq 0x2f6d8f(%rip), %rdi    # 0x395854
leaq 0x2a9f19(%rip), %rsi    # 0x3489e5
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9d4
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x54(%rbx), %rdx
leaq 0x2dae54(%rip), %rdi    # 0x379948
leaq 0x2a9f51(%rip), %rsi    # 0x348a4c
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9d4
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x55(%rbx), %rdx
leaq 0x2a9faf(%rip), %rdi    # 0x348ad2
leaq 0x2a9fb3(%rip), %rsi    # 0x348add
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9d4
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x50(%rbx), %rdx
leaq 0x2db316(%rip), %rdi    # 0x379e68
leaq 0x2aa02b(%rip), %rsi    # 0x348b84
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x10a4fd
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9d4
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x57(%rbx), %rdx
leaq 0x2a8569(%rip), %rdi    # 0x3470ed
leaq 0x2aa05c(%rip), %rsi    # 0x348be7
xorl %ecx, %ecx
callq 0x10a235
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
addq $0x58, %rbx
leaq 0x2aa055(%rip), %rdi    # 0x348bfd
leaq 0x2aa052(%rip), %rsi    # 0x348c01
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1918b