LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
leaq 0x3e0(%rdi), %r13
movq (%r12), %rsi
movl $0x2, %ecx
cmpq %r15, %rsi
je 0x25ca2f
movzbl (%rsi), %eax
leaq 0x1(,%rax,4), %rbx
addq %r13, %rbx
movsbl -0x1(%rbx), %eax
testl %eax, %eax
je 0x25c9b7
movslq %eax, %rdx
movq %rbp, %rdi
subq (%r14), %rdi
cmpq %rdx, %rdi
jl 0x25ca2f
incq %rsi
movq %rsi, (%r12)
jmp 0x25ca13
movq 0x10(%rsp), %rax
movq 0x1d8(%rax), %rdi
callq *0x1d0(%rax)
movl %eax, %edi
leaq 0xc(%rsp), %rsi
callq 0x25c4a8
movl %eax, %edx
movq %rbp, %rsi
subq (%r14), %rsi
movl $0x2, %ecx
cmpq %rdx, %rsi
jl 0x25ca0e
movq (%r12), %rcx
movzbl (%rcx), %edi
movq 0x10(%rsp), %r9
movzbl 0x88(%r9,%rdi), %edi
addq %rdi, %rcx
addq $-0x3, %rcx
movq %rcx, (%r12)
xorl %ecx, %ecx
leaq 0xc(%rsp), %rbx
cmpq %rdx, %rsi
jl 0x25ca2f
movl %eax, %eax
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movq (%r14), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, (%r14)
movb %dl, (%rsi)
incq %rcx
cmpl %ecx, %eax
jne 0x25ca17
xorl %ecx, %ecx
testl %ecx, %ecx
je 0x25c974
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/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq (%rsi), %rsi
cmpq %rdx, %rsi
je 0x25cac1
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r13
cmpq %rbx, (%r14)
je 0x25cac1
movzbl (%rsi), %eax
movzwl 0x1e0(%r13,%rax,2), %eax
testw %ax, %ax
je 0x25ca81
incq %rsi
jmp 0x25caa7
movq 0x1d8(%r13), %rdi
callq *0x1d0(%r13)
movq (%r12), %rcx
movzbl (%rcx), %edx
movzbl 0x88(%r13,%rdx), %edx
leaq (%rcx,%rdx), %rsi
addq $-0x3, %rsi
movq %rsi, (%r12)
movq (%r14), %rcx
leaq 0x2(%rcx), %rdx
movq %rdx, (%r14)
movw %ax, (%rcx)
movq (%r12), %rsi
cmpq %r15, %rsi
jne 0x25ca66
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x25cb34
cmpl $-0x1, %eax
je 0x25cb2a
movb %al, 0x85(%r14)
leaq 0x7a(%rip), %rax        # 0x25cb7a
movq %rax, (%r14)
leaq 0x80(%rip), %rax        # 0x25cb8a
movq %rax, 0x8(%r14)
leaq 0x88(%rip), %rax        # 0x25cb9d
movq %rax, 0x60(%r14)
movq %rbx, 0x88(%r14)
movq %r14, (%rbx)
movl $0x1, %eax
jmp 0x25cb2c
xorl %eax, %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/xmltok_impl.c
// Function: little2_attributeValueTok
static int PTRCALL
PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
                          const char *end, const char **nextTokPtr)
{
  const char *start;
  if (ptr == end)
    return XML_TOK_NONE;
  start = ptr;
  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_AMP:
      if (ptr == start)
        return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
      *nextTokPtr = ptr;
      return XML_TOK_DATA_CHARS;
    case BT_LT:
      /* this is for inside entity references */
      *nextTokPtr = ptr;
      return XML_TOK_INVALID;
    case BT_LF:
      if (ptr == start) {
        *nextTokPtr = ptr + MINBPC(enc);
        return XML_TOK_DATA_NEWLINE;
      }
      *nextTokPtr = ptr;
      return XML_TOK_DATA_CHARS;
    case BT_CR:
      if (ptr == start) {
        ptr += MINBPC(enc);
        if (ptr == end)
          return XML_TOK_TRAILING_CR;
        if (BYTE_TYPE(enc, ptr) == BT_LF)
          ptr += MINBPC(enc);
        *nextTokPtr = ptr;
        return XML_TOK_DATA_NEWLINE;
      }
      *nextTokPtr = ptr;
      return XML_TOK_DATA_CHARS;
    case BT_S:
      if (ptr == start) {
        *nextTokPtr = ptr + MINBPC(enc);
        return XML_TOK_ATTRIBUTE_VALUE_S;
      }
      *nextTokPtr = ptr;
      return XML_TOK_DATA_CHARS;
    default:
      ptr += MINBPC(enc);
      break;
    }
  }
  *nextTokPtr = ptr;
  return XML_TOK_DATA_CHARS;
}

// Assembly:
cmpq %rdx, %rsi
je 0x261001
movq %rsi, %rax
leaq 0x174b4d(%rip), %r8     # 0x3d5aac
movzbl 0x1(%rsi), %r10d
cmpl $0xdb, %r10d
jg 0x260f90
movb $0x7, %r9b
leal -0xd8(%r10), %r11d
cmpl $0x4, %r11d
jb 0x260fb8
testl %r10d, %r10d
jne 0x260fb5
movzbl (%rsi), %r9d
movb 0x88(%rdi,%r9), %r9b
jmp 0x260fb8
leal -0xdc(%r10), %r9d
cmpl $0x4, %r9d
jae 0x260fa2
movb $0x8, %r9b
jmp 0x260fb8
cmpl $0xff, %r10d
jne 0x260fb5
cmpb $-0x3, (%rsi)
jbe 0x260fb5
xorl %r9d, %r9d
jmp 0x260fb8
movb $0x1d, %r9b
movzbl %r9b, %r10d
movl $0x2, %r9d
leal -0x2(%r10), %r11d
cmpl $0x8, %r11d
ja 0x260fe6
movslq (%r8,%r11,4), %r10
addq %r8, %r10
jmpq *%r10
movl $0x3, %r9d
jmp 0x260fec
movl $0x4, %r9d
jmp 0x260fec
cmpl $0x15, %r10d
je 0x261041
addq %r9, %rsi
cmpq %rdx, %rsi
jne 0x260f5f
movq %rsi, (%rcx)
movl $0x6, %eax
retq
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
retq
cmpq %rax, %rsi
jne 0x260ff8
leaq 0x2(%rsi), %rax
cmpq %rdx, %rax
je 0x261053
cmpb $0x0, 0x3(%rsi)
je 0x261059
xorl %edx, %edx
jmp 0x261067
movq %rsi, (%rcx)
xorl %eax, %eax
retq
cmpq %rax, %rsi
jne 0x260ff8
addq $0x2, %rsi
movq %rsi, (%rcx)
jmp 0x261074
cmpq %rax, %rsi
jne 0x260ff8
addq $0x2, %rsi
jmp 0x262a17
cmpq %rax, %rsi
jne 0x260ff8
addq $0x2, %rsi
movq %rsi, (%rcx)
movl $0x27, %eax
retq
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
retq
movzbl (%rax), %edx
cmpb $0xa, 0x88(%rdi,%rdx)
sete %dl
addq $0x4, %rsi
testb %dl, %dl
cmovneq %rsi, %rax
movq %rax, (%rcx)
movl $0x7, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_entityValueTok
static int PTRCALL
PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
                       const char *end, const char **nextTokPtr)
{
  const char *start;
  if (ptr == end)
    return XML_TOK_NONE;
  start = ptr;
  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_AMP:
      if (ptr == start)
        return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
      *nextTokPtr = ptr;
      return XML_TOK_DATA_CHARS;
    case BT_PERCNT:
      if (ptr == start) {
        int tok =  PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
                                       end, nextTokPtr);
        return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
      }
      *nextTokPtr = ptr;
      return XML_TOK_DATA_CHARS;
    case BT_LF:
      if (ptr == start) {
        *nextTokPtr = ptr + MINBPC(enc);
        return XML_TOK_DATA_NEWLINE;
      }
      *nextTokPtr = ptr;
      return XML_TOK_DATA_CHARS;
    case BT_CR:
      if (ptr == start) {
        ptr += MINBPC(enc);
        if (ptr == end)
          return XML_TOK_TRAILING_CR;
        if (BYTE_TYPE(enc, ptr) == BT_LF)
          ptr += MINBPC(enc);
        *nextTokPtr = ptr;
        return XML_TOK_DATA_NEWLINE;
      }
      *nextTokPtr = ptr;
      return XML_TOK_DATA_CHARS;
    default:
      ptr += MINBPC(enc);
      break;
    }
  }
  *nextTokPtr = ptr;
  return XML_TOK_DATA_CHARS;
}

// Assembly:
pushq %rax
cmpq %rdx, %rsi
je 0x261131
movq %rsi, %rax
leaq 0x174a42(%rip), %r8     # 0x3d5ad0
movzbl 0x1(%rsi), %r10d
cmpl $0xdb, %r10d
jg 0x2610bf
movb $0x7, %r9b
leal -0xd8(%r10), %r11d
cmpl $0x4, %r11d
jb 0x2610e7
testl %r10d, %r10d
jne 0x2610e4
movzbl (%rsi), %r9d
movb 0x88(%rdi,%r9), %r9b
jmp 0x2610e7
leal -0xdc(%r10), %r9d
cmpl $0x4, %r9d
jae 0x2610d1
movb $0x8, %r9b
jmp 0x2610e7
cmpl $0xff, %r10d
jne 0x2610e4
cmpb $-0x3, (%rsi)
jbe 0x2610e4
xorl %r9d, %r9d
jmp 0x2610e7
movb $0x1d, %r9b
movzbl %r9b, %r10d
movl $0x2, %r9d
leal -0x3(%r10), %r11d
cmpl $0x7, %r11d
ja 0x261115
movslq (%r8,%r11,4), %r10
addq %r8, %r10
jmpq *%r10
movl $0x3, %r9d
jmp 0x26111b
movl $0x4, %r9d
jmp 0x26111b
cmpl $0x1e, %r10d
je 0x26116d
addq %r9, %rsi
cmpq %rdx, %rsi
jne 0x26108e
movq %rsi, (%rcx)
movl $0x6, %eax
jmp 0x261136
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
popq %rcx
retq
cmpq %rax, %rsi
jne 0x261127
addq $0x2, %rsi
popq %rax
jmp 0x262a17
cmpq %rax, %rsi
jne 0x261127
leaq 0x2(%rsi), %rax
cmpq %rdx, %rax
je 0x261187
cmpb $0x0, 0x3(%rsi)
je 0x26118e
xorl %edx, %edx
jmp 0x26119c
cmpq %rax, %rsi
jne 0x261127
addq $0x2, %rsi
movq %rsi, (%rcx)
jmp 0x2611a9
cmpq %rax, %rsi
jne 0x261127
addq $0x2, %rsi
callq 0x2623fe
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x16, %ecx
cmovnel %ecx, %eax
jmp 0x261136
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x261136
movzbl (%rax), %edx
cmpb $0xa, 0x88(%rdi,%rdx)
sete %dl
addq $0x4, %rsi
testb %dl, %dl
cmovneq %rsi, %rax
movq %rax, (%rcx)
movl $0x7, %eax
jmp 0x261136
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rcx), %dil
testb %dil, %dil
je 0x25e358
incq %rcx
xorl %eax, %eax
cmpq %rdx, %rsi
je 0x25e360
cmpb %dil, (%rsi)
jne 0x25e360
incq %rsi
movb (%rcx), %dil
incq %rcx
testb %dil, %dil
jne 0x25e340
xorl %eax, %eax
cmpq %rdx, %rsi
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x2f400020, %ecx       # imm = 0x2F400020
movq %rsi, %rax
movzbl 0x1(%rax), %r8d
cmpl $0xdb, %r8d
jg 0x261351
movb $0x7, %dl
leal -0xd8(%r8), %r9d
cmpl $0x4, %r9d
jb 0x261375
testl %r8d, %r8d
jne 0x261373
movzbl (%rax), %edx
movb 0x88(%rdi,%rdx), %dl
jmp 0x261375
leal -0xdc(%r8), %edx
cmpl $0x4, %edx
jae 0x261361
movb $0x8, %dl
jmp 0x261375
cmpl $0xff, %r8d
jne 0x261373
cmpb $-0x3, (%rax)
jbe 0x261373
xorl %edx, %edx
jmp 0x261375
movb $0x1d, %dl
cmpb $0x1d, %dl
ja 0x2613a8
movzbl %dl, %r8d
movl $0x2, %edx
btl %r8d, %ecx
jae 0x26138e
addq %rdx, %rax
jmp 0x261323
cmpl $0x6, %r8d
je 0x2613a1
cmpl $0x7, %r8d
jne 0x2613a8
movl $0x4, %edx
jmp 0x261389
movl $0x3, %edx
jmp 0x261389
subl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_charRefNumber
PREFIX(charRefNumber)(__attribute__ ((unused)) const ENCODING *enc, const char *ptr)
{
  int result = 0;
  /* skip &# */
  ptr += 2*MINBPC(enc);
  if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
    for (ptr += MINBPC(enc);
         !CHAR_MATCHES(enc, ptr, ASCII_SEMI);
         ptr += MINBPC(enc)) {
      int c = BYTE_TO_ASCII(enc, ptr);
      switch (c) {
      case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4:
      case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9:
        result <<= 4;
        result |= (c - ASCII_0);
        break;
      case ASCII_A: case ASCII_B: case ASCII_C:
      case ASCII_D: case ASCII_E: case ASCII_F:
        result <<= 4;
        result += 10 + (c - ASCII_A);
        break;
      case ASCII_a: case ASCII_b: case ASCII_c:
      case ASCII_d: case ASCII_e: case ASCII_f:
        result <<= 4;
        result += 10 + (c - ASCII_a);
        break;
      }
      if (result >= 0x110000)
        return -1;
    }
  }
  else {
    for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
      int c = BYTE_TO_ASCII(enc, ptr);
      result *= 10;
      result += (c - ASCII_0);
      if (result >= 0x110000)
        return -1;
    }
  }
  return checkCharRefNumber(result);
}

// Assembly:
cmpb $0x0, 0x5(%rsi)
jne 0x261807
cmpb $0x78, 0x4(%rsi)
jne 0x261807
addq $0x7, %rsi
xorl %edi, %edi
movl $0x3ff, %eax            # imm = 0x3FF
movl $0x7e0000, %ecx         # imm = 0x7E0000
movabsq $0x7e000000000000, %rdx # imm = 0x7E000000000000
movb (%rsi), %r9b
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
testb %r9b, %r9b
jne 0x2617be
cmpb $0x3b, -0x1(%rsi)
je 0x261841
testb %r9b, %r9b
jne 0x2617be
movsbl -0x1(%rsi), %r8d
leal -0x30(%r8), %r9d
cmpl $0x36, %r9d
ja 0x2617f9
btq %r9, %rax
jb 0x2617e5
btq %r9, %rcx
jb 0x2617f0
btq %r9, %rdx
jae 0x2617f9
shll $0x4, %edi
addl %r8d, %edi
addl $-0x57, %edi
jmp 0x2617f9
shll $0x4, %edi
orl %edi, %r9d
movl %r9d, %edi
jmp 0x2617f9
shll $0x4, %edi
addl %r8d, %edi
addl $-0x37, %edi
addq $0x2, %rsi
cmpl $0x110000, %edi         # imm = 0x110000
jl 0x26179c
jmp 0x26183b
addq $0x5, %rsi
xorl %edi, %edi
movb (%rsi), %cl
movl $0xffffffcf, %eax       # imm = 0xFFFFFFCF
testb %cl, %cl
jne 0x261829
cmpb $0x3b, -0x1(%rsi)
je 0x261841
testb %cl, %cl
jne 0x261829
movsbl -0x1(%rsi), %eax
addl $-0x30, %eax
leal (%rdi,%rdi,4), %ecx
leal (%rax,%rcx,2), %edi
addq $0x2, %rsi
cmpl $0x110000, %edi         # imm = 0x110000
jl 0x26180d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
jmp 0x25c840
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq %rdx, %rsi
je 0x261a55
movq 0x8(%rcx), %r8
leaq 0x1741f8(%rip), %rax    # 0x3d5b5c
movzbl 0x1(%rsi), %r10d
cmpl $0xdb, %r10d
jg 0x261995
movb $0x7, %r9b
leal -0xd8(%r10), %r11d
cmpl $0x4, %r11d
jb 0x2619bd
testl %r10d, %r10d
jne 0x2619ba
movzbl (%rsi), %r9d
movb 0x88(%rdi,%r9), %r9b
jmp 0x2619bd
leal -0xdc(%r10), %r9d
cmpl $0x4, %r9d
jae 0x2619a7
movb $0x8, %r9b
jmp 0x2619bd
cmpl $0xff, %r10d
jne 0x2619ba
cmpb $-0x3, (%rsi)
jbe 0x2619ba
xorl %r9d, %r9d
jmp 0x2619bd
movb $0x1d, %r9b
movzbl %r9b, %r9d
addl $-0x5, %r9d
cmpl $0x5, %r9d
ja 0x2619d5
movslq (%rax,%r9,4), %r9
addq %rax, %r9
jmpq *%r9
addq $0x2, %rsi
jmp 0x261a45
addq $0x4, %rsi
jmp 0x261a45
addq $0x3, %rsi
jmp 0x261a45
incq (%rcx)
leaq 0x2(%rsi), %r9
cmpq %rdx, %r9
je 0x261a33
cmpb $0x0, 0x3(%rsi)
je 0x261a16
xorl %r8d, %r8d
jmp 0x261a27
movq $-0x1, 0x8(%rcx)
incq (%rcx)
addq $0x2, %rsi
movq $-0x1, %r8
jmp 0x261a45
movzbl (%r9), %r8d
cmpb $0xa, 0x88(%rdi,%r8)
sete %r8b
testb %r8b, %r8b
je 0x261a33
addq $0x4, %rsi
movq %rsi, %r9
movq $-0x1, 0x8(%rcx)
movq $-0x1, %r8
movq %r9, %rsi
incq %r8
movq %r8, 0x8(%rcx)
cmpq %rdx, %rsi
jne 0x261964
retq
// File: /workspace/github_c_makefile_star2_O1/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 (%rsi), %rax
cmpq %rdx, %rax
je 0x25e8e1
movb (%rax), %dil
movq (%rcx), %r9
testb %dil, %dil
js 0x25e8ae
cmpq %r8, %r9
je 0x25e8e1
leaq 0x1(%rax), %rdi
movq %rdi, (%rsi)
movb (%rax), %al
movq (%rcx), %rdi
leaq 0x1(%rdi), %r9
movq %r9, (%rcx)
movb %al, (%rdi)
jmp 0x25e87f
movq %r8, %rax
subq %r9, %rax
cmpq $0x2, %rax
jl 0x25e8e1
movl %edi, %eax
shrb $0x6, %al
orb $-0x40, %al
leaq 0x1(%r9), %r10
movq %r10, (%rcx)
movb %al, (%r9)
andb $-0x41, %dil
movq (%rcx), %rax
leaq 0x1(%rax), %r9
movq %r9, (%rcx)
movb %dil, (%rax)
incq (%rsi)
jmp 0x25e87f
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_scanLit
static int PTRCALL
PREFIX(scanLit)(int open, const ENCODING *enc,
                const char *ptr, const char *end,
                const char **nextTokPtr)
{
  while (ptr != end) {
    int t = BYTE_TYPE(enc, ptr);
    switch (t) {
    INVALID_CASES(ptr, nextTokPtr)
    case BT_QUOT:
    case BT_APOS:
      ptr += MINBPC(enc);
      if (t != open)
        break;
      if (ptr == end)
        return -XML_TOK_LITERAL;
      *nextTokPtr = ptr;
      switch (BYTE_TYPE(enc, ptr)) {
      case BT_S: case BT_CR: case BT_LF:
      case BT_GT: case BT_PERCNT: case BT_LSQB:
        return XML_TOK_LITERAL;
      default:
        return XML_TOK_INVALID;
      }
    default:
      ptr += MINBPC(enc);
      break;
    }
  }
  return XML_TOK_PARTIAL;
}

// Assembly:
pushq %rbp
pushq %rbx
leaq 0x173e3e(%rip), %r9     # 0x3d5b74
movl $0x40300e00, %r10d      # imm = 0x40300E00
cmpq %rcx, %rdx
je 0x261ea9
movzbl 0x1(%rdx), %r11d
cmpl $0xdb, %r11d
jg 0x261d78
movl $0x7, %ebp
leal -0xd8(%r11), %ebx
cmpl $0x4, %ebx
jb 0x261da0
testl %r11d, %r11d
jne 0x261d9b
movzbl (%rdx), %r11d
movzbl 0x88(%rsi,%r11), %ebp
jmp 0x261da0
leal -0xdc(%r11), %ebx
cmpl $0x4, %ebx
jae 0x261d8b
movl $0x8, %ebp
jmp 0x261da0
cmpl $0xff, %r11d
jne 0x261d9b
xorl %ebp, %ebp
cmpb $-0x3, (%rdx)
ja 0x261da0
movl $0x1d, %ebp
cmpl $0xd, %ebp
ja 0x261e2a
movl %ebp, %r11d
movslq (%r9,%r11,4), %r11
addq %r9, %r11
jmpq *%r11
movq %rdx, (%r8)
xorl %eax, %eax
movq %rdx, %r11
xorl %ebx, %ebx
jmp 0x261e4e
leaq 0x2(%rdx), %r11
movb $0x1, %bl
cmpl %edi, %ebp
jne 0x261e4e
cmpq %rcx, %r11
je 0x261e5b
movq %r11, (%r8)
movzbl 0x3(%rdx), %eax
cmpl $0xdb, %eax
jg 0x261e65
movb $0x7, %dl
leal -0xd8(%rax), %ebx
cmpl $0x4, %ebx
jb 0x261e87
testl %eax, %eax
jne 0x261e85
movzbl (%r11), %eax
movb 0x88(%rsi,%rax), %dl
jmp 0x261e87
movq %rcx, %r11
subq %rdx, %r11
cmpq $0x4, %r11
jl 0x261e3c
addq $0x4, %rdx
jmp 0x261e49
movq %rcx, %r11
subq %rdx, %r11
cmpq $0x2, %r11
jl 0x261e3c
addq $0x2, %rdx
jmp 0x261e49
movq %rcx, %r11
subq %rdx, %r11
cmpq $0x3, %r11
jge 0x261e45
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
xorl %ebx, %ebx
jmp 0x261e4b
addq $0x3, %rdx
movb $0x1, %bl
movq %rdx, %r11
movq %r11, %rdx
testb %bl, %bl
jne 0x261d3c
jmp 0x261eae
movl $0xffffffe5, %eax       # imm = 0xFFFFFFE5
jmp 0x261dbe
leal -0xdc(%rax), %edx
cmpl $0x4, %edx
jae 0x261e74
movb $0x8, %dl
jmp 0x261e87
cmpl $0xff, %eax
jne 0x261e85
cmpb $-0x3, (%r11)
jbe 0x261e85
xorl %edx, %edx
jmp 0x261e87
movb $0x1d, %dl
xorl %eax, %eax
cmpb $0x1e, %dl
ja 0x261dbe
movzbl %dl, %edx
btl %edx, %r10d
jae 0x261dbe
movl $0x1b, %eax
jmp 0x261dbe
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_scanComment
static int PTRCALL
PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
                    const char *end, const char **nextTokPtr)
{
  if (ptr != end) {
    if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
      *nextTokPtr = ptr;
      return XML_TOK_INVALID;
    }
    ptr += MINBPC(enc);
    while (ptr != end) {
      switch (BYTE_TYPE(enc, ptr)) {
      INVALID_CASES(ptr, nextTokPtr)
      case BT_MINUS:
        if ((ptr += MINBPC(enc)) == end)
          return XML_TOK_PARTIAL;
        if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
          if ((ptr += MINBPC(enc)) == end)
            return XML_TOK_PARTIAL;
          if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
            *nextTokPtr = ptr;
            return XML_TOK_INVALID;
          }
          *nextTokPtr = ptr + MINBPC(enc);
          return XML_TOK_COMMENT;
        }
        break;
      default:
        ptr += MINBPC(enc);
        break;
      }
    }
  }
  return XML_TOK_PARTIAL;
}

// Assembly:
pushq %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rdx, %rsi
je 0x262991
xorl %r8d, %r8d
cmpb $0x0, 0x1(%rsi)
jne 0x26298b
cmpb $0x2d, (%rsi)
jne 0x26298b
addq $0x2, %rsi
cmpq %rdx, %rsi
je 0x262991
leaq 0x173542(%rip), %r9     # 0x3d5dcc
movzbl 0x1(%rsi), %r11d
cmpl $0xdb, %r11d
jg 0x2628ba
movb $0x7, %r10b
leal -0xd8(%r11), %ebx
cmpl $0x4, %ebx
jb 0x2628e2
testl %r11d, %r11d
jne 0x2628df
movzbl (%rsi), %r10d
movb 0x88(%rdi,%r10), %r10b
jmp 0x2628e2
leal -0xdc(%r11), %r10d
cmpl $0x4, %r10d
jae 0x2628cc
movb $0x8, %r10b
jmp 0x2628e2
cmpl $0xff, %r11d
jne 0x2628df
cmpb $-0x3, (%rsi)
jbe 0x2628df
xorl %r10d, %r10d
jmp 0x2628e2
movb $0x1d, %r10b
movzbl %r10b, %r10d
cmpb $0x8, %r10b
ja 0x262904
movslq (%r9,%r10,4), %r10
addq %r9, %r10
jmpq *%r10
movq %rdx, %r10
subq %rsi, %r10
cmpq $0x2, %r10
jge 0x262921
jmp 0x26295a
cmpl $0x1b, %r10d
jne 0x262921
leaq 0x2(%rsi), %r10
cmpq %rdx, %r10
je 0x262991
cmpb $0x0, 0x3(%rsi)
jne 0x26294c
cmpb $0x2d, (%r10)
jne 0x26294c
jmp 0x262961
addq $0x2, %rsi
jmp 0x262949
movq %rdx, %r10
subq %rsi, %r10
cmpq $0x4, %r10
jl 0x26295a
addq $0x4, %rsi
jmp 0x262949
movq %rdx, %r10
subq %rsi, %r10
cmpq $0x3, %r10
jl 0x26295a
addq $0x3, %rsi
movq %rsi, %r10
movq %r10, %rsi
cmpq %rdx, %r10
jne 0x26288a
jmp 0x262991
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x262991
leaq 0x4(%rsi), %rdi
cmpq %rdx, %rdi
je 0x262991
cmpb $0x0, 0x5(%rsi)
jne 0x262988
leaq 0x6(%rsi), %rax
xorl %edx, %edx
cmpb $0x3e, 0x4(%rsi)
cmoveq %rax, %rdi
movl $0xd, %r8d
cmovnel %edx, %r8d
movq %rdi, %rsi
movq %rsi, (%rcx)
movl %r8d, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 (%rsi), %rax
movq %rdx, %r9
subq %rax, %r9
movq (%rcx), %rdi
subq %rdi, %r8
cmpq %r8, %r9
jle 0x25fa2c
addq %rax, %r8
movq %r8, %rdx
cmpq %rax, %r8
jbe 0x25fa2c
leaq -0x1(%rdx), %r8
movb -0x1(%rdx), %r9b
andb $-0x40, %r9b
negb %r9b
jo 0x25fa05
jmp 0x25fa2c
movb (%rax), %r8b
movb %r8b, (%rdi)
incq %rax
incq %rdi
cmpq %rdx, %rax
jne 0x25fa20
movq %rax, (%rsi)
movq %rdi, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: utf8_toUtf16
static void PTRCALL
utf8_toUtf16(const ENCODING *enc,
             const char **fromP, const char *fromLim,
             unsigned short **toP, const unsigned short *toLim)
{
  unsigned short *to = *toP;
  const char *from = *fromP;
  while (from != fromLim && to != toLim) {
    switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
    case BT_LEAD2:
      *to++ = (unsigned short)(((from[0] & 0x1f) << 6) | (from[1] & 0x3f));
      from += 2;
      break;
    case BT_LEAD3:
      *to++ = (unsigned short)(((from[0] & 0xf) << 12)
                               | ((from[1] & 0x3f) << 6) | (from[2] & 0x3f));
      from += 3;
      break;
    case BT_LEAD4:
      {
        unsigned long n;
        if (to + 1 == toLim)
          goto after;
        n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12)
            | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
        n -= 0x10000;
        to[0] = (unsigned short)((n >> 10) | 0xD800);
        to[1] = (unsigned short)((n & 0x3FF) | 0xDC00);
        to += 2;
        from += 4;
      }
      break;
    default:
      *to++ = *from++;
      break;
    }
  }
after:
  *fromP = from;
  *toP = to;
}

// Assembly:
movq (%rcx), %rax
movq (%rsi), %r9
cmpq %rdx, %r9
setne %r10b
cmpq %r8, %rax
setne %r11b
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x25fb59
pushq %rbp
pushq %rbx
movzbl (%r9), %r10d
movzwl %r10w, %r10d
movzbl 0x88(%rdi,%r10), %r11d
cmpl $0x7, %r11d
je 0x25fad5
cmpl $0x6, %r11d
je 0x25faa7
cmpl $0x5, %r11d
jne 0x25fb3a
andl $0x1f, %r10d
shll $0x6, %r10d
movzbl 0x1(%r9), %r11d
andl $0x3f, %r11d
orl %r10d, %r11d
movw %r11w, (%rax)
addq $0x2, %rax
addq $0x2, %r9
jmp 0x25fb49
shll $0xc, %r10d
movzbl 0x1(%r9), %r11d
andl $0x3f, %r11d
shll $0x6, %r11d
orl %r10d, %r11d
movzbl 0x2(%r9), %r10d
andl $0x3f, %r10d
orl %r11d, %r10d
movw %r10w, (%rax)
addq $0x2, %rax
addq $0x3, %r9
jmp 0x25fb49
leaq 0x2(%rax), %r11
cmpq %r8, %r11
je 0x25fb33
andl $0x7, %r10d
shll $0x12, %r10d
movzbl 0x1(%r9), %ebx
andl $0x3f, %ebx
shll $0xc, %ebx
orl %r10d, %ebx
movzbl 0x2(%r9), %r10d
andl $0x3f, %r10d
shll $0x6, %r10d
movzbl 0x3(%r9), %ebp
andl $0x3f, %ebp
addl %r10d, %ebx
addl $0xff0000, %ebx         # imm = 0xFF0000
shrl $0xa, %ebx
orl $0xd800, %ebx           # imm = 0xD800
movw %bx, (%rax)
orl %r10d, %ebp
orl $0xdc00, %ebp           # imm = 0xDC00
movw %bp, 0x2(%rax)
addq $0x4, %rax
addq $0x4, %r9
cmpq %r8, %r11
jne 0x25fb49
jmp 0x25fb57
incq %r9
movsbl %r10b, %r10d
movw %r10w, (%rax)
addq $0x2, %rax
cmpq %rdx, %r9
je 0x25fb57
cmpq %r8, %rax
jne 0x25fa5b
popq %rbx
popq %rbp
movq %r9, (%rsi)
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_sameName
static int PTRCALL
PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
{
  for (;;) {
    switch (BYTE_TYPE(enc, ptr1)) {
#define LEAD_CASE(n) \
    case BT_LEAD ## n: \
      if (*ptr1++ != *ptr2++) \
        return 0;
    LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2)
#undef LEAD_CASE
      /* fall through */
      if (*ptr1++ != *ptr2++)
        return 0;
      break;
    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:
      if (*ptr2++ != *ptr1++)
        return 0;
      if (MINBPC(enc) > 1) {
        if (*ptr2++ != *ptr1++)
          return 0;
        if (MINBPC(enc) > 2) {
          if (*ptr2++ != *ptr1++)
            return 0;
          if (MINBPC(enc) > 3) {
            if (*ptr2++ != *ptr1++)
              return 0;
          }
        }
      }
      break;
    default:
      if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
        return 1;
      switch (BYTE_TYPE(enc, ptr2)) {
      case BT_LEAD2:
      case BT_LEAD3:
      case BT_LEAD4:
      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:
        return 0;
      default:
        return 1;
      }
    }
  }
  /* not reached */
}

