// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2d8, %rsp            # imm = 0x2D8
movl %edi, 0x2d4(%rsp)
movq %rsi, 0x2c8(%rsp)
movl %edx, 0x2c4(%rsp)
movq %rcx, 0x2b8(%rsp)
movq %r8, 0x2b0(%rsp)
movq 0x2b8(%rsp), %rax
movq %rax, 0x2a8(%rsp)
movl $0x0, 0x2a4(%rsp)
cmpq $0x0, 0x2b0(%rsp)
je 0x314ae
movq 0x2b0(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x31476
jmp 0x314ae
movq 0x60ab23(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e4b8c(%rip), %rsi    # 0x516013
leaq 0x4e4d31(%rip), %rdx    # 0x5161bf
leaq 0x4eb62c(%rip), %rcx    # 0x51cac1
leaq 0x4eb496(%rip), %r8     # 0x51c932
movl $0x76, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x314b0
jmp 0x314b2
cmpq $0x0, 0x2a8(%rsp)
jne 0x314f5
movq 0x60aadc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e4b45(%rip), %rsi    # 0x516013
leaq 0x54968a(%rip), %rdx    # 0x57ab5f
leaq 0x4eb5e5(%rip), %rcx    # 0x51cac1
leaq 0x4eb44f(%rip), %r8     # 0x51c932
movl $0x77, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x314f7
movq 0x2a8(%rsp), %rax
testb $0x1, (%rax)
je 0x31a24
movq 0x2c8(%rsp), %rax
movslq 0x2c4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x2b0(%rsp), %rsi
callq 0xd4e10
movq %rax, 0x288(%rsp)
cmpq $0x0, 0x288(%rsp)
jne 0x31547
movl $0xffffffff, 0x2a4(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x2a4(%rsp)
jne 0x31a12
movq 0x2a8(%rsp), %rax
testb $0x1, 0x2(%rax)
jne 0x315ab
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb561(%rip), %rsi    # 0x51cad7
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x2c8(%rsp), %rax
movslq 0x2c4(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x4f5948(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb526(%rip), %rsi    # 0x51cae4
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x190(%rsp)
movq 0x288(%rsp), %rdi
callq 0xd6720
movq 0x190(%rsp), %rdi
movq %rax, %rdx
leaq 0x4f04ae(%rip), %rsi    # 0x521aa6
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb4e8(%rip), %rsi    # 0x51cafa
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x198(%rsp)
movq 0x288(%rsp), %rdi
callq 0xd6770
movq 0x198(%rsp), %rdi
movb %al, %cl
leaq 0x563570(%rip), %rdx    # 0x594bbb
leaq 0x52813b(%rip), %rax    # 0x55978d
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x4f588c(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb48e(%rip), %rsi    # 0x51cb08
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1a0(%rsp)
movq 0x288(%rsp), %rdi
callq 0xd66d0
movq 0x1a0(%rsp), %rdi
movq %rax, %rdx
leaq 0x4f03f2(%rip), %rsi    # 0x521aa6
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb449(%rip), %rsi    # 0x51cb17
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1a8(%rsp)
movq 0x288(%rsp), %rdi
callq 0xd6870
movq 0x1a8(%rsp), %rdi
movq %rax, %rdx
leaq 0x4f039e(%rip), %rsi    # 0x521aa6
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb40b(%rip), %rsi    # 0x51cb2d
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1b0(%rsp)
movq 0x288(%rsp), %rdi
callq 0xd68c0
movq 0x1b0(%rsp), %rdi
movq %rax, %rdx
leaq 0x4f034a(%rip), %rsi    # 0x521aa6
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb3c9(%rip), %rsi    # 0x51cb3f
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1b8(%rsp)
movq 0x288(%rsp), %rdi
callq 0xd6820
movq %rax, 0x1c0(%rsp)
movq 0x288(%rsp), %rdi
callq 0xd67d0
movq 0x1b8(%rsp), %rdi
movq 0x1c0(%rsp), %rdx
movq %rax, %rcx
leaq 0x4e9a63(%rip), %rsi    # 0x51b230
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb37e(%rip), %rsi    # 0x51cb65
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1c8(%rsp)
movq 0x288(%rsp), %rdi
callq 0xd6a10
movl %eax, %edi
callq 0xd4600
movq 0x1c8(%rsp), %rdi
movq %rax, %rdx
leaq 0x4f56c4(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0xddca0
movq 0x288(%rsp), %rdi
callq 0xd6680
movq %rax, 0x298(%rsp)
movq 0x298(%rsp), %rdi
callq 0x7e970
movq %rax, 0x290(%rsp)
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb306(%rip), %rsi    # 0x51cb72
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1d0(%rsp)
movq 0x298(%rsp), %rdi
callq 0x7e8c0
movq 0x1d0(%rsp), %rdi
movl %eax, %edx
leaq 0x561611(%rip), %rsi    # 0x592eb6
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb2c3(%rip), %rsi    # 0x51cb82
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1d8(%rsp)
movq 0x298(%rsp), %rdi
callq 0x7e8c0
movq 0x1d8(%rsp), %rdi
movl %eax, %edx
movq 0x290(%rsp), %rcx
leaq 0x57b5db(%rip), %rsi    # 0x5acedb
movb $0x0, %al
callq 0xddca0
movq 0x298(%rsp), %rdi
callq 0x7f400
testb $0x1, %al
jne 0x3191a
jmp 0x31934
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb26b(%rip), %rsi    # 0x51cb98
movb $0x0, %al
callq 0xddca0
movq 0x298(%rsp), %rdi
callq 0x7f1a0
testb $0x1, %al
jne 0x31947
jmp 0x31961
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb245(%rip), %rsi    # 0x51cb9f
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x5618ff(%rip), %rsi    # 0x593273
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
testb $0x1, 0x3(%rax)
je 0x31a10
callq 0x11d4a0
movq %rax, 0x280(%rsp)
movq 0x298(%rsp), %rdi
movq 0x280(%rsp), %rsi
callq 0x7ea70
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eb1e8(%rip), %rsi    # 0x51cbaa
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x188(%rsp)
movq 0x280(%rsp), %rdi
callq 0x11dee0
movq 0x188(%rsp), %rdi
movq %rax, %rdx
leaq 0x4f54f0(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0xddca0
movq 0x280(%rsp), %rdi
callq 0x11f560
jmp 0x31a12
movq 0x288(%rsp), %rdi
callq 0xd6ae0
jmp 0x32cc7
callq 0xb7a40
movq %rax, 0x278(%rsp)
movq 0x2a8(%rsp), %rax
testb $0x1, 0x1(%rax)
je 0x31a4c
movq 0x278(%rsp), %rdi
callq 0xba710
movq 0x278(%rsp), %rdi
movq 0x2c8(%rsp), %rax
movslq 0x2c4(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x2b0(%rsp), %rdx
callq 0xb7aa0
movq %rax, 0x270(%rsp)
cmpq $0x0, %rax
jne 0x31a8e
movl $0xffffffff, 0x2a4(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x2a4(%rsp)
jne 0x32cad
movq 0x270(%rsp), %rdi
callq 0xc2d70
movq %rax, 0x258(%rsp)
movq $0x0, 0x250(%rsp)
movq $0x0, 0x238(%rsp)
movq 0x2a8(%rsp), %rax
testb $0x1, 0x2(%rax)
jne 0x31b1f
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eafed(%rip), %rsi    # 0x51cad7
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x2c8(%rsp), %rax
movslq 0x2c4(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x4f53d4(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eafb2(%rip), %rsi    # 0x51cae4
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x170(%rsp)
movq 0x270(%rsp), %rdi
callq 0xa9c40
movq 0x170(%rsp), %rdi
movq %rax, %rdx
leaq 0x4eff3a(%rip), %rsi    # 0x521aa6
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eaf74(%rip), %rsi    # 0x51cafa
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x178(%rsp)
movq 0x270(%rsp), %rdi
callq 0xa9ca0
movq 0x178(%rsp), %rdi
movb %al, %cl
leaq 0x562ffc(%rip), %rdx    # 0x594bbb
leaq 0x527bc7(%rip), %rax    # 0x55978d
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x4f5318(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eaf1a(%rip), %rsi    # 0x51cb08
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x180(%rsp)
movq 0x270(%rsp), %rdi
callq 0xa9d00
movq 0x180(%rsp), %rdi
movq %rax, %rdx
leaq 0x4efe7e(%rip), %rsi    # 0x521aa6
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eaf7e(%rip), %rsi    # 0x51cbc0
movb $0x0, %al
callq 0xddca0
cmpq $0x400, 0x258(%rsp) # imm = 0x400
jae 0x31c7e
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x258(%rsp), %rdx
leaq 0x4eaf60(%rip), %rsi    # 0x51cbd2
movb $0x0, %al
callq 0xddca0
jmp 0x31d2c
cmpq $0x100000, 0x258(%rsp) # imm = 0x100000
jae 0x31cbc
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x258(%rsp), %rdx
movq 0x258(%rsp), %rcx
shrq $0xa, %rcx
leaq 0x4eaf2a(%rip), %rsi    # 0x51cbdd
movb $0x0, %al
callq 0xddca0
jmp 0x31d2a
cmpq $0x40000000, 0x258(%rsp) # imm = 0x40000000
jae 0x31cfa
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x258(%rsp), %rdx
movq 0x258(%rsp), %rcx
shrq $0x14, %rcx
leaq 0x4eaf01(%rip), %rsi    # 0x51cbf2
movb $0x0, %al
callq 0xddca0
jmp 0x31d28
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x258(%rsp), %rdx
movq 0x258(%rsp), %rcx
shrq $0x1e, %rcx
leaq 0x4eaee6(%rip), %rsi    # 0x51cc07
movb $0x0, %al
callq 0xddca0
jmp 0x31d2a
jmp 0x31d2c
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eadd8(%rip), %rsi    # 0x51cb17
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x150(%rsp)
movq 0x270(%rsp), %rdi
callq 0xa9d50
movq 0x150(%rsp), %rdi
movq %rax, %rdx
leaq 0x4efd2d(%rip), %rsi    # 0x521aa6
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ead9a(%rip), %rsi    # 0x51cb2d
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x158(%rsp)
movq 0x270(%rsp), %rdi
callq 0xb7df0
movq 0x158(%rsp), %rdi
movq %rax, %rdx
leaq 0x4efcd9(%rip), %rsi    # 0x521aa6
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ead58(%rip), %rsi    # 0x51cb3f
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x160(%rsp)
movq 0x270(%rsp), %rdi
callq 0xb1050
movq %rax, 0x168(%rsp)
movq 0x270(%rsp), %rdi
callq 0xb10b0
movq 0x160(%rsp), %rdi
movq 0x168(%rsp), %rdx
movq %rax, %rcx
leaq 0x4e93f2(%rip), %rsi    # 0x51b230
movb $0x0, %al
callq 0xddca0
movq 0x270(%rsp), %rdi
callq 0xb1f80
movq %rax, 0x268(%rsp)
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eadaf(%rip), %rsi    # 0x51cc1c
movb $0x0, %al
callq 0xddca0
movq $0x0, 0x260(%rsp)
movq 0x260(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0x268(%rsp), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq 0x148(%rsp), %rax
cmpq %rcx, %rax
jae 0x31fad
movq 0x260(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x140(%rsp)
movq 0x268(%rsp), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq 0x140(%rsp), %rax
cmpq %rcx, %rax
jae 0x31f30
movq 0x270(%rsp), %rdi
movq 0x260(%rsp), %rsi
addq $0x1, %rsi
callq 0xc2cc0
movq %rax, 0x138(%rsp)
movq 0x270(%rsp), %rdi
movq 0x260(%rsp), %rsi
callq 0xc2cc0
movq %rax, %rcx
movq 0x138(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x230(%rsp)
jmp 0x31f70
movq 0x270(%rsp), %rdi
callq 0xa9d50
movq %rax, 0x130(%rsp)
movq 0x270(%rsp), %rdi
movq 0x260(%rsp), %rsi
callq 0xc2cc0
movq %rax, %rcx
movq 0x130(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x230(%rsp)
movq 0x250(%rsp), %rax
cmpq 0x230(%rsp), %rax
jae 0x31f92
movq 0x230(%rsp), %rax
movq %rax, 0x250(%rsp)
jmp 0x31f94
movq 0x260(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x260(%rsp)
jmp 0x31e80
movq 0x250(%rsp), %rdi
movl $0x8, %esi
leaq 0x4ea971(%rip), %rdx    # 0x51c932
movl $0x107, %ecx            # imm = 0x107
callq 0xe83c0
movq %rax, 0x248(%rsp)
movq 0x270(%rsp), %rdi
callq 0xa9d50
movq %rax, %rdi
movl $0x8, %esi
leaq 0x4ea943(%rip), %rdx    # 0x51c932
movl $0x10a, %ecx            # imm = 0x10A
callq 0xe83c0
movq %rax, 0x240(%rsp)
movq $0x0, 0x260(%rsp)
movq 0x260(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x268(%rsp), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq 0x128(%rsp), %rax
cmpq %rcx, %rax
jae 0x323b4
movq 0x270(%rsp), %rdi
movq 0x260(%rsp), %rsi
callq 0xc2cc0
movq %rax, 0x220(%rsp)
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x110(%rsp)
movq 0x268(%rsp), %rdi
movq 0x260(%rsp), %rsi
callq 0x11f8c0
movq %rax, 0x118(%rsp)
movq 0x270(%rsp), %rdi
movq 0x260(%rsp), %rsi
callq 0xc29f0
movq 0x110(%rsp), %rdi
movq 0x118(%rsp), %rdx
movq %rax, %rcx
leaq 0x4eab76(%rip), %rsi    # 0x51cc31
movb $0x0, %al
callq 0xddca0
movq 0x260(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x120(%rsp)
movq 0x268(%rsp), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq 0x120(%rsp), %rax
cmpq %rcx, %rax
jae 0x3211e
movq 0x270(%rsp), %rdi
movq 0x260(%rsp), %rsi
addq $0x1, %rsi
callq 0xc2cc0
subq 0x220(%rsp), %rax
movq %rax, 0x228(%rsp)
jmp 0x3213b
movq 0x270(%rsp), %rdi
callq 0xa9d50
subq 0x220(%rsp), %rax
movq %rax, 0x228(%rsp)
cmpq $0x1, 0x228(%rsp)
jne 0x32162
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4eaaec(%rip), %rsi    # 0x51cc45
movb $0x0, %al
callq 0xddca0
jmp 0x32184
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x228(%rsp), %rdx
leaq 0x4eaad7(%rip), %rsi    # 0x51cc54
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
testb $0x1, 0x4(%rax)
je 0x32399
movq $0x0, 0x208(%rsp)
movq 0x270(%rsp), %rdi
movq 0x260(%rsp), %rsi
callq 0xc29f0
subq 0x228(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x218(%rsp)
movq 0x218(%rsp), %rax
shrq %rax
movq 0x218(%rsp), %rcx
andq $0x1, %rcx
addq %rcx, %rax
movq %rax, 0x218(%rsp)
movq $0x0, 0x210(%rsp)
movq 0x210(%rsp), %rax
cmpq 0x228(%rsp), %rax
jae 0x32298
movq 0x270(%rsp), %rdi
movq 0x210(%rsp), %rsi
addq 0x220(%rsp), %rsi
callq 0xb09f0
movq %rax, %rdx
movq 0x248(%rsp), %rax
movq 0x210(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x248(%rsp), %rax
movq 0x210(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x240(%rsp), %rax
movq 0x238(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x238(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x238(%rsp)
movq 0x210(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x210(%rsp)
jmp 0x321f9
movq 0x248(%rsp), %rdi
movq 0x228(%rsp), %rsi
movl $0x8, %edx
leaq 0xa2c(%rip), %rcx       # 0x32ce0
callq 0x19e70
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x248(%rsp), %rax
movq (%rax), %rdx
movq 0x248(%rsp), %rax
movq 0x228(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rcx
leaq 0x4ea977(%rip), %rsi    # 0x51cc66
movb $0x0, %al
callq 0xddca0
movq 0x228(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x210(%rsp)
movq 0x208(%rsp), %rax
cmpq 0x218(%rsp), %rax
jae 0x32356
movq 0x248(%rsp), %rax
movq 0x210(%rsp), %rcx
movq (%rax,%rcx,8), %rax
addq 0x208(%rsp), %rax
movq %rax, 0x208(%rsp)
movq 0x210(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x210(%rsp)
jmp 0x3230a
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x248(%rsp), %rax
movq 0x210(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq 0x228(%rsp), %rcx
subq 0x210(%rsp), %rcx
subq $0x1, %rcx
leaq 0x4ea8f9(%rip), %rsi    # 0x51cc8b
movb $0x0, %al
callq 0xddca0
jmp 0x3239b
movq 0x260(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x260(%rsp)
jmp 0x3200d
movq 0x248(%rsp), %rdi
leaq 0x4ea56f(%rip), %rsi    # 0x51c932
movl $0x13d, %edx            # imm = 0x13D
callq 0xe88c0
movq 0x2a8(%rsp), %rax
testb $0x1, 0x4(%rax)
je 0x32507
movq $0x0, 0x1f8(%rsp)
movq 0x270(%rsp), %rdi
callq 0xa9d50
movq %rax, 0x1f0(%rsp)
movq 0x270(%rsp), %rdi
callq 0xa9d00
subq 0x1f0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x200(%rsp)
movq 0x200(%rsp), %rax
shrq %rax
movq 0x200(%rsp), %rcx
andq $0x1, %rcx
addq %rcx, %rax
movq %rax, 0x200(%rsp)
movq 0x240(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
movl $0x8, %edx
leaq 0x881(%rip), %rcx       # 0x32ce0
callq 0x19e70
movq 0x1f0(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x260(%rsp)
movq 0x1f8(%rsp), %rax
cmpq 0x200(%rsp), %rax
jae 0x324c4
movq 0x240(%rsp), %rax
movq 0x260(%rsp), %rcx
movq (%rax,%rcx,8), %rax
addq 0x1f8(%rsp), %rax
movq %rax, 0x1f8(%rsp)
movq 0x260(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x260(%rsp)
jmp 0x32478
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x240(%rsp), %rax
movq 0x260(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq 0x1f0(%rsp), %rcx
subq 0x260(%rsp), %rcx
subq $0x1, %rcx
leaq 0x4ea7b1(%rip), %rsi    # 0x51ccb1
movb $0x0, %al
callq 0xddca0
movq 0x240(%rsp), %rdi
leaq 0x4ea41c(%rip), %rsi    # 0x51c932
movl $0x152, %edx            # imm = 0x152
callq 0xe88c0
movq 0x270(%rsp), %rdi
callq 0xb0f00
movq %rax, 0x298(%rsp)
movq 0x298(%rsp), %rdi
callq 0x7e970
movq %rax, 0x290(%rsp)
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ea615(%rip), %rsi    # 0x51cb72
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x100(%rsp)
movq 0x298(%rsp), %rdi
callq 0x7e8c0
movq 0x100(%rsp), %rdi
movl %eax, %edx
leaq 0x560920(%rip), %rsi    # 0x592eb6
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ea5d2(%rip), %rsi    # 0x51cb82
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x108(%rsp)
movq 0x298(%rsp), %rdi
callq 0x7e8c0
movq 0x108(%rsp), %rdi
movl %eax, %edx
movq 0x290(%rsp), %rcx
leaq 0x57a8ea(%rip), %rsi    # 0x5acedb
movb $0x0, %al
callq 0xddca0
movq 0x298(%rsp), %rdi
callq 0x7f400
testb $0x1, %al
jne 0x3260b
jmp 0x32625
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ea57a(%rip), %rsi    # 0x51cb98
movb $0x0, %al
callq 0xddca0
movq 0x298(%rsp), %rdi
callq 0x7f1a0
testb $0x1, %al
jne 0x32638
jmp 0x32652
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ea554(%rip), %rsi    # 0x51cb9f
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x560c0e(%rip), %rsi    # 0x593273
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
testb $0x1, 0x3(%rax)
je 0x32701
callq 0x11d4a0
movq %rax, 0x1e8(%rsp)
movq 0x298(%rsp), %rdi
movq 0x1e8(%rsp), %rsi
callq 0x7ea70
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ea4f7(%rip), %rsi    # 0x51cbaa
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xf8(%rsp)
movq 0x1e8(%rsp), %rdi
callq 0x11dee0
movq 0xf8(%rsp), %rdi
movq %rax, %rdx
leaq 0x4f47ff(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0xddca0
movq 0x1e8(%rsp), %rdi
callq 0x11f560
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ea5c5(%rip), %rsi    # 0x51ccd9
movb $0x0, %al
callq 0xddca0
movq $0x0, 0x260(%rsp)
movq 0x260(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0x298(%rsp), %rdi
callq 0x7e8c0
movl %eax, %ecx
movq 0xf0(%rsp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x328d3
movq 0x270(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x298(%rsp), %rdi
movq 0x290(%rsp), %rax
movq 0x260(%rsp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x7f6f0
movq 0x98(%rsp), %rdi
movzbl %al, %esi
callq 0xb0f60
movq %rax, 0x1e0(%rsp)
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xd0(%rsp)
movq 0x290(%rsp), %rax
movq 0x260(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, 0xdc(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq %rax, %xmm0
movaps 0x4e6143(%rip), %xmm1   # 0x518930
movaps %xmm1, 0xa0(%rsp)
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x4e613f(%rip), %xmm1   # 0x518940
movaps %xmm1, 0xb0(%rsp)
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, 0xc8(%rsp)
movq 0x270(%rsp), %rdi
callq 0xa9d00
movq %rax, 0xe8(%rsp)
movq 0x270(%rsp), %rdi
callq 0xa9d50
movaps 0xa0(%rsp), %xmm3
movaps 0xb0(%rsp), %xmm2
movsd 0xc8(%rsp), %xmm0
movq 0xd0(%rsp), %rdi
movl 0xdc(%rsp), %edx
movq 0xe0(%rsp), %rcx
movq %rax, %rsi
movq 0xe8(%rsp), %rax
subq %rsi, %rax
incq %rax
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x4e7f90(%rip), %xmm1   # 0x51a838
mulsd %xmm1, %xmm0
leaq 0x4ea43f(%rip), %rsi    # 0x51ccf2
movb $0x1, %al
callq 0xddca0
movq 0x260(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x260(%rsp)
jmp 0x32727
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ea41f(%rip), %rsi    # 0x51cd05
xorl %eax, %eax
movb %al, 0x4f(%rsp)
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x270(%rsp), %rdi
callq 0xb2880
movq %rax, 0x18(%rsp)
movq 0x270(%rsp), %rdi
callq 0xb2900
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
movb 0x4f(%rsp), %al
leaq 0x4ea3e2(%rip), %rsi    # 0x51cd1b
movq %rsi, 0x28(%rsp)
callq 0xddca0
movb 0x4f(%rsp), %al
movq 0x2a8(%rsp), %rcx
movq 0x10(%rcx), %rdi
leaq 0x4ea3d5(%rip), %rsi    # 0x51cd2f
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x270(%rsp), %rdi
callq 0xb2530
movq %rax, 0x30(%rsp)
movq 0x270(%rsp), %rdi
callq 0xb27b0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
movb 0x4f(%rsp), %al
callq 0xddca0
movb 0x4f(%rsp), %al
movq 0x2a8(%rsp), %rcx
movq 0x10(%rcx), %rdi
leaq 0x4ea38d(%rip), %rsi    # 0x51cd4e
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x270(%rsp), %rdi
callq 0xb2980
movq 0x38(%rsp), %rdi
movq %rax, %rdx
movb 0x4f(%rsp), %al
leaq 0x4ef0af(%rip), %rsi    # 0x521aa6
callq 0xddca0
movb 0x4f(%rsp), %al
movq 0x2a8(%rsp), %rcx
movq 0x10(%rcx), %rdi
leaq 0x4ea152(%rip), %rsi    # 0x51cb65
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x270(%rsp), %rdi
callq 0xc2d90
movl %eax, %edi
callq 0xd4600
movq 0x40(%rsp), %rdi
movq %rax, %rdx
movb 0x4f(%rsp), %al
leaq 0x4f449c(%rip), %rsi    # 0x526eec
callq 0xddca0
movb 0x4f(%rsp), %al
movq 0x2a8(%rsp), %rcx
movq 0x10(%rcx), %rdi
leaq 0x4ea314(%rip), %rsi    # 0x51cd80
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x270(%rsp), %rdi
callq 0xc2d70
shlq $0x3, %rax
movq %rax, %xmm0
movaps 0x4e5e8e(%rip), %xmm1   # 0x518930
movaps %xmm1, 0x50(%rsp)
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x4e5e8d(%rip), %xmm1   # 0x518940
movaps %xmm1, 0x60(%rsp)
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rsp)
movq 0x270(%rsp), %rdi
callq 0xa9d00
movaps 0x50(%rsp), %xmm3
movaps 0x60(%rsp), %xmm2
movsd 0x78(%rsp), %xmm0
movq 0x80(%rsp), %rdi
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
leaq 0x4ee74a(%rip), %rsi    # 0x52125f
movb $0x1, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ea26b(%rip), %rsi    # 0x51cd9a
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x88(%rsp)
movq 0x270(%rsp), %rdi
callq 0xaf360
movq 0x88(%rsp), %rdi
movb %al, %cl
leaq 0x562053(%rip), %rdx    # 0x594bbb
leaq 0x526c1e(%rip), %rax    # 0x55978d
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x4f436f(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ea218(%rip), %rsi    # 0x51cdaf
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x90(%rsp)
movq 0x270(%rsp), %rdi
callq 0xb24d0
movq 0x90(%rsp), %rdi
movb %al, %cl
leaq 0x561feb(%rip), %rdx    # 0x594bbb
leaq 0x526bb6(%rip), %rax    # 0x55978d
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x4f4307(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0xddca0
movq 0x270(%rsp), %rdi
callq 0xb24d0
testb $0x1, %al
jne 0x32bff
jmp 0x32c4d
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ea1b7(%rip), %rsi    # 0x51cdc9
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x270(%rsp), %rdi
callq 0xb1e50
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x4eee60(%rip), %rsi    # 0x521aa6
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x4ea189(%rip), %rsi    # 0x51cde9
movb $0x0, %al
callq 0xddca0
movq 0x2a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x270(%rsp), %rdi
callq 0xb2480
movq (%rsp), %rdi
movb %al, %cl
leaq 0x561f2a(%rip), %rdx    # 0x594bbb
leaq 0x526af5(%rip), %rax    # 0x55978d
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x4f4246(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0xddca0
movq 0x270(%rsp), %rdi
callq 0xae070
movq 0x278(%rsp), %rdi
callq 0xb7e50
movl 0x2a4(%rsp), %eax
addq $0x2d8, %rsp            # imm = 0x2D8
retq
nopw %cs:(%rax,%rax)