LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
cmpl $0x0, -0x8(%rsp)
jge 0x383cba
movl $0x0, -0x4(%rsp)
jmp 0x383d37
cmpl $0x10000, -0x8(%rsp)    # imm = 0x10000
jge 0x383cdd
movl -0x8(%rsp), %eax
movw %ax, %cx
movq -0x10(%rsp), %rax
movw %cx, (%rax)
movl $0x1, -0x4(%rsp)
jmp 0x383d37
cmpl $0x110000, -0x8(%rsp)   # imm = 0x110000
jge 0x383d2f
movl -0x8(%rsp), %eax
subl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
sarl $0xa, %eax
addl $0xd800, %eax           # imm = 0xD800
movw %ax, %cx
movq -0x10(%rsp), %rax
movw %cx, (%rax)
movl -0x8(%rsp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
addl $0xdc00, %eax           # imm = 0xDC00
movw %ax, %cx
movq -0x10(%rsp), %rax
movw %cx, 0x2(%rax)
movl $0x2, -0x4(%rsp)
jmp 0x383d37
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rsp)
movl -0x8(%rsp), %eax
sarl $0x8, %eax
movl %eax, -0xc(%rsp)
testl %eax, %eax
je 0x3842ec
jmp 0x3842c5
movl -0xc(%rsp), %eax
addl $0xffffff28, %eax       # imm = 0xFFFFFF28
subl $0x8, %eax
jb 0x3842e2
jmp 0x3842d5
movl -0xc(%rsp), %eax
subl $0xff, %eax
je 0x384311
jmp 0x384331
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x384339
movslq -0x8(%rsp), %rcx
leaq 0x2b4008(%rip), %rax    # 0x638300
movzbl 0x88(%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x38430f
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x384339
jmp 0x384331
cmpl $0xfffe, -0x8(%rsp)     # imm = 0xFFFE
je 0x384325
cmpl $0xffff, -0x8(%rsp)     # imm = 0xFFFF
jne 0x38432f
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x384339
jmp 0x384331
movl -0x8(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: unknown_isName
static int PTRFASTCALL
unknown_isName(const ENCODING *enc, const char *p)
{
  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
  int c = uenc->convert(uenc->userData, p);
  if (c & ~0xFFFF)
    return 0;
  return UCS2_GET_NAMING(namePages, c >> 8, c & 0xFF);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x1d0(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x1d8(%rcx), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
andl $0xffff0000, %eax       # imm = 0xFFFF0000
cmpl $0x0, %eax
je 0x384393
movl $0x0, 0x24(%rsp)
jmp 0x3843e3
movl 0x4(%rsp), %eax
sarl $0x8, %eax
movslq %eax, %rcx
leaq 0x21d5cc(%rip), %rax    # 0x5a1970
movzbl (%rax,%rcx), %eax
shll $0x3, %eax
movl 0x4(%rsp), %ecx
andl $0xff, %ecx
sarl $0x5, %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x21cf9c(%rip), %rax    # 0x5a1360
movl (%rax,%rcx,4), %eax
movl 0x4(%rsp), %ecx
andl $0xff, %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: unknown_isNmstrt
static int PTRFASTCALL
unknown_isNmstrt(const ENCODING *enc, const char *p)
{
  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
  int c = uenc->convert(uenc->userData, p);
  if (c & ~0xFFFF)
    return 0;
  return UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xFF);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x1d0(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x1d8(%rcx), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
andl $0xffff0000, %eax       # imm = 0xFFFF0000
cmpl $0x0, %eax
je 0x384443
movl $0x0, 0x24(%rsp)
jmp 0x384493
movl 0x4(%rsp), %eax
sarl $0x8, %eax
movslq %eax, %rcx
leaq 0x21d41c(%rip), %rax    # 0x5a1870
movzbl (%rax,%rcx), %eax
shll $0x3, %eax
movl 0x4(%rsp), %ecx
andl $0xff, %ecx
sarl $0x5, %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x21ceec(%rip), %rax    # 0x5a1360
movl (%rax,%rcx,4), %eax
movl 0x4(%rsp), %ecx
andl $0xff, %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: unknown_toUtf8
static void PTRCALL
unknown_toUtf8(const ENCODING *enc,
               const char **fromP, const char *fromLim,
               char **toP, const char *toLim)
{
  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
  char buf[XML_UTF8_ENCODE_MAX];
  for (;;) {
    const char *utf8;
    int n;
    if (*fromP == fromLim)
      break;
    utf8 = uenc->utf8[(unsigned char)**fromP];
    n = *utf8++;
    if (n == 0) {
      int c = uenc->convert(uenc->userData, *fromP);
      n = XmlUtf8Encode(c, buf);
      if (n > toLim - *toP)
        break;
      utf8 = buf;
      *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
                 - (BT_LEAD2 - 2));
    }
    else {
      if (n > toLim - *toP)
        break;
      (*fromP)++;
    }
    do {
      *(*toP)++ = *utf8++;
    } while (--n != 0);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
cmpq 0x30(%rsp), %rax
jne 0x38455b
jmp 0x384696
movq 0x18(%rsp), %rax
addq $0x3e0, %rax            # imm = 0x3E0
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
movzbl (%rcx), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movsbl (%rax), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x38462d
movq 0x18(%rsp), %rax
movq 0x1d0(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x1d8(%rcx), %rdi
movq 0x38(%rsp), %rcx
movq (%rcx), %rsi
callq *%rax
movl %eax, (%rsp)
movl (%rsp), %edi
leaq 0x14(%rsp), %rsi
callq 0x383b40
movl %eax, 0x4(%rsp)
movslq 0x4(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jle 0x3845f5
jmp 0x384696
leaq 0x14(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
movzbl (%rcx), %ecx
movzbl 0x88(%rax,%rcx), %edx
subl $0x3, %edx
movq 0x38(%rsp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x384658
movslq 0x4(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jle 0x384649
jmp 0x384696
movq 0x38(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x38465a
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb (%rax), %cl
movq 0x28(%rsp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
jne 0x38465a
jmp 0x384547
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: unknown_toUtf16
static void PTRCALL
unknown_toUtf16(const ENCODING *enc,
                const char **fromP, const char *fromLim,
                unsigned short **toP, const unsigned short *toLim)
{
  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
  while (*fromP != fromLim && *toP != toLim) {
    unsigned short c = uenc->utf16[(unsigned char)**fromP];
    if (c == 0) {
      c = (unsigned short)
          uenc->convert(uenc->userData, *fromP);
      *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
                 - (BT_LEAD2 - 2));
    }
    else
      (*fromP)++;
    *(*toP)++ = c;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq 0x20(%rsp), %rcx
movb %al, 0x5(%rsp)
je 0x3846f0
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq 0x10(%rsp), %rax
setne %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
testb $0x1, %al
jne 0x3846fd
jmp 0x3847a7
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movzbl (%rcx), %ecx
movw 0x1e0(%rax,%rcx,2), %ax
movw %ax, 0x6(%rsp)
movzwl 0x6(%rsp), %eax
cmpl $0x0, %eax
jne 0x384779
movq 0x8(%rsp), %rax
movq 0x1d0(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x1d8(%rcx), %rdi
movq 0x28(%rsp), %rcx
movq (%rcx), %rsi
callq *%rax
movw %ax, 0x6(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movzbl (%rcx), %ecx
movzbl 0x88(%rax,%rcx), %edx
subl $0x3, %edx
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x384788
movq 0x28(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movw 0x6(%rsp), %cx
movq 0x18(%rsp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x2, %rsi
movq %rsi, (%rdx)
movw %cx, (%rax)
jmp 0x3846c7
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_ns.c
// Function: XmlInitEncoding
int
NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
                    const char *name)
{
  int i = getEncodingIndex(name);
  if (i == UNKNOWN_ENC)
    return 0;
  SET_INIT_ENC_INDEX(p, i);
  p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
  p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
  p->initEnc.updatePosition = initUpdatePosition;
  p->encPtr = encPtr;
  *encPtr = &(p->initEnc);
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x3848a0
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jne 0x384822
movl $0x0, 0x24(%rsp)
jmp 0x384888
movl 0x4(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0x85(%rax)
movq 0x18(%rsp), %rax
leaq 0xe1(%rip), %rcx        # 0x384920
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
leaq 0x112(%rip), %rcx       # 0x384960
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
leaq 0x152(%rip), %rcx       # 0x3849b0
movq %rcx, 0x60(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: getEncodingIndex
static int FASTCALL
getEncodingIndex(const char *name)
{
  static const char * const encodingNames[] = {
    KW_ISO_8859_1,
    KW_US_ASCII,
    KW_UTF_8,
    KW_UTF_16,
    KW_UTF_16BE,
    KW_UTF_16LE,
  };
  int i;
  if (name == NULL)
    return NO_ENC;
  for (i = 0; i < (int)(sizeof(encodingNames)/sizeof(encodingNames[0])); i++)
    if (streqci(name, encodingNames[i]))
      return i;
  return UNKNOWN_ENC;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x3848bb
movl $0x6, 0x14(%rsp)
jmp 0x38490a
movl $0x0, 0x4(%rsp)
cmpl $0x6, 0x4(%rsp)
jge 0x384902
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rcx
leaq 0x2b4165(%rip), %rax    # 0x638a40
movq (%rax,%rcx,8), %rsi
callq 0x397f90
cmpl $0x0, %eax
je 0x3848f3
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x38490a
jmp 0x3848f5
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3848c3
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_ns.c
// Function: XmlParseXmlDecl
int
NS(XmlParseXmlDecl)(int isGeneralTextEntity,
                    const ENCODING *enc,
                    const char *ptr,
                    const char *end,
                    const char **badPtr,
                    const char **versionPtr,
                    const char **versionEndPtr,
                    const char **encodingName,
                    const ENCODING **encoding,
                    int *standalone)
{
  return doParseXmlDecl(NS(findEncoding),
                        isGeneralTextEntity,
                        enc,
                        ptr,
                        end,
                        badPtr,
                        versionPtr,
                        versionEndPtr,
                        encodingName,
                        encoding,
                        standalone);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movl 0x54(%rsp), %esi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %r14
movq 0x70(%rsp), %rbx
movq 0x78(%rsp), %r11
movq 0x80(%rsp), %r10
movq 0x88(%rsp), %rax
leaq 0x4e4(%rip), %rdi       # 0x384f50
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x384aa0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_ns.c
// Function: findEncoding
static const ENCODING *
NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end)
{
#define ENCODING_MAX 128
  char buf[ENCODING_MAX] = {0}; /* to satisfy gcc-10 on Linux, which
                                   reported
        error: ‘buf’ may be used uninitialized [-Werror=maybe-uninitialized] */
  char *p = buf;
  int i;
  XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
  if (ptr != end)
    return 0;
  *p = 0;
  if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
    return enc;
  i = getEncodingIndex(buf);
  if (i == UNKNOWN_ENC)
    return 0;
  return NS(encodings)[i];
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x19360
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xa8(%rsp), %rax
movq 0x70(%rax), %rax
movq 0xa8(%rsp), %rdi
movq 0x98(%rsp), %rdx
movq 0x8(%rsp), %r8
addq $0x80, %r8
addq $-0x1, %r8
leaq 0xa0(%rsp), %rsi
leaq 0x8(%rsp), %rcx
callq *%rax
movq 0xa0(%rsp), %rax
cmpq 0x98(%rsp), %rax
je 0x384fe5
movq $0x0, 0xb0(%rsp)
jmp 0x385061
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
leaq 0x10(%rsp), %rdi
leaq 0x21ca9d(%rip), %rsi    # 0x5a1a96
callq 0x397f90
cmpl $0x0, %eax
je 0x385026
movq 0xa8(%rsp), %rax
cmpl $0x2, 0x80(%rax)
jne 0x385026
movq 0xa8(%rsp), %rax
movq %rax, 0xb0(%rsp)
jmp 0x385061
leaq 0x10(%rsp), %rdi
callq 0x3848a0
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jne 0x385049
movq $0x0, 0xb0(%rsp)
jmp 0x385061
movslq 0x4(%rsp), %rcx
leaq 0x2b3a1b(%rip), %rax    # 0x638a70
movq (%rax,%rcx,8), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: normal_nameMatchesAscii
static int PTRCALL
PREFIX(nameMatchesAscii)(__attribute__ ((unused)) const ENCODING *enc, const char *ptr1,
                         const char *end1, const char *ptr2)
{
  for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
    if (ptr1 == end1)
      return 0;
    if (!CHAR_MATCHES(enc, ptr1, *ptr2))
      return 0;
  }
  return ptr1 == end1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpb $0x0, (%rax)
je 0x386bf2
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jne 0x386bb4
movl $0x0, -0x4(%rsp)
jmp 0x386c08
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
movq -0x28(%rsp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x386bd2
movl $0x0, -0x4(%rsp)
jmp 0x386c08
jmp 0x386bd4
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x386b94
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_nameLength
PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
{
  const char *start = ptr;
  for (;;) {
    switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \
    case BT_LEAD ## n: ptr += n; break;
    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
#undef LEAD_CASE
    case BT_NONASCII:
    case BT_NMSTRT:
#ifdef XML_NS
    case BT_COLON:
#endif
    case BT_HEX:
    case BT_DIGIT:
    case BT_NAME:
    case BT_MINUS:
      ptr += MINBPC(enc);
      break;
    default:
      return (int)(ptr - start);
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x38d231
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rcx), %ecx
movzbl 0x88(%rax,%rcx), %eax
movl %eax, 0xc(%rsp)
jmp 0x38d24d
movq 0x18(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x18(%rsp), %rax
movsbl %cl, %edi
movsbl (%rax), %esi
callq 0x38e510
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x18, %eax
ja 0x38d2b3
movq (%rsp), %rax
leaq 0x212d1a(%rip), %rcx    # 0x59ff84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x18(%rsp)
jmp 0x38d2c5
movq 0x18(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x18(%rsp)
jmp 0x38d2c5
movq 0x18(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x18(%rsp)
jmp 0x38d2c5
movq 0x18(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x18(%rsp)
jmp 0x38d2c5
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rcx, %rax
addq $0x28, %rsp
retq
jmp 0x38d208
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_skipS
PREFIX(skipS)(const ENCODING *enc, const char *ptr)
{
  for (;;) {
    switch (BYTE_TYPE(enc, ptr)) {
    case BT_LF:
    case BT_CR:
    case BT_S:
      ptr += MINBPC(enc);
      break;
    default:
      return ptr;
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x38d307
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movzbl (%rcx), %ecx
movzbl 0x88(%rax,%rcx), %eax
movl %eax, 0x4(%rsp)
jmp 0x38d323
movq 0x8(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x8(%rsp), %rax
movsbl %cl, %edi
movsbl (%rax), %esi
callq 0x38e510
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x38d33e
jmp 0x38d334
movl (%rsp), %eax
subl $0x15, %eax
jne 0x38d34e
jmp 0x38d33e
movq 0x8(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x8(%rsp)
jmp 0x38d358
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
jmp 0x38d2de
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_updatePosition
static void PTRCALL
PREFIX(updatePosition)(const ENCODING *enc,
                       const char *ptr,
                       const char *end,
                       POSITION *pos)
{
  while (ptr != end) {
    switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \
    case BT_LEAD ## n: \
      ptr += n; \
      break;
    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
#undef LEAD_CASE
    case BT_LF:
      pos->columnNumber = (XML_Size)-1;
      pos->lineNumber++;
      ptr += MINBPC(enc);
      break;
    case BT_CR:
      pos->lineNumber++;
      ptr += MINBPC(enc);
      if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
        ptr += MINBPC(enc);
      pos->columnNumber = (XML_Size)-1;
      break;
    default:
      ptr += MINBPC(enc);
      break;
    }
    pos->columnNumber++;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x38def9
movq 0x28(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x38dd91
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl (%rcx), %ecx
movzbl 0x88(%rax,%rcx), %eax
movl %eax, 0x14(%rsp)
jmp 0x38ddad
movq 0x28(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x28(%rsp), %rax
movsbl %cl, %edi
movsbl (%rax), %esi
callq 0x38e510
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x5, %eax
ja 0x38ded5
movq 0x8(%rsp), %rax
leaq 0x212284(%rip), %rcx    # 0x5a0054
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
jmp 0x38dee3
movq 0x28(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x28(%rsp)
jmp 0x38dee3
movq 0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
jmp 0x38dee3
movq 0x18(%rsp), %rax
movq $-0x1, 0x8(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
jmp 0x38dee3
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x38dec6
movq 0x28(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x38de93
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movzbl (%rcx), %ecx
movzbl 0x88(%rax,%rcx), %eax
movl %eax, 0x4(%rsp)
jmp 0x38deaf
movq 0x28(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x28(%rsp), %rax
movsbl %cl, %edi
movsbl (%rax), %esi
callq 0x38e510
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl $0xa, %eax
jne 0x38dec6
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq $-0x1, 0x8(%rax)
jmp 0x38dee3
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x38dd58
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: latin1_toUtf8
static void PTRCALL
latin1_toUtf8(__attribute__ ((unused)) const ENCODING *enc,
              const char **fromP, const char *fromLim,
              char **toP, const char *toLim)
{
  for (;;) {
    unsigned char c;
    if (*fromP == fromLim)
      break;
    c = (unsigned char)**fromP;
    if (c & 0x80) {
      if (toLim - *toP < 2)
        break;
      *(*toP)++ = (char)((c >> 6) | UTF8_cval2);
      *(*toP)++ = (char)((c & 0x3f) | 0x80);
      (*fromP)++;
    }
    else {
      if (*toP == toLim)
        break;
      *(*toP)++ = *(*fromP)++;
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0x38777d
jmp 0x38784a
movq -0x10(%rsp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x29(%rsp)
movzbl -0x29(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x38780c
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x2, %rax
jge 0x3877b5
jmp 0x38784a
movzbl -0x29(%rsp), %eax
sarl $0x6, %eax
orl $0xc0, %eax
movb %al, %cl
movq -0x20(%rsp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movzbl -0x29(%rsp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x20(%rsp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x387845
movq -0x20(%rsp), %rax
movq (%rax), %rax
cmpq -0x28(%rsp), %rax
jne 0x38781d
jmp 0x38784a
movq -0x10(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %cl
movq -0x20(%rsp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
jmp 0x387769
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_checkPiTarget
static int PTRCALL
PREFIX(checkPiTarget)(__attribute__ ((unused)) const ENCODING *enc, const char *ptr,
                      const char *end, int *tokPtr)
{
  int upper = 0;
  *tokPtr = XML_TOK_PI;
  if (end - ptr != MINBPC(enc)*3)
    return 1;
  switch (BYTE_TO_ASCII(enc, ptr)) {
  case ASCII_x:
    break;
  case ASCII_X:
    upper = 1;
    break;
  default:
    return 1;
  }
  ptr += MINBPC(enc);
  switch (BYTE_TO_ASCII(enc, ptr)) {
  case ASCII_m:
    break;
  case ASCII_M:
    upper = 1;
    break;
  default:
    return 1;
  }
  ptr += MINBPC(enc);
  switch (BYTE_TO_ASCII(enc, ptr)) {
  case ASCII_l:
    break;
  case ASCII_L:
    upper = 1;
    break;
  default:
    return 1;
  }
  if (upper)
    return 0;
  *tokPtr = XML_TOK_XML_DECL;
  return 1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
movq -0x28(%rsp), %rax
movl $0xb, (%rax)
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
subq %rcx, %rax
cmpq $0x6, %rax
je 0x38fb57
movl $0x1, -0x4(%rsp)
jmp 0x38fca2
movq -0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x38fb73
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
movl %eax, -0x30(%rsp)
jmp 0x38fb7e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x30(%rsp)
jmp 0x38fb7e
movl -0x30(%rsp), %eax
movl %eax, -0x34(%rsp)
subl $0x58, %eax
je 0x38fb9a
jmp 0x38fb8d
movl -0x34(%rsp), %eax
subl $0x78, %eax
jne 0x38fba4
jmp 0x38fb98
jmp 0x38fbb1
movl $0x1, -0x2c(%rsp)
jmp 0x38fbb1
movl $0x1, -0x4(%rsp)
jmp 0x38fca2
movq -0x18(%rsp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x38fbdb
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
movl %eax, -0x38(%rsp)
jmp 0x38fbe6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x38(%rsp)
jmp 0x38fbe6
movl -0x38(%rsp), %eax
movl %eax, -0x3c(%rsp)
subl $0x4d, %eax
je 0x38fc02
jmp 0x38fbf5
movl -0x3c(%rsp), %eax
subl $0x6d, %eax
jne 0x38fc0c
jmp 0x38fc00
jmp 0x38fc19
movl $0x1, -0x2c(%rsp)
jmp 0x38fc19
movl $0x1, -0x4(%rsp)
jmp 0x38fca2
movq -0x18(%rsp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x38fc43
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
movl %eax, -0x40(%rsp)
jmp 0x38fc4e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x40(%rsp)
jmp 0x38fc4e
movl -0x40(%rsp), %eax
movl %eax, -0x44(%rsp)
subl $0x4c, %eax
je 0x38fc6a
jmp 0x38fc5d
movl -0x44(%rsp), %eax
subl $0x6c, %eax
jne 0x38fc74
jmp 0x38fc68
jmp 0x38fc7e
movl $0x1, -0x2c(%rsp)
jmp 0x38fc7e
movl $0x1, -0x4(%rsp)
jmp 0x38fca2
cmpl $0x0, -0x2c(%rsp)
je 0x38fc8f
movl $0x0, -0x4(%rsp)
jmp 0x38fca2
movq -0x28(%rsp), %rax
movl $0xc, (%rax)
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: normal_scanCdataSection
static int PTRCALL
PREFIX(scanCdataSection)(__attribute__ ((unused)) const ENCODING *enc, const char *ptr,
                         const char *end, const char **nextTokPtr)
{
  static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A,
                                     ASCII_T, ASCII_A, ASCII_LSQB };
  int i;
  /* CDATA[ */
  if (end - ptr < 6 * MINBPC(enc))
    return XML_TOK_PARTIAL;
  for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
    if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
      *nextTokPtr = ptr;
      return XML_TOK_INVALID;
    }
  }
  *nextTokPtr = ptr;
  return XML_TOK_CDATA_SECT_OPEN;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
subq %rcx, %rax
cmpq $0x6, %rax
jge 0x389bd1
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x389c45
movl $0x0, -0x2c(%rsp)
cmpl $0x6, -0x2c(%rsp)
jge 0x389c30
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
movslq -0x2c(%rsp), %rdx
leaq 0x217c6c(%rip), %rcx    # 0x5a1860
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x389c13
movq -0x18(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rsp)
jmp 0x389c45
jmp 0x389c15
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x389bd9
movq -0x18(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
movl $0x8, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_scanCharRef
static int PTRCALL
PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
                    const char *end, const char **nextTokPtr)
{
  if (ptr != end) {
    if (CHAR_MATCHES(enc, ptr, ASCII_x))
      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
    switch (BYTE_TYPE(enc, ptr)) {
    case BT_DIGIT:
      break;
    default:
      *nextTokPtr = ptr;
      return XML_TOK_INVALID;
    }
    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
      switch (BYTE_TYPE(enc, ptr)) {
      case BT_DIGIT:
        break;
      case BT_SEMI:
        *nextTokPtr = ptr + MINBPC(enc);
        return XML_TOK_CHAR_REF;
      default:
        *nextTokPtr = ptr;
        return XML_TOK_INVALID;
      }
    }
  }
  return XML_TOK_PARTIAL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x39186d
movq 0x20(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x391739
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x78, %eax
jne 0x391739
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x2, %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x391880
movl %eax, 0x34(%rsp)
jmp 0x391875
movq 0x20(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x391762
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movzbl (%rcx), %ecx
movzbl 0x88(%rax,%rcx), %eax
movl %eax, 0xc(%rsp)
jmp 0x39177e
movq 0x20(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x20(%rsp), %rax
movsbl %cl, %edi
movsbl (%rax), %esi
callq 0x38e510
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
subl $0x19, %eax
jne 0x39178b
jmp 0x391789
jmp 0x3917a5
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x34(%rsp)
jmp 0x391875
movq 0x20(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x39186b
movq 0x20(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x3917ec
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movzbl (%rcx), %ecx
movzbl 0x88(%rax,%rcx), %eax
movl %eax, 0x8(%rsp)
jmp 0x391808
movq 0x20(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x20(%rsp), %rax
movsbl %cl, %edi
movsbl (%rax), %esi
callq 0x38e510
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x12, %eax
je 0x391824
jmp 0x391817
movl 0x4(%rsp), %eax
subl $0x19, %eax
jne 0x39183f
jmp 0x391822
jmp 0x391856
movq 0x20(%rsp), %rcx
addq $0x2, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0xa, 0x34(%rsp)
jmp 0x391875
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x34(%rsp)
jmp 0x391875
jmp 0x391858
movq 0x20(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x20(%rsp)
jmp 0x3917b3
jmp 0x39186d
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_scanHexCharRef
static int PTRCALL
PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
                       const char *end, const char **nextTokPtr)
{
  if (ptr != end) {
    switch (BYTE_TYPE(enc, ptr)) {
    case BT_DIGIT:
    case BT_HEX:
      break;
    default:
      *nextTokPtr = ptr;
      return XML_TOK_INVALID;
    }
    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
      switch (BYTE_TYPE(enc, ptr)) {
      case BT_DIGIT:
      case BT_HEX:
        break;
      case BT_SEMI:
        *nextTokPtr = ptr + MINBPC(enc);
        return XML_TOK_CHAR_REF;
      default:
        *nextTokPtr = ptr;
        return XML_TOK_INVALID;
      }
    }
  }
  return XML_TOK_PARTIAL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x3919e2
movq 0x20(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x3918d1
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movzbl (%rcx), %ecx
movzbl 0x88(%rax,%rcx), %eax
movl %eax, 0xc(%rsp)
jmp 0x3918ed
movq 0x20(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x20(%rsp), %rax
movsbl %cl, %edi
movsbl (%rax), %esi
callq 0x38e510
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $-0x18, %eax
subl $0x1, %eax
ja 0x3918fd
jmp 0x3918fb
jmp 0x391917
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x34(%rsp)
jmp 0x3919ea
movq 0x20(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x3919e0
movq 0x20(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x39195e
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movzbl (%rcx), %ecx
movzbl 0x88(%rax,%rcx), %eax
movl %eax, 0x8(%rsp)
jmp 0x39197a
movq 0x20(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x20(%rsp), %rax
movsbl %cl, %edi
movsbl (%rax), %esi
callq 0x38e510
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x12, %eax
je 0x391999
jmp 0x391989
movl 0x4(%rsp), %eax
addl $-0x18, %eax
subl $0x1, %eax
ja 0x3919b4
jmp 0x391997
jmp 0x3919cb
movq 0x20(%rsp), %rcx
addq $0x2, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0xa, 0x34(%rsp)
jmp 0x3919ea
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x34(%rsp)
jmp 0x3919ea
jmp 0x3919cd
movq 0x20(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x20(%rsp)
jmp 0x391925
jmp 0x3919e2
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: utf8_toUtf8
static void PTRCALL
utf8_toUtf8(__attribute__ ((unused)) const ENCODING *enc,
            const char **fromP, const char *fromLim,
            char **toP, const char *toLim)
{
  char *to;
  const char *from;
  if (fromLim - *fromP > toLim - *toP) {
    /* Avoid copying partial characters. */
    for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--)
      if (((unsigned char)fromLim[-1] & 0xc0) != 0x80)
        break;
  }
  for (to = *toP, from = *fromP; from != fromLim; from++, to++)
    *to = *from;
  *fromP = from;
  *toP = to;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq -0x28(%rsp), %rcx
movq -0x20(%rsp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jle 0x38ac18
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
movq -0x20(%rsp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x38ac16
movq -0x18(%rsp), %rax
movzbl -0x1(%rax), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
je 0x38ac04
jmp 0x38ac16
jmp 0x38ac06
movq -0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x38abde
jmp 0x38ac18
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x18(%rsp), %rax
je 0x38ac6a
movq -0x38(%rsp), %rax
movb (%rax), %cl
movq -0x30(%rsp), %rax
movb %cl, (%rax)
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x38ac32
movq -0x38(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x30(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: unicode_byte_type
static int PTRFASTCALL
unicode_byte_type(char hi, char lo)
{
  switch ((unsigned char)hi) {
  case 0xD8: case 0xD9: case 0xDA: case 0xDB:
    return BT_LEAD4;
  case 0xDC: case 0xDD: case 0xDE: case 0xDF:
    return BT_TRAIL;
  case 0xFF:
    switch ((unsigned char)lo) {
    case 0xFF:
    case 0xFE:
      return BT_NONXML;
    }
    break;
  }
  return BT_NONASCII;
}

// Assembly:
movb %sil, %al
movb %dil, %cl
movb %cl, -0x5(%rsp)
movb %al, -0x6(%rsp)
movzbl -0x5(%rsp), %eax
movl %eax, -0xc(%rsp)
addl $0xffffff28, %eax       # imm = 0xFFFFFF28
subl $0x4, %eax
jb 0x38e550
jmp 0x38e533
movl -0xc(%rsp), %eax
addl $0xffffff24, %eax       # imm = 0xFFFFFF24
subl $0x4, %eax
jb 0x38e55a
jmp 0x38e543
movl -0xc(%rsp), %eax
subl $0xff, %eax
je 0x38e564
jmp 0x38e581
movl $0x7, -0x4(%rsp)
jmp 0x38e589
movl $0x8, -0x4(%rsp)
jmp 0x38e589
movzbl -0x6(%rsp), %eax
addl $0xffffff02, %eax       # imm = 0xFFFFFF02
subl $0x1, %eax
ja 0x38e57f
jmp 0x38e575
movl $0x0, -0x4(%rsp)
jmp 0x38e589
jmp 0x38e581
movl $0x1d, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: streqci
static int FASTCALL
streqci(const char *s1, const char *s2)
{
  for (;;) {
    char c1 = *s1++;
    char c2 = *s2++;
    if (ASCII_a <= c1 && c1 <= ASCII_z)
      c1 += ASCII_A - ASCII_a;
    if (ASCII_a <= c2 && c2 <= ASCII_z)
      c2 += ASCII_A - ASCII_a;
    if (c1 != c2)
      return 0;
    if (!c1)
      break;
  }
  return 1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x19(%rsp)
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rsp)
movb (%rax), %al
movb %al, -0x1a(%rsp)
movsbl -0x19(%rsp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x397fec
movsbl -0x19(%rsp), %eax
cmpl $0x7a, %eax
jg 0x397fec
movsbl -0x19(%rsp), %eax
addl $-0x20, %eax
movb %al, -0x19(%rsp)
movsbl -0x1a(%rsp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x398010
movsbl -0x1a(%rsp), %eax
cmpl $0x7a, %eax
jg 0x398010
movsbl -0x1a(%rsp), %eax
addl $-0x20, %eax
movb %al, -0x1a(%rsp)
movsbl -0x19(%rsp), %eax
movsbl -0x1a(%rsp), %ecx
cmpl %ecx, %eax
je 0x398028
movl $0x0, -0x4(%rsp)
jmp 0x39803e
cmpb $0x0, -0x19(%rsp)
jne 0x398031
jmp 0x398036
jmp 0x397f9a
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: toAscii
static int
toAscii(const ENCODING *enc, const char *ptr, const char *end)
{
  char buf[1];
  char *p = buf;
  XmlUtf8Convert(enc, &ptr, end, &p, p + 1);
  if (p == buf)
    return -1;
  else
    return buf[0];
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x17(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x70(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %r8
addq $0x1, %r8
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rcx
callq *%rax
movq 0x8(%rsp), %rax
leaq 0x17(%rsp), %rcx
cmpq %rcx, %rax
jne 0x39890e
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x398917
movsbl 0x17(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: isSpace
static int FASTCALL
isSpace(int c)
{
  switch (c) {
  case 0x20:
  case 0xD:
  case 0xA:
  case 0x9:
    return 1;
  }
  return 0;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x39894c
jmp 0x398936
movl -0xc(%rsp), %eax
subl $0xd, %eax
je 0x39894c
jmp 0x398941
movl -0xc(%rsp), %eax
subl $0x20, %eax
jne 0x398956
jmp 0x39894c
movl $0x1, -0x4(%rsp)
jmp 0x39895e
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_status64
SQLITE_API int sqlite3_status64(
  int op,
  sqlite3_int64 *pCurrent,
  sqlite3_int64 *pHighwater,
  int resetFlag
){
  sqlite3_mutex *pMutex;
  wsdStatInit;
  if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
    return SQLITE_MISUSE_BKPT;
  }
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex();
  sqlite3_mutex_enter(pMutex);
  *pCurrent = wsdStat.nowValue[op];
  *pHighwater = wsdStat.mxValue[op];
  if( resetFlag ){
    wsdStat.mxValue[op] = wsdStat.nowValue[op];
  }
  sqlite3_mutex_leave(pMutex);
  (void)pMutex;  /* Prevent warning when SQLITE_THREADSAFE=0 */
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x3bf5f2
cmpl $0xa, -0x8(%rbp)
jl 0x3bf604
movl $0x53d5, %edi           # imm = 0x53D5
callq 0x3bf6a0
movl %eax, -0x4(%rbp)
jmp 0x3bf68d
movslq -0x8(%rbp), %rcx
leaq 0x1e731c(%rip), %rax    # 0x5a692b
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3bf623
callq 0x3bf6d0
movq %rax, -0x30(%rbp)
jmp 0x3bf62c
callq 0x3bf6e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x283b19(%rip), %rax    # 0x643158
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movslq -0x8(%rbp), %rcx
leaq 0x283b03(%rip), %rax    # 0x643158
movq 0x50(%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x3bf686
movslq -0x8(%rbp), %rcx
leaq 0x283ae6(%rip), %rax    # 0x643158
movq (%rax,%rcx,8), %rdx
movslq -0x8(%rbp), %rcx
leaq 0x283ad7(%rip), %rax    # 0x643158
movq %rdx, 0x50(%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_status
SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
  sqlite3_int64 iCur = 0, iHwtr = 0;
  int rc;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);
  if( rc==0 ){
    *pCurrent = (int)iCur;
    *pHighwater = (int)iHwtr;
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x4(%rbp), %edi
movl -0x1c(%rbp), %ecx
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3bf5d0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x3bf74a
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3LookasideUsed
SQLITE_PRIVATE int sqlite3LookasideUsed(sqlite3 *db, int *pHighwater){
  u32 nInit = countLookasideSlots(db->lookaside.pInit);
  u32 nFree = countLookasideSlots(db->lookaside.pFree);
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
  nInit += countLookasideSlots(db->lookaside.pSmallInit);
  nFree += countLookasideSlots(db->lookaside.pSmallFree);
#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */
  if( pHighwater ) *pHighwater = db->lookaside.nSlot - nInit;
  return db->lookaside.nSlot - (nInit+nFree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x190(%rax), %rdi
callq 0x3d5dc0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rdi
callq 0x3d5dc0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rdi
callq 0x3d5dc0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rdi
callq 0x3d5dc0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3bfd1c
movq -0x8(%rbp), %rax
movl 0x17c(%rax), %ecx
subl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x17c(%rax), %eax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
subl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DeleteTable
SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3 *db, Table *pTable){
  /* Do not delete the table until the reference count reaches zero. */
  if( !pTable ) return;
  if( ((!db || db->pnBytesFreed==0) && (--pTable->nTabRef)>0) ) return;
  deleteTable(db, pTable);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3bff39
jmp 0x3bff6f
cmpq $0x0, -0x8(%rbp)
je 0x3bff4e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2d0(%rax)
jne 0x3bff62
movq -0x10(%rbp), %rcx
movl 0x3c(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x3c(%rcx)
cmpl $0x0, %eax
jbe 0x3bff62
jmp 0x3bff6f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4119c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)