LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xedee
cmpl $-0x1, %edx
je 0xee20
cmpl $0x3e, %edx
jne 0xee00
jmp 0xee20
movq %r14, %rdi
movl $0x2, %esi
callq 0x10a60
movl $0xfffd, %edx           # imm = 0xFFFD
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movl %edx, %edi
callq 0x4322
movq %r12, %rdi
callq 0x43e3
movl 0x100(%r15), %edx
jmp 0xedde
movq 0x10(%r14), %rax
movl $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1130e
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf470(%rip), %rsi      # 0x1e2cf
movl $0x2, %edx
movq %r15, %rdi
movl $0x1, %ecx
callq 0x79bb
testb %al, %al
je 0xee88
movq 0x10(%r14), %rax
movl $0x2d, (%rax)
movb $0x1, 0x4(%rbx)
jmp 0xef3d
leaq 0xf443(%rip), %rsi      # 0x1e2d2
movl $0x7, %edx
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x79bb
testb %al, %al
je 0xeee6
movq 0x10(%r14), %rax
movl $0x33, (%rax)
movb $0x1, 0x4(%rbx)
leaq 0x97a1(%rip), %r14      # 0x18658
movq %r14, %rdi
callq 0x113fd
movq %rax, 0xc8(%rbx)
movq %r14, %rdi
callq 0x113fd
movq %rax, 0xd0(%rbx)
movq %r14, %rdi
callq 0x113fd
movq %rax, 0xd8(%rbx)
jmp 0xef3d
cmpb $0x1, 0x5(%rbx)
jne 0xef1d
leaq 0xf3e7(%rip), %rsi      # 0x1e2da
movl $0x7, %edx
movq %r15, %rdi
movl $0x1, %ecx
callq 0x79bb
testb %al, %al
je 0xef1d
movq 0x10(%r14), %rax
movl $0x43, (%rax)
movb $0x1, %al
movb %al, 0x6(%rbx)
movb %al, 0x4(%rbx)
jmp 0xef3d
movq %r14, %rdi
movl $0x1b, %esi
callq 0x10a60
movq 0x10(%r14), %rdi
movl $0x2b, (%rdi)
movb $0x1, 0x4(%rbx)
callq 0x10a14
movl $0x2, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xef8c
cmpl $-0x1, %edx
je 0xefbe
testl %edx, %edx
jne 0xefa2
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%rbx), %rsi
movl $0x2f, (%rsi)
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
jmp 0xefec
cmpl $0x3e, %edx
je 0xefc8
cmpl $0x2d, %edx
jne 0xefa2
movq 0x10(%rbx), %rax
movl $0x2e, (%rax)
jmp 0xefb7
movq 0x10(%rbx), %rsi
movl $0x2f, (%rsi)
addq $0x10, %rsi
movl %edx, %edi
callq 0x4322
movl $0x2, %ebp
jmp 0xefec
movq %rbx, %rdi
movl $0x1c, %esi
jmp 0xefd0
movq %rbx, %rdi
movl $0x1d, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1130e
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_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 0xf10f
testl %edx, %edx
je 0xf0e9
cmpl $0x2d, %edx
jne 0xf138
movq 0x10(%rbx), %rax
movl $0x30, (%rax)
jmp 0xf147
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
jmp 0xf14c
movq %rcx, %r14
movq %rbx, %rdi
movl $0x1c, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1130e
xorl %ebp, %ebp
jmp 0xf14c
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_O3/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 0xf1b7
movl %edx, %ebp
testl %edx, %edx
je 0xf179
cmpl $0x2d, %ebp
jne 0xf1e0
movq 0x10(%rbx), %rax
movl $0x31, (%rax)
jmp 0xf207
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
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 0xf20c
movq %rcx, %r14
movq %rbx, %rdi
movl $0x1c, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1130e
xorl %ebp, %ebp
jmp 0xf20c
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_O3/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 0xf25e
cmpl $0x21, %ebp
je 0xf2c2
cmpl $0x2d, %ebp
je 0xf2de
cmpl $0x3e, %ebp
jne 0xf320
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1130e
movl $0x1, %ebp
jmp 0xf36b
cmpl $-0x1, %ebp
je 0xf2fa
testl %ebp, %ebp
jne 0xf320
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
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 0xf36b
movq %rbx, %rdi
movl $0x1e, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x32, (%rax)
jmp 0xf366
movq %rbx, %rdi
movl $0x1f, %esi
callq 0x10a60
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x2d, %edi
jmp 0xf361
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1130e
xorl %ebp, %ebp
jmp 0xf36b
movq %rbx, %rdi
movl $0x1d, %esi
callq 0x10a60
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_O3/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 0xf3f9
cmpl $-0x1, %ebp
je 0xf492
testl %ebp, %ebp
jne 0xf440
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
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 0xf4d2
cmpl $0x3e, %ebp
je 0xf4b8
cmpl $0x2d, %ebp
jne 0xf440
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 0xf486
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 0xf4d2
movq %rbx, %rdi
movl $0x21, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1130e
xorl %ebp, %ebp
jmp 0xf4d2
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1130e
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_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 0xf5b4
movq %rsi, %r15
movq %rdi, %rbx
incl %edx
cmpl $0x21, %edx
ja 0xf58b
movabsq $0x200002c00, %rax      # imm = 0x200002C00
btq %rdx, %rax
jae 0xf528
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 0xf58b
movq %rcx, %r14
movq %rbx, %rdi
movl $0x22, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
xorl %ebp, %ebp
movl %ebp, (%rax)
movb $0x1, 0xe0(%r15)
movl %ebp, (%r14)
movups 0xc8(%rax), %xmm0
movups 0xd8(%rax), %xmm1
movups %xmm0, 0x30(%r14)
movups %xmm1, 0x40(%r14)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xca0d
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
jmp 0xf51b
movq %rbx, %rdi
movl $0x24, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x34, (%rax)
movb $0x1, %al
movb %al, 0x4(%r15)
movb %al, 0xe0(%r15)
jmp 0xf516
leaq 0xed27(%rip), %rdi      # 0x1e2e2
leaq 0xe2a2(%rip), %rsi      # 0x1d864
leaq 0xed3e(%rip), %rcx      # 0x1e307
movl $0x9af, %edx            # imm = 0x9AF
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/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 0xf61d
movl %edx, %eax
movabsq $0x100001600, %rcx      # imm = 0x100001600
btq %rax, %rcx
jb 0xf6d8
testq %rax, %rax
je 0xf6aa
cmpq $0x3e, %rax
jne 0xf61d
movq %r14, %rdi
movl $0x25, %esi
jmp 0xf62a
cmpl $-0x1, %edx
jne 0xf67e
movq %r14, %rdi
movl $0x22, %esi
callq 0x10a60
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 0x10(%r14), %rdi
movq %r15, %rsi
callq 0xca0d
movq 0x10(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
jmp 0xf6d8
movq 0x10(%r14), %rsi
movl $0x35, (%rsi)
movb $0x0, 0xe0(%r12)
movzbl %dl, %eax
leaq 0x8ab5(%rip), %rcx      # 0x18150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
addq $0x10, %rsi
jmp 0xf6d3
movq %r14, %rdi
movl $0x2, %esi
callq 0x10a60
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_O3/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 0xf968
movabsq $0x200002c00, %rax      # imm = 0x200002C00
btq %rdx, %rax
jae 0xf908
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rcx, %r12
testq %rdx, %rdx
je 0xf998
cmpq $0x3f, %rdx
jne 0xf968
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 0x10(%r14), %rdi
movq %r12, %rsi
callq 0xca0d
movq 0x10(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
movl $0x1, %ebx
jmp 0xf8fa
leaq 0xe8(%r15), %r12
leaq 0xe9eb(%rip), %rsi      # 0x1e361
movl $0x6, %edx
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x79bb
testb %al, %al
je 0xf9f9
movq 0x10(%r14), %rax
movl $0x37, (%rax)
jmp 0xfa1d
movq %r14, %rdi
movl $0x22, %esi
callq 0x10a60
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 0x10(%r14), %rdi
movq %r12, %rsi
callq 0xca0d
movq 0x10(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
jmp 0xf8fa
leaq 0xe968(%rip), %rsi      # 0x1e368
movl $0x6, %edx
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x79bb
testb %al, %al
je 0xfa27
movq 0x10(%r14), %rax
movl $0x3d, (%rax)
movb $0x1, 0x4(%r15)
jmp 0xf8fa
movq %r14, %rdi
movl $0x26, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movl $0x42, (%rax)
movb $0x1, 0xe0(%r15)
jmp 0xf8fa
// File: /workspace/github_c_makefile_star2_O3/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 0xfdef
cmpl $-0x1, %edx
je 0xfe23
testl %edx, %edx
jne 0xfe0d
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
jmp 0xfe92
cmpl $0x3e, %edx
je 0xfe2d
cmpl $0x22, %edx
jne 0xfe0d
movq 0x10(%rbx), %rax
movl $0x3b, (%rax)
movq %rbx, %rdi
callq 0x1134b
jmp 0xfe1c
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl %edx, %edi
callq 0x4322
movl $0x2, %ebp
jmp 0xfe92
movq %rbx, %rdi
movl $0x22, %esi
jmp 0xfe35
movq %rbx, %rdi
movl $0x27, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
xorl %ebp, %ebp
movl %ebp, (%rax)
movb $0x1, 0xe0(%r15)
movq %rbx, %rdi
callq 0x1134b
movl %ebp, (%r14)
movq 0x10(%rbx), %rax
movups 0xc8(%rax), %xmm0
movups 0xd8(%rax), %xmm1
movups %xmm1, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xca0d
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
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_doctype_system_id_double_quoted_state
static StateResult handle_doctype_system_id_double_quoted_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '"':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_DOCTYPE_SYSTEM_ID);
      finish_doctype_system_id(parser);
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_temporary_buffer(parser, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case '>':
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_END);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      finish_doctype_system_id(parser);
      emit_doctype(parser, output);
      return RETURN_ERROR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      finish_doctype_system_id(parser);
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x21, %edx
jg 0x1066d
cmpl $-0x1, %edx
je 0x106a1
testl %edx, %edx
jne 0x1068b
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0xfffd, %edi           # imm = 0xFFFD
callq 0x4322
jmp 0x10710
cmpl $0x3e, %edx
je 0x106ab
cmpl $0x22, %edx
jne 0x1068b
movq 0x10(%rbx), %rax
movl $0x41, (%rax)
movq %rbx, %rdi
callq 0x1138f
jmp 0x1069a
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl %edx, %edi
callq 0x4322
movl $0x2, %ebp
jmp 0x10710
movq %rbx, %rdi
movl $0x22, %esi
jmp 0x106b3
movq %rbx, %rdi
movl $0x27, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
xorl %ebp, %ebp
movl %ebp, (%rax)
movb $0x1, 0xe0(%r15)
movq %rbx, %rdi
callq 0x1138f
movl %ebp, (%r14)
movq 0x10(%rbx), %rax
movups 0xc8(%rax), %xmm0
movups 0xd8(%rax), %xmm1
movups %xmm1, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xca0d
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
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_after_doctype_system_id_state
static StateResult handle_after_doctype_system_id_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      return NEXT_CHAR;
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      emit_doctype(parser, output);
      return RETURN_SUCCESS;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_doc_type_state.force_quirks = true;
      emit_doctype(parser, output);
      return RETURN_ERROR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_DOCTYPE_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_DOCTYPE);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, %ebp
incl %edx
cmpl $0x3f, %edx
ja 0x108a0
movabsq $0x200002c00, %rax      # imm = 0x200002C00
btq %rdx, %rax
jae 0x10847
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r14
testq %rdx, %rdx
je 0x108b9
cmpq $0x3f, %rdx
jne 0x108a0
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movl %ecx, (%r14)
movups 0xc8(%rax), %xmm0
movups 0xd8(%rax), %xmm1
movups %xmm0, 0x30(%r14)
movups %xmm1, 0x40(%r14)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xca0d
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
movl $0x1, %ebp
jmp 0x1083a
movq %rbx, %rdi
movl $0x23, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x42, (%rax)
jmp 0x1083a
movq %rsi, %r15
movq %rbx, %rdi
movl $0x22, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
xorl %ebp, %ebp
movl %ebp, (%rax)
movb $0x1, 0xe0(%r15)
movl %ebp, (%r14)
movups 0xc8(%rax), %xmm0
movups 0xd8(%rax), %xmm1
movups %xmm0, 0x30(%r14)
movups %xmm1, 0x40(%r14)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xca0d
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
jmp 0x1083a
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3e, %edx
je 0x1092f
movl $0x2, %ebp
cmpl $-0x1, %edx
jne 0x10970
movq 0x10(%rbx), %rax
xorl %ebp, %ebp
movl %ebp, (%rax)
movl %ebp, (%rcx)
movups 0xc8(%rax), %xmm0
movups 0xd8(%rax), %xmm1
movups %xmm0, 0x30(%rcx)
movups %xmm1, 0x40(%rcx)
movq 0x10(%rbx), %rdi
movq %rcx, %rsi
callq 0xca0d
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_cdata_state
static StateResult handle_cdata_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  if (c == -1 || utf8iterator_maybe_consume_literal(&tokenizer->_input, "]]>")) {
    tokenizer->_reconsume_current_input = true;
    reset_token_start_point(tokenizer);
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
    tokenizer->_is_in_cdata = false;
    return NEXT_CHAR;
  } else {
    return emit_current_char(parser, output);
  }
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
leaq 0xe8(%r12), %rsi
leaq 0x8(%rsp), %r15
movl $0x20, %edx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x1142c
movl %eax, %ebp
movl (%r15), %esi
leaq 0xfe42(%rip), %rax      # 0x20940
cmpl (%rax), %esi
jne 0x10b24
movq 0x10(%r14), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%rbx)
movl $0x26, 0x30(%rbx)
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
jmp 0x10b3e
movb $0x1, 0x4(%r12)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
movl 0xc(%rsp), %eax
movl %eax, 0x8(%r12)
movzbl %bpl, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: start_new_tag
static void start_new_tag(GumboParser* parser, bool is_start_tag) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  GumboTagState* tag_state = &tokenizer->_tag_state;
  int c = utf8iterator_current(&tokenizer->_input);
  assert(is_alpha(c));
  c = ensure_lowercase(c);
  assert(is_alpha(c));

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x10(%rdi), %r12
movl 0x100(%r12), %eax
movl %eax, %ecx
orl $0x20, %ecx
addl $-0x61, %ecx
cmpl $0x1a, %ecx
jae 0x10c25
movzbl %al, %ecx
leaq 0x75d2(%rip), %rdx      # 0x18150
movzbl (%rdx,%rcx), %ecx
andl $0x20, %ecx
movzbl %al, %ebp
orl %ecx, %ebp
movl %ebp, %eax
orl $0x20, %eax
addl $-0x61, %eax
cmpl $0x1a, %eax
jae 0x10c44
movl %esi, %ebx
movq %rdi, %r14
leaq 0x68(%r12), %r15
movq %r15, %rdi
callq 0x7470
movq 0x10(%r14), %rax
movq 0x120(%rax), %rcx
movq %rcx, 0xa0(%rax)
movups 0x110(%rax), %xmm0
movups %xmm0, 0x90(%rax)
movq 0xe8(%rax), %rcx
movq %rcx, 0x80(%rax)
movl %ebp, %edi
movq %r15, %rsi
callq 0x4322
cmpq $0x0, 0xa8(%r12)
jne 0x10c63
leaq 0xa8(%r12), %rsi
movl $0x1, %edi
callq 0x7af0
xorl %eax, %eax
movb %al, 0xb8(%r12)
movb %bl, 0xc4(%r12)
movb %al, 0xc5(%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xce81(%rip), %rdi      # 0x1daad
leaq 0xcc31(%rip), %rsi      # 0x1d864
leaq 0xce7f(%rip), %rcx      # 0x1dab9
movl $0x2cc, %edx            # imm = 0x2CC
callq 0x4100
leaq 0xce62(%rip), %rdi      # 0x1daad
leaq 0xcc12(%rip), %rsi      # 0x1d864
leaq 0xce60(%rip), %rcx      # 0x1dab9
movl $0x2ce, %edx            # imm = 0x2CE
callq 0x4100
leaq 0xce78(%rip), %rdi      # 0x1dae2
leaq 0xcbf3(%rip), %rsi      # 0x1d864
leaq 0xce41(%rip), %rcx      # 0x1dab9
movl $0x2d3, %edx            # imm = 0x2D3
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: emit_temporary_buffer
static bool emit_temporary_buffer(GumboParser* parser, GumboToken* output) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  assert(tokenizer->_temporary_buffer.data);
  utf8iterator_reset(&tokenizer->_input);
  tokenizer->_temporary_buffer_emit = tokenizer->_temporary_buffer.data;
  return maybe_emit_from_temporary_buffer(parser, output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r15
cmpq $0x0, 0x10(%r15)
je 0x10cbc
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe8(%r15), %rdi
callq 0x7a58
movq 0x10(%r15), %rax
movq %rax, 0x28(%r15)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xc919
leaq 0xce43(%rip), %rdi      # 0x1db06
leaq 0xcb9a(%rip), %rsi      # 0x1d864
leaq 0xce57(%rip), %rcx      # 0x1db28
movl $0x2a4, %edx            # imm = 0x2A4
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: finish_tag_name
static void finish_tag_name(GumboParser* parser) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  GumboTagState* tag_state = &tokenizer->_tag_state;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0x68(%r14), %rdi
movq 0x70(%r14), %rsi
callq 0x77cb
movl %eax, 0x88(%r14)
movq 0x10(%rbx), %rax
movq 0x68(%rax), %rdi
callq 0x113f8
movq 0x10(%rbx), %rdi
addq $0x68, %rdi
callq 0x7470
movq 0x10(%rbx), %rax
movq 0x120(%rax), %rcx
movq %rcx, 0xa0(%rax)
movups 0x110(%rax), %xmm0
movups %xmm0, 0x90(%rax)
movq 0xe8(%rax), %rcx
movq %rcx, 0x80(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: abandon_current_tag
static void abandon_current_tag(GumboParser* parser) {
  GumboTagState* tag_state = &parser->_tokenizer_state->_tag_state;
  for (unsigned int i = 0; i < tag_state->_attributes.length; ++i) {
    gumbo_destroy_attribute(tag_state->_attributes.data[i]);
  }
  gumbo_free(tag_state->_attributes.data);
  mark_tag_state_as_empty(tag_state);
  gumbo_string_buffer_destroy(&tag_state->_buffer);
  gumbo_debug("Abandoning current tag.\n");
}

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

// Assembly:
pushq %rbx
cmpb $0x1, 0xc4(%rdi)
je 0x10f49
movl 0xc0(%rdi), %ebx
cmpl $0x97, %ebx
jne 0x10f32
xorl %eax, %eax
jmp 0x10f47
movq 0x68(%rdi), %rax
movq 0x70(%rdi), %rsi
movq %rax, %rdi
callq 0x77cb
cmpl %eax, %ebx
sete %al
popq %rbx
retq
leaq 0xceaf(%rip), %rdi      # 0x1ddff
leaq 0xc90d(%rip), %rsi      # 0x1d864
leaq 0xcebb(%rip), %rcx      # 0x1de19
movl $0x378, %edx            # imm = 0x378
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: finish_attribute_value
static void finish_attribute_value(GumboParser* parser) {
  GumboTagState* tag_state = &parser->_tokenizer_state->_tag_state;
  if (tag_state->_drop_next_attr_value) {
    // Duplicate attribute name detected in an earlier state, so we have to
    // ignore the value.
    tag_state->_drop_next_attr_value = false;
    reinitialize_tag_buffer(parser);
    return;
  }

  GumboAttribute* attr =
      tag_state->_attributes.data[tag_state->_attributes.length - 1];
  gumbo_free((void*) attr->value);
  copy_over_tag_buffer(parser, &attr->value);
  copy_over_original_tag_text(
      parser, &attr->original_value, &attr->value_start, &attr->value_end);
  reinitialize_tag_buffer(parser);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpb $0x1, 0xb8(%rax)
jne 0x1122f
movb $0x0, 0xb8(%rax)
jmp 0x112c2
movq 0xa8(%rax), %rcx
movl 0xb0(%rax), %eax
decl %eax
movq (%rcx,%rax,8), %r14
movq 0x20(%r14), %rdi
callq 0x113f8
movq 0x10(%rbx), %rdi
addq $0x68, %rdi
callq 0x7648
movq %rax, 0x20(%r14)
leaq 0x68(%r14), %rdx
leaq 0x80(%r14), %rax
movq 0x10(%rbx), %rcx
movq 0x80(%rcx), %rdi
movq %rdi, 0x28(%r14)
movq 0xe8(%rcx), %rsi
subq %rdi, %rsi
movq %rsi, 0x30(%r14)
je 0x11294
cmpb $0xd, -0x1(%rdi,%rsi)
jne 0x11294
decq %rsi
movq %rsi, 0x30(%r14)
movq 0xa0(%rcx), %rsi
movq %rsi, 0x10(%rdx)
movups 0x90(%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x120(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups 0x110(%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rbx), %rax
movq 0x68(%rax), %rdi
callq 0x113f8
movq 0x10(%rbx), %rdi
addq $0x68, %rdi
callq 0x7470
movq 0x10(%rbx), %rax
movq 0x120(%rax), %rcx
movq %rcx, 0xa0(%rax)
movups 0x110(%rax), %xmm0
movups %xmm0, 0x90(%rax)
movq 0xe8(%rax), %rcx
movq %rcx, 0x80(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: emit_comment
static StateResult emit_comment(GumboParser* parser, GumboToken* output) {
  output->type = GUMBO_TOKEN_COMMENT;
  finish_temporary_buffer(parser, &output->v.text);
  finish_token(parser, output);
  return RETURN_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, (%rsi)
movq 0x10(%rdi), %rdi
addq $0x10, %rdi
callq 0x7648
movq %rax, 0x30(%rbx)
movq 0x10(%r14), %rdi
callq 0x10a14
movq 0x10(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xca0d
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: finish_doctype_public_id
static void finish_doctype_public_id(GumboParser* parser) {
  GumboTokenDocType* doc_type_state =
      &parser->_tokenizer_state->_doc_type_state;
  gumbo_free((void*) doc_type_state->public_identifier);
  finish_temporary_buffer(parser, &doc_type_state->public_identifier);
  doc_type_state->has_public_identifier = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0xd0(%r14), %rdi
callq 0x113f8
movq 0x10(%rbx), %rdi
addq $0x10, %rdi
callq 0x7648
movq %rax, 0xd0(%r14)
movq 0x10(%rbx), %rdi
callq 0x10a14
movb $0x1, 0xe1(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: finish_doctype_system_id
static void finish_doctype_system_id(GumboParser* parser) {
  GumboTokenDocType* doc_type_state =
      &parser->_tokenizer_state->_doc_type_state;
  gumbo_free((void*) doc_type_state->system_identifier);
  finish_temporary_buffer(parser, &doc_type_state->system_identifier);
  doc_type_state->has_system_identifier = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0xd8(%r14), %rdi
callq 0x113f8
movq 0x10(%rbx), %rdi
addq $0x10, %rdi
callq 0x7648
movq %rax, 0xd8(%r14)
movq 0x10(%rbx), %rdi
callq 0x10a14
movb $0x1, 0xe2(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/util.c
// Function: gumbo_alloc
void* gumbo_alloc(size_t size) {
  void* ptr = malloc(size);
  if (unlikely(ptr == NULL)) {
    perror(__func__);
    abort();
  }
  return ptr;
}

// Assembly:
pushq %rax
callq 0x41c0
testq %rax, %rax
je 0x113e1
popq %rcx
retq
callq 0x42fe
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/util.c
// Function: gumbo_realloc
void* gumbo_realloc(void* ptr, size_t size) {
  ptr = realloc(ptr, size);
  if (unlikely(ptr == NULL)) {
    perror(__func__);
    abort();
  }
  return ptr;
}

// Assembly:
pushq %rax
callq 0x4210
testq %rax, %rax
je 0x113f3
popq %rcx
retq
callq 0x4310
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/util.c
// Function: gumbo_strdup
char* gumbo_strdup(const char* str) {
  const size_t size = strlen(str) + 1;
  // The strdup(3) function isn't available in strict "-std=c99" mode
  // (it's part of POSIX, not C99), so use malloc(3) and memcpy(3)
  // instead:
  char* buffer = gumbo_alloc(size);
  return memcpy(buffer, str, size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x40b0
leaq 0x1(%rax), %r14
movq %r14, %rdi
callq 0x113d4
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4190
nop