// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq $0x61, 0xd8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x4cb550(%rip), %rdi    # 0x52331e
leaq 0x4ce2ca(%rip), %rsi    # 0x52609f
callq 0xf1420
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
leaq 0x4bf4f3(%rip), %rsi    # 0x5172e4
callq 0xf1a10
movq (%rsp), %rdx
leaq 0x50255b(%rip), %rdi    # 0x55a35c
leaq 0x4ce2c1(%rip), %rsi    # 0x5260c9
xorl %ecx, %ecx
callq 0xf64b0
movq %rax, 0x60(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xf1600
movq 0x60(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rdx
addq $0x52, %rdx
leaq 0x4d6673(%rip), %rdi    # 0x52e4c0
leaq 0x4ce297(%rip), %rsi    # 0x5260eb
movl $0x1, %ecx
callq 0xf5f20
movq %rax, 0x88(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xf1600
movq 0x88(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x80(%rax)
movq (%rsp), %rdx
addq $0x53, %rdx
leaq 0x4d4135(%rip), %rdi    # 0x52bfda
leaq 0x4ce257(%rip), %rsi    # 0x526103
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0xc0(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x54, %rdx
leaq 0x510263(%rip), %rdi    # 0x568142
leaq 0x4ce235(%rip), %rsi    # 0x52611b
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0xb8(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x4, %rdx
leaq 0x51a0a7(%rip), %rdi    # 0x571fc0
leaq 0x4ce21d(%rip), %rsi    # 0x52613d
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0xf6510
movq %rax, 0x78(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xf1600
movq 0x78(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x88(%rax)
movq (%rsp), %rdx
addq $0x20, %rdx
leaq 0x51abce(%rip), %rdi    # 0x572b39
leaq 0x4ce1ea(%rip), %rsi    # 0x52615c
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %r8d
callq 0xf66b0
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x18, %rdx
leaq 0x4ce1f8(%rip), %rdi    # 0x5261a5
leaq 0x4ce1fd(%rip), %rsi    # 0x5261b1
movl $0x61, %ecx
movl $0x5a, %r8d
movl $0x64, %r9d
callq 0xf6710
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
callq 0xf7450
movq 0xd0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x98(%rax)
movq (%rsp), %rdx
addq $0x8, %rdx
leaq 0x4ce1ed(%rip), %rdi    # 0x52620b
leaq 0x4ce1f1(%rip), %rsi    # 0x526216
xorl %eax, %eax
movl %eax, %ecx
callq 0xf6650
movq %rax, 0x48(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
leaq 0x4ce251(%rip), %rdi    # 0x5262a5
leaq 0x4ce257(%rip), %rsi    # 0x5262b2
movl $0x61, %ecx
movl $0x5a, %r8d
movl $0x64, %r9d
callq 0xf6710
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
callq 0xf7450
movq 0xd0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xf1600
movq 0xa0(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xa0(%rax)
movq (%rsp), %rdx
addq $0x38, %rdx
leaq 0x500af6(%rip), %rdi    # 0x558bbb
leaq 0x4ce258(%rip), %rsi    # 0x526324
movl $0xa, %ecx
movl $0x1, %r8d
movl $0x1e, %r9d
callq 0xf6710
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xf7040
movq 0xd0(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x38, %rdx
leaq 0x525890(%rip), %rdi    # 0x57d9a2
leaq 0x4ce2ab(%rip), %rsi    # 0x5263c4
movl $0x50, %ecx
movl $0x46, %r8d
movl $0x63, %r9d
callq 0xf6710
movq %rax, 0x70(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x40, %rdx
leaq 0x4ce2da(%rip), %rdi    # 0x52642f
leaq 0x4ce2e1(%rip), %rsi    # 0x52643d
xorl %eax, %eax
movl %eax, %ecx
callq 0xf5fe0
movq %rax, 0x68(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xf1600
movq 0x68(%rsp), %rdi
callq 0xf7040
movq (%rsp), %rdx
addq $0x28, %rdx
leaq 0x4ce3cd(%rip), %rdi    # 0x526562
leaq 0x4ce34c(%rip), %rsi    # 0x5264e8
movl $0x3c, %ecx
xorl %eax, %eax
movl %eax, %r8d
movl $0x40, %r9d
callq 0xf6710
movq %rax, 0x40(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xf1600
movq 0x40(%rsp), %rdi
callq 0xf7040
movq (%rsp), %rdx
addq $0x30, %rdx
leaq 0x4ce350(%rip), %rdi    # 0x526531
leaq 0x4ce358(%rip), %rsi    # 0x526540
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %r8d
movl $0x64, %r9d
callq 0xf6710
movq %rax, 0x38(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdi
callq 0xf7040
movq (%rsp), %rax
movq 0x60(%rax), %rdx
leaq 0x52e0a0(%rip), %rdi    # 0x5862cd
leaq 0x4cb1ce(%rip), %rsi    # 0x523402
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0xf1600
movq 0xc8(%rsp), %rdi
callq 0xf6ca0
callq 0x2ab520
movq %rax, %rsi
movq (%rsp), %rax
movq 0x70(%rax), %rdx
leaq 0x4ce2ec(%rip), %rdi    # 0x52656a
leaq 0x4ce2e9(%rip), %rcx    # 0x52656e
callq 0xf69f0
movq %rax, 0x58(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdi
callq 0xf7040
callq 0x265650
movq %rax, %rsi
movq (%rsp), %rax
movq 0xb0(%rax), %rdx
leaq 0x525bbe(%rip), %rdi    # 0x57de83
callq 0xf6a50
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0xb8, %rdx
leaq 0x4f1c58(%rip), %rdi    # 0x549f51
leaq 0x4ce276(%rip), %rsi    # 0x526576
movsd 0x4cdd78(%rip), %xmm0   # 0x526080
callq 0xf6160
movq %rax, 0x8(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x8(%rsp), %rdi
callq 0xf7450
movq 0x8(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xa8(%rax)
movq (%rsp), %rdx
addq $0x58, %rdx
leaq 0x4ce276(%rip), %rdi    # 0x5265cb
leaq 0x4ce279(%rip), %rsi    # 0x5265d5
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x20(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf1600
movq 0x20(%rsp), %rdi
callq 0xf7040
movq (%rsp), %rdx
addq $0x59, %rdx
leaq 0x4ce262(%rip), %rdi    # 0x5265f5
leaq 0x4ce26c(%rip), %rsi    # 0x526606
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x18(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdi
callq 0xf7040
movq (%rsp), %rdx
addq $0x57, %rdx
leaq 0x4ce256(%rip), %rdi    # 0x526627
leaq 0x4ce258(%rip), %rsi    # 0x526630
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x28(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x28(%rsp), %rdi
callq 0xf7040
movq (%rsp), %rax
movq 0x68(%rax), %rdx
leaq 0x52dec2(%rip), %rdi    # 0x5862d1
leaq 0x4ce233(%rip), %rsi    # 0x526649
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xf7040
movq 0xd0(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rax
movq 0x78(%rax), %rdx
leaq 0x500970(%rip), %rdi    # 0x558dbf
leaq 0x4ce20f(%rip), %rsi    # 0x526665
callq 0xf6b00
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xf7040
movq 0xd0(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x10, %rdx
leaq 0x4caf1d(%rip), %rdi    # 0x5233b1
leaq 0x4caf04(%rip), %rsi    # 0x52339f
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %r8d
callq 0xf66b0
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rdi
callq 0xf7040
movq 0xd0(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x55, %rdx
leaq 0x4c35ed(%rip), %rdi    # 0x51bad0
leaq 0x4ce18f(%rip), %rsi    # 0x526679
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0xf7040
movq 0xd0(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x56, %rdx
leaq 0x4ce170(%rip), %rdi    # 0x52669a
leaq 0x4ce17f(%rip), %rsi    # 0x5266b0
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x50(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xf1600
movq 0x50(%rsp), %rdi
callq 0xf7040
movq (%rsp), %rdx
addq $0x50, %rdx
leaq 0x4c5fee(%rip), %rdi    # 0x51e556
leaq 0x4ce196(%rip), %rsi    # 0x526705
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x98(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdi
addq $0x51, %rdi
callq 0xf5f90
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0xf1600
movq 0xb0(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0xf7320
movq 0xb0(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0xf7320
movq 0xb0(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xf7320
movq 0xb0(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf7320
movq 0x90(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xf7320
movq 0xc0(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xf7320
movq 0xb8(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xf7320
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0xf7320
movq 0x30(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xf7320
movq 0x48(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0xf7090
movq 0x40(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xf7090
movq 0x68(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xf7090
movq 0x38(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xf7090
movq 0x28(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xf7090
movq 0x20(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0xf7090
movq 0x78(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0xf7150
movq 0x70(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0xf7150
movq 0x30(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0xf7150
movq 0xd0(%rsp), %rax
addq $0xe8, %rsp
retq
nopl (%rax,%rax)