LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_tag_name_state
static StateResult handle_tag_name_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      finish_tag_name(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
      return NEXT_CHAR;
    case '/':
      finish_tag_name(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SELF_CLOSING_START_TAG);
      return NEXT_CHAR;
    case '>':
      finish_tag_name(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return emit_current_tag(parser, output);
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_tag_buffer(parser, UNICODE_REPLACEMENT_CHAR, true);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_TAG_EOF);
      abandon_current_tag(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x3e, %edx
ja 0xd03f
movq %rcx, %r14
movl %edx, %eax
movabsq $0x100001600, %rcx      # imm = 0x100001600
btq %rax, %rcx
jae 0xd008
movq %rbx, %rdi
callq 0x10cdb
movq 0x10(%rbx), %rax
movl $0x21, (%rax)
jmp 0xd129
cmpq $0x2f, %rax
je 0xd117
cmpq $0x3e, %rax
jne 0xd03f
movq %rbx, %rdi
callq 0x10cdb
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10d4a
movl $0x1, %ebp
jmp 0xd12e
cmpl $-0x1, %edx
je 0xd0a2
testl %edx, %edx
jne 0xd0c4
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%rbx), %rsi
cmpq $0x0, 0x70(%rsi)
jne 0xd08f
movq 0x120(%rsi), %rax
movq %rax, 0xa0(%rsi)
movups 0x110(%rsi), %xmm0
movups %xmm0, 0x90(%rsi)
movq 0xe8(%rsi), %rax
movq %rax, 0x80(%rsi)
addq $0x68, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
jmp 0xd12e
movq %rbx, %rdi
movl $0x9, %esi
callq 0x10a60
movq 0x10(%rbx), %rdi
callq 0x10eb9
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
jmp 0xd129
movzbl %dl, %eax
leaq 0xb082(%rip), %rcx      # 0x18150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
movq 0x10(%rbx), %rsi
cmpq $0x0, 0x70(%rsi)
jne 0xd10c
movq 0x120(%rsi), %rax
movq %rax, 0xa0(%rsi)
movups 0x110(%rsi), %xmm0
movups %xmm0, 0x90(%rsi)
movq 0xe8(%rsi), %rax
movq %rax, 0x80(%rsi)
addq $0x68, %rsi
callq 0x4322
jmp 0xd129
movq %rbx, %rdi
callq 0x10cdb
movq 0x10(%rbx), %rax
movl $0x2a, (%rax)
movl $0x2, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rcdata_lt_state
static StateResult handle_rcdata_lt_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "<"));
  if (c == '/') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA_END_TAG_OPEN);
    append_char_to_temporary_buffer(parser, '/');
    return NEXT_CHAR;
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA);
    tokenizer->_reconsume_current_input = true;
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %rax
movq %rsi, %rax
movq 0x10(%rdi), %rsi
cmpq $0x1, 0x18(%rsi)
jne 0xd185
movq 0x10(%rsi), %r8
cmpb $0x3c, (%r8)
jne 0xd185
cmpl $0x2f, %edx
jne 0xd16e
movl $0xb, (%rsi)
addq $0x10, %rsi
movl $0x2f, %edi
callq 0x4322
movl $0x2, %eax
jmp 0xd183
movl $0x2, (%rsi)
movb $0x1, 0x4(%rax)
movq %rcx, %rsi
callq 0x10c82
movzbl %al, %eax
popq %rcx
retq
leaq 0x108a1(%rip), %rdi     # 0x1da2d
leaq 0x106d1(%rip), %rsi     # 0x1d864
leaq 0x10b14(%rip), %rcx     # 0x1dcae
movl $0x4ae, %edx            # imm = 0x4AE
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rcdata_end_tag_open_state
static StateResult handle_rcdata_end_tag_open_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "</"));
  if (is_alpha(c)) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA_END_TAG_NAME);
    start_new_tag(parser, false);
    append_char_to_temporary_buffer(parser, c);
    return NEXT_CHAR;
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA);
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
cmpq $0x2, 0x18(%rax)
jne 0xd212
movl %edx, %ebx
movq 0x10(%rax), %rdx
cmpw $0x2f3c, (%rdx)         # imm = 0x2F3C
jne 0xd212
movq %rdi, %r14
movl %ebx, %edx
orl $0x20, %edx
addl $-0x61, %edx
cmpl $0x19, %edx
ja 0xd1f6
movl $0xc, (%rax)
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b4f
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movl %ebx, %edi
callq 0x4322
movl $0x2, %eax
jmp 0xd20a
movl $0x2, (%rax)
movq %r14, %rdi
movq %rcx, %rsi
callq 0x10c82
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1094b(%rip), %rdi     # 0x1db64
leaq 0x10644(%rip), %rsi     # 0x1d864
leaq 0x10ae3(%rip), %rcx     # 0x1dd0a
movl $0x4c1, %edx            # imm = 0x4C1
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rcdata_end_tag_name_state
static StateResult handle_rcdata_end_tag_name_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  UNUSED_IF_NDEBUG(tokenizer);
  assert(tokenizer->_temporary_buffer.length >= 2);
  if (is_alpha(c)) {
    append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
    append_char_to_temporary_buffer(parser, c);
    return NEXT_CHAR;
  } else if (is_appropriate_end_tag(parser)) {
    switch (c) {
      case '\t':
      case '\n':
      case '\f':
      case ' ':
        finish_tag_name(parser);
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
        return NEXT_CHAR;
      case '/':
        finish_tag_name(parser);
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_SELF_CLOSING_START_TAG);
        return NEXT_CHAR;
      case '>':
        finish_tag_name(parser);
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
        return emit_current_tag(parser, output);
    }
  }
  gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA);
  abandon_current_tag(parser);
  return emit_temporary_buffer(parser, output);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpq $0x1, 0x18(%rsi)
