LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: attlist8
static int PTRCALL
attlist8(PROLOG_STATE *state,
         int tok,
         const char *ptr,
         const char *end,
         const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ATTLIST_NONE;
  case XML_TOK_POUND_NAME:
    if (XmlNameMatchesAscii(enc,
                            ptr + MIN_BYTES_PER_CHAR(enc),
                            end,
                            KW_IMPLIED)) {
      state->handler = attlist1;
      return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
    }
    if (XmlNameMatchesAscii(enc,
                            ptr + MIN_BYTES_PER_CHAR(enc),
                            end,
                            KW_REQUIRED)) {
      state->handler = attlist1;
      return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
    }
    if (XmlNameMatchesAscii(enc,
                            ptr + MIN_BYTES_PER_CHAR(enc),
                            end,
                            KW_FIXED)) {
      state->handler = attlist9;
      return XML_ROLE_ATTLIST_NONE;
    }
    break;
  case XML_TOK_LITERAL:
    state->handler = attlist1;
    return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0xf, %esi
je 0x2536e3
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq -0x132(%rip), %r13      # 0x2534fa
cmpl $0x1b, %esi
je 0x2536d1
cmpl $0x14, %esi
jne 0x2536c3
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movslq 0x80(%r8), %rsi
addq %rdx, %rsi
leaq 0x178148(%rip), %rcx    # 0x3cb7a0
movq %r8, %rdi
movq %r15, %rdx
callq *0x30(%r8)
movl %eax, %ecx
movl $0x23, %eax
testl %ecx, %ecx
jne 0x2536d6
movslq 0x80(%r14), %rsi
addq %r12, %rsi
leaq 0x17812a(%rip), %rcx    # 0x3cb7a8
movq %r14, %rdi
movq %r15, %rdx
callq *0x30(%r14)
movl %eax, %ecx
movl $0x24, %eax
testl %ecx, %ecx
jne 0x2536d6
movslq 0x80(%r14), %rax
addq %rax, %r12
leaq 0x17810d(%rip), %rcx    # 0x3cb7b1
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x2536c3
movl $0x21, %eax
leaq 0x84(%rip), %r13        # 0x253745
jmp 0x2536d6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq -0x892(%rip), %r13      # 0x252e3d
jmp 0x2536d6
movl $0x25, %eax
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x21, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element1
static int PTRCALL
element1(PROLOG_STATE *state,
         int tok,
         __attribute__ ((unused)) const char *ptr,
         __attribute__ ((unused)) const char *end,
         __attribute__ ((unused)) const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ELEMENT_NONE;
  case XML_TOK_NAME:
    if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
      return XML_ROLE_CONTENT_EMPTY;
    }
    if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
      return XML_ROLE_CONTENT_ANY;
    }
    break;
  case XML_TOK_OPEN_PAREN:
    state->handler = element2;
    state->level = 1;
    return XML_ROLE_GROUP_OPEN;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0xf, %esi
je 0x25387c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x17, %esi
je 0x253864
cmpl $0x12, %esi
jne 0x2538b2
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
leaq 0x177f7c(%rip), %rcx    # 0x3cb7b7
movq %r8, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq *0x30(%r8)
testl %eax, %eax
je 0x253882
leaq -0x4a3(%rip), %rax      # 0x2533b0
movq %rax, (%rbx)
movl $0x27, 0xc(%rbx)
movl $0x2a, %eax
jmp 0x2538c1
leaq 0x62(%rip), %rax        # 0x2538cd
movq %rax, (%rbx)
movl $0x1, 0x8(%rbx)
movl $0x2c, %eax
jmp 0x2538c1
movl $0x27, %eax
retq
leaq 0x177f34(%rip), %rcx    # 0x3cb7bd
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x2538b2
leaq -0x4f1(%rip), %rax      # 0x2533b0
movq %rax, (%rbx)
movl $0x27, 0xc(%rbx)
movl $0x29, %eax
jmp 0x2538c1
leaq -0xa7c(%rip), %rax      # 0x252e3d
movq %rax, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element2
static int PTRCALL
element2(PROLOG_STATE *state,
         int tok,
         const char *ptr,
         const char *end,
         const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ELEMENT_NONE;
  case XML_TOK_POUND_NAME:
    if (XmlNameMatchesAscii(enc,
                            ptr + MIN_BYTES_PER_CHAR(enc),
                            end,
                            KW_PCDATA)) {
      state->handler = element3;
      return XML_ROLE_CONTENT_PCDATA;
    }
    break;
  case XML_TOK_OPEN_PAREN:
    state->level = 2;
    state->handler = element6;
    return XML_ROLE_GROUP_OPEN;
  case XML_TOK_NAME:
  case XML_TOK_PREFIXED_NAME:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT;
  case XML_TOK_NAME_QUESTION:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_OPT;
  case XML_TOK_NAME_ASTERISK:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_REP;
  case XML_TOK_NAME_PLUS:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_PLUS;
  }
  return common(state, tok);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x33, %eax
leaq 0x18c(%rip), %rdi       # 0x253a69
leal -0x12(%rsi), %r9d
cmpl $0xe, %r9d
ja 0x25392b
leaq 0x177db2(%rip), %rsi    # 0x3cb6a0
movslq (%rsi,%r9,4), %r9
addq %rsi, %r9
jmpq *%r9
movslq 0x80(%r8), %rax
addq %rax, %rdx
leaq 0x177eb8(%rip), %rax    # 0x3cb7c1
movq %r8, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq *0x30(%r8)
testl %eax, %eax
je 0x253935
movl $0x2b, %eax
leaq 0x4e(%rip), %rdi        # 0x253977
jmp 0x25396b
cmpl $0xf, %esi
je 0x253970
cmpl $0x29, %esi
je 0x25396b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq -0xb04(%rip), %rdi      # 0x252e3d
jmp 0x25396b
movl $0x35, %eax
jmp 0x25396b
movl $0x34, %eax
jmp 0x25396b
movl $0x2, 0x8(%rbx)
movl $0x2c, %eax
leaq 0x7a(%rip), %rdi        # 0x2539de
jmp 0x25396b
movl $0x36, %eax
movq %rdi, (%rbx)
popq %rbx
retq
movl $0x27, %eax
jmp 0x25396e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element3
static int PTRCALL
element3(PROLOG_STATE *state,
         int tok,
         __attribute__ ((unused)) const char *ptr,
         __attribute__ ((unused)) const char *end,
         __attribute__ ((unused)) const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ELEMENT_NONE;
  case XML_TOK_CLOSE_PAREN:
    state->handler = declClose;
    state->role_none = XML_ROLE_ELEMENT_NONE;
    return XML_ROLE_GROUP_CLOSE;
  case XML_TOK_CLOSE_PAREN_ASTERISK:
    state->handler = declClose;
    state->role_none = XML_ROLE_ELEMENT_NONE;
    return XML_ROLE_GROUP_CLOSE_REP;
  case XML_TOK_OR:
    state->handler = element4;
    return XML_ROLE_ELEMENT_NONE;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0x17, %esi
jg 0x253996
movl $0x27, %eax
cmpl $0xf, %esi
je 0x2539c6
cmpl $0x15, %esi
jne 0x2539b7
leaq 0x178(%rip), %rcx       # 0x253b0a
movq %rcx, (%rdi)
retq
cmpl $0x24, %esi
je 0x2539c7
cmpl $0x18, %esi
jne 0x2539b7
leaq -0x5f7(%rip), %rax      # 0x2533b0
movq %rax, (%rdi)
movl $0x27, 0xc(%rdi)
movl $0x2d, %eax
retq
leaq -0xb81(%rip), %rax      # 0x252e3d
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
leaq -0x61e(%rip), %rax      # 0x2533b0
movq %rax, (%rdi)
movl $0x27, 0xc(%rdi)
movl $0x2e, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element6
static int PTRCALL
element6(PROLOG_STATE *state,
         int tok,
         __attribute__ ((unused)) const char *ptr,
         __attribute__ ((unused)) const char *end,
         __attribute__ ((unused)) const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ELEMENT_NONE;
  case XML_TOK_OPEN_PAREN:
    state->level += 1;
    return XML_ROLE_GROUP_OPEN;
  case XML_TOK_NAME:
  case XML_TOK_PREFIXED_NAME:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT;
  case XML_TOK_NAME_QUESTION:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_OPT;
  case XML_TOK_NAME_ASTERISK:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_REP;
  case XML_TOK_NAME_PLUS:
    state->handler = element7;
    return XML_ROLE_CONTENT_ELEMENT_PLUS;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0x16, %esi
jle 0x253a04
leal -0x17(%rsi), %eax
cmpl $0x9, %eax
ja 0x253a1e
leaq 0x177cea(%rip), %rcx    # 0x3cb6dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incl 0x8(%rdi)
movl $0x2c, %eax
retq
cmpl $0xf, %esi
je 0x253a63
cmpl $0x12, %esi
jne 0x253a23
leaq 0x54(%rip), %rax        # 0x253a69
movq %rax, (%rdi)
movl $0x33, %eax
retq
cmpl $0x29, %esi
je 0x253a0e
leaq -0xbed(%rip), %rax      # 0x252e3d
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
leaq 0x2f(%rip), %rax        # 0x253a69
movq %rax, (%rdi)
movl $0x34, %eax
retq
leaq 0x1f(%rip), %rax        # 0x253a69
movq %rax, (%rdi)
movl $0x36, %eax
retq
leaq 0xf(%rip), %rax         # 0x253a69
movq %rax, (%rdi)
movl $0x35, %eax
retq
movl $0x27, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element7
static int PTRCALL
element7(PROLOG_STATE *state,
         int tok,
         __attribute__ ((unused)) const char *ptr,
         __attribute__ ((unused)) const char *end,
         __attribute__ ((unused)) const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ELEMENT_NONE;
  case XML_TOK_CLOSE_PAREN:
    state->level -= 1;
    if (state->level == 0) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
    }
    return XML_ROLE_GROUP_CLOSE;
  case XML_TOK_CLOSE_PAREN_ASTERISK:
    state->level -= 1;
    if (state->level == 0) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
    }
    return XML_ROLE_GROUP_CLOSE_REP;
  case XML_TOK_CLOSE_PAREN_QUESTION:
    state->level -= 1;
    if (state->level == 0) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
    }
    return XML_ROLE_GROUP_CLOSE_OPT;
  case XML_TOK_CLOSE_PAREN_PLUS:
    state->level -= 1;
    if (state->level == 0) {
      state->handler = declClose;
      state->role_none = XML_ROLE_ELEMENT_NONE;
    }
    return XML_ROLE_GROUP_CLOSE_PLUS;
  case XML_TOK_COMMA:
    state->handler = element6;
    return XML_ROLE_GROUP_SEQUENCE;
  case XML_TOK_OR:
    state->handler = element6;
    return XML_ROLE_GROUP_CHOICE;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0x22, %esi
jle 0x253a91
addl $-0x23, %esi
cmpl $0x3, %esi
ja 0x253aea
leaq 0x177c87(%rip), %rax    # 0x3cb704
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
decl 0x8(%rdi)
movl $0x2f, %eax
je 0x253ad8
retq
cmpl $0xf, %esi
je 0x253aac
cmpl $0x15, %esi
je 0x253afa
cmpl $0x18, %esi
jne 0x253aea
decl 0x8(%rdi)
movl $0x2d, %eax
jne 0x253a90
jmp 0x253ad8
movl $0x27, %eax
retq
decl 0x8(%rdi)
movl $0x30, %eax
jne 0x253a90
jmp 0x253ad8
leaq -0xe7(%rip), %rax       # 0x2539de
movq %rax, (%rdi)
movl $0x32, %eax
retq
decl 0x8(%rdi)
movl $0x2e, %eax
jne 0x253a90
leaq -0x72f(%rip), %rcx      # 0x2533b0
movq %rcx, (%rdi)
movl $0x27, 0xc(%rdi)
retq
leaq -0xcb4(%rip), %rax      # 0x252e3d
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
leaq -0x123(%rip), %rax      # 0x2539de
movq %rax, (%rdi)
movl $0x31, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: element5
static int PTRCALL
element5(PROLOG_STATE *state,
         int tok,
         __attribute__ ((unused)) const char *ptr,
         __attribute__ ((unused)) const char *end,
         __attribute__ ((unused)) const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ELEMENT_NONE;
  case XML_TOK_CLOSE_PAREN_ASTERISK:
    state->handler = declClose;
    state->role_none = XML_ROLE_ELEMENT_NONE;
    return XML_ROLE_GROUP_CLOSE_REP;
  case XML_TOK_OR:
    state->handler = element4;
    return XML_ROLE_ELEMENT_NONE;
  }
  return common(state, tok);
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0xf, %esi
je 0x253bc5
movq %rdi, %rbx
cmpl $0x12, %esi
jne 0x253bed
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
leaq 0x177b76(%rip), %rcx    # 0x3cb71c
movq %r8, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq *0x30(%r8)
movl $0x11, %ebp
testl %eax, %eax
je 0x253bcc
leaq 0x44(%rip), %rax        # 0x253c07
jmp 0x253bf9
movl $0x11, %ebp
jmp 0x253bfc
leaq 0x177b50(%rip), %rcx    # 0x3cb723
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x253bed
leaq 0x53(%rip), %rax        # 0x253c3e
jmp 0x253bf9
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq -0xdbc(%rip), %rax      # 0x252e3d
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: notation4
static int PTRCALL
notation4(PROLOG_STATE *state,
          int tok,
          __attribute__ ((unused)) const char *ptr,
          __attribute__ ((unused)) const char *end,
          __attribute__ ((unused)) const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_NOTATION_NONE;
  case XML_TOK_LITERAL:
    state->handler = declClose;
    state->role_none = XML_ROLE_NOTATION_NONE;
    return XML_ROLE_NOTATION_SYSTEM_ID;
  case XML_TOK_DECL_CLOSE:
    setTopLevel(state);
    return XML_ROLE_NOTATION_NO_SYSTEM_ID;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0xf, %esi
je 0x253ca2
cmpl $0x11, %esi
je 0x253c92
cmpl $0x1b, %esi
jne 0x253ca8
leaq -0x8d2(%rip), %rax      # 0x2533b0
movq %rax, (%rdi)
movl $0x11, 0xc(%rdi)
movl $0x13, %eax
retq
leaq -0xda8(%rip), %rax      # 0x252ef1
movq %rax, (%rdi)
movl $0x14, %eax
retq
movl $0x11, %eax
retq
leaq -0xe72(%rip), %rax      # 0x252e3d
movq %rax, (%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: XmlUtf8Encode
int FASTCALL
XmlUtf8Encode(int c, char *buf)
{
  enum {
    /* minN is minimum legal resulting value for N byte sequence */
    min2 = 0x80,
    min3 = 0x800,
    min4 = 0x10000
  };

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

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

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

// Assembly:
movl %edi, %ecx
sarl $0x8, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leal -0xd8(%rcx), %edx
cmpl $0x8, %edx
jae 0x2540b0
retq
cmpl $0xff, %ecx
je 0x2540d2
testl %ecx, %ecx
jne 0x2540df
movslq %edi, %rcx
leaq 0x26192a(%rip), %rdx    # 0x4b59f0
cmpb $0x0, 0x88(%rcx,%rdx)
jne 0x2540df
jmp 0x2540af
movl %edi, %ecx
andl $-0x2, %ecx
cmpl $0xfffe, %ecx           # imm = 0xFFFE
je 0x2540af
movl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movq %rsi, %r12
movq (%rsi), %rsi
cmpq %rdx, %rsi
je 0x254274
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r13
leaq 0x3e0(%rdi), %rbp
movzbl (%rsi), %ecx
movsbl (%rbp,%rcx,4), %eax
testl %eax, %eax
je 0x254203
movslq %eax, %rdx
movq %rbx, %rdi
subq (%r14), %rdi
cmpq %rdx, %rdi
jl 0x254274
leaq 0x1(,%rcx,4), %rcx
addq %rbp, %rcx
incq %rsi
jmp 0x254247
movq 0x1d8(%r13), %rdi
callq *0x1d0(%r13)
movl %eax, %edi
leaq 0x4(%rsp), %rsi
callq 0x253cfc
movl %eax, %ecx
movq %rbx, %rdx
subq (%r14), %rdx
cmpq %rcx, %rdx
jl 0x254274
movq (%r12), %rcx
movzbl (%rcx), %edx
movzbl 0x88(%r13,%rdx), %edx
leaq (%rcx,%rdx), %rsi
addq $-0x3, %rsi
leaq 0x4(%rsp), %rcx
movq %rsi, (%r12)
movl %eax, %eax
xorl %edx, %edx
movb (%rcx,%rdx), %sil
movq (%r14), %rdi
leaq 0x1(%rdi), %r8
movq %r8, (%r14)
movb %sil, (%rdi)
incq %rdx
cmpl %edx, %eax
jne 0x25424f
movq (%r12), %rsi
cmpq %r15, %rsi
jne 0x2541d5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/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 0x254301
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r13
movq (%rcx), %rcx
cmpq %rbx, %rcx
je 0x254301
movzbl (%rsi), %eax
movzwl 0x1e0(%r13,%rax,2), %eax
testw %ax, %ax
je 0x2542c1
incq %rsi
jmp 0x2542e7
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), %rdx
leaq 0x2(%rdx), %rcx
movq %rcx, (%r14)
movw %ax, (%rdx)
movq (%r12), %rsi
cmpq %r15, %rsi
jne 0x2542a6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/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 0x254374
cmpl $-0x1, %eax
je 0x25436a
movb %al, 0x85(%r14)
leaq 0x7a(%rip), %rax        # 0x2543ba
movq %rax, (%r14)
leaq 0x80(%rip), %rax        # 0x2543ca
movq %rax, 0x8(%r14)
leaq 0x88(%rip), %rax        # 0x2543dd
movq %rax, 0x60(%r14)
movq %rbx, 0x88(%r14)
movq %r14, (%rbx)
movl $0x1, %eax
jmp 0x25436c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: normal_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 0x25597c
leaq 0x176293(%rip), %r8     # 0x3cbbbc
movq %rsi, %rax
movzbl (%rax), %r9d
movzbl 0x88(%rdi,%r9), %r9d
addl $-0x2, %r9d
cmpl $0x13, %r9d
ja 0x255965
movslq (%r8,%r9,4), %r9
addq %r8, %r9
jmpq *%r9
movl $0x2, %r9d
jmp 0x25596b
movl $0x4, %r9d
jmp 0x25596b
movl $0x3, %r9d
jmp 0x25596b
movl $0x1, %r9d
addq %r9, %rax
cmpq %rdx, %rax
jne 0x25592c
movq %rax, (%rcx)
movl $0x6, %eax
retq
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
retq
cmpq %rsi, %rax
jne 0x255973
incq %rsi
movq %rsi, (%rcx)
jmp 0x2559d8
cmpq %rsi, %rax
jne 0x255973
incq %rsi
movq %rsi, (%rcx)
movl $0x27, %eax
retq
movq %rax, (%rcx)
xorl %eax, %eax
retq
cmpq %rsi, %rax
jne 0x255973
incq %rsi
jmp 0x256973
cmpq %rsi, %rax
jne 0x255973
leaq 0x1(%rsi), %rax
cmpq %rdx, %rax
je 0x2559de
movzbl 0x1(%rsi), %edx
addq $0x2, %rsi
cmpb $0xa, 0x88(%rdi,%rdx)
cmoveq %rsi, %rax
movq %rax, (%rcx)
movl $0x7, %eax
retq
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: normal_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 0x255a4b
leaq 0x17621b(%rip), %r8     # 0x3cbc0c
movq %rsi, %rax
movzbl (%rax), %r9d
movzbl 0x88(%rdi,%r9), %r9d
leal -0x3(%r9), %r10d
cmpl $0x7, %r10d
ja 0x255a2d
movslq (%r8,%r10,4), %r9
addq %r8, %r9
jmpq *%r9
movl $0x2, %r9d
jmp 0x255a39
movl $0x4, %r9d
jmp 0x255a39
movl $0x3, %r9d
jmp 0x255a39
cmpl $0x1e, %r9d
je 0x255a99
movl $0x1, %r9d
addq %r9, %rax
cmpq %rdx, %rax
jne 0x2559f4
movq %rax, (%rcx)
movl $0x6, %eax
jmp 0x255a50
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
popq %rcx
retq
cmpq %rsi, %rax
jne 0x255a41
incq %rsi
popq %rax
jmp 0x256973
cmpq %rsi, %rax
jne 0x255a41
incq %rsi
movq %rsi, (%rcx)
jmp 0x255a92
cmpq %rsi, %rax
jne 0x255a41
leaq 0x1(%rsi), %rax
cmpq %rdx, %rax
je 0x255ab2
movzbl 0x1(%rsi), %edx
addq $0x2, %rsi
cmpb $0xa, 0x88(%rdi,%rdx)
cmoveq %rsi, %rax
movq %rax, (%rcx)
movl $0x7, %eax
jmp 0x255a50
cmpq %rsi, %rax
jne 0x255a41
incq %rsi
callq 0x25660e
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x16, %ecx
cmovnel %ecx, %eax
jmp 0x255a50
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x255a50
// File: /workspace/github_c_makefile_star2_O3/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 0x255b7e
incq %rcx
xorl %eax, %eax
cmpq %rdx, %rsi
je 0x255b86
cmpb %dil, (%rsi)
jne 0x255b86
incq %rsi
movb (%rcx), %dil
incq %rcx
testb %dil, %dil
jne 0x255b66
xorl %eax, %eax
cmpq %rdx, %rsi
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x2, %edx
cmpl $0xdb, %r8d
jg 0x258858
leal -0xd8(%r8), %r9d
cmpl $0x4, %r9d
jae 0x258868
movl $0x4, %edx
addq %rdx, %rax
jmp 0x25882e
cmpl $0xff, %r8d
jne 0x258894
cmpb $-0x3, (%rax)
jbe 0x258853
jmp 0x2588aa
testl %r8d, %r8d
jne 0x258853
movzbl (%rax), %r8d
movzbl 0x88(%rdi,%r8), %r8d
cmpl $0x1d, %r8d
ja 0x2588aa
btl %r8d, %ecx
jb 0x258853
cmpl $0x6, %r8d
je 0x2588a3
cmpl $0x7, %r8d
je 0x25884e
jmp 0x2588aa
addl $0xffffff24, %r8d       # imm = 0xFFFFFF24
cmpl $0x4, %r8d
jae 0x258853
jmp 0x2588aa
movl $0x3, %edx
jmp 0x258853
subl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: normal_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:
movzbl 0x2(%rsi), %eax
cmpl $0x3b, %eax
je 0x255ef7
addq $0x3, %rsi
xorl %edi, %edi
cmpl $0x78, %eax
jne 0x255edd
leaq 0x175e04(%rip), %rax    # 0x3cbc98
movzbl (%rsi), %ecx
leal -0x30(%rcx), %edx
cmpl $0x36, %edx
ja 0x255ecf
movsbl %cl, %ecx
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
shll $0x4, %edi
addl $-0x30, %ecx
orl %ecx, %edi
jmp 0x255ec7
shll $0x4, %edi
addl %ecx, %edi
addl $-0x57, %edi
jmp 0x255ec7
shll $0x4, %edi
addl %ecx, %edi
addl $-0x37, %edi
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
jg 0x255ef1
incq %rsi
jmp 0x255e94
movb (%rsi), %al
incq %rsi
cmpb $0x3b, %al
je 0x255ef9
movsbl %al, %eax
leal (%rdi,%rdi,4), %ecx
leal (%rax,%rcx,2), %edi
addl $-0x30, %edi
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
jle 0x255ed4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
xorl %edi, %edi
jmp 0x25409a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: normal_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 0x256017
movq 0x8(%rcx), %r8
leaq 0x175dd7(%rip), %rax    # 0x3cbd74
movzbl (%rsi), %r9d
movzbl 0x88(%rdi,%r9), %r9d
addl $-0x5, %r9d
cmpl $0x5, %r9d
ja 0x255fc4
movslq (%rax,%r9,4), %r9
addq %rax, %r9
jmpq *%r9
addq $0x3, %rsi
jmp 0x256005
incq %rsi
jmp 0x256005
addq $0x4, %rsi
jmp 0x256005
incq (%rcx)
leaq 0x1(%rsi), %r9
movq $-0x1, %r8
cmpq %rdx, %r9
je 0x256008
movzbl 0x1(%rsi), %r10d
cmpb $0xa, 0x88(%rdi,%r10)
jne 0x256008
addq $0x2, %rsi
jmp 0x256005
incq (%rcx)
incq %rsi
movq $-0x1, %r8
movq %rsi, %r9
incq %r8
movq %r8, 0x8(%rcx)
movq %r9, %rsi
cmpq %rdx, %r9
jne 0x255f9d
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2560f0
movb (%rax), %dil
movq (%rcx), %r9
testb %dil, %dil
jns 0x2560d4
movq %r8, %rax
subq %r9, %rax
cmpq $0x2, %rax
jl 0x2560f0
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)
movq (%rsi), %rax
incq %rax
movq %rax, (%rsi)
jmp 0x25608b
cmpq %r8, %r9
je 0x2560f0
leaq 0x1(%rax), %rdi
movq %rdi, (%rsi)
movb (%rax), %al
movq (%rcx), %rdi
leaq 0x1(%rdi), %r9
movq %r9, (%rcx)
movb %al, (%rdi)
jmp 0x256088
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, %rdx
je 0x2591b7
leaq 0x173327(%rip), %r9     # 0x3cc430
movzbl 0x1(%rdx), %r10d
cmpl $0xdb, %r10d
jg 0x25913a
leal -0xd8(%r10), %r11d
cmpl $0x4, %r11d
jae 0x25914a
movq %rcx, %r10
subq %rdx, %r10
cmpq $0x4, %r10
jl 0x2591be
addq $0x4, %rdx
jmp 0x2591a8
cmpl $0xff, %r10d
jne 0x259177
cmpb $-0x3, (%rdx)
jbe 0x2591a4
jmp 0x2591b8
testl %r10d, %r10d
jne 0x2591a4
movzbl (%rdx), %r10d
movzbl 0x88(%rsi,%r10), %r11d
cmpq $0xd, %r11
ja 0x2591a4
movslq (%r9,%r11,4), %r10
addq %r9, %r10
jmpq *%r10
leaq 0x2(%rdx), %r10
cmpl %edi, %r11d
jne 0x2591ab
jmp 0x2591c4
addl $0xffffff24, %r10d      # imm = 0xFFFFFF24
cmpl $0x4, %r10d
jae 0x2591a4
jmp 0x2591b8
movq %rcx, %r10
subq %rdx, %r10
cmpq $0x3, %r10
jl 0x2591be
addq $0x3, %rdx
jmp 0x2591a8
movq %rcx, %r10
subq %rdx, %r10
cmpq $0x2, %r10
jl 0x2591be
addq $0x2, %rdx
movq %rdx, %r10
movq %r10, %rdx
cmpq %rcx, %r10
jne 0x259109
retq
movq %rdx, (%r8)
xorl %eax, %eax
retq
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
retq
cmpq %rcx, %r10
je 0x2591f4
movq %r10, (%r8)
cmpb $0x0, 0x3(%rdx)
jne 0x2591bb
movzbl (%r10), %eax
movzbl 0x88(%rsi,%rax), %ecx
cmpl $0x1e, %ecx
ja 0x2591bb
movl $0x1b, %eax
movl $0x40300e00, %edx       # imm = 0x40300E00
btl %ecx, %edx
jb 0x2591b7
jmp 0x2591bb
movl $0xffffffe5, %eax       # imm = 0xFFFFFFE5
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_scanDecl
static int PTRCALL
PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
                 const char *end, const char **nextTokPtr)
{
  if (ptr == end)
    return XML_TOK_PARTIAL;
  switch (BYTE_TYPE(enc, ptr)) {
  case BT_MINUS:
    return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
  case BT_LSQB:
    *nextTokPtr = ptr + MINBPC(enc);
    return XML_TOK_COND_SECT_OPEN;
  case BT_NMSTRT:
  case BT_HEX:
    ptr += MINBPC(enc);
    break;
  default:
    *nextTokPtr = ptr;
    return XML_TOK_INVALID;
  }
  while (ptr != end) {
    switch (BYTE_TYPE(enc, ptr)) {
    case BT_PERCNT:
      if (ptr + MINBPC(enc) == end)
        return XML_TOK_PARTIAL;
      /* don't allow <!ENTITY% foo "whatever"> */
      switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
      case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
        *nextTokPtr = ptr;
        return XML_TOK_INVALID;
      }
      /* fall through */
    case BT_S: case BT_CR: case BT_LF:
      *nextTokPtr = ptr;
      return XML_TOK_DECL_OPEN;
    case BT_NMSTRT:
    case BT_HEX:
      ptr += MINBPC(enc);
      break;
    default:
      *nextTokPtr = ptr;
      return XML_TOK_INVALID;
    }
  }
  return XML_TOK_PARTIAL;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rdx, %rsi
je 0x259278
cmpb $0x0, 0x1(%rsi)
je 0x259210
movq %rsi, (%rcx)
xorl %eax, %eax
retq
movzbl (%rsi), %r8d
movzbl 0x88(%rdi,%r8), %r8d
addl $-0x14, %r8d
cmpl $0x7, %r8d
ja 0x25920a
leaq 0x17323a(%rip), %r9     # 0x3cc468
movslq (%r9,%r8,4), %r8
addq %r9, %r8
jmpq *%r8
addq $0x2, %rsi
cmpq %rdx, %rsi
je 0x259278
leaq 0x173240(%rip), %r8     # 0x3cc488
cmpb $0x0, 0x1(%rsi)
jne 0x25920a
movzbl (%rsi), %r9d
movzbl 0x88(%rdi,%r9), %r9d
leal -0x15(%r9), %r10d
cmpl $0x9, %r10d
ja 0x25928f
movslq (%r8,%r10,4), %r9
addq %r8, %r9
jmpq *%r9
addq $0x2, %rsi
cmpq %rdx, %rsi
jne 0x259248
retq
addq $0x2, %rsi
movq %rsi, (%rcx)
movl $0x21, %eax
retq
addq $0x2, %rsi
jmp 0x259ac5
addl $-0x9, %r9d
cmpl $0x2, %r9d
jae 0x25920a
movq %rsi, (%rcx)
movl $0x10, %eax
retq
leaq 0x2(%rsi), %r8
cmpq %rdx, %r8
je 0x259278
cmpb $0x0, 0x3(%rsi)
jne 0x25929d
movzbl (%r8), %eax
movzbl 0x88(%rdi,%rax), %eax
cmpl $0x1e, %eax
ja 0x25929d
movl $0x40200600, %edx       # imm = 0x40200600
btl %eax, %edx
jb 0x25920a
jmp 0x25929d
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rdx, %rsi
je 0x259bfa
xorl %r8d, %r8d
cmpb $0x0, 0x1(%rsi)
jne 0x259bf4
cmpb $0x2d, (%rsi)
jne 0x259bf4
addq $0x2, %rsi
cmpq %rdx, %rsi
je 0x259bfa
leaq 0x172b8b(%rip), %r9     # 0x3cc688
movzbl 0x1(%rsi), %r10d
cmpl $0xdb, %r10d
jg 0x259b2e
leal -0xd8(%r10), %r11d
cmpl $0x4, %r11d
jae 0x259b41
movq %rdx, %r10
subq %rsi, %r10
cmpq $0x4, %r10
jl 0x259bc4
addq $0x4, %rsi
jmp 0x259ba1
cmpl $0xff, %r10d
jne 0x259b71
cmpb $-0x3, (%rsi)
jbe 0x259b9d
jmp 0x259bf4
testl %r10d, %r10d
jne 0x259b9d
movzbl (%rsi), %r10d
movzbl 0x88(%rdi,%r10), %r10d
cmpq $0x8, %r10
ja 0x259b80
movslq (%r9,%r10,4), %r10
addq %r9, %r10
jmpq *%r10
movq %rdx, %r10
subq %rsi, %r10
cmpq $0x2, %r10
jge 0x259b9d
jmp 0x259bc4
addl $0xffffff24, %r10d      # imm = 0xFFFFFF24
cmpl $0x4, %r10d
jae 0x259b9d
jmp 0x259bf4
cmpl $0x1b, %r10d
jne 0x259b9d
leaq 0x2(%rsi), %r10
cmpq %rdx, %r10
je 0x259bfa
cmpb $0x0, 0x3(%rsi)
jne 0x259ba4
cmpb $0x2d, (%r10)
jne 0x259ba4
jmp 0x259bca
addq $0x2, %rsi
movq %rsi, %r10
movq %r10, %rsi
cmpq %rdx, %r10
jne 0x259afd
jmp 0x259bfa
movq %rdx, %r10
subq %rsi, %r10
cmpq $0x3, %r10
jl 0x259bc4
addq $0x3, %rsi
jmp 0x259ba1
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
retq
leaq 0x4(%rsi), %rdi
cmpq %rdx, %rdi
je 0x259bfa
cmpb $0x0, 0x5(%rsi)
jne 0x259bf1
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
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2570d2
addq %rax, %r8
movq %r8, %rdx
cmpq %rax, %r8
jbe 0x2570d2
leaq -0x1(%rdx), %r8
movb -0x1(%rdx), %r9b
andb $-0x40, %r9b
negb %r9b
jo 0x2570ab
jmp 0x2570d2
movb (%rax), %r8b
movb %r8b, (%rdi)
incq %rax
incq %rdi
cmpq %rdx, %rax
jne 0x2570c6
movq %rax, (%rsi)
movq %rdi, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2571fe
pushq %rbx
movzbl (%r9), %r10d
movzwl %r10w, %r10d
movzbl 0x88(%rdi,%r10), %r11d
cmpl $0x7, %r11d
je 0x25717a
cmpl $0x6, %r11d
je 0x25714c
cmpl $0x5, %r11d
jne 0x2571e0
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 0x2571ef
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 0x2571ef
leaq 0x2(%rax), %r11
cmpq %r8, %r11
je 0x2571fd
andl $0x7, %r10d
shll $0x12, %r10d
movzbl 0x1(%r9), %r11d
andl $0x3f, %r11d
shll $0xc, %r11d
orl %r10d, %r11d
movzbl 0x2(%r9), %r10d
andl $0x3f, %r10d
shll $0x6, %r10d
movzbl 0x3(%r9), %ebx
andl $0x3f, %ebx
addl %r10d, %r11d
addl $0xff0000, %r11d        # imm = 0xFF0000
shrl $0xa, %r11d
orl $0xd800, %r11d          # imm = 0xD800
movw %r11w, (%rax)
orl %r10d, %ebx
orl $0xdc00, %ebx           # imm = 0xDC00
movw %bx, 0x2(%rax)
addq $0x4, %rax
addq $0x4, %r9
jmp 0x2571ef
incq %r9
movsbl %r10b, %r10d
movw %r10w, (%rax)
addq $0x2, %rax
cmpq %rdx, %r9
je 0x2571fd
cmpq %r8, %rax
jne 0x257100
popq %rbx
movq %r9, (%rsi)
movq %rax, (%rcx)
retq