// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/encdesc.c
// Function: encdesc_analyze_descs
static int encdesc_analyze_descs(GtEncdesc *encdesc,
                                 GtCstrIterator *cstr_iterator,
                                 GtError *err)
{
  DescField  *cur_field;
  const char *descbuffer = NULL;
  char       *longest_desc = NULL,
             *mutable_desc = NULL,
              sep[GT_ENCDESC_NUMOFSEPS] = {GT_ENCDESC_SEPS};
  GtUword     chars_len,
              cur_desc = 0,
              cur_field_num,
              desc_char_idx,
              desclength,
              j_idx,
              k_idx,
              len_diff,
              longest_desc_field_idx = 0,
              sep_idx,
              start_pos = 0,
              tmp_numoffields;
  GtWord      out,
              value,
              value_delta;
  int         had_err = 0,
              status;
  unsigned    zero_count;
  bool        found;

  encdesc->num_of_fields = 0;
  encdesc->num_of_fields_is_const = true;
  GT_INITARRAY(&encdesc->num_of_fields_tab, GtUword);

  /* find description with maximum number of fields */
  /* TODO DW check constant number of fields here */
  /* TODO DW count totalnumofchars here */
  gt_error_check(err);
  status = gt_cstr_iterator_next(cstr_iterator, &descbuffer, err);
  while (status != 0) {
    if (status < 0)
      return status;
    gt_assert(descbuffer != NULL);

    desclength = (GtUword) strlen(descbuffer);

    tmp_numoffields = 0;
    for (desc_char_idx = 0; desc_char_idx <= desclength; desc_char_idx++) {
      for (sep_idx = 0; sep_idx < GT_ENCDESC_NUMOFSEPS; sep_idx++) {
        if (descbuffer[desc_char_idx] == sep[sep_idx]) {
          if (desc_char_idx - start_pos > 0) {
            tmp_numoffields++;
            start_pos = desc_char_idx + 1;
          }
          break;
        }
      }
    }
    if (tmp_numoffields > encdesc->num_of_fields) {
      encdesc->num_of_fields = tmp_numoffields;
      gt_free(longest_desc);
      longest_desc = gt_cstr_dup(descbuffer);
    }
    cur_desc++;
    status = gt_cstr_iterator_next(cstr_iterator, &descbuffer, err);
  }
  if (encdesc->num_of_fields == 0) {
    gt_error_set(err, "The file given seems to have no descriptions, there is "
                      "nothing to compress, aborting.");
    had_err = 1;
  }

  if (!had_err) {
    gt_assert(longest_desc != NULL);
    gt_log_log("longest desc: %s", longest_desc);
    encdesc->fields = gt_calloc((size_t) encdesc->num_of_fields,
                                sizeof (*encdesc->fields));

    /* analyze description with maximum number of fields and initialize fields
     */
    desclength = (GtUword) strlen(longest_desc);
    start_pos = 0;

    for (desc_char_idx = 0; desc_char_idx <= desclength; desc_char_idx++) {
      found = false;
      for (sep_idx = 0; sep_idx < GT_ENCDESC_NUMOFSEPS; sep_idx++)
        if (longest_desc[desc_char_idx] == sep[sep_idx]) {
          if (desc_char_idx - start_pos > 0)
            found = true;
        }

      if (found) {
        cur_field = &encdesc->fields[longest_desc_field_idx];
        cur_field->sep = longest_desc[desc_char_idx];
        longest_desc[desc_char_idx] = '\0';
        cur_field->len = desc_char_idx - start_pos;
        cur_field->data = gt_cstr_dup(longest_desc + start_pos);

        cur_field->max_len = cur_field->len;
        cur_field->min_len = cur_field->len;
        cur_field->is_const = true;
        cur_field->fieldlen_is_const = true;
        cur_field->has_zero_padding = false;
        cur_field->chars =
          gt_calloc((size_t) cur_field->max_len, sizeof (cur_field->chars));

        for (j_idx = 0; j_idx < cur_field->max_len; j_idx++)
          cur_field->chars[j_idx] = li_ull_gt_hashmap_new();

        cur_field->num_values = li_ull_gt_hashmap_new();
        cur_field->delta_values = li_ull_gt_hashmap_new();
        cur_field->zero_count = gt_disc_distri_new();
        cur_field->max_zero = 0;
        cur_field->num_values_size = 0;
        cur_field->delta_values_size = 0;
        if (gt_parse_word(&out, cur_field->data) == 0) {
          cur_field->is_numeric = true;
          cur_field->max_value = out;
          cur_field->min_value = out;
        }
        cur_field->bittab = gt_bittab_new(cur_field->len);
        gt_assert(cur_field->bittab != NULL);
        /* Set all bits to 1*/
        for (j_idx = 0; j_idx < cur_field->len; j_idx++) {
          gt_bittab_set_bit(cur_field->bittab, j_idx);
        }

        start_pos = desc_char_idx + 1;
        longest_desc_field_idx++;
      }
    }
    gt_assert(encdesc->num_of_fields == longest_desc_field_idx);

    gt_free(longest_desc);
  }

  if (!had_err) {
    if (gt_cstr_iterator_reset(cstr_iterator, err) != 0)
      had_err = 1;
  }

  if (!had_err) {
    cur_desc = 0;

    /* analyze all descriptions */
    status = gt_cstr_iterator_next(cstr_iterator, &descbuffer, err);
    while (status != 0) {
      if (status == -1)
        return -1;
      gt_assert(descbuffer != NULL);

      gt_free(mutable_desc);
      desclength = (GtUword) strlen(descbuffer);
      encdesc->total_num_of_chars += desclength;
      mutable_desc = gt_cstr_dup(descbuffer);

      cur_field_num = 0;
      start_pos = 0;

      for (desc_char_idx = 0;
           desc_char_idx <= desclength &&
             cur_field_num < encdesc->num_of_fields;
           desc_char_idx++) {
        cur_field = &encdesc->fields[cur_field_num];
        /* check for end of string, if there are less fields then in longest */
        if (mutable_desc[desc_char_idx] ==  cur_field->sep ||
            mutable_desc[desc_char_idx] == '\0') {
          mutable_desc[desc_char_idx] = '\0';

          chars_len = desc_char_idx - start_pos;
          if (chars_len > cur_field->max_len) {
            cur_field->is_const = false;
            cur_field->fieldlen_is_const = false;
            cur_field->chars =
              gt_realloc(cur_field->chars,
                         (size_t) chars_len * sizeof (GtHashtable*));
            for (k_idx = cur_field->max_len; k_idx < chars_len; k_idx++)
              cur_field->chars[k_idx] = li_ull_gt_hashmap_new();

            cur_field->max_len = chars_len;
          }
          else if (chars_len < cur_field->min_len) {
            cur_field->is_const = false;
            cur_field->fieldlen_is_const = false;
            cur_field->min_len = chars_len;
          }

          for (k_idx = 0; k_idx < chars_len; k_idx++) {
            (void) encdesc_hashmap_distr_add(
                                      cur_field->chars[k_idx],
                                      (GtWord) mutable_desc[start_pos + k_idx]);
          }

          if (cur_field->is_const) {
            if (strcmp(cur_field->data, mutable_desc + start_pos) != 0)
              cur_field->is_const = false;
          }

          if (cur_field->is_numeric) {
            if (gt_parse_word(&out, (mutable_desc + start_pos)) != 0)
              cur_field->is_numeric = false;
            else {
              value = out;

              zero_count = count_leading_zeros((mutable_desc + start_pos));
              if (zero_count > 0)
                cur_field->has_zero_padding = true;
              if (zero_count > cur_field->max_zero)
                cur_field->max_zero = zero_count;
              gt_disc_distri_add(cur_field->zero_count,
                                 (GtUword) zero_count);

              if (cur_desc == 0) {
                cur_field->global_value =
                  cur_field->min_value =
                  cur_field->max_value = value;
                cur_field->is_value_const =
                  cur_field->is_delta_positive =
                  cur_field->is_delta_negative = true;
              }
              else {
                value_delta = value - cur_field->prev_value;
                if (value_delta != 0) {
                  cur_field->is_value_const = false;
                  if (value < cur_field->min_value) {
                    cur_field->min_value = value;
                  }
                  if (value > cur_field->max_value) {
                    cur_field->max_value = value;
                  }
                }
                if (value_delta <= 0)
                  cur_field->is_delta_positive = false;
                if (value_delta >= 0)
                  cur_field->is_delta_negative = false;

                if (cur_desc == 1UL) {
                  cur_field->max_delta =
                    cur_field->min_delta =
                    cur_field->global_delta = value_delta;
                  cur_field->is_delta_const = true;
                }
                else {
                  if (value_delta > cur_field->max_delta) {
                    cur_field->is_delta_const = false;
                    cur_field->max_delta = value_delta;
                  }
                  if (value_delta < cur_field->min_delta) {
                    cur_field->is_delta_const = false;
                    cur_field->min_delta = value_delta;
                  }
                }
                if (encdesc_hashmap_distr_add(cur_field->delta_values,
                                              value_delta) == 1)
                  cur_field->delta_values_size++;
              }
              if (encdesc_hashmap_distr_add(cur_field->num_values,
                                            value) == 1)
                cur_field->num_values_size++;
              cur_field->prev_value = value;
            }
          }

          /* unmark non constant positions */
          if (!cur_field->is_const) {
            for (k_idx = 0; k_idx < cur_field->len; k_idx++) {
              if (k_idx < chars_len) {
                if (cur_field->data[k_idx] != mutable_desc[k_idx + start_pos])
                  gt_bittab_unset_bit(cur_field->bittab, k_idx);
              }
              else
                gt_bittab_unset_bit(cur_field->bittab, k_idx);
            }
          }
          start_pos = desc_char_idx + 1;
          cur_field_num++;
        }
      }

      gt_assert(desc_char_idx == desclength + 1);
      gt_assert(cur_field_num <= longest_desc_field_idx);
      if (cur_field_num != longest_desc_field_idx) {
        gt_log_log(GT_WU "!= " GT_WU " less fields in desc: " GT_WU ": %s\t"
                   GT_WU "!=" GT_WU,
                   cur_field_num, longest_desc_field_idx,
                   cur_desc, descbuffer,
                   desc_char_idx, desclength);
        encdesc->num_of_fields_is_const = false;
      }

      GT_STOREINARRAY(&encdesc->num_of_fields_tab, GtUword, 128 ,cur_field_num);

      /* TODO DW this heuristic is bad, if the 2nd field is missing, all
         following fields are missing too! */
      /* change this so a field can be absent in a single description */
      /* absent fields are non constant */
      for (/* nothing */;
           cur_field_num < encdesc->num_of_fields;
           cur_field_num++) {
        cur_field = &encdesc->fields[cur_field_num];
        cur_field->is_const = false;
        cur_field->fieldlen_is_const = false;
        cur_field->is_numeric = false;
      }
      cur_desc++;
      status = gt_cstr_iterator_next(cstr_iterator, &descbuffer, err);
    }
    gt_free(mutable_desc);
    mutable_desc = NULL;

    encdesc->num_of_descs = cur_desc;
    if (encdesc->num_of_fields_is_const) {
      GT_FREEARRAY(&encdesc->num_of_fields_tab, GtUword);
    }

    for (cur_field_num = 0;
         cur_field_num < encdesc->num_of_fields;
         cur_field_num++) {
      cur_field = &encdesc->fields[cur_field_num];
      gt_assert(cur_field->bittab != NULL);

      gt_log_log("field " GT_WU " is %sconst.",
                 cur_field_num,
                 cur_field->is_const ? "" : "not ");

      if (!cur_field->is_numeric) {
        if (!cur_field->is_const) {
          len_diff = cur_field->max_len - cur_field->min_len;
          cur_field->bits_per_len =
            encdesc_digits_per_value((GtUword) len_diff, 2UL);
        }
      }
      else {
        /* TODO DW range can be large, but the size of the dist is more
           important for huffman coding */
        GtWord value_range, delta_range, value_diff;
        value_range = labs(cur_field->max_value - cur_field->min_value);
        delta_range = labs(cur_field->max_delta - cur_field->min_delta);
        gt_log_log("value range: " GT_WD " delta range: " GT_WD, value_range,
                   delta_range);
        gt_log_log("num values: " GT_WU " num deltas: " GT_WU,
                   cur_field->num_values_size,
                   cur_field->delta_values_size);
        if (value_range < delta_range || cur_field->delta_values_size == 0) {
          cur_field->use_delta_coding = false;
          value_diff = value_range;
        }
        else {
          cur_field->use_delta_coding = true;
          value_diff = delta_range;
        }
        cur_field->bits_per_num =
          encdesc_digits_per_value((GtUword) value_diff, 2UL);
        cur_field->bits_per_value =
          encdesc_digits_per_value((GtUword) value_range, 2UL);
      }
      gt_log_log("uses huffman: %s", cur_field->use_hc ? "yes" : "no");
      if (!cur_field->is_const) {
        gt_log_log("is %snumeric",
                   cur_field->is_numeric ? "" : "not ");
        if (cur_field->is_numeric) {
          gt_log_log("is %sdelta const, uses %s delta coding",
                     cur_field->is_delta_const ? "" : "not ",
                     cur_field->use_delta_coding ? "" : "no ");
          gt_log_log("delta is %sstrictly %schanging",
                     (cur_field->is_delta_positive ||
                      cur_field->is_delta_negative) ? "" : "not ",
                     cur_field->is_delta_positive ? "positive " :
                     (cur_field->is_delta_negative ? "negative " : ""));
        }
      }
    }
    encdesc->bits_per_field =
      encdesc_digits_per_value(encdesc->num_of_fields, 2UL);
  }
  return had_err;
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0xf8(%rsp)
movq $0x0, 0xe8(%rsp)
movq $0x0, 0xe0(%rsp)
movq $0x0, 0xd8(%rsp)
movq 0x3eed5b(%rip), %rax    # 0x54e695
movq %rax, 0xce(%rsp)
movw 0x3eed54(%rip), %ax     # 0x54e69d
movw %ax, 0xd6(%rsp)
movq $0x0, 0xb8(%rsp)
movq $0x0, 0x80(%rsp)
movq $0x0, 0x70(%rsp)
movl $0x0, 0x4c(%rsp)
movq 0x108(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x108(%rsp), %rax
movb $0x1, 0x6c(%rax)
movq 0x108(%rsp), %rax
movq $0x0, (%rax)
movq 0x108(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x108(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x15f9c7
cmpq $0x0, 0xf8(%rsp)
je 0x15fa1d
movq 0xf8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x15f9e5
jmp 0x15fa1d
movq 0x4dc5b4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b661d(%rip), %rsi    # 0x516013
leaq 0x3b67c2(%rip), %rdx    # 0x5161bf
leaq 0x3eec9b(%rip), %rcx    # 0x54e69f
leaq 0x3ee85d(%rip), %r8     # 0x54e268
movl $0x164, %r9d            # imm = 0x164
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x15fa1f
movq 0x100(%rsp), %rdi
movq 0xf8(%rsp), %rdx
leaq 0xe8(%rsp), %rsi
callq 0x48ea50
movl %eax, 0x48(%rsp)
cmpl $0x0, 0x48(%rsp)
je 0x15fc0c
cmpl $0x0, 0x48(%rsp)
jge 0x15fa62
movl 0x48(%rsp), %eax
movl %eax, 0x114(%rsp)
jmp 0x1610fb
jmp 0x15fa64
cmpq $0x0, 0xe8(%rsp)
jne 0x15faa7
movq 0x4dc52a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b6593(%rip), %rsi    # 0x516013
leaq 0x3eec2e(%rip), %rdx    # 0x54e6b5
leaq 0x3eec11(%rip), %rcx    # 0x54e69f
leaq 0x3ee7d3(%rip), %r8     # 0x54e268
movl $0x169, %r9d            # imm = 0x169
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x15faa9
movq 0xe8(%rsp), %rdi
callq 0x192b0
movq %rax, 0xa0(%rsp)
movq $0x0, 0x68(%rsp)
movq $0x0, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
cmpq 0xa0(%rsp), %rax
ja 0x15fb80
movq $0x0, 0x78(%rsp)
cmpq $0xa, 0x78(%rsp)
jae 0x15fb65
movq 0xe8(%rsp), %rax
movq 0xa8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x78(%rsp), %rcx
movsbl 0xce(%rsp,%rcx), %ecx
cmpl %ecx, %eax
jne 0x15fb53
movq 0xa8(%rsp), %rax
subq 0x70(%rsp), %rax
cmpq $0x0, %rax
jbe 0x15fb51
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
movq 0xa8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x15fb65
jmp 0x15fb55
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0x15faf2
jmp 0x15fb67
movq 0xa8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa8(%rsp)
jmp 0x15fad3
movq 0x68(%rsp), %rax
movq 0x108(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jbe 0x15fbd2
movq 0x68(%rsp), %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0xe0(%rsp), %rdi
leaq 0x3ee6b5(%rip), %rsi    # 0x54e268
movl $0x17b, %edx            # imm = 0x17B
callq 0xe88c0
movq 0xe8(%rsp), %rdi
callq 0xa2db0
movq %rax, 0xe0(%rsp)
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xf8(%rsp), %rdx
leaq 0xe8(%rsp), %rsi
callq 0x48ea50
movl %eax, 0x48(%rsp)
jmp 0x15fa40
movq 0x108(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x15fc39
movq 0xf8(%rsp), %rdi
leaq 0x3eea9e(%rip), %rsi    # 0x54e6c8
movb $0x0, %al
callq 0xd88c0
movl $0x1, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x160121
jmp 0x15fc46
cmpq $0x0, 0xe0(%rsp)
jne 0x15fc89
movq 0x4dc348(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b63b1(%rip), %rsi    # 0x516013
leaq 0x3eeab5(%rip), %rdx    # 0x54e71e
leaq 0x3eea2f(%rip), %rcx    # 0x54e69f
leaq 0x3ee5f1(%rip), %r8     # 0x54e268
movl $0x188, %r9d            # imm = 0x188
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x15fc8b
movq 0xe0(%rsp), %rsi
leaq 0x3eea99(%rip), %rdi    # 0x54e733
movb $0x0, %al
callq 0xe7740
movq 0x108(%rsp), %rax
movq 0x40(%rax), %rdi
movl $0xc8, %esi
leaq 0x3ee5af(%rip), %rdx    # 0x54e268
movl $0x18b, %ecx            # imm = 0x18B
callq 0xe83c0
movq %rax, %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0xe0(%rsp), %rdi
callq 0x192b0
movq %rax, 0xa0(%rsp)
movq $0x0, 0x70(%rsp)
movq $0x0, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
cmpq 0xa0(%rsp), %rax
ja 0x1600b6
movb $0x0, 0x43(%rsp)
movq $0x0, 0x78(%rsp)
cmpq $0xa, 0x78(%rsp)
jae 0x15fd79
movq 0xe0(%rsp), %rax
movq 0xa8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x78(%rsp), %rcx
movsbl 0xce(%rsp,%rcx), %ecx
cmpl %ecx, %eax
jne 0x15fd67
movq 0xa8(%rsp), %rax
subq 0x70(%rsp), %rax
cmpq $0x0, %rax
jbe 0x15fd65
movb $0x1, 0x43(%rsp)
jmp 0x15fd67
jmp 0x15fd69
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0x15fd20
testb $0x1, 0x43(%rsp)
je 0x16009b
movq 0x108(%rsp), %rax
movq 0x18(%rax), %rax
imulq $0xc8, 0x80(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0xf0(%rsp)
movq 0xe0(%rsp), %rax
movq 0xa8(%rsp), %rcx
movb (%rax,%rcx), %cl
movq 0xf0(%rsp), %rax
movb %cl, 0xb8(%rax)
movq 0xe0(%rsp), %rax
movq 0xa8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0xa8(%rsp), %rcx
subq 0x70(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0xe0(%rsp), %rdi
addq 0x70(%rsp), %rdi
callq 0xa2db0
movq %rax, %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0xf0(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x68(%rax)
movq 0xf0(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0xf0(%rsp), %rax
movb $0x1, 0xbb(%rax)
movq 0xf0(%rsp), %rax
movb $0x1, 0xb9(%rax)
movq 0xf0(%rsp), %rax
movb $0x0, 0xba(%rax)
movq 0xf0(%rsp), %rax
movq 0x68(%rax), %rdi
movl $0x8, %esi
leaq 0x3ee3dd(%rip), %rdx    # 0x54e268
movl $0x1a7, %ecx            # imm = 0x1A7
callq 0xe83c0
movq %rax, %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x30(%rax)
movq $0x0, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x68(%rcx), %rax
jae 0x15fefc
callq 0x163500
movq %rax, %rdx
movq 0xf0(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x98(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x15feb0
callq 0x163500
movq %rax, %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x20(%rax)
callq 0x163500
movq %rax, %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x28(%rax)
callq 0xa5080
movq %rax, %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0xf0(%rsp), %rax
movl $0x0, 0xb4(%rax)
movq 0xf0(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0xf0(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0xf0(%rsp), %rax
movq 0x40(%rax), %rsi
leaq 0x60(%rsp), %rdi
callq 0xf85a0
cmpl $0x0, %eax
jne 0x15ffbc
movq 0xf0(%rsp), %rax
movb $0x1, 0xbf(%rax)
movq 0x60(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x60(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0xf0(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x89a20
movq %rax, %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0xf0(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x160023
movq 0x4dbfae(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b6017(%rip), %rsi    # 0x516013
leaq 0x3ee741(%rip), %rdx    # 0x54e744
leaq 0x3ee695(%rip), %rcx    # 0x54e69f
leaq 0x3ee257(%rip), %r8     # 0x54e268
movl $0x1b8, %r9d            # imm = 0x1B8
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x160025
movq $0x0, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x160076
movq 0xf0(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x98(%rsp), %rsi
callq 0x89b00
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x160031
movq 0xa8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0x16009d
movq 0xa8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa8(%rsp)
jmp 0x15fcfc
jmp 0x1600b8
movq 0x108(%rsp), %rax
movq 0x40(%rax), %rax
cmpq 0x80(%rsp), %rax
je 0x160106
movq 0x4dbecb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b5f34(%rip), %rsi    # 0x516013
leaq 0x3ee678(%rip), %rdx    # 0x54e75e
leaq 0x3ee5b2(%rip), %rcx    # 0x54e69f
leaq 0x3ee174(%rip), %r8     # 0x54e268
movl $0x1c2, %r9d            # imm = 0x1C2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x160108
movq 0xe0(%rsp), %rdi
leaq 0x3ee151(%rip), %rsi    # 0x54e268
movl $0x1c4, %edx            # imm = 0x1C4
callq 0xe88c0
cmpl $0x0, 0x4c(%rsp)
jne 0x16014c
movq 0x100(%rsp), %rdi
movq 0xf8(%rsp), %rsi
callq 0x48e960
cmpl $0x0, %eax
je 0x16014a
movl $0x1, 0x4c(%rsp)
jmp 0x16014c
cmpl $0x0, 0x4c(%rsp)
jne 0x1610f0
movq $0x0, 0xb8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xf8(%rsp), %rdx
leaq 0xe8(%rsp), %rsi
callq 0x48ea50
movl %eax, 0x48(%rsp)
cmpl $0x0, 0x48(%rsp)
je 0x160c2b
cmpl $-0x1, 0x48(%rsp)
jne 0x1601a6
movl $0xffffffff, 0x114(%rsp) # imm = 0xFFFFFFFF
jmp 0x1610fb
jmp 0x1601a8
cmpq $0x0, 0xe8(%rsp)
jne 0x1601eb
movq 0x4dbde6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b5e4f(%rip), %rsi    # 0x516013
leaq 0x3ee4ea(%rip), %rdx    # 0x54e6b5
leaq 0x3ee4cd(%rip), %rcx    # 0x54e69f
leaq 0x3ee08f(%rip), %r8     # 0x54e268
movl $0x1d4, %r9d            # imm = 0x1D4
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1601ed
movq 0xd8(%rsp), %rdi
leaq 0x3ee06c(%rip), %rsi    # 0x54e268
movl $0x1d6, %edx            # imm = 0x1D6
callq 0xe88c0
movq 0xe8(%rsp), %rdi
callq 0x192b0
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rcx
movq 0x108(%rsp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq 0xe8(%rsp), %rdi
callq 0xa2db0
movq %rax, 0xd8(%rsp)
movq $0x0, 0xb0(%rsp)
movq $0x0, 0x70(%rsp)
movq $0x0, 0xa8(%rsp)
movq 0xa8(%rsp), %rcx
xorl %eax, %eax
cmpq 0xa0(%rsp), %rcx
movb %al, 0x1f(%rsp)
ja 0x16029c
movq 0xb0(%rsp), %rax
movq 0x108(%rsp), %rcx
cmpq 0x40(%rcx), %rax
setb %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x1602a9
jmp 0x160935
movq 0x108(%rsp), %rax
movq 0x18(%rax), %rax
imulq $0xc8, 0xb0(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0xf0(%rsp)
movq 0xd8(%rsp), %rax
movq 0xa8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0xf0(%rsp), %rcx
movsbl 0xb8(%rcx), %ecx
cmpl %ecx, %eax
je 0x160310
movq 0xd8(%rsp), %rax
movq 0xa8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x16091a
movq 0xd8(%rsp), %rax
movq 0xa8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0xa8(%rsp), %rax
subq 0x70(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x68(%rcx), %rax
jbe 0x16041b
movq 0xf0(%rsp), %rax
movb $0x0, 0xbb(%rax)
movq 0xf0(%rsp), %rax
movb $0x0, 0xb9(%rax)
movq 0xf0(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0xc0(%rsp), %rsi
shlq $0x3, %rsi
leaq 0x3eded8(%rip), %rdx    # 0x54e268
movl $0x1ee, %ecx            # imm = 0x1EE
callq 0xe8540
movq %rax, %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0xf0(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
cmpq 0xc0(%rsp), %rax
jae 0x160405
callq 0x163500
movq %rax, %rdx
movq 0xf0(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x90(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
jmp 0x1603bd
movq 0xc0(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x68(%rax)
jmp 0x160465
movq 0xc0(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x160463
movq 0xf0(%rsp), %rax
movb $0x0, 0xbb(%rax)
movq 0xf0(%rsp), %rax
movb $0x0, 0xb9(%rax)
movq 0xc0(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x58(%rax)
jmp 0x160465
movq $0x0, 0x90(%rsp)
movq 0x90(%rsp), %rax
cmpq 0xc0(%rsp), %rax
jae 0x1604d0
movq 0xf0(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x90(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0xd8(%rsp), %rax
movq 0x70(%rsp), %rcx
addq 0x90(%rsp), %rcx
movsbq (%rax,%rcx), %rsi
callq 0x163540
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
jmp 0x160471
movq 0xf0(%rsp), %rax
testb $0x1, 0xbb(%rax)
je 0x160515
movq 0xf0(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0xd8(%rsp), %rsi
addq 0x70(%rsp), %rsi
callq 0x19980
cmpl $0x0, %eax
je 0x160513
movq 0xf0(%rsp), %rax
movb $0x0, 0xbb(%rax)
jmp 0x160515
movq 0xf0(%rsp), %rax
testb $0x1, 0xbf(%rax)
je 0x160822
movq 0xd8(%rsp), %rsi
addq 0x70(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0xf85a0
cmpl $0x0, %eax
je 0x16055a
movq 0xf0(%rsp), %rax
movb $0x0, 0xbf(%rax)
jmp 0x160820
movq 0x60(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0xd8(%rsp), %rdi
addq 0x70(%rsp), %rdi
callq 0x163410
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
jbe 0x160590
movq 0xf0(%rsp), %rax
movb $0x1, 0xba(%rax)
movl 0x44(%rsp), %eax
movq 0xf0(%rsp), %rcx
cmpl 0xb4(%rcx), %eax
jbe 0x1605b6
movl 0x44(%rsp), %ecx
movq 0xf0(%rsp), %rax
movl %ecx, 0xb4(%rax)
movq 0xf0(%rsp), %rax
movq 0x38(%rax), %rdi
movl 0x44(%rsp), %eax
movl %eax, %esi
callq 0xa50a0
cmpq $0x0, 0xb8(%rsp)
jne 0x160639
movq 0x58(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0xf0(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0xf0(%rsp), %rax
movq %rcx, 0x78(%rax)
movq 0xf0(%rsp), %rax
movb $0x1, 0xbe(%rax)
movq 0xf0(%rsp), %rax
movb $0x1, 0xbd(%rax)
movq 0xf0(%rsp), %rax
movb $0x1, 0xc0(%rax)
jmp 0x1607dd
movq 0x58(%rsp), %rax
movq 0xf0(%rsp), %rcx
subq 0xa0(%rcx), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x1606bf
movq 0xf0(%rsp), %rax
movb $0x0, 0xc0(%rax)
movq 0x58(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x98(%rcx), %rax
jge 0x160693
movq 0x58(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x58(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x88(%rcx), %rax
jle 0x1606bd
movq 0x58(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x88(%rax)
jmp 0x1606bf
cmpq $0x0, 0x50(%rsp)
jg 0x1606d6
movq 0xf0(%rsp), %rax
movb $0x0, 0xbd(%rax)
cmpq $0x0, 0x50(%rsp)
jl 0x1606ed
movq 0xf0(%rsp), %rax
movb $0x0, 0xbe(%rax)
cmpq $0x1, 0xb8(%rsp)
jne 0x160738
movq 0x50(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x70(%rax)
movq 0xf0(%rsp), %rax
movq %rcx, 0x90(%rax)
movq 0xf0(%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0xf0(%rsp), %rax
movb $0x1, 0xbc(%rax)
jmp 0x1607ac
movq 0x50(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x80(%rcx), %rax
jle 0x160771
movq 0xf0(%rsp), %rax
movb $0x0, 0xbc(%rax)
movq 0x50(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x50(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x90(%rcx), %rax
jge 0x1607aa
movq 0xf0(%rsp), %rax
movb $0x0, 0xbc(%rax)
movq 0x50(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x90(%rax)
jmp 0x1607ac
movq 0xf0(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x50(%rsp), %rsi
callq 0x163540
cmpl $0x1, %eax
jne 0x1607db
movq 0xf0(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
jmp 0x1607dd
movq 0xf0(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x58(%rsp), %rsi
callq 0x163540
cmpl $0x1, %eax
jne 0x16080c
movq 0xf0(%rsp), %rax
movq 0x60(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x60(%rax)
movq 0x58(%rsp), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0xa0(%rax)
jmp 0x160822
movq 0xf0(%rsp), %rax
testb $0x1, 0xbb(%rax)
jne 0x1608f5
movq $0x0, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x1608f3
movq 0x90(%rsp), %rax
cmpq 0xc0(%rsp), %rax
jae 0x1608bf
movq 0xf0(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x90(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0xd8(%rsp), %rcx
movq 0x90(%rsp), %rdx
addq 0x70(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x1608bd
movq 0xf0(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x90(%rsp), %rsi
callq 0x89ba0
jmp 0x1608d8
movq 0xf0(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x90(%rsp), %rsi
callq 0x89ba0
jmp 0x1608da
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
jmp 0x160843
jmp 0x1608f5
movq 0xa8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
movq 0xb0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb0(%rsp)
jmp 0x16091c
movq 0xa8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa8(%rsp)
jmp 0x160269
jmp 0x160937
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
je 0x160988
movq 0x4db649(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b56b2(%rip), %rsi    # 0x516013
leaq 0x3ede27(%rip), %rdx    # 0x54e78f
leaq 0x3edd30(%rip), %rcx    # 0x54e69f
leaq 0x3ed8f2(%rip), %r8     # 0x54e268
movl $0x256, %r9d            # imm = 0x256
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x16098a
jmp 0x16098c
movq 0xb0(%rsp), %rax
cmpq 0x80(%rsp), %rax
jbe 0x1609d6
movq 0x4db5fb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b5664(%rip), %rsi    # 0x516013
leaq 0x3eddf9(%rip), %rdx    # 0x54e7af
leaq 0x3edce2(%rip), %rcx    # 0x54e69f
leaq 0x3ed8a4(%rip), %r8     # 0x54e268
movl $0x257, %r9d            # imm = 0x257
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1609d8
movq 0xb0(%rsp), %rax
cmpq 0x80(%rsp), %rax
je 0x160a38
movq 0xb0(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0xb8(%rsp), %rcx
movq 0xe8(%rsp), %r8
movq 0xa8(%rsp), %r9
movq 0xa0(%rsp), %rax
leaq 0x3eddb6(%rip), %rdi    # 0x54e7d7
movq %rax, (%rsp)
movb $0x0, %al
callq 0xe7740
movq 0x108(%rsp), %rax
movb $0x0, 0x6c(%rax)
jmp 0x160a3a
jmp 0x160a3c
movq 0x108(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x0, %rax
movq 0x108(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x160af9
movq $0x80, 0x38(%rsp)
xorl %eax, %eax
cmpq 0x38(%rsp), %rax
jbe 0x160aa8
movq 0x4db529(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b5592(%rip), %rsi    # 0x516013
leaq 0x3b871f(%rip), %rdx    # 0x5191a7
leaq 0x3edc10(%rip), %rcx    # 0x54e69f
leaq 0x3ed7d2(%rip), %r8     # 0x54e268
movl $0x261, %r9d            # imm = 0x261
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x160aaa
movq 0x38(%rsp), %rcx
movq 0x108(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x108(%rsp), %rax
movq (%rax), %rdi
movq 0x108(%rsp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
leaq 0x3ed787(%rip), %rdx    # 0x54e268
movl $0x261, %ecx            # imm = 0x261
callq 0xe8540
movq %rax, %rcx
movq 0x108(%rsp), %rax
movq %rcx, (%rax)
jmp 0x160afb
movq 0x108(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x160b41
movq 0x4db490(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b54f9(%rip), %rsi    # 0x516013
leaq 0x3edce6(%rip), %rdx    # 0x54e807
leaq 0x3edb77(%rip), %rcx    # 0x54e69f
leaq 0x3ed739(%rip), %r8     # 0x54e268
movl $0x261, %r9d            # imm = 0x261
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x160b43
jmp 0x160b45
movq 0xb0(%rsp), %rdx
movq 0x108(%rsp), %rax
movq (%rax), %rax
movq 0x108(%rsp), %rsi
movq 0x10(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x10(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x160b75
movq 0xb0(%rsp), %rax
movq 0x108(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x160bf1
movq 0x108(%rsp), %rax
movq 0x18(%rax), %rax
imulq $0xc8, 0xb0(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movb $0x0, 0xbb(%rax)
movq 0xf0(%rsp), %rax
movb $0x0, 0xb9(%rax)
movq 0xf0(%rsp), %rax
movb $0x0, 0xbf(%rax)
movq 0xb0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb0(%rsp)
jmp 0x160b75
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xf8(%rsp), %rdx
leaq 0xe8(%rsp), %rsi
callq 0x48ea50
movl %eax, 0x48(%rsp)
jmp 0x160184
movq 0xd8(%rsp), %rdi
leaq 0x3ed62e(%rip), %rsi    # 0x54e268
movl $0x272, %edx            # imm = 0x272
callq 0xe88c0
movq $0x0, 0xd8(%rsp)
movq 0xb8(%rsp), %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x108(%rsp), %rax
testb $0x1, 0x6c(%rax)
je 0x160cd1
jmp 0x160c74
movq 0x108(%rsp), %rax
cmpq $0x0, (%rax)
je 0x160ccd
movq 0x108(%rsp), %rax
movq (%rax), %rdi
leaq 0x3ed5d4(%rip), %rsi    # 0x54e268
movl $0x277, %edx            # imm = 0x277
callq 0xe88c0
movq 0x108(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x108(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x108(%rsp), %rax
movq $0x0, (%rax)
jmp 0x160ccf
jmp 0x160cd1
movq $0x0, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq 0x108(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x1610cd
movq 0x108(%rsp), %rax
movq 0x18(%rax), %rax
imulq $0xc8, 0xb0(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x160d61
movq 0x4db270(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b52d9(%rip), %rsi    # 0x516013
leaq 0x3eda03(%rip), %rdx    # 0x54e744
leaq 0x3ed957(%rip), %rcx    # 0x54e69f
leaq 0x3ed519(%rip), %r8     # 0x54e268
movl $0x27e, %r9d            # imm = 0x27E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x160d63
movq 0xb0(%rsp), %rsi
movq 0xf0(%rsp), %rax
movb 0xbb(%rax), %cl
leaq 0x3c708c(%rip), %rdx    # 0x527e0c
leaq 0x43c8a1(%rip), %rax    # 0x59d628
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x3edaa6(%rip), %rdi    # 0x54e83b
movb $0x0, %al
callq 0xe7740
movq 0xf0(%rsp), %rax
testb $0x1, 0xbf(%rax)
jne 0x160e05
movq 0xf0(%rsp), %rax
testb $0x1, 0xbb(%rax)
jne 0x160e00
movq 0xf0(%rsp), %rax
movq 0x68(%rax), %rax
movq 0xf0(%rsp), %rcx
subq 0x58(%rcx), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
movl $0x2, %esi
callq 0x1635f0
movl %eax, %ecx
movq 0xf0(%rsp), %rax
movl %ecx, 0xa8(%rax)
jmp 0x160f2a
movq 0xf0(%rsp), %rax
movq 0x88(%rax), %rax
movq 0xf0(%rsp), %rcx
subq 0x98(%rcx), %rax
movq %rax, %rcx
negq %rcx
cmovnsq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0xf0(%rsp), %rax
movq 0x80(%rax), %rax
movq 0xf0(%rsp), %rcx
subq 0x90(%rcx), %rax
movq %rax, %rcx
negq %rcx
cmovnsq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x3ed9e1(%rip), %rdi    # 0x54e851
movb $0x0, %al
callq 0xe7740
movq 0xf0(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0xf0(%rsp), %rax
movq 0x48(%rax), %rdx
leaq 0x3ed9dd(%rip), %rdi    # 0x54e873
movb $0x0, %al
callq 0xe7740
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jl 0x160eb8
movq 0xf0(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x160ed3
movq 0xf0(%rsp), %rax
movb $0x0, 0xc1(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x160eec
movq 0xf0(%rsp), %rax
movb $0x1, 0xc1(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x1635f0
movl %eax, %ecx
movq 0xf0(%rsp), %rax
movl %ecx, 0xac(%rax)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x1635f0
movl %eax, %ecx
movq 0xf0(%rsp), %rax
movl %ecx, 0xb0(%rax)
movq 0xf0(%rsp), %rax
movb 0xc2(%rax), %cl
leaq 0x433c7c(%rip), %rsi    # 0x594bbb
leaq 0x3f8847(%rip), %rax    # 0x55978d
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x3ed93f(%rip), %rdi    # 0x54e893
movb $0x0, %al
callq 0xe7740
movq 0xf0(%rsp), %rax
testb $0x1, 0xbb(%rax)
jne 0x1610b2
movq 0xf0(%rsp), %rax
movb 0xbf(%rax), %cl
leaq 0x3c6e87(%rip), %rsi    # 0x527e0c
leaq 0x43c69c(%rip), %rax    # 0x59d628
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x3ed90a(%rip), %rdi    # 0x54e8a4
movb $0x0, %al
callq 0xe7740
movq 0xf0(%rsp), %rax
testb $0x1, 0xbf(%rax)
je 0x1610b0
movq 0xf0(%rsp), %rax
movb 0xbc(%rax), %cl
leaq 0x3c6e41(%rip), %rsi    # 0x527e0c
leaq 0x43c656(%rip), %rax    # 0x59d628
testb $0x1, %cl
cmovneq %rax, %rsi
movq 0xf0(%rsp), %rax
movb 0xc1(%rax), %cl
leaq 0x3ed8ea(%rip), %rdx    # 0x54e8d8
leaq 0x43c633(%rip), %rax    # 0x59d628
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x3ed8ae(%rip), %rdi    # 0x54e8b1
movb $0x0, %al
callq 0xe7740
movq 0xf0(%rsp), %rcx
movb $0x1, %al
testb $0x1, 0xbd(%rcx)
movb %al, 0x1e(%rsp)
jne 0x161033
movq 0xf0(%rsp), %rax
movb 0xbe(%rax), %al
movb %al, 0x1e(%rsp)
movb 0x1e(%rsp), %dl
leaq 0x3c6dce(%rip), %rax    # 0x527e0c
leaq 0x43c5e3(%rip), %rcx    # 0x59d628
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0xf0(%rsp), %rax
testb $0x1, 0xbd(%rax)
je 0x161070
leaq 0x3ed892(%rip), %rax    # 0x54e8fb
movq %rax, 0x8(%rsp)
jmp 0x161098
movq 0xf0(%rsp), %rax
movb 0xbe(%rax), %dl
leaq 0x43c5a3(%rip), %rax    # 0x59d628
leaq 0x3ed879(%rip), %rcx    # 0x54e905
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x3ed833(%rip), %rdi    # 0x54e8dc
movb $0x0, %al
callq 0xe7740
jmp 0x1610b2
jmp 0x1610b4
movq 0xb0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb0(%rsp)
jmp 0x160cdd
movq 0x108(%rsp), %rax
movq 0x40(%rax), %rdi
movl $0x2, %esi
callq 0x1635f0
movl %eax, %ecx
movq 0x108(%rsp), %rax
movl %ecx, 0x68(%rax)
movl 0x4c(%rsp), %eax
movl %eax, 0x114(%rsp)
movl 0x114(%rsp), %eax
addq $0x118, %rsp            # imm = 0x118
retq
nopw (%rax,%rax)