// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movq %rdx, 0x128(%rsp)
movq %rcx, 0x120(%rsp)
movq %r8, 0x118(%rsp)
movq 0x138(%rsp), %rax
movq 0x290(%rax), %rax
movq %rax, 0x110(%rsp)
movl $0x0, 0xf4(%rsp)
movl $0x0, 0xdc(%rsp)
movq 0x110(%rsp), %rdi
addq $0x28, %rdi
movq 0x120(%rsp), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x37ade0
movq %rax, 0x108(%rsp)
cmpq $0x0, 0x108(%rsp)
jne 0x37df16
movq 0x110(%rsp), %rdi
addq $0xa0, %rdi
movq 0x120(%rsp), %rax
movq (%rax), %rsi
callq 0x373d60
movq %rax, 0xc0(%rsp)
cmpq $0x0, 0xc0(%rsp)
jne 0x37de95
movl $0x1, 0x144(%rsp)
jmp 0x37f470
movq 0x110(%rsp), %rdi
addq $0x28, %rdi
movq 0xc0(%rsp), %rsi
movl $0x28, %edx
callq 0x37ade0
movq %rax, 0x108(%rsp)
cmpq $0x0, 0x108(%rsp)
jne 0x37ded6
movl $0x1, 0x144(%rsp)
jmp 0x37f470
movq 0x138(%rsp), %rax
movzbl 0x1c8(%rax), %eax
cmpl $0x0, %eax
je 0x37df14
movq 0x138(%rsp), %rdi
movq 0x108(%rsp), %rsi
callq 0x37fef0
cmpl $0x0, %eax
jne 0x37df14
movl $0x1, 0x144(%rsp)
jmp 0x37f470
jmp 0x37df16
movq 0x108(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x104(%rsp)
movq 0x130(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x130(%rsp), %rdi
movq 0x128(%rsp), %rsi
movq 0x138(%rsp), %rcx
movl 0x2c0(%rcx), %edx
movq 0x138(%rsp), %rcx
movq 0x2d0(%rcx), %rcx
callq *%rax
movl %eax, 0xe8(%rsp)
movl 0xe8(%rsp), %eax
addl 0x104(%rsp), %eax
movq 0x138(%rsp), %rcx
cmpl 0x2c0(%rcx), %eax
jle 0x37e070
movq 0x138(%rsp), %rax
movl 0x2c0(%rax), %eax
movl %eax, 0xbc(%rsp)
movl 0xe8(%rsp), %ecx
addl 0x104(%rsp), %ecx
addl $0x10, %ecx
movq 0x138(%rsp), %rax
movl %ecx, 0x2c0(%rax)
movq 0x138(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x138(%rsp), %rcx
movq 0x2d0(%rcx), %rdi
movq 0x138(%rsp), %rcx
movslq 0x2c0(%rcx), %rsi
shlq $0x5, %rsi
callq *%rax
movq %rax, 0xb0(%rsp)
cmpq $0x0, 0xb0(%rsp)
jne 0x37e013
movl $0x1, 0x144(%rsp)
jmp 0x37f470
movq 0xb0(%rsp), %rcx
movq 0x138(%rsp), %rax
movq %rcx, 0x2d0(%rax)
movl 0xe8(%rsp), %eax
cmpl 0xbc(%rsp), %eax
jle 0x37e06e
movq 0x130(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x130(%rsp), %rdi
movq 0x128(%rsp), %rsi
movl 0xe8(%rsp), %edx
movq 0x138(%rsp), %rcx
movq 0x2d0(%rcx), %rcx
callq *%rax
jmp 0x37e070
movq 0x138(%rsp), %rax
movq 0x2d0(%rax), %rax
movq %rax, 0xf8(%rsp)
movl $0x0, 0xec(%rsp)
movl 0xec(%rsp), %eax
cmpl 0xe8(%rsp), %eax
jge 0x37e576
movq 0x138(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x138(%rsp), %rax
movq 0x2d0(%rax), %rax
movslq 0xec(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x138(%rsp), %rax
movq 0x2d0(%rax), %rax
movslq 0xec(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x130(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x130(%rsp), %rdi
movq 0x138(%rsp), %rcx
movq 0x2d0(%rcx), %rcx
movslq 0xec(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
cltq
addq %rax, %rcx
callq 0x379e10
movq %rax, 0xa8(%rsp)
cmpq $0x0, 0xa8(%rsp)
jne 0x37e184
movl $0x1, 0x144(%rsp)
jmp 0x37f470
movq 0xa8(%rsp), %rax
movq (%rax), %rax
cmpb $0x0, -0x1(%rax)
je 0x37e1ee
movq 0x130(%rsp), %rax
movq 0x138(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x37e1de
movq 0x138(%rsp), %rax
movq 0x2d0(%rax), %rax
movslq 0xec(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq 0x138(%rsp), %rax
movq %rcx, 0x210(%rax)
movl $0x8, 0x144(%rsp)
jmp 0x37f470
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movb $0x1, -0x1(%rax)
movq 0xa8(%rsp), %rax
movq (%rax), %rdx
movq 0xf8(%rsp), %rax
movl 0xf4(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xf4(%rsp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x138(%rsp), %rax
movq 0x2d0(%rax), %rax
movslq 0xec(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpb $0x0, 0x18(%rax)
jne 0x37e3c9
movb $0x1, 0xa3(%rsp)
movq 0xa8(%rsp), %rax
cmpb $0x0, 0x10(%rax)
je 0x37e2ed
movl $0x0, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
cmpl 0x104(%rsp), %eax
jge 0x37e2eb
movq 0xa8(%rsp), %rax
movq 0x108(%rsp), %rcx
movq 0x20(%rcx), %rcx
movslq 0x9c(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jne 0x37e2d6
movq 0x108(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x9c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb 0x8(%rax), %al
movb %al, 0xa3(%rsp)
jmp 0x37e2eb
jmp 0x37e2d8
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9c(%rsp)
jmp 0x37e277
jmp 0x37e2ed
movq 0x138(%rsp), %rdi
movq 0x130(%rsp), %rsi
movb 0xa3(%rsp), %al
movq 0x138(%rsp), %rcx
movq 0x2d0(%rcx), %rcx
movslq 0xec(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movq 0x138(%rsp), %rdx
movq 0x2d0(%rdx), %rdx
movslq 0xec(%rsp), %r8
shlq $0x5, %r8
addq %r8, %rdx
movq 0x10(%rdx), %r8
movq 0x138(%rsp), %r9
addq $0x300, %r9             # imm = 0x300
movzbl %al, %edx
callq 0x37a970
movl %eax, 0xa4(%rsp)
cmpl $0x0, 0xa4(%rsp)
je 0x37e383
movl 0xa4(%rsp), %eax
movl %eax, 0x144(%rsp)
jmp 0x37f470
movq 0x138(%rsp), %rax
movq 0x320(%rax), %rdx
movq 0xf8(%rsp), %rax
movslq 0xf4(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x138(%rsp), %rax
movq 0x318(%rax), %rcx
movq 0x138(%rsp), %rax
movq %rcx, 0x320(%rax)
jmp 0x37e485
movq 0x138(%rsp), %rdi
addq $0x300, %rdi            # imm = 0x300
movq 0x130(%rsp), %rsi
movq 0x138(%rsp), %rax
movq 0x2d0(%rax), %rax
movslq 0xec(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movq 0x138(%rsp), %rax
movq 0x2d0(%rax), %rax
movslq 0xec(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
callq 0x379ae0
movq %rax, %rdx
movq 0xf8(%rsp), %rax
movslq 0xf4(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0xf8(%rsp), %rax
movslq 0xf4(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x37e467
movl $0x1, 0x144(%rsp)
jmp 0x37f470
movq 0x138(%rsp), %rax
movq 0x318(%rax), %rcx
movq 0x138(%rsp), %rax
movq %rcx, 0x320(%rax)
movq 0xa8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x37e54d
movq 0xa8(%rsp), %rax
cmpb $0x0, 0x11(%rax)
je 0x37e51a
movq 0x138(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0xa8(%rsp), %rdx
movq 0xf8(%rsp), %rax
movslq 0xf4(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x118(%rsp), %r8
callq 0x3800f0
movl %eax, 0x98(%rsp)
cmpl $0x0, 0x98(%rsp)
je 0x37e507
movl 0x98(%rsp), %eax
movl %eax, 0x144(%rsp)
jmp 0x37f470
movl 0xf4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xf4(%rsp)
jmp 0x37e54b
movl 0xf4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf4(%rsp)
movl 0xdc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xdc(%rsp)
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movb $0x2, -0x1(%rax)
jmp 0x37e55e
movl 0xf4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf4(%rsp)
jmp 0x37e560
movl 0xec(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xec(%rsp)
jmp 0x37e092
movl 0xf4(%rsp), %ecx
movq 0x138(%rsp), %rax
movl %ecx, 0x2c4(%rax)
movq 0x108(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x37e624
movq 0x108(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movsbl -0x1(%rax), %eax
cmpl $0x0, %eax
je 0x37e624
movl $0x0, 0xec(%rsp)
movl 0xec(%rsp), %eax
cmpl 0xf4(%rsp), %eax
jge 0x37e622
movq 0xf8(%rsp), %rax
movslq 0xec(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x108(%rsp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jne 0x37e60d
movl 0xec(%rsp), %ecx
movq 0x138(%rsp), %rax
movl %ecx, 0x2c8(%rax)
jmp 0x37e622
jmp 0x37e60f
movl 0xec(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xec(%rsp)
jmp 0x37e5c1
jmp 0x37e636
movq 0x138(%rsp), %rax
movl $0xffffffff, 0x2c8(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0xec(%rsp)
movl 0xec(%rsp), %eax
cmpl 0x104(%rsp), %eax
jge 0x37e83b
movq 0x108(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0xec(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpb $0x0, -0x1(%rax)
jne 0x37e823
movq 0x90(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x37e823
movq 0x90(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x37e7b1
movq 0x90(%rsp), %rax
movq (%rax), %rax
cmpb $0x0, 0x11(%rax)
je 0x37e72e
movq 0x138(%rsp), %rdi
movq 0x90(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
movq 0x90(%rsp), %rax
movq (%rax), %rdx
movq 0x90(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x118(%rsp), %r8
callq 0x3800f0
movl %eax, 0x8c(%rsp)
cmpl $0x0, 0x8c(%rsp)
je 0x37e729
movl 0x8c(%rsp), %eax
movl %eax, 0x144(%rsp)
jmp 0x37f470
jmp 0x37e7af
movq 0x90(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movb $0x2, -0x1(%rax)
movl 0xdc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xdc(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq 0xf8(%rsp), %rax
movl 0xf4(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xf4(%rsp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x90(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0xf8(%rsp), %rax
movl 0xf4(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xf4(%rsp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x37e821
movq 0x90(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movb $0x1, -0x1(%rax)
movq 0x90(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq 0xf8(%rsp), %rax
movl 0xf4(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xf4(%rsp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x90(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0xf8(%rsp), %rax
movl 0xf4(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xf4(%rsp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x37e823
jmp 0x37e825
movl 0xec(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xec(%rsp)
jmp 0x37e641
movq 0xf8(%rsp), %rax
movslq 0xf4(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl $0x0, 0xec(%rsp)
cmpl $0x0, 0xdc(%rsp)
je 0x37f00e
movq 0x138(%rsp), %rax
movq 0x2e0(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x138(%rsp), %rax
movzbl 0x2e8(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x7c(%rsp)
movl 0xdc(%rsp), %eax
shll %eax
movq 0x138(%rsp), %rcx
movzbl 0x2e8(%rcx), %ecx
sarl %cl, %eax
cmpl $0x0, %eax
je 0x37e991
jmp 0x37e8c2
movl 0xdc(%rsp), %eax
movq 0x138(%rsp), %rdx
movb 0x2e8(%rdx), %cl
movb %cl, %sil
addb $0x1, %sil
movb %sil, 0x2e8(%rdx)
movzbl %cl, %ecx
sarl %cl, %eax
cmpl $0x0, %eax
je 0x37e8f1
jmp 0x37e8c2
movq 0x138(%rsp), %rax
movzbl 0x2e8(%rax), %eax
cmpl $0x3, %eax
jge 0x37e914
movq 0x138(%rsp), %rax
movb $0x3, 0x2e8(%rax)
movq 0x138(%rsp), %rax
movzbl 0x2e8(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x7c(%rsp)
movq 0x138(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x138(%rsp), %rcx
movq 0x2d8(%rcx), %rdi
movslq 0x7c(%rsp), %rcx
imulq $0x18, %rcx, %rsi
callq *%rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0x37e971
movl $0x1, 0x144(%rsp)
jmp 0x37f470
movq 0x70(%rsp), %rcx
movq 0x138(%rsp), %rax
movq %rcx, 0x2d8(%rax)
movq $0x0, 0x80(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0x37e9f7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x80(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x88(%rsp)
cmpl $0x0, 0x88(%rsp)
je 0x37e9f5
movq 0x80(%rsp), %rcx
movq 0x138(%rsp), %rax
movq 0x2d8(%rax), %rax
movl 0x88(%rsp), %edx
addl $-0x1, %edx
movl %edx, 0x88(%rsp)
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x37e9b4
jmp 0x37e9f7
movq 0x80(%rsp), %rcx
addq $-0x1, %rcx
movq %rcx, 0x80(%rsp)
movq 0x138(%rsp), %rax
movq %rcx, 0x2e0(%rax)
movl 0xec(%rsp), %eax
cmpl 0xf4(%rsp), %eax
jge 0x37f00c
movq 0xf8(%rsp), %rax
movslq 0xec(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2, %eax
jne 0x37efeb
movq $0x0, 0x50(%rsp)
movq 0x68(%rsp), %rax
movb $0x0, -0x1(%rax)
movq 0x110(%rsp), %rdi
addq $0x50, %rdi
movq 0x68(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x37ade0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x37eab4
movl $0x1b, 0x144(%rsp)
jmp 0x37f470
movl $0x0, 0x88(%rsp)
movl 0x88(%rsp), %eax
movq 0x58(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x37eb91
movq 0x58(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x88(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x4f(%rsp)
movq 0x138(%rsp), %rax
movq 0x318(%rax), %rax
movq 0x138(%rsp), %rcx
cmpq 0x310(%rcx), %rax
jne 0x37eb2c
movq 0x138(%rsp), %rdi
addq $0x300, %rdi            # imm = 0x300
callq 0x37a570
cmpb $0x0, %al
jne 0x37eb2c
xorl %eax, %eax
testb $0x1, %al
jne 0x37eb65
jmp 0x37eb55
movb 0x4f(%rsp), %cl
movq 0x138(%rsp), %rdx
movq 0x318(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x318(%rdx)
movb %cl, (%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x37eb65
movl $0x1, 0x144(%rsp)
jmp 0x37f470
imulq $0xf4243, 0x50(%rsp), %rax # imm = 0xF4243
movzbl 0x4f(%rsp), %ecx
xorq %rcx, %rax
movq %rax, 0x50(%rsp)
movl 0x88(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x88(%rsp)
jmp 0x37eabf
jmp 0x37eb93
movq 0x68(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rsp)
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x37ebae
jmp 0x37eb93
jmp 0x37ebb0
movq 0x68(%rsp), %rax
movb (%rax), %al
movb %al, 0x4e(%rsp)
movq 0x138(%rsp), %rax
movq 0x318(%rax), %rax
movq 0x138(%rsp), %rcx
cmpq 0x310(%rcx), %rax
jne 0x37ebfb
movq 0x138(%rsp), %rdi
addq $0x300, %rdi            # imm = 0x300
callq 0x37a570
cmpb $0x0, %al
jne 0x37ebfb
xorl %eax, %eax
testb $0x1, %al
jne 0x37ec37
jmp 0x37ec27
movq 0x68(%rsp), %rax
movb (%rax), %cl
movq 0x138(%rsp), %rdx
movq 0x318(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x318(%rdx)
movb %cl, (%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x37ec37
movl $0x1, 0x144(%rsp)
jmp 0x37f470
imulq $0xf4243, 0x50(%rsp), %rax # imm = 0xF4243
movzbl 0x4e(%rsp), %ecx
xorq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rsp)
cmpb $0x0, (%rax)
jne 0x37ebb0
movb $0x0, 0x4d(%rsp)
movl 0x7c(%rsp), %eax
subl $0x1, %eax
cltq
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
andq 0x40(%rsp), %rax
movl %eax, 0x88(%rsp)
movq 0x138(%rsp), %rax
movq 0x2d8(%rax), %rax
movslq 0x88(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x80(%rsp), %rax
jne 0x37ee1f
movq 0x50(%rsp), %rax
movq 0x138(%rsp), %rcx
movq 0x2d8(%rcx), %rcx
movslq 0x88(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jne 0x37ed97
movq 0x138(%rsp), %rax
movq 0x320(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x138(%rsp), %rax
movq 0x2d8(%rax), %rax
movslq 0x88(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movsbl (%rax), %ecx
movq 0x30(%rsp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, 0x7(%rsp)
jne 0x37ed4e
movq 0x38(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x37ed58
jmp 0x37ed78
jmp 0x37ed5a
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x37ed22
movq 0x38(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x37ed95
movl $0x8, 0x144(%rsp)
jmp 0x37f470
jmp 0x37ed97
cmpb $0x0, 0x4d(%rsp)
jne 0x37edda
movq 0x50(%rsp), %rax
movq 0x40(%rsp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq 0x138(%rsp), %rcx
movzbl 0x2e8(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq 0x40(%rsp), %rcx
shrq $0x2, %rcx
andq %rcx, %rax
orq $0x1, %rax
movb %al, 0x4d(%rsp)
movl 0x88(%rsp), %eax
movzbl 0x4d(%rsp), %ecx
cmpl %ecx, %eax
jge 0x37ee05
movl 0x7c(%rsp), %eax
movzbl 0x4d(%rsp), %ecx
subl %ecx, %eax
addl 0x88(%rsp), %eax
movl %eax, 0x88(%rsp)
jmp 0x37ee1a
movzbl 0x4d(%rsp), %ecx
movl 0x88(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x88(%rsp)
jmp 0x37ec8b
movq 0x138(%rsp), %rax
cmpb $0x0, 0x1c9(%rax)
je 0x37eefe
movq 0x138(%rsp), %rax
movb 0x36c(%rax), %cl
movq 0x138(%rsp), %rax
movq 0x318(%rax), %rax
movb %cl, -0x1(%rax)
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x138(%rsp), %rax
movq 0x318(%rax), %rax
movq 0x138(%rsp), %rcx
cmpq 0x310(%rcx), %rax
jne 0x37eea4
movq 0x138(%rsp), %rdi
addq $0x300, %rdi            # imm = 0x300
callq 0x37a570
cmpb $0x0, %al
jne 0x37eea4
xorl %eax, %eax
testb $0x1, %al
jne 0x37eee0
jmp 0x37eed0
movq 0x68(%rsp), %rax
movb (%rax), %cl
movq 0x138(%rsp), %rdx
movq 0x318(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x318(%rdx)
movb %cl, (%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x37eee0
movl $0x1, 0x144(%rsp)
jmp 0x37f470
jmp 0x37eee2
movq 0x68(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rsp)
cmpb $0x0, (%rax)
jne 0x37ee64
jmp 0x37eefe
movq 0x138(%rsp), %rax
movq 0x320(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x138(%rsp), %rax
movq 0x318(%rax), %rcx
movq 0x138(%rsp), %rax
movq %rcx, 0x320(%rax)
movq 0x68(%rsp), %rdx
movq 0xf8(%rsp), %rax
movslq 0xec(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x80(%rsp), %rcx
movq 0x138(%rsp), %rax
movq 0x2d8(%rax), %rax
movslq 0x88(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x50(%rsp), %rcx
movq 0x138(%rsp), %rax
movq 0x2d8(%rax), %rax
movslq 0x88(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x68(%rsp), %rcx
movq 0x138(%rsp), %rax
movq 0x2d8(%rax), %rax
movslq 0x88(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl 0xdc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xdc(%rsp)
cmpl $0x0, %eax
jne 0x37efe9
movl 0xec(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xec(%rsp)
jmp 0x37f00c
jmp 0x37eff4
movq 0x68(%rsp), %rax
movb $0x0, -0x1(%rax)
jmp 0x37eff6
movl 0xec(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xec(%rsp)
jmp 0x37ea1a
jmp 0x37f00e
jmp 0x37f010
movl 0xec(%rsp), %eax
cmpl 0xf4(%rsp), %eax
jge 0x37f04b
movq 0xf8(%rsp), %rax
movslq 0xec(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movb $0x0, -0x1(%rax)
movl 0xec(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xec(%rsp)
jmp 0x37f010
movq 0x118(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xd0(%rsp)
cmpq $0x0, 0xd0(%rsp)
je 0x37f092
movq 0xd0(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movb $0x0, -0x1(%rax)
movq 0xd0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xd0(%rsp)
jmp 0x37f05e
movq 0x138(%rsp), %rax
cmpb $0x0, 0x1c8(%rax)
jne 0x37f0b3
movl $0x0, 0x144(%rsp)
jmp 0x37f470
movq 0x108(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x37f12b
movq 0x108(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0xd0(%rsp)
cmpq $0x0, 0xd0(%rsp)
jne 0x37f0f5
movl $0x1b, 0x144(%rsp)
jmp 0x37f470
movq 0x120(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rsp)
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x37f129
jmp 0x37f108
jmp 0x37f17b
movq 0x110(%rsp), %rax
cmpq $0x0, 0x110(%rax)
je 0x37f169
movq 0x110(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0xd0(%rsp)
movq 0x120(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xc8(%rsp)
jmp 0x37f179
movl $0x0, 0x144(%rsp)
jmp 0x37f470
jmp 0x37f17b
movl $0x0, 0xf0(%rsp)
movq 0x138(%rsp), %rax
movzbl 0x1c9(%rax), %eax
cmpl $0x0, %eax
je 0x37f1db
movq 0xd0(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0x37f1db
jmp 0x37f1ad
movq 0xd0(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0xf0(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xf0(%rsp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x37f1d9
jmp 0x37f1ad
jmp 0x37f1db
movq 0xc8(%rsp), %rcx
movq 0x120(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0xd0(%rsp), %rax
movl 0x28(%rax), %ecx
movq 0x120(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0xd0(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq 0x120(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0xf0(%rsp), %ecx
movq 0x120(%rsp), %rax
movl %ecx, 0x20(%rax)
movl $0x0, 0xec(%rsp)
movq 0xc8(%rsp), %rax
movl 0xec(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xec(%rsp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x37f262
jmp 0x37f23c
movl 0xec(%rsp), %eax
movq 0xd0(%rsp), %rcx
addl 0x28(%rcx), %eax
addl 0xf0(%rsp), %eax
movl %eax, 0xe8(%rsp)
movl 0xe8(%rsp), %eax
movq 0xd0(%rsp), %rcx
cmpl 0x2c(%rcx), %eax
jle 0x37f39d
movq 0x138(%rsp), %rax
movq 0x18(%rax), %rax
movl 0xe8(%rsp), %ecx
addl $0x18, %ecx
movslq %ecx, %rdi
shlq $0x0, %rdi
callq *%rax
movq %rax, 0xe0(%rsp)
cmpq $0x0, 0xe0(%rsp)
jne 0x37f2dc
movl $0x1, 0x144(%rsp)
jmp 0x37f470
movl 0xe8(%rsp), %ecx
addl $0x18, %ecx
movq 0xd0(%rsp), %rax
movl %ecx, 0x2c(%rax)
movq 0xe0(%rsp), %rdi
movq 0xd0(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0xd0(%rsp), %rax
movslq 0x28(%rax), %rdx
shlq $0x0, %rdx
callq 0x19610
movq 0x138(%rsp), %rax
movq 0x2a0(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x37f36f
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq 0xd0(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x37f35e
movq 0xe0(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x37f360
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x37f32e
movq 0x138(%rsp), %rax
movq 0x28(%rax), %rax
movq 0xd0(%rsp), %rcx
movq 0x20(%rcx), %rdi
callq *%rax
movq 0xe0(%rsp), %rcx
movq 0xd0(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0xd0(%rsp), %rax
movq 0x20(%rax), %rax
movq 0xd0(%rsp), %rcx
movslq 0x28(%rcx), %rcx
addq %rcx, %rax
movq %rax, 0xe0(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movslq 0xec(%rsp), %rdx
shlq $0x0, %rdx
callq 0x19610
cmpl $0x0, 0xf0(%rsp)
je 0x37f44e
movl 0xec(%rsp), %ecx
subl $0x1, %ecx
movq 0xe0(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0xe0(%rsp)
movq 0x138(%rsp), %rax
movb 0x36c(%rax), %cl
movq 0xe0(%rsp), %rax
movb %cl, (%rax)
movq 0xe0(%rsp), %rdi
addq $0x1, %rdi
movq 0xd0(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movslq 0xf0(%rsp), %rdx
shlq $0x0, %rdx
callq 0x19610
movq 0xd0(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x120(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x144(%rsp)
movl 0x144(%rsp), %eax
addq $0x148, %rsp            # imm = 0x148
retq
nop