// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/gt_ltrharvest.c
// Function: gt_ltrharvest_option_parser_new
static GtOptionParser* gt_ltrharvest_option_parser_new(void *tool_arguments)
{
  LTRharvestArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *optionindex,
           *optionltrsearchseqrange,
           *optionseed,
           *optionminlenltr,
           *optionmaxlenltr,
           *optionmindistltr,
           *optionmaxdistltr,
           *optionmintsd,
           *optionmaxtsd,
           *optionsimilar,
           *optionmotif,
           *optionmotifmis,
           *optionvic,
           *optionoverlaps,
           *optionxdrop,
           *optionmat,
           *optionmis,
           *optionins,
           *optiondel,
           *optionv,
           *optiontabout,
           *optionmd5,
           *optionseqids,
           *optionoffset,
           *optionlongoutput,
           *optionout,
           *optionoutinner,
           *optiongff3,
           *optionscan;
  GtRange default_ltrsearchseqrange = {0,0};
  static const char *overlaps[] = {
    "best", /* the default */
    "no",
    "all",
    NULL
  };

  gt_assert(arguments);

  op = gt_option_parser_new("[option ...] -index <indexname>",
                            "Predict LTR retrotransposons.");

  /* -index */
  optionindex = gt_option_new_string("index",
                             "specify the name of the enhanced suffix "
                             "array index (mandatory)",
                             arguments->str_indexname, NULL);
  gt_option_is_mandatory(optionindex);
  gt_option_parser_add_option(op, optionindex);

  /* -range */
  optionltrsearchseqrange
    = gt_option_new_range("range",
                          "specify range in the input sequence(s) in which LTR "
                          "pairs are searched",
                          &arguments->searchrange,
                          &default_ltrsearchseqrange);
  gt_option_parser_add_option(op, optionltrsearchseqrange);

  /* -seed */
  optionseed = gt_option_new_uword_min("seed",
                               "specify minimum seed length for"
                               " exact repeats",
                               &arguments->minseedlength,
                               30UL,
                               1UL);
  gt_option_parser_add_option(op, optionseed);

  /* -minlenltr */
  optionminlenltr = gt_option_new_uword_min_max("minlenltr",
                               "specify minimum length for each LTR",
                               &arguments->minltrlength,
                               100UL,
                               1UL,
                               GT_UNDEF_UWORD);
  gt_option_parser_add_option(op, optionminlenltr);

  /* -maxlenltr */
  optionmaxlenltr = gt_option_new_uword_min_max("maxlenltr",
                               "specify maximum length for each LTR",
                               &arguments->maxltrlength,
                               1000UL,
                               1UL,
                               GT_UNDEF_UWORD);
  gt_option_parser_add_option(op, optionmaxlenltr);

  /* -mindistltr */
  optionmindistltr = gt_option_new_uword_min_max("mindistltr",
                               "specify minimum distance of "
                               "LTR startpositions",
                               &arguments->mindistance,
                               1000UL,
                               1UL,
                               GT_UNDEF_UWORD);
  gt_option_parser_add_option(op, optionmindistltr);

  /* -maxdistltr */
  optionmaxdistltr = gt_option_new_uword_min_max("maxdistltr",
                               "specify maximum distance of "
                               "LTR startpositions",
                               &arguments->maxdistance,
                               15000UL,
                               1UL,
                               GT_UNDEF_UWORD);
  gt_option_parser_add_option(op, optionmaxdistltr);

  /* -similar */
  optionsimilar = gt_option_new_double_min_max("similar",
                               "specify similaritythreshold in "
                               "range [1..100%]",
                               &arguments->similaritythreshold,
                               (double) 85.0,
                               (double) 0.0,
                               100.0);
  gt_option_parser_add_option(op, optionsimilar);

  /* -mintsd */
  optionmintsd = gt_option_new_uint_min_max("mintsd",
                              "specify minimum length for each TSD",
                               &arguments->minlengthTSD,
                               4U,
                               0,
                               GT_UNDEF_UINT);
  gt_option_parser_add_option(op, optionmintsd);

  /* -maxtsd */
  optionmaxtsd = gt_option_new_uint_min_max("maxtsd",
                              "specify maximum length for each TSD",
                               &arguments->maxlengthTSD,
                               20U,
                               0,
                               GT_UNDEF_UINT);
  gt_option_parser_add_option(op, optionmaxtsd);

  optionmotif = gt_option_new_string("motif",
                             "specify 2 nucleotides startmotif + "
                             "2 nucleotides endmotif: ****",
                             arguments->str_motif, NULL);
  gt_option_parser_add_option(op, optionmotif);
  arguments->optionmotif = gt_option_ref(optionmotif);

  /* -motifmis */
  optionmotifmis = gt_option_new_uint_min_max("motifmis",
                             "specify maximum number of "
                             "mismatches in motif [0,3]",
                             &arguments->allowedmismatches,
                             4U,
                             0,
                             3U);
  gt_option_parser_add_option(op, optionmotifmis);
  arguments->optionmotifmis = gt_option_ref(optionmotifmis);

  /* -vic */
  optionvic = gt_option_new_uint_min_max("vic",
                        "specify the number of nucleotides (to the left and "
                        "to the right) that will be searched "
                        "for TSDs and/or motifs around 5' and 3' boundary "
                        "of predicted LTR retrotransposons",
                        &arguments->vicinity,
                        60U,
                        1U,
                        500U);
  gt_option_parser_add_option(op, optionvic);

  /* -overlaps */
  optionoverlaps = gt_option_new_choice("overlaps",
               "specify no|best|all",
               arguments->str_overlaps,
               overlaps[0],
               overlaps);
  gt_option_parser_add_option(op, optionoverlaps);
  arguments->optionoverlaps = gt_option_ref(optionoverlaps);

  /* -xdrop */
  optionxdrop = gt_option_new_int_min("xdrop",
                        "specify xdropbelowscore for extension-alignment",
                        &arguments->xdropbelowscore,
                        5,
                        0);
  gt_option_parser_add_option(op, optionxdrop);

  /* -mat */
  optionmat = gt_option_new_int_min("mat",
                        "specify matchscore for extension-alignment",
                        &arguments->arbitscores.mat,
                        2,
                        1);
  gt_option_parser_add_option(op, optionmat);

  /* -mis */
  optionmis = gt_option_new_int_max("mis",
                        "specify mismatchscore for extension-alignment",
                        &arguments->arbitscores.mis,
                        -2,
                        -1);
  gt_option_parser_add_option(op, optionmis);

  /* -ins */
  optionins = gt_option_new_int_max("ins",
                        "specify insertionscore for extension-alignment",
                        &arguments->arbitscores.ins,
                        -3,
                        -1);
  gt_option_parser_add_option(op, optionins);

  /* -del */
  optiondel = gt_option_new_int_max("del",
                        "specify deletionscore for extension-alignment",
                        &arguments->arbitscores.del,
                        -3,
                        -1);
  gt_option_parser_add_option(op, optiondel);

  /* -v */
  optionv = gt_option_new_bool("v",
                           "verbose mode",
                           &arguments->verbosemode,
                           false);
  gt_option_parser_add_option(op, optionv);

  /* -tabout */
  optiontabout = gt_option_new_bool("tabout",
                                    "show 'old' tabular output instead "
                                    "of GFF3 on stdout",
                                    &arguments->tabout,
                                    true);
  gt_option_parser_add_option(op, optiontabout);

  /* -seqids */
  optionseqids = gt_option_new_bool("seqids",
                                    "use sequence descriptions instead of "
                                    "sequence numbers in GFF3 output",
                                    &arguments->seqids,
                                    false);
  gt_option_parser_add_option(op, optionseqids);

  /* -md5 */
  optionmd5 = gt_option_new_bool("md5",
                                 "add MD5 hashes to seqids in GFF3 output",
                                 &arguments->md5,
                                 false);
  gt_option_parser_add_option(op, optionmd5);

  /* -longoutput */
  optionlongoutput = gt_option_new_bool("longoutput",
                           "additional motif/TSD output",
                           &arguments->longoutput,
                           false);
  gt_option_parser_add_option(op, optionlongoutput);

  /* -out */
  arguments->fastaoutput = false;
  optionout = gt_option_new_string("out",
                             "specify FASTA outputfilename",
                             arguments->str_fastaoutputfilename, NULL);
  gt_option_parser_add_option(op, optionout);
  arguments->optionout = gt_option_ref(optionout);

  /* -outinner */
  arguments->fastaoutputinnerregion = false;
  optionoutinner = gt_option_new_string("outinner",
                             "specify FASTA outputfilename for inner regions",
                             arguments->str_fastaoutputfilenameinnerregion,
                              NULL);
  gt_option_parser_add_option(op, optionoutinner);
  arguments->optionoutinner = gt_option_ref(optionoutinner);

  /* -gff3 */
  arguments->gff3output = false;
  optiongff3 = gt_option_new_string("gff3",
                                    "specify GFF3 outputfilename",
                                    arguments->str_gff3filename, NULL);
  gt_option_parser_add_option(op, optiongff3);
  arguments->optiongff3 = gt_option_ref(optiongff3);

  /* -offset */
  optionoffset = gt_option_new_uword("offset",
                                     "offset added to GFF3 coordinates",
                                     &arguments->offset,
                                     0UL);
  gt_option_parser_add_option(op, optionoffset);
  gt_option_is_extended_option(optionoffset);

  /* -scan */
  optionscan = gt_option_new_bool("scan",
                                  "scan the index sequentially instead of "
                                  "mapping it into memory entirely",
                                  &arguments->scan,
                                  true);
  gt_option_parser_add_option(op, optionscan);
  gt_option_is_extended_option(optionscan);

  /* implications */
  gt_option_imply(optionmaxtsd, optionmintsd);
  gt_option_imply(optionmotifmis, optionmotif);

  gt_option_imply_either_2(optionlongoutput, optionmintsd, optionmotif);

  gt_option_parser_refer_to_manual(op);

  return op;
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x110(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x108(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19360
cmpq $0x0, 0x108(%rsp)
jne 0x2fc3b3
movq 0x33fc1e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x219c87(%rip), %rsi    # 0x516013
leaq 0x27e7cc(%rip), %rdx    # 0x57ab5f
leaq 0x295a11(%rip), %rcx    # 0x591dab
leaq 0x2959f2(%rip), %r8     # 0x591d93
movl $0xde, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2fc3b5
leaq 0x295a0f(%rip), %rdi    # 0x591dcb
leaq 0x295a28(%rip), %rsi    # 0x591deb
callq 0xf1420
movq %rax, 0x100(%rsp)
movq 0x108(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x26316b(%rip), %rdi    # 0x55f54e
leaq 0x2323d2(%rip), %rsi    # 0x52e7bc
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0xf8(%rsp)
movq 0xf8(%rsp), %rdi
callq 0xf6ca0
movq 0x100(%rsp), %rdi
movq 0xf8(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0x40, %rdx
leaq 0x2535c4(%rip), %rdi    # 0x54f9f4
leaq 0x2959d2(%rip), %rsi    # 0x591e09
leaq 0x8(%rsp), %rcx
callq 0xf68a0
movq %rax, 0xf0(%rsp)
movq 0x100(%rsp), %rdi
movq 0xf0(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0x50, %rdx
leaq 0x22a28f(%rip), %rdi    # 0x526700
leaq 0x232384(%rip), %rsi    # 0x52e7fc
movl $0x1e, %ecx
movl $0x1, %r8d
callq 0xf66b0
movq %rax, 0xe8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xe8(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0x58, %rdx
leaq 0x295998(%rip), %rdi    # 0x591e50
leaq 0x29599b(%rip), %rsi    # 0x591e5a
movl $0x64, %ecx
movl $0x1, %r8d
movq $-0x1, %r9
callq 0xf6710
movq %rax, 0xe0(%rsp)
movq 0x100(%rsp), %rdi
movq 0xe0(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0x60, %rdx
leaq 0x295978(%rip), %rdi    # 0x591e7e
leaq 0x29597b(%rip), %rsi    # 0x591e88
movl $0x3e8, %ecx            # imm = 0x3E8
movl $0x1, %r8d
movq $-0x1, %r9
callq 0xf6710
movq %rax, 0xd8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0x68, %rdx
leaq 0x295958(%rip), %rdi    # 0x591eac
leaq 0x29595c(%rip), %rsi    # 0x591eb7
movl $0x3e8, %ecx            # imm = 0x3E8
movl $0x1, %r8d
movq $-0x1, %r9
callq 0xf6710
movq %rax, 0xd0(%rsp)
movq 0x100(%rsp), %rdi
movq 0xd0(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0x70, %rdx
leaq 0x295944(%rip), %rdi    # 0x591ee6
leaq 0x295948(%rip), %rsi    # 0x591ef1
movl $0x3a98, %ecx           # imm = 0x3A98
movl $0x1, %r8d
movq $-0x1, %r9
callq 0xf6710
movq %rax, 0xc8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0x88, %rdx
leaq 0x254206(%rip), %rdi    # 0x5507f9
leaq 0x295926(%rip), %rsi    # 0x591f20
movsd 0x23210e(%rip), %xmm0   # 0x52e710
xorps %xmm1, %xmm1
movsd 0x21e22b(%rip), %xmm2   # 0x51a838
callq 0xf6240
movq %rax, 0xb0(%rsp)
movq 0x100(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0xa4, %rdx
leaq 0x2323d2(%rip), %rdi    # 0x52ea17
leaq 0x2323d2(%rip), %rsi    # 0x52ea1e
movl $0x4, %ecx
xorl %r8d, %r8d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0xf65d0
movq %rax, 0xc0(%rsp)
movq 0x100(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0xa8, %rdx
leaq 0x2323b0(%rip), %rdi    # 0x52ea42
leaq 0x2323b0(%rip), %rsi    # 0x52ea49
movl $0x14, %ecx
xorl %r8d, %r8d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0xf65d0
movq %rax, 0xb8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rax
movq 0x18(%rax), %rdx
leaq 0x2bf3f1(%rip), %rdi    # 0x5bbacd
leaq 0x29586c(%rip), %rsi    # 0x591f4f
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0xa8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0xc0(%rax)
movq 0x108(%rsp), %rdx
addq $0xac, %rdx
leaq 0x295851(%rip), %rdi    # 0x591f8f
leaq 0x295853(%rip), %rsi    # 0x591f98
movl $0x4, %ecx
xorl %r8d, %r8d
movl $0x3, %r9d
callq 0xf65d0
movq %rax, 0xa0(%rsp)
movq 0x100(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xf1600
movq 0xa0(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0xc8(%rax)
movq 0x108(%rsp), %rdx
addq $0xb0, %rdx
leaq 0x2322c3(%rip), %rdi    # 0x52ea6d
leaq 0x29581b(%rip), %rsi    # 0x591fcc
movl $0x3c, %ecx
movl $0x1, %r8d
movl $0x1f4, %r9d            # imm = 0x1F4
callq 0xf65d0
movq %rax, 0x98(%rsp)
movq 0x100(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x342599(%rip), %rcx    # 0x63ed90
leaq 0x26cd2a(%rip), %rdi    # 0x569528
leaq 0x295871(%rip), %rsi    # 0x592076
leaq 0x342584(%rip), %r8     # 0x63ed90
callq 0xf6b30
movq %rax, 0x90(%rsp)
movq 0x100(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0xf1600
movq 0x90(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0xd0(%rax)
movq 0x108(%rsp), %rdx
addq $0x90, %rdx
leaq 0x24f83e(%rip), %rdi    # 0x54c0a1
leaq 0x23212a(%rip), %rsi    # 0x52e994
movl $0x5, %ecx
xorl %r8d, %r8d
callq 0xf6370
movq %rax, 0x88(%rsp)
movq 0x100(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0x94, %rdx
leaq 0x23045a(%rip), %rdi    # 0x52cd04
leaq 0x23202d(%rip), %rsi    # 0x52e8de
movl $0x2, %ecx
movl $0x1, %r8d
callq 0xf6370
movq %rax, 0x80(%rsp)
movq 0x100(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0x94, %rdx
addq $0x4, %rdx
leaq 0x29569c(%rip), %rdi    # 0x591f94
leaq 0x23200a(%rip), %rsi    # 0x52e909
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0xf63d0
movq %rax, 0x78(%rsp)
movq 0x100(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0x94, %rdx
addq $0x8, %rdx
leaq 0x274cf6(%rip), %rdi    # 0x571636
leaq 0x231ff0(%rip), %rsi    # 0x52e937
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0xf63d0
movq %rax, 0x70(%rsp)
movq 0x100(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0x94, %rdx
addq $0xc, %rdx
leaq 0x29392d(%rip), %rdi    # 0x5902b5
leaq 0x231fd7(%rip), %rsi    # 0x52e966
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0xf63d0
movq %rax, 0x68(%rsp)
movq 0x100(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0xbb, %rdx
leaq 0x265657(%rip), %rdi    # 0x562023
leaq 0x2956b7(%rip), %rsi    # 0x59208a
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x60(%rsp)
movq 0x100(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0xbc, %rdx
leaq 0x295690(%rip), %rdi    # 0x592097
leaq 0x295690(%rip), %rsi    # 0x59209e
movl $0x1, %ecx
callq 0xf5f20
movq %rax, 0x58(%rsp)
movq 0x100(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0xbe, %rdx
leaq 0x268db2(%rip), %rdi    # 0x5657f7
leaq 0x2322b2(%rip), %rsi    # 0x52ecfe
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x48(%rsp)
movq 0x100(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0xbd, %rdx
leaq 0x2416cb(%rip), %rdi    # 0x53e14b
leaq 0x2322bc(%rip), %rsi    # 0x52ed43
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x50(%rsp)
movq 0x100(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rdx
addq $0xb9, %rdx
leaq 0x297e37(%rip), %rdi    # 0x5948f2
leaq 0x295610(%rip), %rsi    # 0x5920d2
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x38(%rsp)
movq 0x100(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf1600
movq 0x108(%rsp), %rax
movb $0x0, 0xb6(%rax)
movq 0x108(%rsp), %rax
movq 0x28(%rax), %rdx
leaq 0x297f3c(%rip), %rdi    # 0x594a3e
leaq 0x2955e5(%rip), %rsi    # 0x5920ee
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x30(%rsp)
movq 0x100(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf1600
movq 0x30(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0xd8(%rax)
movq 0x108(%rsp), %rax
movb $0x0, 0xb7(%rax)
movq 0x108(%rsp), %rax
movq 0x30(%rax), %rdx
leaq 0x2955a4(%rip), %rdi    # 0x59210b
leaq 0x2955a6(%rip), %rsi    # 0x592114
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x28(%rsp)
movq 0x100(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x28(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0xe0(%rax)
movq 0x108(%rsp), %rax
movb $0x0, 0xb8(%rax)
movq 0x108(%rsp), %rax
movq 0x38(%rax), %rdx
leaq 0x255ea0(%rip), %rdi    # 0x552a6c
leaq 0x295570(%rip), %rsi    # 0x592143
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x20(%rsp)
movq 0x100(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf1600
movq 0x20(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0xe8(%rax)
movq 0x108(%rsp), %rdx
addq $0x80, %rdx
leaq 0x23c9b2(%rip), %rdi    # 0x5395d7
leaq 0x295533(%rip), %rsi    # 0x59215f
xorl %eax, %eax
movl %eax, %ecx
callq 0xf5fe0
movq %rax, 0x40(%rsp)
movq 0x100(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xf1600
movq 0x40(%rsp), %rdi
callq 0xf6ff0
movq 0x108(%rsp), %rdx
addq $0xba, %rdx
leaq 0x2218ea(%rip), %rdi    # 0x51e556
leaq 0x29550d(%rip), %rsi    # 0x592180
movl $0x1, %ecx
callq 0xf5f20
movq %rax, 0x18(%rsp)
movq 0x100(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdi
callq 0xf6ff0
movq 0xb8(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0xf7090
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0xf7090
movq 0x38(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0xf7150
movq 0x100(%rsp), %rdi
callq 0xf1720
movq 0x100(%rsp), %rax
addq $0x118, %rsp            # imm = 0x118
retq
nop