LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xe869
movl %edx, %eax
movabsq $0x4000800100001600, %rcx # imm = 0x4000800100001600
btq %rax, %rcx
jae 0xe869
movl $0x15, %eax
cmpq $0x6, 0x38(%rsi)
jne 0xe84b
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)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11472
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %edx, %eax
orl $0x20, %eax
addl $-0x61, %eax
cmpl $0x19, %eax
ja 0xe894
movzbl %dl, %eax
leaq 0xb8d0(%rip), %rcx      # 0x1a150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
addq $0x30, %rsi
callq 0x4322
jmp 0xe851
movq 0x10(%r14), %rax
movl $0x15, (%rax)
movb $0x1, 0x4(%rsi)
movl $0x2, %eax
jmp 0xe861
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
cmpl $0x2c, %edx
jg 0xe8f3
cmpl $-0x1, %edx
je 0xe909
testl %edx, %edx
jne 0xe931
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%r14)
movl $0xfffd, 0x30(%r14)     # imm = 0xFFFD
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd443
xorl %eax, %eax
jmp 0xe941
cmpl $0x3c, %edx
je 0xe927
cmpl $0x2d, %edx
jne 0xe931
movq 0x10(%rbx), %rax
movl $0x1d, (%rax)
jmp 0xe931
movq %rbx, %rdi
movl $0xe, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movl $0x2, %eax
jmp 0xe941
movq 0x10(%rbx), %rax
movl $0x1f, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11472
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
cmpl $0x2c, %edx
jg 0xe99d
cmpl $-0x1, %edx
je 0xe9bf
testl %edx, %edx
jne 0xe9b3
movq 0x10(%rbx), %rax
movl $0x1c, (%rax)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%r14)
movl $0xfffd, 0x30(%r14)     # imm = 0xFFFD
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd443
xorl %eax, %eax
jmp 0xe9f7
cmpl $0x3c, %edx
je 0xe9dd
cmpl $0x2d, %edx
jne 0xe9b3
movq 0x10(%rbx), %rax
movl $0x1e, (%rax)
jmp 0xe9e7
movq 0x10(%rbx), %rax
movl $0x1c, (%rax)
jmp 0xe9e7
movq %rbx, %rdi
movl $0xe, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movl $0x2, %eax
jmp 0xe9f7
movq 0x10(%rbx), %rax
movl $0x1f, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11472
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xea23
cmpl $0x3e, %edx
je 0xea66
cmpl $0x3c, %edx
je 0xea72
cmpl $0x2d, %edx
je 0xeaa6
jmp 0xea9c
cmpl $-0x1, %edx
je 0xea7e
testl %edx, %edx
jne 0xea9c
movq 0x10(%r14), %rax
movl $0x1c, (%rax)
movq %r14, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%r14), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%rbx)
movl $0xfffd, 0x30(%rbx)     # imm = 0xFFFD
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd443
xorl %eax, %eax
jmp 0xeab6
movq 0x10(%r14), %rax
movl $0x5, (%rax)
jmp 0xeaa6
movq 0x10(%r14), %rax
movl $0x1f, (%rax)
jmp 0xeaa6
movq %r14, %rdi
movl $0xe, %esi
callq 0x11412
movq 0x10(%r14), %rax
movl $0x0, (%rax)
movl $0x2, %eax
jmp 0xeab6
movq 0x10(%r14), %rax
movl $0x1c, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11472
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xeafb
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movl $0x20, (%rax)
addq $0x30, %rsi
movq %rsi, %rdi
callq 0x7a1e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11472
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_O1/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 0xeb79
movl %edx, %eax
movabsq $0x4000800100001600, %rcx # imm = 0x4000800100001600
btq %rax, %rcx
jae 0xeb79
movl $0x1c, %eax
cmpq $0x6, 0x38(%rsi)
jne 0xeb5b
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)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11472
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %edx, %eax
orl $0x20, %eax
addl $-0x61, %eax
cmpl $0x19, %eax
ja 0xeba4
movzbl %dl, %eax
leaq 0xb5c0(%rip), %rcx      # 0x1a150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
addq $0x30, %rsi
callq 0x4322
jmp 0xeb61
movq 0x10(%r14), %rax
movl $0x1c, (%rax)
movb $0x1, 0x4(%rsi)
movl $0x2, %eax
jmp 0xeb71
// File: /workspace/github_c_makefile_star2_O1/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 0xec0c
leal -0x9(%r15), %eax
cmpl $0x2, %eax
jb 0xecf4
cmpl $-0x1, %r15d
je 0xecc9
testl %r15d, %r15d
jne 0xec36
movq %r14, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%r14), %rsi
movl $0x22, (%rsi)
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
jmp 0xec89
cmpl $0x3e, %r15d
ja 0xecb8
movl %r15d, %eax
movabsq $0x3000008400000000, %rdx # imm = 0x3000008400000000
btq %rax, %rdx
jae 0xec90
movq %r14, %rdi
movl $0x10, %esi
callq 0x11412
movq 0x10(%r14), %rsi
movl $0x22, (%rsi)
movzbl %r15b, %eax
leaq 0xb505(%rip), %rcx      # 0x1a150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
cmpq $0x0, 0x70(%rsi)
jne 0xec85
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 0xecf4
cmpq $0x2f, %rax
je 0xecea
cmpq $0x3e, %rax
jne 0xecb8
movq 0x10(%r14), %rax
movl $0x0, (%rax)
movq %r14, %rdi
movq %rcx, %rsi
callq 0x117b0
movl $0x1, %ebx
jmp 0xecf4
cmpl $0xc, %r15d
je 0xecf4
cmpl $0x20, %r15d
je 0xecf4
jmp 0xec36
movq %r14, %rdi
movl $0xf, %esi
callq 0x11412
movq 0x10(%r14), %rax
movl $0x0, (%rax)
movq %r14, %rdi
callq 0x11914
jmp 0xecf4
movq 0x10(%r14), %rax
movl $0x2a, (%rax)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf238
cmpl $-0x1, %edx
je 0xf25f
testl %edx, %edx
jne 0xf24e
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%rbx), %rsi
addq $0x68, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
jmp 0xf258
cmpl $0x26, %edx
je 0xf280
cmpl $0x22, %edx
jne 0xf24e
movq 0x10(%rbx), %rax
movl $0x29, (%rax)
jmp 0xf299
movq 0x10(%rbx), %rsi
addq $0x68, %rsi
movl %edx, %edi
callq 0x4322
jmp 0xf299
movq %rbx, %rdi
movl $0x11, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
callq 0x11914
jmp 0xf294
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_O1/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 0xf2da
cmpl $-0x1, %edx
je 0xf301
testl %edx, %edx
jne 0xf2f0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%rbx), %rsi
addq $0x68, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
jmp 0xf2fa
cmpl $0x26, %edx
je 0xf322
cmpl $0x27, %edx
jne 0xf2f0
movq 0x10(%rbx), %rax
movl $0x29, (%rax)
jmp 0xf33b
movq 0x10(%rbx), %rsi
addq $0x68, %rsi
movl %edx, %edi
callq 0x4322
jmp 0xf33b
movq %rbx, %rdi
movl $0x12, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
callq 0x11914
jmp 0xf336
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_O1/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, %r14
movq %rdi, %rbx
callq 0x11c95
cmpl $0x3e, %ebp
ja 0xf6bf
movl %ebp, %eax
movabsq $0x100001600, %rcx      # imm = 0x100001600
btq %rax, %rcx
jae 0xf697
movq 0x10(%rbx), %rax
movl $0x21, (%rax)
jmp 0xf70a
cmpq $0x2f, %rax
je 0xf700
cmpq $0x3e, %rax
jne 0xf6bf
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x117b0
movl $0x1, %eax
jmp 0xf70f
movq %rbx, %rdi
cmpl $-0x1, %ebp
jne 0xf6e5
movl $0x16, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
callq 0x11914
jmp 0xf6f9
movl $0x17, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x21, (%rax)
movb $0x1, 0x4(%r14)
jmp 0xf70a
movq 0x10(%rbx), %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_O1/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 0xf752
movq %rsi, %r14
cmpl $0x3e, %edx
jne 0xf773
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movb $0x1, 0xc5(%r14)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x117b0
movl $0x1, %eax
jmp 0xf794
movq %rbx, %rdi
movl $0x19, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
callq 0x11914
jmp 0xf78f
movq %rbx, %rdi
movl $0x1a, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x21, (%rax)
movb $0x1, 0x4(%r14)
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_bogus_comment_state
static StateResult handle_bogus_comment_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  while (c != '>' && c != -1) {
    if (c == '\0') {
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      c = 0xFFFD;
    }
    append_char_to_temporary_buffer(parser, c);
    utf8iterator_next(&tokenizer->_input);
    c = utf8iterator_current(&tokenizer->_input);
  }
  gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
  return emit_comment(parser, output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xe8(%rsi), %r12
testl %edx, %edx
je 0xf7c4
cmpl $-0x1, %edx
je 0xf7f6
cmpl $0x3e, %edx
jne 0xf7d6
jmp 0xf7f6
movq %r14, %rdi
movl $0x2, %esi
callq 0x11412
movl $0xfffd, %edx           # imm = 0xFFFD
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movl %edx, %edi
callq 0x4322
movq %r12, %rdi
callq 0x43e4
movl 0x100(%r15), %edx
jmp 0xf7b4
movq 0x10(%r14), %rax
movl $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11d94
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_markup_declaration_state
static StateResult handle_markup_declaration_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int UNUSED_ARG(c),
  GumboToken* UNUSED_ARG(output)
) {
  Utf8Iterator *input = &tokenizer->_input;
  if (utf8iterator_maybe_consume_literal(input, "--")) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT_START);
    tokenizer->_reconsume_current_input = true;
  } else if (utf8iterator_maybe_consume_literal_icase(input, "DOCTYPE")) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_DOCTYPE);
    tokenizer->_reconsume_current_input = true;
    // If we get here, we know we'll eventually emit a doctype token, so now is
    // the time to initialize the doctype strings. (Not in doctype_state_init,
    // since then they'll leak if ownership never gets transferred to the
    // doctype token.
    tokenizer->_doc_type_state.name = gumbo_strdup("");
    tokenizer->_doc_type_state.public_identifier = gumbo_strdup("");
    tokenizer->_doc_type_state.system_identifier = gumbo_strdup("");
  } else if (
    tokenizer->_is_current_node_foreign
    && utf8iterator_maybe_consume_literal(input, "[CDATA[")
  ) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_CDATA);
    tokenizer->_is_in_cdata = true;
    tokenizer->_reconsume_current_input = true;
  } else {
    tokenizer_add_parse_error(parser, GUMBO_ERR_DASHES_OR_DOCTYPE);
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_COMMENT);
    tokenizer->_reconsume_current_input = true;
    clear_temporary_buffer(parser);
  }
  return NEXT_CHAR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe8(%rsi), %r15
leaq 0x1097a(%rip), %rsi     # 0x201af
movl $0x2, %edx
movq %r15, %rdi
movl $0x1, %ecx
callq 0x7d5f
testb %al, %al
je 0xf85e
movq 0x10(%r14), %rax
movl $0x2d, (%rax)
movb $0x1, 0x4(%rbx)
jmp 0xf916
leaq 0x1094d(%rip), %rsi     # 0x201b2
movl $0x7, %edx
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x7d5f
testb %al, %al
je 0xf8bc
movq 0x10(%r14), %rax
movl $0x33, (%rax)
movb $0x1, 0x4(%rbx)
leaq 0xade6(%rip), %r14      # 0x1a673
movq %r14, %rdi
callq 0x11e81
movq %rax, 0xc8(%rbx)
movq %r14, %rdi
callq 0x11e81
movq %rax, 0xd0(%rbx)
movq %r14, %rdi
callq 0x11e81
movq %rax, 0xd8(%rbx)
jmp 0xf916
cmpb $0x1, 0x5(%rbx)
jne 0xf8f3
leaq 0x108f1(%rip), %rsi     # 0x201ba
movl $0x7, %edx
movq %r15, %rdi
movl $0x1, %ecx
callq 0x7d5f
testb %al, %al
je 0xf8f3
movq 0x10(%r14), %rax
movl $0x43, (%rax)
movb $0x1, %al
movb %al, 0x6(%rbx)
movb %al, 0x4(%rbx)
jmp 0xf916
movq %r14, %rdi
movl $0x1b, %esi
callq 0x11412
movq 0x10(%r14), %rax
movl $0x2b, (%rax)
movb $0x1, 0x4(%rbx)
movq %r14, %rdi
callq 0x113c5
movl $0x2, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_comment_start_state
static StateResult handle_comment_start_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT_START_DASH);
      return NEXT_CHAR;
    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, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case '>':
      tokenizer_add_parse_error(parser, GUMBO_ERR_COMMENT_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      emit_comment(parser, output);
      return RETURN_ERROR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_COMMENT_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, c);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
cmpl $0x2c, %edx
jg 0xf965
cmpl $-0x1, %edx
je 0xf997
testl %edx, %edx
jne 0xf97b
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%rbx), %rsi
movl $0x2f, (%rsi)
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
jmp 0xf9c5
cmpl $0x3e, %edx
je 0xf9a1
cmpl $0x2d, %edx
jne 0xf97b
movq 0x10(%rbx), %rax
movl $0x2e, (%rax)
jmp 0xf990
movq 0x10(%rbx), %rsi
movl $0x2f, (%rsi)
addq $0x10, %rsi
movl %edx, %edi
callq 0x4322
movl $0x2, %ebp
jmp 0xf9c5
movq %rbx, %rdi
movl $0x1c, %esi
jmp 0xf9a9
movq %rbx, %rdi
movl $0x1d, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11d94
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_comment_state
static StateResult handle_comment_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT_END_DASH);
      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 -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_COMMENT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      emit_comment(parser, output);
      return RETURN_ERROR;
    default:
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xfae8
testl %edx, %edx
je 0xfac2
cmpl $0x2d, %edx
jne 0xfb11
movq 0x10(%rbx), %rax
movl $0x30, (%rax)
jmp 0xfb20
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
jmp 0xfb25
movq %rcx, %r14
movq %rbx, %rdi
movl $0x1c, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11d94
xorl %ebp, %ebp
jmp 0xfb25
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl %edx, %edi
callq 0x4322
movl $0x2, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_comment_end_dash_state
static StateResult handle_comment_end_dash_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT_END);
      return NEXT_CHAR;
    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, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_COMMENT_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, c);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xfb90
