// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/gff3_parser.c
// Function: parse_attributes
static int parse_attributes(char *attributes, GtGenomeNode *feature_node,
                            bool *is_child, GtGFF3Parser *parser,
                            const char *seqid, GtQueue *genome_nodes,
                            const char *filename, unsigned int line_number,
                            GtError *err)
{
  GtSplitter *attribute_splitter, *tmp_splitter, *parent_splitter;
  char *id_value = NULL, *parent_value = NULL;
  GtUword i;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(attributes);

  attribute_splitter = gt_splitter_new();
  tmp_splitter = gt_splitter_new();
  parent_splitter = gt_splitter_new();
  gt_splitter_split(attribute_splitter, attributes, strlen(attributes), ';');

  for (i = 0; !had_err && i < gt_splitter_size(attribute_splitter); i++) {
    const char *old_value;
    bool attr_valid = true;
    char *attr_tag = NULL,
         *attr_value = NULL,
         *token = gt_splitter_get_token(attribute_splitter, i);
    if (strncmp(token, ".", 1) == 0) {
      if (gt_splitter_size(attribute_splitter) > 1) {
        gt_error_set(err, "more than one attribute token defined on line %u in "
                     "file \"%s\", although the first one is '.'", line_number,
                     filename);
        had_err = -1;
      }
      else
        break; /* no attributes to parse */
    }
    else if (is_blank_attribute(token))
      continue;
    else {
      gt_splitter_reset(tmp_splitter);
      gt_splitter_split(tmp_splitter, token, strlen(token), '=');
      if (gt_splitter_size(tmp_splitter) != 2) {
        if (parser->tidy && gt_splitter_size(tmp_splitter) == 1) {
          gt_warning("token \"%s\" on line %u in file \"%s\" does not "
                     "contain exactly one '='", token, line_number, filename);
          continue;
        }
        else {
          gt_error_set(err, "token \"%s\" on line %u in file \"%s\" does not "
                       "contain exactly one '='", token, line_number, filename);
          had_err = -1;
          break;
        }
      }
      else {
        attr_tag = gt_splitter_get_token(tmp_splitter, 0);
        /* Skip leading blanks of attribute tag.
           Iit is not mentioned in the GFF3 spec that attribute tags cannot
           start with blanks, but if a Parent or ID attribute is prepended by a
           blank (e.g. '; Parent=' instead of ';Parent=') the parent-child
           relations do not get reconstructed correctly, because then '; Parent'
           would be treated as an attribute without special meaning.
           Therefore we decided to skip leading blanks and do _not_ consider
           them as part of the attribute but rather as an artefact of the GFF3
           construction. */
        while (attr_tag[0] == ' ')
          attr_tag++;
        attr_value = gt_splitter_get_token(tmp_splitter, 1);
      }
    }
    if (!had_err && !strlen(attr_tag)) {
      attr_valid = false;
      if (parser->tidy) {
        gt_warning("attribute \"=%s\" on line %u in file \"%s\" has no tag; "
                   "skip it", attr_value, line_number, filename);
      }
      else {
        gt_error_set(err, "attribute \"=%s\" on line %u in file \"%s\" has no "
                     "tag", attr_value, line_number, filename);
        had_err = -1;
      }
    }
    if (!had_err && !strlen(attr_value)) {
      attr_valid = false;
      if (parser->tidy) {
        gt_warning("attribute \"%s=\" on line %u in file \"%s\" has no value; "
                   "skip it", attr_tag, line_number, filename);
      }
      else {
        gt_error_set(err, "attribute \"%s=\" on line %u in file \"%s\" has no "
                     "value", attr_tag, line_number, filename);
        had_err = -1;
      }
    }
    if (!had_err && attr_valid && isupper(attr_tag[0])) {
      /* check if uppercase attributes are the predefined ones */
      bool invalid;
      if (parser->gvf_mode)
        invalid = invalid_uppercase_gff3_attribute(attr_tag)
                    && invalid_uppercase_gvf_attribute(attr_tag);
      else
        invalid = invalid_uppercase_gff3_attribute(attr_tag);
      if (invalid) {
        if (parser->tidy) {
          gt_warning("illegal uppercase attribute \"%s\" on line %u in file "
                     "\"%s\"; change to lowercase", attr_tag, line_number,
                     filename);
          attr_tag[0] = tolower(attr_tag[0]);
        }
        else {
          gt_error_set(err, "illegal uppercase attribute \"%s\" on line %u in "
                            "file \"%s\" (uppercase attributes are reserved)",
                            attr_tag, line_number, filename);
          had_err = -1;
        }
      }
    }
    /* save all attributes, although the Parent and ID attributes are newly
       created in GFF3 output */
    if (!had_err && attr_valid) {
      if ((old_value = gt_feature_node_get_attribute((GtFeatureNode*)
                                                     feature_node, attr_tag))) {
        /* handle duplicate attribute */
        if (parser->tidy) {
          GtStr *combined_value;
          gt_warning("more than one %s attribute on line %u in file \"%s\"; "
                     "join them", attr_tag, line_number, filename);
          combined_value = gt_str_new_cstr(old_value);
          gt_str_append_char(combined_value, ',');
          gt_str_append_cstr(combined_value, attr_value);
          gt_feature_node_set_attribute((GtFeatureNode*) feature_node,
                                        attr_tag, gt_str_get(combined_value));
          gt_str_delete(combined_value);
        }
        else {
          gt_error_set(err, "more than one %s attribute on line %u in file "
                            "\"%s\"", attr_tag, line_number, filename);
          had_err = -1;
        }
      }
      else {
        gt_feature_node_add_attribute((GtFeatureNode*) feature_node, attr_tag,
                                      attr_value);
      }
    }
    /* some attributes require special care */
    if (!had_err && attr_valid) {
      if (!strcmp(attr_tag, GT_GFF_ID))
        id_value = attr_value; /* process later */
      else if (!strcmp(attr_tag, GT_GFF_PARENT))
        parent_value = attr_value; /* process later */
      else if (!strcmp(attr_tag, GT_GFF_IS_CIRCULAR)) {
        SimpleSequenceRegion *ssr;
        if (strcmp(attr_value, "true")) {
          gt_error_set(err, "value \"%s\" of %s attribute on line %u in file "
                       "\"%s\" does not equal \"true\"", attr_value,
                       GT_GFF_IS_CIRCULAR, line_number, filename);
          had_err = -1;
        }
        ssr = gt_hashmap_get(parser->seqid_to_ssr_mapping, seqid);
        gt_assert(ssr); /* XXX */
        gt_assert(!ssr->is_circular); /* XXX */
        ssr->is_circular = true;
      }
      else if (!strcmp(attr_tag, GT_GFF_TARGET)) {
        /* the value of ``Target'' attributes have a special syntax which is
           checked here */
        had_err = gt_gff3_parser_parse_target_attributes(attr_value, NULL, NULL,
                                                         NULL, NULL, filename,
                                                         line_number, err);
        if (had_err && parser->tidy) {
          GtStrArray *target_ids;
          GtArray *target_ranges, *target_strands;
          /* try to tidy up the ``Target'' attributes */
          gt_error_unset(err);
          target_ids = gt_str_array_new();
          target_ranges = gt_array_new(sizeof (GtRange));
          target_strands = gt_array_new(sizeof (GtStrand));
          had_err = gt_gff3_parser_parse_all_target_attributes(attr_value, true,
                                                               target_ids,
                                                               target_ranges,
                                                               target_strands,
                                                               filename,
                                                               line_number,
                                                               err);
          if (!had_err) {
            GtStr *new_target = gt_str_new();
            gt_gff3_parser_build_target_str(new_target, target_ids,
                                            target_ranges, target_strands);
            gt_feature_node_set_attribute((GtFeatureNode*) feature_node,
                                          GT_GFF_TARGET,
                                          gt_str_get(new_target));
            gt_str_delete(new_target);
          }
          gt_array_delete(target_strands);
          gt_array_delete(target_ranges);
          gt_str_array_delete(target_ids);
        }
      }
      else if (!strcmp(attr_tag, GT_GFF_DBXREF)
                 || !strcmp(attr_tag, GT_GFF_ONTOLOGY_TERM)) {
        if (parser->xrf_checker) {
          if (!gt_xrf_checker_is_valid(parser->xrf_checker, attr_value, err)) {
            had_err = -1;
          }
        }
      }
      else if (parser->type_checker && !strcmp(attr_tag, GT_GFF_GAP)) {
        GtGapStr *gs = NULL;
        GtRange rng = gt_genome_node_get_range(feature_node);
        if (gt_type_checker_is_a(parser->type_checker,
                                 gt_symbol("protein_match"),
                                 gt_feature_node_get_type((GtFeatureNode*)
                                                          feature_node))) {
          gs = gt_gap_str_new_protein(attr_value, err);
        } else {
          gs = gt_gap_str_new_nucleotide(attr_value, err);
        }
        if (!gs) {
          gt_assert(gt_error_is_set(err));
          had_err = -1;
        }
        if (!had_err) {
          if (gt_range_length(&rng) != gt_gap_str_length_reference(gs)) {
            gt_error_set(err, "length of aligned reference in %s attribute on "
                              "line %u in file \"%s\" (" GT_WU ") does not "
                              "match the length of its %s feature (" GT_WU ")",
                         GT_GFF_GAP, line_number, filename,
                         gt_gap_str_length_reference(gs),
                         gt_feature_node_get_type((GtFeatureNode*)
                                                  feature_node),
                         gt_range_length(&rng));
            had_err = -1;
          }
        }
        gt_gap_str_delete(gs);
      }
    }
  }

  /* process ID attribute */
  if (!had_err && id_value) {
    had_err = process_id_attr(id_value, (GtFeatureNode*) feature_node, is_child,
                              parser, genome_nodes, filename, line_number, err);
  }

  /* we check multi-feature contrains before we process the Parent attribute,
     because that prevents problems with multi-features with different parents
     and allows to process multi-features with orphaned parents at the same
     time. */
  if (!had_err && gt_feature_node_is_multi((GtFeatureNode*) feature_node)) {
    had_err =
      check_multi_feature_constrains(feature_node, (GtGenomeNode*)
                    gt_feature_node_get_multi_representative((GtFeatureNode*)
                                                             feature_node),
                    gt_feature_node_get_attribute((GtFeatureNode*) feature_node,
                                                  GT_GFF_ID),
                                     parser, filename, line_number, err);
  }

  /* finally, process Parent attribute */
  if (!had_err && parent_value) {
    had_err = process_parent_attr(parent_value, feature_node, id_value,
                                  is_child, parser, genome_nodes, filename,
                                  line_number, err);
  }

  gt_splitter_delete(parent_splitter);
  gt_splitter_delete(tmp_splitter);
  gt_splitter_delete(attribute_splitter);

  return had_err;
}

// Assembly:
subq $0x198, %rsp            # imm = 0x198
movq 0x1b0(%rsp), %rax
movl 0x1a8(%rsp), %eax
movq 0x1a0(%rsp), %rax
movq %rdi, 0x190(%rsp)
movq %rsi, 0x188(%rsp)
movq %rdx, 0x180(%rsp)
movq %rcx, 0x178(%rsp)
movq %r8, 0x170(%rsp)
movq %r9, 0x168(%rsp)
movq $0x0, 0x148(%rsp)
movq $0x0, 0x140(%rsp)
movl $0x0, 0x134(%rsp)
cmpq $0x0, 0x1b0(%rsp)
je 0x2ce67
movq 0x1b0(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x2ce2f
jmp 0x2ce67
movq 0x1871a2(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x131226(%rip), %rsi    # 0x15e066
leaq 0x131801(%rip), %rdx    # 0x15e648
leaq 0x137742(%rip), %rcx    # 0x164590
leaq 0x136756(%rip), %r8     # 0x1635ab
movl $0x4c7, %r9d            # imm = 0x4C7
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x2ce69
jmp 0x2ce6b
cmpq $0x0, 0x190(%rsp)
jne 0x2ceae
movq 0x18715b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1311df(%rip), %rsi    # 0x15e066
leaq 0x135371(%rip), %rdx    # 0x1621ff
leaq 0x1376fb(%rip), %rcx    # 0x164590
leaq 0x13670f(%rip), %r8     # 0x1635ab
movl $0x4c8, %r9d            # imm = 0x4C8
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x2ceb0
callq 0x16a10
movq %rax, 0x160(%rsp)
callq 0x16a10
movq %rax, 0x158(%rsp)
callq 0x16a10
movq %rax, 0x150(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x190(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x190(%rsp), %rdi
callq 0xb240
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq %rax, %rdx
movl $0x3b, %ecx
callq 0x16a30
movq $0x0, 0x138(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x134(%rsp)
movb %al, 0xa7(%rsp)
jne 0x2cf75
movq 0x138(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x160(%rsp), %rdi
callq 0x17010
movq %rax, %rcx
movq 0x98(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0xa7(%rsp)
movb 0xa7(%rsp), %al
testb $0x1, %al
jne 0x2cf85
jmp 0x2db8d
movb $0x1, 0x127(%rsp)
movq $0x0, 0x118(%rsp)
movq $0x0, 0x110(%rsp)
movq 0x160(%rsp), %rdi
movq 0x138(%rsp), %rsi
callq 0x16f20
movq %rax, 0x108(%rsp)
movq 0x108(%rsp), %rdi
leaq 0x13a615(%rip), %rsi    # 0x1675e6
movl $0x1, %edx
callq 0xb280
cmpl $0x0, %eax
jne 0x2d02f
movq 0x160(%rsp), %rdi
callq 0x17010
cmpq $0x1, %rax
jbe 0x2d025
movq 0x1b0(%rsp), %rdi
movl 0x1a8(%rsp), %edx
movq 0x1a0(%rsp), %rcx
leaq 0x137590(%rip), %rsi    # 0x1645a1
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d02a
jmp 0x2db8d
jmp 0x2d19a
movq 0x108(%rsp), %rdi
callq 0x2dd40
testb $0x1, %al
jne 0x2d042
jmp 0x2d047
jmp 0x2db74
movq 0x158(%rsp), %rdi
callq 0x16fa0
movq 0x158(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x108(%rsp), %rdi
callq 0xb240
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq %rax, %rdx
movl $0x3d, %ecx
callq 0x16a30
movq 0x158(%rsp), %rdi
callq 0x17010
cmpq $0x2, %rax
je 0x2d13d
movq 0x178(%rsp), %rax
testb $0x1, 0x1c(%rax)
je 0x2d100
movq 0x158(%rsp), %rdi
callq 0x17010
cmpq $0x1, %rax
jne 0x2d100
movq 0x108(%rsp), %rsi
movl 0x1a8(%rsp), %edx
movq 0x1a0(%rsp), %rcx
leaq 0x13750a(%rip), %rdi    # 0x1645fe
movb $0x0, %al
callq 0x1c550
jmp 0x2db74
movq 0x1b0(%rsp), %rdi
movq 0x108(%rsp), %rdx
movl 0x1a8(%rsp), %ecx
movq 0x1a0(%rsp), %r8
leaq 0x1374d8(%rip), %rsi    # 0x1645fe
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
jmp 0x2db8d
movq 0x158(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x16f20
movq %rax, 0x118(%rsp)
movq 0x118(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x2d17c
movq 0x118(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x118(%rsp)
jmp 0x2d156
movq 0x158(%rsp), %rdi
movl $0x1, %esi
callq 0x16f20
movq %rax, 0x110(%rsp)
jmp 0x2d198
jmp 0x2d19a
cmpl $0x0, 0x134(%rsp)
jne 0x2d232
movq 0x118(%rsp), %rdi
callq 0xb240
cmpq $0x0, %rax
jne 0x2d232
movb $0x0, 0x127(%rsp)
movq 0x178(%rsp), %rax
testb $0x1, 0x1c(%rax)
je 0x2d1f8
movq 0x110(%rsp), %rsi
movl 0x1a8(%rsp), %edx
movq 0x1a0(%rsp), %rcx
leaq 0x137453(%rip), %rdi    # 0x164642
movb $0x0, %al
callq 0x1c550
jmp 0x2d230
movq 0x1b0(%rsp), %rdi
movq 0x110(%rsp), %rdx
movl 0x1a8(%rsp), %ecx
movq 0x1a0(%rsp), %r8
leaq 0x137460(%rip), %rsi    # 0x16467e
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d232
cmpl $0x0, 0x134(%rsp)
jne 0x2d2ca
movq 0x110(%rsp), %rdi
callq 0xb240
cmpq $0x0, %rax
jne 0x2d2ca
movb $0x0, 0x127(%rsp)
movq 0x178(%rsp), %rax
testb $0x1, 0x1c(%rax)
je 0x2d290
movq 0x118(%rsp), %rsi
movl 0x1a8(%rsp), %edx
movq 0x1a0(%rsp), %rcx
leaq 0x13742a(%rip), %rdi    # 0x1646b1
movb $0x0, %al
callq 0x1c550
jmp 0x2d2c8
movq 0x1b0(%rsp), %rdi
movq 0x118(%rsp), %rdx
movl 0x1a8(%rsp), %ecx
movq 0x1a0(%rsp), %r8
leaq 0x137439(%rip), %rsi    # 0x1646ef
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d2ca
cmpl $0x0, 0x134(%rsp)
jne 0x2d412
testb $0x1, 0x127(%rsp)
je 0x2d412
callq 0xb6b0
movq (%rax), %rax
movq 0x118(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x2d412
movq 0x178(%rsp), %rax
testb $0x1, 0x1f(%rax)
je 0x2d361
movq 0x118(%rsp), %rdi
callq 0x2dd90
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x87(%rsp)
jne 0x2d33b
jmp 0x2d34f
movq 0x118(%rsp), %rdi
callq 0x2df50
movb %al, 0x87(%rsp)
movb 0x87(%rsp), %al
andb $0x1, %al
movb %al, 0x107(%rsp)
jmp 0x2d377
movq 0x118(%rsp), %rdi
callq 0x2dd90
andb $0x1, %al
movb %al, 0x107(%rsp)
testb $0x1, 0x107(%rsp)
je 0x2d410
movq 0x178(%rsp), %rax
testb $0x1, 0x1c(%rax)
je 0x2d3d6
movq 0x118(%rsp), %rsi
movl 0x1a8(%rsp), %edx
movq 0x1a0(%rsp), %rcx
leaq 0x137373(%rip), %rdi    # 0x164724
movb $0x0, %al
callq 0x1c550
movq 0x118(%rsp), %rax
movsbl (%rax), %edi
callq 0xb8c0
movb %al, %cl
movq 0x118(%rsp), %rax
movb %cl, (%rax)
jmp 0x2d40e
movq 0x1b0(%rsp), %rdi
movq 0x118(%rsp), %rdx
movl 0x1a8(%rsp), %ecx
movq 0x1a0(%rsp), %r8
leaq 0x137376(%rip), %rsi    # 0x164772
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d410
jmp 0x2d412
cmpl $0x0, 0x134(%rsp)
jne 0x2d569
testb $0x1, 0x127(%rsp)
je 0x2d569
movq 0x188(%rsp), %rdi
movq 0x118(%rsp), %rsi
callq 0x1fde0
movq %rax, 0x128(%rsp)
cmpq $0x0, %rax
je 0x2d54a
movq 0x178(%rsp), %rax
testb $0x1, 0x1c(%rax)
je 0x2d510
movq 0x118(%rsp), %rsi
movl 0x1a8(%rsp), %edx
movq 0x1a0(%rsp), %rcx
leaq 0x13734a(%rip), %rdi    # 0x1647cf
movb $0x0, %al
callq 0x1c550
movq 0x128(%rsp), %rdi
callq 0x18f70
movq %rax, 0xf8(%rsp)
movq 0xf8(%rsp), %rdi
movl $0x2c, %esi
callq 0x194d0
movq 0xf8(%rsp), %rdi
movq 0x110(%rsp), %rsi
callq 0x18fb0
movq 0x188(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xf8(%rsp), %rdi
callq 0x19940
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq %rax, %rdx
callq 0x21400
movq 0xf8(%rsp), %rdi
callq 0x1afc0
jmp 0x2d548
movq 0x1b0(%rsp), %rdi
movq 0x118(%rsp), %rdx
movl 0x1a8(%rsp), %ecx
movq 0x1a0(%rsp), %r8
leaq 0x1372d7(%rip), %rsi    # 0x16480d
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d567
movq 0x188(%rsp), %rdi
movq 0x118(%rsp), %rsi
movq 0x110(%rsp), %rdx
callq 0x22b50
jmp 0x2d569
cmpl $0x0, 0x134(%rsp)
jne 0x2db72
testb $0x1, 0x127(%rsp)
je 0x2db72
movq 0x118(%rsp), %rdi
leaq 0x1372ac(%rip), %rsi    # 0x164840
callq 0xb850
cmpl $0x0, %eax
jne 0x2d5b3
movq 0x110(%rsp), %rax
movq %rax, 0x148(%rsp)
jmp 0x2db70
movq 0x118(%rsp), %rdi
leaq 0x137281(%rip), %rsi    # 0x164843
callq 0xb850
cmpl $0x0, %eax
jne 0x2d5e1
movq 0x110(%rsp), %rax
movq %rax, 0x140(%rsp)
jmp 0x2db6e
movq 0x118(%rsp), %rdi
leaq 0x13725a(%rip), %rsi    # 0x16484a
callq 0xb850
cmpl $0x0, %eax
jne 0x2d718
movq 0x110(%rsp), %rdi
leaq 0x16103d(%rip), %rsi    # 0x18e64a
callq 0xb850
cmpl $0x0, %eax
je 0x2d657
movq 0x1b0(%rsp), %rdi
movq 0x110(%rsp), %rdx
movl 0x1a8(%rsp), %r8d
movq 0x1a0(%rsp), %r9
leaq 0x137218(%rip), %rsi    # 0x164856
leaq 0x137205(%rip), %rcx    # 0x16484a
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
movq 0x178(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x170(%rsp), %rsi
callq 0x86470
movq %rax, 0xf0(%rsp)
cmpq $0x0, 0xf0(%rsp)
jne 0x2d6bb
movq 0x18694e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1309d2(%rip), %rsi    # 0x15e066
leaq 0x136769(%rip), %rdx    # 0x163e04
leaq 0x136eee(%rip), %rcx    # 0x164590
leaq 0x135f02(%rip), %r8     # 0x1635ab
movl $0x55b, %r9d            # imm = 0x55B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x2d6bd
jmp 0x2d6bf
movq 0xf0(%rsp), %rax
testb $0x1, 0x1d(%rax)
je 0x2d705
movq 0x186904(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x130988(%rip), %rsi    # 0x15e066
leaq 0x1371ba(%rip), %rdx    # 0x16489f
leaq 0x136ea4(%rip), %rcx    # 0x164590
leaq 0x135eb8(%rip), %r8     # 0x1635ab
movl $0x55c, %r9d            # imm = 0x55C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x2d707
movq 0xf0(%rsp), %rax
movb $0x1, 0x1d(%rax)
jmp 0x2db6c
movq 0x118(%rsp), %rdi
leaq 0x13718a(%rip), %rsi    # 0x1648b1
callq 0xb850
cmpl $0x0, %eax
jne 0x2d8cb
movq 0x110(%rsp), %rdi
movq 0x1a0(%rsp), %r9
movl 0x1a8(%rsp), %r10d
movq 0x1b0(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %r8d
movq %r8, %rsi
movq %r8, %rdx
movq %r8, %rcx
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x29080
movl %eax, 0x134(%rsp)
cmpl $0x0, 0x134(%rsp)
je 0x2d8c6
movq 0x178(%rsp), %rax
testb $0x1, 0x1c(%rax)
je 0x2d8c6
movq 0x1b0(%rsp), %rdi
callq 0xc2d0
callq 0x1b020
movq %rax, 0xe8(%rsp)
movl $0x10, %edi
callq 0x75ab0
movq %rax, 0xe0(%rsp)
movl $0x4, %edi
callq 0x75ab0
movq %rax, 0xd8(%rsp)
movq 0x110(%rsp), %rdi
movq 0xe8(%rsp), %rdx
movq 0xe0(%rsp), %rcx
movq 0xd8(%rsp), %r8
movq 0x1a0(%rsp), %r9
movl 0x1a8(%rsp), %r10d
movq 0x1b0(%rsp), %rax
movl $0x1, %esi
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x29470
movl %eax, 0x134(%rsp)
cmpl $0x0, 0x134(%rsp)
jne 0x2d89f
callq 0x18f00
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0xe0(%rsp), %rdx
movq 0xd8(%rsp), %rcx
callq 0x29520
movq 0x188(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x19940
movq 0x68(%rsp), %rdi
movq %rax, %rdx
leaq 0x137024(%rip), %rsi    # 0x1648b1
callq 0x21400
movq 0xd0(%rsp), %rdi
callq 0x1afc0
movq 0xd8(%rsp), %rdi
callq 0x770a0
movq 0xe0(%rsp), %rdi
callq 0x770a0
movq 0xe8(%rsp), %rdi
callq 0x1b780
jmp 0x2db6a
movq 0x118(%rsp), %rdi
leaq 0x136fde(%rip), %rsi    # 0x1648b8
callq 0xb850
cmpl $0x0, %eax
je 0x2d8fd
movq 0x118(%rsp), %rdi
leaq 0x136fcc(%rip), %rsi    # 0x1648bf
callq 0xb850
cmpl $0x0, %eax
jne 0x2d943
movq 0x178(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2d93e
movq 0x178(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x110(%rsp), %rsi
movq 0x1b0(%rsp), %rdx
callq 0x39a40
testb $0x1, %al
jne 0x2d93c
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d93e
jmp 0x2db68
movq 0x178(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2db66
movq 0x118(%rsp), %rdi
leaq 0x136f68(%rip), %rsi    # 0x1648cd
callq 0xb850
cmpl $0x0, %eax
jne 0x2db66
movq $0x0, 0xc8(%rsp)
movq 0x188(%rsp), %rdi
callq 0x259f0
movq %rax, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0x178(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x58(%rsp)
leaq 0x136f1d(%rip), %rdi    # 0x1648d1
callq 0x1baa0
movq %rax, 0x60(%rsp)
movq 0x188(%rsp), %rdi
callq 0x211d0
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq %rax, %rdx
callq 0x395c0
testb $0x1, %al
jne 0x2d9e3
jmp 0x2da02
movq 0x110(%rsp), %rdi
movq 0x1b0(%rsp), %rsi
callq 0xa6990
movq %rax, 0xc8(%rsp)
jmp 0x2da1f
movq 0x110(%rsp), %rdi
movq 0x1b0(%rsp), %rsi
callq 0xa6890
movq %rax, 0xc8(%rsp)
cmpq $0x0, 0xc8(%rsp)
jne 0x2da82
jmp 0x2da2c
movq 0x1b0(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x2da75
movq 0x186594(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x130618(%rip), %rsi    # 0x15e066
leaq 0x15cfe3(%rip), %rdx    # 0x18aa38
leaq 0x136b34(%rip), %rcx    # 0x164590
leaq 0x135b48(%rip), %r8     # 0x1635ab
movl $0x596, %r9d            # imm = 0x596
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x2da77
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x134(%rsp)
jne 0x2db59
leaq 0xb8(%rsp), %rdi
callq 0x93bd0
movq %rax, 0x50(%rsp)
movq 0xc8(%rsp), %rdi
callq 0xa6a10
movq %rax, %rcx
movq 0x50(%rsp), %rax
cmpq %rcx, %rax
je 0x2db57
movq 0x1b0(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x1a8(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0x1a0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xc8(%rsp), %rdi
callq 0xa6a10
movq %rax, 0x40(%rsp)
movq 0x188(%rsp), %rdi
callq 0x211d0
movq %rax, 0x48(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x93bd0
movq 0x28(%rsp), %rdi
movl 0x34(%rsp), %ecx
movq 0x38(%rsp), %r8
movq 0x40(%rsp), %r9
movq 0x48(%rsp), %r10
leaq 0x136daa(%rip), %rsi    # 0x1648df
leaq 0x136d91(%rip), %rdx    # 0x1648cd
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x134(%rsp) # imm = 0xFFFFFFFF
jmp 0x2db59
movq 0xc8(%rsp), %rdi
callq 0xa6ab0
jmp 0x2db68
jmp 0x2db6a
jmp 0x2db6c
jmp 0x2db6e
jmp 0x2db70
jmp 0x2db72
jmp 0x2db74
movq 0x138(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x138(%rsp)
jmp 0x2cf2d
cmpl $0x0, 0x134(%rsp)
jne 0x2dbf7
cmpq $0x0, 0x148(%rsp)
je 0x2dbf7
movq 0x148(%rsp), %rdi
movq 0x188(%rsp), %rsi
movq 0x180(%rsp), %rdx
movq 0x178(%rsp), %rcx
movq 0x168(%rsp), %r8
movq 0x1a0(%rsp), %r9
movl 0x1a8(%rsp), %r10d
movq 0x1b0(%rsp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2e1c0
movl %eax, 0x134(%rsp)
cmpl $0x0, 0x134(%rsp)
jne 0x2dc88
movq 0x188(%rsp), %rdi
callq 0x217b0
testb $0x1, %al
jne 0x2dc18
jmp 0x2dc88
movq 0x188(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x188(%rsp), %rdi
callq 0x21c40
movq %rax, 0x20(%rsp)
movq 0x188(%rsp), %rdi
leaq 0x136bfa(%rip), %rsi    # 0x164840
callq 0x1fde0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
movq 0x178(%rsp), %rcx
movq 0x1a0(%rsp), %r8
movl 0x1a8(%rsp), %r9d
movq 0x1b0(%rsp), %rax
movq %rax, (%rsp)
callq 0x2e740
movl %eax, 0x134(%rsp)
cmpl $0x0, 0x134(%rsp)
jne 0x2dcff
cmpq $0x0, 0x140(%rsp)
je 0x2dcff
movq 0x140(%rsp), %rdi
movq 0x188(%rsp), %rsi
movq 0x148(%rsp), %rdx
movq 0x180(%rsp), %rcx
movq 0x178(%rsp), %r8
movq 0x168(%rsp), %r9
movq 0x1a0(%rsp), %r11
movl 0x1a8(%rsp), %r10d
movq 0x1b0(%rsp), %rax
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x2ed80
movl %eax, 0x134(%rsp)
movq 0x150(%rsp), %rdi
callq 0x17060
movq 0x158(%rsp), %rdi
callq 0x17060
movq 0x160(%rsp), %rdi
callq 0x17060
movl 0x134(%rsp), %eax
addq $0x198, %rsp            # imm = 0x198
retq
nopw %cs:(%rax,%rax)