// Assembly:
movl $0x2f400000, %ecx       # imm = 0x2F400000
movb 0x1(%rsi), %r8b
movzbl %r8b, %r9d
cmpl $0xdb, %r9d
jg 0x2611e6
movb $0x7, %al
leal -0xd8(%r9), %r10d
cmpl $0x4, %r10d
jb 0x26120a
testl %r9d, %r9d
jne 0x261208
movzbl (%rsi), %eax
movb 0x88(%rdi,%rax), %al
jmp 0x26120a
leal -0xdc(%r9), %eax
cmpl $0x4, %eax
jae 0x2611f6
movb $0x8, %al
jmp 0x26120a
cmpl $0xff, %r9d
jne 0x261208
cmpb $-0x3, (%rsi)
jbe 0x261208
xorl %eax, %eax
jmp 0x26120a
movb $0x1d, %al
movzbl %al, %eax
cmpb $0x1d, %al
ja 0x26125b
btl %eax, %ecx
jae 0x26122f
movb (%rdx), %r9b
xorl %eax, %eax
cmpb (%rsi), %r9b
jne 0x2612e5
cmpb %r8b, 0x1(%rdx)
je 0x261274
jmp 0x2612e5
cmpl $0x6, %eax
je 0x261249
cmpl $0x7, %eax
jne 0x26125b
movb (%rsi), %al
cmpb (%rdx), %al
jne 0x2612dd
incq %rsi
incq %rdx
movb (%rsi), %al
cmpb (%rdx), %al
jne 0x2612dd
incq %rsi
incq %rdx
jmp 0x261260
cmpl $0x5, %eax
jne 0x261281
movb (%rsi), %r8b
xorl %eax, %eax
cmpb (%rdx), %r8b
jne 0x2612e5
movb 0x1(%rsi), %r8b
cmpb 0x1(%rdx), %r8b
jne 0x2612e5
addq $0x2, %rdx
addq $0x2, %rsi
jmp 0x2611b5
movzbl 0x1(%rdx), %ecx
cmpl $0xdb, %ecx
jg 0x2612aa
movb $0x7, %al
leal -0xd8(%rcx), %esi
cmpl $0x4, %esi
jb 0x2612cc
testl %ecx, %ecx
jne 0x2612ca
movzbl (%rdx), %eax
movb 0x88(%rdi,%rax), %al
jmp 0x2612cc
leal -0xdc(%rcx), %eax
cmpl $0x4, %eax
jae 0x2612b9
movb $0x8, %al
jmp 0x2612cc
cmpl $0xff, %ecx
jne 0x2612ca
cmpb $-0x3, (%rdx)
jbe 0x2612ca
xorl %eax, %eax
jmp 0x2612cc
movb $0x1d, %al
cmpb $0x1d, %al
ja 0x2612e0
movzbl %al, %eax
movl $0x2f4000e0, %ecx       # imm = 0x2F4000E0
btl %eax, %ecx
jae 0x2612e0
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rsi, %rax
movl $0x200600, %ecx         # imm = 0x200600
movzbl 0x1(%rax), %esi
cmpl $0xdb, %esi
jg 0x2613de
movb $0x7, %dl
leal -0xd8(%rsi), %r8d
cmpl $0x4, %r8d
jb 0x261400
testl %esi, %esi
jne 0x2613fe
movzbl (%rax), %edx
movb 0x88(%rdi,%rdx), %dl
jmp 0x261400
leal -0xdc(%rsi), %edx
cmpl $0x4, %edx
jae 0x2613ed
movb $0x8, %dl
jmp 0x261400
cmpl $0xff, %esi
jne 0x2613fe
cmpb $-0x3, (%rax)
jbe 0x2613fe
xorl %edx, %edx
jmp 0x261400
movb $0x1d, %dl
cmpb $0x15, %dl
ja 0x261413
movzbl %dl, %edx
btl %edx, %ecx
jae 0x261413
addq $0x2, %rax
jmp 0x2613b3
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_predefinedEntityName
static int PTRCALL
PREFIX(predefinedEntityName)(__attribute__ ((unused)) const ENCODING *enc, const char *ptr,
                             const char *end)
{
  switch ((end - ptr)/MINBPC(enc)) {
  case 2:
    if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
      switch (BYTE_TO_ASCII(enc, ptr)) {
      case ASCII_l:
        return ASCII_LT;
      case ASCII_g:
        return ASCII_GT;
      }
    }
    break;
  case 3:
    if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
      ptr += MINBPC(enc);
      if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
        ptr += MINBPC(enc);
        if (CHAR_MATCHES(enc, ptr, ASCII_p))
          return ASCII_AMP;
      }
    }
    break;
  case 4:
    switch (BYTE_TO_ASCII(enc, ptr)) {
    case ASCII_q:
      ptr += MINBPC(enc);
      if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
        ptr += MINBPC(enc);
        if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
          ptr += MINBPC(enc);
          if (CHAR_MATCHES(enc, ptr, ASCII_t))
            return ASCII_QUOT;
        }
      }
      break;
    case ASCII_a:
      ptr += MINBPC(enc);
      if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
        ptr += MINBPC(enc);
        if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
          ptr += MINBPC(enc);
          if (CHAR_MATCHES(enc, ptr, ASCII_s))
            return ASCII_APOS;
        }
      }
      break;
    }
  }
  return 0;
}

// Assembly:
subq %rsi, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
addq %rdx, %rax
sarq %rax
cmpq $0x4, %rax
je 0x2618e1
cmpq $0x3, %rax
je 0x2618ab
cmpq $0x2, %rax
jne 0x26194d
cmpb $0x0, 0x3(%rsi)
jne 0x26194d
cmpb $0x74, 0x2(%rsi)
jne 0x26194d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x0, 0x1(%rsi)
jne 0x261892
movsbl (%rsi), %eax
xorl %ecx, %ecx
cmpl $0x67, %eax
movl $0x3e, %edx
cmovnel %ecx, %edx
cmpl $0x6c, %eax
movl $0x3c, %eax
cmovnel %edx, %eax
retq
cmpb $0x0, 0x1(%rsi)
jne 0x26194d
cmpb $0x61, (%rsi)
jne 0x26194d
cmpb $0x0, 0x3(%rsi)
jne 0x26194d
cmpb $0x6d, 0x2(%rsi)
jne 0x26194d
cmpb $0x0, 0x5(%rsi)
jne 0x26194d
movl $0x26, %eax
cmpb $0x70, 0x4(%rsi)
jne 0x26194d
jmp 0x26194f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x0, 0x1(%rsi)
jne 0x2618ef
movsbl (%rsi), %eax
cmpl $0x61, %eax
je 0x261924
cmpl $0x71, %eax
jne 0x26194d
cmpb $0x0, 0x3(%rsi)
jne 0x26194d
cmpb $0x75, 0x2(%rsi)
jne 0x26194d
cmpb $0x0, 0x5(%rsi)
jne 0x26194d
cmpb $0x6f, 0x4(%rsi)
jne 0x26194d
cmpb $0x0, 0x7(%rsi)
jne 0x26194d
movl $0x22, %eax
cmpb $0x74, 0x6(%rsi)
jne 0x26194d
jmp 0x26194f
cmpb $0x0, 0x3(%rsi)
jne 0x26194d
cmpb $0x70, 0x2(%rsi)
jne 0x26194d
cmpb $0x0, 0x5(%rsi)
jne 0x26194d
cmpb $0x6f, 0x4(%rsi)
jne 0x26194d
cmpb $0x0, 0x7(%rsi)
jne 0x26194d
movl $0x27, %eax
cmpb $0x73, 0x6(%rsi)
je 0x26194f
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_isPublicId
static int PTRCALL
PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
                   const char **badPtr)
{
  ptr += MINBPC(enc);
  end -= MINBPC(enc);
  for (; ptr != end; ptr += MINBPC(enc)) {
    switch (BYTE_TYPE(enc, ptr)) {
    case BT_DIGIT:
    case BT_HEX:
    case BT_MINUS:
    case BT_APOS:
    case BT_LPAR:
    case BT_RPAR:
    case BT_PLUS:
    case BT_COMMA:
    case BT_SOL:
    case BT_EQUALS:
    case BT_QUEST:
    case BT_CR:
    case BT_LF:
    case BT_SEMI:
    case BT_EXCL:
    case BT_AST:
    case BT_PERCNT:
    case BT_NUM:
#ifdef XML_NS
    case BT_COLON:
#endif
      break;
    case BT_S:
      if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
        *badPtr = ptr;
        return 0;
      }
      break;
    case BT_NAME:
    case BT_NMSTRT:
      if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
        break;
    default:
      switch (BYTE_TO_ASCII(enc, ptr)) {
      case 0x24: /* $ */
      case 0x40: /* @ */
        break;
      default:
        *badPtr = ptr;
        return 0;
      }
      break;
    }
  }
  return 1;
}

// Assembly:
addq $-0x2, %rdx
addq $0x2, %rsi
movl $0x1, %eax
cmpq %rdx, %rsi
je 0x261b32
pushq %rbx
movabsq $0xfcb0fe600, %r8       # imm = 0xFCB0FE600
movl $0x4400000, %r9d        # imm = 0x4400000
movzbl 0x1(%rsi), %r10d
testl %r10d, %r10d
je 0x261aa8
movb $0x7, %r11b
leal -0xd8(%r10), %ebx
cmpl $0x4, %ebx
jb 0x261ab4
leal -0xdc(%r10), %r11d
cmpl $0x4, %r11d
jae 0x261ae7
movb $0x8, %r11b
jmp 0x261ab4
movzbl (%rsi), %r11d
movb 0x88(%rdi,%r11), %r11b
cmpb $0x23, %r11b
ja 0x261b11
movzbl %r11b, %r11d
btq %r11, %r8
jae 0x261acf
addq $0x2, %rsi
cmpq %rdx, %rsi
jne 0x261a7d
jmp 0x261b31
btq %r11, %r9
jae 0x261aff
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
testl %r10d, %r10d
jne 0x261b20
cmpb $0x0, (%rsi)
jns 0x261ac4
jmp 0x261b11
cmpl $0xff, %r10d
jne 0x261afa
cmpb $-0x3, (%rsi)
jbe 0x261afa
xorl %r11d, %r11d
jmp 0x261ab4
movb $0x1d, %r11b
jmp 0x261ab4
cmpq $0x15, %r11
jne 0x261b11
testl %r10d, %r10d
jne 0x261ac4
cmpb $0x9, (%rsi)
jne 0x261ac4
jmp 0x261b2c
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
testl %r10d, %r10d
jne 0x261b20
movsbl (%rsi), %r11d
cmpl $0x40, %r11d
je 0x261ac4
cmpl $0x24, %r11d
je 0x261ac4
movq %rsi, (%rcx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0xb, (%rdx)
subq %rdi, %rsi
movl $0x1, %eax
cmpq $0x6, %rsi
jne 0x262a0a
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpb $0x0, 0x1(%rdi)
jne 0x2629b5
movsbl (%rdi), %ecx
cmpl $0x78, %ecx
je 0x2629c6
cmpl $0x58, %ecx
jne 0x262a0a
movl $0x1, %ecx
jmp 0x2629c8
xorl %ecx, %ecx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpb $0x0, 0x3(%rdi)
jne 0x2629d7
movsbl 0x2(%rdi), %esi
cmpl $0x6d, %esi
je 0x2629e6
cmpl $0x4d, %esi
jne 0x262a0a
movl $0x1, %ecx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpb $0x0, 0x5(%rdi)
jne 0x2629f5
movsbl 0x4(%rdi), %esi
cmpl $0x6c, %esi
je 0x262a04
cmpl $0x4c, %esi
jne 0x262a0a
movl $0x1, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x262a0b
retq
movl $0xc, (%rdx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpl $0xa, %edi
jb 0x27b78f
leaq 0x163bb6(%rip), %rsi    # 0x3df31f
leaq 0x16842c(%rip), %rdx    # 0x3e3b9c
leaq 0x163a0e(%rip), %r8     # 0x3df185
movl $0x15, %ebx
movl $0x15, %edi
movl $0x53d5, %ecx           # imm = 0x53D5
xorl %eax, %eax
callq 0x27e637
jmp 0x27b7b2
movl %edi, %eax
leaq 0x24e360(%rip), %rdi    # 0x4c9af8
movq (%rdi,%rax,8), %r8
movq %r8, (%rsi)
movq 0x50(%rdi,%rax,8), %rsi
movq %rsi, (%rdx)
xorl %ebx, %ebx
testl %ecx, %ecx
je 0x27b7b2
movq %r8, 0x50(%rdi,%rax,8)
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
cmpl $0xa, %edi
jae 0x27b7eb
movl %ebp, %edx
leaq 0x24e324(%rip), %rsi    # 0x4c9af8
movq (%rsi,%rdx,8), %r12
movq 0x50(%rsi,%rdx,8), %rax
xorl %r15d, %r15d
testl %ecx, %ecx
je 0x27b81c
movq %r12, 0x50(%rsi,%rdx,8)
jmp 0x27b81c
leaq 0x163b2d(%rip), %rsi    # 0x3df31f
leaq 0x1683a3(%rip), %rdx    # 0x3e3b9c
leaq 0x163985(%rip), %r8     # 0x3df185
xorl %r12d, %r12d
movl $0x15, %r15d
movl $0x15, %edi
movl $0x53d5, %ecx           # imm = 0x53D5
xorl %eax, %eax
callq 0x27e637
xorl %eax, %eax
cmpl $0x9, %ebp
ja 0x27b826
movl %r12d, (%r14)
movl %eax, (%rbx)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x190(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x27bc8c
movq (%rcx), %rcx
incl %eax
jmp 0x27bc80
movq 0x198(%rdi), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0x27bca4
movq (%rdx), %rdx
incl %ecx
jmp 0x27bc98
movq 0x1a0(%rdi), %r8
xorl %edx, %edx
testq %r8, %r8
je 0x27bcb9
movq (%r8), %r8
incl %edx
jmp 0x27bcad
movq 0x1a8(%rdi), %r9
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
testq %r9, %r9
je 0x27bcd3
movq (%r9), %r9
incl %r8d
jmp 0x27bcc6
addl %eax, %edx
testq %rsi, %rsi
je 0x27bce4
movl 0x17c(%rdi), %eax
subl %edx, %eax
movl %eax, (%rsi)
movl 0x17c(%rdi), %eax
addl %edx, %ecx
addl %r8d, %ecx
subl %ecx, %eax
addl $-0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeClearObject
SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
  SubProgram *pSub, *pNext;
  assert( p->db==0 || p->db==db );
  releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
  for(pSub=p->pProgram; pSub; pSub=pNext){
    pNext = pSub->pNext;
    vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
    sqlite3DbFree(db, pSub);
  }
  if( p->magic!=VDBE_MAGIC_INIT ){
    releaseMemArray(p->aVar, p->nVar);
    sqlite3DbFree(db, p->pVList);
    sqlite3DbFree(db, p->pFree);
  }
  vdbeFreeOpArray(db, p->aOp, p->nOp);
  sqlite3DbFree(db, p->aColName);
  sqlite3DbFree(db, p->zSql);
#ifdef SQLITE_ENABLE_NORMALIZE
  sqlite3DbFree(db, p->zNormSql);
  {
    DblquoteStr *pThis, *pNext;
    for(pThis=p->pDblStr; pThis; pThis=pNext){
      pNext = pThis->pNextStr;
      sqlite3DbFree(db, pThis);
    }
  }
#endif
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
  {
    int i;
    for(i=0; i<p->nScan; i++){
      sqlite3DbFree(db, p->aScan[i].zName);
    }
    sqlite3DbFree(db, p->aScan);
  }
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x98(%rsi), %rdi
movzwl 0xc0(%rsi), %esi
addl %esi, %esi
callq 0x29983d
movq 0x118(%r14), %r15
testq %r15, %r15
je 0x27bdeb
movq 0x28(%r15), %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %rbx, %rdi
callq 0x2998cc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x28c3e7
movq %r12, %r15
testq %r12, %r12
jne 0x27bdc5
cmpl $0x16bceaa5, 0x24(%r14) # imm = 0x16BCEAA5
je 0x27be2e
movq 0x80(%r14), %rdi
movswl 0x20(%r14), %esi
callq 0x29983d
movq 0xb0(%r14), %rsi
testq %rsi, %rsi
je 0x27be1a
movq %rbx, %rdi
callq 0x28c3e7
movq 0xf8(%r14), %rsi
testq %rsi, %rsi
je 0x27be2e
movq %rbx, %rdi
callq 0x28c3e7
movq 0x88(%r14), %rsi
movl 0x90(%r14), %edx
movq %rbx, %rdi
callq 0x2998cc
movq 0x98(%r14), %rsi
testq %rsi, %rsi
je 0x27be58
movq %rbx, %rdi
callq 0x28c3e7
movq 0xf0(%r14), %rsi
testq %rsi, %rsi
je 0x27be77
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x28c3e7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_vfs_find
SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
  sqlite3_vfs *pVfs = 0;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex;
#endif
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return 0;
#endif
#if SQLITE_THREADSAFE
  mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
  sqlite3_mutex_enter(mutex);
  for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
    if( zVfs==0 ) break;
    if( strcmp(zVfs, pVfs->zName)==0 ) break;
  }
  sqlite3_mutex_leave(mutex);
  return pVfs;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x27bed9
testl %eax, %eax
je 0x27be97
xorl %ebx, %ebx
jmp 0x27beae
testq %r14, %r14
sete %al
movq 0x24dcf4(%rip), %rbx    # 0x4c9b98
testq %rbx, %rbx
sete %cl
orb %al, %cl
je 0x27beb9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x27beae
movq 0x10(%rbx), %rbx
testq %r14, %r14
je 0x27beae
testq %rbx, %rbx
jne 0x27beb9
jmp 0x27beae
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_vfs_register
SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
  MUTEX_LOGIC(sqlite3_mutex *mutex;)
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pVfs==0 ) return SQLITE_MISUSE_BKPT;
#endif

  MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )
  sqlite3_mutex_enter(mutex);
  vfsUnlink(pVfs);
  if( makeDflt || vfsList==0 ){
    pVfs->pNext = vfsList;
    vfsList = pVfs;
  }else{
    pVfs->pNext = vfsList->pNext;
    vfsList->pNext = pVfs;
  }
  assert(vfsList);
  sqlite3_mutex_leave(mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x27bed9
testl %eax, %eax
jne 0x27c21c
movq %rbx, %rdi
callq 0x27c223
testl %ebp, %ebp
setne %cl
movq 0x24d9a3(%rip), %rax    # 0x4c9b98
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x27c208
leaq 0x24d992(%rip), %rcx    # 0x4c9b98
jmp 0x27c213
movq %rax, %rcx
addq $0x10, %rcx
movq 0x10(%rax), %rax
movq %rax, 0x10(%rbx)
movq %rbx, (%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vfsUnlink
static void vfsUnlink(sqlite3_vfs *pVfs){
  assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)) );
  if( pVfs==0 ){
    /* No-op */
  }else if( vfsList==pVfs ){
    vfsList = pVfs->pNext;
  }else if( vfsList ){
    sqlite3_vfs *p = vfsList;
    while( p->pNext && p->pNext!=pVfs ){
      p = p->pNext;
    }
    if( p->pNext==pVfs ){
      p->pNext = pVfs->pNext;
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0x27c24f
movq 0x24d969(%rip), %rcx    # 0x4c9b98
cmpq %rdi, %rcx
je 0x27c250
testq %rcx, %rcx
je 0x27c24f
movq %rcx, %rax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x27c24a
cmpq %rdi, %rcx
jne 0x27c239
cmpq %rdi, %rcx
je 0x27c259
retq
leaq 0x24d941(%rip), %rax    # 0x4c9b98
jmp 0x27c25d
addq $0x10, %rax
movq 0x10(%rdi), %rcx
movq %rcx, (%rax)
retq