LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: reportDefault
static void
reportDefault(XML_Parser parser, const ENCODING *enc,
              const char *s, const char *end)
{
  if (MUST_CONVERT(enc, s)) {
    const char **eventPP;
    const char **eventEndPP;
    if (enc == encoding) {
      eventPP = &eventPtr;
      eventEndPP = &eventEndPtr;
    }
    else {
      eventPP = &(openInternalEntities->internalEventPtr);
      eventEndPP = &(openInternalEntities->internalEventEndPtr);
    }
    do {
      ICHAR *dataPtr = (ICHAR *)dataBuf;
      XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
      *eventEndPP = s;
      defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));
      *eventPP = s;
    } while (s != end);
  }
  else
    defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movq %rdx, 0x8(%rsp)
cmpb $0x0, 0x84(%rsi)
je 0x1fd0cf
movq 0x8(%r14), %rdi
movq 0xa0(%r14), %rax
subl %edx, %ebx
movq %rdx, %rsi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rsi, %r15
cmpq %rsi, 0x120(%r14)
je 0x1fd0e8
movq 0x228(%r14), %rbp
leaq 0x8(%rbp), %r12
jmp 0x1fd0f6
leaq 0x210(%r14), %rbp
leaq 0x218(%r14), %r12
leaq 0x10(%rsp), %r13
movq 0x58(%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%r14), %r8
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq *0x70(%r15)
movq 0x8(%rsp), %rax
movq %rax, (%r12)
movq 0x8(%r14), %rdi
movq 0x58(%r14), %rsi
movl 0x10(%rsp), %edx
subl %esi, %edx
callq *0xa0(%r14)
movq 0x8(%rsp), %rax
movq %rax, (%rbp)
cmpq %rbx, %rax
jne 0x1fd0fb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: handleUnknownEncoding
static enum XML_Error
handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)
{
  if (unknownEncodingHandler) {
    XML_Encoding info;
    int i;
    for (i = 0; i < 256; i++)
      info.map[i] = -1;
    info.convert = NULL;
    info.data = NULL;
    info.release = NULL;
    if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName,
                               &info)) {
      ENCODING *enc;
      unknownEncodingMem = MALLOC(XmlSizeOfUnknownEncoding());
      if (!unknownEncodingMem) {
        if (info.release)
          info.release(info.data);
        return XML_ERROR_NO_MEMORY;
      }
      enc = (ns
             ? XmlInitUnknownEncodingNS
             : XmlInitUnknownEncoding)(unknownEncodingMem,
                                       info.map,
                                       info.convert,
                                       info.data);
      if (enc) {
        unknownEncodingData = info.data;
        unknownEncodingRelease = info.release;
        encoding = enc;
        return XML_ERROR_NONE;
      }
    }
    if (info.release != NULL)
      info.release(info.data);
  }
  return XML_ERROR_UNKNOWN_ENCODING;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
movq 0xf8(%rdi), %rax
pushq $0x12
popq %rbx
testq %rax, %rax
je 0x1fe9ab
movq %rdi, %r14
xorl %ecx, %ecx
cmpq $0x100, %rcx            # imm = 0x100
je 0x1fe8ff
orl $-0x1, 0x8(%rsp,%rcx,4)
incq %rcx
jmp 0x1fe8ec
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rdx
movups %xmm0, 0x400(%rdx)
andq $0x0, 0x410(%rdx)
movq 0x1e0(%r14), %rdi
callq *%rax
testl %eax, %eax
je 0x1fe987
movq 0x18(%r14), %r15
callq 0x2032fb
movslq %eax, %rdi
callq *%r15
movq %rax, 0x1d0(%r14)
testq %rax, %rax
je 0x1fe991
leaq 0x8(%rsp), %rsi
movq 0x400(%rsi), %rcx
movq 0x408(%rsi), %rdx
movq %rax, %rdi
callq 0x203301
testq %rax, %rax
je 0x1fe987
movq 0x408(%rsp), %rcx
movq %rcx, 0x1d8(%r14)
movq 0x418(%rsp), %rcx
movq %rcx, 0x1e8(%r14)
movq %rax, 0x120(%r14)
xorl %ebx, %ebx
jmp 0x1fe9ab
movq 0x418(%rsp), %rax
jmp 0x1fe99c
movq 0x418(%rsp), %rax
pushq $0x1
popq %rbx
testq %rax, %rax
je 0x1fe9ab
movq 0x408(%rsp), %rdi
callq *%rax
movl %ebx, %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: poolStoreString
static XML_Char *
poolStoreString(STRING_POOL *pool, const ENCODING *enc,
                const char *ptr, const char *end)
{
  if (!poolAppend(pool, enc, ptr, end))
    return NULL;
  if (pool->ptr == pool->end && !poolGrow(pool))
    return NULL;
  *(pool->ptr)++ = 0;
  return pool->start;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1fef72
testq %rax, %rax
je 0x1fec45
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
jne 0x1fec34
movq %rbx, %rdi
callq 0x1ff0dd
testb %al, %al
je 0x1fec45
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb $0x0, (%rax)
movq 0x20(%rbx), %rax
jmp 0x1fec47
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: normalizePublicId
static void FASTCALL
normalizePublicId(XML_Char *publicId)
{
  XML_Char *p = publicId;
  XML_Char *s;
  for (s = publicId; *s; s++) {
    switch (*s) {
    case 0x20:
    case 0xD:
    case 0xA:
      if (p != publicId && p[-1] != 0x20)
        *p++ = 0x20;
      break;
    default:
      *p++ = *s;
    }
  }
  if (p != publicId && p[-1] == 0x20)
    --p;
  *p = XML_T('\0');
}

// Assembly:
movq %rdi, %rax
movq %rdi, %rcx
movzbl (%rcx), %edx
cmpl $0xa, %edx
je 0x1fec67
cmpl $0xd, %edx
je 0x1fec67
cmpl $0x20, %edx
je 0x1fec67
testl %edx, %edx
jne 0x1fec77
jmp 0x1fec87
movq %rdi, %rdx
cmpq %rdi, %rax
je 0x1fec7f
movb $0x20, %dl
cmpb $0x20, -0x1(%rax)
je 0x1fec7c
movb %dl, (%rax)
incq %rax
movq %rax, %rdx
incq %rcx
movq %rdx, %rax
jmp 0x1fec4f
cmpq %rdi, %rax
je 0x1fec98
leaq -0x1(%rax), %rdi
cmpb $0x20, -0x1(%rax)
cmovneq %rax, %rdi
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: contentProcessor
static enum XML_Error PTRCALL
contentProcessor(XML_Parser parser,
                 const char *start,
                 const char *end,
                 const char **endPtr)
{
  enum XML_Error result = doContent(parser, 0, encoding, start, end, 
                                    endPtr, (XML_Bool)!ps_finalBuffer);
  if (result == XML_ERROR_NONE) {
    if (!storeRawNames(parser))
      return XML_ERROR_NO_MEMORY;
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %r9
movq %rdx, %r8
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x120(%rdi), %rdx
xorl %eax, %eax
cmpb $0x0, 0x37c(%rdi)
sete %al
movl %eax, (%rsp)
xorl %esi, %esi
callq 0x1ff808
movl %eax, %ebp
testl %eax, %eax
jne 0x1fecdd
movq %rbx, %rdi
callq 0x2008de
testb %al, %al
jne 0x1fecdd
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: getElementType
static ELEMENT_TYPE *
getElementType(XML_Parser parser,
               const ENCODING *enc,
               const char *ptr,
               const char *end)
{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);
  ELEMENT_TYPE *ret;

  if (!name)
    return NULL;
  ret = (ELEMENT_TYPE *) lookup(&dtd->elementTypes, name, sizeof(ELEMENT_TYPE));
  if (!ret)
    return NULL;
  if (ret->name != name)
    poolDiscard(&dtd->pool);
  else {
    poolFinish(&dtd->pool);
    if (!setElementTypePrefix(parser, ret))
      return NULL;
  }
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x290(%rdi), %r12
leaq 0xa0(%r12), %rdi
callq 0x1fec0c
testq %rax, %rax
je 0x1fed5b
movq %rax, %r15
leaq 0x28(%r12), %rdi
pushq $0x28
popq %rdx
movq %rax, %rsi
callq 0x1ff2cb
testq %rax, %rax
je 0x1fed5b
movq %rax, %rbx
cmpq %r15, (%rax)
je 0x1fed3c
movq 0xc0(%r12), %rax
movq %rax, 0xb8(%r12)
jmp 0x1fed5d
movq 0xb8(%r12), %rax
movq %rax, 0xc0(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2018b6
testl %eax, %eax
jne 0x1fed5d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: poolAppend
static XML_Char *
poolAppend(STRING_POOL *pool, const ENCODING *enc,
           const char *ptr, const char *end)
{
  if (!pool->ptr && !poolGrow(pool))
    return NULL;
  for (;;) {
    XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
    if (ptr == end)
      break;
    if (!poolGrow(pool))
      return NULL;
  }
  return pool->start;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, (%rsp)
cmpq $0x0, 0x18(%rdi)
jne 0x1fef9d
movq %r14, %rdi
callq 0x1ff0dd
testb %al, %al
je 0x1fefd5
leaq 0x18(%r14), %r13
movq %rsp, %rbp
xorl %r12d, %r12d
movq 0x10(%r14), %r8
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq *0x70(%r15)
cmpq %rbx, (%rsp)
je 0x1fefcf
movq %r14, %rdi
callq 0x1ff0dd
testb %al, %al
jne 0x1fefa7
jmp 0x1fefd8
movq 0x20(%r14), %r12
jmp 0x1fefd8
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: defineAttribute
static int
defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,
                XML_Bool isId, const XML_Char *value, XML_Parser parser)
{
  DEFAULT_ATTRIBUTE *att;
  if (value || isId) {
    /* The handling of default attributes gets messed up if we have
       a default which duplicates a non-default. */
    int i;
    for (i = 0; i < type->nDefaultAtts; i++)
      if (attId == type->defaultAtts[i].id)
        return 1;
    if (isId && !type->idAtt && !attId->xmlns)
      type->idAtt = attId;
  }
  if (type->nDefaultAtts == type->allocDefaultAtts) {
    if (type->allocDefaultAtts == 0) {
      type->allocDefaultAtts = 8;
      type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(type->allocDefaultAtts
                            * sizeof(DEFAULT_ATTRIBUTE));
      if (!type->defaultAtts)
        return 0;
    }
    else {
      DEFAULT_ATTRIBUTE *temp;
      int count = type->allocDefaultAtts * 2;
      temp = (DEFAULT_ATTRIBUTE *)
        REALLOC(type->defaultAtts, (count * sizeof(DEFAULT_ATTRIBUTE)));
      if (temp == NULL)
        return 0;
      type->allocDefaultAtts = count;
      type->defaultAtts = temp;
    }
  }
  att = type->defaultAtts + type->nDefaultAtts;
  att->id = attId;
  att->value = value;
  att->isCdata = isCdata;
  if (!isCdata)
    attId->maybeTokenized = XML_TRUE;
  type->nDefaultAtts += 1;
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
testq %r8, %r8
sete %al
testl %ecx, %ecx
sete %dl
movslq 0x18(%rdi), %r13
pushq $0x1
popq %rbx
testb %al, %dl
jne 0x1ff05a
xorl %eax, %eax
testl %r13d, %r13d
movl $0x0, %edx
cmovgl %r13d, %edx
imulq $0x18, %rdx, %rdx
addq $0x18, %rdx
leaq 0x18(%rax), %rsi
cmpq %rsi, %rdx
je 0x1ff044
movq 0x20(%r14), %rdi
cmpq %r15, (%rdi,%rax)
movq %rsi, %rax
jne 0x1ff02c
jmp 0x1ff0ae
testb %cl, %cl
je 0x1ff05a
cmpq $0x0, 0x10(%r14)
jne 0x1ff05a
cmpb $0x0, 0x11(%r15)
jne 0x1ff05a
movq %r15, 0x10(%r14)
cmpl 0x1c(%r14), %r13d
jne 0x1ff083
testl %r13d, %r13d
je 0x1ff0bf
movq 0x20(%r14), %rdi
imulq $0x30, %r13, %rsi
callq *0x20(%r9)
testq %rax, %rax
je 0x1ff0d9
addl %r13d, %r13d
movl %r13d, 0x1c(%r14)
movq %rax, 0x20(%r14)
jmp 0x1ff087
movq 0x20(%r14), %rax
movslq 0x18(%r14), %rcx
imulq $0x18, %rcx, %rdx
movq %r15, (%rax,%rdx)
movq %r12, 0x10(%rax,%rdx)
movb %bpl, 0x8(%rax,%rdx)
testb %bpl, %bpl
jne 0x1ff0a7
movb $0x1, 0x10(%r15)
leal 0x1(%rcx), %eax
movl %eax, 0x18(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, 0x1c(%r14)
movl $0xc0, %edi
callq *0x18(%r9)
movq %rax, 0x20(%r14)
testq %rax, %rax
jne 0x1ff087
xorl %ebx, %ebx
jmp 0x1ff0ae
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: storeAttributeValue
static enum XML_Error
storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
                    const char *ptr, const char *end,
                    STRING_POOL *pool)
{
  enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr,
                                               end, pool);
  if (result)
    return result;
  if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
    poolChop(pool);
  if (!poolAppendChar(pool, XML_T('\0')))
    return XML_ERROR_NO_MEMORY;
  return XML_ERROR_NONE;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %edx, %ebp
callq 0x201cb8
testl %eax, %eax
jne 0x1ff2aa
movq 0x18(%rbx), %rax
testb %bpl, %bpl
je 0x1ff2b1
cmpq 0x10(%rbx), %rax
jne 0x1ff29d
movq %rbx, %rdi
callq 0x1ff0dd
testb %al, %al
je 0x1ff2c6
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb $0x0, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpq 0x20(%rbx), %rax
je 0x1ff287
cmpb $0x20, -0x1(%rax)
jne 0x1ff287
decq %rax
movq %rax, 0x18(%rbx)
jmp 0x1ff287
pushq $0x1
popq %rax
jmp 0x1ff2aa
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: nextScaffoldPart
static int FASTCALL
nextScaffoldPart(XML_Parser parser)
{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  CONTENT_SCAFFOLD * me;
  int next;

  if (!dtd->scaffIndex) {
    dtd->scaffIndex = (int *)MALLOC(groupSize * sizeof(int));
    if (!dtd->scaffIndex)
      return -1;
    dtd->scaffIndex[0] = 0;
  }

  if (dtd->scaffCount >= dtd->scaffSize) {
    CONTENT_SCAFFOLD *temp;
    if (dtd->scaffold) {
      temp = (CONTENT_SCAFFOLD *)
        REALLOC(dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
      if (temp == NULL)
        return -1;
      dtd->scaffSize *= 2;
    }
    else {
      temp = (CONTENT_SCAFFOLD *)MALLOC(INIT_SCAFFOLD_ELEMENTS
                                        * sizeof(CONTENT_SCAFFOLD));
      if (temp == NULL)
        return -1;
      dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;
    }
    dtd->scaffold = temp;
  }
  next = dtd->scaffCount++;
  me = &dtd->scaffold[next];
  if (dtd->scaffLevel) {
    CONTENT_SCAFFOLD *parent = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel-1]];
    if (parent->lastchild) {
      dtd->scaffold[parent->lastchild].nextsib = next;
    }
    if (!parent->childcnt)
      parent->firstchild = next;
    parent->lastchild = next;
    parent->childcnt++;
  }
  me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;
  return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x290(%rdi), %r15
cmpq $0x0, 0x138(%r15)
pushq $-0x1
popq %rbx
jne 0x1ff5bd
movl 0x368(%r14), %edi
shlq $0x2, %rdi
callq *0x18(%r14)
movq %rax, 0x138(%r15)
testq %rax, %rax
je 0x1ff683
andl $0x0, (%rax)
movl 0x130(%r15), %ecx
movl 0x12c(%r15), %esi
movq 0x120(%r15), %rax
cmpl %esi, %ecx
jae 0x1ff5da
movl %ecx, %ebx
jmp 0x1ff626
testq %rax, %rax
je 0x1ff600
addl %esi, %esi
shlq $0x5, %rsi
movq %rax, %rdi
callq *0x20(%r14)
testq %rax, %rax
je 0x1ff683
movl 0x12c(%r15), %ecx
addl %ecx, %ecx
jmp 0x1ff611
movl $0x400, %edi            # imm = 0x400
callq *0x18(%r14)
testq %rax, %rax
je 0x1ff683
pushq $0x20
popq %rcx
movl %ecx, 0x12c(%r15)
movq %rax, 0x120(%r15)
movl 0x130(%r15), %ebx
leal 0x1(%rbx), %ecx
movl %ecx, 0x130(%r15)
movslq %ebx, %rcx
movslq 0x134(%r15), %rdx
testq %rdx, %rdx
je 0x1ff677
movq 0x138(%r15), %rsi
movslq -0x4(%rsi,%rdx,4), %rsi
shlq $0x5, %rsi
leaq (%rax,%rsi), %rdx
movslq 0x14(%rax,%rsi), %rsi
testq %rsi, %rsi
je 0x1ff665
shlq $0x5, %rsi
movl %ebx, 0x1c(%rax,%rsi)
movl 0x18(%rdx), %esi
testl %esi, %esi
jne 0x1ff66f
movl %ebx, 0x10(%rdx)
movl %ebx, 0x14(%rdx)
incl %esi
movl %esi, 0x18(%rdx)
shlq $0x5, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%rcx)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: reportProcessingInstruction
static int
reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
                            const char *start, const char *end)
{
  const XML_Char *target;
  XML_Char *data;
  const char *tem;
  if (!processingInstructionHandler) {
    if (defaultHandler)
      reportDefault(parser, enc, start, end);
    return 1;
  }
  start += enc->minBytesPerChar * 2;
  tem = start + XmlNameLength(enc, start);
  target = poolStoreString(&tempPool, enc, start, tem);
  if (!target)
    return 0;
  poolFinish(&tempPool);
  data = poolStoreString(&tempPool, enc,
                        XmlSkipS(enc, tem),
                        end - enc->minBytesPerChar*2);
  if (!data)
    return 0;
  normalizeLines(data);
  processingInstructionHandler(handlerArg, target, data);
  poolClear(&tempPool);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %rbx
cmpq $0x0, 0x80(%rdi)
je 0x1ff757
movslq 0x80(%r12), %rax
leaq (%rdx,%rax,2), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq *0x38(%r12)
movslq %eax, %r13
addq %rbp, %r13
leaq 0x300(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x1fec0c
xorl %ebp, %ebp
testq %rax, %rax
je 0x1ff772
movq %rax, (%rsp)
movq 0x318(%rbx), %rax
movq %rax, 0x320(%rbx)
movq %r12, %rdi
movq %r13, %rsi
callq *0x40(%r12)
movslq 0x80(%r12), %rcx
addq %rcx, %rcx
subq %rcx, %r14
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x1fec0c
testq %rax, %rax
je 0x1ff772
movq %rax, %r14
movq %rax, %rdi
callq 0x202177
movq 0x8(%rbx), %rdi
movq (%rsp), %rsi
movq %r14, %rdx
callq *0x80(%rbx)
movq %r15, %rdi
callq 0x1fbde4
pushq $0x1
popq %rbp
jmp 0x1ff772
pushq $0x1
popq %rbp
cmpq $0x0, 0xa0(%rbx)
je 0x1ff772
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x1fd08b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: reportComment
static int
reportComment(XML_Parser parser, const ENCODING *enc,
              const char *start, const char *end)
{
  XML_Char *data;
  if (!commentHandler) {
    if (defaultHandler)
      reportDefault(parser, enc, start, end);
    return 1;
  }
  data = poolStoreString(&tempPool,
                         enc,
                         start + enc->minBytesPerChar * 4,
                         end - enc->minBytesPerChar * 3);
  if (!data)
    return 0;
  normalizeLines(data);
  commentHandler(handlerArg, data);
  poolClear(&tempPool);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x88(%rdi)
je 0x1ff7e2
leaq 0x300(%rbx), %r14
movslq 0x80(%rsi), %rax
leaq (%rdx,%rax,4), %rdx
leaq (%rax,%rax,2), %rax
subq %rax, %rcx
movq %r14, %rdi
callq 0x1fec0c
testq %rax, %rax
je 0x1ff7f9
movq %rax, %r15
movq %rax, %rdi
callq 0x202177
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq *0x88(%rbx)
movq %r14, %rdi
callq 0x1fbde4
pushq $0x1
popq %rbp
jmp 0x1ff7fb
pushq $0x1
popq %rbp
cmpq $0x0, 0xa0(%rbx)
je 0x1ff7fb
movq %rbx, %rdi
callq 0x1fd08b
jmp 0x1ff7fb
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: storeRawNames
static XML_Bool
storeRawNames(XML_Parser parser)
{
  TAG *tag = tagStack;
  while (tag) {
    int bufSize;
    int nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);
    char *rawNameBuf = tag->buf + nameLen;
    /* Stop if already stored.  Since tagStack is a stack, we can stop
       at the first entry that has already been copied; everything
       below it in the stack is already been accounted for in a
       previous call to this function.
    */
    if (tag->rawName == rawNameBuf)
      break;
    /* For re-use purposes we need to ensure that the
       size of tag->buf is a multiple of sizeof(XML_Char).
    */
    bufSize = nameLen + ROUND_UP(tag->rawNameLength, sizeof(XML_Char));
    if (bufSize > tag->bufEnd - tag->buf) {
      char *temp = (char *)REALLOC(tag->buf, bufSize);
      if (temp == NULL)
        return XML_FALSE;
      /* if tag->name.str points to tag->buf (only when namespace
         processing is off) then we have to update it
      */
      if (tag->name.str == (XML_Char *)tag->buf)
        tag->name.str = (XML_Char *)temp;
      /* if tag->name.localPart is set (when namespace processing is on)
         then update it as well, since it will always point into tag->buf
      */
      if (tag->name.localPart)
        tag->name.localPart = (XML_Char *)temp + (tag->name.localPart -
                                                  (XML_Char *)tag->buf);
      tag->buf = temp;
      tag->bufEnd = temp + bufSize;
      rawNameBuf = temp + nameLen;
    }
    memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);
    tag->rawName = rawNameBuf;
    tag = tag->parent;
  }
  return XML_TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x2a0(%rdi), %r12
movq (%r12), %r12
movb $0x1, %al
testq %r12, %r12
je 0x2009a0
movslq 0x30(%r12), %r13
movq 0x8(%r12), %rsi
movq 0x40(%r12), %rdi
leaq (%rdi,%r13), %r15
incq %r15
cmpq %r15, %rsi
je 0x2009a0
incq %r13
movl 0x10(%r12), %eax
leal (%rax,%r13), %ecx
movslq %ecx, %r14
movq 0x48(%r12), %rcx
subq %rdi, %rcx
cmpq %r14, %rcx
jge 0x200989
movq %r14, %rsi
callq *0x20(%rbx)
testq %rax, %rax
je 0x20099e
movq 0x40(%r12), %rcx
cmpq %rcx, 0x18(%r12)
jne 0x200957
movq %rax, 0x18(%r12)
movq 0x20(%r12), %rdx
testq %rdx, %rdx
je 0x20096c
subq %rcx, %rdx
addq %rax, %rdx
movq %rdx, 0x20(%r12)
movq %rax, 0x40(%r12)
addq %rax, %r14
movq %r14, 0x48(%r12)
addq %rax, %r13
movq 0x8(%r12), %rsi
movl 0x10(%r12), %eax
movq %r13, %r15
movslq %eax, %rdx
movq %r15, %rdi
callq 0x17630
movq %r15, 0x8(%r12)
jmp 0x2008f1
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: cdataSectionProcessor
static enum XML_Error PTRCALL
cdataSectionProcessor(XML_Parser parser,
                      const char *start,
                      const char *end,
                      const char **endPtr)
{
  enum XML_Error result = doCdataSection(parser, encoding, &start, end,
                                         endPtr, (XML_Bool)!ps_finalBuffer);
  if (result != XML_ERROR_NONE)
    return result;
  if (start) {
    if (parentParser) {  /* we are parsing an external entity */
      processor = externalEntityContentProcessor;
      return externalEntityContentProcessor(parser, start, end, endPtr);
    }
    else {
      processor = contentProcessor;
      return contentProcessor(parser, start, end, endPtr);
    }
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x120(%rdi), %rsi
xorl %r9d, %r9d
cmpb $0x0, 0x37c(%rdi)
sete %r9b
movq %r14, %rcx
movq %rbx, %r8
callq 0x2014bc
testl %eax, %eax
je 0x201730
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x201769
cmpq $0x0, 0x370(%r15)
je 0x20176d
leaq 0x51a(%rip), %rax       # 0x201c65
movq %rax, 0x200(%r15)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x201c65
xorl %eax, %eax
jmp 0x201726
leaq -0x2ad8(%rip), %rax     # 0x1fec9c
movq %rax, 0x200(%r15)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1fec9c
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: setElementTypePrefix
static int
setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType)
{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  const XML_Char *name;
  for (name = elementType->name; *name; name++) {
    if (*name == XML_T(ASCII_COLON)) {
      PREFIX *prefix;
      const XML_Char *s;
      for (s = elementType->name; s != name; s++) {
        if (!poolAppendChar(&dtd->pool, *s))
          return 0;
      }
      if (!poolAppendChar(&dtd->pool, XML_T('\0')))
        return 0;
      prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),
                                sizeof(PREFIX));
      if (!prefix)
        return 0;
      if (prefix->name == poolStart(&dtd->pool))
        poolFinish(&dtd->pool);
      else
        poolDiscard(&dtd->pool);
      elementType->prefix = prefix;

    }
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x290(%rdi), %rbp
movq (%rsi), %r13
leaq 0xa0(%rbp), %r15
leaq 0x78(%rbp), %r12
movzbl (%r13), %eax
cmpl $0x3a, %eax
je 0x2018f0
testl %eax, %eax
jne 0x20199a
jmp 0x2019b3
movq (%r14), %rbx
movq 0xb0(%rbp), %rcx
movq 0xb8(%rbp), %rax
cmpq %r13, %rbx
je 0x201936
cmpq %rcx, %rax
jne 0x201922
movq %r15, %rdi
callq 0x1ff0dd
testb %al, %al
je 0x2019a2
movq 0xb8(%rbp), %rax
movb (%rbx), %cl
leaq 0x1(%rax), %rdx
movq %rdx, 0xb8(%rbp)
movb %cl, (%rax)
incq %rbx
jmp 0x2018f3
cmpq %rcx, %rax
jne 0x20194e
movq %r15, %rdi
callq 0x1ff0dd
testb %al, %al
je 0x2019a2
movq 0xb8(%rbp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xb8(%rbp)
movb $0x0, (%rax)
movq 0xc0(%rbp), %rsi
movq %r12, %rdi
pushq $0x10
popq %rdx
callq 0x1ff2cb
testq %rax, %rax
je 0x2019a2
movq 0xc0(%rbp), %rcx
cmpq %rcx, (%rax)
je 0x201988
movq %rcx, 0xb8(%rbp)
jmp 0x201996
movq 0xb8(%rbp), %rcx
movq %rcx, 0xc0(%rbp)
movq %rax, 0x8(%r14)
incq %r13
jmp 0x2018d9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rax
jmp 0x2019a4
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: externalEntityContentProcessor
static enum XML_Error PTRCALL
externalEntityContentProcessor(XML_Parser parser,
                               const char *start,
                               const char *end,
                               const char **endPtr)
{
  enum XML_Error result = doContent(parser, 1, encoding, start, end, 
                                    endPtr, (XML_Bool)!ps_finalBuffer);
  if (result == XML_ERROR_NONE) {
    if (!storeRawNames(parser))
      return XML_ERROR_NO_MEMORY;
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r9
movq %rdx, %r8
movq %rsi, %rcx
movq %rdi, %r14
movq 0x120(%rdi), %rdx
xorl %eax, %eax
cmpb $0x0, 0x37c(%rdi)
sete %al
movl %eax, (%rsp)
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x1ff808
movl %eax, %ebp
testl %eax, %eax
jne 0x201cab
movq %r14, %rdi
callq 0x2008de
testb %al, %al
je 0x201cad
movl %ebp, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: hash
static unsigned long FASTCALL
hash(KEY s)
{
  unsigned long h = 0;
  while (*s)
    h = CHAR_HASH(h, *s++);
  return h;
}

// Assembly:
xorl %eax, %eax
movzbl (%rdi), %ecx
testq %rcx, %rcx
je 0x202080
imulq $0xf4243, %rax, %rax    # imm = 0xF4243
incq %rdi
xorq %rcx, %rax
jmp 0x202069
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: build_node
static void
build_node(XML_Parser parser,
           int src_node,
           XML_Content *dest,
           XML_Content **contpos,
           XML_Char **strpos)
{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  dest->type = dtd->scaffold[src_node].type;
  dest->quant = dtd->scaffold[src_node].quant;
  if (dest->type == XML_CTYPE_NAME) {
    const XML_Char *src;
    dest->name = *strpos;
    src = dtd->scaffold[src_node].name;
    for (;;) {
      *(*strpos)++ = *src;
      if (!*src)
        break;
      src++;
    }
    dest->numchildren = 0;
    dest->children = NULL;
  }
  else {
    unsigned int i;
    int cn;
    dest->numchildren = dtd->scaffold[src_node].childcnt;
    dest->children = *contpos;
    *contpos += dest->numchildren;
    for (i = 0, cn = dtd->scaffold[src_node].firstchild;
         i < dest->numchildren;
         i++, cn = dtd->scaffold[cn].nextsib) {
      build_node(parser, cn, &(dest->children[i]), contpos, strpos);
    }
    dest->name = NULL;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rdx, %rbx
movq %rdi, 0x10(%rsp)
movq 0x290(%rdi), %rbp
movq 0x120(%rbp), %rax
movslq %esi, %rdi
shlq $0x5, %rdi
movq (%rax,%rdi), %rdx
movq %rdx, (%rbx)
cmpl $0x4, %edx
jne 0x2020e6
movq (%r14), %rdx
movq %rdx, 0x8(%rbx)
movq 0x8(%rax,%rdi), %rax
movb (%rax), %cl
movq (%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, (%r14)
movb %cl, (%rdx)
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x2020c7
andl $0x0, 0x10(%rbx)
pushq $0x18
jmp 0x202162
movl 0x18(%rax,%rdi), %eax
movl %eax, 0x10(%rbx)
movq (%rcx), %rdx
movq %rdx, 0x18(%rbx)
movq %rax, %rsi
shlq $0x5, %rsi
addq %rdx, %rsi
movq %rcx, 0x8(%rsp)
movq %rsi, (%rcx)
movq 0x120(%rbp), %rdx
leaq (%rdx,%rdi), %rcx
addq $0x10, %rcx
xorl %r15d, %r15d
xorl %r12d, %r12d
movl %eax, %eax
cmpq %rax, %r12
jae 0x202160
movslq (%rcx), %r13
movq 0x18(%rbx), %rdx
addq %r15, %rdx
movq 0x10(%rsp), %rdi
movl %r13d, %esi
movq 0x8(%rsp), %rcx
movq %r14, %r8
callq 0x202081
incq %r12
movq 0x120(%rbp), %rax
shlq $0x5, %r13
leaq (%rax,%r13), %rcx
addq $0x1c, %rcx
movl 0x10(%rbx), %eax
addq $0x20, %r15
jmp 0x20211b
pushq $0x8
popq %rax
andq $0x0, (%rbx,%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: normalizeLines
static void FASTCALL
normalizeLines(XML_Char *s)
{
  XML_Char *p;
  for (;; s++) {
    if (*s == XML_T('\0'))
      return;
    if (*s == 0xD)
      break;
  }
  p = s;
  do {
    if (*s == 0xD) {
      *p++ = 0xA;
      if (*++s == 0xA)
        s++;
    }
    else
      *p++ = *s++;
  } while (*s);
  *p = XML_T('\0');
}

// Assembly:
movzbl (%rdi), %ecx
testl %ecx, %ecx
je 0x2021b5
cmpl $0xd, %ecx
je 0x202188
incq %rdi
jmp 0x202177
movq %rdi, %rax
cmpb $0xd, %cl
jne 0x20219e
movb $0xa, (%rax)
cmpb $0xa, 0x1(%rdi)
je 0x2021a5
incq %rdi
jmp 0x2021a9
incq %rdi
movb %cl, (%rax)
jmp 0x2021a9
addq $0x2, %rdi
incq %rax
movb (%rdi), %cl
testb %cl, %cl
jne 0x20218b
movb $0x0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: externalEntityInitProcessor2
static enum XML_Error PTRCALL
externalEntityInitProcessor2(XML_Parser parser,
                             const char *start,
                             const char *end,
                             const char **endPtr)
{
  const char *next = start; /* XmlContentTok doesn't always set the last arg */
  int tok = XmlContentTok(encoding, start, end, &next);
  switch (tok) {
  case XML_TOK_BOM:
    /* If we are at the end of the buffer, this would cause the next stage,
       i.e. externalEntityInitProcessor3, to pass control directly to
       doContent (by detecting XML_TOK_NONE) without processing any xml text
       declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.
    */
    if (next == end && !ps_finalBuffer) {
      *endPtr = next;
      return XML_ERROR_NONE;
    }
    start = next;
    break;
  case XML_TOK_PARTIAL:
    if (!ps_finalBuffer) {
      *endPtr = start;
      return XML_ERROR_NONE;
    }
    eventPtr = start;
    return XML_ERROR_UNCLOSED_TOKEN;
  case XML_TOK_PARTIAL_CHAR:
    if (!ps_finalBuffer) {
      *endPtr = start;
      return XML_ERROR_NONE;
    }
    eventPtr = start;
    return XML_ERROR_PARTIAL_CHAR;
  }
  processor = externalEntityInitProcessor3;
  return externalEntityInitProcessor3(parser, start, end, endPtr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rcx
movq %rsi, (%rcx)
movq 0x120(%rdi), %rdi
callq *0x8(%rdi)
cmpl $-0x2, %eax
je 0x202232
cmpl $-0x1, %eax
je 0x20221d
cmpl $0xe, %eax
jne 0x2021fc
movq (%rsp), %r14
cmpq %r12, %r14
jne 0x2021fc
cmpb $0x0, 0x37c(%r15)
je 0x202248
leaq 0x56(%rip), %rax        # 0x202259
movq %rax, 0x200(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x202259
jmp 0x20224d
cmpb $0x0, 0x37c(%r15)
je 0x202248
movq %r14, 0x210(%r15)
pushq $0x5
jmp 0x202245
cmpb $0x0, 0x37c(%r15)
je 0x202248
movq %r14, 0x210(%r15)
pushq $0x6
popq %rax
jmp 0x20224d
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: externalEntityInitProcessor3
static enum XML_Error PTRCALL
externalEntityInitProcessor3(XML_Parser parser,
                             const char *start,
                             const char *end,
                             const char **endPtr)
{
  int tok;
  const char *next = start; /* XmlContentTok doesn't always set the last arg */
  eventPtr = start;
  tok = XmlContentTok(encoding, start, end, &next);
  eventEndPtr = next;

  switch (tok) {
  case XML_TOK_XML_DECL:
    {
      enum XML_Error result;
      result = processXmlDecl(parser, 1, start, next);
      if (result != XML_ERROR_NONE)
        return result;
      switch (ps_parsing) {
      case XML_SUSPENDED: 
        *endPtr = next;
        return XML_ERROR_NONE;
      case XML_FINISHED:
        return XML_ERROR_ABORTED;
      default:
        start = next;
      }
    }
    break;
  case XML_TOK_PARTIAL:
    if (!ps_finalBuffer) {
      *endPtr = start;
      return XML_ERROR_NONE;
    }
    return XML_ERROR_UNCLOSED_TOKEN;
  case XML_TOK_PARTIAL_CHAR:
    if (!ps_finalBuffer) {
      *endPtr = start;
      return XML_ERROR_NONE;
    }
    return XML_ERROR_PARTIAL_CHAR;
  }
  processor = externalEntityContentProcessor;
  tagLevel = 1;
  return externalEntityContentProcessor(parser, start, end, endPtr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x8(%rsp), %r13
movq %rsi, (%r13)
movq %rsi, 0x210(%rdi)
movq 0x120(%rdi), %rdi
movq %r13, %rcx
callq *0x8(%rdi)
movq (%r13), %rcx
movq %rcx, 0x218(%r15)
cmpl $-0x2, %eax
je 0x2022e4
cmpl $-0x1, %eax
je 0x2022d6
cmpl $0xc, %eax
jne 0x202303
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x1fe9ba
testl %eax, %eax
jne 0x20232d
movl 0x378(%r15), %eax
cmpl $0x2, %eax
je 0x2022fa
cmpl $0x3, %eax
jne 0x2022fe
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
jmp 0x2022f6
cmpb $0x0, 0x37c(%r15)
je 0x2022f3
pushq $0x5
jmp 0x2022f0
cmpb $0x0, 0x37c(%r15)
je 0x2022f3
pushq $0x6
popq %rax
jmp 0x20232d
movq %r12, (%rbx)
xorl %eax, %eax
jmp 0x20232d
pushq $0x23
jmp 0x2022f0
movq 0x8(%rsp), %r12
leaq -0x6a5(%rip), %rax      # 0x201c65
movq %rax, 0x200(%r15)
movl $0x1, 0x23c(%r15)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x201c65
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: hashTableClear
static void FASTCALL
hashTableClear(HASH_TABLE *table)
{
  size_t i;
  for (i = 0; i < table->size; i++) {
    table->mem->free_fcn(table->v[i]);
    table->v[i] = NULL;
  }
  table->used = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq 0x10(%rbx), %r14
jae 0x202366
movq (%rbx), %rax
movq 0x20(%rbx), %rcx
movq (%rax,%r14,8), %rdi
callq *0x10(%rcx)
movq (%rbx), %rax
andq $0x0, (%rax,%r14,8)
incq %r14
jmp 0x202345
andq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: hashTableDestroy
static void FASTCALL
hashTableDestroy(HASH_TABLE *table)
{
  size_t i;
  for (i = 0; i < table->size; i++)
    table->mem->free_fcn(table->v[i]);
  table->mem->free_fcn(table->v);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rbx), %r14
jae 0x202399
movq (%rdi,%r14,8), %rdi
callq *%rax
incq %r14
jmp 0x20237d
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: prolog0
static int PTRCALL
prolog0(PROLOG_STATE *state,
        int tok,
        const char *ptr,
        const char *end,
        const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    state->handler = prolog1;
    return XML_ROLE_NONE;
  case XML_TOK_XML_DECL:
    state->handler = prolog1;
    return XML_ROLE_XML_DECL;
  case XML_TOK_PI:
    state->handler = prolog1;
    return XML_ROLE_PI;
  case XML_TOK_COMMENT:
    state->handler = prolog1;
    return XML_ROLE_COMMENT;
  case XML_TOK_BOM:
    return XML_ROLE_NONE;
  case XML_TOK_DECL_OPEN:
    if (!XmlNameMatchesAscii(enc,
                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
                             end,
                             KW_DOCTYPE))
      break;
    state->handler = doctype0;
    return XML_ROLE_DOCTYPE_NONE;
  case XML_TOK_INSTANCE_START:
    state->handler = error;
    return XML_ROLE_INSTANCE_START;
  }
  return common(state, tok);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leal -0xb(%rsi), %edi
cmpl $0x5, %edi
ja 0x2023d8
xorl %eax, %eax
leaq 0x64(%rip), %rsi        # 0x202428
leaq 0x169675(%rip), %r9     # 0x36ba40
movslq (%r9,%rdi,4), %rdi
addq %r9, %rdi
jmpq *%rdi
pushq $0x37
jmp 0x2023e7
cmpl $0x1d, %esi
jne 0x202419
pushq $0x2
jmp 0x20241b
pushq $0x38
jmp 0x2023e7
pushq $0x1
popq %rax
jmp 0x202423
movslq 0x80(%r8), %rax
leaq (%rdx,%rax,2), %rsi
leaq 0x169728(%rip), %rax    # 0x36bb24
movq %r8, %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq *0x30(%r8)
testl %eax, %eax
je 0x202419
pushq $0x3
popq %rax
leaq 0x8c(%rip), %rsi        # 0x2024a3
jmp 0x202423
pushq $-0x1
popq %rax
leaq 0xab(%rip), %rsi        # 0x2024ce
movq %rsi, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: prolog1
static int PTRCALL
prolog1(PROLOG_STATE *state,
        int tok,
        const char *ptr,
        const char *end,
        const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_NONE;
  case XML_TOK_PI:
    return XML_ROLE_PI;
  case XML_TOK_COMMENT:
    return XML_ROLE_COMMENT;
  case XML_TOK_BOM:
    return XML_ROLE_NONE;
  case XML_TOK_DECL_OPEN:
    if (!XmlNameMatchesAscii(enc,
                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
                             end,
                             KW_DOCTYPE))
      break;
    state->handler = doctype0;
    return XML_ROLE_DOCTYPE_NONE;
  case XML_TOK_INSTANCE_START:
    state->handler = error;
    return XML_ROLE_INSTANCE_START;
  }
  return common(state, tok);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leal -0xb(%rsi), %eax
cmpl $0x5, %eax
ja 0x202448
leaq 0x16961d(%rip), %rsi    # 0x36ba58
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
xorl %eax, %eax
jmp 0x2024a1
cmpl $0x1d, %esi
jne 0x202490
leaq 0x7a(%rip), %rax        # 0x2024ce
movq %rax, (%rbx)
pushq $0x2
jmp 0x2024a0
pushq $0x37
jmp 0x2024a0
movslq 0x80(%r8), %rax
leaq (%rdx,%rax,2), %rsi
leaq 0x1696b3(%rip), %rax    # 0x36bb24
movq %r8, %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq *0x30(%r8)
testl %eax, %eax
je 0x202490
leaq 0x1a(%rip), %rax        # 0x2024a3
movq %rax, (%rbx)
pushq $0x3
jmp 0x2024a0
leaq 0x37(%rip), %rax        # 0x2024ce
movq %rax, (%rbx)
pushq $-0x1
jmp 0x2024a0
pushq $0x38
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: doctype1
static int PTRCALL
doctype1(PROLOG_STATE *state,
         int tok,
         const char *ptr,
         const char *end,
         const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_DOCTYPE_NONE;
  case XML_TOK_OPEN_BRACKET:
    state->handler = internalSubset;
    return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
  case XML_TOK_DECL_CLOSE:
    state->handler = prolog2;
    return XML_ROLE_DOCTYPE_CLOSE;
  case XML_TOK_NAME:
    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
      state->handler = doctype3;
      return XML_ROLE_DOCTYPE_NONE;
    }
    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
      state->handler = doctype2;
      return XML_ROLE_DOCTYPE_NONE;
    }
    break;
  }
  return common(state, tok);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0xf, %esi
je 0x202535
movq %rdi, %rbx
cmpl $0x19, %esi
je 0x2024fc
cmpl $0x12, %esi
je 0x202508
cmpl $0x11, %esi
jne 0x20255b
pushq $0x8
popq %rbp
leaq 0x1b8(%rip), %rax       # 0x2026b2
jmp 0x202565
pushq $0x7
popq %rbp
leaq 0x6d(%rip), %rax        # 0x202573
jmp 0x202565
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
leaq 0x169614(%rip), %rcx    # 0x36bb2c
movq %r8, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq *0x30(%r8)
pushq $0x3
popq %rbp
testl %eax, %eax
je 0x20253a
leaq 0x1c0(%rip), %rax       # 0x2026f3
jmp 0x202565
pushq $0x3
popq %rbp
jmp 0x202568
leaq 0x1695f2(%rip), %rcx    # 0x36bb33
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x20255b
leaq 0x1c2(%rip), %rax       # 0x20271b
jmp 0x202565
pushq $-0x1
popq %rbp
leaq -0x97(%rip), %rax       # 0x2024ce
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: prolog2
static int PTRCALL
prolog2(PROLOG_STATE *state,
        int tok,
        __attribute__ ((unused)) const char *ptr,
        __attribute__ ((unused)) const char *end,
        __attribute__ ((unused)) const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_NONE;
  case XML_TOK_PI:
    return XML_ROLE_PI;
  case XML_TOK_COMMENT:
    return XML_ROLE_COMMENT;
  case XML_TOK_INSTANCE_START:
    state->handler = error;
    return XML_ROLE_INSTANCE_START;
  }
  return common(state, tok);
}

// Assembly:
addl $-0xb, %esi
rorl %esi
cmpl $0x9, %esi
ja 0x2026e5
leaq 0x1693c5(%rip), %rax    # 0x36ba88
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
pushq $0x37
jmp 0x2026f1
xorl %eax, %eax
retq
pushq $0x38
jmp 0x2026f1
leaq -0x210(%rip), %rax      # 0x2024ce
movq %rax, (%rdi)
pushq $0x2
jmp 0x2026f1
leaq -0x21e(%rip), %rax      # 0x2024ce
movq %rax, (%rdi)
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: entity2
static int PTRCALL
entity2(PROLOG_STATE *state,
        int tok,
        const char *ptr,
        const char *end,
        const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ENTITY_NONE;
  case XML_TOK_NAME:
    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
      state->handler = entity4;
      return XML_ROLE_ENTITY_NONE;
    }
    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
      state->handler = entity3;
      return XML_ROLE_ENTITY_NONE;
    }
    break;
  case XML_TOK_LITERAL:
    state->handler = declClose;
    state->role_none = XML_ROLE_ENTITY_NONE;
    return XML_ROLE_ENTITY_VALUE;
  }
  return common(state, tok);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq $0xb
popq %rbx
cmpl $0xf, %esi
je 0x2028d4
movq %rdi, %r14
cmpl $0x1b, %esi
je 0x20288d
cmpl $0x12, %esi
jne 0x2028c7
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
leaq 0x1692b9(%rip), %rcx    # 0x36bb2c
movq %r8, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq *0x30(%r8)
testl %eax, %eax
je 0x2028a3
leaq 0x18e(%rip), %rax       # 0x202a19
jmp 0x2028c2
leaq 0x137(%rip), %rax       # 0x2029cb
movq %rax, (%r14)
movl $0xb, 0xc(%r14)
pushq $0xc
jmp 0x2028d3
leaq 0x169289(%rip), %rcx    # 0x36bb33
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x30(%r15)
testl %eax, %eax
je 0x2028c7
leaq 0x17f(%rip), %rax       # 0x202a41
movq %rax, (%r14)
jmp 0x2028d4
leaq -0x400(%rip), %rax      # 0x2024ce
movq %rax, (%r14)
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: entity7
static int PTRCALL
entity7(PROLOG_STATE *state,
        int tok,
        const char *ptr,
        const char *end,
        const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ENTITY_NONE;
  case XML_TOK_NAME:
    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
      state->handler = entity9;
      return XML_ROLE_ENTITY_NONE;
    }
    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
      state->handler = entity8;
      return XML_ROLE_ENTITY_NONE;
    }
    break;
  case XML_TOK_LITERAL:
    state->handler = declClose;
    state->role_none = XML_ROLE_ENTITY_NONE;
    return XML_ROLE_ENTITY_VALUE;
  }
  return common(state, tok);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq $0xb
popq %rbx
cmpl $0xf, %esi
je 0x20296f
movq %rdi, %r14
cmpl $0x1b, %esi
je 0x202928
cmpl $0x12, %esi
jne 0x202962
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
leaq 0x16921e(%rip), %rcx    # 0x36bb2c
movq %r8, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq *0x30(%r8)
testl %eax, %eax
je 0x20293e
leaq 0x55(%rip), %rax        # 0x20297b
jmp 0x20295d
leaq 0x9c(%rip), %rax        # 0x2029cb
movq %rax, (%r14)
movl $0xb, 0xc(%r14)
pushq $0xc
jmp 0x20296e
leaq 0x1691ee(%rip), %rcx    # 0x36bb33
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x30(%r15)
testl %eax, %eax
je 0x202962
leaq 0x46(%rip), %rax        # 0x2029a3
movq %rax, (%r14)
jmp 0x20296f
leaq -0x49b(%rip), %rax      # 0x2024ce
movq %rax, (%r14)
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: entity6
static int PTRCALL
entity6(PROLOG_STATE *state,
        int tok,
        __attribute__ ((unused)) const char *ptr,
        __attribute__ ((unused)) const char *end,
        __attribute__ ((unused)) const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ENTITY_NONE;
  case XML_TOK_NAME:
    state->handler = declClose;
    state->role_none = XML_ROLE_ENTITY_NONE;
    return XML_ROLE_ENTITY_NOTATION_NAME;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0xf, %esi
je 0x202ae1
cmpl $0x12, %esi
jne 0x202ae5
leaq -0x108(%rip), %rax      # 0x2029cb
movq %rax, (%rdi)
movl $0xb, 0xc(%rdi)
pushq $0x10
jmp 0x202af1
pushq $0xb
jmp 0x202af1
leaq -0x61e(%rip), %rax      # 0x2024ce
movq %rax, (%rdi)
pushq $-0x1
popq %rax
retq