LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_comment_end_state
static StateResult handle_comment_end_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return emit_comment(parser, output);
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT);
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case '!':
      tokenizer_add_parse_error(
          parser, GUMBO_ERR_COMMENT_BANG_AFTER_DOUBLE_DASH);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT_END_BANG);
      return NEXT_CHAR;
    case '-':
      tokenizer_add_parse_error(
          parser, GUMBO_ERR_COMMENT_DASH_AFTER_DOUBLE_DASH);
      append_char_to_temporary_buffer(parser, '-');
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      emit_comment(parser, output);
      return RETURN_ERROR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_COMMENT_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT);
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xde36
movl %edx, %ebp
testl %edx, %edx
je 0xdd89
cmpl $0x21, %ebp
je 0xdddc
cmpl $0x2d, %ebp
je 0xddc9
cmpl $0x3e, %ebp
jne 0xddf3
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5a2
pushq $0x1
jmp 0xde2e
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x2f, (%rax)
pushq $0x2d
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0xed83
movq %rbx, %rdi
movl %r14d, %esi
callq 0xed83
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xed83
jmp 0xde2f
pushq $0x1f
popq %rsi
movq %rbx, %rdi
callq 0xed94
pushq $0x2d
popq %rsi
movq %rbx, %rdi
jmp 0xde27
pushq $0x1e
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x32, (%rax)
jmp 0xde2c
pushq $0x1d
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x2f, (%rax)
pushq $0x2d
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0xed83
movq %rbx, %rdi
movl %r14d, %esi
callq 0xed83
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed83
pushq $0x2
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5a2
xorl %ebp, %ebp
jmp 0xde2f
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_comment_end_bang_state
static StateResult handle_comment_end_bang_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT_END_DASH);
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, '!');
      return NEXT_CHAR;
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return emit_comment(parser, output);
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT);
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, '!');
      append_char_to_temporary_buffer(parser, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_COMMENT_END_BANG_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      emit_comment(parser, output);
      return RETURN_ERROR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT);
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, '!');
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xdf0f
movl %edx, %ebp
testl %edx, %edx
je 0xdeae
cmpl $0x3e, %ebp
je 0xdef9
cmpl $0x2d, %ebp
jne 0xdf30
movq 0x10(%rbx), %rax
movl $0x30, (%rax)
pushq $0x2d
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed83
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed83
pushq $0x21
popq %rsi
movq %rbx, %rdi
jmp 0xdf64
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x2f, (%rax)
pushq $0x2d
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0xed83
movq %rbx, %rdi
movl %r14d, %esi
callq 0xed83
pushq $0x21
popq %rsi
movq %rbx, %rdi
callq 0xed83
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xed83
jmp 0xdf6c
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5a2
pushq $0x1
jmp 0xdf6b
pushq $0x21
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5a2
xorl %ebp, %ebp
jmp 0xdf6c
movq 0x10(%rbx), %rax
movl $0x2f, (%rax)
pushq $0x2d
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0xed83
movq %rbx, %rdi
movl %r14d, %esi
callq 0xed83
pushq $0x21
popq %rsi
movq %rbx, %rdi
callq 0xed83
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed83
pushq $0x2
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_doctype_state
static StateResult handle_doctype_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  assert(!tokenizer->_temporary_buffer.length);
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_DOCTYPE_NAME);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_SPACE);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_DOCTYPE_NAME);
      tokenizer->_reconsume_current_input = true;
      tokenizer->_doc_type_state.force_quirks = true;
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x18(%rsi)
jne 0xe005
movq %rsi, %rbx
movq %rdi, %r14
incl %edx
cmpl $0x21, %edx
ja 0xdfe3
movabsq $0x200002c00, %rax      # imm = 0x200002C00
btq %rdx, %rax
jae 0xdfb3
movq 0x10(%r14), %rax
movl $0x34, (%rax)
pushq $0x2
popq %rax
popq %rbx
popq %r14
popq %r15
retq
testq %rdx, %rdx
jne 0xdfe3
movq %rcx, %r15
pushq $0x22
popq %rsi
movq %r14, %rdi
callq 0xed94
movq 0x10(%r14), %rax
andl $0x0, (%rax)
movb $0x1, 0xe0(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0xf5f6
xorl %eax, %eax
jmp 0xdfad
pushq $0x24
popq %rsi
movq %r14, %rdi
callq 0xed94
movq 0x10(%r14), %rax
movl $0x34, (%rax)
movb $0x1, %al
movb %al, 0x4(%rbx)
movb %al, 0xe0(%rbx)
jmp 0xdfaa
leaq 0xe248(%rip), %rdi      # 0x1c254
leaq 0xd7c1(%rip), %rsi      # 0x1b7d4
leaq 0xe25f(%rip), %rcx      # 0x1c279
movl $0x9af, %edx            # imm = 0x9AF
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_before_doctype_name_state
static StateResult handle_before_doctype_name_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DOCTYPE_NAME);
      tokenizer->_doc_type_state.force_quirks = true;
      append_char_to_temporary_buffer(parser, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case '>':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_RIGHT_BRACKET);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DOCTYPE_NAME);
      tokenizer->_doc_type_state.force_quirks = false;
      append_char_to_temporary_buffer(parser, ensure_lowercase(c));
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2
popq %rbp
cmpl $0x3e, %edx
ja 0xe061
movl %edx, %eax
movabsq $0x100001600, %rcx      # imm = 0x100001600
btq %rax, %rcx
jb 0xe0e2
testq %rax, %rax
je 0xe0b9
cmpq $0x3e, %rax
jne 0xe061
pushq $0x25
jmp 0xe068
cmpl $-0x1, %edx
jne 0xe08f
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movb $0x1, 0xe0(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf5f6
xorl %ebp, %ebp
jmp 0xe0e2
movq 0x10(%rbx), %rax
movl $0x35, (%rax)
movb $0x0, 0xe0(%r14)
movzbl %dl, %eax
leaq 0x80a5(%rip), %rcx      # 0x16150
movzbl (%rcx,%rax), %esi
andl $0x20, %esi
orl %eax, %esi
movq %rbx, %rdi
jmp 0xe0dd
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x35, (%rax)
movb $0x1, 0xe0(%r14)
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xed83
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_doctype_name_state
static StateResult handle_doctype_name_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_DOCTYPE_NAME);
      gumbo_free((void*) tokenizer->_doc_type_state.name);
      finish_temporary_buffer(parser, &tokenizer->_doc_type_state.name);
      return NEXT_CHAR;
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      gumbo_free((void*) tokenizer->_doc_type_state.name);
      finish_temporary_buffer(parser, &tokenizer->_doc_type_state.name);
      emit_doctype(parser, output);
      return RETURN_SUCCESS;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_temporary_buffer(parser, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      gumbo_free((void*) tokenizer->_doc_type_state.name);
      finish_temporary_buffer(parser, &tokenizer->_doc_type_state.name);
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DOCTYPE_NAME);
      tokenizer->_doc_type_state.force_quirks = false;
      append_char_to_temporary_buffer(parser, ensure_lowercase(c));
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x3e, %edx
ja 0xe194
movl %edx, %eax
movabsq $0x100001600, %rcx      # imm = 0x100001600
btq %rax, %rcx
jae 0xe151
movq 0x10(%rbx), %rax
movl $0x36, (%rax)
movq 0xc8(%r15), %rdi
addq $0xc8, %r15
callq 0xf6e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf5cd
pushq $0x2
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testq %rax, %rax
je 0xe215
cmpq $0x3e, %rax
jne 0xe194
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq 0xc8(%r15), %rdi
addq $0xc8, %r15
callq 0xf6e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf5cd
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5f6
pushq $0x1
jmp 0xe145
cmpl $-0x1, %edx
jne 0xe1e3
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
leaq 0xc8(%r15), %r12
movb $0x1, 0xe0(%r15)
movq 0xc8(%r15), %rdi
callq 0xf6e0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf5cd
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5f6
xorl %ebp, %ebp
jmp 0xe146
movq 0x10(%rbx), %rax
movl $0x35, (%rax)
movb $0x0, 0xe0(%r15)
movzbl %dl, %eax
leaq 0x7f51(%rip), %rcx      # 0x16150
movzbl (%rcx,%rax), %esi
andl $0x20, %esi
orl %eax, %esi
movq %rbx, %rdi
callq 0xed83
jmp 0xe143
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed94
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xed83
jmp 0xe146
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_after_doctype_name_state
static StateResult handle_after_doctype_name_state (
  GumboParser* parser,
  GumboTokenizerState* 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_DATA);
      emit_doctype(parser, output);
      return RETURN_SUCCESS;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
  }

    Utf8Iterator *input = &tokenizer->_input;
    if (utf8iterator_maybe_consume_literal_icase(input, "PUBLIC")) {
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_DOCTYPE_PUBLIC_KEYWORD);
      tokenizer->_reconsume_current_input = true;
    } else if (utf8iterator_maybe_consume_literal_icase(input, "SYSTEM")) {
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_DOCTYPE_SYSTEM_KEYWORD);
      tokenizer->_reconsume_current_input = true;
    } else {
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_SPACE_OR_RIGHT_BRACKET);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_DOCTYPE);
      tokenizer->_doc_type_state.force_quirks = true;
    }
    return NEXT_CHAR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x2
popq %rbx
incl %edx
cmpl $0x3f, %edx
ja 0xe28f
movabsq $0x200002c00, %rax      # imm = 0x200002C00
btq %rdx, %rax
jae 0xe26a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rcx, %r12
testq %rdx, %rdx
je 0xe2ba
cmpq $0x3f, %rdx
jne 0xe28f
movq 0x10(%r15), %rax
andl $0x0, (%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0xf5f6
pushq $0x1
popq %rbx
jmp 0xe25c
leaq 0xe8(%r14), %r12
leaq 0xe036(%rip), %rsi      # 0x1c2d3
pushq $0x6
popq %rdx
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x75d7
testb %al, %al
je 0xe2e6
movq 0x10(%r15), %rax
movl $0x37, (%rax)
jmp 0xe308
pushq $0x22
popq %rsi
movq %r15, %rdi
callq 0xed94
movq 0x10(%r15), %rax
andl $0x0, (%rax)
movb $0x1, 0xe0(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0xf5f6
xorl %ebx, %ebx
jmp 0xe25c
leaq 0xdfed(%rip), %rsi      # 0x1c2da
pushq $0x6
popq %rdx
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x75d7
testb %al, %al
je 0xe312
movq 0x10(%r15), %rax
movl $0x3d, (%rax)
movb $0x1, 0x4(%r14)
jmp 0xe25c
pushq $0x26
popq %rsi
movq %r15, %rdi
callq 0xed94
movq 0x10(%r15), %rax
movl $0x42, (%rax)
movb $0x1, 0xe0(%r14)
jmp 0xe25c
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_after_doctype_public_keyword_state
static StateResult handle_after_doctype_public_keyword_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_DOCTYPE_PUBLIC_ID);
      return NEXT_CHAR;
    case '"':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      assert(temporary_buffer_is_empty(parser));
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_DOCTYPE_PUBLIC_ID_DOUBLE_QUOTED);
      return NEXT_CHAR;
    case '\'':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      assert(temporary_buffer_is_empty(parser));
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_DOCTYPE_PUBLIC_ID_SINGLE_QUOTED);
      return NEXT_CHAR;
    case '>':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_RIGHT_BRACKET);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_DOCTYPE);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leal -0x9(%rdx), %eax
cmpl $0x2, %eax
jb 0xe368
movq %rcx, %r14
movq %rsi, %r15
cmpl $-0x1, %edx
je 0xe3ce
cmpl $0xc, %edx
je 0xe368
cmpl $0x3e, %edx
je 0xe377
cmpl $0x22, %edx
je 0xe399
cmpl $0x27, %edx
je 0xe37b
cmpl $0x20, %edx
jne 0xe3b7
movq 0x10(%rbx), %rax
movl $0x38, (%rax)
pushq $0x2
popq %rax
jmp 0xe3f5
pushq $0x25
jmp 0xe3d0
pushq $0x23
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jne 0xe3fb
movl $0x3a, (%rax)
jmp 0xe372
pushq $0x23
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jne 0xe41a
movl $0x39, (%rax)
jmp 0xe372
pushq $0x23
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x42, (%rax)
jmp 0xe3e0
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movb $0x1, 0xe0(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5f6
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xdedf(%rip), %rdi      # 0x1c2e1
leaq 0xd3cb(%rip), %rsi      # 0x1b7d4
leaq 0xdef3(%rip), %rcx      # 0x1c303
movl $0xa55, %edx            # imm = 0xA55
callq 0x4100
leaq 0xdec0(%rip), %rdi      # 0x1c2e1
leaq 0xd3ac(%rip), %rsi      # 0x1b7d4
leaq 0xded4(%rip), %rcx      # 0x1c303
movl $0xa4f, %edx            # imm = 0xA4F
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_before_doctype_public_id_state
static StateResult handle_before_doctype_public_id_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      return NEXT_CHAR;
    case '"':
      assert(temporary_buffer_is_empty(parser));
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_DOCTYPE_PUBLIC_ID_DOUBLE_QUOTED);
      return NEXT_CHAR;
    case '\'':
      assert(temporary_buffer_is_empty(parser));
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_DOCTYPE_PUBLIC_ID_SINGLE_QUOTED);
      return NEXT_CHAR;
    case '>':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_END);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_DOCTYPE);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
pushq $0x2
popq %rax
leal -0x9(%rdx), %ecx
cmpl $0x2, %ecx
jb 0xe4e4
movq %rsi, %r15
movq %rdi, %r14
cmpl $-0x1, %edx
je 0xe4bd
cmpl $0xc, %edx
je 0xe4e4
cmpl $0x20, %edx
je 0xe4e4
cmpl $0x3e, %edx
je 0xe4a2
cmpl $0x27, %edx
je 0xe48f
cmpl $0x22, %edx
jne 0xe4a6
movq 0x10(%r14), %rcx
cmpq $0x0, 0x18(%rcx)
jne 0xe509
movl $0x39, (%rcx)
jmp 0xe4e4
movq 0x10(%r14), %rcx
cmpq $0x0, 0x18(%rcx)
jne 0xe4ea
movl $0x3a, (%rcx)
jmp 0xe4e4
pushq $0x27
jmp 0xe4bf
pushq $0x23
popq %rsi
movq %r14, %rdi
callq 0xed94
movq 0x10(%r14), %rax
movl $0x42, (%rax)
jmp 0xe4cf
pushq $0x22
popq %rsi
movq %r14, %rdi
callq 0xed94
movq 0x10(%r14), %rax
andl $0x0, (%rax)
movb $0x1, 0xe0(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf5f6
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xddf0(%rip), %rdi      # 0x1c2e1
leaq 0xd2dc(%rip), %rsi      # 0x1b7d4
leaq 0xde73(%rip), %rcx      # 0x1c372
movl $0xa81, %edx            # imm = 0xA81
callq 0x4100
leaq 0xddd1(%rip), %rdi      # 0x1c2e1
leaq 0xd2bd(%rip), %rsi      # 0x1b7d4
leaq 0xde54(%rip), %rcx      # 0x1c372
movl $0xa7c, %edx            # imm = 0xA7C
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_doctype_public_id_double_quoted_state
static StateResult handle_doctype_public_id_double_quoted_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '"':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_DOCTYPE_PUBLIC_ID);
      finish_doctype_public_id(parser);
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_temporary_buffer(parser, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case '>':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_END);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      finish_doctype_public_id(parser);
      emit_doctype(parser, output);
      return RETURN_ERROR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      finish_doctype_public_id(parser);
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xe57f
testl %edx, %edx
je 0xe55f
cmpl $0x3e, %edx
je 0xe57b
cmpl $0x22, %edx
jne 0xe5b0
movq 0x10(%rbx), %rax
movl $0x3b, (%rax)
movq %rbx, %rdi
callq 0xf633
jmp 0xe5ba
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed94
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xed83
jmp 0xe5bd
pushq $0x27
jmp 0xe581
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movb $0x1, 0xe0(%r15)
movq %rbx, %rdi
callq 0xf633
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5f6
xorl %ebp, %ebp
jmp 0xe5bd
movq %rbx, %rdi
movl %edx, %esi
callq 0xed83
pushq $0x2
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_after_doctype_public_id_state
static StateResult handle_after_doctype_public_id_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_BETWEEN_DOCTYPE_PUBLIC_SYSTEM_ID);
      return NEXT_CHAR;
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      emit_doctype(parser, output);
      return RETURN_SUCCESS;
    case '"':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      assert(temporary_buffer_is_empty(parser));
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_DOCTYPE_SYSTEM_ID_DOUBLE_QUOTED);
      return NEXT_CHAR;
    case '\'':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      assert(temporary_buffer_is_empty(parser));
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_DOCTYPE_SYSTEM_ID_SINGLE_QUOTED);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_reconsume_current_input = true;
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_DOCTYPE);
      tokenizer->_doc_type_state.force_quirks = true;
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leal -0x9(%rdx), %eax
cmpl $0x2, %eax
jb 0xe6a4
movq %rcx, %r15
movq %rsi, %r14
cmpl $-0x1, %edx
je 0xe728
cmpl $0xc, %edx
je 0xe6a4
cmpl $0x3e, %edx
je 0xe6b7
cmpl $0x22, %edx
je 0xe6eb
cmpl $0x27, %edx
je 0xe6cd
cmpl $0x20, %edx
jne 0xe709
movq 0x10(%rbx), %rax
movl $0x3c, (%rax)
pushq $0x2
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf5f6
pushq $0x1
jmp 0xe6b0
pushq $0x23
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jne 0xe759
movl $0x40, (%rax)
jmp 0xe6ae
pushq $0x23
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jne 0xe778
movl $0x3f, (%rax)
jmp 0xe6ae
pushq $0x23
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x42, (%rax)
movb $0x1, 0xe0(%r14)
jmp 0xe6ae
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movb $0x1, %al
movb %al, 0x4(%r14)
movb %al, 0xe0(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf5f6
xorl %eax, %eax
jmp 0xe6b1
leaq 0xdb81(%rip), %rdi      # 0x1c2e1
leaq 0xd06d(%rip), %rsi      # 0x1b7d4
leaq 0xdc6f(%rip), %rcx      # 0x1c3dd
movl $0xafd, %edx            # imm = 0xAFD
callq 0x4100
leaq 0xdb62(%rip), %rdi      # 0x1c2e1
leaq 0xd04e(%rip), %rsi      # 0x1b7d4
leaq 0xdc50(%rip), %rcx      # 0x1c3dd
movl $0xaf7, %edx            # imm = 0xAF7
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_between_doctype_public_system_id_state
static StateResult handle_between_doctype_public_system_id_state (
  GumboParser* parser,
  GumboTokenizerState* 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_DATA);
      emit_doctype(parser, output);
      return RETURN_SUCCESS;
    case '"':
      assert(temporary_buffer_is_empty(parser));
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_DOCTYPE_SYSTEM_ID_DOUBLE_QUOTED);
      return NEXT_CHAR;
    case '\'':
      assert(temporary_buffer_is_empty(parser));
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_DOCTYPE_SYSTEM_ID_SINGLE_QUOTED);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_DOCTYPE);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
pushq $0x2
popq %rax
leal -0x9(%rdx), %ecx
cmpl $0x2, %ecx
jb 0xe855
movq %rsi, %r15
movq %rdi, %r14
cmpl $-0x1, %edx
je 0xe82e
cmpl $0xc, %edx
je 0xe855
cmpl $0x20, %edx
je 0xe855
cmpl $0x22, %edx
je 0xe804
cmpl $0x27, %edx
je 0xe7f1
cmpl $0x3e, %edx
jne 0xe817
movq 0x10(%r14), %rax
andl $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf5f6
pushq $0x1
popq %rax
jmp 0xe855
movq 0x10(%r14), %rcx
cmpq $0x0, 0x18(%rcx)
jne 0xe85b
movl $0x40, (%rcx)
jmp 0xe855
movq 0x10(%r14), %rcx
cmpq $0x0, 0x18(%rcx)
jne 0xe87a
movl $0x3f, (%rcx)
jmp 0xe855
pushq $0x23
popq %rsi
movq %r14, %rdi
callq 0xed94
movq 0x10(%r14), %rax
movl $0x42, (%rax)
jmp 0xe840
pushq $0x22
popq %rsi
movq %r14, %rdi
callq 0xed94
movq 0x10(%r14), %rax
andl $0x0, (%rax)
movb $0x1, 0xe0(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf5f6
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xda7f(%rip), %rdi      # 0x1c2e1
leaq 0xcf6b(%rip), %rsi      # 0x1b7d4
leaq 0xdbd7(%rip), %rcx      # 0x1c447
movl $0xb27, %edx            # imm = 0xB27
callq 0x4100
leaq 0xda60(%rip), %rdi      # 0x1c2e1
leaq 0xcf4c(%rip), %rsi      # 0x1b7d4
leaq 0xdbb8(%rip), %rcx      # 0x1c447
movl $0xb22, %edx            # imm = 0xB22
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_after_doctype_system_keyword_state
static StateResult handle_after_doctype_system_keyword_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_DOCTYPE_SYSTEM_ID);
      return NEXT_CHAR;
    case '"':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      assert(temporary_buffer_is_empty(parser));
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_DOCTYPE_SYSTEM_ID_DOUBLE_QUOTED);
      return NEXT_CHAR;
    case '\'':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      assert(temporary_buffer_is_empty(parser));
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_DOCTYPE_SYSTEM_ID_SINGLE_QUOTED);
      return NEXT_CHAR;
    case '>':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_END);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_DOCTYPE);
      tokenizer->_doc_type_state.force_quirks = true;
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leal -0x9(%rdx), %eax
cmpl $0x2, %eax
jb 0xe8d1
movq %rcx, %r15
movq %rsi, %r14
cmpl $-0x1, %edx
je 0xe942
cmpl $0xc, %edx
je 0xe8d1
cmpl $0x3e, %edx
je 0xe8e3
cmpl $0x22, %edx
je 0xe905
cmpl $0x27, %edx
je 0xe8e7
cmpl $0x20, %edx
jne 0xe923
movq 0x10(%rbx), %rax
movl $0x3e, (%rax)
pushq $0x2
popq %rax
jmp 0xe969
pushq $0x27
jmp 0xe944
pushq $0x23
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jne 0xe96f
movl $0x40, (%rax)
jmp 0xe8db
pushq $0x23
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jne 0xe98e
movl $0x3f, (%rax)
jmp 0xe8db
pushq $0x23
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x42, (%rax)
movb $0x1, 0xe0(%r14)
jmp 0xe8db
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movb $0x1, 0xe0(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf5f6
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xd96b(%rip), %rdi      # 0x1c2e1
leaq 0xce57(%rip), %rsi      # 0x1b7d4
leaq 0xdb36(%rip), %rcx      # 0x1c4ba
movl $0xb50, %edx            # imm = 0xB50
callq 0x4100
leaq 0xd94c(%rip), %rdi      # 0x1c2e1
leaq 0xce38(%rip), %rsi      # 0x1b7d4
leaq 0xdb17(%rip), %rcx      # 0x1c4ba
movl $0xb4a, %edx            # imm = 0xB4A
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_doctype_system_id_double_quoted_state
static StateResult handle_doctype_system_id_double_quoted_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '"':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_DOCTYPE_SYSTEM_ID);
      finish_doctype_system_id(parser);
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_temporary_buffer(parser, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case '>':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_END);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      finish_doctype_system_id(parser);
      emit_doctype(parser, output);
      return RETURN_ERROR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      finish_doctype_system_id(parser);
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xeb0a
testl %edx, %edx
je 0xeaea
cmpl $0x3e, %edx
je 0xeb06
cmpl $0x22, %edx
jne 0xeb3b
movq 0x10(%rbx), %rax
movl $0x41, (%rax)
movq %rbx, %rdi
callq 0xf66b
jmp 0xeb45
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed94
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xed83
jmp 0xeb48
pushq $0x27
jmp 0xeb0c
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movb $0x1, 0xe0(%r15)
movq %rbx, %rdi
callq 0xf66b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5f6
xorl %ebp, %ebp
jmp 0xeb48
movq %rbx, %rdi
movl %edx, %esi
callq 0xed83
pushq $0x2
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_after_doctype_system_id_state
static StateResult handle_after_doctype_system_id_state (
  GumboParser* parser,
  GumboTokenizerState* 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_DATA);
      emit_doctype(parser, output);
      return RETURN_SUCCESS;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_DOCTYPE);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rbp
incl %edx
cmpl $0x3f, %edx
ja 0xec4d
movabsq $0x200002c00, %rax      # imm = 0x200002C00
btq %rdx, %rax
jae 0xec28
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r14
testq %rdx, %rdx
je 0xec64
cmpq $0x3f, %rdx
jne 0xec4d
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5f6
pushq $0x1
popq %rbp
jmp 0xec1b
pushq $0x23
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x42, (%rax)
jmp 0xec1b
movq %rsi, %r15
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movb $0x1, 0xe0(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5f6
xorl %ebp, %ebp
jmp 0xec1b
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_cdata_state
static StateResult handle_cdata_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  if (c == -1 || utf8iterator_maybe_consume_literal(&tokenizer->_input, "]]>")) {
    tokenizer->_reconsume_current_input = true;
    reset_token_start_point(tokenizer);
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
    tokenizer->_is_in_cdata = false;
    return NEXT_CHAR;
  } else {
    return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $-0x1, %edx
je 0xece9
movq %rcx, %r15
leaq 0xe8(%rbx), %rdi
leaq 0xd8bc(%rip), %rsi      # 0x1c594
pushq $0x3
popq %rdx
pushq $0x1
popq %rbp
movl %ebp, %ecx
callq 0x75d7
testb %al, %al
je 0xed1e
movb $0x1, 0x4(%rbx)
movq 0xe8(%rbx), %rax
movq %rax, 0x48(%rbx)
movups 0x110(%rbx), %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x120(%rbx), %rax
movq %rax, 0x60(%rbx)
movq 0x10(%r14), %rax
andl $0x0, (%rax)
movb $0x0, 0x6(%rbx)
pushq $0x2
popq %rbp
jmp 0xed29
movq %r14, %rdi
movq %r15, %rsi
callq 0xedf4
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: clear_temporary_buffer
static void clear_temporary_buffer(GumboParser* parser) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  assert(!tokenizer->_temporary_buffer_emit);
  utf8iterator_mark(&tokenizer->_input);
  gumbo_string_buffer_clear(&tokenizer->_temporary_buffer);
  // The temporary buffer and script data buffer are the same object in the
  // spec, so the script data buffer should be cleared as well.
  gumbo_string_buffer_clear(&tokenizer->_script_data_buffer);
}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rbx
cmpq $0x0, 0x28(%rbx)
jne 0xed64
leaq 0xe8(%rbx), %rdi
callq 0x7650
leaq 0x10(%rbx), %rdi
callq 0x72fb
addq $0x30, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x72fb
leaq 0xcb15(%rip), %rdi      # 0x1b880
leaq 0xca62(%rip), %rsi      # 0x1b7d4
leaq 0xcbf9(%rip), %rcx      # 0x1b972
movl $0x167, %edx            # imm = 0x167
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: emit_char_ref
static StateResult emit_char_ref (
  GumboParser* parser,
  int additional_allowed_char,
  bool UNUSED_ARG(is_in_attribute),
  GumboToken* output
) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  OneOrTwoCodepoints char_ref;
  bool status = gumbo_consume_char_ref (
    parser,
    &tokenizer->_input,
    additional_allowed_char,
    false,
    &char_ref
  );
  if (char_ref.first != kGumboNoChar) {
    // gumbo_consume_char_ref ends with the iterator pointing at the next
    // character, so we need to be sure not advance it again before
    // reading the next token.
    tokenizer->_reconsume_current_input = true;
    emit_char(parser, char_ref.first, output);
    tokenizer->_buffered_emit_char = char_ref.second;
  } else {
    emit_char(parser, '&', output);
  }
  return status ? RETURN_SUCCESS : RETURN_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
leaq 0xe8(%r12), %rsi
pushq $0x20
popq %rdx
leaq 0x8(%rsp), %r15
xorl %ecx, %ecx
movq %r15, %r8
callq 0xf714
movl %eax, %ebp
movl (%r15), %esi
leaq 0xfa7e(%rip), %rax      # 0x1e8c0
cmpl (%rax), %esi
jne 0xee56
pushq $0x26
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6041
jmp 0xee70
movb $0x1, 0x4(%r12)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6041
movl 0xc(%rsp), %eax
movl %eax, 0x8(%r12)
movzbl %bpl, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: temporary_buffer_equals__
static bool temporary_buffer_equals__ (
  const GumboParser* parser,
  const char* text,
  size_t text_len
) {
  const GumboStringBuffer* buf = &parser->_tokenizer_state->_temporary_buffer;
  return
    text_len == buf->length
    && memcmp(buf->data, text, text_len) == 0;
}

// Assembly:
movq 0x10(%rdi), %rax
cmpq %rdx, 0x18(%rax)
jne 0xeed3
pushq %rax
movq 0x10(%rax), %rdi
callq 0x4200
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: start_new_tag
static void start_new_tag(GumboParser* parser, bool is_start_tag) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  GumboTagState* tag_state = &tokenizer->_tag_state;
  int c = utf8iterator_current(&tokenizer->_input);
  assert(is_alpha(c));
  c = ensure_lowercase(c);
  assert(is_alpha(c));

  initialize_tag_buffer(parser);
  gumbo_string_buffer_append_codepoint(c, &tag_state->_buffer);

  assert(tag_state->_attributes.data == NULL);
  // Initial size chosen by statistical analysis of a corpus of 60k webpages.
  // 99.5% of elements have 0 attributes, 93% of the remainder have 1. These
  // numbers are a bit higher for more modern websites (eg. ~45% = 0, ~40% = 1
  // for the HTML5 Spec), but still have basically 99% of nodes with <= 2 attrs.
  gumbo_vector_init(1, &tag_state->_attributes);
  tag_state->_drop_next_attr_value = false;
  tag_state->_is_start_tag = is_start_tag;
  tag_state->_is_self_closing = false;
  gumbo_debug("Starting new tag.\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r15
movl 0x100(%r15), %eax
movl %eax, %ecx
orl $0x20, %ecx
addl $-0x61, %ecx
cmpl $0x1a, %ecx
jae 0xef68
movzbl %al, %ecx
leaq 0x7251(%rip), %rdx      # 0x16150
movzbl (%rdx,%rcx), %ecx
andl $0x20, %ecx
movzbl %al, %ebp
orl %ecx, %ebp
movl %ebp, %eax
orl $0x20, %eax
addl $-0x61, %eax
cmpl $0x1a, %eax
jae 0xef87
movl %esi, %ebx
leaq 0x68(%r15), %r14
callq 0xf01e
movl %ebp, %edi
movq %r14, %rsi
callq 0x42a0
cmpq $0x0, 0xa8(%r15)
jne 0xefa6
leaq 0xa8(%r15), %rsi
pushq $0x1
popq %rdi
callq 0x76f4
xorl %eax, %eax
movb %al, 0xb8(%r15)
movb %bl, 0xc4(%r15)
movb %al, 0xc5(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcab0(%rip), %rdi      # 0x1ba1f
leaq 0xc85e(%rip), %rsi      # 0x1b7d4
leaq 0xcaae(%rip), %rcx      # 0x1ba2b
movl $0x2cc, %edx            # imm = 0x2CC
callq 0x4100
leaq 0xca91(%rip), %rdi      # 0x1ba1f
leaq 0xc83f(%rip), %rsi      # 0x1b7d4
leaq 0xca8f(%rip), %rcx      # 0x1ba2b
movl $0x2ce, %edx            # imm = 0x2CE
callq 0x4100
leaq 0xcaa7(%rip), %rdi      # 0x1ba54
leaq 0xc820(%rip), %rsi      # 0x1b7d4
leaq 0xca70(%rip), %rcx      # 0x1ba2b
movl $0x2d3, %edx            # imm = 0x2D3
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: emit_temporary_buffer
static bool emit_temporary_buffer(GumboParser* parser, GumboToken* output) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  assert(tokenizer->_temporary_buffer.data);
  utf8iterator_reset(&tokenizer->_input);
  tokenizer->_temporary_buffer_emit = tokenizer->_temporary_buffer.data;
  return maybe_emit_from_temporary_buffer(parser, output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r15
cmpq $0x0, 0x10(%r15)
je 0xefff
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe8(%r15), %rdi
callq 0x7668
movq 0x10(%r15), %rax
movq %rax, 0x28(%r15)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xbd2b
leaq 0xca72(%rip), %rdi      # 0x1ba78
leaq 0xc7c7(%rip), %rsi      # 0x1b7d4
leaq 0xca86(%rip), %rcx      # 0x1ba9a
movl $0x2a4, %edx            # imm = 0x2A4
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: initialize_tag_buffer
static void initialize_tag_buffer(GumboParser* parser) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  GumboTagState* tag_state = &tokenizer->_tag_state;

  gumbo_string_buffer_init(&tag_state->_buffer);
  reset_tag_buffer_start_point(parser);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
addq $0x68, %rdi
callq 0x70f4
movq 0x10(%rbx), %rax
movq 0x120(%rax), %rcx
movq %rcx, 0xa0(%rax)
movups 0x110(%rax), %xmm0
movups %xmm0, 0x90(%rax)
movq 0xe8(%rax), %rcx
movq %rcx, 0x80(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: finish_tag_name
static void finish_tag_name(GumboParser* parser) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  GumboTagState* tag_state = &tokenizer->_tag_state;

  tag_state->_tag =
      gumbo_tagn_enum(tag_state->_buffer.data, tag_state->_buffer.length);
  reinitialize_tag_buffer(parser);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0x68(%r14), %rdi
movq 0x70(%r14), %rsi
callq 0x7441
movl %eax, 0x88(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf287
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: append_char_to_tag_buffer
static void append_char_to_tag_buffer (
  GumboParser* parser,
  int codepoint,
  bool reinitilize_position_on_first
) {
  GumboStringBuffer* buffer = &parser->_tokenizer_state->_tag_state._buffer;
  if (buffer->length == 0 && reinitilize_position_on_first) {
    reset_tag_buffer_start_point(parser);
  }
  gumbo_string_buffer_append_codepoint(codepoint, buffer);
}

// Assembly:
movl %esi, %eax
xorb $0x1, %dl
movq 0x10(%rdi), %rsi
cmpq $0x0, 0x70(%rsi)
setne %cl
orb %dl, %cl
jne 0xf229
movq 0x120(%rsi), %rcx
movq %rcx, 0xa0(%rsi)
movups 0x110(%rsi), %xmm0
movups %xmm0, 0x90(%rsi)
movq 0xe8(%rsi), %rcx
movq %rcx, 0x80(%rsi)
addq $0x68, %rsi
movl %eax, %edi
jmp 0x42a0
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: abandon_current_tag
static void abandon_current_tag(GumboParser* parser) {
  GumboTagState* tag_state = &parser->_tokenizer_state->_tag_state;
  for (unsigned int i = 0; i < tag_state->_attributes.length; ++i) {
    gumbo_destroy_attribute(tag_state->_attributes.data[i]);
  }
  gumbo_free(tag_state->_attributes.data);
  mark_tag_state_as_empty(tag_state);
  gumbo_string_buffer_destroy(&tag_state->_buffer);
  gumbo_debug("Abandoning current tag.\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rbx
leaq 0xa8(%rbx), %r14
xorl %r15d, %r15d
movl 0xb0(%rbx), %eax
cmpq %rax, %r15
jae 0xf263
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x6bab
incq %r15
jmp 0xf247
movq 0xa8(%rbx), %rdi
addq $0x68, %rbx
callq 0xf6e0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7301
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: is_appropriate_end_tag
static bool is_appropriate_end_tag(GumboParser* parser) {
  GumboTagState* tag_state = &parser->_tokenizer_state->_tag_state;
  assert(!tag_state->_is_start_tag);
  return tag_state->_last_start_tag != GUMBO_TAG_LAST &&
         tag_state->_last_start_tag == gumbo_tagn_enum(tag_state->_buffer.data,
                                           tag_state->_buffer.length);
}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rax
cmpb $0x1, 0xc4(%rax)
je 0xf2d5
movl 0xc0(%rax), %ebx
cmpl $0x97, %ebx
jne 0xf2c1
xorl %eax, %eax
jmp 0xf2d3
movq 0x68(%rax), %rdi
movq 0x70(%rax), %rsi
callq 0x7441
cmpl %eax, %ebx
sete %al
popq %rbx
retq
leaq 0xca95(%rip), %rdi      # 0x1bd71
leaq 0xc4f1(%rip), %rsi      # 0x1b7d4
leaq 0xcaa1(%rip), %rcx      # 0x1bd8b
movl $0x378, %edx            # imm = 0x378
callq 0x4100