LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: stringcap
static void stringcap (luaL_Buffer *b, CapState *cs) {
  StrAux cps[MAXSTRCAPS];
  int n;
  size_t len, i;
  const char *c;
  updatecache(cs, cs->cap->idx);
  c = lua_tolstring(cs->L, subscache(cs), &len);
  n = getstrcaps(cs, cps, 0) - 1;
  for (i = 0; i < len; i++) {
    if (c[i] != '%' || c[++i] < '0' || c[i] > '9')
      luaL_addchar(b, c[i]);
    else {
      int l = c[i] - '0';
      if (l > n)
        luaL_error(cs->L, "invalid capture index (%d)", l);
      else if (cps[l].isstring)
        luaL_addlstring(b, cps[l].u.s.s, cps[l].u.s.e - cps[l].u.s.s);
      else {
        Capture *curr = cs->cap;
        cs->cap = cps[l].u.cp;
        if (addonestring(b, cs, "capture") == 0)
          luaL_error(cs->L, "no values in capture index %d", l);
        cs->cap = curr;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movswl 0x8(%rax), %esi
cmpl %esi, 0x28(%rbx)
je 0x24a610
movq %rbx, %rdi
callq 0x24a7d8
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
incl %esi
leaq 0x18(%rsp), %r12
movq %r12, %rdx
callq 0x22db9e
movq %rax, %r15
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x24a80e
movl %eax, 0xc(%rsp)
cmpq $0x0, (%r12)
je 0x24a727
leaq 0x2018(%r14), %r13
xorl %ebp, %ebp
cmpb $0x25, (%r15,%rbp)
jne 0x24a667
movb 0x1(%r15,%rbp), %al
incq %rbp
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x24a693
cmpq %r13, (%r14)
jb 0x24a674
movq %r14, %rdi
callq 0x23159c
movb (%r15,%rbp), %al
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r14)
movb %al, (%rcx)
incq %rbp
cmpq 0x18(%rsp), %rbp
jb 0x24a650
jmp 0x24a727
addb $-0x30, %al
movzbl %al, %r12d
cmpl %r12d, 0xc(%rsp)
jle 0x24a6c9
movl %r12d, %eax
leaq (%rax,%rax,2), %rax
leaq (%rsp,%rax,8), %rax
addq $0x20, %rax
cmpl $0x0, (%rax)
je 0x24a6e0
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
subq %rsi, %rdx
movq %r14, %rdi
callq 0x2314fb
jmp 0x24a684
movq 0x10(%rbx), %rdi
leaq 0x188e40(%rip), %rsi    # 0x3d3514
movl %r12d, %edx
xorl %eax, %eax
callq 0x230abd
jmp 0x24a684
movq (%rbx), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x1a90a8(%rip), %rdx    # 0x3f37a4
callq 0x24a929
testl %eax, %eax
jne 0x24a71a
movq 0x10(%rbx), %rdi
leaq 0x188e1f(%rip), %rsi    # 0x3d352f
movl %r12d, %edx
xorl %eax, %eax
callq 0x230abd
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
jmp 0x24a684
addq $0x118, %rsp            # imm = 0x118
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/lpeg-0.10.2/lpeg.c
// Function: substcap
static void substcap (luaL_Buffer *b, CapState *cs) {
  const char *curr = cs->cap->s;
  if (isfullcap(cs->cap))  /* no nested captures? */
    luaL_addlstring(b, curr, cs->cap->siz - 1);  /* keep original text */
  else {
    cs->cap++;
    while (!isclosecap(cs->cap)) {
      const char *next = cs->cap->s;
      luaL_addlstring(b, curr, next - curr);  /* add text up to capture */
      if (addonestring(b, cs, "replacement") == 0)  /* no capture value? */
        curr = next;  /* keep original text in final result */
      else
        curr = closeaddr(cs->cap - 1);  /* continue after match */
    }
    luaL_addlstring(b, curr, cs->cap->s - curr);  /* add last piece of text */
  }
  cs->cap++;  /* go to next capture */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rcx
movq (%rcx), %rsi
movzbl 0xb(%rcx), %edx
testq %rdx, %rdx
je 0x24a75d
decl %edx
movq %r14, %rdi
jmp 0x24a7c3
leaq 0x10(%rcx), %rax
movq %rax, (%rbx)
cmpb $0x0, 0x1a(%rcx)
je 0x24a7b4
leaq 0x1338dd(%rip), %r15    # 0x37e04e
movq (%rax), %r12
movq %r12, %rdx
subq %rsi, %rdx
movq %r14, %rdi
callq 0x2314fb
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x24a929
testl %eax, %eax
je 0x24a7a6
movq (%rbx), %rax
movq -0x10(%rax), %rcx
movzbl -0x5(%rax), %eax
leaq (%rcx,%rax), %r12
decq %r12
movq (%rbx), %rax
cmpb $0x0, 0xa(%rax)
movq %r12, %rsi
jne 0x24a771
jmp 0x24a7b7
movq %rsi, %r12
movq (%rax), %rdx
subq %r12, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2314fb
addq $0x10, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: getstrcaps
static int getstrcaps (CapState *cs, StrAux *cps, int n) {
  int k = n++;
  cps[k].isstring = 1;
  cps[k].u.s.s = cs->cap->s;
  if (!isfullcap(cs->cap++)) {
    while (!isclosecap(cs->cap)) {
      if (n >= MAXSTRCAPS)  /* too many captures? */
        cs->cap = nextcap(cs->cap);  /* skip it */
      else if (captype(cs->cap) == Csimple)
        n = getstrcaps(cs, cps, n);
      else {
        cps[n].isstring = 0;
        cps[n].u.cp = cs->cap;
        cs->cap = nextcap(cs->cap);
        n++;
      }
    }
    cs->cap++;  /* skip close */
  }
  cps[k].u.s.e = closeaddr(cs->cap - 1);
  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %eax
movq %rdi, %rbx
movslq %edx, %rcx
incl %eax
leaq (%rcx,%rcx,2), %rcx
leaq (%rsi,%rcx,8), %r15
movl $0x1, (%r15)
movq (%rdi), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%r15)
movq (%rdi), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, (%rdi)
cmpb $0x0, 0xb(%rcx)
jne 0x24a90e
movq (%rbx), %rcx
movb 0xa(%rcx), %dl
testb %dl, %dl
je 0x24a907
movq %rsi, %r14
cmpl $0xa, %eax
jl 0x24a86f
cmpb $0x0, 0xb(%rcx)
je 0x24a8b5
addq $0x10, %rcx
movq %rcx, (%rbx)
jmp 0x24a8a9
cmpb $0x5, %dl
jne 0x24a883
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x24a80e
jmp 0x24a8a9
movslq %eax, %rdx
leaq (%rdx,%rdx,2), %rdx
movl $0x0, (%r14,%rdx,8)
movq %rcx, 0x8(%r14,%rdx,8)
movq (%rbx), %rcx
cmpb $0x0, 0xb(%rcx)
je 0x24a8de
addq $0x10, %rcx
movq %rcx, (%rbx)
incl %eax
movq (%rbx), %rcx
movb 0xa(%rcx), %dl
testb %dl, %dl
jne 0x24a85b
jmp 0x24a907
addq $0x20, %rcx
xorl %edx, %edx
cmpb $0x0, -0x6(%rcx)
je 0x24a8cd
xorl %esi, %esi
cmpb $0x0, -0x5(%rcx)
sete %sil
jmp 0x24a8d6
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testl %edx, %edx
je 0x24a86a
addl %esi, %edx
addq $0x10, %rcx
jmp 0x24a8bb
addq $0x20, %rcx
xorl %edx, %edx
cmpb $0x0, -0x6(%rcx)
je 0x24a8f6
xorl %esi, %esi
cmpb $0x0, -0x5(%rcx)
sete %sil
jmp 0x24a8ff
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testl %edx, %edx
je 0x24a8a4
addl %esi, %edx
addq $0x10, %rcx
jmp 0x24a8e4
addq $0x10, %rcx
movq %rcx, (%rbx)
movq (%rbx), %rcx
movq -0x10(%rcx), %rdx
movzbl -0x5(%rcx), %ecx
addq %rdx, %rcx
decq %rcx
movq %rcx, 0x10(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: addonestring
static int addonestring (luaL_Buffer *b, CapState *cs, const char *what) {
  switch (captype(cs->cap)) {
    case Cstring:
      stringcap(b, cs);  /* add capture directly to buffer */
      return 1;
    case Csubst:
      substcap(b, cs);  /* add capture directly to buffer */
      return 1;
    default: {
      lua_State *L = cs->L;
      int n = pushcapture(cs);
      if (n > 0) {
        if (n > 1) lua_pop(L, n - 1);  /* only one result */
        if (!lua_isstring(L, -1))
          luaL_error(L, "invalid %s value (a %s)", what, luaL_typename(L, -1));
        luaL_addvalue(b);
      }
      return n;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movzbl 0xa(%rax), %eax
cmpl $0xa, %eax
je 0x24a94e
cmpl $0x9, %eax
jne 0x24a95d
movq %rbx, %rdi
callq 0x24a5e5
jmp 0x24a956
movq %rbx, %rdi
callq 0x24a739
movl $0x1, %ebp
jmp 0x24a9ca
movq %rdx, %r14
movq 0x10(%rsi), %r15
movq %rsi, %rdi
callq 0x24a02e
movl %eax, %ebp
testl %eax, %eax
jle 0x24a9ca
cmpl $0x1, %ebp
je 0x24a983
movl %ebp, %esi
negl %esi
movq %r15, %rdi
callq 0x22d42e
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22d88c
testl %eax, %eax
jne 0x24a9c2
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22d7b8
movq %r15, %rdi
movl %eax, %esi
callq 0x22d7d3
leaq 0x188b9b(%rip), %rsi    # 0x3d354d
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x230abd
movq %rbx, %rdi
callq 0x231673
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lpeg-0.10.2/lpeg.c
// Function: printcharset
static void printcharset (const Charset st) {
  int i;
  printf("[");
  for (i = 0; i <= UCHAR_MAX; i++) {
    int first = i;
    while (testchar(st, i) && i <= UCHAR_MAX) i++;
    if (i - 1 == first)  /* unary range? */
      printf("(%02x)", first);
    else if (i - 1 > first)  /* non-empty range? */
      printf("(%02x-%02x)", first, i - 1);
  }
  printf("]");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x5b, %edi
callq 0x17a20
leaq 0x188c9a(%rip), %r14    # 0x3d36e7
leaq 0x188c9a(%rip), %r15    # 0x3d36ee
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
leal (%r12,%r13), %eax
movl %eax, %ecx
andb $0x7, %cl
movl $0x1, %edx
shll %cl, %edx
decl %ebp
incl %r13d
cmpl $0xff, %eax
jg 0x24aa85
sarl $0x3, %eax
cltq
movzbl (%rbx,%rax), %eax
andl %eax, %edx
jne 0x24aa5c
cmpl $-0x2, %ebp
jne 0x24aa99
movq %r14, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x17070
jmp 0x24aab3
movl %r12d, %edx
subl %ebp, %edx
addl $-0x2, %edx
cmpl %r12d, %edx
jle 0x24aab3
movq %r15, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x17070
notl %ebp
addl %r12d, %ebp
addl %r12d, %r13d
movl %r13d, %r12d
cmpl $0xff, %ebp
jl 0x24aa57
movl $0x5d, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17a20
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/samtools-0.1.18/bam.c
// Function: bam_calend
uint32_t bam_calend(const bam1_core_t *c, const uint32_t *cigar)
{
	uint32_t k, end;
	end = c->pos;
	for (k = 0; k < c->n_cigar; ++k) {
		int op = cigar[k] & BAM_CIGAR_MASK;
		if (op == BAM_CMATCH || op == BAM_CDEL || op == BAM_CREF_SKIP)
			end += cigar[k] >> BAM_CIGAR_SHIFT;
	}
	return end;
}

// Assembly:
movl 0x4(%rdi), %eax
movq 0x8(%rdi), %rcx
shrq $0x30, %rcx
je 0x24ab21
xorl %edx, %edx
movl (%rsi,%rdx,4), %edi
movl %edi, %r8d
andl $0xf, %r8d
movl %edi, %r9d
shrl $0x4, %r9d
cmpl $0x3, %r8d
movl $0x0, %r8d
cmovel %r9d, %r8d
testb $0xd, %dil
cmovel %r9d, %r8d
addl %r8d, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x24aaef
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/samtools-0.1.18/bam.c
// Function: bam_cigar2qlen
int32_t bam_cigar2qlen(const bam1_core_t *c, const uint32_t *cigar)
{
	uint32_t k;
	int32_t l = 0;
	for (k = 0; k < c->n_cigar; ++k) {
		int op = cigar[k] & BAM_CIGAR_MASK;
		if (op == BAM_CMATCH || op == BAM_CINS || op == BAM_CSOFT_CLIP || op == BAM_CEQUAL || op == BAM_CDIFF)
			l += cigar[k] >> BAM_CIGAR_SHIFT;
	}
	return l;
}

// Assembly:
movq 0x8(%rdi), %rcx
xorl %eax, %eax
shrq $0x30, %rcx
je 0x24ab5d
xorl %edx, %edx
movl $0x193, %edi            # imm = 0x193
xorl %eax, %eax
movl (%rsi,%rdx,4), %r8d
movl %r8d, %r9d
andl $0xf, %r9d
cmpl $0x8, %r9d
ja 0x24ab55
btl %r9d, %edi
jae 0x24ab55
shrl $0x4, %r8d
addl %r8d, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x24ab37
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: XML_ParserCreate_MM
XML_Parser XMLCALL
XML_ParserCreate_MM(const XML_Char *encodingName,
                    const XML_Memory_Handling_Suite *memsuite,
                    const XML_Char *nameSep)
{
  XML_Parser parser = parserCreate(encodingName, memsuite, nameSep, NULL);
  if (parser != NULL && ns) {
    /* implicit context only set for root parser, since child
       parsers (i.e. external entity parsers) will inherit it
    */
    if (!setContext(parser, implicitContext)) {
      XML_ParserFree(parser);
      return NULL;
    }
  }
  return parser;
}

// Assembly:
pushq %rbx
callq 0x2531dc
movq %rax, %rbx
testq %rax, %rax
je 0x2531c5
cmpb $0x0, 0x1c8(%rbx)
je 0x2531c5
leaq 0x1814f1(%rip), %rsi    # 0x3d46a0
movq %rbx, %rdi
callq 0x25346c
testb %al, %al
jne 0x2531c5
movq %rbx, %rdi
callq 0x253721
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: XML_SetEncoding
enum XML_Status XMLCALL
XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
{
  /* Block after XML_Parse()/XML_ParseBuffer() has been called.
     XXX There's no way for the caller to determine which of the
     XXX possible error cases caused the XML_STATUS_ERROR return.
  */
  if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
    return XML_STATUS_ERROR;
  if (encodingName == NULL)
    protocolEncodingName = NULL;
  else {
    protocolEncodingName = poolCopyString(&tempPool, encodingName);
    if (!protocolEncodingName)
      return XML_STATUS_ERROR;
  }
  return XML_STATUS_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x378(%rdi), %eax
xorl %ebx, %ebx
orl $0x2, %eax
cmpl $0x3, %eax
je 0x253ecb
movq %rdi, %r14
testq %rsi, %rsi
je 0x253ebb
leaq 0x300(%r14), %rdi
callq 0x253ed5
movq %rax, 0x1c0(%r14)
testq %rax, %rax
jne 0x253ec6
jmp 0x253ecb
movq $0x0, 0x1c0(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: poolCopyString
static const XML_Char * FASTCALL
poolCopyString(STRING_POOL *pool, const XML_Char *s)
{
  do {
    if (!poolAppendChar(pool, *s))
      return NULL;
  } while (*s++);
  s = pool->start;
  poolFinish(pool);
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
movq 0x18(%r14), %rax
cmpq 0x10(%r14), %rax
jne 0x253ef8
movq %r14, %rdi
callq 0x2578ac
testb %al, %al
je 0x253f1f
movb (%r15), %al
movq 0x18(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%r14)
movb %al, (%rcx)
cmpb $0x0, (%r15)
leaq 0x1(%r15), %r15
jne 0x253ee2
movq 0x18(%r14), %rax
movq 0x20(%r14), %rbx
movq %rax, 0x20(%r14)
movq %rbx, %rax
popq %rbx
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: externalEntityInitProcessor
static enum XML_Error PTRCALL
externalEntityInitProcessor(XML_Parser parser,
                            const char *start,
                            const char *end,
                            const char **endPtr)
{
  enum XML_Error result = initializeEncoding(parser);
  if (result != XML_ERROR_NONE)
    return result;
  processor = externalEntityInitProcessor2;
  return externalEntityInitProcessor2(parser, start, end, endPtr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x255200
testl %eax, %eax
je 0x254789
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6b04(%rip), %rax      # 0x25b294
movq %rax, 0x200(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x25b294
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: poolDestroy
static void FASTCALL
poolDestroy(STRING_POOL *pool)
{
  BLOCK *p = pool->blocks;
  while (p) {
    BLOCK *tem = p->next;
    pool->mem->free_fcn(p);
    p = tem;
  }
  p = pool->freeBlocks;
  while (p) {
    BLOCK *tem = p->next;
    pool->mem->free_fcn(p);
    p = tem;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2547d5
movq (%rdi), %r14
movq 0x28(%rbx), %rax
callq *0x10(%rax)
movq %r14, %rdi
testq %r14, %r14
jne 0x2547c3
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2547f0
movq (%rdi), %r14
movq 0x28(%rbx), %rax
callq *0x10(%rax)
movq %r14, %rdi
testq %r14, %r14
jne 0x2547de
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: XML_ParseBuffer
enum XML_Status XMLCALL
XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
{
  const char *start;
  enum XML_Status result = XML_STATUS_OK;

  switch (ps_parsing) {
  case XML_SUSPENDED:
    errorCode = XML_ERROR_SUSPENDED;
    return XML_STATUS_ERROR;
  case XML_FINISHED:
    errorCode = XML_ERROR_FINISHED;
    return XML_STATUS_ERROR;
  default:
    ps_parsing = XML_PARSING;
  }

  start = bufferPtr;
  positionPtr = start;
  bufferEnd += len;
  parseEndPtr = bufferEnd;
  parseEndByteIndex += len;
  ps_finalBuffer = (XML_Bool)isFinal;

  errorCode = processor(parser, start, parseEndPtr, &bufferPtr);

  if (errorCode != XML_ERROR_NONE) {
    eventEndPtr = eventPtr;
    processor = errorProcessor;
    return XML_STATUS_ERROR;
  }
  else {
    switch (ps_parsing) {
    case XML_SUSPENDED:
      result = XML_STATUS_SUSPENDED;
      break;
    case XML_INITIALIZED: 
    case XML_PARSING:
      if (isFinal) {
        ps_parsing = XML_FINISHED;
        return result;
      }
    default: ;  /* should not happen */
    }
  }

  XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
  positionPtr = bufferPtr;
  return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x378(%rdi), %eax
cmpl $0x2, %eax
je 0x254d63
cmpl $0x3, %eax
jne 0x254d6f
movl $0x21, 0x208(%rbx)
jmp 0x254dda
movl $0x24, 0x208(%rbx)
jmp 0x254dda
movl %edx, %r14d
movl $0x1, 0x378(%rbx)
leaq 0x30(%rbx), %rcx
movq 0x30(%rbx), %rax
movq %rax, 0x220(%rbx)
movslq %esi, %rsi
movq 0x38(%rbx), %rdx
addq %rsi, %rdx
movq %rdx, 0x38(%rbx)
movq %rdx, 0x50(%rbx)
addq %rsi, 0x48(%rbx)
movb %r14b, 0x37c(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq *0x200(%rbx)
movl %eax, 0x208(%rbx)
testl %eax, %eax
je 0x254de3
movq 0x210(%rbx), %rax
movq %rax, 0x218(%rbx)
leaq -0x1a2(%rip), %rax      # 0x254c31
movq %rax, 0x200(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl 0x378(%rbx), %eax
movl $0x1, %ebp
cmpl $0x2, %eax
jae 0x254e04
testl %r14d, %r14d
je 0x254e0e
movl $0x2, 0x378(%rbx)
jmp 0x254ddc
cmpl $0x3, %eax
jne 0x254e0e
movl $0x2, %ebp
movq 0x30(%rbx), %rdx
movq 0x120(%rbx), %rdi
movq 0x220(%rbx), %rsi
leaq 0x2f0(%rbx), %rcx
callq *0x60(%rdi)
movq 0x30(%rbx), %rax
movq %rax, 0x220(%rbx)
jmp 0x254ddc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: XML_ResumeParser
enum XML_Status XMLCALL
XML_ResumeParser(XML_Parser parser)
{
  enum XML_Status result = XML_STATUS_OK;

  if (ps_parsing != XML_SUSPENDED) {
    errorCode = XML_ERROR_NOT_SUSPENDED;
    return XML_STATUS_ERROR;
  }
  ps_parsing = XML_PARSING;

  errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);

  if (errorCode != XML_ERROR_NONE) {
    eventEndPtr = eventPtr;
    processor = errorProcessor;
    return XML_STATUS_ERROR;
  }
  else {
    switch (ps_parsing) {
    case XML_SUSPENDED:
      result = XML_STATUS_SUSPENDED;
      break;
    case XML_INITIALIZED: 
    case XML_PARSING:
      if (ps_finalBuffer) {
        ps_parsing = XML_FINISHED;
        return result;
      }
    default: ;
    }
  }

  XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
  positionPtr = bufferPtr;
  return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, 0x378(%rdi)
jne 0x254edc
movl $0x1, 0x378(%rbx)
leaq 0x30(%rbx), %rcx
movq 0x30(%rbx), %rsi
movq 0x50(%rbx), %rdx
movq %rbx, %rdi
callq *0x200(%rbx)
movl %eax, 0x208(%rbx)
testl %eax, %eax
je 0x254ef1
movq 0x210(%rbx), %rax
movq %rax, 0x218(%rbx)
leaq -0x2a2(%rip), %rax      # 0x254c31
movq %rax, 0x200(%rbx)
jmp 0x254ee6
movl $0x22, 0x208(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl 0x378(%rbx), %eax
movl $0x1, %ebp
cmpl $0x2, %eax
jae 0x254f16
cmpb $0x0, 0x37c(%rbx)
je 0x254f20
movl $0x2, 0x378(%rbx)
jmp 0x254ee8
cmpl $0x3, %eax
jne 0x254f20
movl $0x2, %ebp
movq 0x30(%rbx), %rdx
movq 0x120(%rbx), %rdi
movq 0x220(%rbx), %rsi
leaq 0x2f0(%rbx), %rcx
callq *0x60(%rdi)
movq 0x30(%rbx), %rax
movq %rax, 0x220(%rbx)
jmp 0x254ee8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: XML_GetCurrentLineNumber
XML_Size XMLCALL
XML_GetCurrentLineNumber(XML_Parser parser)
{
  if (eventPtr && eventPtr >= positionPtr) {
    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
    positionPtr = eventPtr;
  }
  return position.lineNumber + 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x210(%rdi), %rdx
testq %rdx, %rdx
je 0x254ffa
movq 0x220(%rbx), %rsi
cmpq %rsi, %rdx
jb 0x254ffa
movq 0x120(%rbx), %rdi
leaq 0x2f0(%rbx), %rcx
callq *0x60(%rdi)
movq 0x210(%rbx), %rax
movq %rax, 0x220(%rbx)
movq 0x2f0(%rbx), %rax
incq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: XML_GetCurrentColumnNumber
XML_Size XMLCALL
XML_GetCurrentColumnNumber(XML_Parser parser)
{
  if (eventPtr && eventPtr >= positionPtr) {
    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
    positionPtr = eventPtr;
  }
  return position.columnNumber;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x210(%rdi), %rdx
testq %rdx, %rdx
je 0x255041
movq 0x220(%rbx), %rsi
cmpq %rsi, %rdx
jb 0x255041
movq 0x120(%rbx), %rdi
leaq 0x2f0(%rbx), %rcx
callq *0x60(%rdi)
movq 0x210(%rbx), %rax
movq %rax, 0x220(%rbx)
movq 0x2f8(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: XML_DefaultCurrent
void XMLCALL
XML_DefaultCurrent(XML_Parser parser)
{
  if (defaultHandler) {
    if (openInternalEntities)
      reportDefault(parser,
                    internalEncoding,
                    openInternalEntities->internalEventPtr,
                    openInternalEntities->internalEventEndPtr);
    else
      reportDefault(parser, encoding, eventPtr, eventEndPtr);
  }
}

// Assembly:
cmpq $0x0, 0xa0(%rdi)
je 0x255097
movq 0x228(%rdi), %rax
testq %rax, %rax
je 0x255098
movq 0x1b8(%rdi), %rsi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
jmp 0x2550af
retq
movq 0x120(%rdi), %rsi
movq 0x210(%rdi), %rdx
movq 0x218(%rdi), %rcx
jmp 0x2550af
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: reportDefault
static void
reportDefault(XML_Parser parser, const ENCODING *enc,
              const char *s, const char *end)
{
  if (MUST_CONVERT(enc, s)) {
    const char **eventPP;
    const char **eventEndPP;
    if (enc == encoding) {
      eventPP = &eventPtr;
      eventEndPP = &eventEndPtr;
    }
    else {
      eventPP = &(openInternalEntities->internalEventPtr);
      eventEndPP = &(openInternalEntities->internalEventEndPtr);
    }
    do {
      ICHAR *dataPtr = (ICHAR *)dataBuf;
      XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
      *eventEndPP = s;
      defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));
      *eventPP = s;
    } while (s != end);
  }
  else
    defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movq %rdx, 0x8(%rsp)
cmpb $0x0, 0x84(%rsi)
je 0x2550f3
movq 0x8(%r14), %rdi
movq 0xa0(%r14), %rax
subl %edx, %ebx
movq %rdx, %rsi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rsi, %r15
cmpq %rsi, 0x120(%r14)
je 0x25510c
movq 0x228(%r14), %rbp
leaq 0x8(%rbp), %r12
jmp 0x25511a
leaq 0x210(%r14), %rbp
leaq 0x218(%r14), %r12
leaq 0x10(%rsp), %r13
movq 0x58(%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%r14), %r8
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq *0x70(%r15)
movq 0x8(%rsp), %rax
movq %rax, (%r12)
movq 0x8(%r14), %rdi
movq 0x58(%r14), %rsi
movl 0x10(%rsp), %edx
subl %esi, %edx
callq *0xa0(%r14)
movq 0x8(%rsp), %rax
movq %rax, (%rbp)
cmpq %rbx, 0x8(%rsp)
jne 0x25511f
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: prologInitProcessor
static enum XML_Error PTRCALL
prologInitProcessor(XML_Parser parser,
                    const char *s,
                    const char *end,
                    const char **nextPtr)
{
  enum XML_Error result = initializeEncoding(parser);
  if (result != XML_ERROR_NONE)
    return result;
  processor = prologProcessor;
  return prologProcessor(parser, s, end, nextPtr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x255200
testl %eax, %eax
je 0x2551d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x57(%rip), %rax        # 0x255236
movq %rax, 0x200(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x255236
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlparse.c
// Function: handleUnknownEncoding
static enum XML_Error
handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)
{
  if (unknownEncodingHandler) {
    XML_Encoding info;
    int i;
    for (i = 0; i < 256; i++)
      info.map[i] = -1;
    info.convert = NULL;
    info.data = NULL;
    info.release = NULL;
    if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName,
                               &info)) {
      ENCODING *enc;
      unknownEncodingMem = MALLOC(XmlSizeOfUnknownEncoding());
      if (!unknownEncodingMem) {
        if (info.release)
          info.release(info.data);
        return XML_ERROR_NO_MEMORY;
      }
      enc = (ns
             ? XmlInitUnknownEncodingNS
             : XmlInitUnknownEncoding)(unknownEncodingMem,
                                       info.map,
                                       info.convert,
                                       info.data);
      if (enc) {
        unknownEncodingData = info.data;
        unknownEncodingRelease = info.release;
        encoding = enc;
        return XML_ERROR_NONE;
      }
    }
    if (info.release != NULL)
      info.release(info.data);
  }
  return XML_ERROR_UNKNOWN_ENCODING;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
movq 0xf8(%rdi), %r12
testq %r12, %r12
je 0x2570ac
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
movl $0xff, %esi
callq 0x173a0
xorps %xmm0, %xmm0
movups %xmm0, 0x400(%r15)
movq $0x0, 0x410(%r15)
movq 0x1e0(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *%r12
testl %eax, %eax
je 0x257061
movq 0x18(%rbx), %r14
callq 0x25c593
movslq %eax, %rdi
callq *%r14
movq %rax, 0x1d0(%rbx)
testq %rax, %rax
je 0x257063
leaq 0x8(%rsp), %rsi
movq 0x400(%rsi), %rcx
movq 0x408(%rsi), %rdx
movq %rax, %rdi
callq 0x25c599
testq %rax, %rax
je 0x257083
movq 0x408(%rsp), %rcx
movq %rcx, 0x1d8(%rbx)
movq 0x418(%rsp), %rcx
movq %rcx, 0x1e8(%rbx)
movq %rax, 0x120(%rbx)
xorl %ebx, %ebx
jmp 0x25707f
jmp 0x257089
movq 0x418(%rsp), %rax
movl $0x1, %ebx
testq %rax, %rax
je 0x25707f
movq 0x408(%rsp), %rdi
callq *%rax
xorl %eax, %eax
jmp 0x257085
movb $0x1, %al
testb %al, %al
je 0x2570a5
movq 0x418(%rsp), %rax
movb $0x1, %bpl
testq %rax, %rax
je 0x2570a7
movq 0x408(%rsp), %rdi
callq *%rax
jmp 0x2570a7
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x2570b1
movl $0x12, %ebx
movl %ebx, %eax
addq $0x420, %rsp            # imm = 0x420
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/xmlparse.c
// Function: poolStoreString
static XML_Char *
poolStoreString(STRING_POOL *pool, const ENCODING *enc,
                const char *ptr, const char *end)
{
  if (!poolAppend(pool, enc, ptr, end))
    return NULL;
  if (pool->ptr == pool->end && !poolGrow(pool))
    return NULL;
  *(pool->ptr)++ = 0;
  return pool->start;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x257718
testq %rax, %rax
je 0x2573dc
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
jne 0x2573c7
movq %rbx, %rdi
callq 0x2578ac
testb %al, %al
je 0x2573dc
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb $0x0, (%rax)
movq 0x20(%rbx), %rax
jmp 0x2573de
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2573fc
cmpl $0x20, %esi
je 0x257401
cmpl $0xd, %esi
je 0x257401
jmp 0x257414
cmpl $0xa, %esi
jne 0x257410
cmpq %rdi, %rax
je 0x257419
movb $0x20, %dl
cmpb $0x20, -0x1(%rax)
jne 0x257414
jmp 0x257419
testl %esi, %esi
je 0x25741e
movb %dl, (%rax)
incq %rax
incq %rcx
jmp 0x2573e6
cmpq %rdi, %rax
je 0x25742f
leaq -0x1(%rax), %rcx
cmpb $0x20, -0x1(%rax)
cmoveq %rcx, %rax
movb $0x0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x258124
movl %eax, %ebp
testl %eax, %eax
jne 0x257476
movq %rbx, %rdi
callq 0x25904e
testb %al, %al
jne 0x257476
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2573a3
testq %rax, %rax
je 0x2574f6
movq %rax, %r15
leaq 0x28(%r12), %rdi
movl $0x28, %edx
movq %rax, %rsi
callq 0x257a9b
testq %rax, %rax
je 0x2574f6
movq %rax, %rbx
cmpq %r15, (%rax)
je 0x2574d7
movq 0xc0(%r12), %rax
movq %rax, 0xb8(%r12)
jmp 0x2574f8
movq 0xb8(%r12), %rax
movq %rax, 0xc0(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25a8ac
testl %eax, %eax
jne 0x2574f8
xorl %ebx, %ebx
movq %rbx, %rax
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: 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 0x257743
movq %r14, %rdi
callq 0x2578ac
testb %al, %al
je 0x25777b
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 0x257775
movq %r14, %rdi
callq 0x2578ac
testb %al, %al
jne 0x25774d
jmp 0x25777e
movq 0x20(%r14), %r12
jmp 0x25777e
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_O1/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
testb %al, %dl
jne 0x257815
movslq 0x18(%rbx), %rax
testq %rax, %rax
setg %dl
jle 0x2577f2
movq 0x20(%rbx), %rsi
cmpq %r14, (%rsi)
je 0x257808
addq $0x18, %rsi
movl $0x1, %edx
cmpq %rdx, %rax
je 0x2577ef
incq %rdx
leaq 0x18(%rsi), %rdi
cmpq %r14, (%rsi)
movq %rdi, %rsi
jne 0x2577d0
decq %rdx
cmpq %rax, %rdx
setb %dl
jmp 0x257808
seta %dl
testb %cl, %cl
je 0x257808
cmpq $0x0, 0x10(%rbx)
jne 0x257808
cmpb $0x0, 0x11(%r14)
jne 0x257808
movq %r14, 0x10(%rbx)
movl $0x1, %eax
testb %dl, %dl
jne 0x2578a3
movslq 0x1c(%rbx), %r12
cmpl %r12d, 0x18(%rbx)
jne 0x257875
testl %r12d, %r12d
je 0x257851
movq 0x20(%rbx), %rdi
movq %r12, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
callq *0x20(%r9)
movq %rax, %rcx
testq %rax, %rax
je 0x25786e
addl %r12d, %r12d
movl %r12d, 0x1c(%rbx)
movq %rcx, 0x20(%rbx)
movl $0x1, %eax
jmp 0x257870
movl $0x8, 0x1c(%rbx)
movl $0xc0, %edi
callq *0x18(%r9)
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x257875
xorl %eax, %eax
jmp 0x2578a3
xorl %eax, %eax
testq %rcx, %rcx
je 0x2578a3
movq 0x20(%rbx), %rcx
movslq 0x18(%rbx), %rax
leaq (%rax,%rax,2), %rdx
movq %r14, (%rcx,%rdx,8)
movq %r15, 0x10(%rcx,%rdx,8)
movb %bpl, 0x8(%rcx,%rdx,8)
testb %bpl, %bpl
jne 0x257899
movb $0x1, 0x10(%r14)
incl %eax
movl %eax, 0x18(%rbx)
movl $0x1, %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/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 0x25aca9
testl %eax, %eax
jne 0x257a74
testb %bpl, %bpl
je 0x257a7b
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
jne 0x257a63
movq %rbx, %rdi
callq 0x2578ac
testb %al, %al
je 0x257a94
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
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x257a4d
cmpb $0x20, -0x1(%rax)
jne 0x257a4d
decq %rax
movq %rax, 0x18(%rbx)
jmp 0x257a4d
movl $0x1, %eax
jmp 0x257a74
// File: /workspace/github_c_makefile_star2_O1/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 0x257e46
movl 0x368(%rbx), %edi
shlq $0x2, %rdi
callq *0x18(%rbx)
movq %rax, 0x138(%r14)
testq %rax, %rax
je 0x257f10
movl $0x0, (%rax)
movl 0x12c(%r14), %esi
cmpl %esi, 0x130(%r14)
jb 0x257ea3
movq 0x120(%r14), %rdi
testq %rdi, %rdi
je 0x257e7f
addl %esi, %esi
shlq $0x5, %rsi
callq *0x20(%rbx)
testq %rax, %rax
je 0x257f10
movl 0x12c(%r14), %ecx
addl %ecx, %ecx
jmp 0x257e95
movl $0x400, %edi            # imm = 0x400
callq *0x18(%rbx)
testq %rax, %rax
je 0x257f10
movl $0x20, %ecx
movl %ecx, 0x12c(%r14)
movq %rax, 0x120(%r14)
movl 0x130(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x130(%r14)
movq 0x120(%r14), %rcx
movslq %eax, %rdx
movslq 0x134(%r14), %rsi
testq %rsi, %rsi
je 0x257f02
movq 0x138(%r14), %rdi
movslq -0x4(%rdi,%rsi,4), %rdi
shlq $0x5, %rdi
leaq (%rcx,%rdi), %rsi
movslq 0x14(%rcx,%rdi), %rdi
testq %rdi, %rdi
je 0x257ef0
shlq $0x5, %rdi
movl %eax, 0x1c(%rcx,%rdi)
movl 0x18(%rsi), %edi
testl %edi, %edi
jne 0x257efa
movl %eax, 0x10(%rsi)
movl %eax, 0x14(%rsi)
incl %edi
movl %edi, 0x18(%rsi)
shlq $0x5, %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx,%rdx)
jmp 0x257f15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x258007
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 0x2573a3
xorl %ebp, %ebp
testq %rax, %rax
je 0x25804f
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 0x2573a3
testq %rax, %rax
je 0x25804f
movq %rax, %r14
movq %rax, %rdi
callq 0x25b254
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 0x258026
testq %rax, %rax
je 0x258030
movq %rax, %rdx
movq (%rax), %rax
movq %rcx, (%rdx)
movq %rdx, %rcx
testq %rax, %rax
jne 0x257ff4
jmp 0x258029
movl $0x1, %ebp
cmpq $0x0, 0xa0(%rbx)
je 0x25804f
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x2550af
jmp 0x25804f
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_O1/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 0x2580d7
leaq 0x300(%rbx), %rdi
movslq 0x80(%rsi), %rax
leaq (%rdx,%rax,4), %rdx
leaq (%rax,%rax,2), %rax
subq %rax, %rcx
callq 0x2573a3
testq %rax, %rax
je 0x2580f0
movq %rax, %r14
movq %rax, %rdi
callq 0x25b254
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq *0x88(%rbx)
movq 0x300(%rbx), %rax
movq 0x308(%rbx), %rcx
testq %rcx, %rcx
je 0x2580f4
testq %rax, %rax
je 0x2580fe
movq %rax, %rdx
movq (%rax), %rax
movq %rcx, (%rdx)
movq %rdx, %rcx
testq %rax, %rax
jne 0x2580c4
jmp 0x2580f7
movl $0x1, %ebp
cmpq $0x0, 0xa0(%rbx)
je 0x25811d
movq %rbx, %rdi
callq 0x2550af
jmp 0x25811d
xorl %ebp, %ebp
jmp 0x25811d
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_O1/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 %rdi, %r14
movq 0x2a0(%rdi), %r13
movb $0x1, %bl
testq %r13, %r13
je 0x259115
movslq 0x30(%r13), %rbp
movq 0x40(%r13), %rdi
leaq (%rdi,%rbp), %r15
incq %r15
cmpq %r15, 0x8(%r13)
je 0x2590fa
incq %rbp
movl 0x10(%r13), %eax
addl %ebp, %eax
movslq %eax, %r12
movq 0x48(%r13), %rax
subq %rdi, %rax
cmpq %r12, %rax
jge 0x2590de
movq %r12, %rsi
callq *0x20(%r14)
testq %rax, %rax
je 0x2590d9
movq 0x40(%r13), %rcx
cmpq %rcx, 0x18(%r13)
jne 0x2590b5
movq %rax, 0x18(%r13)
movq 0x20(%r13), %rdx
testq %rdx, %rdx
je 0x2590c8
subq %rcx, %rdx
addq %rax, %rdx
movq %rdx, 0x20(%r13)
movq %rax, 0x40(%r13)
addq %rax, %r12
movq %r12, 0x48(%r13)
addq %rax, %rbp
movq %rbp, %r15
testq %rax, %rax
je 0x259101
movq 0x8(%r13), %rsi
movslq 0x10(%r13), %rdx
movq %r15, %rdi
callq 0x17660
movq %r15, 0x8(%r13)
movq (%r13), %r13
xorl %eax, %eax
jmp 0x259106
movl $0x3, %eax
jmp 0x259106
movl $0x1, %eax
testl %eax, %eax
je 0x259063
cmpl $0x3, %eax
je 0x259115
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq