LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: attlist2
static int PTRCALL
attlist2(PROLOG_STATE *state,
         int tok,
         const char *ptr,
         const char *end,
         const ENCODING *enc)
{
  switch (tok) {
  case XML_TOK_PROLOG_S:
    return XML_ROLE_ATTLIST_NONE;
  case XML_TOK_NAME:
    {
      static const char * const types[] = {
        KW_CDATA,
        KW_ID,
        KW_IDREF,
        KW_IDREFS,
        KW_ENTITY,
        KW_ENTITIES,
        KW_NMTOKEN,
        KW_NMTOKENS,
      };
      int i;
      for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
        if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
          state->handler = attlist8;
          return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
        }
    }
    if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
      state->handler = attlist5;
      return XML_ROLE_ATTLIST_NONE;
    }
    break;
  case XML_TOK_OPEN_PAREN:
    state->handler = attlist3;
    return XML_ROLE_ATTLIST_NONE;
  }
  return common(state, tok);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x21
popq %rbp
cmpl $0xf, %esi
je 0x202be0
cmpl $0x17, %esi
je 0x202b91
cmpl $0x12, %esi
jne 0x202bc3
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, (%rsp)
pushq $0x17
popq %rbp
xorl %r13d, %r13d
leaq 0x168ff8(%rip), %rbx    # 0x36bb60
movq 0x30(%r15), %rax
cmpq $0x20, %r13
je 0x202b9a
movslq (%r13,%rbx), %rcx
addq %rbx, %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *%rax
testl %eax, %eax
jne 0x202bd2
addq $0x4, %r13
incl %ebp
jmp 0x202b68
leaq 0x140(%rip), %rax       # 0x202cd8
jmp 0x202bbe
leaq 0x168fb0(%rip), %rcx    # 0x36bb51
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *%rax
testl %eax, %eax
movq (%rsp), %rdi
pushq $0x21
popq %rbp
je 0x202bc3
leaq 0xf6(%rip), %rax        # 0x202cb4
movq %rax, (%rdi)
jmp 0x202be0
leaq -0x6fc(%rip), %rax      # 0x2024ce
movq %rax, (%rdi)
pushq $-0x1
popq %rbp
jmp 0x202be0
leaq 0x18(%rip), %rax        # 0x202bf1
movq (%rsp), %rcx
movq %rax, (%rcx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x202c48
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq -0x116(%rip), %r13      # 0x202af3
cmpl $0x1b, %esi
je 0x202c43
cmpl $0x14, %esi
jne 0x202c9d
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movslq 0x80(%r8), %rsi
addq %rdx, %rsi
leaq 0x168f7f(%rip), %rcx    # 0x36bbb0
movq %r8, %rdi
movq %r15, %rdx
callq *0x30(%r8)
testl %eax, %eax
je 0x202c4c
pushq $0x23
jmp 0x202c45
pushq $0x25
popq %rax
jmp 0x202ca7
pushq $0x21
popq %rax
retq
movslq 0x80(%r14), %rsi
addq %r12, %rsi
leaq 0x168f5b(%rip), %rcx    # 0x36bbb8
movq %r14, %rdi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x202c6f
pushq $0x24
jmp 0x202c45
movslq 0x80(%r14), %rax
addq %rax, %r12
leaq 0x168f41(%rip), %rcx    # 0x36bbc1
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x202c9d
pushq $0x21
popq %rax
leaq 0x6b(%rip), %r13        # 0x202d06
jmp 0x202ca7
pushq $-0x1
popq %rax
leaq -0x7d9(%rip), %r13      # 0x2024ce
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x202e1f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x17, %esi
je 0x202e0a
cmpl $0x12, %esi
jne 0x202e50
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
leaq 0x168de3(%rip), %rcx    # 0x36bbc7
movq %r8, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq *0x30(%r8)
testl %eax, %eax
je 0x202e23
leaq -0x431(%rip), %rax      # 0x2029cb
movq %rax, (%rbx)
movl $0x27, 0xc(%rbx)
pushq $0x2a
jmp 0x202e5c
leaq 0x58(%rip), %rax        # 0x202e69
movq %rax, (%rbx)
movl $0x1, 0x8(%rbx)
pushq $0x2c
jmp 0x202e5c
pushq $0x27
popq %rax
retq
leaq 0x168da3(%rip), %rcx    # 0x36bbcd
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x202e50
leaq -0x477(%rip), %rax      # 0x2029cb
movq %rax, (%rbx)
movl $0x27, 0xc(%rbx)
pushq $0x29
jmp 0x202e5c
leaq -0x989(%rip), %rax      # 0x2024ce
movq %rax, (%rbx)
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x33
popq %rax
leaq 0x15c(%rip), %rdi       # 0x202fd3
leal -0x12(%rsi), %r9d
cmpl $0xe, %r9d
ja 0x202ec3
leaq 0x168c28(%rip), %rsi    # 0x36bab0
movslq (%rsi,%r9,4), %r9
addq %rsi, %r9
jmpq *%r9
movslq 0x80(%r8), %rax
addq %rax, %rdx
leaq 0x168d2e(%rip), %rax    # 0x36bbd1
movq %r8, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq *0x30(%r8)
testl %eax, %eax
je 0x202ecd
pushq $0x2b
popq %rax
leaq 0x40(%rip), %rdi        # 0x202f01
jmp 0x202ef7
cmpl $0xf, %esi
je 0x202efc
cmpl $0x29, %esi
je 0x202ef7
pushq $-0x1
popq %rax
leaq -0xa09(%rip), %rdi      # 0x2024ce
jmp 0x202ef7
pushq $0x35
jmp 0x202ef6
pushq $0x34
jmp 0x202ef6
movl $0x2, 0x8(%rbx)
pushq $0x2c
popq %rax
leaq 0x69(%rip), %rdi        # 0x202f5b
jmp 0x202ef7
pushq $0x36
popq %rax
movq %rdi, (%rbx)
popq %rbx
retq
pushq $0x27
popq %rax
jmp 0x202efa
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $0x27
popq %rax
cmpl $0xf, %esi
je 0x202f5a
cmpl $0x15, %esi
je 0x202f2d
cmpl $0x24, %esi
je 0x202f38
cmpl $0x18, %esi
jne 0x202f4d
leaq -0x554(%rip), %rax      # 0x2029cb
movq %rax, (%rdi)
movl $0x27, 0xc(%rdi)
pushq $0x2d
jmp 0x202f4b
leaq 0x124(%rip), %rcx       # 0x203058
movq %rcx, (%rdi)
retq
leaq -0x574(%rip), %rax      # 0x2029cb
movq %rax, (%rdi)
movl $0x27, 0xc(%rdi)
pushq $0x2e
popq %rax
retq
leaq -0xa86(%rip), %rax      # 0x2024ce
movq %rax, (%rdi)
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leal -0x17(%rsi), %eax
cmpl $0x9, %eax
ja 0x202f7a
leaq 0x168b82(%rip), %rcx    # 0x36baec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incl 0x8(%rdi)
pushq $0x2c
jmp 0x202fd1
cmpl $0xf, %esi
je 0x202fcf
cmpl $0x12, %esi
je 0x202f89
cmpl $0x29, %esi
jne 0x202f97
leaq 0x43(%rip), %rax        # 0x202fd3
movq %rax, (%rdi)
pushq $0x33
jmp 0x202fd1
leaq -0xad0(%rip), %rax      # 0x2024ce
movq %rax, (%rdi)
pushq $-0x1
jmp 0x202fd1
leaq 0x27(%rip), %rax        # 0x202fd3
movq %rax, (%rdi)
pushq $0x35
jmp 0x202fd1
leaq 0x19(%rip), %rax        # 0x202fd3
movq %rax, (%rdi)
pushq $0x36
jmp 0x202fd1
leaq 0xb(%rip), %rax         # 0x202fd3
movq %rax, (%rdi)
pushq $0x34
jmp 0x202fd1
pushq $0x27
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leal -0x23(%rsi), %eax
cmpl $0x3, %eax
jbe 0x202ff1
cmpl $0xf, %esi
je 0x20301d
cmpl $0x15, %esi
je 0x203008
cmpl $0x18, %esi
jne 0x20302f
decl 0x8(%rdi)
pushq $0x2d
jmp 0x203042
leaq 0x168b1c(%rip), %rcx    # 0x36bb14
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
decl 0x8(%rdi)
pushq $0x2f
jmp 0x203042
leaq -0xb4(%rip), %rax       # 0x202f5b
movq %rax, (%rdi)
pushq $0x31
jmp 0x20303b
decl 0x8(%rdi)
pushq $0x30
jmp 0x203042
pushq $0x27
jmp 0x20303b
leaq -0xcd(%rip), %rax       # 0x202f5b
movq %rax, (%rdi)
pushq $0x32
jmp 0x20303b
leaq -0xb68(%rip), %rax      # 0x2024ce
movq %rax, (%rdi)
pushq $-0x1
popq %rax
retq
decl 0x8(%rdi)
pushq $0x2e
popq %rax
je 0x203046
retq
leaq -0x682(%rip), %rcx      # 0x2029cb
movq %rcx, (%rdi)
movl $0x27, 0xc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $0x27
popq %rax
cmpl $0xf, %esi
je 0x2030c2
cmpl $0x15, %esi
je 0x2030aa
cmpl $0x24, %esi
jne 0x2030b5
leaq -0x6d1(%rip), %rax      # 0x2029cb
movq %rax, (%rdi)
movl $0x27, 0xc(%rdi)
pushq $0x2e
popq %rax
retq
leaq -0x59(%rip), %rcx       # 0x203058
movq %rcx, (%rdi)
retq
leaq -0xbee(%rip), %rax      # 0x2024ce
movq %rax, (%rdi)
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x203105
movq %rdi, %rbx
cmpl $0x12, %esi
jne 0x20312b
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
leaq 0x168a44(%rip), %rcx    # 0x36bb2c
movq %r8, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq *0x30(%r8)
pushq $0x11
popq %rbp
testl %eax, %eax
je 0x20310a
leaq 0x40(%rip), %rax        # 0x203143
jmp 0x203135
pushq $0x11
popq %rbp
jmp 0x203138
leaq 0x168a22(%rip), %rcx    # 0x36bb33
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x30(%r14)
testl %eax, %eax
je 0x20312b
leaq 0x4b(%rip), %rax        # 0x203174
jmp 0x203135
pushq $-0x1
popq %rbp
leaq -0xc67(%rip), %rax      # 0x2024ce
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmlrole.c
// Function: notation3
static int PTRCALL
notation3(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;
  }
  return common(state, tok);
}

// Assembly:
cmpl $0xf, %esi
je 0x203162
cmpl $0x1b, %esi
jne 0x203166
leaq -0x789(%rip), %rax      # 0x2029cb
movq %rax, (%rdi)
movl $0x11, 0xc(%rdi)
pushq $0x13
jmp 0x203172
pushq $0x11
jmp 0x203172
leaq -0xc9f(%rip), %rax      # 0x2024ce
movq %rax, (%rdi)
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2031ce
cmpl $0x11, %esi
je 0x2031c0
cmpl $0x1b, %esi
jne 0x2031d2
leaq -0x7e7(%rip), %rax      # 0x2029cb
movq %rax, (%rdi)
movl $0x11, 0xc(%rdi)
pushq $0x13
jmp 0x2031de
leaq -0xc54(%rip), %rax      # 0x202573
movq %rax, (%rdi)
pushq $0x14
jmp 0x2031de
pushq $0x11
jmp 0x2031de
leaq -0xd0b(%rip), %rax      # 0x2024ce
movq %rax, (%rdi)
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2032b8
cmpl $0x7f, %edi
ja 0x203232
movb %dil, (%rsi)
pushq $0x1
jmp 0x20327e
cmpl $0x7ff, %edi            # imm = 0x7FF
ja 0x203253
movl %edi, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x1(%rsi)
pushq $0x2
jmp 0x20327e
cmpl $0xffff, %edi           # imm = 0xFFFF
ja 0x203280
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)
pushq $0x3
popq %rax
retq
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
ja 0x2032b8
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)
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2032fa
cmpl $0xffff, %edi           # imm = 0xFFFF
ja 0x2032ce
movw %di, (%rsi)
pushq $0x1
popq %rax
retq
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
ja 0x2032fa
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)
pushq $0x2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rax
leal -0xd8(%rcx), %edx
cmpl $0x8, %edx
jae 0x2035c6
retq
cmpl $0xff, %ecx
je 0x2035e8
testl %ecx, %ecx
jne 0x2035f5
movslq %edi, %rcx
leaq 0x231434(%rip), %rdx    # 0x434a10
cmpb $0x0, 0x88(%rcx,%rdx)
jne 0x2035f5
jmp 0x2035c5
movl %edi, %ecx
andl $-0x2, %ecx
cmpl $0xfffe, %ecx           # imm = 0xFFFE
je 0x2035c5
movl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x3e0(%rdi), %rbp
movq (%r12), %rsi
cmpq %r15, %rsi
je 0x20377a
movzbl (%rsi), %ecx
movsbl (%rbp,%rcx,4), %eax
testl %eax, %eax
je 0x203711
movslq %eax, %rdx
movq %rbx, %rdi
subq (%r14), %rdi
cmpq %rdx, %rdi
jl 0x20377a
leaq 0x1(,%rcx,4), %rcx
addq %rbp, %rcx
incq %rsi
jmp 0x203755
movq 0x1d8(%r13), %rdi
callq *0x1d0(%r13)
movl %eax, %edi
leaq 0x4(%rsp), %rsi
callq 0x20321c
movl %eax, %ecx
movq %rbx, %rdx
subq (%r14), %rdx
cmpq %rcx, %rdx
jl 0x20377a
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 0x20375d
jmp 0x2036da
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%r12), %rsi
cmpq %r15, %rsi
je 0x2037fe
cmpq %rbx, (%r14)
je 0x2037fe
movzbl (%rsi), %eax
movzwl 0x1e0(%r13,%rax,2), %eax
testw %ax, %ax
je 0x2037c5
incq %rsi
jmp 0x2037eb
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)
jmp 0x2037a1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20386f
cmpl $-0x1, %eax
je 0x203865
movb %al, 0x85(%r14)
leaq 0x89(%rip), %rax        # 0x2038c6
movq %rax, (%r14)
leaq 0x8f(%rip), %rax        # 0x2038d6
movq %rax, 0x8(%r14)
leaq 0x95(%rip), %rax        # 0x2038e7
movq %rax, 0x60(%r14)
movq %rbx, 0x88(%r14)
movq %r14, (%rbx)
pushq $0x1
popq %rax
jmp 0x203867
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: getEncodingIndex
static int FASTCALL
getEncodingIndex(const char *name)
{
  static const char * const encodingNames[] = {
    KW_ISO_8859_1,
    KW_US_ASCII,
    KW_UTF_8,
    KW_UTF_16,
    KW_UTF_16BE,
    KW_UTF_16LE,
  };
  int i;
  if (name == NULL)
    return NO_ENC;
  for (i = 0; i < (int)(sizeof(encodingNames)/sizeof(encodingNames[0])); i++)
    if (streqci(name, encodingNames[i]))
      return i;
  return UNKNOWN_ENC;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2038b2
movq %rdi, %r14
leaq 0x16a2a1(%rip), %r12    # 0x36db28
xorl %r15d, %r15d
pushq $-0x1
popq %rbx
movq %r12, %r13
cmpq $0x6, %r15
je 0x2038ba
movslq (%r13), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x20c263
testl %eax, %eax
jne 0x2038b7
incq %r15
addq $0x4, %r13
jmp 0x203890
pushq $0x6
popq %rbx
jmp 0x2038ba
movl %r15d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rdx, %rsi
je 0x205215
movabsq $0x2, %r8
movabsq $0x1, %r9
leaq 0x166f21(%rip), %r10    # 0x36c0e4
movabsq $0x3, %r11
movabsq $0x4, %rbx
movq %rsi, %rax
cmpq %rdx, %rax
je 0x205259
movzbl (%rax), %r14d
movzbl 0x88(%rdi,%r14), %r14d
addl $-0x2, %r14d
cmpl $0x13, %r14d
ja 0x20520d
movslq (%r10,%r14,4), %r15
addq %r10, %r15
movq %r8, %r14
jmpq *%r15
movq %r11, %r14
jmp 0x205210
movq %rbx, %r14
jmp 0x205210
movq %r9, %r14
addq %r14, %rax
jmp 0x2051da
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
jmp 0x205261
cmpq %rsi, %rax
jne 0x205259
incq %rsi
movq %rsi, (%rcx)
jmp 0x205287
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x205261
cmpq %rsi, %rax
jne 0x205259
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x20615a
cmpq %rsi, %rax
jne 0x205259
incq %rsi
movq %rsi, (%rcx)
movl $0x27, %eax
jmp 0x205261
cmpq %rsi, %rax
je 0x205267
movq %rax, (%rcx)
movl $0x6, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1(%rsi), %rax
cmpq %rdx, %rax
je 0x20528e
movzbl 0x1(%rsi), %edx
addq $0x2, %rsi
cmpb $0xa, 0x88(%rdi,%rdx)
cmoveq %rsi, %rax
movq %rax, (%rcx)
movl $0x7, %eax
jmp 0x205261
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x205261
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
cmpq %rdx, %rsi
je 0x2052fd
pushq $0x2
popq %r8
pushq $0x1
popq %r9
leaq 0x166e86(%rip), %r10    # 0x36c134
pushq $0x3
popq %r11
pushq $0x4
popq %rbx
movq %rsi, %rax
cmpq %rdx, %rax
je 0x20534e
movzbl (%rax), %r14d
movzbl 0x88(%rdi,%r14), %r14d
leal -0x3(%r14), %r15d
cmpl $0x7, %r15d
ja 0x2052ef
movslq (%r10,%r15,4), %r15
addq %r10, %r15
movq %r8, %r14
jmpq *%r15
movq %r11, %r14
jmp 0x2052f8
movq %rbx, %r14
jmp 0x2052f8
cmpl $0x1e, %r14d
je 0x205349
movq %r9, %r14
addq %r14, %rax
jmp 0x2052b8
pushq $-0x4
jmp 0x205353
cmpq %rsi, %rax
jne 0x20534e
leaq 0x1(%rsi), %rax
cmpq %rdx, %rax
je 0x20536e
movzbl 0x1(%rsi), %edx
addq $0x2, %rsi
cmpb $0xa, 0x88(%rdi,%rdx)
cmoveq %rsi, %rax
movq %rax, (%rcx)
jmp 0x205333
cmpq %rsi, %rax
jne 0x20534e
incq %rsi
movq %rsi, (%rcx)
pushq $0x7
jmp 0x205353
cmpq %rsi, %rax
jne 0x20534e
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x20615a
cmpq %rsi, %rax
je 0x20535a
movq %rax, (%rcx)
pushq $0x6
popq %rax
popq %rbx
popq %r14
popq %r15
retq
incq %rsi
callq 0x205dfd
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x16, %ecx
cmovnel %ecx, %eax
jmp 0x205354
pushq $-0x3
jmp 0x205353
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movb (%rcx), %dil
testb %dil, %dil
je 0x20542c
cmpq %rdx, %rsi
je 0x205434
cmpb %dil, (%rsi)
jne 0x205434
incq %rsi
incq %rcx
jmp 0x205412
xorl %eax, %eax
cmpq %rdx, %rsi
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $0x2
popq %rcx
pushq $0x4
popq %rdx
movl $0x2f400020, %r8d       # imm = 0x2F400020
pushq $0x3
popq %r9
movq %rsi, %rax
movzbl 0x1(%rax), %r10d
leal -0xd8(%r10), %r11d
cmpl $0x4, %r11d
jae 0x20818b
movq %rdx, %r11
addq %r11, %rax
jmp 0x208171
testl %r10d, %r10d
je 0x2081b5
cmpl $0xff, %r10d
je 0x2081ab
addl $0xffffff24, %r10d      # imm = 0xFFFFFF24
movq %rcx, %r11
cmpl $0x4, %r10d
jae 0x208186
jmp 0x2081e4
cmpb $-0x3, (%rax)
movq %rcx, %r11
jbe 0x208186
jmp 0x2081e4
movzbl (%rax), %r10d
movzbl 0x88(%rdi,%r10), %r10d
cmpl $0x1d, %r10d
ja 0x2081e4
btl %r10d, %r8d
movq %rcx, %r11
jb 0x208186
cmpl $0x6, %r10d
je 0x2081df
cmpl $0x7, %r10d
je 0x208183
jmp 0x2081e4
movq %r9, %r11
jmp 0x208186
subl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb 0x2(%rsi), %al
addq $0x3, %rsi
xorl %edi, %edi
cmpb $0x78, %al
jne 0x20578e
leaq 0x166a72(%rip), %rax    # 0x36c1c0
movzbl (%rsi), %ecx
leal -0x30(%rcx), %edx
cmpl $0x36, %edx
ja 0x205789
movsbl %cl, %ecx
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
shll $0x4, %edi
addl $-0x30, %ecx
orl %ecx, %edi
jmp 0x205781
shll $0x4, %edi
addl %ecx, %edi
addl $-0x57, %edi
jmp 0x205781
shll $0x4, %edi
addl %ecx, %edi
addl $-0x37, %edi
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
jg 0x2057ad
incq %rsi
jmp 0x20574e
cmpb $0x3b, %al
je 0x2057b1
movsbl %al, %eax
imull $0xa, %edi, %ecx
leal (%rax,%rcx), %edi
addl $-0x30, %edi
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
jg 0x2057ad
movb (%rsi), %al
incq %rsi
jmp 0x20578e
pushq $-0x1
popq %rax
retq
jmp 0x2035b2
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdx, %rax
subq %rsi, %rax
pushq $0x2
popq %rcx
cqto
idivq %rcx
cmpq $0x4, %rax
je 0x208681
cmpq $0x3, %rax
je 0x20865a
cmpq $0x2, %rax
jne 0x208687
cmpb $0x0, 0x3(%rsi)
jne 0x208687
cmpb $0x74, 0x2(%rsi)
jne 0x208687
xorl %eax, %eax
cmpb $0x0, 0x1(%rsi)
jne 0x208689
movb (%rsi), %al
xorl %ecx, %ecx
cmpb $0x67, %al
pushq $0x3e
popq %rdx
cmovnel %ecx, %edx
cmpb $0x6c, %al
pushq $0x3c
popq %rax
cmovnel %edx, %eax
retq
cmpb $0x0, 0x1(%rsi)
jne 0x208687
cmpb $0x61, (%rsi)
jne 0x208687
cmpb $0x0, 0x3(%rsi)
jne 0x208687
cmpb $0x6d, 0x2(%rsi)
jne 0x208687
cmpb $0x0, 0x5(%rsi)
jne 0x208687
cmpb $0x70, 0x4(%rsi)
jne 0x208687
pushq $0x26
popq %rax
retq
cmpb $0x0, 0x1(%rsi)
je 0x20868a
xorl %eax, %eax
retq
movzbl (%rsi), %eax
cmpl $0x61, %eax
je 0x2086bf
cmpl $0x71, %eax
jne 0x208687
cmpb $0x0, 0x3(%rsi)
jne 0x208687
cmpb $0x75, 0x2(%rsi)
jne 0x208687
cmpb $0x0, 0x5(%rsi)
jne 0x208687
cmpb $0x6f, 0x4(%rsi)
jne 0x208687
cmpb $0x0, 0x7(%rsi)
jne 0x208687
cmpb $0x74, 0x6(%rsi)
jne 0x208687
pushq $0x22
jmp 0x20867f
cmpb $0x0, 0x3(%rsi)
jne 0x208687
cmpb $0x70, 0x2(%rsi)
jne 0x208687
cmpb $0x0, 0x5(%rsi)
jne 0x208687
cmpb $0x6f, 0x4(%rsi)
jne 0x208687
cmpb $0x0, 0x7(%rsi)
jne 0x208687
cmpb $0x73, 0x6(%rsi)
jne 0x208687
pushq $0x27
jmp 0x20867f
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x1642ee(%rip), %rax    # 0x36c9dc
cmpq %rdx, %rsi
je 0x208783
movzbl 0x1(%rsi), %r8d
leal -0xd8(%r8), %r9d
cmpl $0x4, %r9d
jae 0x20870f
addq $0x4, %rsi
jmp 0x20877a
testl %r8d, %r8d
jne 0x208776
movzbl (%rsi), %r8d
movzbl 0x88(%rdi,%r8), %r8d
addl $-0x5, %r8d
cmpl $0x5, %r8d
ja 0x208776
movslq (%rax,%r8,4), %r8
addq %rax, %r8
jmpq *%r8
addq $0x3, %rsi
jmp 0x20877a
incq (%rcx)
leaq 0x2(%rsi), %r8
cmpq %rdx, %r8
je 0x208764
cmpb $0x0, 0x3(%rsi)
jne 0x208764
movzbl 0x2(%rsi), %r9d
cmpb $0xa, 0x88(%rdi,%r9)
jne 0x208764
addq $0x4, %rsi
movq %rsi, %r8
orq $-0x1, 0x8(%rcx)
movq %r8, %rsi
jmp 0x20877a
orq $-0x1, 0x8(%rcx)
incq (%rcx)
addq $0x2, %rsi
incq 0x8(%rcx)
jmp 0x2086ee
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r9
cmpq %rdx, %r9
je 0x205981
movb (%r9), %al
movq (%rcx), %rdi
testb %al, %al
js 0x20594d
cmpq %r8, %rdi
je 0x205981
leaq 0x1(%r9), %rax
movq %rax, (%rsi)
movb (%r9), %al
movq (%rcx), %rdi
leaq 0x1(%rdi), %r9
movq %r9, (%rcx)
movb %al, (%rdi)
jmp 0x20591e
movq %r8, %r9
subq %rdi, %r9
cmpq $0x2, %r9
jl 0x205981
movl %eax, %r9d
shrb $0x6, %r9b
orb $-0x40, %r9b
leaq 0x1(%rdi), %r10
movq %r10, (%rcx)
movb %r9b, (%rdi)
andb $-0x41, %al
movq (%rcx), %rdi
leaq 0x1(%rdi), %r9
movq %r9, (%rcx)
movb %al, (%rdi)
incq (%rsi)
jmp 0x20591e
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xfffffffe, %r9d       # imm = 0xFFFFFFFE
leaq 0x163ff6(%rip), %r10    # 0x36c9f4
cmpq %rcx, %rdx
je 0x208aa9
movq %rdx, %r11
movzbl 0x1(%rdx), %edx
leal -0xd8(%rdx), %ebx
cmpl $0x4, %ebx
jae 0x208a2e
movq %rcx, %rdx
subq %r11, %rdx
cmpq $0x4, %rdx
jl 0x208a9f
addq $0x4, %r11
movq %r11, %rdx
jmp 0x2089fe
testl %edx, %edx
je 0x208a56
cmpl $0xff, %edx
je 0x208a47
addl $0xffffff24, %edx       # imm = 0xFFFFFF24
cmpl $0x4, %edx
jae 0x208a4d
jmp 0x208aa4
cmpb $-0x3, (%r11)
ja 0x208aa4
addq $0x2, %r11
movq %r11, %rdx
jmp 0x2089fe
movzbl (%r11), %edx
movzbl 0x88(%rsi,%rdx), %ebx
cmpq $0xd, %rbx
ja 0x208a4d
movslq (%r10,%rbx,4), %rdx
addq %r10, %rdx
jmpq *%rdx
leaq 0x2(%r11), %rdx
cmpl %edi, %ebx
jne 0x2089fe
jmp 0x208aab
movq %rcx, %rdx
subq %r11, %rdx
cmpq $0x3, %rdx
jl 0x208a9f
addq $0x3, %r11
movq %r11, %rdx
jmp 0x2089fe
movq %rcx, %rdx
subq %r11, %rdx
cmpq $0x2, %rdx
jge 0x208a4d
movl %r9d, %eax
jmp 0x208aa9
movq %r11, (%r8)
xorl %eax, %eax
popq %rbx
retq
cmpq %rcx, %rdx
je 0x208adb
movq %rdx, (%r8)
cmpb $0x0, 0x3(%r11)
jne 0x208aa7
movzbl (%rdx), %eax
movzbl 0x88(%rsi,%rax), %eax
cmpl $0x1e, %eax
ja 0x208aa7
movl $0x40300e00, %ecx       # imm = 0x40300E00
btl %eax, %ecx
jae 0x208aa7
movl $0x1b, %eax
jmp 0x208aa9
movl $0xffffffe5, %eax       # imm = 0xFFFFFFE5
jmp 0x208aa9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_scanPercent
static int PTRCALL
PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
                    const char **nextTokPtr)
{
  if (ptr == end)
    return -XML_TOK_PERCENT;
  switch (BYTE_TYPE(enc, ptr)) {
  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
  case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
    *nextTokPtr = ptr;
    return XML_TOK_PERCENT;
  default:
    *nextTokPtr = ptr;
    return XML_TOK_INVALID;
  }
  while (ptr != end) {
    switch (BYTE_TYPE(enc, ptr)) {
    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    case BT_SEMI:
      *nextTokPtr = ptr + MINBPC(enc);
      return XML_TOK_PARAM_ENTITY_REF;
    default:
      *nextTokPtr = ptr;
      return XML_TOK_INVALID;
    }
  }
  return XML_TOK_PARTIAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
cmpq %rdx, %rsi
je 0x208f6a
movzbl 0x1(%rsi), %eax
leal -0xd8(%rax), %r8d
cmpl $0x4, %r8d
jb 0x208faa
leal -0xdc(%rax), %r8d
cmpl $0x4, %r8d
jb 0x208fdd
testl %eax, %eax
je 0x208f71
cmpl $0xff, %eax
jne 0x208e68
cmpb $-0x3, (%rsi)
ja 0x208fdd
leaq 0x164ab1(%rip), %r8     # 0x36d920
movzbl (%rax,%r8), %eax
movzbl (%rsi), %r8d
shll $0x5, %eax
movl %r8d, %r9d
shrl $0x3, %r9d
andl $0x1c, %r9d
orl %eax, %r9d
leaq 0x164590(%rip), %rax    # 0x36d420
movl (%r9,%rax), %eax
btl %r8d, %eax
jae 0x208fdd
movq %rdx, %r9
subq %rsi, %r9
addq $0x2, %rsi
addq $-0x2, %r9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq 0x163c68(%rip), %r10    # 0x36cb20
leaq 0x164b61(%rip), %r11    # 0x36da20
leaq 0x16455a(%rip), %rbx    # 0x36d420
xorl %r8d, %r8d
cmpq %rdx, %rsi
je 0x208fe6
movzbl 0x1(%rsi), %r14d
testl %r14d, %r14d
je 0x208f38
cmpl $0xff, %r14d
je 0x208f06
leal -0xd8(%r14), %ebp
cmpl $0x4, %ebp
jb 0x208fba
leal -0xdc(%r14), %ebp
cmpl $0x4, %ebp
jae 0x208f0f
jmp 0x208fe0
cmpb $-0x3, (%rsi)
ja 0x208fe0
movzbl (%r14,%r11), %ebp
movzbl (%rsi), %r14d
shll $0x5, %ebp
movl %r14d, %r15d
shrl $0x3, %r15d
andl $0x1c, %r15d
orl %ebp, %r15d
movl (%r15,%rbx), %ebp
btl %r14d, %ebp
jb 0x208f5d
jmp 0x208fe0
movzbl (%rsi), %r15d
movzbl 0x88(%rdi,%r15), %r15d
addl $-0x5, %r15d
cmpl $0x18, %r15d
ja 0x208fe0
movslq (%r10,%r15,4), %r15
addq %r10, %r15
jmpq *%r15
addq $0x2, %rsi
addq $-0x2, %r9
jmp 0x208ec9
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
jmp 0x208fe6
movzbl (%rsi), %r8d
movzbl 0x88(%rdi,%r8), %r9d
movl $0x16, %r8d
leal -0x5(%r9), %r10d
cmpl $0x13, %r10d
ja 0x208fc2
leaq 0x163b3b(%rip), %rax    # 0x36cad0
movslq (%rax,%r10,4), %r9
addq %rax, %r9
jmpq *%r9
subq %rsi, %rdx
cmpq $0x2, %rdx
jl 0x208fb3
jmp 0x208fdd
subq %rsi, %rdx
cmpq $0x4, %rdx
jge 0x208fdd
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x208fe6
cmpq $0x4, %r9
jl 0x208fb3
jmp 0x208fe0
cmpl $0x1e, %r9d
je 0x208fe0
cmpl $0x1d, %r9d
je 0x208e68
jmp 0x208fdd
subq %rsi, %rdx
cmpq $0x3, %rdx
jl 0x208fb3
xorl %r8d, %r8d
movq %rsi, (%rcx)
movl %r8d, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x3, %r9
jl 0x208fb3
jmp 0x208fe0
addq $0x2, %rsi
movl $0x1c, %r8d
jmp 0x208fe0
cmpq $0x2, %r9
jl 0x208fb3
jmp 0x208fe0