LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_attr_value_unquoted_state
static StateResult handle_attr_value_unquoted_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_ATTR_NAME);
      finish_attribute_value(parser);
      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 '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      finish_attribute_value(parser);
      return emit_current_tag(parser, output);
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_tag_buffer(parser, UNICODE_REPLACEMENT_CHAR, true);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_UNQUOTED_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_reconsume_current_input = true;
      abandon_current_tag(parser);
      return NEXT_CHAR;
    case '<':
    case '=':
    case '"':
    case '\'':
    case '`':
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_UNQUOTED_EQUALS);
    // Fall through.
    default:
      append_char_to_tag_buffer(parser, c, true);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x61, %eax
ja 0x14918
movq -0x30(%rbp), %rax
leaq 0x2104a(%rip), %rcx     # 0x35870
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movl $0x21, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x17a70
movl $0x2, -0x4(%rbp)
jmp 0x14930
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xbc(%rax)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x14930
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x17a70
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x172b0
movl %eax, -0x4(%rbp)
jmp 0x14930
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
movl $0x1, %edx
callq 0x174b0
movl $0x2, -0x4(%rbp)
jmp 0x14930
movq -0x10(%rbp), %rdi
movl $0x13, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x17510
movl $0x2, -0x4(%rbp)
jmp 0x14930
movq -0x10(%rbp), %rdi
movl $0x15, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x1, %edx
callq 0x174b0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17a70
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3f, %eax
ja 0x14b39
movq -0x30(%rbp), %rax
leaq 0x20f49(%rip), %rcx     # 0x359f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movl $0x21, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x14b64
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x14b64
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x172b0
movl %eax, -0x4(%rbp)
jmp 0x14b64
movq -0x10(%rbp), %rdi
movl $0x16, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x17510
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x14b64
movq -0x10(%rbp), %rdi
movl $0x17, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0x21, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x14bc6
jmp 0x14b94
movl -0x2c(%rbp), %eax
subl $0x3e, %eax
jne 0x14bf1
jmp 0x14b9e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0xc5(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x172b0
movl %eax, -0x4(%rbp)
jmp 0x14c1c
movq -0x10(%rbp), %rdi
movl $0x19, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x17510
movl $0x2, -0x4(%rbp)
jmp 0x14c1c
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0x21, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x3e, -0x14(%rbp)
movb %al, -0x21(%rbp)
je 0x14c5c
cmpl $-0x1, -0x14(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x14c65
jmp 0x14cb1
cmpl $0x0, -0x14(%rbp)
jne 0x14c80
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movl $0xfffd, -0x14(%rbp)    # imm = 0xFFFD
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x16c30
movq -0x10(%rbp), %rdi
addq $0xe8, %rdi
callq 0x6500
movq -0x10(%rbp), %rdi
addq $0xe8, %rdi
callq 0x11f40
movl %eax, -0x14(%rbp)
jmp 0x14c47
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x17b20
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x14f04
jmp 0x14e68
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x14ea2
jmp 0x14e71
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
je 0x14e88
jmp 0x14e7b
movl -0x2c(%rbp), %eax
subl $0x3e, %eax
je 0x14ed5
jmp 0x14f33
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x14f54
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x14f54
movq -0x10(%rbp), %rdi
movl $0x1d, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17b20
movl $0x0, -0x4(%rbp)
jmp 0x14f54
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17b20
movl $0x0, -0x4(%rbp)
jmp 0x14f54
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x15113
jmp 0x150c4
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x150ee
jmp 0x150cd
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
jne 0x15142
jmp 0x150d7
movq -0x10(%rbp), %rdi
movl $0x30, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x15155
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x15155
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17b20
movl $0x0, -0x4(%rbp)
jmp 0x15155
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x151f6
jmp 0x15184
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x151b5
jmp 0x1518d
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
jne 0x15225
jmp 0x1519b
movq -0x10(%rbp), %rdi
movl $0x31, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x15254
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl $0x2d, %esi
callq 0x16c30
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x15254
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17b20
movl $0x0, -0x4(%rbp)
jmp 0x15254
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl $0x2d, %esi
callq 0x16c30
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x155b4
jmp 0x155d3
leaq 0x219ff(%rip), %rdi     # 0x36fba
leaq 0x20e6e(%rip), %rsi     # 0x36430
movl $0x9af, %edx            # imm = 0x9AF
leaq 0x21a11(%rip), %rcx     # 0x36fdf
callq 0x4100
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x15618
jmp 0x155e0
movl -0x2c(%rbp), %eax
addl $-0x9, %eax
subl $0x2, %eax
jb 0x15601
jmp 0x155ed
movl -0x2c(%rbp), %eax
subl $0xc, %eax
je 0x15601
jmp 0x155f7
movl -0x2c(%rbp), %eax
subl $0x20, %eax
jne 0x15652
jmp 0x15601
movq -0x10(%rbp), %rdi
movl $0x34, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x15688
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17bc0
movl $0x0, -0x4(%rbp)
jmp 0x15688
movq -0x10(%rbp), %rdi
movl $0x24, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0x34, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0xe0(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3f, %eax
ja 0x157a0
movq -0x30(%rbp), %rax
leaq 0x20422(%rip), %rcx     # 0x35af8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2, -0x4(%rbp)
jmp 0x157db
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0x35, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x157db
movq -0x10(%rbp), %rdi
movl $0x25, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17bc0
movl $0x0, -0x4(%rbp)
jmp 0x157db
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17bc0
movl $0x0, -0x4(%rbp)
jmp 0x157db
movq -0x10(%rbp), %rdi
movl $0x35, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x0, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %edi
callq 0x17170
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x15f36
jmp 0x15e88
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x15ecb
jmp 0x15e91
movl -0x2c(%rbp), %eax
subl $0x22, %eax
je 0x15ea8
jmp 0x15e9b
movl -0x2c(%rbp), %eax
subl $0x3e, %eax
je 0x15ef3
jmp 0x15f79
movq -0x10(%rbp), %rdi
movl $0x3b, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x17c50
movl $0x2, -0x4(%rbp)
jmp 0x15f8c
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x15f8c
movq -0x10(%rbp), %rdi
movl $0x27, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rdi
callq 0x17c50
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17bc0
movl $0x0, -0x4(%rbp)
jmp 0x15f8c
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rdi
callq 0x17c50
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17bc0
movl $0x0, -0x4(%rbp)
jmp 0x15f8c
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x16836
jmp 0x16788
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x167cb
jmp 0x16791
movl -0x2c(%rbp), %eax
subl $0x22, %eax
je 0x167a8
jmp 0x1679b
movl -0x2c(%rbp), %eax
subl $0x3e, %eax
je 0x167f3
jmp 0x16879
movq -0x10(%rbp), %rdi
movl $0x41, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x17ca0
movl $0x2, -0x4(%rbp)
jmp 0x1688c
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x1688c
movq -0x10(%rbp), %rdi
movl $0x27, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rdi
callq 0x17ca0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17bc0
movl $0x0, -0x4(%rbp)
jmp 0x1688c
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rdi
callq 0x17ca0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17bc0
movl $0x0, -0x4(%rbp)
jmp 0x1688c
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x16a59
jmp 0x16a04
movl -0x2c(%rbp), %eax
addl $-0x9, %eax
subl $0x2, %eax
jb 0x16a2f
jmp 0x16a11
movl -0x2c(%rbp), %eax
subl $0xc, %eax
je 0x16a2f
jmp 0x16a1b
movl -0x2c(%rbp), %eax
subl $0x20, %eax
je 0x16a2f
jmp 0x16a25
movl -0x2c(%rbp), %eax
subl $0x3e, %eax
je 0x16a38
jmp 0x16a93
movl $0x2, -0x4(%rbp)
jmp 0x16ab6
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17bc0
movl $0x1, -0x4(%rbp)
jmp 0x16ab6
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17bc0
movl $0x0, -0x4(%rbp)
jmp 0x16ab6
movq -0x10(%rbp), %rdi
movl $0x23, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0x42, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_bogus_doctype_state
static StateResult handle_bogus_doctype_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  if (c == '>' || c == -1) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
    emit_doctype(parser, output);
    return RETURN_ERROR;
  }
  return NEXT_CHAR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x3e, -0x1c(%rbp)
je 0x16ae3
cmpl $-0x1, -0x1c(%rbp)
jne 0x16b04
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17bc0
movl $0x0, -0x4(%rbp)
jmp 0x16b0b
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x16b64
movq -0x18(%rbp), %rdi
addq $0xe8, %rdi
leaq 0x207ab(%rip), %rsi     # 0x372fa
movl $0x3, %edx
movl $0x1, %ecx
callq 0x65f0
testb $0x1, %al
jne 0x16b64
jmp 0x16b91
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x18(%rbp), %rdi
callq 0x121b0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x0, 0x6(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x16ba6
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x16bd5
jmp 0x16bf4
leaq 0x1f92e(%rip), %rdi     # 0x3650a
leaq 0x1f84d(%rip), %rsi     # 0x36430
movl $0x167, %edx            # imm = 0x167
leaq 0x1fa4a(%rip), %rcx     # 0x36639
callq 0x4100
movq -0x10(%rbp), %rdi
addq $0xe8, %rdi
callq 0x6790
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x5f40
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x5f40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0xe8, %rsi
movl -0xc(%rbp), %edx
xorl %ecx, %ecx
leaq -0x28(%rbp), %r8
callq 0x17df0
andb $0x1, %al
movb %al, -0x29(%rbp)
movl -0x28(%rbp), %eax
leaq 0x227ae(%rip), %rcx     # 0x39620
cmpl (%rcx), %eax
je 0x16e9a
movq -0x20(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x11df0
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x16eac
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x26, %esi
callq 0x11df0
movb -0x29(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: emit_replacement_char
static StateResult emit_replacement_char(
    GumboParser* parser, GumboToken* output) {
  // In all cases, this is because of a null byte in the input stream.
  tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
  emit_char(parser, UNICODE_REPLACEMENT_CHAR, output);
  return RETURN_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x11df0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x21(%rbp)
jne 0x16f94
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4150
cmpl $0x0, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0xe8, %rdi
callq 0x11f40
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x1700d
jmp 0x1700f
jmp 0x1702e
leaq 0x1f6d0(%rip), %rdi     # 0x366e6
leaq 0x1f413(%rip), %rsi     # 0x36430
movl $0x2cc, %edx            # imm = 0x2CC
leaq 0x1f6c9(%rip), %rcx     # 0x366f2
callq 0x4100
movl -0x24(%rbp), %edi
callq 0x17170
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x17047
jmp 0x17049
jmp 0x17068
leaq 0x1f696(%rip), %rdi     # 0x366e6
leaq 0x1f3d9(%rip), %rsi     # 0x36430
movl $0x2ce, %edx            # imm = 0x2CE
leaq 0x1f68f(%rip), %rcx     # 0x366f2
callq 0x4100
movq -0x8(%rbp), %rdi
callq 0x17190
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x5c00
movq -0x20(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x1708a
jmp 0x170a9
leaq 0x1f68a(%rip), %rdi     # 0x3671b
leaq 0x1f398(%rip), %rsi     # 0x36430
movl $0x2d3, %edx            # imm = 0x2D3
leaq 0x1f64e(%rip), %rcx     # 0x366f2
callq 0x4100
movq -0x20(%rbp), %rsi
addq $0x40, %rsi
movl $0x1, %edi
callq 0x69f0
movq -0x20(%rbp), %rax
movb $0x0, 0x50(%rax)
movb -0x9(%rbp), %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x5c(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x5d(%rax)
leaq 0x1f660(%rip), %rdi     # 0x3673f
movb $0x0, %al
callq 0x11c40
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x17119
jmp 0x17138
leaq 0x1f632(%rip), %rdi     # 0x36752
leaq 0x1f309(%rip), %rsi     # 0x36430
movl $0x2a4, %edx            # imm = 0x2A4
leaq 0x1f641(%rip), %rcx     # 0x36774
callq 0x4100
movq -0x18(%rbp), %rdi
addq $0xe8, %rdi
callq 0x67d0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11e40
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5ad0
movq -0x8(%rbp), %rdi
callq 0x17200
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: reset_tag_buffer_start_point
static void reset_tag_buffer_start_point(GumboParser* parser) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  GumboTagState* tag_state = &tokenizer->_tag_state;

  utf8iterator_get_position(&tokenizer->_input, &tag_state->_start_pos);
  tag_state->_original_text = utf8iterator_get_char_pointer(&tokenizer->_input);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0xe8, %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x11a70
movq -0x10(%rbp), %rdi
addq $0xe8, %rdi
callq 0x12200
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x61c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x175a0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x68, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x174f0
testb $0x1, -0xd(%rbp)
je 0x174f0
movq -0x8(%rbp), %rdi
callq 0x17200
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x5c00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x68, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x48(%rcx), %eax
jae 0x1755e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x51a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x17533
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x17d80
movq -0x10(%rbp), %rdi
callq 0x11a30
movq -0x10(%rbp), %rdi
callq 0x5f60
leaq 0x1f3b9(%rip), %rdi     # 0x3693d
movb $0x0, %al
callq 0x11c40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x68, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x5c(%rax)
jne 0x175f8
jmp 0x17617
leaq 0x1f4a8(%rip), %rdi     # 0x36aa7
leaq 0x1ee2a(%rip), %rsi     # 0x36430
movl $0x378, %edx            # imm = 0x378
leaq 0x1f4af(%rip), %rcx     # 0x36ac1
callq 0x4100
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x97, 0x58(%rcx)
movb %al, -0x11(%rbp)
je 0x17654
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x61c0
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: add_duplicate_attr_error
static void add_duplicate_attr_error (
  GumboParser* parser,
  int original_index,
  int new_index
) {
  GumboError* error = gumbo_add_error(parser);
  if (!error) {
    return;
  }
  GumboTagState* tag_state = &parser->_tokenizer_state->_tag_state;
  error->type = GUMBO_ERR_DUPLICATE_ATTR;
  error->position = tag_state->_start_pos;
  error->original_text = tag_state->_original_text;
  error->v.duplicate_attr.original_index = original_index;
  error->v.duplicate_attr.new_index = new_index;
  copy_over_tag_buffer(parser, &error->v.duplicate_attr.name);
  reinitialize_tag_buffer(parser);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5210
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x178b8
jmp 0x17930
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x68, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x18, (%rax)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x30(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x38(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x17940
movq -0x8(%rbp), %rdi
callq 0x175a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: copy_over_original_tag_text
static void copy_over_original_tag_text (
  GumboParser* parser,
  GumboStringPiece* original_text,
  GumboSourcePosition* start_pos,
  GumboSourcePosition* end_pos
) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  GumboTagState* tag_state = &tokenizer->_tag_state;

  original_text->data = tag_state->_original_text;
  original_text->length = utf8iterator_get_char_pointer(&tokenizer->_input) -
                          tag_state->_original_text;
  if (
    original_text->length > 0
    && original_text->data[original_text->length - 1] == '\r'
  ) {
    // Since \r is skipped by the UTF-8 iterator, it can sometimes end up
    // appended to the end of original text even when it's really the first part
    // of the next character. If we detect this situation, shrink the length of
    // the original text by 1 to remove the carriage return.
    --original_text->length;
  }
  *start_pos = tag_state->_start_pos;
  utf8iterator_get_position(&tokenizer->_input, end_pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
addq $0xe8, %rdi
callq 0x12200
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x17a2c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x17a2c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rdx
movq %rdx, (%rax)
movq 0x30(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x38(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdi
addq $0xe8, %rdi
movq -0x20(%rbp), %rsi
callq 0x11a70
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)