jbe 0xd35b
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, %eax
orl $0x20, %eax
addl $-0x61, %eax
cmpl $0x19, %eax
ja 0xd2b5
movzbl %bpl, %eax
leaq 0xaef3(%rip), %rcx      # 0x18150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
movq 0x10(%rbx), %rsi
cmpq $0x0, 0x70(%rsi)
jne 0xd29b
movq 0x120(%rsi), %rax
movq %rax, 0xa0(%rsi)
movups 0x110(%rsi), %xmm0
movups %xmm0, 0x90(%rsi)
movq 0xe8(%rsi), %rax
movq %rax, 0x80(%rsi)
addq $0x68, %rsi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl %ebp, %edi
callq 0x4322
jmp 0xd2ee
movq %rcx, %r14
movq 0x10(%rbx), %rdi
callq 0x10f16
testb %al, %al
je 0xd325
cmpl $0x3e, %ebp
ja 0xd325
movl %ebp, %eax
movabsq $0x100001600, %rcx      # imm = 0x100001600
btq %rax, %rcx
jae 0xd2f5
movq %rbx, %rdi
callq 0x10cdb
movq 0x10(%rbx), %rax
movl $0x21, (%rax)
movl $0x2, %eax
jmp 0xd342
cmpq $0x2f, %rax
je 0xd347
cmpq $0x3e, %rax
jne 0xd325
movq %rbx, %rdi
callq 0x10cdb
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10d4a
movl $0x1, %eax
jmp 0xd342
movq 0x10(%rbx), %rdi
movl $0x2, (%rdi)
callq 0x10eb9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10c82
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x10cdb
movq 0x10(%rbx), %rax
movl $0x2a, (%rax)
jmp 0xd2ee
leaq 0x10a0e(%rip), %rdi     # 0x1dd70
leaq 0x104fb(%rip), %rsi     # 0x1d864
leaq 0x10a29(%rip), %rcx     # 0x1dd99
movl $0x4d5, %edx            # imm = 0x4D5
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rawtext_lt_state
static StateResult handle_rawtext_lt_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "<"));
  if (c == '/') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RAWTEXT_END_TAG_OPEN);
    append_char_to_temporary_buffer(parser, '/');
    return NEXT_CHAR;
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RAWTEXT);
    tokenizer->_reconsume_current_input = true;
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %rax
movq %rsi, %rax
movq 0x10(%rdi), %rsi
cmpq $0x1, 0x18(%rsi)
jne 0xd3ca
movq 0x10(%rsi), %r8
cmpb $0x3c, (%r8)
jne 0xd3ca
cmpl $0x2f, %edx
jne 0xd3b3
movl $0xe, (%rsi)
addq $0x10, %rsi
movl $0x2f, %edi
callq 0x4322
movl $0x2, %eax
jmp 0xd3c8
movl $0x4, (%rsi)
movb $0x1, 0x4(%rax)
movq %rcx, %rsi
callq 0x10c82
movzbl %al, %eax
popq %rcx
retq
leaq 0x1065c(%rip), %rdi     # 0x1da2d
leaq 0x1048c(%rip), %rsi     # 0x1d864
leaq 0x10a66(%rip), %rcx     # 0x1de45
movl $0x4f9, %edx            # imm = 0x4F9
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rawtext_end_tag_open_state
static StateResult handle_rawtext_end_tag_open_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "</"));
  if (is_alpha(c)) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RAWTEXT_END_TAG_NAME);
    start_new_tag(parser, false);
    append_char_to_temporary_buffer(parser, c);
    return NEXT_CHAR;
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RAWTEXT);
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
cmpq $0x2, 0x18(%rax)
jne 0xd457
movl %edx, %ebx
movq 0x10(%rax), %rdx
cmpw $0x2f3c, (%rdx)         # imm = 0x2F3C
jne 0xd457
movq %rdi, %r14
movl %ebx, %edx
orl $0x20, %edx
addl $-0x61, %edx
cmpl $0x19, %edx
ja 0xd43b
movl $0xf, (%rax)
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b4f
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movl %ebx, %edi
callq 0x4322
movl $0x2, %eax
jmp 0xd44f
movl $0x4, (%rax)
movq %r14, %rdi
movq %rcx, %rsi
callq 0x10c82
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10706(%rip), %rdi     # 0x1db64
leaq 0x103ff(%rip), %rsi     # 0x1d864
leaq 0x10a36(%rip), %rcx     # 0x1dea2
movl $0x50c, %edx            # imm = 0x50C
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rawtext_end_tag_name_state
static StateResult handle_rawtext_end_tag_name_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  assert(tokenizer->_temporary_buffer.length >= 2);
  gumbo_debug("Last end tag: %.*s\n", (int) tokenizer->_tag_state._buffer.length,
      tokenizer->_tag_state._buffer.data);
  if (is_alpha(c)) {
    append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
    append_char_to_temporary_buffer(parser, c);
    return NEXT_CHAR;
  } else if (is_appropriate_end_tag(parser)) {
    gumbo_debug("Is an appropriate end tag.\n");
    switch (c) {
      case '\t':
      case '\n':
      case '\f':
      case ' ':
        finish_tag_name(parser);
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
        return NEXT_CHAR;
      case '/':
        finish_tag_name(parser);
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_SELF_CLOSING_START_TAG);
        return NEXT_CHAR;
      case '>':
        finish_tag_name(parser);
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
        return emit_current_tag(parser, output);
    }
  }
  gumbo_tokenizer_set_state(parser, GUMBO_LEX_RAWTEXT);
  abandon_current_tag(parser);
  return emit_temporary_buffer(parser, output);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpq $0x1, 0x18(%rsi)
jbe 0xd5a0
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, %eax
orl $0x20, %eax
addl $-0x61, %eax
cmpl $0x19, %eax
ja 0xd4fa
movzbl %bpl, %eax
leaq 0xacae(%rip), %rcx      # 0x18150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
movq 0x10(%rbx), %rsi
cmpq $0x0, 0x70(%rsi)
jne 0xd4e0
movq 0x120(%rsi), %rax
movq %rax, 0xa0(%rsi)
movups 0x110(%rsi), %xmm0
movups %xmm0, 0x90(%rsi)
movq 0xe8(%rsi), %rax
movq %rax, 0x80(%rsi)
addq $0x68, %rsi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl %ebp, %edi
callq 0x4322
jmp 0xd533
movq %rcx, %r14
movq 0x10(%rbx), %rdi
callq 0x10f16
testb %al, %al
je 0xd56a
cmpl $0x3e, %ebp
ja 0xd56a
movl %ebp, %eax
movabsq $0x100001600, %rcx      # imm = 0x100001600
btq %rax, %rcx
jae 0xd53a
movq %rbx, %rdi
callq 0x10cdb
movq 0x10(%rbx), %rax
movl $0x21, (%rax)
movl $0x2, %eax
jmp 0xd587
cmpq $0x2f, %rax
je 0xd58c
cmpq $0x3e, %rax
jne 0xd56a
movq %rbx, %rdi
callq 0x10cdb
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10d4a
movl $0x1, %eax
jmp 0xd587
movq 0x10(%rbx), %rdi
movl $0x4, (%rdi)
callq 0x10eb9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10c82
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x10cdb
movq 0x10(%rbx), %rax
movl $0x2a, (%rax)
jmp 0xd533
leaq 0x107c9(%rip), %rdi     # 0x1dd70
leaq 0x102b6(%rip), %rsi     # 0x1d864
leaq 0x10954(%rip), %rcx     # 0x1df09
movl $0x51f, %edx            # imm = 0x51F
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_lt_state
static StateResult handle_script_lt_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "<"));
  if (c == '/') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_END_TAG_OPEN);
    append_char_to_temporary_buffer(parser, '/');
    return NEXT_CHAR;
  } else if (c == '!') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_START);
    append_char_to_temporary_buffer(parser, '!');
    return emit_temporary_buffer(parser, output);
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
    tokenizer->_reconsume_current_input = true;
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0x10(%rdi), %rcx
cmpq $0x1, 0x18(%rcx)
jne 0xd63a
movq 0x10(%rcx), %rax
cmpb $0x3c, (%rax)
jne 0xd63a
movq %rdi, %r14
leaq 0x10(%rcx), %rax
cmpl $0x21, %edx
je 0xd605
cmpl $0x2f, %edx
jne 0xd61a
movl $0x11, (%rcx)
movl $0x2f, %edi
movq %rax, %rsi
callq 0x4322
movl $0x2, %eax
jmp 0xd632
movl $0x13, (%rcx)
movl $0x21, %edi
movq %rax, %rsi
callq 0x4322
jmp 0xd624
movl $0x5, (%rcx)
movb $0x1, 0x4(%rsi)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10c82
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x103ec(%rip), %rdi     # 0x1da2d
leaq 0x1021c(%rip), %rsi     # 0x1d864
leaq 0x10921(%rip), %rcx     # 0x1df70
movl $0x546, %edx            # imm = 0x546
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_end_tag_open_state
static StateResult handle_script_end_tag_open_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "</"));
  if (is_alpha(c)) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_END_TAG_NAME);
    start_new_tag(parser, false);
    append_char_to_temporary_buffer(parser, c);
    return NEXT_CHAR;
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
cmpq $0x2, 0x18(%rax)
jne 0xd6c7
movl %edx, %ebx
movq 0x10(%rax), %rdx
cmpw $0x2f3c, (%rdx)         # imm = 0x2F3C
jne 0xd6c7
movq %rdi, %r14
movl %ebx, %edx
orl $0x20, %edx
addl $-0x61, %edx
cmpl $0x19, %edx
ja 0xd6ab
movl $0x12, (%rax)
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b4f
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movl %ebx, %edi
callq 0x4322
movl $0x2, %eax
jmp 0xd6bf
movl $0x5, (%rax)
movq %r14, %rdi
movq %rcx, %rsi
callq 0x10c82
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10496(%rip), %rdi     # 0x1db64
leaq 0x1018f(%rip), %rsi     # 0x1d864
leaq 0x108f0(%rip), %rcx     # 0x1dfcc
movl $0x55d, %edx            # imm = 0x55D
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_start_state
static StateResult handle_script_escaped_start_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  if (c == '-') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_START_DASH);
    return emit_current_char(parser, output);
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
    tokenizer->_reconsume_current_input = true;
    return NEXT_CHAR;
  }
}

// Assembly:
movq 0x10(%rdi), %rax
cmpl $0x2d, %edx
jne 0xd857
pushq %rax
movl $0x14, (%rax)
movl 0x100(%rax), %esi
movq %rcx, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
retq
movl $0x5, (%rax)
movb $0x1, 0x4(%rsi)
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_start_dash_state
static StateResult handle_script_escaped_start_dash_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  if (c == '-') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_DASH_DASH);
    return emit_current_char(parser, output);
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
    tokenizer->_reconsume_current_input = true;
    return NEXT_CHAR;
  }
}

// Assembly:
movq 0x10(%rdi), %rax
cmpl $0x2d, %edx
jne 0xd88f
pushq %rax
movl $0x17, (%rax)
movl 0x100(%rax), %esi
movq %rcx, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
retq
movl $0x5, (%rax)
movb $0x1, 0x4(%rsi)
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_state
static StateResult handle_script_escaped_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_DASH);
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_LT);
      clear_temporary_buffer(parser);
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
    case '\0':
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      return emit_eof(parser, output);
    default:
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x2c, %edx
jg 0xd8eb
cmpl $-0x1, %edx
je 0xd918
testl %edx, %edx
jne 0xd901
movq %r14, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%rbx)
movl $0xfffd, 0x30(%rbx)     # imm = 0xFFFD
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
xorl %eax, %eax
jmp 0xd96b
cmpl $0x3c, %edx
je 0xd945
cmpl $0x2d, %edx
jne 0xd901
movq 0x10(%r14), %rax
movl $0x16, (%rax)
jmp 0xd905
movq 0x10(%r14), %rax
movl 0x100(%rax), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
jmp 0xd93e
movq %r14, %rdi
movl $0xe, %esi
callq 0x10a60
movl $0x8, (%rbx)
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
movl $0x1, %eax
jmp 0xd96b
movq 0x10(%r14), %rdi
movl $0x18, (%rdi)
callq 0x10a14
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movl $0x3c, %edi
callq 0x4322
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_dash_state
static StateResult handle_script_escaped_dash_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_DASH_DASH);
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_LT);
      clear_temporary_buffer(parser);
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
    case '\0':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
cmpl $0x2c, %edx
jg 0xd9c8
cmpl $-0x1, %edx
je 0xda00
testl %edx, %edx
jne 0xd9de
movq 0x10(%rbx), %rax
movl $0x15, (%rax)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%r14)
movl $0xfffd, 0x30(%r14)     # imm = 0xFFFD
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xca0d
xorl %eax, %eax
jmp 0xda3f
cmpl $0x3c, %edx
je 0xda19
cmpl $0x2d, %edx
jne 0xd9de
movq 0x10(%rbx), %rax
movl $0x17, (%rax)
jmp 0xd9e8
movq 0x10(%rbx), %rax
movl $0x15, (%rax)
movl 0x100(%rax), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x62f4
movl $0x1, %eax
jmp 0xda3f
movq %rbx, %rdi
movl $0xe, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
jmp 0xda3a
movq 0x10(%rbx), %rdi
movl $0x18, (%rdi)
callq 0x10a14
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x3c, %edi
callq 0x4322
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_dash_dash_state
static StateResult handle_script_escaped_dash_dash_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_LT);
      clear_temporary_buffer(parser);
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
      return emit_current_char(parser, output);
    case '\0':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
cmpl $0x2c, %edx
jle 0xda72
cmpl $0x3e, %edx
je 0xdabc
cmpl $0x3c, %edx
je 0xdac8
cmpl $0x2d, %edx
jne 0xdb09
movq 0x10(%rbx), %rax
jmp 0xdb13
cmpl $-0x1, %edx
je 0xdaeb
testl %edx, %edx
jne 0xdb09
movq 0x10(%rbx), %rax
movl $0x15, (%rax)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%r14)
movl $0xfffd, 0x30(%r14)     # imm = 0xFFFD
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xca0d
xorl %eax, %eax
jmp 0xdb29
movq 0x10(%rbx), %rax
movl $0x5, (%rax)
jmp 0xdb13
movq 0x10(%rbx), %rdi
movl $0x18, (%rdi)
callq 0x10a14
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x3c, %edi
callq 0x4322
jmp 0xdb02
movq %rbx, %rdi
movl $0xe, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movl $0x2, %eax
jmp 0xdb29
movq 0x10(%rbx), %rax
movl $0x15, (%rax)
movl 0x100(%rax), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_lt_state
static StateResult handle_script_escaped_lt_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "<"));
  assert(!tokenizer->_script_data_buffer.length);
  if (c == '/') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_END_TAG_OPEN);
    append_char_to_temporary_buffer(parser, c);
    return NEXT_CHAR;
  } else if (is_alpha(c)) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_START);
    append_char_to_temporary_buffer(parser, c);
    gumbo_string_buffer_append_codepoint (
      ensure_lowercase(c),
      &tokenizer->_script_data_buffer
    );
    return emit_temporary_buffer(parser, output);
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
cmpq $0x1, 0x18(%rax)
jne 0xdbe5
movq %rcx, %rbx
movq 0x10(%rax), %rcx
cmpb $0x3c, (%rcx)
jne 0xdbe5
movq %rsi, %r15
cmpq $0x0, 0x38(%rsi)
jne 0xdc04
movl %edx, %ebp
leaq 0x10(%rax), %rsi
cmpl $0x2f, %edx
jne 0xdb87
movl $0x19, (%rax)
movl $0x2f, %edi
callq 0x4322
movl $0x2, %eax
jmp 0xdbda
movq %rdi, %r14
movl %ebp, %ecx
orl $0x20, %ecx
addl $-0x61, %ecx
cmpl $0x19, %ecx
ja 0xdbc6
addq $0x30, %r15
movl $0x1b, (%rax)
movl %ebp, %edi
callq 0x4322
movzbl %bpl, %eax
leaq 0xa59d(%rip), %rcx      # 0x18150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
movq %r15, %rsi
callq 0x4322
jmp 0xdbcc
movl $0x15, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10c82
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfe41(%rip), %rdi      # 0x1da2d
leaq 0xfc71(%rip), %rsi      # 0x1d864
leaq 0x1049e(%rip), %rcx     # 0x1e098
movl $0x60d, %edx            # imm = 0x60D
callq 0x4100
leaq 0x104f1(%rip), %rdi     # 0x1e0fc
leaq 0xfc52(%rip), %rsi      # 0x1d864
leaq 0x1047f(%rip), %rcx     # 0x1e098
movl $0x60e, %edx            # imm = 0x60E
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_end_tag_open_state
static StateResult handle_script_escaped_end_tag_open_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "</"));
  if (is_alpha(c)) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_END_TAG_NAME);
    start_new_tag(parser, false);
    append_char_to_temporary_buffer(parser, c);
    return NEXT_CHAR;
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
cmpq $0x2, 0x18(%rax)
jne 0xdc91
movl %edx, %ebx
movq 0x10(%rax), %rdx
cmpw $0x2f3c, (%rdx)         # imm = 0x2F3C
jne 0xdc91
movq %rdi, %r14
movl %ebx, %edx
orl $0x20, %edx
addl $-0x61, %edx
cmpl $0x19, %edx
ja 0xdc75
movl $0x1a, (%rax)
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b4f
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movl %ebx, %edi
callq 0x4322
movl $0x2, %eax
jmp 0xdc89
movl $0x15, (%rax)
movq %r14, %rdi
movq %rcx, %rsi
callq 0x10c82
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xfecc(%rip), %rdi      # 0x1db64
leaq 0xfbc5(%rip), %rsi      # 0x1d864
leaq 0x1047d(%rip), %rcx     # 0x1e123
movl $0x628, %edx            # imm = 0x628
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_start_state
static StateResult handle_script_double_escaped_start_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
    case '/':
    case '>':
      gumbo_tokenizer_set_state (
        parser,
        string_piece_equal (
          &kScriptTag,
          (GumboStringPiece*) &tokenizer->_script_data_buffer
        )
        ? GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED
        : GUMBO_LEX_SCRIPT_ESCAPED
      );
      return emit_current_char(parser, output);
    default:
      if (is_alpha(c)) {
        gumbo_string_buffer_append_codepoint (
          ensure_lowercase(c),
          &tokenizer->_script_data_buffer
        );
        return emit_current_char(parser, output);
      } else {
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
        tokenizer->_reconsume_current_input = true;
        return NEXT_CHAR;
      }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x3e, %edx
ja 0xde6d
movl %edx, %eax
movabsq $0x4000800100001600, %rcx # imm = 0x4000800100001600
btq %rax, %rcx
jae 0xde6d
movl $0x15, %eax
cmpq $0x6, 0x38(%rsi)
jne 0xde49
movq 0x30(%rsi), %rax
movl $0x69726373, %ecx       # imm = 0x69726373
xorl (%rax), %ecx
movzwl 0x4(%rax), %eax
xorl $0x7470, %eax           # imm = 0x7470
orl %ecx, %eax
movl $0x1c, %ecx
movl $0x15, %eax
cmovel %ecx, %eax
movq 0x10(%r14), %rcx
movl %eax, (%rcx)
movl 0x100(%rcx), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %edx, %eax
orl $0x20, %eax
addl $-0x61, %eax
cmpl $0x19, %eax
ja 0xdea2
movzbl %dl, %eax
leaq 0xa2cc(%rip), %rcx      # 0x18150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
addq $0x30, %rsi
callq 0x4322
movq 0x10(%r14), %rax
movl 0x100(%rax), %esi
jmp 0xde55
movq 0x10(%r14), %rax
movl $0x15, (%rax)
movb $0x1, 0x4(%rsi)
movl $0x2, %eax
jmp 0xde65
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_state
static StateResult handle_script_double_escaped_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_DASH);
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_LT);
      return emit_current_char(parser, output);
    case '\0':
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x2c, %edx
jg 0xdf00
cmpl $-0x1, %edx
je 0xdf1c
testl %edx, %edx
jne 0xdf16
movq %r14, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%rbx)
movl $0xfffd, 0x30(%rbx)     # imm = 0xFFFD
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
xorl %eax, %eax
jmp 0xdf5a
cmpl $0x3c, %edx
je 0xdf3a
cmpl $0x2d, %edx
jne 0xdf16
movq 0x10(%r14), %rax
movl $0x1d, (%rax)
jmp 0xdf44
movq 0x10(%r14), %rax
jmp 0xdf44
movq %r14, %rdi
movl $0xe, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movl $0x0, (%rax)
movl $0x2, %eax
jmp 0xdf5a
movq 0x10(%r14), %rax
movl $0x1f, (%rax)
movl 0x100(%rax), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_dash_state
static StateResult handle_script_double_escaped_dash_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_DASH_DASH);
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_LT);
      return emit_current_char(parser, output);
    case '\0':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x2c, %edx
jg 0xdfb5
cmpl $-0x1, %edx
je 0xdfd7
testl %edx, %edx
jne 0xdfcb
movq 0x10(%r14), %rax
movl $0x1c, (%rax)
movq %r14, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%rbx)
movl $0xfffd, 0x30(%rbx)     # imm = 0xFFFD
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
xorl %eax, %eax
jmp 0xe015
cmpl $0x3c, %edx
je 0xdff5
cmpl $0x2d, %edx
jne 0xdfcb
movq 0x10(%r14), %rax
movl $0x1e, (%rax)
jmp 0xdfff
movq 0x10(%r14), %rax
movl $0x1c, (%rax)
jmp 0xdfff
movq %r14, %rdi
movl $0xe, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movl $0x0, (%rax)
movl $0x2, %eax
jmp 0xe015
movq 0x10(%r14), %rax
movl $0x1f, (%rax)
movl 0x100(%rax), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_dash_dash_state
static StateResult handle_script_double_escaped_dash_dash_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_LT);
      return emit_current_char(parser, output);
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
      return emit_current_char(parser, output);
    case '\0':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x2c, %edx
jle 0xe048
cmpl $0x3e, %edx
je 0xe08c
cmpl $0x3c, %edx
je 0xe098
cmpl $0x2d, %edx
jne 0xe0c2
movq 0x10(%r14), %rax
jmp 0xe0cc
cmpl $-0x1, %edx
je 0xe0a4
testl %edx, %edx
jne 0xe0c2
movq 0x10(%r14), %rax
movl $0x1c, (%rax)
movq %r14, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%rbx)
movl $0xfffd, 0x30(%rbx)     # imm = 0xFFFD
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
xorl %eax, %eax
jmp 0xe0e2
movq 0x10(%r14), %rax
movl $0x5, (%rax)
jmp 0xe0cc
movq 0x10(%r14), %rax
movl $0x1f, (%rax)
jmp 0xe0cc
movq %r14, %rdi
movl $0xe, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movl $0x0, (%rax)
movl $0x2, %eax
jmp 0xe0e2
movq 0x10(%r14), %rax
movl $0x1c, (%rax)
movl 0x100(%rax), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_lt_state
static StateResult handle_script_double_escaped_lt_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  if (c == '/') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_END);
    gumbo_string_buffer_clear(&tokenizer->_script_data_buffer);
    return emit_current_char(parser, output);
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
    tokenizer->_reconsume_current_input = true;
    return NEXT_CHAR;
  }
}

// Assembly:
movq 0x10(%rdi), %rax
cmpl $0x2f, %edx
jne 0xe131
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movl $0x20, (%rax)
addq $0x30, %rsi
movq %rsi, %rdi
callq 0x7680
movq 0x10(%r14), %rax
movl 0x100(%rax), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1c, (%rax)
movb $0x1, 0x4(%rsi)
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_end_state
static StateResult handle_script_double_escaped_end_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
    case '/':
    case '>':
      gumbo_tokenizer_set_state(
          parser, string_piece_equal(&kScriptTag,
                      (GumboStringPiece*) &tokenizer->_script_data_buffer)
                      ? GUMBO_LEX_SCRIPT_ESCAPED
                      : GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
      return emit_current_char(parser, output);
    default:
      if (is_alpha(c)) {
        gumbo_string_buffer_append_codepoint (
          ensure_lowercase(c),
          &tokenizer->_script_data_buffer
        );
        return emit_current_char(parser, output);
      } else {
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
        tokenizer->_reconsume_current_input = true;
        return NEXT_CHAR;
      }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x3e, %edx
ja 0xe1b5
movl %edx, %eax
movabsq $0x4000800100001600, %rcx # imm = 0x4000800100001600
btq %rax, %rcx
jae 0xe1b5
movl $0x1c, %eax
cmpq $0x6, 0x38(%rsi)
jne 0xe191
movq 0x30(%rsi), %rax
movl $0x69726373, %ecx       # imm = 0x69726373
xorl (%rax), %ecx
movzwl 0x4(%rax), %eax
xorl $0x7470, %eax           # imm = 0x7470
orl %ecx, %eax
movl $0x15, %ecx
movl $0x1c, %eax
cmovel %ecx, %eax
movq 0x10(%r14), %rcx
movl %eax, (%rcx)
movl 0x100(%rcx), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %edx, %eax
orl $0x20, %eax
addl $-0x61, %eax
cmpl $0x19, %eax
ja 0xe1ea
movzbl %dl, %eax
leaq 0x9f84(%rip), %rcx      # 0x18150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
addq $0x30, %rsi
callq 0x4322
movq 0x10(%r14), %rax
movl 0x100(%rax), %esi
jmp 0xe19d
movq 0x10(%r14), %rax
movl $0x1c, (%rax)
movb $0x1, 0x4(%rsi)
movl $0x2, %eax
jmp 0xe1ad
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_before_attr_name_state
static StateResult handle_before_attr_name_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      return NEXT_CHAR;
    case '/':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SELF_CLOSING_START_TAG);
      return NEXT_CHAR;
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return emit_current_tag(parser, output);
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_ATTR_NAME);
      append_char_to_temporary_buffer(parser, 0xfffd);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_NAME_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      abandon_current_tag(parser);
      return NEXT_CHAR;
    case '"':
    case '\'':
    case '<':
    case '=':
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_NAME_INVALID);
    // Fall through.
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_ATTR_NAME);
      append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rdi, %r14
movl $0x2, %ebx
cmpl $0xb, %edx
jg 0xe252
leal -0x9(%r15), %eax
cmpl $0x2, %eax
jb 0xe337
cmpl $-0x1, %r15d
je 0xe30f
testl %r15d, %r15d
jne 0xe27c
movq %r14, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%r14), %rsi
movl $0x22, (%rsi)
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
jmp 0xe2cf
cmpl $0x3e, %r15d
ja 0xe2fe
movl %r15d, %eax
movabsq $0x3000008400000000, %rdx # imm = 0x3000008400000000
btq %rax, %rdx
jae 0xe2d6
movq %r14, %rdi
movl $0x10, %esi
callq 0x10a60
movq 0x10(%r14), %rsi
movl $0x22, (%rsi)
movzbl %r15b, %eax
leaq 0x9ebf(%rip), %rcx      # 0x18150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
cmpq $0x0, 0x70(%rsi)
jne 0xe2cb
movq 0x120(%rsi), %rax
movq %rax, 0xa0(%rsi)
movups 0x110(%rsi), %xmm0
movups %xmm0, 0x90(%rsi)
movq 0xe8(%rsi), %rax
movq %rax, 0x80(%rsi)
addq $0x68, %rsi
callq 0x4322
jmp 0xe337
cmpq $0x2f, %rax
je 0xe32d
cmpq $0x3e, %rax
jne 0xe2fe
movq 0x10(%r14), %rax
movl $0x0, (%rax)
movq %r14, %rdi
movq %rcx, %rsi
callq 0x10d4a
movl $0x1, %ebx
jmp 0xe337
cmpl $0xc, %r15d
je 0xe337
cmpl $0x20, %r15d
je 0xe337
jmp 0xe27c
movq %r14, %rdi
movl $0xf, %esi
callq 0x10a60
movq 0x10(%r14), %rdi
movl $0x0, (%rdi)
callq 0x10eb9
jmp 0xe337
movq 0x10(%r14), %rax
movl $0x2a, (%rax)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_attr_value_double_quoted_state
static StateResult handle_attr_value_double_quoted_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* UNUSED_ARG(output)
) {
  switch (c) {
    case '"':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_ATTR_VALUE_QUOTED);
      return NEXT_CHAR;
    case '&':
      tokenizer->_tag_state._attr_value_state = tokenizer->_state;
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_CHAR_REF_IN_ATTR_VALUE);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_tag_buffer(parser, UNICODE_REPLACEMENT_CHAR, false);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_DOUBLE_QUOTE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      abandon_current_tag(parser);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    default:
      append_char_to_tag_buffer(parser, c, false);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x21, %edx
jg 0xe872
cmpl $-0x1, %edx
je 0xe899
testl %edx, %edx
jne 0xe888
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%rbx), %rsi
addq $0x68, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
jmp 0xe892
cmpl $0x26, %edx
je 0xe8b7
cmpl $0x22, %edx
jne 0xe888
movq 0x10(%rbx), %rax
movl $0x29, (%rax)
jmp 0xe8d0
movq 0x10(%rbx), %rsi
addq $0x68, %rsi
movl %edx, %edi
callq 0x4322
jmp 0xe8d0
movq %rbx, %rdi
movl $0x11, %esi
callq 0x10a60
movq 0x10(%rbx), %rdi
movl $0x0, (%rdi)
callq 0x10eb9
jmp 0xe8cb
movl (%r14), %eax
movl %eax, 0xbc(%r14)
movq 0x10(%rbx), %rax
movl $0x28, (%rax)
movb $0x1, 0x4(%r14)
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_attr_value_single_quoted_state
static StateResult handle_attr_value_single_quoted_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* UNUSED_ARG(output)
) {
  switch (c) {
    case '\'':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_ATTR_VALUE_QUOTED);
      return NEXT_CHAR;
    case '&':
      tokenizer->_tag_state._attr_value_state = tokenizer->_state;
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_CHAR_REF_IN_ATTR_VALUE);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_tag_buffer(parser, UNICODE_REPLACEMENT_CHAR, false);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_SINGLE_QUOTE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      abandon_current_tag(parser);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    default:
      append_char_to_tag_buffer(parser, c, false);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x25, %edx
jg 0xe911
cmpl $-0x1, %edx
je 0xe938
testl %edx, %edx
jne 0xe927
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%rbx), %rsi
addq $0x68, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
jmp 0xe931
cmpl $0x26, %edx
je 0xe956
cmpl $0x27, %edx
jne 0xe927
movq 0x10(%rbx), %rax
movl $0x29, (%rax)
jmp 0xe96f
movq 0x10(%rbx), %rsi
addq $0x68, %rsi
movl %edx, %edi
callq 0x4322
jmp 0xe96f
movq %rbx, %rdi
movl $0x12, %esi
callq 0x10a60
movq 0x10(%rbx), %rdi
movl $0x0, (%rdi)
callq 0x10eb9
jmp 0xe96a
movl (%r14), %eax
movl %eax, 0xbc(%r14)
movq 0x10(%rbx), %rax
movl $0x28, (%rax)
movb $0x1, 0x4(%r14)
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_after_attr_value_quoted_state
static StateResult handle_after_attr_value_quoted_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  finish_attribute_value(parser);
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
      return NEXT_CHAR;
    case '/':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SELF_CLOSING_START_TAG);
      return NEXT_CHAR;
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return emit_current_tag(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_AFTER_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      abandon_current_tag(parser);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_AFTER_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1120f
cmpl $0x3e, %ebp
ja 0xecf0
movl %ebp, %eax
movabsq $0x100001600, %rcx      # imm = 0x100001600
btq %rax, %rcx
jae 0xecc8
movq 0x10(%r14), %rax
movl $0x21, (%rax)
jmp 0xed37
cmpq $0x2f, %rax
je 0xed2d
cmpq $0x3e, %rax
jne 0xecf0
movq 0x10(%r14), %rax
movl $0x0, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x10d4a
movl $0x1, %eax
jmp 0xed3c
movq %r14, %rdi
cmpl $-0x1, %ebp
jne 0xed13
movl $0x16, %esi
callq 0x10a60
movq 0x10(%r14), %rdi
movl $0x0, (%rdi)
callq 0x10eb9
jmp 0xed27
movl $0x17, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movl $0x21, (%rax)
movb $0x1, 0x4(%rbx)
jmp 0xed37
movq 0x10(%r14), %rax
movl $0x2a, (%rax)
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_self_closing_start_tag_state
static StateResult handle_self_closing_start_tag_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_tag_state._is_self_closing = true;
      return emit_current_tag(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SOLIDUS_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      abandon_current_tag(parser);
      return NEXT_CHAR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SOLIDUS_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xed7f
movq %rsi, %r14
cmpl $0x3e, %edx
jne 0xed9d
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movb $0x1, 0xc5(%r14)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x10d4a
movl $0x1, %eax
jmp 0xedbe
movq %rbx, %rdi
movl $0x19, %esi
callq 0x10a60
movq 0x10(%rbx), %rdi
movl $0x0, (%rdi)
callq 0x10eb9
jmp 0xedb9
movq %rbx, %rdi
movl $0x1a, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x21, (%rax)
movb $0x1, 0x4(%r14)
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq