LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x259152
movq 0x10(%r15), %rax
movq %rax, 0x230(%rbx)
jmp 0x259166
movl $0x28, %edi
callq *0x18(%rbx)
movq %rax, %r15
testq %rax, %rax
je 0x259217
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 0x258124
testl %eax, %eax
jne 0x25921c
movq 0x8(%rsp), %rcx
cmpq %rcx, %r13
je 0x2591f3
cmpl $0x3, 0x378(%rbx)
jne 0x2591f3
subl %r12d, %ecx
movl %ecx, 0x14(%r14)
leaq 0x15bb(%rip), %rcx      # 0x25a7a5
movq %rcx, 0x200(%rbx)
jmp 0x25921c
movb $0x0, 0x38(%r14)
movq 0x10(%r15), %rcx
movq %rcx, 0x228(%rbx)
movq 0x230(%rbx), %rcx
movq %rcx, 0x10(%r15)
movq %r15, 0x230(%rbx)
jmp 0x25921c
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25a483
testl %eax, %eax
je 0x25a743
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x25a77c
cmpq $0x0, 0x370(%r15)
je 0x25a780
leaq 0x4f3(%rip), %rax       # 0x25ac51
movq %rax, 0x200(%r15)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x25ac51
xorl %eax, %eax
jmp 0x25a739
leaq -0x3354(%rip), %rax     # 0x257433
movq %rax, 0x200(%r15)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x257433
// File: /workspace/github_c_makefile_star2_O1/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 0x290(%rdi), %r12
movq (%rsi), %r13
leaq 0xa0(%r12), %r14
leaq 0x78(%r12), %r15
movzbl (%r13), %eax
cmpl $0x3a, %eax
je 0x25a8e8
testl %eax, %eax
jne 0x25a9aa
jmp 0x25a9c3
movq (%rbx), %rbp
cmpq %r13, %rbp
je 0x25a930
movq 0xb8(%r12), %rax
cmpq 0xb0(%r12), %rax
jne 0x25a912
movq %r14, %rdi
callq 0x2578ac
testb %al, %al
je 0x25a9b2
movb (%rbp), %al
movq 0xb8(%r12), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0xb8(%r12)
movb %al, (%rcx)
incq %rbp
jmp 0x25a8eb
movq 0xb8(%r12), %rax
cmpq 0xb0(%r12), %rax
jne 0x25a94e
movq %r14, %rdi
callq 0x2578ac
testb %al, %al
je 0x25a9b2
movq 0xb8(%r12), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xb8(%r12)
movb $0x0, (%rax)
movq 0xc0(%r12), %rsi
movl $0x10, %edx
movq %r15, %rdi
callq 0x257a9b
testq %rax, %rax
je 0x25a9b2
movq 0xc0(%r12), %rcx
cmpq %rcx, (%rax)
je 0x25a996
movq %rcx, 0xb8(%r12)
jmp 0x25a9a6
movq 0xb8(%r12), %rcx
movq %rcx, 0xc0(%r12)
movq %rax, 0x8(%rbx)
incq %r13
jmp 0x25a8d1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x25a9b4
// File: /workspace/github_c_makefile_star2_O1/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 0x258124
movl %eax, %ebp
testl %eax, %eax
jne 0x25ac9c
movq %r14, %rdi
callq 0x25904e
testb %al, %al
je 0x25ac9e
movl %ebp, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25b1b6
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 0x25b18b
movl $0x0, 0x10(%r14)
movl $0x18, %edx
jmp 0x25b23d
movl 0x18(%r10,%rax), %esi
movl %esi, 0x10(%r14)
movq (%rcx), %rdx
movq %rdx, 0x18(%r14)
shlq $0x5, %rsi
addq %rsi, (%rcx)
movl $0x8, %edx
cmpl $0x0, 0x10(%r14)
je 0x25b23d
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 0x25b149
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 0x25b1f7
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_O1/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), %eax
testl %eax, %eax
je 0x25b293
cmpl $0xd, %eax
je 0x25b265
incq %rdi
jmp 0x25b254
movq %rdi, %rax
movb (%rdi), %cl
cmpb $0xd, %cl
jne 0x25b27d
movb $0xa, (%rax)
cmpb $0xa, 0x1(%rdi)
je 0x25b284
incq %rdi
jmp 0x25b288
incq %rdi
movb %cl, (%rax)
jmp 0x25b288
addq $0x2, %rdi
incq %rax
cmpb $0x0, (%rdi)
jne 0x25b268
movb $0x0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25b313
cmpl $-0x1, %eax
je 0x25b2fb
cmpl $0xe, %eax
jne 0x25b2da
movq (%rsp), %r14
cmpq %r12, %r14
jne 0x25b2da
cmpb $0x0, 0x37c(%r15)
je 0x25b32b
leaq 0x5b(%rip), %rax        # 0x25b33c
movq %rax, 0x200(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x25b33c
jmp 0x25b330
cmpb $0x0, 0x37c(%r15)
je 0x25b32b
movq %r14, 0x210(%r15)
movl $0x5, %eax
jmp 0x25b330
cmpb $0x0, 0x37c(%r15)
je 0x25b32b
movq %r14, 0x210(%r15)
movl $0x6, %eax
jmp 0x25b330
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r12
movq %rsi, %r14
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 0x25b3d9
cmpl $-0x1, %eax
je 0x25b3d2
cmpl $0xc, %eax
jne 0x25b3a6
movq %r15, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x2570c3
testl %eax, %eax
je 0x25b3fb
xorl %ecx, %ecx
testb %cl, %cl
je 0x25b3ed
leaq -0x75c(%rip), %rax      # 0x25ac51
movq %rax, 0x200(%r15)
movl $0x1, 0x23c(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x25ac51
jmp 0x25b3ed
movl $0x5, %eax
jmp 0x25b3de
movl $0x6, %eax
cmpb $0x0, 0x37c(%r15)
jne 0x25b3ed
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl 0x378(%r15), %eax
cmpl $0x2, %eax
je 0x25b418
cmpl $0x3, %eax
jne 0x25b41f
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x25b3a0
movl $0x23, %eax
jmp 0x25b3a0
movb $0x1, %cl
movq 0x8(%rsp), %r14
jmp 0x25b3a2
// File: /workspace/github_c_makefile_star2_O1/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 0x25b453
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 0x25b43c
movq (%rbx), %rdi
movq 0x20(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x25b49b
xorl %eax, %eax
leaq 0x73(%rip), %rsi        # 0x25b4f7
leaq 0x1798c5(%rip), %r9     # 0x3d4d50
movslq (%r9,%rdi,4), %rdi
addq %r9, %rdi
jmpq *%rdi
movl $0x37, %eax
jmp 0x25b4f2
cmpl $0x1d, %esi
jne 0x25b4e6
movl $0x2, %eax
jmp 0x25b4eb
movl $0x38, %eax
jmp 0x25b4f2
movl $0x1, %eax
jmp 0x25b4f2
movslq 0x80(%r8), %rax
leaq (%rdx,%rax,2), %rsi
leaq 0x17996d(%rip), %rax    # 0x3d4e34
movq %r8, %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq *0x30(%r8)
testl %eax, %eax
je 0x25b4e6
movl $0x3, %eax
leaq 0x9c(%rip), %rsi        # 0x25b580
jmp 0x25b4f2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq 0xbf(%rip), %rsi        # 0x25b5b1
movq %rsi, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25b517
leaq 0x17985e(%rip), %rsi    # 0x3d4d68
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
xorl %eax, %eax
jmp 0x25b57e
cmpl $0x1d, %esi
jne 0x25b568
leaq 0x8e(%rip), %rax        # 0x25b5b1
movq %rax, (%rbx)
movl $0x2, %eax
jmp 0x25b57e
movl $0x37, %eax
jmp 0x25b57e
movslq 0x80(%r8), %rax
leaq (%rdx,%rax,2), %rsi
leaq 0x1798ee(%rip), %rax    # 0x3d4e34
movq %r8, %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq *0x30(%r8)
testl %eax, %eax
je 0x25b568
leaq 0x22(%rip), %rax        # 0x25b580
movq %rax, (%rbx)
movl $0x3, %eax
jmp 0x25b57e
leaq 0x42(%rip), %rax        # 0x25b5b1
movq %rax, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x25b57e
movl $0x38, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25b5dc
cmpl $0xf, %esi
je 0x25b5f4
cmpl $0x11, %esi
jne 0x25b64b
movl $0x8, %ebp
leaq 0x1d9(%rip), %rax       # 0x25b7b3
jmp 0x25b657
cmpl $0x12, %esi
je 0x25b5fb
cmpl $0x19, %esi
jne 0x25b64b
movl $0x7, %ebp
leaq 0x73(%rip), %rax        # 0x25b665
jmp 0x25b657
movl $0x3, %ebp
jmp 0x25b65a
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
leaq 0x179831(%rip), %rcx    # 0x3d4e3c
movq %r8, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq *0x30(%r8)
movl $0x3, %ebp
testl %eax, %eax
je 0x25b62a
leaq 0x1d4(%rip), %rax       # 0x25b7fc
jmp 0x25b657
leaq 0x179812(%rip), %rcx    # 0x3d4e43
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x25b64b
leaq 0x1e1(%rip), %rax       # 0x25b82a
jmp 0x25b657
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq -0xa6(%rip), %rax       # 0x25b5b1
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25b7ec
leaq 0x1795d4(%rip), %rax    # 0x3d4d98
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      # 0x25b5b1
movq %rax, (%rdi)
movl $0x2, %eax
retq
leaq -0x242(%rip), %rax      # 0x25b5b1
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25ba16
movq %rdi, %r14
cmpl $0x1b, %esi
je 0x25b9ca
cmpl $0x12, %esi
jne 0x25ba07
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
leaq 0x17948c(%rip), %rcx    # 0x3d4e3c
movq %r8, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq *0x30(%r8)
testl %eax, %eax
je 0x25b9e3
leaq 0x1b2(%rip), %rax       # 0x25bb7a
jmp 0x25ba02
leaq 0x153(%rip), %rax       # 0x25bb24
movq %rax, (%r14)
movl $0xb, 0xc(%r14)
movl $0xc, %ebx
jmp 0x25ba16
leaq 0x179459(%rip), %rcx    # 0x3d4e43
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x30(%r15)
testl %eax, %eax
je 0x25ba07
leaq 0x1a6(%rip), %rax       # 0x25bba8
movq %rax, (%r14)
jmp 0x25ba16
leaq -0x45d(%rip), %rax      # 0x25b5b1
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_O1/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 0x25babc
movq %rdi, %r14
cmpl $0x1b, %esi
je 0x25ba70
cmpl $0x12, %esi
jne 0x25baad
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
leaq 0x1793e6(%rip), %rcx    # 0x3d4e3c
movq %r8, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq *0x30(%r8)
testl %eax, %eax
je 0x25ba89
leaq 0x5a(%rip), %rax        # 0x25bac8
jmp 0x25baa8
leaq 0xad(%rip), %rax        # 0x25bb24
movq %rax, (%r14)
movl $0xb, 0xc(%r14)
movl $0xc, %ebx
jmp 0x25babc
leaq 0x1793b3(%rip), %rcx    # 0x3d4e43
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x30(%r15)
testl %eax, %eax
je 0x25baad
leaq 0x4e(%rip), %rax        # 0x25baf6
movq %rax, (%r14)
jmp 0x25babc
leaq -0x503(%rip), %rax      # 0x25b5b1
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_O1/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 0x25bd10
movq %rdi, %rbx
cmpl $0x17, %esi
je 0x25bd04
cmpl $0x12, %esi
jne 0x25bd91
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
leaq 0x1791a7(%rip), %rcx    # 0x3d4e90
movq %r8, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq *0x30(%r8)
testl %eax, %eax
je 0x25bd1b
movl $0x17, %r13d
xorl %eax, %eax
jmp 0x25bd62
leaq 0x1b4(%rip), %rax       # 0x25bebf
jmp 0x25bd9d
movl $0x21, %r13d
jmp 0x25bda3
movq %rbx, (%rsp)
xorl %r13d, %r13d
leaq 0x179147(%rip), %rbx    # 0x3d4e70
cmpq $0x7, %r13
je 0x25bdb5
movslq 0x4(%rbx,%r13,4), %rcx
addq %rbx, %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
incq %r13
testl %eax, %eax
je 0x25bd29
leaq -0x1(%r13), %rax
cmpq $0x7, %rax
setae %al
addl $0x17, %r13d
movq (%rsp), %rbx
leaq 0x55(%rip), %rcx        # 0x25bdbe
movq %rcx, (%rbx)
testb %al, %al
je 0x25bda3
leaq 0x1790ea(%rip), %rcx    # 0x3d4e61
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x25bd91
leaq 0x108(%rip), %rax       # 0x25be97
jmp 0x25bd9d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq -0x7ec(%rip), %rax      # 0x25b5b1
movq %rax, (%rbx)
movl %ebp, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
setae %al
movq (%rsp), %rbx
jmp 0x25bd6c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: attlist8
static int PTRCALL
attlist8(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_POUND_NAME:
    if (XmlNameMatchesAscii(enc,
                            ptr + MIN_BYTES_PER_CHAR(enc),
                            end,
                            KW_IMPLIED)) {
      state->handler = attlist1;
      return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
    }
    if (XmlNameMatchesAscii(enc,
                            ptr + MIN_BYTES_PER_CHAR(enc),
                            end,
                            KW_REQUIRED)) {
      state->handler = attlist1;
      return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
    }
    if (XmlNameMatchesAscii(enc,
                            ptr + MIN_BYTES_PER_CHAR(enc),
                            end,
                            KW_FIXED)) {
      state->handler = attlist9;
      return XML_ROLE_ATTLIST_NONE;
    }
    break;
  case XML_TOK_LITERAL:
    state->handler = attlist1;
    return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0xf, %esi
je 0x25be91
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq -0x16c(%rip), %r13      # 0x25bc6e
cmpl $0x1b, %esi
je 0x25be7f
cmpl $0x14, %esi
jne 0x25be71
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movslq 0x80(%r8), %rsi
addq %rdx, %rsi
leaq 0x1790ba(%rip), %rcx    # 0x3d4ec0
movq %r8, %rdi
movq %r15, %rdx
callq *0x30(%r8)
movl %eax, %ecx
movl $0x23, %eax
testl %ecx, %ecx
jne 0x25be84
movslq 0x80(%r14), %rsi
addq %r12, %rsi
leaq 0x17909c(%rip), %rcx    # 0x3d4ec8
movq %r14, %rdi
movq %r15, %rdx
callq *0x30(%r14)
movl %eax, %ecx
movl $0x24, %eax
testl %ecx, %ecx
jne 0x25be84
movslq 0x80(%r14), %rax
addq %rax, %r12
leaq 0x17907f(%rip), %rcx    # 0x3d4ed1
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x25be71
movl $0x21, %eax
leaq 0x84(%rip), %r13        # 0x25bef3
jmp 0x25be84
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq -0x8cc(%rip), %r13      # 0x25b5b1
jmp 0x25be84
movl $0x25, %eax
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x21, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element1
static int PTRCALL
element1(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_ELEMENT_NONE;
  case XML_TOK_NAME:
    if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
      return XML_ROLE_CONTENT_EMPTY;
    }
    if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
      return XML_ROLE_CONTENT_ANY;
    }
    break;
  case XML_TOK_OPEN_PAREN:
    state->handler = element2;
    state->level = 1;
    return XML_ROLE_GROUP_OPEN;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0xf, %esi
je 0x25c02a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x17, %esi
je 0x25c012
cmpl $0x12, %esi
jne 0x25c060
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
leaq 0x178eee(%rip), %rcx    # 0x3d4ed7
movq %r8, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq *0x30(%r8)
testl %eax, %eax
je 0x25c030
leaq -0x4dd(%rip), %rax      # 0x25bb24
movq %rax, (%rbx)
movl $0x27, 0xc(%rbx)
movl $0x2a, %eax
jmp 0x25c06f
leaq 0x62(%rip), %rax        # 0x25c07b
movq %rax, (%rbx)
movl $0x1, 0x8(%rbx)
movl $0x2c, %eax
jmp 0x25c06f
movl $0x27, %eax
retq
leaq 0x178ea6(%rip), %rcx    # 0x3d4edd
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x25c060
leaq -0x52b(%rip), %rax      # 0x25bb24
movq %rax, (%rbx)
movl $0x27, 0xc(%rbx)
movl $0x29, %eax
jmp 0x25c06f
leaq -0xab6(%rip), %rax      # 0x25b5b1
movq %rax, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element2
static int PTRCALL
element2(PROLOG_STATE *state,
         int tok,
         const char *ptr,
         const char *end,
         const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ELEMENT_NONE;
  case XML_TOK_POUND_NAME:
    if (XmlNameMatchesAscii(enc,
                            ptr + MIN_BYTES_PER_CHAR(enc),
                            end,
                            KW_PCDATA)) {
      state->handler = element3;
      return XML_ROLE_CONTENT_PCDATA;
    }
    break;
  case XML_TOK_OPEN_PAREN:
    state->level = 2;
    state->handler = element6;
    return XML_ROLE_GROUP_OPEN;
  case XML_TOK_NAME:
  case XML_TOK_PREFIXED_NAME:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT;
  case XML_TOK_NAME_QUESTION:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_OPT;
  case XML_TOK_NAME_ASTERISK:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_REP;
  case XML_TOK_NAME_PLUS:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_PLUS;
  }
  return common(state, tok);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x33, %eax
leaq 0x18c(%rip), %rdi       # 0x25c217
leal -0x12(%rsi), %r9d
cmpl $0xe, %r9d
ja 0x25c0d9
leaq 0x178d24(%rip), %rsi    # 0x3d4dc0
movslq (%rsi,%r9,4), %r9
addq %rsi, %r9
jmpq *%r9
movslq 0x80(%r8), %rax
addq %rax, %rdx
leaq 0x178e2a(%rip), %rax    # 0x3d4ee1
movq %r8, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq *0x30(%r8)
testl %eax, %eax
je 0x25c0e3
movl $0x2b, %eax
leaq 0x4e(%rip), %rdi        # 0x25c125
jmp 0x25c119
cmpl $0xf, %esi
je 0x25c11e
cmpl $0x29, %esi
je 0x25c119
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq -0xb3e(%rip), %rdi      # 0x25b5b1
jmp 0x25c119
movl $0x35, %eax
jmp 0x25c119
movl $0x34, %eax
jmp 0x25c119
movl $0x2, 0x8(%rbx)
movl $0x2c, %eax
leaq 0x7a(%rip), %rdi        # 0x25c18c
jmp 0x25c119
movl $0x36, %eax
movq %rdi, (%rbx)
popq %rbx
retq
movl $0x27, %eax
jmp 0x25c11c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element3
static int PTRCALL
element3(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_ELEMENT_NONE;
  case XML_TOK_CLOSE_PAREN:
    state->handler = declClose;
    state->role_none = XML_ROLE_ELEMENT_NONE;
    return XML_ROLE_GROUP_CLOSE;
  case XML_TOK_CLOSE_PAREN_ASTERISK:
    state->handler = declClose;
    state->role_none = XML_ROLE_ELEMENT_NONE;
    return XML_ROLE_GROUP_CLOSE_REP;
  case XML_TOK_OR:
    state->handler = element4;
    return XML_ROLE_ELEMENT_NONE;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0x17, %esi
jg 0x25c144
movl $0x27, %eax
cmpl $0xf, %esi
je 0x25c174
cmpl $0x15, %esi
jne 0x25c165
leaq 0x178(%rip), %rcx       # 0x25c2b8
movq %rcx, (%rdi)
retq
cmpl $0x24, %esi
je 0x25c175
cmpl $0x18, %esi
jne 0x25c165
leaq -0x631(%rip), %rax      # 0x25bb24
movq %rax, (%rdi)
movl $0x27, 0xc(%rdi)
movl $0x2d, %eax
retq
leaq -0xbbb(%rip), %rax      # 0x25b5b1
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
leaq -0x658(%rip), %rax      # 0x25bb24
movq %rax, (%rdi)
movl $0x27, 0xc(%rdi)
movl $0x2e, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element6
static int PTRCALL
element6(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_ELEMENT_NONE;
  case XML_TOK_OPEN_PAREN:
    state->level += 1;
    return XML_ROLE_GROUP_OPEN;
  case XML_TOK_NAME:
  case XML_TOK_PREFIXED_NAME:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT;
  case XML_TOK_NAME_QUESTION:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_OPT;
  case XML_TOK_NAME_ASTERISK:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_REP;
  case XML_TOK_NAME_PLUS:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_PLUS;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0x16, %esi
jle 0x25c1b2
leal -0x17(%rsi), %eax
cmpl $0x9, %eax
ja 0x25c1cc
leaq 0x178c5c(%rip), %rcx    # 0x3d4dfc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incl 0x8(%rdi)
movl $0x2c, %eax
retq
cmpl $0xf, %esi
je 0x25c211
cmpl $0x12, %esi
jne 0x25c1d1
leaq 0x54(%rip), %rax        # 0x25c217
movq %rax, (%rdi)
movl $0x33, %eax
retq
cmpl $0x29, %esi
je 0x25c1bc
leaq -0xc27(%rip), %rax      # 0x25b5b1
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
leaq 0x2f(%rip), %rax        # 0x25c217
movq %rax, (%rdi)
movl $0x34, %eax
retq
leaq 0x1f(%rip), %rax        # 0x25c217
movq %rax, (%rdi)
movl $0x36, %eax
retq
leaq 0xf(%rip), %rax         # 0x25c217
movq %rax, (%rdi)
movl $0x35, %eax
retq
movl $0x27, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element7
static int PTRCALL
element7(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_ELEMENT_NONE;
  case XML_TOK_CLOSE_PAREN:
    state->level -= 1;
    if (state->level == 0) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
    }
    return XML_ROLE_GROUP_CLOSE;
  case XML_TOK_CLOSE_PAREN_ASTERISK:
    state->level -= 1;
    if (state->level == 0) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
    }
    return XML_ROLE_GROUP_CLOSE_REP;
  case XML_TOK_CLOSE_PAREN_QUESTION:
    state->level -= 1;
    if (state->level == 0) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
    }
    return XML_ROLE_GROUP_CLOSE_OPT;
  case XML_TOK_CLOSE_PAREN_PLUS:
    state->level -= 1;
    if (state->level == 0) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
    }
    return XML_ROLE_GROUP_CLOSE_PLUS;
  case XML_TOK_COMMA:
    state->handler = element6;
    return XML_ROLE_GROUP_SEQUENCE;
  case XML_TOK_OR:
    state->handler = element6;
    return XML_ROLE_GROUP_CHOICE;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0x22, %esi
jle 0x25c23f
addl $-0x23, %esi
cmpl $0x3, %esi
ja 0x25c298
leaq 0x178bf9(%rip), %rax    # 0x3d4e24
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
decl 0x8(%rdi)
movl $0x2f, %eax
je 0x25c286
retq
cmpl $0xf, %esi
je 0x25c25a
cmpl $0x15, %esi
je 0x25c2a8
cmpl $0x18, %esi
jne 0x25c298
decl 0x8(%rdi)
movl $0x2d, %eax
jne 0x25c23e
jmp 0x25c286
movl $0x27, %eax
retq
decl 0x8(%rdi)
movl $0x30, %eax
jne 0x25c23e
jmp 0x25c286
leaq -0xe7(%rip), %rax       # 0x25c18c
movq %rax, (%rdi)
movl $0x32, %eax
retq
decl 0x8(%rdi)
movl $0x2e, %eax
jne 0x25c23e
leaq -0x769(%rip), %rcx      # 0x25bb24
movq %rcx, (%rdi)
movl $0x27, 0xc(%rdi)
retq
leaq -0xcee(%rip), %rax      # 0x25b5b1
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
leaq -0x123(%rip), %rax      # 0x25c18c
movq %rax, (%rdi)
movl $0x31, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element5
static int PTRCALL
element5(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_ELEMENT_NONE;
  case XML_TOK_CLOSE_PAREN_ASTERISK:
    state->handler = declClose;
    state->role_none = XML_ROLE_ELEMENT_NONE;
    return XML_ROLE_GROUP_CLOSE_REP;
  case XML_TOK_OR:
    state->handler = element4;
    return XML_ROLE_ELEMENT_NONE;
  }
  return common(state, tok);
}

// Assembly:
movl $0x27, %eax
cmpl $0xf, %esi
je 0x25c32e
cmpl $0x15, %esi
je 0x25c314
cmpl $0x24, %esi
jne 0x25c31f
leaq -0x7e0(%rip), %rax      # 0x25bb24
movq %rax, (%rdi)
movl $0x27, 0xc(%rdi)
movl $0x2e, %eax
retq
leaq -0x63(%rip), %rcx       # 0x25c2b8
movq %rcx, (%rdi)
retq
leaq -0xd75(%rip), %rax      # 0x25b5b1
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: notation1
static int PTRCALL
notation1(PROLOG_STATE *state,
          int tok,
          const char *ptr,
          const char *end,
          const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_NOTATION_NONE;
  case XML_TOK_NAME:
    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
      state->handler = notation3;
      return XML_ROLE_NOTATION_NONE;
    }
    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
      state->handler = notation2;
      return XML_ROLE_NOTATION_NONE;
    }
    break;
  }
  return common(state, tok);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0xf, %esi
je 0x25c373
movq %rdi, %rbx
cmpl $0x12, %esi
jne 0x25c39b
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
leaq 0x178ae8(%rip), %rcx    # 0x3d4e3c
movq %r8, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq *0x30(%r8)
movl $0x11, %ebp
testl %eax, %eax
je 0x25c37a
leaq 0x44(%rip), %rax        # 0x25c3b5
jmp 0x25c3a7
movl $0x11, %ebp
jmp 0x25c3aa
leaq 0x178ac2(%rip), %rcx    # 0x3d4e43
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x25c39b
leaq 0x53(%rip), %rax        # 0x25c3ec
jmp 0x25c3a7
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq -0xdf6(%rip), %rax      # 0x25b5b1
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: notation4
static int PTRCALL
notation4(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_NOTATION_NONE;
  case XML_TOK_LITERAL:
    state->handler = declClose;
    state->role_none = XML_ROLE_NOTATION_NONE;
    return XML_ROLE_NOTATION_SYSTEM_ID;
  case XML_TOK_DECL_CLOSE:
    setTopLevel(state);
    return XML_ROLE_NOTATION_NO_SYSTEM_ID;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0xf, %esi
je 0x25c450
cmpl $0x11, %esi
je 0x25c440
cmpl $0x1b, %esi
jne 0x25c456
leaq -0x90c(%rip), %rax      # 0x25bb24
movq %rax, (%rdi)
movl $0x11, 0xc(%rdi)
movl $0x13, %eax
retq
leaq -0xde2(%rip), %rax      # 0x25b665
movq %rax, (%rdi)
movl $0x14, %eax
retq
movl $0x11, %eax
retq
leaq -0xeac(%rip), %rax      # 0x25b5b1
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: XmlUtf8Encode
int FASTCALL
XmlUtf8Encode(int c, char *buf)
{
  enum {
    /* minN is minimum legal resulting value for N byte sequence */
    min2 = 0x80,
    min3 = 0x800,
    min4 = 0x10000
  };

  if (c < 0)
    return 0;
  if (c < min2) {
    buf[0] = (char)(c | UTF8_cval1);
    return 1;
  }
  if (c < min3) {
    buf[0] = (char)((c >> 6) | UTF8_cval2);
    buf[1] = (char)((c & 0x3f) | 0x80);
    return 2;
  }
  if (c < min4) {
    buf[0] = (char)((c >> 12) | UTF8_cval3);
    buf[1] = (char)(((c >> 6) & 0x3f) | 0x80);
    buf[2] = (char)((c & 0x3f) | 0x80);
    return 3;
  }
  if (c < 0x110000) {
    buf[0] = (char)((c >> 18) | UTF8_cval4);
    buf[1] = (char)(((c >> 12) & 0x3f) | 0x80);
    buf[2] = (char)(((c >> 6) & 0x3f) | 0x80);
    buf[3] = (char)((c & 0x3f) | 0x80);
    return 4;
  }
  return 0;
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
js 0x25c54c
cmpl $0x7f, %edi
jg 0x25c4c0
movb %dil, (%rsi)
movl $0x1, %eax
retq
cmpl $0x7ff, %edi            # imm = 0x7FF
jg 0x25c4e3
movl %edi, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x1(%rsi)
movl $0x2, %eax
retq
cmpl $0xffff, %edi           # imm = 0xFFFF
jg 0x25c512
movl %edi, %eax
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%rsi)
movl %edi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x2(%rsi)
movl $0x3, %eax
retq
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
jg 0x25c54c
movl %edi, %eax
shrl $0x12, %eax
orb $-0x10, %al
movb %al, (%rsi)
movl %edi, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
movl %edi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x3(%rsi)
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: XmlUtf16Encode
int FASTCALL
XmlUtf16Encode(int charNum, unsigned short *buf)
{
  if (charNum < 0)
    return 0;
  if (charNum < 0x10000) {
    buf[0] = (unsigned short)charNum;
    return 1;
  }
  if (charNum < 0x110000) {
    charNum -= 0x10000;
    buf[0] = (unsigned short)((charNum >> 10) + 0xD800);
    buf[1] = (unsigned short)((charNum & 0x3FF) + 0xDC00);
    return 2;
  }
  return 0;
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
js 0x25c592
cmpl $0xffff, %edi           # imm = 0xFFFF
jg 0x25c564
movw %di, (%rsi)
movl $0x1, %eax
retq
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
jg 0x25c592
leal 0x3ff0000(%rdi), %eax
shrl $0xa, %eax
addl $0xffffd800, %eax       # imm = 0xFFFFD800
movw %ax, (%rsi)
andl $0x3ff, %edi            # imm = 0x3FF
orl $0xdc00, %edi           # imm = 0xDC00
movw %di, 0x2(%rsi)
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: checkCharRefNumber
static int FASTCALL
checkCharRefNumber(int result)
{
  switch (result >> 8) {
  case 0xD8: case 0xD9: case 0xDA: case 0xDB:
  case 0xDC: case 0xDD: case 0xDE: case 0xDF:
    return -1;
  case 0:
    if (latin1_encoding.type[result] == BT_NONXML)
      return -1;
    break;
  case 0xFF:
    if (result == 0xFFFE || result == 0xFFFF)
      return -1;
    break;
  }
  return result;
}

// Assembly:
movl %edi, %ecx
sarl $0x8, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leal -0xd8(%rcx), %edx
cmpl $0x8, %edx
jae 0x25c856
retq
cmpl $0xff, %ecx
je 0x25c878
testl %ecx, %ecx
jne 0x25c885
movslq %edi, %rcx
leaq 0x264194(%rip), %rdx    # 0x4c0a00
cmpb $0x0, 0x88(%rcx,%rdx)
jne 0x25c885
jmp 0x25c855
movl %edi, %ecx
andl $-0x2, %ecx
cmpl $0xfffe, %ecx           # imm = 0xFFFE
je 0x25c855
movl %edi, %eax
retq