// File: /workspace/github_c_makefile_star2_O1/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 0xa7073
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0xa7e53
movq (%rsp), %r15
testq %r15, %r15
je 0xa7e4e
cmpb $0x1, (%r15)
jne 0xa7390
movslq %ebp, %r15
movq (%rbx,%r15,8), %rdi
movq %r14, %rsi
callq 0x1000e4
movq %rax, %r14
testq %rax, %rax
sete %bpl
je 0xa7383
movq (%rsp), %r13
cmpb $0x0, 0x2(%r13)
jne 0xa70dc
movq 0x10(%r13), %rdi
leaq 0x2ad9e0(%rip), %rsi    # 0x354a9f
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
movq (%rbx,%r15,8), %rdx
leaq 0x2b7d87(%rip), %rsi    # 0x35ee5c
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad9c5(%rip), %rsi    # 0x354aac
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rbx
movq %r14, %rdi
callq 0x100d4c
leaq 0x2b2962(%rip), %r15    # 0x359a63
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad9a6(%rip), %rsi    # 0x354ac2
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0x100d5c
leaq 0x2e92b7(%rip), %rcx    # 0x3903ed
leaq 0x32189e(%rip), %rdx    # 0x3c89db
testb %al, %al
cmovneq %rcx, %rdx
leaq 0x2b7d12(%rip), %rbx    # 0x35ee5c
movq %r12, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad96e(%rip), %rsi    # 0x354ad0
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0x100d3c
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad94f(%rip), %rsi    # 0x354adf
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0x100d8f
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad937(%rip), %rsi    # 0x354af5
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0x100d9f
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad91b(%rip), %rsi    # 0x354b07
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0x100d7f
movq %rax, %r12
movq %r14, %rdi
callq 0x100d6f
leaq 0x2abfe6(%rip), %rsi    # 0x3531f7
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad901(%rip), %rsi    # 0x354b2d
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0x100dde
movl %eax, %edi
callq 0xffd58
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq %r14, %rdi
callq 0x100d2c
movq %rax, %rbx
movq %rax, %rdi
callq 0xd3733
movq %rax, %r15
movq 0x10(%r13), %rdi
leaq 0x2ad8c3(%rip), %rsi    # 0x354b3a
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r12
movq %rbx, %rdi
callq 0xd3713
leaq 0x322114(%rip), %rsi    # 0x3c93a5
movq %r12, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad8a2(%rip), %rsi    # 0x354b4a
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r12
movq %rbx, %rdi
callq 0xd3713
leaq 0x339ed4(%rip), %rsi    # 0x3e1196
movq %r12, %rdi
movl %eax, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x103d21
movq %rbx, %rdi
callq 0xd3c75
testb %al, %al
je 0xa72f3
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2ad874(%rip), %rsi    # 0x354b60
xorl %eax, %eax
callq 0x103d21
movq %rbx, %rdi
callq 0xd3b2e
testb %al, %al
je 0xa7315
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2ad859(%rip), %rsi    # 0x354b67
xorl %eax, %eax
callq 0x103d21
movq (%rsp), %r15
movq 0x10(%r15), %rdi
leaq 0x3223fb(%rip), %rsi    # 0x3c971f
xorl %eax, %eax
callq 0x103d21
cmpb $0x1, 0x3(%r15)
jne 0xa7383
callq 0x1208f8
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd3764
movq (%rsp), %rbx
movq 0x10(%rbx), %rdi
leaq 0x2ad81e(%rip), %rsi    # 0x354b72
xorl %eax, %eax
callq 0x103d21
movq 0x10(%rbx), %rbx
movq %r15, %rdi
callq 0x120d23
leaq 0x2b7aee(%rip), %rsi    # 0x35ee5c
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq %r15, %rdi
callq 0x121b03
movq %r14, %rdi
callq 0x100e07
jmp 0xa7e39
callq 0xf36ef
movq %rax, %r12
cmpb $0x1, 0x1(%r15)
jne 0xa73a7
movq %r12, %rdi
callq 0xf69bc
movslq %ebp, %r15
movq (%rbx,%r15,8), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0xf374b
movq %rax, %r13
testq %rax, %rax
sete %bpl
je 0xa7e29
movq %r12, 0x60(%rsp)
movq %r13, %rdi
callq 0xfac04
movq %rax, %r14
movq (%rsp), %r12
cmpb $0x0, 0x2(%r12)
jne 0xa740f
movq 0x10(%r12), %rdi
leaq 0x2ad6ae(%rip), %rsi    # 0x354a9f
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %rdi
movq (%rbx,%r15,8), %rdx
leaq 0x2b7a54(%rip), %rsi    # 0x35ee5c
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %rdi
leaq 0x2ad691(%rip), %rsi    # 0x354aac
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %r15
movq %r13, %rdi
callq 0xec1af
leaq 0x2b262d(%rip), %rbx    # 0x359a63
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %rdi
leaq 0x2ad670(%rip), %rsi    # 0x354ac2
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %r15
movq %r13, %rdi
callq 0xec1c2
leaq 0x2e8f80(%rip), %rcx    # 0x3903ed
leaq 0x321567(%rip), %rdx    # 0x3c89db
testb %al, %al
cmovneq %rcx, %rdx
leaq 0x2b79db(%rip), %rsi    # 0x35ee5c
movq %r15, %rdi
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %rdi
leaq 0x2ad639(%rip), %rsi    # 0x354ad0
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %r15
movq %r13, %rdi
callq 0xec1d8
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %rdi
leaq 0x2ad6c1(%rip), %rsi    # 0x354b88
xorl %eax, %eax
callq 0x103d21
cmpq $0x3ff, %r14            # imm = 0x3FF
ja 0xa74ef
movq 0x10(%r12), %rdi
leaq 0x2ad6b7(%rip), %rsi    # 0x354b9a
movq %r14, %rdx
xorl %eax, %eax
callq 0x103d21
jmp 0xa7555
cmpq $0xfffff, %r14          # imm = 0xFFFFF
ja 0xa751b
movq (%rsp), %r12
movq 0x10(%r12), %rdi
movq %r14, %rcx
shrq $0xa, %rcx
leaq 0x2ad696(%rip), %rsi    # 0x354ba5
movq %r14, %rdx
xorl %eax, %eax
callq 0x103d21
jmp 0xa7555
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq %r14, %rcx
cmpq $0x3fffffff, %r14       # imm = 0x3FFFFFFF
ja 0xa753c
shrq $0x14, %rcx
leaq 0x2ad680(%rip), %rsi    # 0x354bba
jmp 0xa7547
shrq $0x1e, %rcx
leaq 0x2ad688(%rip), %rsi    # 0x354bcf
movq %r14, %rdx
xorl %eax, %eax
callq 0x103d21
movq (%rsp), %r12
movq 0x10(%r12), %rdi
leaq 0x2ad57e(%rip), %rsi    # 0x354adf
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %rbx
movq %r13, %rdi
callq 0xec1e8
leaq 0x2b24e4(%rip), %r15    # 0x359a63
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %rdi
leaq 0x2ad55a(%rip), %rsi    # 0x354af5
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %rbx
movq %r13, %rdi
callq 0xf4233
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %rdi
leaq 0x2ad53c(%rip), %rsi    # 0x354b07
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %rbx
movq %r13, %rdi
callq 0xf034b
movq %rax, %r15
movq %r13, %rdi
callq 0xf035e
leaq 0x2abc06(%rip), %rsi    # 0x3531f7
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x103d21
movq %r13, %rdi
callq 0xf08d6
movq 0x10(%r12), %rdi
movq %rax, %r12
leaq 0x2ad5cc(%rip), %rsi    # 0x354be4
xorl %eax, %eax
callq 0x103d21
movq %r12, %rdi
callq 0x121e78
testq %rax, %rax
movq %r12, 0x18(%rsp)
je 0xa7687
xorl %r15d, %r15d
xorl %r14d, %r14d
leaq 0x1(%r15), %rbx
movq %r12, %rdi
callq 0x121e78
movq %r13, %rdi
cmpq %rax, %rbx
jae 0xa7655
movq %rbx, %rsi
callq 0xfabd1
jmp 0xa765a
callq 0xec1e8
movq %rax, %r12
movq %r13, %rdi
movq %r15, %rsi
callq 0xfabd1
subq %rax, %r12
cmpq %r12, %r14
cmovbeq %r12, %r14
movq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x121e78
movq %rbx, %r15
cmpq %rax, %rbx
jb 0xa7637
movb %bpl, 0xf(%rsp)
leaq 0x2ad267(%rip), %rbx    # 0x3548fa
movl $0x8, %esi
movq %r14, %rdi
movq %rbx, %rdx
movl $0x107, %ecx            # imm = 0x107
callq 0x1093ef
movq %rax, 0x38(%rsp)
movq %r13, %rdi
callq 0xec1e8
movl $0x8, %esi
movq %rax, %rdi
movq %rbx, %rdx
movl $0x10a, %ecx            # imm = 0x10A
callq 0x1093ef
movq %rax, 0x48(%rsp)
movq %r12, %rdi
callq 0x121e78
testq %rax, %rax
movq (%rsp), %r15
movq %r13, 0x10(%rsp)
je 0xa78b8
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %r13, %rdi
movq %r14, %rsi
callq 0xfabd1
movq %r13, %rbx
movq %rax, %r13
movq 0x10(%r15), %rax
movq %rax, 0x20(%rsp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x121cfa
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfab0d
movq 0x20(%rsp), %rdi
leaq 0x2ad4cc(%rip), %rsi    # 0x354bf9
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x103d21
leaq 0x1(%r14), %rbx
movq %r12, %rdi
callq 0x121e78
cmpq %rax, %rbx
jae 0xa775a
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xfabd1
jmp 0xa7764
movq 0x10(%rsp), %rdi
callq 0xec1e8
movq %rax, %r12
movq %rax, 0x20(%rsp)
subq %r13, %r12
movq (%rsp), %r15
movq 0x10(%r15), %rdi
cmpq $0x1, %r12
jne 0xa778d
leaq 0x2ad489(%rip), %rsi    # 0x354c0d
xorl %eax, %eax
callq 0x103d21
jmp 0xa779e
leaq 0x2ad488(%rip), %rsi    # 0x354c1c
movq %r12, %rdx
xorl %eax, %eax
callq 0x103d21
cmpb $0x1, 0x4(%r15)
jne 0xa786c
movq %r12, 0x50(%rsp)
movq %rbx, 0x40(%rsp)
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xfab0d
movq %rax, %r12
cmpq %r13, 0x20(%rsp)
je 0xa77fc
movq 0x38(%rsp), %r14
movq 0x10(%rsp), %r15
movq 0x48(%rsp), %rbx
movq %r15, %rdi
movq %r13, %rsi
callq 0xeffd3
movq %rax, (%r14)
movq %rax, (%rbx,%rbp,8)
incq %rbp
incq %r13
addq $0x8, %r14
cmpq %r13, 0x20(%rsp)
jne 0xa77d9
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 0x62d(%rip), %rcx       # 0xa7e58
callq 0x17f60
movq (%rsp), %r15
movq 0x10(%r15), %rdi
movq (%r14), %rdx
leaq -0x1(%r13), %rbx
movq -0x8(%r14,%r13,8), %rcx
leaq 0x2ad3e3(%rip), %rsi    # 0x354c2e
xorl %eax, %eax
callq 0x103d21
testq %r12, %r12
je 0xa7873
xorl %eax, %eax
movq 0x10(%rsp), %r13
addq (%r14,%rbx,8), %rax
decq %rbx
cmpq %r12, %rax
jb 0xa785e
jmp 0xa7878
movq 0x10(%rsp), %r13
jmp 0xa789f
movq 0x10(%rsp), %r13
movq 0x10(%r15), %rdi
movq 0x8(%r14,%rbx,8), %rdx
notq %rbx
movq 0x50(%rsp), %rcx
addq %rbx, %rcx
leaq 0x2ad3c0(%rip), %rsi    # 0x354c53
xorl %eax, %eax
callq 0x103d21
movq 0x40(%rsp), %rbx
movq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x121e78
movq %rbx, %r14
cmpq %rax, %rbx
jb 0xa76ee
leaq 0x2ad03b(%rip), %rsi    # 0x3548fa
movq 0x38(%rsp), %rdi
movl $0x13d, %edx            # imm = 0x13D
callq 0x109670
cmpb $0x1, 0x4(%r15)
movq 0x48(%rsp), %r12
jne 0xa7953
movq %r13, %rdi
callq 0xec1e8
movq %rax, %rbx
movq %r13, %rdi
callq 0xec1d8
movq %rax, %r14
subq %rbx, %r14
incq %r14
movq %r14, %r15
shrq %r15
andl $0x1, %r14d
leaq 0x551(%rip), %rcx       # 0xa7e58
movl $0x8, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x17f60
addq %r15, %r14
je 0xa7930
xorl %ecx, %ecx
movq %rbx, %rax
addq -0x8(%r12,%rax,8), %rcx
decq %rax
cmpq %r14, %rcx
jb 0xa7921
jmp 0xa7933
movq %rbx, %rax
movq (%rsp), %r15
movq 0x10(%r15), %rdi
movq (%r12,%rax,8), %rdx
subq %rax, %rbx
leaq 0x2ad330(%rip), %rsi    # 0x354c79
movq %rbx, %rcx
xorl %eax, %eax
callq 0x103d21
leaq 0x2acfa0(%rip), %rsi    # 0x3548fa
movq %r12, %rdi
movl $0x152, %edx            # imm = 0x152
callq 0x109670
movq %r13, %rdi
callq 0xf02da
movq %rax, %rbp
movq %rax, %rdi
callq 0xd3733
movq %rax, %r14
movq 0x10(%r15), %rdi
leaq 0x2ad1b2(%rip), %rsi    # 0x354b3a
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r15), %rbx
movq %rbp, %rdi
callq 0xd3713
leaq 0x321a03(%rip), %rsi    # 0x3c93a5
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r15), %rdi
leaq 0x2ad191(%rip), %rsi    # 0x354b4a
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r15), %rbx
movq %rbp, %rdi
callq 0xd3713
leaq 0x3397c3(%rip), %rsi    # 0x3e1196
movq %rbx, %rdi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x103d21
movq %rbp, %rdi
callq 0xd3c75
testb %al, %al
je 0xa7a04
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2ad163(%rip), %rsi    # 0x354b60
xorl %eax, %eax
callq 0x103d21
movq %rbp, %rdi
callq 0xd3b2e
testb %al, %al
je 0xa7a26
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2ad148(%rip), %rsi    # 0x354b67
xorl %eax, %eax
callq 0x103d21
movq %r14, %r13
movq (%rsp), %r12
movq 0x10(%r12), %rdi
leaq 0x321ce6(%rip), %rsi    # 0x3c971f
xorl %eax, %eax
callq 0x103d21
cmpb $0x1, 0x3(%r12)
jne 0xa7a97
callq 0x1208f8
movq %rax, %rbx
movq %rbp, %rdi
movq %rax, %rsi
callq 0xd3764
movq 0x10(%r12), %rdi
leaq 0x2ad10b(%rip), %rsi    # 0x354b72
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %r15
movq %rbx, %rdi
callq 0x120d23
leaq 0x2b73da(%rip), %rsi    # 0x35ee5c
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq %rbx, %rdi
callq 0x121b03
movq 0x10(%r12), %rdi
leaq 0x2ad1fe(%rip), %rsi    # 0x354ca1
xorl %eax, %eax
callq 0x103d21
movq %rbp, %rdi
callq 0xd3713
testl %eax, %eax
movq 0x10(%rsp), %r14
je 0xa7bae
movq %r13, %rbx
xorl %r13d, %r13d
movq %rbp, 0x40(%rsp)
movsbl (%rbx,%r13), %esi
movq %rbp, %rdi
callq 0xd3d89
movzbl %al, %esi
movq %r14, %rdi
callq 0xf02fa
movq %rax, %r15
movq 0x10(%r12), %rax
movq %rax, 0x18(%rsp)
movsbl (%rbx,%r13), %eax
movl %eax, 0x20(%rsp)
movq %r15, %xmm0
movq 0x2a8ddb(%rip), %xmm1   # 0x3508e0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2a8ddf(%rip), %xmm1   # 0x3508f0
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 0xec1d8
movq %rbx, %rbp
movq %rax, %rbx
movq %r14, %rdi
callq 0xec1e8
subq %rax, %rbx
incq %rbx
movq %rbx, %xmm0
movq %rbp, %rbx
punpckldq 0x2a8d8d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2a8d95(%rip), %xmm0   # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd 0x50(%rsp), %xmm0
divsd %xmm1, %xmm0
mulsd 0x2aac77(%rip), %xmm0   # 0x3527f0
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rbp
leaq 0x2ad130(%rip), %rsi    # 0x354cba
movl 0x20(%rsp), %edx
movq %r15, %rcx
movb $0x1, %al
callq 0x103d21
incq %r13
movq %rbp, %rdi
callq 0xd3713
movl %eax, %eax
cmpq %rax, %r13
jb 0xa7aca
movq 0x10(%r12), %rdi
leaq 0x2ad113(%rip), %rsi    # 0x354ccd
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r12), %rbx
movq %r14, %rdi
callq 0xf0c8a
movq %r12, %r13
movq %rax, %r12
movq %r14, %rdi
callq 0xf0cac
leaq 0x2ad100(%rip), %r15    # 0x354ce3
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad0f6(%rip), %rsi    # 0x354cf7
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rbx
movq %r14, %rdi
callq 0xf0b87
movq %rax, %r12
movq %r14, %rdi
callq 0xf0c37
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad0d9(%rip), %rsi    # 0x354d16
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rbx
movq %r14, %rdi
callq 0xf0ccd
leaq 0x2b1e0c(%rip), %rsi    # 0x359a63
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2acebe(%rip), %rsi    # 0x354b2d
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0xfac0f
movl %eax, %edi
callq 0xffd58
leaq 0x2b71cc(%rip), %rbx    # 0x35ee5c
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad09d(%rip), %rsi    # 0x354d48
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0xfac04
shlq $0x3, %rax
movq %rax, %xmm0
punpckldq 0x2a8c11(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2a8c19(%rip), %xmm0   # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
movq %r14, %rdi
callq 0xec1d8
movq %rax, %xmm0
punpckldq 0x2a8be2(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2a8bea(%rip), %xmm0   # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd 0x20(%rsp), %xmm0
divsd %xmm1, %xmm0
leaq 0x2b150c(%rip), %rsi    # 0x35922f
movq %r15, %rdi
movb $0x1, %al
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2ad02a(%rip), %rsi    # 0x354d62
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0xef27f
testb %al, %al
leaq 0x320c87(%rip), %r12    # 0x3c89db
movq %r12, %rdx
leaq 0x2e868f(%rip), %rbp    # 0x3903ed
cmovneq %rbp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %rdi
leaq 0x2acffd(%rip), %rsi    # 0x354d77
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0xf0b65
testb %al, %al
movq %r12, %rdx
cmovneq %rbp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x103d21
movq %r14, %rdi
callq 0xf0b65
testb %al, %al
movq %r13, %r15
movq %r14, %r13
je 0xa7de7
movq 0x10(%r15), %rdi
leaq 0x2acfd1(%rip), %rsi    # 0x354d91
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r15), %rbx
movq %r13, %rdi
callq 0xf085a
leaq 0x2b1c89(%rip), %rsi    # 0x359a63
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r15), %rdi
leaq 0x2acfbf(%rip), %rsi    # 0x354db1
xorl %eax, %eax
callq 0x103d21
movq 0x10(%r15), %rbx
movq %r13, %rdi
callq 0xf0b51
testb %al, %al
cmovneq %rbp, %r12
leaq 0x2b704a(%rip), %rsi    # 0x35ee5c
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x103d21
movb 0xf(%rsp), %bpl
movq 0x60(%rsp), %r12
movq %r13, %rdi
callq 0xee90c
movq %r12, %rdi
callq 0xf424d
movzbl %bpl, %eax
negl %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1a5a7
callq 0x1a570