// File: /workspace/github_c_makefile_star2_O2/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 $0x78, %rsp
movq %r8, %r14
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, %rbx
testq %r8, %r8
je 0x26bb2
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2793f
testq %r13, %r13
je 0x27915
cmpb $0x1, (%r13)
movslq %ebp, %r15
jne 0x26eb8
movq (%rbx,%r15,8), %rdi
movq %r14, %rsi
callq 0x87eb0
movq %rax, %r14
testq %rax, %rax
sete %bpl
je 0x26eab
cmpb $0x0, 0x2(%r13)
jne 0x26c14
movq 0x10(%r13), %rdi
leaq 0x2c4e79(%rip), %rsi    # 0x2eba70
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
movq (%rbx,%r15,8), %rdx
leaq 0x2cf233(%rip), %rsi    # 0x2f5e40
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4e5e(%rip), %rsi    # 0x2eba7d
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rbx
movq %r14, %rdi
callq 0x885cb
leaq 0x2c9e02(%rip), %r15    # 0x2f0a3b
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4e3f(%rip), %rsi    # 0x2eba93
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0x8860e
leaq 0x30079f(%rip), %rcx    # 0x32740d
leaq 0x338b36(%rip), %rdx    # 0x35f7ab
testb %al, %al
cmovneq %rcx, %rdx
leaq 0x2cf1be(%rip), %rbx    # 0x2f5e40
movq %r12, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4e07(%rip), %rsi    # 0x2ebaa1
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0x88588
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4de8(%rip), %rsi    # 0x2ebab0
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0x886da
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4dd0(%rip), %rsi    # 0x2ebac6
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r12
movq %r14, %rdi
callq 0x8871d
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4db4(%rip), %rsi    # 0x2ebad8
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0x88697
movq %rax, %r12
movq %r14, %rdi
callq 0x88654
leaq 0x2c349e(%rip), %rsi    # 0x2ea1e7
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4d9a(%rip), %rsi    # 0x2ebafe
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r15
movq %r14, %rdi
callq 0x88828
movl %eax, %edi
callq 0x87aa0
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq %r14, %rdi
callq 0x88545
movq %rax, %rbx
movq %rax, %rdi
callq 0x56d14
movq %rax, %r15
movq 0x10(%r13), %rdi
leaq 0x2c4d5c(%rip), %rsi    # 0x2ebb0b
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r12
movq %rbx, %rdi
callq 0x56c8e
leaq 0x3393ac(%rip), %rsi    # 0x360175
movq %r12, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4d3b(%rip), %rsi    # 0x2ebb1b
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r12
movq %rbx, %rdi
callq 0x56c8e
leaq 0x351067(%rip), %rsi    # 0x377e61
movq %r12, %rdi
movl %eax, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x8d432
movq %rbx, %rdi
callq 0x5741b
testb %al, %al
je 0x26e27
movq 0x10(%r13), %rdi
leaq 0x2c4d11(%rip), %rsi    # 0x2ebb31
xorl %eax, %eax
callq 0x8d432
movq %rbx, %rdi
callq 0x572d7
testb %al, %al
je 0x26e45
movq 0x10(%r13), %rdi
leaq 0x2c4cfa(%rip), %rsi    # 0x2ebb38
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x33969f(%rip), %rsi    # 0x3604ef
xorl %eax, %eax
callq 0x8d432
cmpb $0x1, 0x3(%r13)
jne 0x26eab
callq 0xacb84
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x56dde
movq 0x10(%r13), %rdi
leaq 0x2c4cc7(%rip), %rsi    # 0x2ebb43
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rbx
movq %r15, %rdi
callq 0xad1fa
leaq 0x2cefaa(%rip), %rsi    # 0x2f5e40
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq %r15, %rdi
callq 0xae103
movq %r14, %rdi
callq 0x888b5
jmp 0x27900
callq 0x791cd
movq %rax, %r12
cmpb $0x1, 0x1(%r13)
jne 0x26ecf
movq %r12, %rdi
callq 0x7d003
movq (%rbx,%r15,8), %rsi
movq %r12, 0x70(%rsp)
movq %r12, %rdi
movq %r14, %rdx
callq 0x7921d
movq %rax, %r12
testq %rax, %rax
sete %bpl
je 0x278ee
movb %bpl, 0x7(%rsp)
movq %r12, %rdi
callq 0x81d0c
movq %rax, %r14
cmpb $0x0, 0x2(%r13)
jne 0x26f32
movq 0x10(%r13), %rdi
leaq 0x2c4b5b(%rip), %rsi    # 0x2eba70
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
movq (%rbx,%r15,8), %rdx
leaq 0x2cef15(%rip), %rsi    # 0x2f5e40
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4b40(%rip), %rsi    # 0x2eba7d
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r15
movq %r12, %rdi
callq 0x704cf
leaq 0x2c9ae4(%rip), %rbx    # 0x2f0a3b
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4b21(%rip), %rsi    # 0x2eba93
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r15
movq %r12, %rdi
callq 0x70515
leaq 0x300481(%rip), %rcx    # 0x32740d
leaq 0x338818(%rip), %rdx    # 0x35f7ab
testb %al, %al
cmovneq %rcx, %rdx
leaq 0x2ceea0(%rip), %rsi    # 0x2f5e40
movq %r15, %rdi
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4aec(%rip), %rsi    # 0x2ebaa1
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r15
movq %r12, %rdi
callq 0x7055e
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4b76(%rip), %rsi    # 0x2ebb59
xorl %eax, %eax
callq 0x8d432
cmpq $0x3ff, %r14            # imm = 0x3FF
ja 0x2700a
movq 0x10(%r13), %rdi
leaq 0x2c4b6d(%rip), %rsi    # 0x2ebb6b
movq %r14, %rdx
xorl %eax, %eax
callq 0x8d432
jmp 0x27059
cmpq $0xfffff, %r14          # imm = 0xFFFFF
ja 0x27027
movq 0x10(%r13), %rdi
movq %r14, %rcx
shrq $0xa, %rcx
leaq 0x2c4b51(%rip), %rsi    # 0x2ebb76
jmp 0x2704f
movq 0x10(%r13), %rdi
movq %r14, %rcx
cmpq $0x3fffffff, %r14       # imm = 0x3FFFFFFF
ja 0x27044
shrq $0x14, %rcx
leaq 0x2c4b49(%rip), %rsi    # 0x2ebb8b
jmp 0x2704f
shrq $0x1e, %rcx
leaq 0x2c4b51(%rip), %rsi    # 0x2ebba0
movq %r14, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4a4c(%rip), %rsi    # 0x2ebab0
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rbx
movq %r12, %rdi
callq 0x705a1
leaq 0x2c99ba(%rip), %r15    # 0x2f0a3b
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4a2a(%rip), %rsi    # 0x2ebac6
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rbx
movq %r12, %rdi
callq 0x79eb4
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4a0e(%rip), %rsi    # 0x2ebad8
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rbx
movq %r12, %rdi
callq 0x7557f
movq %rax, %r15
movq %r12, %rdi
callq 0x755c5
leaq 0x2c30f8(%rip), %rsi    # 0x2ea1e7
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x8d432
movq %r12, 0x8(%rsp)
movq %r12, %rdi
callq 0x75d3b
movq %rax, %rbp
movq 0x10(%r13), %rdi
leaq 0x2c4a9b(%rip), %rsi    # 0x2ebbb5
xorl %eax, %eax
callq 0x8d432
xorl %ebx, %ebx
movq %rbp, %rdi
callq 0xae61c
cmpq %rax, %rbx
jae 0x27175
leaq 0x1(%rbx), %r15
movq %rbp, %rdi
callq 0xae61c
cmpq %rax, %r15
movq 0x8(%rsp), %r12
movq %r12, %rdi
jae 0x27153
movq %r15, %rsi
callq 0x81ca6
jmp 0x27158
callq 0x705a1
movq %r12, %rdi
movq %rax, %r12
movq %rbx, %rsi
callq 0x81ca6
subq %rax, %r12
cmpq %r12, %r14
cmovbeq %r12, %r14
movq %r15, %rbx
jmp 0x27123
movq %rbp, 0x50(%rsp)
leaq 0x2c474a(%rip), %rbx    # 0x2eb8cb
pushq $0x8
popq %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x107, %ecx            # imm = 0x107
callq 0x9334a
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x705a1
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x10a, %ecx            # imm = 0x10A
callq 0x9334a
movq %rax, 0x18(%rsp)
movq $0x0, 0x48(%rsp)
xorl %ebp, %ebp
movq %r13, 0x28(%rsp)
movq %r13, %r12
movq 0x50(%rsp), %r13
movq %r13, %rdi
callq 0xae61c
cmpq %rax, %rbp
jae 0x2738c
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x81ca6
movq %rax, 0x30(%rsp)
movq 0x10(%r12), %rbx
movq %r13, %rdi
movq %rbp, %rsi
callq 0xae386
movq %rax, %r15
movq %r14, %rdi
movq %rbp, %rsi
callq 0x81afe
movq %rbx, %rdi
leaq 0x2c49a5(%rip), %rsi    # 0x2ebbca
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x8d432
incq %rbp
movq %r13, %rdi
callq 0xae61c
movq %r14, %rdi
cmpq %rax, %rbp
jae 0x2724f
movq %rbp, %rsi
callq 0x81ca6
jmp 0x27254
callq 0x705a1
movq %rax, %r15
movq %rax, %rbx
movq 0x30(%rsp), %r14
subq %r14, %rbx
movq %r12, %r13
movq 0x10(%r12), %rdi
cmpq $0x1, %rbx
jne 0x27280
leaq 0x2c4967(%rip), %rsi    # 0x2ebbde
xorl %eax, %eax
callq 0x8d432
jmp 0x27291
leaq 0x2c4966(%rip), %rsi    # 0x2ebbed
movq %rbx, %rdx
xorl %eax, %eax
callq 0x8d432
cmpb $0x1, 0x4(%r13)
jne 0x271cf
leaq -0x1(%rbp), %rsi
movq 0x8(%rsp), %rdi
callq 0x81afe
subq %rbx, %rax
incq %rax
movq %rax, 0x20(%rsp)
andl $0x1, %eax
movq %rax, 0x68(%rsp)
movq 0x18(%rsp), %rax
movq 0x48(%rsp), %rcx
leaq (%rax,%rcx,8), %r13
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x272f4
leaq (%r14,%r12), %rsi
movq 0x8(%rsp), %rdi
callq 0x75173
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%r12,8)
movq %rax, (%r13,%r12,8)
incq %r12
jmp 0x272ce
movq 0x20(%rsp), %rax
shrq %rax
addq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
pushq $0x8
popq %rdx
leaq 0x65a(%rip), %rcx       # 0x27975
callq 0x17ed0
movq 0x28(%rsp), %r13
movq 0x10(%r13), %rdi
movq (%r14), %rdx
movq -0x8(%r14,%rbx,8), %rcx
movq 0x20(%rsp), %rbx
leaq 0x2c48c2(%rip), %rsi    # 0x2ebbff
xorl %eax, %eax
callq 0x8d432
addq %r12, 0x48(%rsp)
shlq $0x3, %r15
movq 0x30(%rsp), %rax
shlq $0x3, %rax
subq %rax, %r15
addq %r14, %r15
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rbx, %rax
jae 0x27372
addq -0x8(%r15), %rax
addq $-0x8, %r15
incq %rcx
jmp 0x27360
movq 0x10(%r13), %rdi
movq (%r15), %rdx
leaq 0x2c48a4(%rip), %rsi    # 0x2ebc24
xorl %eax, %eax
callq 0x8d432
jmp 0x271cf
leaq 0x2c4538(%rip), %rsi    # 0x2eb8cb
movq 0x10(%rsp), %rdi
movl $0x13d, %edx            # imm = 0x13D
callq 0x936f9
movq %r12, %r13
cmpb $0x1, 0x4(%r12)
movq 0x8(%rsp), %r12
jne 0x27423
movq %r12, %rdi
callq 0x705a1
movq %rax, %r14
movq %r12, %rdi
callq 0x7055e
movq %rax, %rbx
subq %r14, %rbx
incq %rbx
movq %rbx, %rax
shrq %rax
andl $0x1, %ebx
addq %rax, %rbx
leaq 0x594(%rip), %rcx       # 0x27975
pushq $0x8
popq %rdx
movq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x17ed0
leaq (%r15,%r14,8), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rbx, %rdx
jae 0x2740e
addq -0x8(%rax), %rdx
addq $-0x8, %rax
incq %rcx
jmp 0x273fc
movq 0x10(%r13), %rdi
movq (%rax), %rdx
leaq 0x2c482e(%rip), %rsi    # 0x2ebc4a
xorl %eax, %eax
callq 0x8d432
leaq 0x2c44a1(%rip), %rsi    # 0x2eb8cb
movq 0x18(%rsp), %rdi
movl $0x152, %edx            # imm = 0x152
callq 0x936f9
movq %r12, %rdi
callq 0x754dd
movq %rax, %rbp
movq %rax, %rdi
callq 0x56d14
movq %rax, %r15
movq 0x10(%r13), %rdi
leaq 0x2c46b1(%rip), %rsi    # 0x2ebb0b
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rbx
movq %rbp, %rdi
callq 0x56c8e
leaq 0x338d01(%rip), %rsi    # 0x360175
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x2c4690(%rip), %rsi    # 0x2ebb1b
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rbx
movq %rbp, %rdi
callq 0x56c8e
leaq 0x3509bc(%rip), %rsi    # 0x377e61
movq %rbx, %rdi
movl %eax, %edx
movq %r15, 0x10(%rsp)
movq %r15, %rcx
xorl %eax, %eax
callq 0x8d432
movq %rbp, %rdi
callq 0x5741b
testb %al, %al
je 0x274d7
movq 0x10(%r13), %rdi
leaq 0x2c4661(%rip), %rsi    # 0x2ebb31
xorl %eax, %eax
callq 0x8d432
movq %rbp, %rdi
callq 0x572d7
testb %al, %al
je 0x274f5
movq 0x10(%r13), %rdi
leaq 0x2c464a(%rip), %rsi    # 0x2ebb38
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %rdi
leaq 0x338fef(%rip), %rsi    # 0x3604ef
xorl %eax, %eax
callq 0x8d432
cmpb $0x1, 0x3(%r13)
jne 0x2755b
callq 0xacb84
movq %rax, %rbx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x56dde
movq 0x10(%r13), %rdi
leaq 0x2c4617(%rip), %rsi    # 0x2ebb43
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r13), %r15
movq %rbx, %rdi
callq 0xad1fa
leaq 0x2ce8fa(%rip), %rsi    # 0x2f5e40
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq %rbx, %rdi
callq 0xae103
movq 0x10(%r13), %rdi
leaq 0x2c470c(%rip), %rsi    # 0x2ebc72
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x8d432
movq 0x8(%rsp), %r14
movq %rbp, %rdi
callq 0x56c8e
movl %eax, %eax
cmpq %rax, %r12
jae 0x27655
movq 0x10(%rsp), %rbx
movsbl (%rbx,%r12), %esi
movq %rbp, %rdi
callq 0x57552
movzbl %al, %esi
movq %r14, %rdi
callq 0x754fd
movq %rax, %r15
movq 0x28(%rsp), %rax
movq 0x10(%rax), %r13
movsbl (%rbx,%r12), %eax
movl %eax, 0x30(%rsp)
movq %r15, %xmm0
movq 0x2c0319(%rip), %xmm1   # 0x2e78e0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2c031d(%rip), %xmm1   # 0x2e78f0
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 0x7055e
movq %rax, %rbx
movq %r14, %rdi
callq 0x705a1
subq %rax, %rbx
incq %rbx
movq %rbx, %xmm0
punpckldq 0x2c02d1(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2c02d9(%rip), %xmm0   # 0x2e78f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd 0x50(%rsp), %xmm0
divsd %xmm1, %xmm0
mulsd 0x2c21ab(%rip), %xmm0   # 0x2e97e0
movq %r13, %rdi
leaq 0x2c464c(%rip), %rsi    # 0x2ebc8b
movl 0x30(%rsp), %edx
movq %r15, %rcx
movb $0x1, %al
callq 0x8d432
incq %r12
jmp 0x27575
movq 0x28(%rsp), %r12
movq 0x10(%r12), %rdi
leaq 0x2c4638(%rip), %rsi    # 0x2ebc9e
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %rbx
movq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x7628b
movq %rax, %r14
movq %r13, %rdi
callq 0x762ad
leaq 0x2c4623(%rip), %r15    # 0x2ebcb4
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %rdi
leaq 0x2c4618(%rip), %rsi    # 0x2ebcc8
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %rbx
movq %r13, %rdi
callq 0x760bc
movq %rax, %r14
movq %r13, %rdi
callq 0x76238
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %rdi
leaq 0x2c45f9(%rip), %rsi    # 0x2ebce7
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %rbx
movq %r13, %rdi
callq 0x762ce
leaq 0x2c9332(%rip), %rsi    # 0x2f0a3b
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %rdi
leaq 0x2c43dc(%rip), %rsi    # 0x2ebafe
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %r14
movq %r13, %rdi
callq 0x81d17
movl %eax, %edi
callq 0x87aa0
leaq 0x2ce6fc(%rip), %rbx    # 0x2f5e40
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %rdi
leaq 0x2c45b9(%rip), %rsi    # 0x2ebd19
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %r14
movq %r13, %rdi
callq 0x81d0c
shlq $0x3, %rax
movq %rax, %xmm0
movq 0x2c015b(%rip), %xmm1   # 0x2e78e0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2c015f(%rip), %xmm1   # 0x2e78f0
subpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x30(%rsp)
movq %r13, %rdi
callq 0x7055e
movq %rax, %xmm0
punpckldq 0x2c0124(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2c012c(%rip), %xmm0   # 0x2e78f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd 0x30(%rsp), %xmm0
divsd %xmm1, %xmm0
leaq 0x2c8a26(%rip), %rsi    # 0x2f0207
movq %r14, %rdi
movb $0x1, %al
callq 0x8d432
movq 0x10(%r12), %rdi
leaq 0x2c453c(%rip), %rsi    # 0x2ebd33
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %r14
movq %r13, %rdi
callq 0x740a6
testb %al, %al
leaq 0x337f97(%rip), %r15    # 0x35f7ab
movq %r15, %rdx
leaq 0x2ffbef(%rip), %rbp    # 0x32740d
cmovneq %rbp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %rdi
leaq 0x2c450d(%rip), %rsi    # 0x2ebd48
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %r14
movq %r13, %rdi
callq 0x7609a
testb %al, %al
movq %r15, %rdx
cmovneq %rbp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8d432
movq %r13, %rdi
callq 0x7609a
testb %al, %al
je 0x278a5
movq 0x10(%r12), %rdi
leaq 0x2c44e5(%rip), %rsi    # 0x2ebd62
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %rbx
movq %r13, %rdi
callq 0x75c98
leaq 0x2c91a3(%rip), %rsi    # 0x2f0a3b
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %rdi
leaq 0x2c44d1(%rip), %rsi    # 0x2ebd82
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r12), %rbx
movq %r13, %rdi
callq 0x76086
testb %al, %al
leaq 0x2ffb3f(%rip), %rax    # 0x32740d
cmovneq %rax, %r15
leaq 0x2ce567(%rip), %rsi    # 0x2f5e40
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8d432
movb 0x7(%rsp), %bpl
movq %r13, %r12
movq %r12, %rdi
callq 0x735fd
movq 0x70(%rsp), %rdi
callq 0x79f01
movzbl %bpl, %eax
negl %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x41064c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bd6ed(%rip), %rsi    # 0x2e5013
leaq 0x320d26(%rip), %rdx    # 0x348653
leaq 0x2c4126(%rip), %rcx    # 0x2eba5a
leaq 0x2c3f90(%rip), %r8     # 0x2eb8cb
pushq $0x77
jmp 0x27967
movq 0x410622(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bd6c3(%rip), %rsi    # 0x2e5013
leaq 0x2bd868(%rip), %rdx    # 0x2e51bf
leaq 0x2c40fc(%rip), %rcx    # 0x2eba5a
leaq 0x2c3f66(%rip), %r8     # 0x2eb8cb
pushq $0x76
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390