movl %edx, %ebp
testl %edx, %edx
je 0xfb52
cmpl $0x2d, %ebp
jne 0xfbb9
movq 0x10(%rbx), %rax
movl $0x31, (%rax)
jmp 0xfbe0
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%rbx), %rsi
movl $0x2f, (%rsi)
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
jmp 0xfbe5
movq %rcx, %r14
movq %rbx, %rdi
movl $0x1c, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11d94
xorl %ebp, %ebp
jmp 0xfbe5
movq 0x10(%rbx), %rsi
movl $0x2f, (%rsi)
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl %ebp, %edi
callq 0x4322
movl $0x2, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %edx, %ebp
movq %rdi, %rbx
cmpl $0x20, %edx
jle 0xfc37
cmpl $0x21, %ebp
je 0xfc9b
cmpl $0x2d, %ebp
je 0xfcb7
cmpl $0x3e, %ebp
jne 0xfcf9
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11d94
movl $0x1, %ebp
jmp 0xfd44
cmpl $-0x1, %ebp
je 0xfcd3
testl %ebp, %ebp
jne 0xfcf9
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%rbx), %rsi
movl $0x2f, (%rsi)
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
jmp 0xfd44
movq %rbx, %rdi
movl $0x1e, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x32, (%rax)
jmp 0xfd3f
movq %rbx, %rdi
movl $0x1f, %esi
callq 0x11412
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x2d, %edi
jmp 0xfd3a
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11d94
xorl %ebp, %ebp
jmp 0xfd44
movq %rbx, %rdi
movl $0x1d, %esi
callq 0x11412
movq 0x10(%rbx), %rsi
movl $0x2f, (%rsi)
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl %ebp, %edi
callq 0x4322
movl $0x2, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %edx, %ebp
movq %rdi, %rbx
cmpl $0x2c, %edx
jg 0xfdd2
cmpl $-0x1, %ebp
je 0xfe6b
testl %ebp, %ebp
jne 0xfe19
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%rbx), %rsi
movl $0x2f, (%rsi)
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x21, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
jmp 0xfeab
cmpl $0x3e, %ebp
je 0xfe91
cmpl $0x2d, %ebp
jne 0xfe19
movq 0x10(%rbx), %rsi
movl $0x30, (%rsi)
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x21, %edi
jmp 0xfe5f
movq 0x10(%rbx), %rsi
movl $0x2f, (%rsi)
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x2d, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x21, %edi
callq 0x4322
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl %ebp, %edi
callq 0x4322
movl $0x2, %ebp
jmp 0xfeab
movq %rbx, %rdi
movl $0x21, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11d94
xorl %ebp, %ebp
jmp 0xfeab
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11d94
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x18(%rsi)
jne 0xff8c
movq %rsi, %r14
movq %rdi, %rbx
incl %edx
cmpl $0x21, %edx
ja 0xff63
movabsq $0x200002c00, %rax      # imm = 0x200002C00
btq %rdx, %rax
jae 0xff01
movq 0x10(%rbx), %rax
movl $0x34, (%rax)
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testq %rdx, %rdx
jne 0xff63
movq %rcx, %r15
movq %rbx, %rdi
movl $0x22, %esi
callq 0x11412
movq 0x10(%rbx), %rax
xorl %ebp, %ebp
movl %ebp, (%rax)
movb $0x1, 0xe0(%r14)
movl %ebp, (%r15)
movups 0xc8(%rax), %xmm0
movups 0xd8(%rax), %xmm1
movups %xmm0, 0x30(%r15)
movups %xmm1, 0x40(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd443
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
jmp 0xfef4
movq %rbx, %rdi
movl $0x24, %esi
callq 0x11412
movq 0x10(%rbx), %rax
movl $0x34, (%rax)
movb $0x1, %al
movb %al, 0x4(%r14)
movb %al, 0xe0(%r14)
jmp 0xfeef
leaq 0x1022f(%rip), %rdi     # 0x201c2
leaq 0xf7aa(%rip), %rsi      # 0x1f744
leaq 0x10246(%rip), %rcx     # 0x201e7
movl $0x9af, %edx            # imm = 0x9AF
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x2, %ebx
cmpl $0x3e, %edx
ja 0xfff5
movl %edx, %eax
movabsq $0x100001600, %rcx      # imm = 0x100001600
btq %rax, %rcx
jb 0x100af
testq %rax, %rax
je 0x10081
cmpq $0x3e, %rax
jne 0xfff5
movq %r14, %rdi
movl $0x25, %esi
jmp 0x10002
cmpl $-0x1, %edx
jne 0x10055
movq %r14, %rdi
movl $0x22, %esi
callq 0x11412
movq 0x10(%r14), %rax
xorl %ebx, %ebx
movl %ebx, (%rax)
movb $0x1, 0xe0(%r12)
movl %ebx, (%r15)
movups 0xc8(%rax), %xmm0
movups 0xd8(%rax), %xmm1
movups %xmm0, 0x30(%r15)
movups %xmm1, 0x40(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xd443
movq 0x10(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
jmp 0x100af
movq 0x10(%r14), %rsi
movl $0x35, (%rsi)
movb $0x0, 0xe0(%r12)
movzbl %dl, %eax
leaq 0xa0de(%rip), %rcx      # 0x1a150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
addq $0x10, %rsi
jmp 0x100aa
movq %r14, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%r14), %rsi
movl $0x35, (%rsi)
movb $0x1, 0xe0(%r12)
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rdi, %r14
movl $0x2, %ebx
incl %edx
cmpl $0x3f, %edx
ja 0x10339
movabsq $0x200002c00, %rax      # imm = 0x200002C00
btq %rdx, %rax
jae 0x102da
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rcx, %r12
testq %rdx, %rdx
je 0x10369
cmpq $0x3f, %rdx
jne 0x10339
movq 0x10(%r14), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movl %ecx, (%r12)
movups 0xc8(%rax), %xmm0
movups 0xd8(%rax), %xmm1
movups %xmm0, 0x30(%r12)
movups %xmm1, 0x40(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0xd443
movq 0x10(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
movl $0x1, %ebx
jmp 0x102cc
leaq 0xe8(%r15), %r12
leaq 0xfefa(%rip), %rsi      # 0x20241
movl $0x6, %edx
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x7d5f
testb %al, %al
je 0x103c9
movq 0x10(%r14), %rax
movl $0x37, (%rax)
jmp 0x103ed
movq %r14, %rdi
movl $0x22, %esi
callq 0x11412
movq 0x10(%r14), %rax
xorl %ebx, %ebx
movl %ebx, (%rax)
movb $0x1, 0xe0(%r15)
movl %ebx, (%r12)
movups 0xc8(%rax), %xmm0
movups 0xd8(%rax), %xmm1
movups %xmm0, 0x30(%r12)
movups %xmm1, 0x40(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0xd443
movq 0x10(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
jmp 0x102cc
leaq 0xfe78(%rip), %rsi      # 0x20248
movl $0x6, %edx
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x7d5f
testb %al, %al
je 0x103f7
movq 0x10(%r14), %rax
movl $0x3d, (%rax)
movb $0x1, 0x4(%r15)
jmp 0x102cc
movq %r14, %rdi
movl $0x26, %esi
callq 0x11412
movq 0x10(%r14), %rax
movl $0x42, (%rax)
movb $0x1, 0xe0(%r15)
jmp 0x102cc
// File: /workspace/github_c_makefile_star2_O1/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 $0x21, %edx
jg 0x107bb
cmpl $-0x1, %edx
je 0x107ef
testl %edx, %edx
jne 0x107d9
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11412
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
jmp 0x1085d
cmpl $0x3e, %edx
je 0x107f9
cmpl $0x22, %edx
jne 0x107d9
movq 0x10(%rbx), %rax
movl $0x3b, (%rax)
movq %rbx, %rdi
callq 0x11dcf
jmp 0x107e8
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl %edx, %edi
callq 0x4322
movl $0x2, %ebp
jmp 0x1085d
movq %rbx, %rdi
movl $0x22, %esi
jmp 0x10801
movq %rbx, %rdi
movl $0x27, %esi
callq 0x11412
movq 0x10(%rbx), %rax
xorl %ebp, %ebp
movl %ebp, (%rax)
movb $0x1, 0xe0(%r15)
movq %rbx, %rdi
callq 0x11dcf
movl %ebp, (%r14)
movq 0x10(%rbx), %rax
movups 0xc8(%rax), %xmm0
movups 0xd8(%rax), %xmm1
movups %xmm1, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd443
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq