// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: storeAtts
static enum XML_Error
storeAtts(XML_Parser parser, const ENCODING *enc,
          const char *attStr, TAG_NAME *tagNamePtr,
          BINDING **bindingsPtr)
{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  ELEMENT_TYPE *elementType;
  int nDefaultAtts;
  const XML_Char **appAtts;   /* the attribute list for the application */
  int attIndex = 0;
  int prefixLen;
  int i;
  int n;
  XML_Char *uri;
  int nPrefixes = 0;
  BINDING *binding;
  const XML_Char *localPart;

  /* lookup the element type name */
  elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, tagNamePtr->str,0);
  if (!elementType) {
    const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
    if (!name)
      return XML_ERROR_NO_MEMORY;
    elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, name,
                                         sizeof(ELEMENT_TYPE));
    if (!elementType)
      return XML_ERROR_NO_MEMORY;
    if (ns && !setElementTypePrefix(parser, elementType))
      return XML_ERROR_NO_MEMORY;
  }
  nDefaultAtts = elementType->nDefaultAtts;

  /* get the attributes from the tokenizer */
  n = XmlGetAttributes(enc, attStr, attsSize, atts);
  if (n + nDefaultAtts > attsSize) {
    int oldAttsSize = attsSize;
    ATTRIBUTE *temp;
    attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
    temp = (ATTRIBUTE *)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
    if (temp == NULL)
      return XML_ERROR_NO_MEMORY;
    atts = temp;
    if (n > oldAttsSize)
      XmlGetAttributes(enc, attStr, n, atts);
  }

  appAtts = (const XML_Char **)atts;
  for (i = 0; i < n; i++) {
    /* add the name and value to the attribute list */
    ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,
                                         atts[i].name
                                         + XmlNameLength(enc, atts[i].name));
    if (!attId)
      return XML_ERROR_NO_MEMORY;
    /* Detect duplicate attributes by their QNames. This does not work when
       namespace processing is turned on and different prefixes for the same
       namespace are used. For this case we have a check further down.
    */
    if ((attId->name)[-1]) {
      if (enc == encoding)
        eventPtr = atts[i].name;
      return XML_ERROR_DUPLICATE_ATTRIBUTE;
    }
    (attId->name)[-1] = 1;
    appAtts[attIndex++] = attId->name;
    if (!atts[i].normalized) {
      enum XML_Error result;
      XML_Bool isCdata = XML_TRUE;

      /* figure out whether declared as other than CDATA */
      if (attId->maybeTokenized) {
        int j;
        for (j = 0; j < nDefaultAtts; j++) {
          if (attId == elementType->defaultAtts[j].id) {
            isCdata = elementType->defaultAtts[j].isCdata;
            break;
          }
        }
      }

      /* normalize the attribute value */
      result = storeAttributeValue(parser, enc, isCdata,
                                   atts[i].valuePtr, atts[i].valueEnd,
                                   &tempPool);
      if (result)
        return result;
      appAtts[attIndex] = poolStart(&tempPool);
      poolFinish(&tempPool);
    }
    else {
      /* the value did not need normalizing */
      appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr,
                                          atts[i].valueEnd);
      if (appAtts[attIndex] == 0)
        return XML_ERROR_NO_MEMORY;
      poolFinish(&tempPool);
    }
    /* handle prefixed attribute names */
    if (attId->prefix) {
      if (attId->xmlns) {
        /* deal with namespace declarations here */
        enum XML_Error result = addBinding(parser, attId->prefix, attId,
                                           appAtts[attIndex], bindingsPtr);
        if (result)
          return result;
        --attIndex;
      }
      else {
        /* deal with other prefixed names later */
        attIndex++;
        nPrefixes++;
        (attId->name)[-1] = 2;
      }
    }
    else
      attIndex++;
  }

  /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */
  nSpecifiedAtts = attIndex;
  if (elementType->idAtt && (elementType->idAtt->name)[-1]) {
    for (i = 0; i < attIndex; i += 2)
      if (appAtts[i] == elementType->idAtt->name) {
        idAttIndex = i;
        break;
      }
  }
  else
    idAttIndex = -1;

  /* do attribute defaulting */
  for (i = 0; i < nDefaultAtts; i++) {
    const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;
    if (!(da->id->name)[-1] && da->value) {
      if (da->id->prefix) {
        if (da->id->xmlns) {
          enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
                                             da->value, bindingsPtr);
          if (result)
            return result;
        }
        else {
          (da->id->name)[-1] = 2;
          nPrefixes++;
          appAtts[attIndex++] = da->id->name;
          appAtts[attIndex++] = da->value;
        }
      }
      else {
        (da->id->name)[-1] = 1;
        appAtts[attIndex++] = da->id->name;
        appAtts[attIndex++] = da->value;
      }
    }
  }
  appAtts[attIndex] = 0;

  /* expand prefixed attribute names, check for duplicates,
     and clear flags that say whether attributes were specified */
  i = 0;
  if (nPrefixes) {
    int j;  /* hash table index */
    unsigned long version = nsAttsVersion;
    int nsAttsSize = (int)1 << nsAttsPower;
    /* size of hash table must be at least 2 * (# of prefixed attributes) */
    if ((nPrefixes << 1) >> nsAttsPower) {  /* true for nsAttsPower = 0 */
      NS_ATT *temp;
      /* hash table size must also be a power of 2 and >= 8 */
      while (nPrefixes >> nsAttsPower++);
      if (nsAttsPower < 3)
        nsAttsPower = 3;
      nsAttsSize = (int)1 << nsAttsPower;
      temp = (NS_ATT *)REALLOC(nsAtts, nsAttsSize * sizeof(NS_ATT));
      if (!temp)
        return XML_ERROR_NO_MEMORY;
      nsAtts = temp;
      version = 0;  /* force re-initialization of nsAtts hash table */
    }
    /* using a version flag saves us from initializing nsAtts every time */
    if (!version) {  /* initialize version flags when version wraps around */
      version = INIT_ATTS_VERSION;
      for (j = nsAttsSize; j != 0; )
        nsAtts[--j].version = version;
    }
    nsAttsVersion = --version;

    /* expand prefixed names and check for duplicates */
    for (; i < attIndex; i += 2) {
      const XML_Char *s = appAtts[i];
      if (s[-1] == 2) {  /* prefixed */
        ATTRIBUTE_ID *id;
        const BINDING *b;
        unsigned long uriHash = 0;
        ((XML_Char *)s)[-1] = 0;  /* clear flag */
        id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, s, 0);
        b = id->prefix->binding;
        if (!b)
          return XML_ERROR_UNBOUND_PREFIX;

        /* as we expand the name we also calculate its hash value */
        for (j = 0; j < b->uriLen; j++) {
          const XML_Char c = b->uri[j];
          if (!poolAppendChar(&tempPool, c))
            return XML_ERROR_NO_MEMORY;
          uriHash = CHAR_HASH(uriHash, c);
        }
        while (*s++ != XML_T(ASCII_COLON))
          ;
        do {  /* copies null terminator */
          const XML_Char c = *s;
          if (!poolAppendChar(&tempPool, *s))
            return XML_ERROR_NO_MEMORY;
          uriHash = CHAR_HASH(uriHash, c);
        } while (*s++);

        { /* Check hash table for duplicate of expanded name (uriName).
             Derived from code in lookup(HASH_TABLE *table, ...).
          */
          unsigned char step = 0;
          unsigned long mask = nsAttsSize - 1;
          j = uriHash & mask;  /* index into hash table */
          while (nsAtts[j].version == version) {
            /* for speed we compare stored hash values first */
            if (uriHash == nsAtts[j].hash) {
              const XML_Char *s1 = poolStart(&tempPool);
              const XML_Char *s2 = nsAtts[j].uriName;
              /* s1 is null terminated, but not s2 */
              for (; *s1 == *s2 && *s1 != 0; s1++, s2++);
              if (*s1 == 0)
                return XML_ERROR_DUPLICATE_ATTRIBUTE;
            }
            if (!step)
              step = PROBE_STEP(uriHash, mask, nsAttsPower);
            j < step ? (j += nsAttsSize - step) : (j -= step);
          }
        }

        if (ns_triplets) {  /* append namespace separator and prefix */
          tempPool.ptr[-1] = namespaceSeparator;
          s = b->prefix->name;
          do {
            if (!poolAppendChar(&tempPool, *s))
              return XML_ERROR_NO_MEMORY;
          } while (*s++);
        }

        /* store expanded name in attribute list */
        s = poolStart(&tempPool);
        poolFinish(&tempPool);
        appAtts[i] = s;

        /* fill empty slot with new version, uriName and hash value */
        nsAtts[j].version = version;
        nsAtts[j].hash = uriHash;
        nsAtts[j].uriName = s;

        if (!--nPrefixes) {
          i += 2;
          break;
        }
      }
      else  /* not prefixed */
        ((XML_Char *)s)[-1] = 0;  /* clear flag */
    }
  }
  /* clear flags for the remaining attributes */
  for (; i < attIndex; i += 2)
    ((XML_Char *)(appAtts[i]))[-1] = 0;
  for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
    binding->attId->name[-1] = 0;

  if (!ns)
    return XML_ERROR_NONE;

  /* expand the element type name */
  if (elementType->prefix) {
    binding = elementType->prefix->binding;
    if (!binding)
      return XML_ERROR_UNBOUND_PREFIX;
    localPart = tagNamePtr->str;
    while (*localPart++ != XML_T(ASCII_COLON))
      ;
  }
  else if (dtd->defaultPrefix.binding) {
    binding = dtd->defaultPrefix.binding;
    localPart = tagNamePtr->str;
  }
  else
    return XML_ERROR_NONE;
  prefixLen = 0;
  if (ns_triplets && binding->prefix->name) {
    for (; binding->prefix->name[prefixLen++];)
      ;  /* prefixLen includes null terminator */
  }
  tagNamePtr->localPart = localPart;
  tagNamePtr->uriLen = binding->uriLen;
  tagNamePtr->prefix = binding->prefix->name;
  tagNamePtr->prefixLen = prefixLen;
  for (i = 0; localPart[i++];)
    ;  /* i includes null terminator */
  n = i + binding->uriLen + prefixLen;
  if (n > binding->uriAlloc) {
    TAG *p;
    uri = (XML_Char *)MALLOC((n + EXPAND_SPARE) * sizeof(XML_Char));
    if (!uri)
      return XML_ERROR_NO_MEMORY;
    binding->uriAlloc = n + EXPAND_SPARE;
    memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));
    for (p = tagStack; p; p = p->parent)
      if (p->name.str == binding->uri)
        p->name.str = uri;
    FREE(binding->uri);
    binding->uri = uri;
  }
  /* if namespaceSeparator != '\0' then uri includes it already */
  uri = binding->uri + binding->uriLen;
  memcpy(uri, localPart, i * sizeof(XML_Char));
  /* we always have a namespace separator between localPart and prefix */
  if (prefixLen) {
    uri += i - 1;
    *uri = namespaceSeparator;  /* replace null terminator */
    memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));
  }
  tagNamePtr->str = binding->uri;
  return XML_ERROR_NONE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, 0x68(%rsp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
movq 0x290(%rdi), %rax
movq %rax, 0x60(%rsp)
leaq 0x28(%rax), %rbx
movq %rcx, 0x50(%rsp)
movq (%rcx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x257a9b
movq %rax, %r12
testq %rax, %rax
jne 0x2596b2
movq 0x60(%rsp), %rax
leaq 0xa0(%rax), %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rsi
callq 0x253ed5
testq %rax, %rax
je 0x2596a0
movl $0x28, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x257a9b
testq %rax, %rax
je 0x2596a0
movq %rax, %r12
cmpb $0x0, 0x1c8(%r14)
je 0x25969c
movq %r14, %rdi
movq %r12, %rsi
callq 0x25a8ac
testl %eax, %eax
je 0x25a246
movb $0x1, %al
jmp 0x2596a5
xorl %eax, %eax
xorl %r12d, %r12d
testb %al, %al
movl $0x1, %eax
je 0x25a2ac
movl 0x18(%r12), %ebp
movl 0x2c0(%r14), %edx
movq 0x2d0(%r14), %rcx
movq %r13, %rdi
movq %r15, %rsi
callq *0x48(%r13)
movl %eax, %ebx
movq %rbp, 0x28(%rsp)
leal (%rbx,%rbp), %eax
movl 0x2c0(%r14), %ebp
cmpl %ebp, %eax
jle 0x25972a
movslq %eax, %rsi
shlq $0x5, %rsi
addl $0x10, %eax
movl %eax, 0x2c0(%r14)
movq 0x2d0(%r14), %rdi
addq $0x200, %rsi            # imm = 0x200
callq *0x20(%r14)
testq %rax, %rax
je 0x259bca
movq %rax, 0x2d0(%r14)
cmpl %ebp, %ebx
jle 0x25972a
movq %r13, %rdi
movq %r15, %rsi
movl %ebx, %edx
movq %rax, %rcx
callq *0x48(%r13)
movq %r12, 0x38(%rsp)
movq 0x2d0(%r14), %rax
movq %rax, 0x10(%rsp)
testl %ebx, %ebx
jle 0x2599b0
leaq 0x300(%r14), %rax
movq %rax, 0x30(%rsp)
movl %ebx, %eax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
leaq (,%rax,8), %rax
leaq (%rax,%rax,2), %rax
movq %rax, 0x40(%rsp)
xorl %r12d, %r12d
movl $0x1, 0x8(%rsp)
movq $0x0, (%rsp)
movq $0x0, 0x18(%rsp)
movq %r14, 0x58(%rsp)
movq 0x2d0(%r14), %rax
movq %r12, %rbp
shlq $0x5, %rbp
movq (%rax,%rbp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq *0x38(%r13)
movslq %eax, %rcx
addq %rbx, %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x257507
testq %rax, %rax
je 0x2597f8
movq %rax, %r15
movq (%rax), %rax
cmpb $0x0, -0x1(%rax)
je 0x259807
movl $0x8, 0x8(%rsp)
cmpq %r13, 0x120(%r14)
jne 0x2597f1
movq 0x2d0(%r14), %rax
movq (%rax,%rbp), %rax
movq %rax, 0x210(%r14)
xorl %ecx, %ecx
jmp 0x25999c
xorl %ecx, %ecx
movl $0x1, 0x8(%rsp)
jmp 0x25999c
movb $0x1, -0x1(%rax)
movq (%r15), %rax
movq (%rsp), %rcx
movq %r14, %rdx
leal 0x1(%rcx), %r14d
movslq %ecx, %rcx
movq 0x10(%rsp), %rbx
movq %rax, (%rbx,%rcx,8)
movq 0x2d0(%rdx), %rcx
leaq (%rcx,%rbp), %rax
cmpb $0x0, 0x18(%rcx,%rbp)
je 0x259873
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x2573a3
movslq %r14d, %rcx
movq %rax, (%rbx,%rcx,8)
testq %rax, %rax
movl %r14d, %ebx
je 0x2598a9
movq 0x58(%rsp), %r14
movq 0x318(%r14), %rax
movq %rax, 0x320(%r14)
jmp 0x259926
cmpb $0x0, 0x10(%r15)
movb $0x1, %dl
movl %r14d, %ebx
je 0x2598c9
cmpl $0x0, 0x28(%rsp)
movq 0x58(%rsp), %r14
jle 0x2598ce
movq 0x38(%rsp), %rcx
movq 0x20(%rcx), %rcx
xorl %esi, %esi
cmpq (%rcx,%rsi), %r15
je 0x2598c3
addq $0x18, %rsi
cmpq %rsi, 0x40(%rsp)
jne 0x259896
jmp 0x2598ce
xorl %ecx, %ecx
movl %ebx, %eax
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
movq 0x58(%rsp), %r14
jmp 0x25999c
movb 0x8(%rcx,%rsi), %dl
jmp 0x2598ce
movq 0x58(%rsp), %r14
movq 0x8(%rax), %rcx
movq 0x10(%rax), %r8
movzbl %dl, %edx
movq %r14, %rdi
movq %r13, %rsi
movq 0x30(%rsp), %r9
callq 0x257a37
movl %eax, %edx
testl %eax, %eax
jne 0x259914
movq 0x320(%r14), %rcx
movslq %ebx, %rdx
movq 0x10(%rsp), %rsi
movq %rcx, (%rsi,%rdx,8)
movq 0x318(%r14), %rcx
movq %rcx, 0x320(%r14)
movl 0x8(%rsp), %edx
testl %eax, %eax
je 0x259922
xorl %ecx, %ecx
movl %ebx, %eax
movq %rax, (%rsp)
jmp 0x259969
movl %edx, 0x8(%rsp)
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x25996f
cmpb $0x0, 0x11(%r15)
je 0x25997c
movslq %ebx, %rax
movq 0x10(%rsp), %rcx
movq (%rcx,%rax,8), %rcx
movq %r14, %rdi
movq %r15, %rdx
movq 0x68(%rsp), %r8
callq 0x25a9ca
testl %eax, %eax
sete %cl
movq (%rsp), %rdx
cmovnel %ebx, %edx
movq %rdx, (%rsp)
movl 0x8(%rsp), %edx
cmovnel %eax, %edx
movl %edx, 0x8(%rsp)
jmp 0x25999c
movq (%rsp), %rax
addl $0x2, %eax
movq %rax, (%rsp)
jmp 0x25999a
movq (%rsp), %rax
addl $0x2, %eax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
incl %eax
movq %rax, 0x18(%rsp)
movq (%r15), %rax
movb $0x2, -0x1(%rax)
movb $0x1, %cl
testb %cl, %cl
je 0x259a18
incq %r12
cmpq 0x20(%rsp), %r12
jne 0x25978d
jmp 0x2599c9
movl $0x1, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
movl %eax, 0x2c4(%r14)
movq 0x38(%rsp), %r12
movq 0x10(%r12), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x259a21
movq (%rcx), %rcx
cmpb $0x0, -0x1(%rcx)
movq 0x10(%rsp), %rdx
movl 0x8(%rsp), %ebp
movq 0x28(%rsp), %rsi
je 0x259a2a
cmpl $0x0, (%rsp)
jle 0x259a31
xorl %eax, %eax
cmpq %rcx, (%rdx,%rax,8)
je 0x259a2a
addq $0x2, %rax
cmpl %eax, (%rsp)
jg 0x259a07
jmp 0x259a31
movl 0x8(%rsp), %eax
jmp 0x25a2ac
movl 0x8(%rsp), %ebp
movq 0x28(%rsp), %rsi
movl %eax, 0x2c8(%r14)
testl %esi, %esi
jle 0x259b08
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %rbx
xorl %r15d, %r15d
movq 0x20(%r12), %rax
movq (%rax,%r15), %rdx
movq (%rdx), %r8
movb $0x1, %dil
cmpb $0x0, -0x1(%r8)
je 0x259a71
testb %dil, %dil
je 0x259bd4
addq $0x18, %r15
cmpq %r15, %rbx
jne 0x259a44
jmp 0x259b08
movq 0x10(%rax,%r15), %rcx
testq %rcx, %rcx
je 0x259a5a
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0x259aa2
cmpb $0x0, 0x11(%rdx)
je 0x259acd
movq %r14, %rdi
movq 0x68(%rsp), %r8
callq 0x25a9ca
testl %eax, %eax
sete %dil
cmovnel %eax, %ebp
jmp 0x259a5a
movb $0x1, -0x1(%r8)
movq (%rax,%r15), %rcx
movq (%rcx), %rcx
movq (%rsp), %r8
movslq %r8d, %rdx
movq 0x10(%rsp), %rsi
movq %rcx, (%rsi,%rdx,8)
movq 0x10(%rax,%r15), %rax
addl $0x2, %r8d
movq %r8, (%rsp)
jmp 0x259afe
movb $0x2, -0x1(%r8)
movq 0x18(%rsp), %rcx
incl %ecx
movq %rcx, 0x18(%rsp)
movq (%rax,%r15), %rcx
movq (%rcx), %rcx
movslq (%rsp), %rdx
movq 0x10(%rsp), %rsi
movq %rcx, (%rsi,%rdx,8)
movq 0x10(%rax,%r15), %rax
leal 0x2(%rdx), %ecx
movq %rcx, (%rsp)
movq %rax, 0x8(%rsi,%rdx,8)
jmp 0x259a5a
movslq (%rsp), %rax
movq 0x10(%rsp), %rbx
movq %rax, 0x48(%rsp)
movq $0x0, (%rbx,%rax,8)
movq 0x18(%rsp), %r15
testl %r15d, %r15d
je 0x259bdb
movb 0x2e8(%r14), %cl
movl $0x1, %edx
shll %cl, %edx
movq 0x2e0(%r14), %rax
movq %rax, 0x40(%rsp)
leal (%r15,%r15), %eax
sarl %cl, %eax
testl %eax, %eax
je 0x259beb
movb 0x2e8(%r14), %al
movl %eax, %ecx
leal 0x1(%rcx), %eax
movl %r15d, %edx
sarl %cl, %edx
testl %edx, %edx
jne 0x259b5b
movzbl %al, %eax
cmpb $0x4, %al
movl $0x3, %ecx
cmovael %eax, %ecx
movb %cl, 0x2e8(%r14)
movl $0x1, %r13d
movl $0x1, %eax
shll %cl, %eax
movq 0x2d8(%r14), %rdi
movq %rax, 0x28(%rsp)
cltq
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
callq *0x20(%r14)
testq %rax, %rax
je 0x259bbc
movq %rax, 0x2d8(%r14)
movq $0x0, 0x40(%rsp)
movl %ebp, %r13d
testq %rax, %rax
je 0x25a0c8
movl %r13d, %eax
jmp 0x259bf2
movl $0x1, %eax
jmp 0x25a2ac
movl %ebp, %eax
jmp 0x25a2ac
movl %ebp, 0x8(%rsp)
xorl %ebp, %ebp
movq 0x48(%rsp), %rdx
jmp 0x25a0e0
movq %rdx, 0x28(%rsp)
movl %ebp, %eax
movq 0x40(%rsp), %r13
testq %r13, %r13
jne 0x259cb1
movl %eax, %edi
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq 0x2d8(%r14), %rcx
movslq 0x28(%rsp), %rdx
leaq 0x1(%rdx), %rax
andq $-0x2, %rax
leaq -0x1(%rdx), %rsi
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdx,%rdx,2), %rdx
leaq (%rcx,%rdx,8), %rcx
addq $-0x18, %rcx
xorl %edx, %edx
movdqa 0x107e30(%rip), %xmm1   # 0x361a70
movdqa 0x107e38(%rip), %xmm2   # 0x361a80
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x259c8f
movq %r13, (%rcx)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x259ca2
movq %r13, -0x18(%rcx)
addq $0x2, %rdx
addq $-0x30, %rcx
cmpq %rdx, %rax
jne 0x259c50
movl %edi, %eax
decq %r13
movq %r13, 0x2e0(%r14)
cmpl $0x0, (%rsp)
jle 0x25a0bd
movl %eax, %ecx
movq 0x60(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x90(%rsp)
movl %ecx, %eax
leaq 0x300(%r14), %rcx
movq %rcx, 0x8(%rsp)
movq 0x28(%rsp), %rcx
decl %ecx
movl %ecx, 0x74(%rsp)
movslq %ecx, %rcx
movq %rcx, %rdx
notq %rdx
movq %rdx, 0x78(%rsp)
shrq $0x2, %rcx
movq %rcx, 0x80(%rsp)
xorl %ebp, %ebp
movq %r13, 0x40(%rsp)
movq %r15, 0x18(%rsp)
movslq %ebp, %rdx
movq (%rbx,%rdx,8), %r15
cmpb $0x2, -0x1(%r15)
movb $0x0, -0x1(%r15)
movb $0x1, %cl
jne 0x259de2
movq %rdx, 0x88(%rsp)
movl %eax, 0x20(%rsp)
movq 0x90(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x257a9b
movq 0x8(%rax), %rax
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x259de6
movq %rbp, 0x30(%rsp)
cmpl $0x0, 0x28(%r12)
jle 0x259e06
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x20(%r12), %rax
movb (%rax,%rbx), %r13b
movq 0x318(%r14), %rax
cmpq 0x310(%r14), %rax
jne 0x259d9b
movq 0x8(%rsp), %rdi
callq 0x2578ac
testb %al, %al
je 0x259dd6
movzbl %r13b, %eax
movq 0x318(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x318(%r14)
movb %al, (%rcx)
imulq $0xf4243, %rbp, %rbp    # imm = 0xF4243
xorq %rax, %rbp
movb $0x1, %al
testb %al, %al
je 0x259f65
incq %rbx
movslq 0x28(%r12), %rax
cmpq %rax, %rbx
jl 0x259d74
jmp 0x259e08
movl $0x1, 0x20(%rsp)
xorl %eax, %eax
jmp 0x259dbf
xorl %edx, %edx
jmp 0x259df7
movl $0x1, %edx
movl $0x1b, %eax
xorl %ecx, %ecx
movq 0x38(%rsp), %r12
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r15
jmp 0x259f84
xorl %ebp, %ebp
cmpb $0x3a, (%r15)
leaq 0x1(%r15), %r15
jne 0x259e08
jmp 0x259e20
movl $0x1, 0x20(%rsp)
xorl %eax, %eax
jmp 0x259e65
movzbl (%r15), %ebx
movq 0x318(%r14), %rax
cmpq 0x310(%r14), %rax
jne 0x259e42
movq 0x8(%rsp), %rdi
callq 0x2578ac
testb %al, %al
je 0x259e14
movb (%r15), %al
movq 0x318(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x318(%r14)
movb %al, (%rcx)
imulq $0xf4243, %rbp, %rbp    # imm = 0xF4243
xorq %rbx, %rbp
movb $0x1, %al
testb %al, %al
je 0x259f65
cmpb $0x0, (%r15)
leaq 0x1(%r15), %r15
jne 0x259e20
movl 0x74(%rsp), %eax
andl %ebp, %eax
movq 0x2d8(%r14), %rdx
movslq %eax, %r15
leaq (%r15,%r15,2), %rsi
movq 0x40(%rsp), %rcx
cmpq %rcx, (%rdx,%rsi,8)
sete %cl
jne 0x259f60
leaq (%rdx,%rsi,8), %r8
movq %rbp, %rsi
andq 0x78(%rsp), %rsi
xorl %edi, %edi
movq 0x28(%rsp), %r9
cmpq 0x8(%r8), %rbp
jne 0x259f0f
movq 0x320(%r14), %r9
movb (%r9), %r11b
testb %r11b, %r11b
sete %r10b
je 0x259ef1
movq 0x10(%r8), %r8
cmpb (%r8), %r11b
jne 0x259ef1
movl $0x1, %r11d
movb (%r9,%r11), %bl
testb %bl, %bl
sete %r10b
je 0x259ef1
leaq 0x1(%r11), %r13
cmpb (%r8,%r11), %bl
movq %r13, %r11
je 0x259ed8
testb %r10b, %r10b
movl 0x20(%rsp), %r8d
movl $0x8, %r9d
cmovnel %r9d, %r8d
movl %r8d, 0x20(%rsp)
movq 0x28(%rsp), %r9
jne 0x259f60
testb %dil, %dil
jne 0x259f33
movl 0x2e8(%r14), %ecx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
addl %edi, %ecx
movq %rsi, %rdi
shrq %cl, %rdi
andl 0x80(%rsp), %edi
orb $0x1, %dil
movzbl %dil, %ecx
subl %ecx, %eax
movl $0x0, %ecx
cmovll %r9d, %ecx
addl %ecx, %eax
movslq %eax, %r15
leaq (%r15,%r15,2), %rcx
leaq (%rdx,%rcx,8), %r8
movq 0x40(%rsp), %rcx
cmpq %rcx, (%r8)
sete %cl
je 0x259eb0
testb $0x1, %cl
je 0x259f9d
xorl %ecx, %ecx
movq 0x38(%rsp), %r12
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r15
movl 0x20(%rsp), %eax
movq 0x30(%rsp), %rbp
movl $0x1, %edx
testl %edx, %edx
jne 0x25a0af
addl $0x2, %ebp
cmpl (%rsp), %ebp
jl 0x259d12
jmp 0x25a0bf
cmpb $0x0, 0x1c9(%r14)
je 0x25a005
movb 0x36c(%r14), %al
movq 0x318(%r14), %rcx
movb %al, -0x1(%rcx)
movq (%r12), %rax
movq (%rax), %rbx
movq 0x318(%r14), %rax
cmpq 0x310(%r14), %rax
movq 0x38(%rsp), %r12
jne 0x259fe6
movq 0x8(%rsp), %rdi
callq 0x2578ac
testb %al, %al
je 0x25a08f
movb (%rbx), %al
movq 0x318(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x318(%r14)
movb %al, (%rcx)
cmpb $0x0, (%rbx)
leaq 0x1(%rbx), %rbx
jne 0x259fbf
movq 0x318(%r14), %rax
movq 0x320(%r14), %rcx
movq %rax, 0x320(%r14)
movq 0x10(%rsp), %rax
movq 0x88(%rsp), %rdx
movq %rcx, (%rax,%rdx,8)
movq 0x2d8(%r14), %rax
leaq (%r15,%r15,2), %rdx
movq 0x40(%rsp), %rsi
movq %rsi, (%rax,%rdx,8)
movq %rbp, 0x8(%rax,%rdx,8)
movq %rcx, 0x10(%rax,%rdx,8)
movq 0x18(%rsp), %r15
decl %r15d
movq 0x38(%rsp), %r12
je 0x25a06f
movq 0x10(%rsp), %rbx
xorl %edx, %edx
movl 0x20(%rsp), %eax
movq 0x30(%rsp), %rbp
movb $0x1, %cl
jmp 0x259f84
movq 0x30(%rsp), %rbp
addl $0x2, %ebp
xorl %ecx, %ecx
movl $0x12, %edx
xorl %r15d, %r15d
movq 0x10(%rsp), %rbx
movl 0x20(%rsp), %eax
jmp 0x259f84
movl $0x1, %edx
xorl %ecx, %ecx
movl $0x1, %eax
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r15
movq 0x30(%rsp), %rbp
jmp 0x259f84
cmpl $0x12, %edx
movq 0x48(%rsp), %rdx
jne 0x25a0d4
movb $0x1, %cl
jmp 0x25a0d4
xorl %ebp, %ebp
movb $0x1, %cl
movq 0x48(%rsp), %rdx
jmp 0x25a0d4
xorl %ecx, %ecx
xorl %ebp, %ebp
movq 0x48(%rsp), %rdx
movl %r13d, %eax
movl %eax, 0x8(%rsp)
testb %cl, %cl
je 0x25a2ac
cmpl (%rsp), %ebp
jge 0x25a0f9
movslq %ebp, %rax
movq (%rbx,%rax,8), %rcx
movb $0x0, -0x1(%rcx)
addq $0x2, %rax
cmpq %rdx, %rax
jl 0x25a0e8
movq 0x68(%rsp), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x25a117
movq 0x18(%rax), %rcx
movq (%rcx), %rcx
movb $0x0, -0x1(%rcx)
movq 0x8(%rax), %rax
jmp 0x25a101
xorl %eax, %eax
cmpb $0x0, 0x1c8(%r14)
je 0x25a2ac
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x25a152
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x25a24d
movq 0x50(%rsp), %rax
movq (%rax), %r15
cmpb $0x3a, (%r15)
leaq 0x1(%r15), %r15
jne 0x25a146
jmp 0x25a174
movq 0x60(%rsp), %rax
movq 0x110(%rax), %r12
testq %r12, %r12
movl $0x0, %eax
je 0x25a2ac
movq 0x50(%rsp), %rax
movq (%rax), %r15
xorl %ebp, %ebp
cmpb $0x0, 0x1c9(%r14)
je 0x25a198
movq (%r12), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x25a198
xorl %ebp, %ebp
cmpb $0x0, (%rax,%rbp)
leaq 0x1(%rbp), %rbp
jne 0x25a18e
movq 0x50(%rsp), %rdx
movq %r15, 0x8(%rdx)
movl 0x28(%r12), %eax
movl %eax, 0x1c(%rdx)
movq (%r12), %rcx
movq (%rcx), %rcx
movq %rcx, 0x10(%rdx)
movl %ebp, 0x20(%rdx)
xorl %r13d, %r13d
cmpb $0x0, (%r15,%r13)
leaq 0x1(%r13), %r13
jne 0x25a1ba
addl %ebp, %eax
leal (%rax,%r13), %ecx
cmpl 0x2c(%r12), %ecx
jle 0x25a262
movq %r12, (%rsp)
movl %eax, %eax
leaq (%rax,%r13), %rbx
addq $0x18, %rbx
movslq %ebx, %rdi
callq *0x18(%r14)
movq %rax, %r12
testq %rax, %rax
je 0x25a254
movq (%rsp), %rax
movl %ebx, 0x2c(%rax)
movq 0x20(%rax), %rsi
movslq 0x28(%rax), %rdx
movq %r12, %rdi
callq 0x17660
movq 0x2a0(%r14), %rax
testq %rax, %rax
je 0x25a230
movq (%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpq %rcx, 0x18(%rax)
jne 0x25a228
movq %r12, 0x18(%rax)
movq (%rax), %rax
testq %rax, %rax
jne 0x25a21e
movq (%rsp), %rbx
movq 0x20(%rbx), %rdi
callq *0x28(%r14)
movq %r12, 0x20(%rbx)
movl 0x8(%rsp), %eax
jmp 0x25a259
xorl %eax, %eax
jmp 0x2596a5
movl $0x1b, %eax
jmp 0x25a2ac
movl $0x1, %eax
testq %r12, %r12
movq (%rsp), %r12
je 0x25a2ac
movslq 0x28(%r12), %rbx
addq 0x20(%r12), %rbx
movl %r13d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17660
testl %ebp, %ebp
je 0x25a29d
leaq (%rbx,%r13), %rdi
movb 0x36c(%r14), %al
movb %al, -0x1(%rbx,%r13)
movq (%r12), %rax
movq (%rax), %rsi
movslq %ebp, %rdx
callq 0x17660
movq 0x20(%r12), %rax
movq 0x50(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq