// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_info.c
// Function: gt_encseq_info_runner
static int gt_encseq_info_runner(GT_UNUSED int argc, const char **argv,
                           int parsed_args, void *tool_arguments,
                           GtError *err)
{
  GtEncseqInfoArguments *arguments = tool_arguments;
  int had_err = 0;
  GtAlphabet *alpha;
  const GtUchar *chars;
  gt_error_check(err);
  gt_assert(arguments);

  if (arguments->nomap) {
    GtEncseqMetadata *emd = gt_encseq_metadata_new(argv[parsed_args], err);
    if (!emd)
      had_err = -1;

    if (!had_err) {
      if (!arguments->noindexname) {
        gt_file_xprintf(arguments->outfp, "index name: ");
        gt_file_xprintf(arguments->outfp, "%s\n", argv[parsed_args]);
      }

      gt_file_xprintf(arguments->outfp, "file format version: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU"\n",
                                          gt_encseq_metadata_version(emd));

      gt_file_xprintf(arguments->outfp, "64-bit file: ");
      gt_file_xprintf(arguments->outfp, "%s\n", gt_encseq_metadata_is64bit(emd)
                                                  ? "yes"
                                                  : "no");

      gt_file_xprintf(arguments->outfp, "total length: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU"\n",
                                        gt_encseq_metadata_total_length(emd));

      gt_file_xprintf(arguments->outfp, "number of sequences: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU"\n",
                                      gt_encseq_metadata_num_of_sequences(emd));

      gt_file_xprintf(arguments->outfp, "number of files: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU"\n",
                                        gt_encseq_metadata_num_of_files(emd));

      gt_file_xprintf(arguments->outfp, "length of shortest/longest "
                                        "sequence: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU"/"GT_WU"\n",
                                        gt_encseq_metadata_min_seq_length(emd),
                                        gt_encseq_metadata_max_seq_length(emd));

      gt_file_xprintf(arguments->outfp, "accesstype: ");
      gt_file_xprintf(arguments->outfp, "%s\n",
                 gt_encseq_access_type_str(gt_encseq_metadata_accesstype(emd)));

      alpha = gt_encseq_metadata_alphabet(emd);
      chars = gt_alphabet_characters(alpha);
      gt_file_xprintf(arguments->outfp, "alphabet size: ");
      gt_file_xprintf(arguments->outfp, "%u\n",
                                        gt_alphabet_num_of_chars(alpha));
      gt_file_xprintf(arguments->outfp, "alphabet characters: ");
      gt_file_xprintf(arguments->outfp, "%.*s", gt_alphabet_num_of_chars(alpha),
                                        (char*) chars);
      if (gt_alphabet_is_dna(alpha))
        gt_file_xprintf(arguments->outfp, " (DNA)");
      if (gt_alphabet_is_protein(alpha))
        gt_file_xprintf(arguments->outfp, " (Protein)");
      gt_file_xprintf(arguments->outfp, "\n");
      if (arguments->show_alphabet) {
        GtStr *out = gt_str_new();
        gt_alphabet_to_str(alpha, out);
        gt_file_xprintf(arguments->outfp, "alphabet definition:\n");
        gt_file_xprintf(arguments->outfp, "%s\n", gt_str_get(out));
        gt_str_delete(out);
      }

    }
    gt_encseq_metadata_delete(emd);
  } else {
    GtEncseqLoader *encseq_loader;
    GtEncseq *encseq;

    encseq_loader = gt_encseq_loader_new();
    if (arguments->mirror)
      gt_encseq_loader_mirror(encseq_loader);
    if (!(encseq = gt_encseq_loader_load(encseq_loader,
                                         argv[parsed_args], err)))
      had_err = -1;

    if (!had_err) {
      const GtStrArray *filenames;
      GtUword i;
      const GtUword compressed_size = gt_encseq_sizeofrep(encseq);
      GtUword max_num_seq_per_file = 0;
      GtUword *lengths, *all_lengths;
      GtUword all_seqnum = 0;

      if (!arguments->noindexname) {
        gt_file_xprintf(arguments->outfp, "index name: ");
        gt_file_xprintf(arguments->outfp, "%s\n", argv[parsed_args]);
      }

      gt_file_xprintf(arguments->outfp, "file format version: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU"\n", gt_encseq_version(encseq));

      gt_file_xprintf(arguments->outfp, "64-bit file: ");
      gt_file_xprintf(arguments->outfp, "%s\n", gt_encseq_is_64_bit(encseq)
                                                   ? "yes"
                                                   : "no");

      gt_file_xprintf(arguments->outfp, "total length: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU"\n",
                                        gt_encseq_total_length(encseq));

      gt_file_xprintf(arguments->outfp, "compressed size: ");
      if (compressed_size < (1<<10))
        gt_file_xprintf(arguments->outfp, ""GT_WU" bytes\n", compressed_size);
      else if (compressed_size < (1<<20))
        gt_file_xprintf(arguments->outfp, ""GT_WU" bytes ("GT_WU" KiB)\n",
                        compressed_size, compressed_size>>10);
      else if (compressed_size < (1<<30))
        gt_file_xprintf(arguments->outfp, ""GT_WU" bytes ("GT_WU" MiB)\n",
                        compressed_size, compressed_size>>20);
      else
        gt_file_xprintf(arguments->outfp, ""GT_WU" bytes ("GT_WU" GiB)\n",
                        compressed_size, compressed_size>>30);

      gt_file_xprintf(arguments->outfp, "number of sequences: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU"\n",
                                        gt_encseq_num_of_sequences(encseq));

      gt_file_xprintf(arguments->outfp, "number of files: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU"\n",
                                        gt_encseq_num_of_files(encseq));

      gt_file_xprintf(arguments->outfp, "length of shortest/longest "
                                        "sequence: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU"/"GT_WU"\n",
                                      gt_encseq_min_seq_length(encseq),
                                      gt_encseq_max_seq_length(encseq));

      filenames = gt_encseq_filenames(encseq);
      gt_file_xprintf(arguments->outfp, "original filenames:\n");
      /* compute maximum number of sequences per file */
      for (i = 0; i < gt_str_array_size(filenames); i++) {
        GtUword num_sequences;
        if (i+1 < gt_str_array_size(filenames))
          num_sequences = gt_encseq_filenum_first_seqnum(encseq, i+1) -
                          gt_encseq_filenum_first_seqnum(encseq, i);
        else
          num_sequences = gt_encseq_num_of_sequences(encseq) -
                          gt_encseq_filenum_first_seqnum(encseq, i);
        GT_UPDATE_MAX(max_num_seq_per_file, num_sequences);
      }
      /* vector for lengths in current file */
      lengths = gt_calloc(max_num_seq_per_file, sizeof (GtUword));
      /* vector for all lengths in encseq */
      all_lengths = gt_calloc(gt_encseq_num_of_sequences(encseq),
                              sizeof (GtUword));
      for (i = 0; i < gt_str_array_size(filenames); i++) {
        GtUword seq_number_diff;
        const GtUword seq_number_first = gt_encseq_filenum_first_seqnum(encseq,
                                                                        i);
        gt_file_xprintf(arguments->outfp, "\t%s ("GT_WU" characters",
                        gt_str_array_get(filenames, i),
                        (GtUword) gt_encseq_effective_filelength(encseq, i));
        /* get number of sequences in current file and print */
        if (i+1 < gt_str_array_size(filenames))
          seq_number_diff = gt_encseq_filenum_first_seqnum(encseq, i+1) -
                            seq_number_first;
        else
          seq_number_diff = gt_encseq_num_of_sequences(encseq)-seq_number_first;
        if (seq_number_diff == 1)
          gt_file_xprintf(arguments->outfp, ", 1 sequence)\n");
        else
          gt_file_xprintf(arguments->outfp, ", "GT_WU" sequences)\n",
              seq_number_diff);

        /* compute n50 for current file */
        if (arguments->show_n50) {
          GtUword n50_sum, seqnum;
          GtUword current_sum = 0;

          n50_sum = (GtUword)(gt_encseq_effective_filelength(encseq, i) -
                    seq_number_diff + 1); /* subtract number of separators */
          /* divide by 2 and round up to next Integer */
          n50_sum = GT_DIV2(n50_sum) + GT_MOD2(n50_sum);

          /* fill length arrays and sort asc. */
          for (seqnum = 0; seqnum < seq_number_diff; seqnum++) {
            lengths[seqnum] = gt_encseq_seqlength(encseq,
                                                  seqnum+seq_number_first);
            all_lengths[all_seqnum] = lengths[seqnum];
            all_seqnum ++;
          }
          qsort(lengths, seq_number_diff, sizeof (GtUword),
                gt_encseq_info_compare);
          gt_file_xprintf(arguments->outfp, "\t\t- minimum/maximum length: "
                          GT_WU"/"GT_WU"\n", lengths[0],
                          lengths[seq_number_diff-1]);
          /* count n50 and print */
          for (seqnum = seq_number_diff-1; current_sum < n50_sum; seqnum--) {
            current_sum += lengths[seqnum];
          }
          gt_file_xprintf(arguments->outfp, "\t\t- n50-length: "GT_WU
                          " (l50-count: "GT_WU")\n",
                          lengths[seqnum+1], seq_number_diff-seqnum-1);
        }
      }
      gt_free(lengths);

      /* compute n50 for whole encseq */
      if (arguments->show_n50) {
        GtUword n50_sum;
        GtUword current_sum = 0;
        const GtUword num_of_sequences = gt_encseq_num_of_sequences(encseq);

        /* calc n50 sum: total length minus number of separators */
        n50_sum = (gt_encseq_total_length(encseq) - num_of_sequences + 1);
        /* divide by 2 and round up to next Integer */
        n50_sum = GT_DIV2(n50_sum) + GT_MOD2(n50_sum);
        qsort(all_lengths, num_of_sequences, sizeof (GtUword),
              gt_encseq_info_compare);
        for (i = num_of_sequences-1; current_sum < n50_sum; i--) {
          current_sum += all_lengths[i];
        }
        gt_file_xprintf(arguments->outfp, "total n50-length: "GT_WU
                        " (l50-count: "GT_WU")\n",
                        all_lengths[i+1], num_of_sequences-i-1);
      }
      gt_free(all_lengths);

      alpha = gt_encseq_alphabet(encseq);
      chars = gt_alphabet_characters(alpha);
      gt_file_xprintf(arguments->outfp, "alphabet size: ");
      gt_file_xprintf(arguments->outfp, "%u\n",
                                        gt_alphabet_num_of_chars(alpha));
      gt_file_xprintf(arguments->outfp, "alphabet characters: ");
      gt_file_xprintf(arguments->outfp, "%.*s", gt_alphabet_num_of_chars(alpha),
                                        (char*) chars);
      if (gt_alphabet_is_dna(alpha))
        gt_file_xprintf(arguments->outfp, " (DNA)");
      if (gt_alphabet_is_protein(alpha))
        gt_file_xprintf(arguments->outfp, " (Protein)");
      gt_file_xprintf(arguments->outfp, "\n");
      if (arguments->show_alphabet) {
        GtStr *out = gt_str_new();
        gt_alphabet_to_str(alpha, out);
        gt_file_xprintf(arguments->outfp, "alphabet definition:\n");
        gt_file_xprintf(arguments->outfp, "%s\n", gt_str_get(out));
        gt_str_delete(out);
      }

      gt_file_xprintf(arguments->outfp, "character distribution:\n");
      for (i = 0; i < gt_alphabet_num_of_chars(alpha); i++) {
        GtUword cc;
        cc = gt_encseq_charcount(encseq, gt_alphabet_encode(alpha, chars[i]));
        gt_file_xprintf(arguments->outfp, "\t%c: "GT_WU" (%.2f%%)\n",
                                          (char) chars[i],
                                          cc,
                             (cc /(double) (gt_encseq_total_length(encseq)
                                  - gt_encseq_num_of_sequences(encseq)+1))*100);
      }

      gt_file_xprintf(arguments->outfp, "number of wildcards: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU" ("GT_WU" range(s))\n",
                                        gt_encseq_wildcards(encseq),
                                        gt_encseq_realwildcardranges(encseq));

      gt_file_xprintf(arguments->outfp, "number of special characters: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU" ("GT_WU" range(s))\n",
                                        gt_encseq_specialcharacters(encseq),
                                        gt_encseq_realspecialranges(encseq));

      gt_file_xprintf(arguments->outfp, "length of longest non-special "
                                        "character stretch: ");
      gt_file_xprintf(arguments->outfp, ""GT_WU"\n",
                                   gt_encseq_lengthoflongestnonspecial(encseq));

      gt_file_xprintf(arguments->outfp, "accesstype: ");
      gt_file_xprintf(arguments->outfp, "%s\n",
                   gt_encseq_access_type_str(gt_encseq_accesstype_get(encseq)));

      gt_file_xprintf(arguments->outfp, "bits used per character: ");
      gt_file_xprintf(arguments->outfp, "%f\n",
        (double) ((uint64_t) CHAR_BIT *
                  (uint64_t) gt_encseq_sizeofrep(encseq)) /
        (double) gt_encseq_total_length(encseq));

      gt_file_xprintf(arguments->outfp, "has special ranges: ");
      gt_file_xprintf(arguments->outfp, "%s\n",
                                        gt_encseq_has_specialranges(encseq)
                                          ? "yes"
                                          : "no");

      gt_file_xprintf(arguments->outfp, "has description support: ");
      gt_file_xprintf(arguments->outfp, "%s\n",
                                       gt_encseq_has_description_support(encseq)
                                          ? "yes"
                                          : "no");

      if (gt_encseq_has_description_support(encseq)) {
        gt_file_xprintf(arguments->outfp, "length of longest description: ");
        gt_file_xprintf(arguments->outfp, ""GT_WU"\n",
                                          gt_encseq_max_desc_length(encseq));
      }

      gt_file_xprintf(arguments->outfp, "has multiple sequence support: ");
      gt_file_xprintf(arguments->outfp, "%s\n",
                                        gt_encseq_has_multiseq_support(encseq)
                                          ? "yes"
                                          : "no");
    }
    gt_encseq_delete(encseq);
    gt_encseq_loader_delete(encseq_loader);
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, (%rsp)
movl %edx, %ebp
movq %rsi, %rbx
testq %r8, %r8
je 0xa4d07
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa5aea
movq (%rsp), %r15
testq %r15, %r15
je 0xa5ae5
cmpb $0x1, (%r15)
jne 0xa5024
movslq %ebp, %r15
movq (%rbx,%r15,8), %rdi
movq %r14, %rsi
callq 0xfb8bc
movq %rax, %r14
testq %rax, %rax
sete %bpl
je 0xa5017
movq (%rsp), %r13
cmpb $0x0, 0x2(%r13)
jne 0xa4d70
movq 0x10(%r13), %rdi
leaq 0x2a6d1d(%rip), %rsi    # 0x34ba70
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
movq (%rbx,%r15,8), %rdx
leaq 0x2b10c7(%rip), %rsi    # 0x355e30
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6d02(%rip), %rsi    # 0x34ba7d
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rbx
movq %r14, %rdi
callq 0xfbee4
leaq 0x2abc93(%rip), %r15    # 0x350a28
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6ce3(%rip), %rsi    # 0x34ba93
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0xfbef4
leaq 0x2e2243(%rip), %rcx    # 0x38700d
leaq 0x31a58a(%rip), %rdx    # 0x3bf35b
testb %al, %al
cmovneq %rcx, %rdx
leaq 0x2b1052(%rip), %rbx    # 0x355e30
movq %r12, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6cab(%rip), %rsi    # 0x34baa1
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0xfbed4
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6c8c(%rip), %rsi    # 0x34bab0
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0xfbf27
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6c74(%rip), %rsi    # 0x34bac6
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0xfbf37
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6c58(%rip), %rsi    # 0x34bad8
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0xfbf17
movq %rax, %r12
movq %r14, %rdi
callq 0xfbf07
leaq 0x2a5342(%rip), %rsi    # 0x34a1e7
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6c3e(%rip), %rsi    # 0x34bafe
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0xfbf76
movl %eax, %edi
callq 0xfb53c
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq %r14, %rdi
callq 0xfbec4
movq %rax, %rbx
movq %rax, %rdi
callq 0xd11de
movq %rax, %r15
movq 0x10(%r13), %rdi
leaq 0x2a6c00(%rip), %rsi    # 0x34bb0b
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r12
movq %rbx, %rdi
callq 0xd11be
leaq 0x31ae00(%rip), %rsi    # 0x3bfd25
movq %r12, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6bdf(%rip), %rsi    # 0x34bb1b
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r12
movq %rbx, %rdi
callq 0xd11be
leaq 0x332aeb(%rip), %rsi    # 0x3d7a41
movq %r12, %rdi
movl %eax, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0xfee51
movq %rbx, %rdi
callq 0xd1749
testb %al, %al
je 0xa4f87
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2a6bb1(%rip), %rsi    # 0x34bb31
xorl %eax, %eax
callq 0xfee51
movq %rbx, %rdi
callq 0xd15f5
testb %al, %al
je 0xa4fa9
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2a6b96(%rip), %rsi    # 0x34bb38
xorl %eax, %eax
callq 0xfee51
movq (%rsp), %r15
movq 0x10(%r15), %rdi
leaq 0x31b0e7(%rip), %rsi    # 0x3c009f
xorl %eax, %eax
callq 0xfee51
cmpb $0x1, 0x3(%r15)
jne 0xa5017
callq 0x11ac6c
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd120f
movq (%rsp), %rbx
movq 0x10(%rbx), %rdi
leaq 0x2a6b5b(%rip), %rsi    # 0x34bb43
xorl %eax, %eax
callq 0xfee51
movq 0x10(%rbx), %rbx
movq %r15, %rdi
callq 0x11b0a1
leaq 0x2b0e2e(%rip), %rsi    # 0x355e30
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq %r15, %rdi
callq 0x11bdbf
movq %r14, %rdi
callq 0xfbf9f
jmp 0xa5ad0
callq 0xef0cd
movq %rax, %r12
cmpb $0x1, 0x1(%r15)
jne 0xa503b
movq %r12, %rdi
callq 0xf237b
movslq %ebp, %r15
movq (%rbx,%r15,8), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0xef129
movq %rax, %r13
testq %rax, %rax
sete %bpl
je 0xa5ac0
movq %r12, 0x60(%rsp)
movq %r13, %rdi
callq 0xf64eb
movq %rax, %r14
movq (%rsp), %r12
cmpb $0x0, 0x2(%r12)
jne 0xa50a3
movq 0x10(%r12), %rdi
leaq 0x2a69eb(%rip), %rsi    # 0x34ba70
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %rdi
movq (%rbx,%r15,8), %rdx
leaq 0x2b0d94(%rip), %rsi    # 0x355e30
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %rdi
leaq 0x2a69ce(%rip), %rsi    # 0x34ba7d
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %r15
movq %r13, %rdi
callq 0xe7b73
leaq 0x2ab95e(%rip), %rbx    # 0x350a28
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %rdi
leaq 0x2a69ad(%rip), %rsi    # 0x34ba93
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %r15
movq %r13, %rdi
callq 0xe7b86
leaq 0x2e1f0c(%rip), %rcx    # 0x38700d
leaq 0x31a253(%rip), %rdx    # 0x3bf35b
testb %al, %al
cmovneq %rcx, %rdx
leaq 0x2b0d1b(%rip), %rsi    # 0x355e30
movq %r15, %rdi
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %rdi
leaq 0x2a6976(%rip), %rsi    # 0x34baa1
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %r15
movq %r13, %rdi
callq 0xe7b9c
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %rdi
leaq 0x2a69fe(%rip), %rsi    # 0x34bb59
xorl %eax, %eax
callq 0xfee51
cmpq $0x3ff, %r14            # imm = 0x3FF
ja 0xa5183
movq 0x10(%r12), %rdi
leaq 0x2a69f4(%rip), %rsi    # 0x34bb6b
movq %r14, %rdx
xorl %eax, %eax
callq 0xfee51
jmp 0xa51e9
cmpq $0xfffff, %r14          # imm = 0xFFFFF
ja 0xa51af
movq (%rsp), %r12
movq 0x10(%r12), %rdi
movq %r14, %rcx
shrq $0xa, %rcx
leaq 0x2a69d3(%rip), %rsi    # 0x34bb76
movq %r14, %rdx
xorl %eax, %eax
callq 0xfee51
jmp 0xa51e9
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq %r14, %rcx
cmpq $0x3fffffff, %r14       # imm = 0x3FFFFFFF
ja 0xa51d0
shrq $0x14, %rcx
leaq 0x2a69bd(%rip), %rsi    # 0x34bb8b
jmp 0xa51db
shrq $0x1e, %rcx
leaq 0x2a69c5(%rip), %rsi    # 0x34bba0
movq %r14, %rdx
xorl %eax, %eax
callq 0xfee51
movq (%rsp), %r12
movq 0x10(%r12), %rdi
leaq 0x2a68bb(%rip), %rsi    # 0x34bab0
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %rbx
movq %r13, %rdi
callq 0xe7bac
leaq 0x2ab815(%rip), %r15    # 0x350a28
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %rdi
leaq 0x2a6897(%rip), %rsi    # 0x34bac6
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %rbx
movq %r13, %rdi
callq 0xefbc9
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %rdi
leaq 0x2a6879(%rip), %rsi    # 0x34bad8
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %rbx
movq %r13, %rdi
callq 0xebd4a
movq %rax, %r15
movq %r13, %rdi
callq 0xebd5d
leaq 0x2a4f62(%rip), %rsi    # 0x34a1e7
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfee51
movq %r13, %rdi
callq 0xec2d5
movq 0x10(%r12), %rdi
movq %rax, %r12
leaq 0x2a6909(%rip), %rsi    # 0x34bbb5
xorl %eax, %eax
callq 0xfee51
movq %r12, %rdi
callq 0x11c131
testq %rax, %rax
movq %r12, 0x18(%rsp)
je 0xa531b
xorl %r15d, %r15d
xorl %r14d, %r14d
leaq 0x1(%r15), %rbx
movq %r12, %rdi
callq 0x11c131
movq %r13, %rdi
cmpq %rax, %rbx
jae 0xa52e9
movq %rbx, %rsi
callq 0xf64b8
jmp 0xa52ee
callq 0xe7bac
movq %rax, %r12
movq %r13, %rdi
movq %r15, %rsi
callq 0xf64b8
subq %rax, %r12
cmpq %r12, %r14
cmovbeq %r12, %r14
movq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x11c131
movq %rbx, %r15
cmpq %rax, %rbx
jb 0xa52cb
movb %bpl, 0xf(%rsp)
leaq 0x2a65a4(%rip), %rbx    # 0x34b8cb
movl $0x8, %esi
movq %r14, %rdi
movq %rbx, %rdx
movl $0x107, %ecx            # imm = 0x107
callq 0x10436a
movq %rax, 0x38(%rsp)
movq %r13, %rdi
callq 0xe7bac
movl $0x8, %esi
movq %rax, %rdi
movq %rbx, %rdx
movl $0x10a, %ecx            # imm = 0x10A
callq 0x10436a
movq %rax, 0x48(%rsp)
movq %r12, %rdi
callq 0x11c131
testq %rax, %rax
movq (%rsp), %r15
movq %r13, 0x10(%rsp)
je 0xa554c
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %r13, %rdi
movq %r14, %rsi
callq 0xf64b8
movq %r13, %rbx
movq %rax, %r13
movq 0x10(%r15), %rax
movq %rax, 0x20(%rsp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x11bfb3
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf63fb
movq 0x20(%rsp), %rdi
leaq 0x2a6809(%rip), %rsi    # 0x34bbca
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfee51
leaq 0x1(%r14), %rbx
movq %r12, %rdi
callq 0x11c131
cmpq %rax, %rbx
jae 0xa53ee
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xf64b8
jmp 0xa53f8
movq 0x10(%rsp), %rdi
callq 0xe7bac
movq %rax, %r12
movq %rax, 0x20(%rsp)
subq %r13, %r12
movq (%rsp), %r15
movq 0x10(%r15), %rdi
cmpq $0x1, %r12
jne 0xa5421
leaq 0x2a67c6(%rip), %rsi    # 0x34bbde
xorl %eax, %eax
callq 0xfee51
jmp 0xa5432
leaq 0x2a67c5(%rip), %rsi    # 0x34bbed
movq %r12, %rdx
xorl %eax, %eax
callq 0xfee51
cmpb $0x1, 0x4(%r15)
jne 0xa5500
movq %r12, 0x50(%rsp)
movq %rbx, 0x40(%rsp)
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xf63fb
movq %rax, %r12
cmpq %r13, 0x20(%rsp)
je 0xa5490
movq 0x38(%rsp), %r14
movq 0x10(%rsp), %r15
movq 0x48(%rsp), %rbx
movq %r15, %rdi
movq %r13, %rsi
callq 0xeb9d2
movq %rax, (%r14)
movq %rax, (%rbx,%rbp,8)
incq %rbp
incq %r13
addq $0x8, %r14
cmpq %r13, 0x20(%rsp)
jne 0xa546d
movq 0x50(%rsp), %r13
subq %r13, %r12
incq %r12
movq %r12, %rax
shrq %rax
andl $0x1, %r12d
addq %rax, %r12
movl $0x8, %edx
movq 0x38(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
leaq 0x630(%rip), %rcx       # 0xa5aef
callq 0x17f60
movq (%rsp), %r15
movq 0x10(%r15), %rdi
movq (%r14), %rdx
leaq -0x1(%r13), %rbx
movq -0x8(%r14,%r13,8), %rcx
leaq 0x2a6720(%rip), %rsi    # 0x34bbff
xorl %eax, %eax
callq 0xfee51
testq %r12, %r12
je 0xa5507
xorl %eax, %eax
movq 0x10(%rsp), %r13
addq (%r14,%rbx,8), %rax
decq %rbx
cmpq %r12, %rax
jb 0xa54f2
jmp 0xa550c
movq 0x10(%rsp), %r13
jmp 0xa5533
movq 0x10(%rsp), %r13
movq 0x10(%r15), %rdi
movq 0x8(%r14,%rbx,8), %rdx
notq %rbx
movq 0x50(%rsp), %rcx
addq %rbx, %rcx
leaq 0x2a66fd(%rip), %rsi    # 0x34bc24
xorl %eax, %eax
callq 0xfee51
movq 0x40(%rsp), %rbx
movq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x11c131
movq %rbx, %r14
cmpq %rax, %rbx
jb 0xa5382
leaq 0x2a6378(%rip), %rsi    # 0x34b8cb
movq 0x38(%rsp), %rdi
movl $0x13d, %edx            # imm = 0x13D
callq 0x1045eb
cmpb $0x1, 0x4(%r15)
movq 0x48(%rsp), %r12
jne 0xa55ea
movq %r13, %rdi
callq 0xe7bac
movq %rax, %rbx
movq %r13, %rdi
callq 0xe7b9c
movq %rax, %r14
subq %rbx, %r14
incq %r14
movq %r14, %r15
shrq %r15
andl $0x1, %r14d
leaq 0x554(%rip), %rcx       # 0xa5aef
movl $0x8, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x17f60
addq %r15, %r14
je 0xa55c7
xorl %ecx, %ecx
movq %rbx, %rax
movq -0x8(%r12,%rax,8), %rdx
decq %rax
addq %rdx, %rcx
cmpq %r14, %rcx
jb 0xa55b5
jmp 0xa55ce
movq (%r12,%rbx,8), %rdx
movq %rbx, %rax
movq (%rsp), %r15
movq 0x10(%r15), %rdi
subq %rax, %rbx
leaq 0x2a666a(%rip), %rsi    # 0x34bc4a
movq %rbx, %rcx
xorl %eax, %eax
callq 0xfee51
leaq 0x2a62da(%rip), %rsi    # 0x34b8cb
movq %r12, %rdi
movl $0x152, %edx            # imm = 0x152
callq 0x1045eb
movq %r13, %rdi
callq 0xebcd9
movq %rax, %rbp
movq %rax, %rdi
callq 0xd11de
movq %rax, %r14
movq 0x10(%r15), %rdi
leaq 0x2a64ec(%rip), %rsi    # 0x34bb0b
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r15), %rbx
movq %rbp, %rdi
callq 0xd11be
leaq 0x31a6ec(%rip), %rsi    # 0x3bfd25
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r15), %rdi
leaq 0x2a64cb(%rip), %rsi    # 0x34bb1b
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r15), %rbx
movq %rbp, %rdi
callq 0xd11be
leaq 0x3323d7(%rip), %rsi    # 0x3d7a41
movq %rbx, %rdi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xfee51
movq %rbp, %rdi
callq 0xd1749
testb %al, %al
je 0xa569b
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2a649d(%rip), %rsi    # 0x34bb31
xorl %eax, %eax
callq 0xfee51
movq %rbp, %rdi
callq 0xd15f5
testb %al, %al
je 0xa56bd
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2a6482(%rip), %rsi    # 0x34bb38
xorl %eax, %eax
callq 0xfee51
movq %r14, %r13
movq (%rsp), %r12
movq 0x10(%r12), %rdi
leaq 0x31a9cf(%rip), %rsi    # 0x3c009f
xorl %eax, %eax
callq 0xfee51
cmpb $0x1, 0x3(%r12)
jne 0xa572e
callq 0x11ac6c
movq %rax, %rbx
movq %rbp, %rdi
movq %rax, %rsi
callq 0xd120f
movq 0x10(%r12), %rdi
leaq 0x2a6445(%rip), %rsi    # 0x34bb43
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %r15
movq %rbx, %rdi
callq 0x11b0a1
leaq 0x2b0717(%rip), %rsi    # 0x355e30
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq %rbx, %rdi
callq 0x11bdbf
movq 0x10(%r12), %rdi
leaq 0x2a6538(%rip), %rsi    # 0x34bc72
xorl %eax, %eax
callq 0xfee51
movq %rbp, %rdi
callq 0xd11be
testl %eax, %eax
movq 0x10(%rsp), %r14
je 0xa5845
movq %r13, %rbx
xorl %r13d, %r13d
movq %rbp, 0x40(%rsp)
movsbl (%rbx,%r13), %esi
movq %rbp, %rdi
callq 0xd185d
movzbl %al, %esi
movq %r14, %rdi
callq 0xebcf9
movq %rax, %r15
movq 0x10(%r12), %rax
movq %rax, 0x18(%rsp)
movsbl (%rbx,%r13), %eax
movl %eax, 0x20(%rsp)
movq %r15, %xmm0
movq 0x2a2144(%rip), %xmm1   # 0x3478e0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2a2148(%rip), %xmm1   # 0x3478f0
subpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x50(%rsp)
movq %r14, %rdi
callq 0xe7b9c
movq %rbx, %rbp
movq %rax, %rbx
movq %r14, %rdi
callq 0xe7bac
subq %rax, %rbx
incq %rbx
movq %rbx, %xmm0
movq %rbp, %rbx
punpckldq 0x2a20f6(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2a20fe(%rip), %xmm0   # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd 0x50(%rsp), %xmm0
divsd %xmm1, %xmm0
mulsd 0x2a3fd0(%rip), %xmm0   # 0x3497e0
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rbp
leaq 0x2a646a(%rip), %rsi    # 0x34bc8b
movl 0x20(%rsp), %edx
movq %r15, %rcx
movb $0x1, %al
callq 0xfee51
incq %r13
movq %rbp, %rdi
callq 0xd11be
movl %eax, %eax
cmpq %rax, %r13
jb 0xa5761
movq 0x10(%r12), %rdi
leaq 0x2a644d(%rip), %rsi    # 0x34bc9e
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r12), %rbx
movq %r14, %rdi
callq 0xec68e
movq %r12, %r13
movq %rax, %r12
movq %r14, %rdi
callq 0xec6b0
leaq 0x2a643a(%rip), %r15    # 0x34bcb4
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6430(%rip), %rsi    # 0x34bcc8
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rbx
movq %r14, %rdi
callq 0xec58b
movq %rax, %r12
movq %r14, %rdi
callq 0xec63b
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6413(%rip), %rsi    # 0x34bce7
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rbx
movq %r14, %rdi
callq 0xec6d1
leaq 0x2ab13a(%rip), %rsi    # 0x350a28
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a61f8(%rip), %rsi    # 0x34bafe
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0xf64f6
movl %eax, %edi
callq 0xfb53c
leaq 0x2b0509(%rip), %rbx    # 0x355e30
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a63d7(%rip), %rsi    # 0x34bd19
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0xf64eb
shlq $0x3, %rax
movq %rax, %xmm0
punpckldq 0x2a1f7a(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2a1f82(%rip), %xmm0   # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
movq %r14, %rdi
callq 0xe7b9c
movq %rax, %xmm0
punpckldq 0x2a1f4b(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2a1f53(%rip), %xmm0   # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd 0x20(%rsp), %xmm0
divsd %xmm1, %xmm0
leaq 0x2aa845(%rip), %rsi    # 0x3501ff
movq %r15, %rdi
movb $0x1, %al
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6364(%rip), %rsi    # 0x34bd33
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0xeacd6
testb %al, %al
leaq 0x319970(%rip), %r12    # 0x3bf35b
movq %r12, %rdx
leaq 0x2e1618(%rip), %rbp    # 0x38700d
cmovneq %rbp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %rdi
leaq 0x2a6337(%rip), %rsi    # 0x34bd48
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0xec569
testb %al, %al
movq %r12, %rdx
cmovneq %rbp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xfee51
movq %r14, %rdi
callq 0xec569
testb %al, %al
movq %r13, %r15
movq %r14, %r13
je 0xa5a7e
movq 0x10(%r15), %rdi
leaq 0x2a630b(%rip), %rsi    # 0x34bd62
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r15), %rbx
movq %r13, %rdi
callq 0xec259
leaq 0x2aafb7(%rip), %rsi    # 0x350a28
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r15), %rdi
leaq 0x2a62f9(%rip), %rsi    # 0x34bd82
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r15), %rbx
movq %r13, %rdi
callq 0xec555
testb %al, %al
cmovneq %rbp, %r12
leaq 0x2b0387(%rip), %rsi    # 0x355e30
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xfee51
movb 0xf(%rsp), %bpl
movq 0x60(%rsp), %r12
movq %r13, %rdi
callq 0xea375
movq %r12, %rdi
callq 0xefbe3
movzbl %bpl, %eax
negl %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1a4e4
callq 0x1a4ad