// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_repfind.c
// Function: gt_repfind_option_parser_new
static GtOptionParser *gt_repfind_option_parser_new(void *tool_arguments)
{
  const GtUword extension_sensitivity = 97;
  GtOptionParser *op;
  GtOption *option, *reverseoption, *reverse_complementoption,
           *option_query_files, *extendxdropoption,
           *extendgreedyoption, *scanoption, *sampleoption, *forwardoption,
           *spmoption, *seedlengthoption, *minidentityoption,
           *maxalilendiffoption, *leastlength_option, *char_access_mode_option,
           *check_extend_symmetry_option, *xdropbelowoption, *historyoption,
           *percmathistoryoption, *errorpercentageoption, *optiontrimstat,
           *optionnoxpolish, *verify_alignment_option, *option_query_indexname,
           *op_evalue;
  GtMaxpairsoptions *arguments = tool_arguments;

  op = gt_option_parser_new("[options] -ii indexname",
                                  "Compute maximal exact matches (and more).");
  gt_option_parser_set_mail_address(op,"<kurtz@zbh.uni-hamburg.de>");

  leastlength_option
    = gt_option_new_uint("l","Specify minimum length of matches",
                         &arguments->userdefinedleastlength,
                         0U);
  gt_option_parser_add_option(op, leastlength_option);
  arguments->refuserdefinedleastlengthoption
    = gt_option_ref(leastlength_option);

  forwardoption = gt_option_new_bool("f","Compute forward matches",
                                     &arguments->forward,
                                     true);
  gt_option_parser_add_option(op, forwardoption);
  arguments->refforwardoption = gt_option_ref(forwardoption);

  reverseoption = gt_option_new_bool("r","Compute reverse matches",
                                     &arguments->reverse,
                                     false);
  gt_option_parser_add_option(op, reverseoption);

  reverse_complementoption = gt_option_new_bool("p",
                                        "Compute matches on reverse strand",
                                        &arguments->reverse_complement,
                                        false);
  gt_option_parser_add_option(op, reverse_complementoption);

  seedlengthoption = gt_option_new_uint_min("seedlength",
                                             "Specify minimum length of seed",
                                             &arguments->seedlength,
                                             0,
                                             1UL);
  gt_option_parser_add_option(op, seedlengthoption);
  arguments->refseedlengthoption = gt_option_ref(seedlengthoption);

  option = gt_option_new_uword_min("maxfreq",
                                   "Specify maximal frequency of maximal exact "
                                   "matches in reference sequence",
                                   &arguments->maxfreq,
                                   0,
                                   2UL);
  gt_option_parser_add_option(op, option);

  extendxdropoption
    = gt_option_new_uword_min_max("extendxdrop",
                         "Extend seed to both sides using xdrop algorithm, "
                         "optional parameter specifies sensitivity",
                         &arguments->extendxdrop,
                         extension_sensitivity, 90, 100);
  gt_option_argument_is_optional(extendxdropoption);
  gt_option_parser_add_option(op, extendxdropoption);
  arguments->refextendxdropoption = gt_option_ref(extendxdropoption);

  xdropbelowoption = gt_option_new_word("xdropbelow",
                                        "Specify xdrop cutoff score "
                                        "(argument 0 means undefined). If "
                                        "undefined an optimal value is "
                                        "determined automatically depending "
                                        "on the error "
                                        "rate",
                                        &arguments->xdropbelowscore,
                                        0);
  gt_option_parser_add_option(op, xdropbelowoption);

  extendgreedyoption
    = gt_option_new_uword_min_max("extendgreedy",
                                  "Extend seed to both sides using "
                                  "greedy algorithm with trimming of waves, "
                                  "optional parameter specifies sensitivity",
                                  &arguments->extendgreedy,
                                  extension_sensitivity, 90, 100);
  gt_option_argument_is_optional(extendgreedyoption);
  gt_option_parser_add_option(op, extendgreedyoption);
  arguments->refextendgreedyoption = gt_option_ref(extendgreedyoption);

  errorpercentageoption
    = gt_option_new_uword_min_max("err","Specify error percentage of matches "
                         "as integer in the range from 1 to 30 "
                         "(for xdrop and greedy extension) [deprecated option, "
                         "kept for backwards compatibility]",
                         &arguments->minidentity,
                         10,
                         1,
                         100 - GT_EXTEND_MIN_IDENTITY_PERCENTAGE);
  gt_option_is_development_option(errorpercentageoption);
  gt_option_parser_add_option(op, errorpercentageoption);

  minidentityoption
    = gt_option_new_uword_min_max("minidentity",
                          "Specify minimum identity of matches\n"
                          "as integer in the range from 70 to 99 "
                          "(for xdrop and greedy extension)",
                          &arguments->minidentity,
                          80,
                          GT_EXTEND_MIN_IDENTITY_PERCENTAGE,99);
  gt_option_parser_add_option(op, minidentityoption);

  maxalilendiffoption
    = gt_option_new_uword("maxalilendiff","Specify maximum difference of "
                          "alignment length (trimming for greedy extension), "
                          "if option is not used or parameter 0 is specified, "
                          "then good value is automatically chosen",
                          &arguments->maxalignedlendifference,
                          0);
  gt_option_parser_add_option(op, maxalilendiffoption);
  gt_option_is_development_option(maxalilendiffoption);

  historyoption
    = gt_option_new_uword_min_max("history",
                                  "Specify size of history in range [1..64] "
                                  "(trimming for greedy extension)",
                                  &arguments->historysize,
                                  60,
                                  0,
                                  64);
  gt_option_parser_add_option(op, historyoption);
  gt_option_is_development_option(historyoption);

  percmathistoryoption
    = gt_option_new_uword_min_max("percmathistory",
                                  "percentage of matches required in history",
                                  &arguments->perc_mat_history,
                                  0,
                                  1,
                                  100);
  gt_option_parser_add_option(op, percmathistoryoption);
  gt_option_is_development_option(percmathistoryoption);

  option = gt_option_new_string("ii",
                                "Specify input index",
                                arguments->indexname, NULL);
  gt_option_parser_add_option(op, option);
  gt_option_is_mandatory(option);

  char_access_mode_option = gt_option_new_string("cam",
                                                 gt_cam_extendgreedy_comment(),
                                                 arguments->cam_string,
                                                 "any,any");
  gt_option_parser_add_option(op, char_access_mode_option);
  gt_option_is_development_option(char_access_mode_option);

  /* -outfmt */
  option = gt_option_new_string_array("outfmt",
                                      gt_querymatch_display_help(),
                                      arguments->display_args);
  gt_option_parser_add_option(op, option);

  /* -evalue */
  op_evalue = gt_option_new_double("evalue","switch on evalue filtering of "
                                            "matches (optional argument "
                                            "specifies evalue threshold)",
                                   &arguments->evalue_threshold,
                                   10.0);
  gt_option_parser_add_option(op, op_evalue);
  gt_option_argument_is_optional(op_evalue);
  arguments->ref_op_evalue = gt_option_ref(op_evalue);

  optionnoxpolish
    = gt_option_new_bool("noxpolish","do not polish X-drop extensions",
                         &arguments->noxpolish, false);
  gt_option_parser_add_option(op, optionnoxpolish);
  gt_option_is_development_option(optionnoxpolish);

  verify_alignment_option
    = gt_option_new_bool("verify-alignment","verify correctness of alignments",
                         &arguments->verify_alignment, false);
  gt_option_parser_add_option(op, verify_alignment_option);
  gt_option_is_development_option(verify_alignment_option);

  optiontrimstat = gt_option_new_bool("trimstat","show trimming statistics",
                                      &arguments->trimstat_on, false);
  gt_option_parser_add_option(op, optiontrimstat);
  gt_option_is_development_option(optiontrimstat);

  option_query_indexname = gt_option_new_string("qii",
                                                "Specify name of query index",
                                                arguments->query_indexname,
                                                NULL);
  gt_option_is_development_option(option_query_indexname);
  gt_option_parser_add_option(op, option_query_indexname);

  /* the following option are options special to repfind */

  option_query_files = gt_option_new_filename_array("q",
                                                    "Specify query files",
                                                    arguments->query_files);
  gt_option_is_development_option(option_query_files);
  gt_option_parser_add_option(op, option_query_files);

  sampleoption = gt_option_new_uword_min("samples","Specify number of samples",
                                         &arguments->samples,
                                         0,
                                         1UL);
  gt_option_is_development_option(sampleoption);
  gt_option_parser_add_option(op, sampleoption);

  spmoption = gt_option_new_bool("spm","Search for suffix prefix matches",
                                       &arguments->searchspm,
                                       false);
  gt_option_is_development_option(spmoption);
  gt_option_parser_add_option(op, spmoption);

  check_extend_symmetry_option
    = gt_option_new_bool("check_extend_symmetry",
                         "check that left/right greedy extension is symmetric "
                         "for sequences mirror around seed",
                         &arguments->check_extend_symmetry,
                         false);
  gt_option_parser_add_option(op, check_extend_symmetry_option);
  gt_option_is_development_option(check_extend_symmetry_option);

  scanoption = gt_option_new_bool("scan","scan index rather than map "
                                         "it to main memory",
                                  &arguments->scanfile,
                                  false);
  gt_option_parser_add_option(op, scanoption);

  option = gt_option_new_verbose(&arguments->beverbose);
  gt_option_parser_add_option(op, option);

  gt_option_exclude(option_query_files,sampleoption);
  gt_option_exclude(option_query_files,scanoption);
  gt_option_exclude(option_query_files,spmoption);
  gt_option_exclude(option_query_files,option_query_indexname);
  gt_option_exclude(sampleoption,spmoption);
  gt_option_exclude(reverseoption,spmoption);
  gt_option_exclude(reverse_complementoption,spmoption);
  gt_option_exclude(extendgreedyoption,extendxdropoption);
  gt_option_exclude(errorpercentageoption,minidentityoption);
  gt_option_imply(xdropbelowoption,extendxdropoption);
  gt_option_imply(historyoption,extendgreedyoption);
  gt_option_imply(maxalilendiffoption,extendgreedyoption);
  gt_option_imply(percmathistoryoption,extendgreedyoption);
  gt_option_imply(optiontrimstat,extendgreedyoption);
  gt_option_imply(optionnoxpolish,extendxdropoption);
  gt_option_imply_either_2(seedlengthoption,extendxdropoption,
                           extendgreedyoption);
  gt_option_imply_either_2(minidentityoption,extendxdropoption,
                           extendgreedyoption);
  gt_option_imply_either_2(errorpercentageoption,extendxdropoption,
                           extendgreedyoption);
  return op;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
leaq 0x2b2d88(%rip), %rdi    # 0x2f22ae
leaq 0x2b5aba(%rip), %rsi    # 0x2f4fe7
callq 0x97df5
movq %rax, %rbx
leaq 0x2a6d90(%rip), %rsi    # 0x2e62cc
movq %rax, %rdi
callq 0x98288
leaq 0x2e8a27(%rip), %rdi    # 0x327f72
leaq 0x2b5abf(%rip), %rsi    # 0x2f5011
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9abcd
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x97db0
movq %rax, 0x90(%r14)
leaq 0x52(%r14), %rdx
leaq 0x2bdbc7(%rip), %rdi    # 0x2fd14b
leaq 0x2b5aa8(%rip), %rsi    # 0x2f5033
pushq $0x1
popq %rbp
movl %ebp, %ecx
callq 0x9a997
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x97db0
movq %rax, 0x80(%r14)
leaq 0x53(%r14), %rdx
leaq 0x2bb870(%rip), %rdi    # 0x2fae2d
leaq 0x2b5a87(%rip), %rsi    # 0x2f504b
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x68(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x54(%r14), %rdx
leaq 0x2f6548(%rip), %rdi    # 0x335b2e
leaq 0x2b5a76(%rip), %rsi    # 0x2f5063
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x60(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x4(%r14), %rdx
leaq 0x3008d9(%rip), %rdi    # 0x33fee8
leaq 0x2b5a6f(%rip), %rsi    # 0x2f5085
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x9abef
movq %rax, %r15
movq %rax, 0x70(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x97db0
movq %rax, 0x88(%r14)
leaq 0x20(%r14), %rdx
leaq 0x2b5a57(%rip), %rdi    # 0x2f50a4
leaq 0x2b5a58(%rip), %rsi    # 0x2f50ac
pushq $0x2
popq %r8
xorl %ecx, %ecx
callq 0x9ac58
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x18(%r14), %rdx
leaq 0x2b5a80(%rip), %rdi    # 0x2f50f5
leaq 0x2b5a85(%rip), %rsi    # 0x2f5101
pushq $0x61
popq %r12
pushq $0x5a
popq %r13
pushq $0x64
popq %r15
movq %r12, %rcx
movq %r13, %r8
movq %r15, %r9
callq 0x9ac6b
movq %rax, %rbp
movq %rax, 0x58(%rsp)
movq %rax, %rdi
callq 0x9b488
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x97f31
movq %rbp, %rdi
callq 0x97db0
movq %rax, 0x98(%r14)
leaq 0x8(%r14), %rdx
leaq 0x2b5a90(%rip), %rdi    # 0x2f515b
leaq 0x2b5a94(%rip), %rsi    # 0x2f5166
xorl %ecx, %ecx
callq 0x9ac34
movq %rax, 0x50(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x48(%r14), %rdx
leaq 0x2b5b01(%rip), %rdi    # 0x2f51f5
leaq 0x2b5b07(%rip), %rsi    # 0x2f5202
movq %r12, %rcx
movq %r13, %r8
movq %r15, %r9
callq 0x9ac6b
movq %rax, %r12
movq %rax, 0x48(%rsp)
movq %rax, %rdi
callq 0x9b488
movq %rbx, %rdi
movq %r12, %rsi
callq 0x97f31
movq %r12, %rdi
callq 0x97db0
movq %rax, 0xa0(%r14)
leaq 0x38(%r14), %r12
leaq 0x2e7106(%rip), %rdi    # 0x326844
leaq 0x2b5b2f(%rip), %rsi    # 0x2f5274
pushq $0xa
popq %rcx
pushq $0x1
popq %rbp
pushq $0x1e
popq %r9
movq %r12, %rdx
movq %rbp, %r8
callq 0x9ac6b
movq %rax, %r13
movq %rax, 0x40(%rsp)
movq %rax, %rdi
callq 0x9b10a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x97f31
leaq 0x30bb2f(%rip), %rdi    # 0x34b2ab
leaq 0x2b5b91(%rip), %rsi    # 0x2f5314
pushq $0x50
popq %rcx
pushq $0x46
popq %r8
pushq $0x63
popq %r9
movq %r12, %rdx
callq 0x9ac6b
movq %rax, 0x38(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x40(%r14), %rdx
leaq 0x2b5bce(%rip), %rdi    # 0x2f537f
leaq 0x2b5bd5(%rip), %rsi    # 0x2f538d
xorl %ecx, %ecx
callq 0x9a9e6
movq %rax, %r12
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r12, %rdi
callq 0x9b10a
leaq 0x28(%r14), %rdx
leaq 0x2b5ccd(%rip), %rdi    # 0x2f54b2
leaq 0x2b5c4c(%rip), %rsi    # 0x2f5438
pushq $0x3c
popq %rcx
pushq $0x40
popq %r9
xorl %r8d, %r8d
callq 0x9ac6b
movq %rax, %r12
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r12, %rdi
callq 0x9b10a
leaq 0x30(%r14), %rdx
leaq 0x2b5c60(%rip), %rdi    # 0x2f5481
leaq 0x2b5c68(%rip), %rsi    # 0x2f5490
xorl %ecx, %ecx
movq %rbp, %r8
movq %r15, %r9
callq 0x9ac6b
movq %rax, %r15
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9b10a
movq 0x60(%r14), %rdx
leaq 0x314078(%rip), %rdi    # 0x3538d3
leaq 0x2b2b30(%rip), %rsi    # 0x2f2392
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9ae37
callq 0x18edf9
movq 0x70(%r14), %rdx
leaq 0x2b5c2b(%rip), %rdi    # 0x2f54ba
leaq 0x2b5c28(%rip), %rcx    # 0x2f54be
movq %rax, %rsi
callq 0x9ad12
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9b10a
callq 0x16908c
movq 0xb0(%r14), %rdx
leaq 0x30be2c(%rip), %rdi    # 0x34b6f3
movq %rax, %rsi
callq 0x9ad43
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0xb8(%r14), %rdx
leaq 0x2d86b5(%rip), %rdi    # 0x317f9d
leaq 0x2b5bd7(%rip), %rsi    # 0x2f54c6
movsd 0x2b56b9(%rip), %xmm0   # 0x2f4fb0
callq 0x9aad7
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9b488
movq %r15, %rdi
callq 0x97db0
movq %rax, 0xa8(%r14)
leaq 0x58(%r14), %rdx
leaq 0x2b5bef(%rip), %rdi    # 0x2f551b
leaq 0x2b5bf2(%rip), %rsi    # 0x2f5525
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9b10a
leaq 0x59(%r14), %rdx
leaq 0x2b5be5(%rip), %rdi    # 0x2f5545
leaq 0x2b5bef(%rip), %rsi    # 0x2f5556
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9b10a
leaq 0x57(%r14), %rdx
leaq 0x2b5be8(%rip), %rdi    # 0x2f5577
leaq 0x2b5bea(%rip), %rsi    # 0x2f5580
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9b10a
movq 0x68(%r14), %rdx
leaq 0x313f14(%rip), %rdi    # 0x3538d7
leaq 0x2b5bcf(%rip), %rsi    # 0x2f5599
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x9b10a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
movq 0x78(%r14), %rdx
leaq 0x2e7051(%rip), %rdi    # 0x326a48
leaq 0x2b5bb7(%rip), %rsi    # 0x2f55b5
callq 0x9ad7e
movq %rax, %r13
movq %rax, %rdi
callq 0x9b10a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x97f31
leaq 0x10(%r14), %rdx
leaq 0x2b291d(%rip), %rdi    # 0x2f2341
leaq 0x2b2904(%rip), %rsi    # 0x2f232f
xorl %ecx, %ecx
movq %rbp, %r8
callq 0x9ac58
movq %rax, %rbp
movq %rax, %rdi
callq 0x9b10a
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x97f31
leaq 0x55(%r14), %rdx
leaq 0x2ab021(%rip), %rdi    # 0x2eaa77
leaq 0x2b5b6c(%rip), %rsi    # 0x2f55c9
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r12
movq %rax, %rdi
callq 0x9b10a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x97f31
leaq 0x56(%r14), %rdx
leaq 0x2b5b65(%rip), %rdi    # 0x2f55ea
leaq 0x2b5b74(%rip), %rsi    # 0x2f5600
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9b10a
leaq 0x50(%r14), %rdx
leaq 0x2ada02(%rip), %rdi    # 0x2ed4b6
leaq 0x2b5b9a(%rip), %rsi    # 0x2f5655
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
addq $0x51, %r14
movq %r14, %rdi
callq 0x9a9b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r13, %rdi
movq %rbp, %rsi
callq 0x9b38d
movq %r13, %rdi
movq %r15, %rsi
callq 0x9b38d
movq %r13, %rdi
movq %r12, %rsi
callq 0x9b38d
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x9b38d
movq %rbp, %rdi
movq %r12, %rsi
callq 0x9b38d
movq 0x68(%rsp), %rdi
movq %r12, %rsi
callq 0x9b38d
movq 0x60(%rsp), %rdi
movq %r12, %rsi
callq 0x9b38d
movq 0x48(%rsp), %r15
movq %r15, %rdi
movq 0x58(%rsp), %r14
movq %r14, %rsi
callq 0x9b38d
movq 0x40(%rsp), %r12
movq %r12, %rdi
movq 0x38(%rsp), %r13
movq %r13, %rsi
callq 0x9b38d
movq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x9b14d
movq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x9b14d
movq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x9b14d
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x9b14d
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x9b14d
movq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x9b14d
movq 0x70(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9b1ed
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9b1ed
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9b1ed
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq