LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
movb (%rcx), %dl
movzbl %dl, %esi
cmpl $0xc, %esi
jle 0x24f34d
cmpl $0x20, %esi
je 0x24f352
cmpl $0xd, %esi
je 0x24f352
jmp 0x24f368
cmpl $0xa, %esi
jne 0x24f364
movq %rdi, %rdx
cmpq %rdi, %rax
je 0x24f370
movb $0x20, %dl
cmpb $0x20, -0x1(%rax)
jne 0x24f368
jmp 0x24f36d
testl %esi, %esi
je 0x24f378
movb %dl, (%rax)
incq %rax
movq %rax, %rdx
incq %rcx
movq %rdx, %rax
jmp 0x24f337
cmpq %rdi, %rax
je 0x24f389
leaq -0x1(%rax), %rdi
cmpb $0x20, -0x1(%rax)
cmovneq %rax, %rdi
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25001c
movl %eax, %ebp
testl %eax, %eax
jne 0x24f3d0
movq %rbx, %rdi
callq 0x250cd9
testb %al, %al
jne 0x24f3d0
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24f2f4
testq %rax, %rax
je 0x24f454
movq %rax, %r15
leaq 0x28(%r12), %rdi
movl $0x28, %edx
movq %rax, %rsi
callq 0x24f9cf
testq %rax, %rax
je 0x24f454
movq %rax, %rbx
cmpq %r15, (%rax)
je 0x24f431
movq 0xc0(%r12), %rax
movq %rax, 0xb8(%r12)
jmp 0x24f456
movq 0xb8(%r12), %rax
movq %rax, 0xc0(%r12)
movq 0x290(%r14), %rdi
movq %rbx, %rsi
callq 0x252263
testl %eax, %eax
jne 0x24f456
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24f6a8
movq %r14, %rdi
callq 0x24f7dc
testb %al, %al
je 0x24f6e0
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 0x24f6da
movq %r14, %rdi
callq 0x24f7dc
testb %al, %al
jne 0x24f6b2
jmp 0x24f6e3
movq 0x20(%r14), %r12
jmp 0x24f6e3
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_O3/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 %r12
pushq %rbx
movq %r8, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testq %r8, %r8
sete %al
testl %ecx, %ecx
sete %dl
movl 0x18(%rdi), %r12d
testb %al, %dl
jne 0x24f757
testl %r12d, %r12d
jle 0x24f741
movq 0x20(%rbx), %rax
leaq (,%r12,8), %rdx
leaq (%rdx,%rdx,2), %rdx
xorl %esi, %esi
cmpq %r14, (%rax,%rsi)
je 0x24f7b1
addq $0x18, %rsi
cmpq %rsi, %rdx
jne 0x24f732
testb %cl, %cl
je 0x24f757
cmpq $0x0, 0x10(%rbx)
jne 0x24f757
cmpb $0x0, 0x11(%r14)
jne 0x24f757
movq %r14, 0x10(%rbx)
cmpl 0x1c(%rbx), %r12d
jne 0x24f787
testl %r12d, %r12d
je 0x24f7bf
movslq %r12d, %rax
movq 0x20(%rbx), %rdi
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
callq *0x20(%r9)
testq %rax, %rax
je 0x24f7d8
leal (%r12,%r12), %ecx
movl %ecx, 0x1c(%rbx)
movq %rax, 0x20(%rbx)
jmp 0x24f78b
movq 0x20(%rbx), %rax
movslq 0x18(%rbx), %rcx
leaq (%rcx,%rcx,2), %rdx
movq %r14, (%rax,%rdx,8)
movq %r15, 0x10(%rax,%rdx,8)
movb %bpl, 0x8(%rax,%rdx,8)
testb %bpl, %bpl
jne 0x24f7ab
movb $0x1, 0x10(%r14)
leal 0x1(%rcx), %eax
movl %eax, 0x18(%rbx)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, 0x1c(%rbx)
movl $0xc0, %edi
callq *0x18(%r9)
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x24f78b
xorl %eax, %eax
jmp 0x24f7b6
// File: /workspace/github_c_makefile_star2_O3/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 0x252651
testl %eax, %eax
jne 0x24f9ac
movq 0x18(%rbx), %rax
testb %bpl, %bpl
je 0x24f9b3
cmpq 0x10(%rbx), %rax
jne 0x24f99f
movq %rbx, %rdi
callq 0x24f7dc
testb %al, %al
je 0x24f9c8
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 0x24f989
cmpb $0x20, -0x1(%rax)
jne 0x24f989
decq %rax
movq %rax, 0x18(%rbx)
jmp 0x24f989
movl $0x1, %eax
jmp 0x24f9ac
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x290(%rdi), %r14
cmpq $0x0, 0x138(%r14)
jne 0x24fd42
movl 0x368(%rbx), %edi
shlq $0x2, %rdi
callq *0x18(%rbx)
movq %rax, 0x138(%r14)
testq %rax, %rax
je 0x24fe06
movl $0x0, (%rax)
movl 0x130(%r14), %ecx
movl 0x12c(%r14), %esi
movq 0x120(%r14), %rax
cmpl %esi, %ecx
jb 0x24fda7
testq %rax, %rax
je 0x24fd80
addl %esi, %esi
shlq $0x5, %rsi
movq %rax, %rdi
callq *0x20(%rbx)
testq %rax, %rax
je 0x24fe06
movl 0x12c(%r14), %ecx
addl %ecx, %ecx
jmp 0x24fd92
movl $0x400, %edi            # imm = 0x400
callq *0x18(%rbx)
testq %rax, %rax
je 0x24fe06
movl $0x20, %ecx
movl %ecx, 0x12c(%r14)
movq %rax, 0x120(%r14)
movl 0x130(%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x130(%r14)
movslq %ecx, %rdx
movslq 0x134(%r14), %rsi
testq %rsi, %rsi
je 0x24fdf8
movq 0x138(%r14), %rdi
movslq -0x4(%rdi,%rsi,4), %rdi
shlq $0x5, %rdi
leaq (%rax,%rdi), %rsi
movslq 0x14(%rax,%rdi), %rdi
testq %rdi, %rdi
je 0x24fde6
shlq $0x5, %rdi
movl %ecx, 0x1c(%rax,%rdi)
movl 0x18(%rsi), %edi
testl %edi, %edi
jne 0x24fdf0
movl %ecx, 0x10(%rsi)
movl %ecx, 0x14(%rsi)
incl %edi
movl %edi, 0x18(%rsi)
shlq $0x5, %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%rdx)
jmp 0x24fe0b
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rdi, %rbx
cmpq $0x0, 0x80(%rdi)
je 0x24feff
movslq 0x80(%r15), %rax
leaq (%rdx,%rax,2), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq *0x38(%r15)
movslq %eax, %r12
addq %rbp, %r12
leaq 0x300(%rbx), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x24f2f4
xorl %ebp, %ebp
testq %rax, %rax
je 0x24ff47
movq %rax, (%rsp)
movq 0x318(%rbx), %rax
movq %rax, 0x320(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq *0x40(%r15)
movslq 0x80(%r15), %rcx
addq %rcx, %rcx
subq %rcx, %r14
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x24f2f4
testq %rax, %rax
je 0x24ff47
movq %rax, %r14
movq %rax, %rdi
callq 0x252aed
movq 0x8(%rbx), %rdi
movq (%rsp), %rsi
movq %r14, %rdx
callq *0x80(%rbx)
movq 0x300(%rbx), %rax
movq 0x308(%rbx), %rcx
testq %rcx, %rcx
je 0x24ff1e
testq %rax, %rax
je 0x24ff28
movq %rax, %rdx
movq (%rax), %rax
movq %rcx, (%rdx)
movq %rdx, %rcx
testq %rax, %rax
jne 0x24feec
jmp 0x24ff21
movl $0x1, %ebp
cmpq $0x0, 0xa0(%rbx)
je 0x24ff47
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x24d5ee
jmp 0x24ff47
movq %rax, %rdx
movq %rdx, 0x308(%rbx)
xorl %eax, %eax
movq %rax, 0x300(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x310(%rbx)
movq %rax, 0x320(%rbx)
movl $0x1, %ebp
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_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x88(%rdi)
je 0x24ffcf
leaq 0x300(%rbx), %rdi
movslq 0x80(%rsi), %rax
leaq (%rdx,%rax,4), %rdx
leaq (%rax,%rax,2), %rax
subq %rax, %rcx
callq 0x24f2f4
testq %rax, %rax
je 0x24ffe8
movq %rax, %r14
movq %rax, %rdi
callq 0x252aed
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq *0x88(%rbx)
movq 0x300(%rbx), %rax
movq 0x308(%rbx), %rcx
testq %rcx, %rcx
je 0x24ffec
testq %rax, %rax
je 0x24fff6
movq %rax, %rdx
movq (%rax), %rax
movq %rcx, (%rdx)
movq %rdx, %rcx
testq %rax, %rax
jne 0x24ffbc
jmp 0x24ffef
movl $0x1, %ebp
cmpq $0x0, 0xa0(%rbx)
je 0x250015
movq %rbx, %rdi
callq 0x24d5ee
jmp 0x250015
xorl %ebp, %ebp
jmp 0x250015
movq %rax, %rdx
movq %rdx, 0x308(%rbx)
xorl %eax, %eax
movq %rax, 0x300(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x310(%rbx)
movq %rax, 0x320(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x2a0(%rdi), %r13
movb $0x1, %bl
testq %r13, %r13
je 0x250d90
movq %rdi, %r14
movslq 0x30(%r13), %rbp
movq 0x8(%r13), %rsi
movq 0x40(%r13), %rdi
leaq (%rdi,%rbp), %r12
incq %r12
cmpq %r12, %rsi
je 0x250d90
incq %rbp
movl 0x10(%r13), %eax
leal (%rax,%rbp), %ecx
movslq %ecx, %r15
movq 0x48(%r13), %rcx
subq %rdi, %rcx
cmpq %r15, %rcx
jge 0x250d70
movq %r15, %rsi
callq *0x20(%r14)
testq %rax, %rax
je 0x250d8e
movq 0x40(%r13), %rcx
cmpq %rcx, 0x18(%r13)
jne 0x250d44
movq %rax, 0x18(%r13)
movq 0x20(%r13), %rdx
testq %rdx, %rdx
je 0x250d57
subq %rcx, %rdx
addq %rax, %rdx
movq %rdx, 0x20(%r13)
movq %rax, 0x40(%r13)
addq %rax, %r15
movq %r15, 0x48(%r13)
addq %rax, %rbp
movq 0x8(%r13), %rsi
movl 0x10(%r13), %eax
movq %rbp, %r12
movslq %eax, %rdx
movq %r12, %rdi
callq 0x17660
movq %r12, 0x8(%r13)
movq (%r13), %r13
testq %r13, %r13
jne 0x250cf9
jmp 0x250d90
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: processInternalEntity
static enum XML_Error
processInternalEntity(XML_Parser parser, ENTITY *entity,
                      XML_Bool betweenDecl)
{
  const char *textStart, *textEnd;
  const char *next;
  enum XML_Error result;
  OPEN_INTERNAL_ENTITY *openEntity;

  if (freeInternalEntities) {
    openEntity = freeInternalEntities;
    freeInternalEntities = openEntity->next;
  }
  else {
    openEntity = (OPEN_INTERNAL_ENTITY *)MALLOC(sizeof(OPEN_INTERNAL_ENTITY));
    if (!openEntity)
      return XML_ERROR_NO_MEMORY;
  }
  entity->open = XML_TRUE;
  entity->processed = 0;
  openEntity->next = openInternalEntities;
  openInternalEntities = openEntity;
  openEntity->entity = entity;
  openEntity->startTagLevel = tagLevel;
  openEntity->betweenDecl = betweenDecl;
  openEntity->internalEventPtr = NULL;
  openEntity->internalEventEndPtr = NULL;
  textStart = (char *)entity->textPtr;
  textEnd = (char *)(entity->textPtr + entity->textLen);

#ifdef XML_DTD
  if (entity->is_param) {
    int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
    result = doProlog(parser, internalEncoding, textStart, textEnd, tok, 
                      next, &next, XML_FALSE);
  }
  else 
#endif /* XML_DTD */
    result = doContent(parser, tagLevel, internalEncoding, textStart, 
                       textEnd, &next, XML_FALSE);

  if (result == XML_ERROR_NONE) {
    if (textEnd != next && ps_parsing == XML_SUSPENDED) {
      entity->processed = (int)(next - textStart);
      processor = internalEntityProcessor;
    }
    else {
      entity->open = XML_FALSE;
      openInternalEntities = openEntity->next;
      /* put openEntity back in list of free instances */
      openEntity->next = freeInternalEntities;
      freeInternalEntities = openEntity;
    }
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x230(%rdi), %r15
testq %r15, %r15
je 0x250dcd
movq 0x10(%r15), %rax
movq %rax, 0x230(%rbx)
jmp 0x250de1
movl $0x28, %edi
callq *0x18(%rbx)
movq %rax, %r15
testq %rax, %rax
je 0x250e94
movb $0x1, 0x38(%r14)
xorl %eax, %eax
movl %eax, 0x14(%r14)
movq 0x228(%rbx), %rcx
movq %rcx, 0x10(%r15)
movq %r15, 0x228(%rbx)
movq %r14, 0x18(%r15)
movl 0x23c(%rbx), %esi
movl %esi, 0x20(%r15)
movb $0x0, 0x24(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x8(%r14), %r12
movslq 0x10(%r14), %r13
addq %r12, %r13
movq 0x1b8(%rbx), %rdx
movl %eax, (%rsp)
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movq %r12, %rcx
movq %r13, %r8
callq 0x25001c
testl %eax, %eax
jne 0x250e99
movq 0x8(%rsp), %rax
cmpq %rax, %r13
je 0x250e6e
cmpl $0x3, 0x378(%rbx)
jne 0x250e6e
subl %r12d, %eax
movl %eax, 0x14(%r14)
leaq 0x12f7(%rip), %rax      # 0x25215c
movq %rax, 0x200(%rbx)
jmp 0x250e90
movb $0x0, 0x38(%r14)
movq 0x10(%r15), %rax
movq %rax, 0x228(%rbx)
movq 0x230(%rbx), %rax
movq %rax, 0x10(%r15)
movq %r15, 0x230(%rbx)
xorl %eax, %eax
jmp 0x250e99
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x251e71
testl %eax, %eax
je 0x2520fa
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x252133
cmpq $0x0, 0x370(%r15)
je 0x252137
leaq 0x4e4(%rip), %rax       # 0x2525f9
movq %rax, 0x200(%r15)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2525f9
xorl %eax, %eax
jmp 0x2520f0
leaq -0x2db1(%rip), %rax     # 0x24f38d
movq %rax, 0x200(%r15)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x24f38d
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rdi, %r14
movq (%rsi), %r13
leaq 0xa0(%rdi), %r15
leaq 0x78(%rdi), %r12
movzbl (%r13), %eax
cmpl $0x3a, %eax
je 0x252299
testl %eax, %eax
jne 0x25234e
jmp 0x252367
movq (%rbx), %rbp
cmpq %r13, %rbp
je 0x2522dd
movq 0xb8(%r14), %rax
cmpq 0xb0(%r14), %rax
jne 0x2522c8
movq %r15, %rdi
callq 0x24f7dc
testb %al, %al
je 0x252356
movq 0xb8(%r14), %rax
movb (%rbp), %cl
leaq 0x1(%rax), %rdx
movq %rdx, 0xb8(%r14)
movb %cl, (%rax)
incq %rbp
jmp 0x25229c
movq 0xb8(%r14), %rax
cmpq 0xb0(%r14), %rax
jne 0x252300
movq %r15, %rdi
callq 0x24f7dc
testb %al, %al
je 0x252356
movq 0xb8(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xb8(%r14)
movb $0x0, (%rax)
movq 0xc0(%r14), %rsi
movl $0x10, %edx
movq %r12, %rdi
callq 0x24f9cf
testq %rax, %rax
je 0x252356
movq 0xc0(%r14), %rcx
cmpq %rcx, (%rax)
je 0x25233c
movq %rcx, 0xb8(%r14)
jmp 0x25234a
movq 0xb8(%r14), %rcx
movq %rcx, 0xc0(%r14)
movq %rax, 0x8(%rbx)
incq %r13
jmp 0x252282
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x252358
// File: /workspace/github_c_makefile_star2_O3/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)
movl $0x1, %ebx
movl $0x1, %esi
callq 0x25001c
movl %eax, %ebp
testl %eax, %eax
jne 0x252644
movq %r14, %rdi
callq 0x250cd9
testb %al, %al
je 0x252646
movl %ebp, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbp
movq %rdx, %r14
movq 0x290(%rdi), %rbx
movq 0x120(%rbx), %r10
movslq %esi, %rax
shlq $0x5, %rax
movq (%r10,%rax), %rdx
movq %rdx, (%r14)
cmpl $0x4, %edx
jne 0x252a4b
movq (%rbp), %rdx
movq %rdx, 0x8(%r14)
movq 0x8(%r10,%rax), %rax
movb (%rax), %cl
movq (%rbp), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, (%rbp)
movb %cl, (%rdx)
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x252a20
movl $0x0, 0x10(%r14)
movl $0x18, %edx
jmp 0x252ad6
movl 0x18(%r10,%rax), %r10d
movl %r10d, 0x10(%r14)
movq (%rcx), %rdx
movq %r10, %rsi
shlq $0x5, %rsi
addq %rdx, %rsi
movq %rdx, 0x18(%r14)
movq %rsi, (%rcx)
movl $0x8, %edx
testq %r10, %r10
je 0x252ad6
movq 0x120(%rbx), %rdx
addq %rdx, %rax
addq $0x10, %rax
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rcx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movslq (%rax), %r13
movq 0x18(%r14), %rdx
addq %r15, %rdx
movl %r13d, %esi
movq %rbp, %r8
callq 0x2529de
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
incq %r12
movq 0x120(%rbx), %rax
shlq $0x5, %r13
addq %r13, %rax
addq $0x1c, %rax
movl 0x10(%r14), %edx
addq $0x20, %r15
cmpq %rdx, %r12
jb 0x252a90
movl $0x8, %edx
movq $0x0, (%r14,%rdx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x252b2b
cmpl $0xd, %ecx
je 0x252afe
incq %rdi
jmp 0x252aed
movq %rdi, %rax
cmpb $0xd, %cl
jne 0x252b14
movb $0xa, (%rax)
cmpb $0xa, 0x1(%rdi)
je 0x252b1b
incq %rdi
jmp 0x252b1f
incq %rdi
movb %cl, (%rax)
jmp 0x252b1f
addq $0x2, %rdi
incq %rax
movb (%rdi), %cl
testb %cl, %cl
jne 0x252b01
movb $0x0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x252bab
cmpl $-0x1, %eax
je 0x252b93
cmpl $0xe, %eax
jne 0x252b72
movq (%rsp), %r14
cmpq %r12, %r14
jne 0x252b72
cmpb $0x0, 0x37c(%r15)
je 0x252bc3
leaq 0x5b(%rip), %rax        # 0x252bd4
movq %rax, 0x200(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x252bd4
jmp 0x252bc8
cmpb $0x0, 0x37c(%r15)
je 0x252bc3
movq %r14, 0x210(%r15)
movl $0x5, %eax
jmp 0x252bc8
cmpb $0x0, 0x37c(%r15)
je 0x252bc3
movq %r14, 0x210(%r15)
movl $0x6, %eax
jmp 0x252bc8
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rsi, %r12
movq %rdi, %r14
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(%r14)
cmpl $-0x2, %eax
je 0x252c5a
cmpl $-0x1, %eax
je 0x252c53
cmpl $0xc, %eax
jne 0x252c7c
movq %r14, %rdi
movl $0x1, %esi
movq %r12, %rdx
callq 0x24f00f
testl %eax, %eax
jne 0x252ca6
movl 0x378(%r14), %eax
cmpl $0x2, %eax
je 0x252c70
cmpl $0x3, %eax
jne 0x252c77
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
jmp 0x252c6c
movl $0x5, %eax
jmp 0x252c5f
movl $0x6, %eax
cmpb $0x0, 0x37c(%r14)
jne 0x252ca6
movq %r12, (%rbx)
xorl %eax, %eax
jmp 0x252ca6
movl $0x23, %eax
jmp 0x252ca6
movq 0x8(%rsp), %r12
leaq -0x68a(%rip), %rax      # 0x2525f9
movq %rax, 0x200(%r14)
movl $0x1, 0x23c(%r14)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2525f9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpq $0x0, 0x10(%rdi)
je 0x252cdc
xorl %r14d, %r14d
movq (%rbx), %rax
movq 0x20(%rbx), %rcx
movq (%rax,%r14,8), %rdi
callq *0x10(%rcx)
incq %r14
cmpq 0x10(%rbx), %r14
jb 0x252cc5
movq (%rbx), %rdi
movq 0x20(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x252d27
xorl %eax, %eax
leaq 0x73(%rip), %rsi        # 0x252d83
leaq 0x178919(%rip), %r9     # 0x3cb630
movslq (%r9,%rdi,4), %rdi
addq %r9, %rdi
jmpq *%rdi
movl $0x37, %eax
jmp 0x252d7e
cmpl $0x1d, %esi
jne 0x252d72
movl $0x2, %eax
jmp 0x252d77
movl $0x38, %eax
jmp 0x252d7e
movl $0x1, %eax
jmp 0x252d7e
movslq 0x80(%r8), %rax
leaq (%rdx,%rax,2), %rsi
leaq 0x1789c1(%rip), %rax    # 0x3cb714
movq %r8, %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq *0x30(%r8)
testl %eax, %eax
je 0x252d72
movl $0x3, %eax
leaq 0x9c(%rip), %rsi        # 0x252e0c
jmp 0x252d7e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq 0xbf(%rip), %rsi        # 0x252e3d
movq %rsi, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x252da3
leaq 0x1788b2(%rip), %rsi    # 0x3cb648
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
xorl %eax, %eax
jmp 0x252e0a
cmpl $0x1d, %esi
jne 0x252df4
leaq 0x8e(%rip), %rax        # 0x252e3d
movq %rax, (%rbx)
movl $0x2, %eax
jmp 0x252e0a
movl $0x37, %eax
jmp 0x252e0a
movslq 0x80(%r8), %rax
leaq (%rdx,%rax,2), %rsi
leaq 0x178942(%rip), %rax    # 0x3cb714
movq %r8, %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq *0x30(%r8)
testl %eax, %eax
je 0x252df4
leaq 0x22(%rip), %rax        # 0x252e0c
movq %rax, (%rbx)
movl $0x3, %eax
jmp 0x252e0a
leaq 0x42(%rip), %rax        # 0x252e3d
movq %rax, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x252e0a
movl $0x38, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %rbx
cmpl $0x11, %esi
jg 0x252e68
cmpl $0xf, %esi
je 0x252e80
cmpl $0x11, %esi
jne 0x252ed7
movl $0x8, %ebp
leaq 0x1d9(%rip), %rax       # 0x25303f
jmp 0x252ee3
cmpl $0x12, %esi
je 0x252e87
cmpl $0x19, %esi
jne 0x252ed7
movl $0x7, %ebp
leaq 0x73(%rip), %rax        # 0x252ef1
jmp 0x252ee3
movl $0x3, %ebp
jmp 0x252ee6
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
leaq 0x178885(%rip), %rcx    # 0x3cb71c
movq %r8, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq *0x30(%r8)
movl $0x3, %ebp
testl %eax, %eax
je 0x252eb6
leaq 0x1d4(%rip), %rax       # 0x253088
jmp 0x252ee3
leaq 0x178866(%rip), %rcx    # 0x3cb723
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x252ed7
leaq 0x1e1(%rip), %rax       # 0x2530b6
jmp 0x252ee3
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq -0xa6(%rip), %rax       # 0x252e3d
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x253078
leaq 0x178628(%rip), %rax    # 0x3cb678
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x37, %eax
retq
xorl %eax, %eax
retq
movl $0x38, %eax
retq
leaq -0x232(%rip), %rax      # 0x252e3d
movq %rax, (%rdi)
movl $0x2, %eax
retq
leaq -0x242(%rip), %rax      # 0x252e3d
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0xb, %ebx
cmpl $0xf, %esi
je 0x2532a2
movq %rdi, %r14
cmpl $0x1b, %esi
je 0x253256
cmpl $0x12, %esi
jne 0x253293
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
leaq 0x1784e0(%rip), %rcx    # 0x3cb71c
movq %r8, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq *0x30(%r8)
testl %eax, %eax
je 0x25326f
leaq 0x1b2(%rip), %rax       # 0x253406
jmp 0x25328e
leaq 0x153(%rip), %rax       # 0x2533b0
movq %rax, (%r14)
movl $0xb, 0xc(%r14)
movl $0xc, %ebx
jmp 0x2532a2
leaq 0x1784ad(%rip), %rcx    # 0x3cb723
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x30(%r15)
testl %eax, %eax
je 0x253293
leaq 0x1a6(%rip), %rax       # 0x253434
movq %rax, (%r14)
jmp 0x2532a2
leaq -0x45d(%rip), %rax      # 0x252e3d
movq %rax, (%r14)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0xb, %ebx
cmpl $0xf, %esi
je 0x253348
movq %rdi, %r14
cmpl $0x1b, %esi
je 0x2532fc
cmpl $0x12, %esi
jne 0x253339
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
leaq 0x17843a(%rip), %rcx    # 0x3cb71c
movq %r8, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq *0x30(%r8)
testl %eax, %eax
je 0x253315
leaq 0x5a(%rip), %rax        # 0x253354
jmp 0x253334
leaq 0xad(%rip), %rax        # 0x2533b0
movq %rax, (%r14)
movl $0xb, 0xc(%r14)
movl $0xc, %ebx
jmp 0x253348
leaq 0x178407(%rip), %rcx    # 0x3cb723
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x30(%r15)
testl %eax, %eax
je 0x253339
leaq 0x4e(%rip), %rax        # 0x253382
movq %rax, (%r14)
jmp 0x253348
leaq -0x503(%rip), %rax      # 0x252e3d
movq %rax, (%r14)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: attlist2
static int PTRCALL
attlist2(PROLOG_STATE *state,
         int tok,
         const char *ptr,
         const char *end,
         const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ATTLIST_NONE;
  case XML_TOK_NAME:
    {
      static const char * const types[] = {
        KW_CDATA,
        KW_ID,
        KW_IDREF,
        KW_IDREFS,
        KW_ENTITY,
        KW_ENTITIES,
        KW_NMTOKEN,
        KW_NMTOKENS,
      };
      int i;
      for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
        if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
          state->handler = attlist8;
          return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
        }
    }
    if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
      state->handler = attlist5;
      return XML_ROLE_ATTLIST_NONE;
    }
    break;
  case XML_TOK_OPEN_PAREN:
    state->handler = attlist3;
    return XML_ROLE_ATTLIST_NONE;
  }
  return common(state, tok);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x21, %ebp
cmpl $0xf, %esi
je 0x2535ff
cmpl $0x17, %esi
je 0x2535e5
cmpl $0x12, %esi
jne 0x2535d4
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, (%rsp)
movl $0x17, %ebp
xorl %r13d, %r13d
leaq 0x1781ce(%rip), %rbx    # 0x3cb750
movslq (%r13,%rbx), %rcx
addq %rbx, %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
jne 0x2535f1
addq $0x4, %r13
incl %ebp
cmpq $0x20, %r13
jne 0x253582
leaq 0x178193(%rip), %rcx    # 0x3cb741
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
movq (%rsp), %rdi
je 0x2535d4
leaq 0x11f(%rip), %rax       # 0x2536e9
movq %rax, (%rdi)
movl $0x21, %ebp
jmp 0x2535ff
leaq -0x79e(%rip), %rax      # 0x252e3d
movq %rax, (%rdi)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x2535ff
leaq 0x125(%rip), %rax       # 0x253711
movq %rax, (%rdi)
jmp 0x2535ff
leaq 0x18(%rip), %rax        # 0x253610
movq (%rsp), %rcx
movq %rax, (%rcx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq