// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_hop.c
// Function: gt_hop_option_parser_new
static GtOptionParser* gt_hop_option_parser_new(void *tool_arguments)
{
  GtHopArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option, *ann_option, *aggressive_option, *conservative_option,
           *moderate_option, *expert_option, *o_option, *reads_option,
           *stats_option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("-<mode> -c <encseq> -map <sam/bam> "
      "-reads <fastq> [options...]",
      "Cognate sequence-based homopolymer error correction.");

  /* -c */
  option = gt_option_new_string("c",
      "cognate sequence\n"
      "(encoded using gt encseq encode)",
      arguments->encseqinput, NULL);
  gt_option_is_mandatory(option);
  gt_option_hide_default(option);
  gt_option_parser_add_option(op, option);

  /* -map */
  option = gt_option_new_string("map",
      "mapping of reads to the cognate sequence\n"
      "it must be in SAM/BAM format, and sorted by coordinate\n"
      "(can be prepared e.g. using: samtools sort)",
      arguments->map, NULL);
  gt_option_is_mandatory(option);
  gt_option_hide_default(option);
  gt_option_parser_add_option(op, option);

  /* -sam */
  option = gt_option_new_bool("sam",
      "mapping file is SAM\ndefault: BAM",
      &arguments->map_is_sam, false);
  gt_option_hide_default(option);
  gt_option_parser_add_option(op, option);

  /* -aggressive */
  aggressive_option = gt_option_new_bool("aggressive",
      "correct as much as possible",
       &arguments->aggressive, false);
  gt_option_hide_default(aggressive_option);
  gt_option_parser_add_option(op, aggressive_option);

  /* -moderate */
  moderate_option = gt_option_new_bool("moderate",
      "mediate between sensitivity and precision",
      &arguments->moderate, false);
  gt_option_hide_default(moderate_option);
  gt_option_exclude(moderate_option, aggressive_option);
  gt_option_parser_add_option(op, moderate_option);

  /* -conservative */
  conservative_option = gt_option_new_bool("conservative",
      "correct only most likely errors",
      &arguments->conservative, false);
  gt_option_hide_default(conservative_option);
  gt_option_exclude(conservative_option, aggressive_option);
  gt_option_exclude(conservative_option, moderate_option);
  gt_option_parser_add_option(op, conservative_option);

  /* -expert */
  expert_option = gt_option_new_bool("expert",
      "manually select correction criteria",
      &arguments->expert, false);
  gt_option_hide_default(expert_option);
  gt_option_exclude(expert_option, aggressive_option);
  gt_option_exclude(expert_option, moderate_option);
  gt_option_exclude(expert_option, conservative_option);
  gt_option_parser_add_option(op, expert_option);

  /* -reads */
  reads_option = gt_option_new_filename_array("reads",
      "uncorrected read file(s) in FastQ format;\n"
      "the corrected reads are output in the currect working directory "
      "in files which are named as the input files, each prepended "
      "by a prefix (see -outprefix option)\n"
      "-reads allows one to output the reads in the same order as in the input "
      "and is mandatory if the SAM contains more than a single primary "
      "alignment for each read (e.g. output of bwasw)\n"
      "see also -o option as an alternative",
      arguments->readset);
  gt_option_parser_add_option(op, reads_option);

  /* -outprefix */
  option = gt_option_new_string("outprefix",
      "prefix for output filenames (corrected reads)"
      "when -reads is specified\n"
      "the prefix is prepended to each input filename",
      arguments->outprefix, "hop_");
  gt_option_imply(option, reads_option);
  gt_option_parser_add_option(op, option);

  /* -o */
  o_option = gt_option_new_string("o", "output file for corrected reads\n"
      "(see also -reads/-outprefix) if -o is used, reads are output "
      "in a single file in the order they are found in the SAM file "
      "(which usually differ from the original order)\n"
      "this will only work if the reads were aligned with a software which "
      "only includes 1 alignment for each read (e.g. bwa)",
      arguments->outfilename, NULL);
  gt_option_exclude(reads_option, o_option);
  gt_option_is_mandatory_either(reads_option, o_option);
  gt_option_parser_add_option(op, o_option);

  /* -hmin */
  option = gt_option_new_uword_min("hmin",
      "minimal homopolymer length in cognate sequence",
      &arguments->hmin, 3UL, 2UL);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -read-hmin */
  option = gt_option_new_uword_min("read-hmin",
      "minimal homopolymer length in reads",
      &arguments->read_hmin, 2UL, 1UL);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -qmax */
  option = gt_option_new_uword("qmax",
      "maximal average quality of homopolymer in a read",
      &arguments->qmax, 120UL);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -altmax */
  option = gt_option_new_double_min_max("altmax",
      "max support of alternate homopol. length;\n"
      "e.g. 0.8 means: do not correct any read if homop. length in more than "
      "80%% of the reads has the same value, different from the cognate\n"
      "if altmax is set to 1.0 reads are always corrected",
      &arguments->altmax, (double) 0.8, 0.0, (double) 1.0);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -cogmin */
  option = gt_option_new_double_min_max("cogmin",
      "min support of cognate sequence homopol. length;\n"
      "e.g. 0.1 means: do not correct any read if cognate homop. length "
      "is not present in at least 10%% of the reads\n"
      "if cogmin is set to 0.0 reads are always corrected",
      &arguments->cogmin, (double) 0.1, 0.0, (double) 1.0);
  gt_option_hide_default(option);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -mapqmin */
  option = gt_option_new_uword("mapqmin",
      "minimal mapping quality",
      &arguments->mapqmin, 21UL);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -covmin */
  option = gt_option_new_uword_min("covmin",
      "minimal coverage;\n"
      "e.g. 5 means: do not correct any read if coverage "
      "(number of reads mapped over whole homopolymer) "
      "is less than 5\n"
      "if covmin is set to 1 reads are always corrected",
      &arguments->covmin, 1UL, 1UL);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -allow-multiple */
  option = gt_option_new_bool("allow-muliple",
      "allow multiple corrections in a read",
      &arguments->allow_multiple, false);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -clenmax */
  option = gt_option_new_uword("clenmax", "maximal correction length\n"
      "default: unlimited", &arguments->clenmax, GT_UNDEF_UWORD);
  gt_option_hide_default(option);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -ann */
  ann_option = gt_option_new_string("ann",
      "annotation of cognate sequence\n"
      "it must be sorted by coordinates on the cognate sequence\n"
      "(this can be e.g. done using: gt gff3 -sort)\n"
      "if -ann is used, corrections will be limited to homopolymers starting"
      "or ending inside the feature type indicated by -ft option"
      "format: sorted GFF3",
      arguments->annotation, NULL);
  gt_option_is_extended_option(ann_option);
  gt_option_parser_add_option(op, ann_option);

  /* -ft */
  option = gt_option_new_string("ft", "feature type to use when -ann option "
      "is specified",
      arguments->atype, gt_ft_CDS);
  gt_option_is_extended_option(option);
  gt_option_imply(option, ann_option);
  gt_option_parser_add_option(op, option);

  /* -stats */
  stats_option = gt_option_new_bool("stats", "output statistics for each "
      "correction position", &arguments->stats, false);
  gt_option_is_development_option(stats_option);
  gt_option_parser_add_option(op, stats_option);

  /* -state-of-truth */
  option = gt_option_new_bool("state-of-truth",
      "similar to -stats in -aggressive "
      "mode, but used to determine the \"state of truth\" set of corrections "
      "for evaluation; currently the only difference is that if multiple hits "
      "are present for a read, they are used all independently for "
      "correction (-reads must be set)",
      &arguments->state_of_truth, false);
  gt_option_is_development_option(option);
  gt_option_exclude(option, aggressive_option);
  gt_option_exclude(option, moderate_option);
  gt_option_exclude(option, conservative_option);
  gt_option_exclude(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -chk */
  option = gt_option_new_bool("chk", "debug option; check that cognate region "
      "of aligned segments is compatible with encseq data",
      &arguments->chk, false);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  /* -allow-partial */
  option = gt_option_new_bool("allow-partial",
      "allow insertions also if there are less gaps in read homopolymer "
      "than the difference in length with the cognate sequence\n"
      "(at most as many symbols as the gaps will be inserted)",
      &arguments->allow_partial, false);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

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

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);

  gt_option_parser_set_min_max_args(op, 0, 0);

  return op;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x3cb23
movq 0x5ff4ae(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d9517(%rip), %rsi    # 0x516013
leaq 0x53e05c(%rip), %rdx    # 0x57ab5f
leaq 0x4e27de(%rip), %rcx    # 0x51f2e8
leaq 0x4e27c4(%rip), %r8     # 0x51f2d5
movl $0x47, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x3cb25
leaq 0x4e27d5(%rip), %rdi    # 0x51f301
leaq 0x4e280d(%rip), %rsi    # 0x51f340
callq 0xf1420
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rdx
leaq 0x55aa6c(%rip), %rdi    # 0x5975b8
leaq 0x4e2822(%rip), %rsi    # 0x51f375
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf6ca0
movq 0x48(%rsp), %rdi
callq 0xf7400
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x537a5a(%rip), %rdi    # 0x5745ee
leaq 0x4e280c(%rip), %rsi    # 0x51f3a7
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf6ca0
movq 0x48(%rsp), %rdi
callq 0xf7400
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x61, %rdx
leaq 0x4e2857(%rip), %rdi    # 0x51f433
leaq 0x4e2854(%rip), %rsi    # 0x51f437
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf7400
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x66, %rdx
leaq 0x4e2840(%rip), %rdi    # 0x51f458
leaq 0x4e2844(%rip), %rsi    # 0x51f463
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0xf7400
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x67, %rdx
leaq 0x4e282b(%rip), %rdi    # 0x51f47f
leaq 0x4e282d(%rip), %rsi    # 0x51f488
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xf7400
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf7320
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x68, %rdx
leaq 0x4e2813(%rip), %rdi    # 0x51f4b2
leaq 0x4e2819(%rip), %rsi    # 0x51f4bf
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xf7400
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf7320
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf7320
movq 0x50(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x69, %rdx
leaq 0x4e25b1(%rip), %rdi    # 0x51f2aa
leaq 0x4e27df(%rip), %rsi    # 0x51f4df
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xf7400
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf7320
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf7320
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf7320
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rax
movq 0x80(%rax), %rdx
leaq 0x4e8aa6(%rip), %rdi    # 0x52580b
leaq 0x4e2797(%rip), %rsi    # 0x51f503
callq 0xf6b00
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rax
movq 0x28(%rax), %rdx
leaq 0x4e2914(%rip), %rdi    # 0x51f6a9
leaq 0x4e2917(%rip), %rsi    # 0x51f6b3
leaq 0x4e2985(%rip), %rcx    # 0x51f728
callq 0xf69f0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf7090
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rdx
leaq 0x513319(%rip), %rdi    # 0x5500f4
leaq 0x4e294b(%rip), %rsi    # 0x51f72d
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf7320
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf6cf0
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x30, %rdx
leaq 0x4e2a74(%rip), %rdi    # 0x51f8a1
leaq 0x4e2a39(%rip), %rsi    # 0x51f86d
movl $0x3, %ecx
movl $0x2, %r8d
callq 0xf66b0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf6ff0
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf7090
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x40, %rdx
leaq 0x4e2a1b(%rip), %rdi    # 0x51f89c
leaq 0x4e2a1e(%rip), %rsi    # 0x51f8a6
movl $0x2, %ecx
movl $0x1, %r8d
callq 0xf66b0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf6ff0
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf7090
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x58, %rdx
leaq 0x4e29f5(%rip), %rdi    # 0x51f8ca
leaq 0x4e29f3(%rip), %rsi    # 0x51f8cf
movl $0x78, %ecx
callq 0xf5fe0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf6ff0
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf7090
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x70, %rdx
leaq 0x4e29dd(%rip), %rdi    # 0x51f900
leaq 0x4e29dd(%rip), %rsi    # 0x51f907
movsd 0x4e2326(%rip), %xmm0   # 0x51f258
xorps %xmm1, %xmm1
movsd 0x4da303(%rip), %xmm2   # 0x517240
callq 0xf6240
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf6ff0
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf7090
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x78, %rdx
leaq 0x4e2a6c(%rip), %rdi    # 0x51f9eb
leaq 0x4e2a6c(%rip), %rsi    # 0x51f9f2
movsd 0x4e22c2(%rip), %xmm0   # 0x51f250
xorps %xmm1, %xmm1
movsd 0x4da2a7(%rip), %xmm2   # 0x517240
callq 0xf6240
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf7400
movq 0x48(%rsp), %rdi
callq 0xf6ff0
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf7090
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x50, %rdx
leaq 0x4e2adf(%rip), %rdi    # 0x51fac4
leaq 0x4e2ae0(%rip), %rsi    # 0x51facc
movl $0x15, %ecx
callq 0xf5fe0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf6ff0
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf7090
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x48, %rdx
leaq 0x4e2ab1(%rip), %rdi    # 0x51fae4
leaq 0x4e2ab1(%rip), %rsi    # 0x51faeb
movl $0x1, %r8d
movq %r8, %rcx
callq 0xf66b0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf6ff0
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf7090
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x65, %rdx
leaq 0x4e2b1a(%rip), %rdi    # 0x51fb9f
leaq 0x4e2b21(%rip), %rsi    # 0x51fbad
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf6ff0
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf7090
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x38, %rdx
leaq 0x4e2b02(%rip), %rdi    # 0x51fbd2
leaq 0x4e2b03(%rip), %rsi    # 0x51fbda
movq $-0x1, %rcx
callq 0xf5fe0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf7400
movq 0x48(%rsp), %rdi
callq 0xf6ff0
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf7090
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x4e2add(%rip), %rdi    # 0x51fc07
leaq 0x4e2ada(%rip), %rsi    # 0x51fc0b
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0xf6ff0
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rax
movq 0x20(%rax), %rdx
leaq 0x5284dd(%rip), %rdi    # 0x565645
leaq 0x4e2bb3(%rip), %rsi    # 0x51fd22
leaq 0x517942(%rip), %rcx    # 0x554ab8
callq 0xf69f0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf6ff0
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xf7090
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x63, %rdx
leaq 0x545968(%rip), %rdi    # 0x582b20
leaq 0x4e2b95(%rip), %rsi    # 0x51fd54
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf7040
movq 0x50(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x6a, %rdx
leaq 0x4e2b8f(%rip), %rdi    # 0x51fd83
leaq 0x4e2b97(%rip), %rsi    # 0x51fd92
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf7040
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf7320
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf7320
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf7320
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf7320
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x62, %rdx
leaq 0x4e2c2e(%rip), %rdi    # 0x51fe9a
leaq 0x4e2c2b(%rip), %rsi    # 0x51fe9e
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf7040
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdx
addq $0x64, %rdx
leaq 0x4e2c51(%rip), %rdi    # 0x51fef9
leaq 0x4e2c58(%rip), %rsi    # 0x51ff07
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf7040
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x58(%rsp), %rdi
addq $0x60, %rdi
callq 0xf5f90
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x50(%rsp), %rdi
leaq 0x1449de(%rip), %rsi    # 0x181ce0
xorl %eax, %eax
movl %eax, %edx
callq 0xf1770
movq 0x50(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xf2a40
movq 0x50(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)