LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: get_current_node
static GumboNode* get_current_node(const GumboParser* parser) {
  const GumboVector* open_elements = &parser->_parser_state->_open_elements;
  if (open_elements->length == 0) {
    assert(!parser->_output->root);
    return NULL;
  }
  assert(open_elements->length > 0);
  assert(open_elements->data != NULL);
  return open_elements->data[open_elements->length - 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x75b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x7587
jmp 0x75a6
leaq 0x2be27(%rip), %rdi     # 0x333b5
leaq 0x2b8df(%rip), %rsi     # 0x32e74
movl $0x1dd, %edx            # imm = 0x1DD
leaq 0x2be2b(%rip), %rcx     # 0x333cc
callq 0x4100
movq $0x0, -0x8(%rbp)
jmp 0x7621
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jbe 0x75bc
jmp 0x75db
leaq 0x2be3a(%rip), %rdi     # 0x333fd
leaq 0x2b8aa(%rip), %rsi     # 0x32e74
movl $0x1e0, %edx            # imm = 0x1E0
leaq 0x2bdf6(%rip), %rcx     # 0x333cc
callq 0x4100
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x75e7
jmp 0x7606
leaq 0x2be29(%rip), %rdi     # 0x33417
leaq 0x2b87f(%rip), %rsi     # 0x32e74
movl $0x1e1, %edx            # imm = 0x1E1
leaq 0x2bdcb(%rip), %rcx     # 0x333cc
callq 0x4100
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: finish_parsing
static void finish_parsing(GumboParser* parser) {
  gumbo_debug("Finishing parsing");
  maybe_flush_text_node_buffer(parser);
  GumboParserState* state = parser->_parser_state;
  for (
    GumboNode* node = pop_current_node(parser);
    node;
    node = pop_current_node(parser)
  ) {
    if (
      (node_html_tag_is(node, GUMBO_TAG_BODY) && state->_closed_body_tag)
      || (node_html_tag_is(node, GUMBO_TAG_HTML) && state->_closed_html_tag)
    ) {
      continue;
    }
    node->parse_flags |= GUMBO_INSERTION_IMPLICIT_END_TAG;
  }
  while (pop_current_node(parser)) {
    // Pop them all.
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2d793(%rip), %rdi     # 0x351d6
movb $0x0, %al
callq 0x7540
movq -0x8(%rbp), %rdi
callq 0x8030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7ad0
movq -0x18(%rbp), %rdi
movl $0xa, %esi
callq 0x8700
testb $0x1, %al
jne 0x7a87
jmp 0x7a94
movq -0x10(%rbp), %rax
testb $0x1, 0xa0(%rax)
jne 0x7ab2
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x8700
testb $0x1, %al
jne 0x7aa5
jmp 0x7ab4
movq -0x10(%rbp), %rax
testb $0x1, 0xa1(%rax)
je 0x7ab4
jmp 0x7ac1
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
callq 0xf060
movq %rax, -0x18(%rbp)
jmp 0x7a6c
jmp 0x7ad2
movq -0x8(%rbp), %rdi
callq 0xf060
cmpq $0x0, %rax
je 0x7ae3
jmp 0x7ad2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: parser_state_destroy
static void parser_state_destroy(GumboParser* parser) {
  GumboParserState* state = parser->_parser_state;
  if (state->_fragment_ctx) {
    destroy_node(state->_fragment_ctx);
  }
  gumbo_vector_destroy(&state->_active_formatting_elements);
  gumbo_vector_destroy(&state->_open_elements);
  gumbo_vector_destroy(&state->_template_insertion_modes);
  gumbo_string_buffer_destroy(&state->_text_node._buffer);
  gumbo_free(state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x7b20
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x7bf0
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x6a50
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x6a50
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x6a50
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x5f60
movq -0x10(%rbp), %rdi
callq 0x17d80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: gumbo_status_to_string
const char* gumbo_status_to_string(GumboOutputStatus status) {
  switch (status) {
    case GUMBO_STATUS_OK:
      return "OK";
    case GUMBO_STATUS_OUT_OF_MEMORY:
      return "System allocator returned NULL during parsing";
    case GUMBO_STATUS_TREE_TOO_DEEP:
      return "Document tree depth limit exceeded";
    default:
      return "Unknown GumboOutputStatus value";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x7b97
jmp 0x7b83
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x7bb1
jmp 0x7b8d
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x7ba4
jmp 0x7bbe
leaq 0x2b36b(%rip), %rax     # 0x32f09
movq %rax, -0x8(%rbp)
jmp 0x7bc9
leaq 0x2b361(%rip), %rax     # 0x32f0c
movq %rax, -0x8(%rbp)
jmp 0x7bc9
leaq 0x2b382(%rip), %rax     # 0x32f3a
movq %rax, -0x8(%rbp)
jmp 0x7bc9
leaq 0x2b398(%rip), %rax     # 0x32f5d
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: gumbo_destroy_output
void gumbo_destroy_output(GumboOutput* output) {
  destroy_node(output->document);
  for (unsigned int i = 0; i < output->errors.length; ++i) {
    gumbo_error_destroy(output->errors.data[i]);
  }
  gumbo_vector_destroy(&output->errors);
  gumbo_free(output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x7bf0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x7c6a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x5930
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7c3f
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x6a50
movq -0x8(%rbp), %rdi
callq 0x17d80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: new_document_node
static GumboNode* new_document_node() {
  GumboNode* document_node = create_node(GUMBO_NODE_DOCUMENT);
  document_node->parse_flags = GUMBO_INSERTION_BY_PARSER;
  gumbo_vector_init(1, &document_node->v.document.children);

  // Must be initialized explicitly, as there's no guarantee that we'll see a
  // doc type token.
  GumboDocument* document = &document_node->v.document;
  document->has_doctype = false;
  document->name = NULL;
  document->public_identifier = NULL;
  document->system_identifier = NULL;
  return document_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
callq 0x7d10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movl $0x1, %edi
callq 0x69f0
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: create_node
static GumboNode* create_node(GumboNodeType type) {
  GumboNode* node = gumbo_alloc(sizeof(GumboNode));
  node->parent = NULL;
  node->index_within_parent = -1;
  node->type = type;
  node->parse_flags = GUMBO_INSERTION_NORMAL;
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x90, %edi
callq 0x17cf0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: create_element
static GumboNode* create_element(GumboParser* parser, GumboTag tag) {
  GumboNode* node = create_node(GUMBO_NODE_ELEMENT);
  GumboElement* element = &node->v.element;
  gumbo_vector_init(1, &element->children);
  gumbo_vector_init(0, &element->attributes);
  element->tag = tag;
  element->tag_namespace = GUMBO_NAMESPACE_HTML;
  element->original_tag = STRING_PIECE_INIT;
  element->original_end_tag = STRING_PIECE_INIT;
  element->start_pos = (parser->_parser_state->_current_token)
    ? parser->_parser_state->_current_token->position
    : kGumboEmptySourcePosition
  ;
  element->end_pos = kGumboEmptySourcePosition;
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
callq 0x7d10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x69f0
movq -0x20(%rbp), %rsi
addq $0x68, %rsi
xorl %edi, %edi
callq 0x69f0
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x20(%rbp), %rax
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x98(%rax)
je 0x7e4d
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x98(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x7e71
movq -0x48(%rbp), %rax
movq 0x28968(%rip), %rcx     # 0x307c0
movq %rcx, (%rax)
movq 0x28966(%rip), %rcx     # 0x307c8
movq %rcx, 0x8(%rax)
movq 0x28963(%rip), %rcx     # 0x307d0
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x28944(%rip), %rcx     # 0x307c0
movq %rcx, 0x50(%rax)
movq 0x28941(%rip), %rcx     # 0x307c8
movq %rcx, 0x58(%rax)
movq 0x2893e(%rip), %rcx     # 0x307d0
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: insert_element_of_tag_type
static GumboNode* insert_element_of_tag_type (
  GumboParser* parser,
  GumboTag tag,
  GumboParseFlags reason
) {
  GumboNode* element = create_element(parser, tag);
  element->parse_flags |= GUMBO_INSERTION_BY_PARSER | reason;
  insert_element(parser, element, false);
  gumbo_debug (
    "Inserting %s element (@%p) from tag type.\n",
    gumbo_normalized_tagname(tag),
    (void*)element
  );
  return element;
}

// 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
movl -0xc(%rbp), %esi
callq 0x7d60
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %ecx
orl $0x1, %ecx
movq -0x18(%rbp), %rax
orl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x7fc0
movl -0xc(%rbp), %edi
callq 0x5f80
movq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq 0x2b0ec(%rip), %rdi     # 0x32fe3
movb $0x0, %al
callq 0x7540
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: reset_insertion_mode_appropriately
static void reset_insertion_mode_appropriately(GumboParser* parser) {
  const GumboVector* open_elements = &parser->_parser_state->_open_elements;
  for (int i = open_elements->length; --i >= 0;) {
    GumboInsertionMode mode = get_appropriate_insertion_mode(parser, i);
    if (mode != GUMBO_INSERTION_MODE_INITIAL) {
      set_insertion_mode(parser, mode);
      return;
    }
  }
  // Should never get here, because is_last will be set on the last iteration
  // and will force GUMBO_INSERTION_MODE_IN_BODY.
  assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x7f9d
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8910
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x7f9b
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x8b40
addq $0x20, %rsp
popq %rbp
retq
jmp 0x7f66
leaq 0x2cf4b(%rip), %rdi     # 0x34eef
leaq 0x2aec9(%rip), %rsi     # 0x32e74
movl $0x2bd, %edx            # imm = 0x2BD
leaq 0x2b335(%rip), %rcx     # 0x332ec
callq 0x4100
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: insert_element
static void insert_element (
  GumboParser* parser,
  GumboNode* node,
  bool is_reconstructing_formatting_elements
) {
  GumboParserState* state = parser->_parser_state;
  // NOTE(jdtang): The text node buffer must always be flushed before inserting
  // a node, otherwise we're handling nodes in a different order than the spec
  // mandated. However, one clause of the spec (character tokens in the body)
  // requires that we reconstruct the active formatting elements *before* adding
  // the character, and reconstructing the active formatting elements may itself
  // result in the insertion of new elements (which should be pushed onto the
  // stack of open elements before the buffer is flushed). We solve this (for
  // the time being, the spec has been rewritten for <template> and the new
  // version may be simpler here) with a boolean flag to this method.
  if (!is_reconstructing_formatting_elements) {
    maybe_flush_text_node_buffer(parser);
  }
  InsertionLocation location = get_appropriate_insertion_location(parser, NULL);
  insert_node(node, location);
  gumbo_vector_add((void*) node, &state->_open_elements);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7ff2
movq -0x8(%rbp), %rdi
callq 0x8030
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x81d0
movq %rax, -0x30(%rbp)
movl %edx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0x8420
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x6a80
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: node_tag_in_set
static bool node_tag_in_set(const GumboNode* node, const TagSet* tags) {
  assert(node != NULL);
  if (node->type != GUMBO_NODE_ELEMENT && node->type != GUMBO_NODE_TEMPLATE) {
    return false;
  }
  return tagset_includes (
    tags,
    node->v.element.tag_namespace,
    node->v.element.tag
  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8699
jmp 0x86b8
leaq 0x2c97f(%rip), %rdi     # 0x3501f
leaq 0x2a7cd(%rip), %rsi     # 0x32e74
movl $0x247, %edx            # imm = 0x247
leaq 0x2aa54(%rip), %rcx     # 0x33107
callq 0x4100
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x86d0
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
je 0x86d0
movb $0x0, -0x1(%rbp)
jmp 0x86ec
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edx
callq 0x8730
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: node_qualified_tag_is
static bool node_qualified_tag_is (
  const GumboNode* node,
  GumboNamespaceEnum ns,
  GumboTag tag
) {
  assert(node);
  return
    (node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE)
    && node->v.element.tag == tag
    && node->v.element.tag_namespace == ns;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x878b
jmp 0x87aa
leaq 0x2c1a4(%rip), %rdi     # 0x34936
leaq 0x2a6db(%rip), %rsi     # 0x32e74
movl $0x258, %edx            # imm = 0x258
leaq 0x2a99b(%rip), %rcx     # 0x33140
callq 0x4100
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0x87c1
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x6, (%rcx)
movb %al, -0x11(%rbp)
jne 0x87e2
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x11(%rbp)
jne 0x87e2
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
cmpl -0xc(%rbp), %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: append_node
static void append_node(GumboNode* parent, GumboNode* node) {
  assert(node->parent == NULL);
  assert(node->index_within_parent == (unsigned int) -1);
  GumboVector* children;
  if (
    parent->type == GUMBO_NODE_ELEMENT
    || parent->type == GUMBO_NODE_TEMPLATE
  ) {
    children = &parent->v.element.children;
  } else {
    assert(parent->type == GUMBO_NODE_DOCUMENT);
    children = &parent->v.document.children;
  }
  node->parent = parent;
  node->index_within_parent = children->length;
  gumbo_vector_add((void*) node, children);
  assert(node->index_within_parent < children->length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x880d
jmp 0x882c
leaq 0x2a979(%rip), %rdi     # 0x3318d
leaq 0x2a659(%rip), %rsi     # 0x32e74
movl $0x34e, %edx            # imm = 0x34E
leaq 0x2aa76(%rip), %rcx     # 0x3329d
callq 0x4100
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x10(%rax)
jne 0x8838
jmp 0x8857
leaq 0x2a994(%rip), %rdi     # 0x331d3
leaq 0x2a62e(%rip), %rsi     # 0x32e74
movl $0x34f, %edx            # imm = 0x34F
leaq 0x2aa4b(%rip), %rcx     # 0x3329d
callq 0x4100
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0x8869
movq -0x8(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x8877
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x88ad
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8882
jmp 0x88a1
leaq 0x2aa3f(%rip), %rdi     # 0x332c8
leaq 0x2a5e4(%rip), %rsi     # 0x32e74
movl $0x357, %edx            # imm = 0x357
leaq 0x2aa01(%rip), %rcx     # 0x3329d
callq 0x4100
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6a80
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x88e6
jmp 0x8905
leaq 0x2a953(%rip), %rdi     # 0x33240
leaq 0x2a580(%rip), %rsi     # 0x32e74
movl $0x35d, %edx            # imm = 0x35D
leaq 0x2a99d(%rip), %rcx     # 0x3329d
callq 0x4100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: get_current_template_insertion_mode
static GumboInsertionMode get_current_template_insertion_mode (
  const GumboParser* parser
) {
  GumboVector* modes = &parser->_parser_state->_template_insertion_modes;
  if (modes->length == 0) {
    return GUMBO_INSERTION_MODE_INITIAL;
  }
  return (GumboInsertionMode) modes->data[(modes->length - 1)];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x8bab
movl $0x0, -0x4(%rbp)
jmp 0x8bc5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: ignore_token
static void ignore_token(GumboParser* parser) {
  GumboToken* token = parser->_parser_state->_current_token;
  // Ownership of the token's internal buffers are normally transferred to the
  // element, but if no element is emitted (as happens in non-verbatim-mode
  // when a token is ignored), we need to free it here to prevent a memory
  // leak.
  gumbo_token_destroy(token);
#ifndef NDEBUG
  if (token->type == GUMBO_TOKEN_START_TAG) {
    // Mark this sentinel so the assertion in the main loop knows it's been
    // destroyed.
    token->v.start_tag.attributes = GUMBO_VECTOR_INIT;
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x98(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11f60
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x8c2b
movq -0x10(%rbp), %rax
movq $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: tag_is
static bool tag_is(const GumboToken* token, bool is_start, GumboTag tag) {
  if (is_start && token->type == GUMBO_TOKEN_START_TAG) {
    return token->v.start_tag.tag == tag;
  } else if (!is_start && token->type == GUMBO_TOKEN_END_TAG) {
    return token->v.end_tag == tag;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
je 0x8c76
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x8c76
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
cmpl -0x18(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x8c9d
testb $0x1, -0x11(%rbp)
jne 0x8c99
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x8c99
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
cmpl -0x18(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x8c9d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: get_adjusted_current_node
static GumboNode* get_adjusted_current_node(const GumboParser* parser) {
  const GumboParserState* state = parser->_parser_state;
  if (state->_open_elements.length == 1 && state->_fragment_ctx) {
    return state->_fragment_ctx;
  }
  return get_current_node(parser);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x8ceb
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x8ceb
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8cf8
movq -0x10(%rbp), %rdi
callq 0x7550
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: tag_in
static bool tag_in (
  const GumboToken* token,
  bool is_start,
  const TagSet* tags
) {
  GumboTag token_tag;
  if (is_start && token->type == GUMBO_TOKEN_START_TAG) {
    token_tag = token->v.start_tag.tag;
  } else if (!is_start && token->type == GUMBO_TOKEN_END_TAG) {
    token_tag = token->v.end_tag;
  } else {
    return false;
  }
  return (*tags)[token_tag] != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0x8d6f
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x8d6f
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x8d92
testb $0x1, -0x11(%rbp)
jne 0x8d8a
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x8d8a
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x8d90
movb $0x0, -0x1(%rbp)
jmp 0x8da8
jmp 0x8d92
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: is_html_integration_point
static bool is_html_integration_point(const GumboNode* node) {
  static const TagSet html_integration_point_svg_tags = {
      TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC), TAG_SVG(TITLE)
  };
  if (node_tag_in_set(node, &html_integration_point_svg_tags)) {
    return true;
  }

  const bool is_mathml_annotation_xml_element = node_qualified_tag_is (
    node,
    GUMBO_NAMESPACE_MATHML,
    GUMBO_TAG_ANNOTATION_XML
  );
  const GumboVector* attributes = &node->v.element.attributes;
  if (
    is_mathml_annotation_xml_element
    && (
      attribute_matches(attributes, "encoding", "text/html")
      || attribute_matches(attributes, "encoding", "application/xhtml+xml")
    )
  ) {
    return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x27be9(%rip), %rsi     # 0x309b0
callq 0x8680
testb $0x1, %al
jne 0x8dd2
jmp 0x8dd8
movb $0x1, -0x1(%rbp)
jmp 0x8e48
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x5b, %edx
callq 0x8770
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
addq $0x68, %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0x8e44
movq -0x20(%rbp), %rdi
leaq 0x2a6ce(%rip), %rsi     # 0x334df
leaq 0x2a6d0(%rip), %rdx     # 0x334e8
callq 0x9400
testb $0x1, %al
jne 0x8e3e
movq -0x20(%rbp), %rdi
leaq 0x2a6b3(%rip), %rsi     # 0x334df
leaq 0x2a6bf(%rip), %rdx     # 0x334f2
callq 0x9400
testb $0x1, %al
jne 0x8e3e
jmp 0x8e44
movb $0x1, -0x1(%rbp)
jmp 0x8e48
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_initial
static bool handle_initial(GumboParser* parser, GumboToken* token) {
  GumboDocument* document = &get_document_node(parser)->v.document;
  if (token->type == GUMBO_TOKEN_WHITESPACE) {
    ignore_token(parser);
    return true;
  } else if (token->type == GUMBO_TOKEN_COMMENT) {
    append_comment_node(parser, get_document_node(parser), token);
    return true;
  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
    document->has_doctype = true;
    document->name = token->v.doc_type.name;
    document->public_identifier = token->v.doc_type.public_identifier;
    document->system_identifier = token->v.doc_type.system_identifier;
    document->doc_type_quirks_mode = compute_quirks_mode(&token->v.doc_type);
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HTML);
    return maybe_add_doctype_error(parser, token);
  }
  parser_add_parse_error(parser, token);
  document->doc_type_quirks_mode = GUMBO_DOCTYPE_QUIRKS;
  set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HTML);
  parser->_parser_state->_reprocess_current_token = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8660
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x955c
movq -0x10(%rbp), %rdi
callq 0x8bd0
movb $0x1, -0x1(%rbp)
jmp 0x9642
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x958f
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8660
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0xe7b0
movb $0x1, -0x1(%rbp)
jmp 0x9642
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x9608
movq -0x20(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xe850
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x8b40
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe960
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9642
jmp 0x960a
jmp 0x960c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x78a0
movq -0x20(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x8b40
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x1, 0x50(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_before_head
static bool handle_before_head(GumboParser* parser, GumboToken* token) {
  if (token->type == GUMBO_TOKEN_DOCTYPE) {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  } else if (token->type == GUMBO_TOKEN_COMMENT) {
    append_comment_node(parser, get_current_node(parser), token);
    return true;
  } else if (token->type == GUMBO_TOKEN_WHITESPACE) {
    ignore_token(parser);
    return true;
  } else if (tag_is(token, kStartTag, GUMBO_TAG_HEAD)) {
    GumboNode* node = insert_element_from_token(parser, token);
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
    parser->_parser_state->_head_element = node;
    return true;
  } else if (
    token->type == GUMBO_TOKEN_END_TAG
    && !tag_in(token, false, &head_body_html_br_tags)
  ) {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  } else {
    GumboNode* node = insert_element_of_tag_type (
      parser,
      GUMBO_TAG_HEAD,
      GUMBO_INSERTION_IMPLIED
    );
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
    parser->_parser_state->_head_element = node;
    parser->_parser_state->_reprocess_current_token = true;
    return true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x9818
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x78a0
movq -0x10(%rbp), %rdi
callq 0x8bd0
movb $0x0, -0x1(%rbp)
jmp 0x9934
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x984b
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7550
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0xe7b0
movb $0x1, -0x1(%rbp)
jmp 0x9934
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x9866
movq -0x10(%rbp), %rdi
callq 0x8bd0
movb $0x1, -0x1(%rbp)
jmp 0x9934
movq -0x18(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x8c40
testb $0x1, %al
jne 0x987c
jmp 0x98b4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xece0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x8b40
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x38(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x9934
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x98ef
movq -0x18(%rbp), %rdi
xorl %esi, %esi
leaq 0x27186(%rip), %rdx     # 0x30a50
callq 0x8d40
testb $0x1, %al
jne 0x98ef
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x78a0
movq -0x10(%rbp), %rdi
callq 0x8bd0
movb $0x0, -0x1(%rbp)
jmp 0x9934
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0x7ea0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x8b40
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x1, 0x50(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_text
static HOT bool handle_text(GumboParser* parser, GumboToken* token) {
  if (
    token->type == GUMBO_TOKEN_CHARACTER
    || token->type == GUMBO_TOKEN_WHITESPACE
  ) {
    insert_text_token(parser, token);
  } else {
    // We provide only bare-bones script handling that doesn't involve any of
    // the parser-pause/already-started/script-nesting flags or re-entrant
    // invocations of the tokenizer. Because the intended usage of this library
    // is mostly for templating, refactoring, and static-analysis libraries, we
    // provide the script body as a text-node child of the <script> element.
    // This behavior doesn't support document.write of partial HTML elements,
    // but should be adequate for almost all other scripting support.
    if (token->type == GUMBO_TOKEN_EOF) {
      parser_add_parse_error(parser, token);
      parser->_parser_state->_reprocess_current_token = true;
    }
    pop_current_node(parser);
    set_insertion_mode(parser, parser->_parser_state->_original_insertion_mode);
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
je 0xc282
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xc291
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xef60
jmp 0xc2d0
movq -0x10(%rbp), %rax
cmpl $0x8, (%rax)
jne 0xc2b3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x78a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x1, 0x50(%rax)
movq -0x8(%rbp), %rdi
callq 0xf060
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x4(%rax), %esi
callq 0x8b40
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_in_table_text
static bool handle_in_table_text(GumboParser* parser, GumboToken* token) {
  if (token->type == GUMBO_TOKEN_NULL) {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  } else if (
    token->type == GUMBO_TOKEN_CHARACTER
    || token->type == GUMBO_TOKEN_WHITESPACE
  ) {
    insert_text_token(parser, token);
    return true;
  } else {
    GumboParserState* state = parser->_parser_state;
    GumboStringBuffer* buffer = &state->_text_node._buffer;
    const char* data = buffer->data;
    // Note that TextNodeBuffer may contain UTF-8 characters, but the
    // presence of any one byte that is not whitespace means we flip
    // the flag, so this loop is still valid.
    for (size_t i = 0, n = buffer->length; i < n; ++i) {
      switch (data[i]) {
      case '\t':
      case '\n':
      case '\f':
      case '\r':
      case ' ':
        continue;
      default:
        state->_foster_parent_insertions = true;
        reconstruct_active_formatting_elements(parser);
        goto loopbreak;
      }
    }
    loopbreak:
    maybe_flush_text_node_buffer(parser);
    state->_foster_parent_insertions = false;
    state->_reprocess_current_token = true;
    state->_insertion_mode = state->_original_insertion_mode;
    return true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x7, (%rax)
jne 0xc8c8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x78a0
movq -0x10(%rbp), %rdi
callq 0x8bd0
movb $0x0, -0x1(%rbp)
jmp 0xc9b0
movq -0x18(%rbp), %rax
cmpl $0x5, (%rax)
je 0xc8da
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xc8f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xef60
movb $0x1, -0x1(%rbp)
jmp 0xc9b0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xc984
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0xc961
jmp 0xc94a
movl -0x44(%rbp), %eax
addl $-0xc, %eax
subl $0x2, %eax
jb 0xc961
jmp 0xc957
movl -0x44(%rbp), %eax
subl $0x20, %eax
jne 0xc963
jmp 0xc961
jmp 0xc976
movq -0x20(%rbp), %rax
movb $0x1, 0x54(%rax)
movq -0x10(%rbp), %rdi
callq 0xf860
jmp 0xc986
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xc927
jmp 0xc986
movq -0x10(%rbp), %rdi
callq 0x8030
movq -0x20(%rbp), %rax
movb $0x0, 0x54(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x50(%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_in_select_in_table
static bool handle_in_select_in_table(GumboParser* parser, GumboToken* token) {
  static const TagSet tags = {
    TAG(CAPTION), TAG(TABLE), TAG(TBODY), TAG(TFOOT), TAG(THEAD),
    TAG(TR), TAG(TD), TAG(TH)
  };
  if (tag_in(token, kStartTag, &tags)) {
    parser_add_parse_error(parser, token);
    close_current_select(parser);
    parser->_parser_state->_reprocess_current_token = true;
    return false;
  } else if (tag_in(token, kEndTag, &tags)) {
    parser_add_parse_error(parser, token);
    if (!has_an_element_in_table_scope(parser, token->v.end_tag)) {
      ignore_token(parser);
      return false;
    } else {
      close_current_select(parser);
      // close_current_select already does the
      // reset_insertion_mode_appropriately
      // reset_insertion_mode_appropriately(parser);
      parser->_parser_state->_reprocess_current_token = true;
      return false;
    }
  } else {
    return handle_in_select(parser, token);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x24f50(%rip), %rdx     # 0x32b60
callq 0x8d40
testb $0x1, %al
jne 0xdc1b
jmp 0xdc43
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x78a0
movq -0x10(%rbp), %rdi
callq 0x11640
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x1, 0x50(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xdcb8
movq -0x18(%rbp), %rdi
xorl %esi, %esi
leaq 0x24f10(%rip), %rdx     # 0x32b60
callq 0x8d40
testb $0x1, %al
jne 0xdc5b
jmp 0xdca6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x78a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x10bf0
testb $0x1, %al
jne 0xdc8b
movq -0x10(%rbp), %rdi
callq 0x8bd0
movb $0x0, -0x1(%rbp)
jmp 0xdcb8
movq -0x10(%rbp), %rdi
callq 0x11640
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x1, 0x50(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xdcb8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd700
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_after_after_body
static bool handle_after_after_body(GumboParser* parser, GumboToken* token) {
  if (token->type == GUMBO_TOKEN_COMMENT) {
    append_comment_node(parser, get_document_node(parser), token);
    return true;
  } else if (
    token->type == GUMBO_TOKEN_DOCTYPE
    || token->type == GUMBO_TOKEN_WHITESPACE
    || tag_is(token, kStartTag, GUMBO_TAG_HTML)
  ) {
    return handle_in_body(parser, token);
  } else if (token->type == GUMBO_TOKEN_EOF) {
    return true;
  } else {
    parser_add_parse_error(parser, token);
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
    parser->_parser_state->_reprocess_current_token = true;
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0xe640
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8660
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0xe7b0
movb $0x1, -0x1(%rbp)
jmp 0xe6b6
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xe668
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
je 0xe668
movq -0x18(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8c40
testb $0x1, %al
jne 0xe668
jmp 0xe67c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa3f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe6b6
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0xe68b
movb $0x1, -0x1(%rbp)
jmp 0xe6b6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x78a0
movq -0x10(%rbp), %rdi
movl $0x6, %esi
callq 0x8b40
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x1, 0x50(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_after_after_frameset
static bool handle_after_after_frameset (
  GumboParser* parser,
  GumboToken* token
) {
  if (token->type == GUMBO_TOKEN_COMMENT) {
    append_comment_node(parser, get_document_node(parser), token);
    return true;
  } else if (
    token->type == GUMBO_TOKEN_DOCTYPE
    || token->type == GUMBO_TOKEN_WHITESPACE
    || tag_is(token, kStartTag, GUMBO_TAG_HTML)
  ) {
    return handle_in_body(parser, token);
  } else if (token->type == GUMBO_TOKEN_EOF) {
    return true;
  } else if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
    return handle_in_head(parser, token);
  } else {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0xe713
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8660
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0xe7b0
movb $0x1, -0x1(%rbp)
jmp 0xe7a5
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xe73b
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
je 0xe73b
movq -0x18(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8c40
testb $0x1, %al
jne 0xe73b
jmp 0xe74f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa3f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe7a5
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0xe75e
movb $0x1, -0x1(%rbp)
jmp 0xe7a5
movq -0x18(%rbp), %rdi
movl $0x1, %esi
movl $0x82, %edx
callq 0x8c40
testb $0x1, %al
jne 0xe777
jmp 0xe78b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9940
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe7a5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x78a0
movq -0x10(%rbp), %rdi
callq 0x8bd0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: append_comment_node
static void append_comment_node (
  GumboParser* parser,
  GumboNode* node,
  const GumboToken* token
) {
  maybe_flush_text_node_buffer(parser);
  GumboNode* comment = create_node(GUMBO_NODE_COMMENT);
  comment->type = GUMBO_NODE_COMMENT;
  comment->parse_flags = GUMBO_INSERTION_NORMAL;
  comment->v.text.text = token->v.text;
  comment->v.text.original_text = token->original_text;
  comment->v.text.start_pos = token->position;
  append_node(node, comment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8030
movl $0x4, %edi
callq 0x7d10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x4, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x87f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: compute_quirks_mode
static GumboQuirksModeEnum compute_quirks_mode(const GumboTokenDocType* doctype) {
  const char *const pubid = doctype->public_identifier;
  const char *const sysid = doctype->system_identifier;

  if (
    doctype->force_quirks
    || strcmp(doctype->name, "html") != 0
    || is_in_static_list(pubid, kQuirksModePublicIdPrefixes, false)
    || is_in_static_list(pubid, kQuirksModePublicIdExactMatches, true)
    || is_in_static_list(sysid, kQuirksModeSystemIdExactMatches, true)
    || (
      !doctype->has_system_identifier
      && is_in_static_list(pubid, kSystemIdDependentPublicIdPrefixes, false)
    )
  ) {
    return GUMBO_DOCTYPE_QUIRKS;
  }

  if (
    is_in_static_list(pubid, kLimitedQuirksPublicIdPrefixes, false)
    || (
      doctype->has_system_identifier
      && is_in_static_list(pubid, kSystemIdDependentPublicIdPrefixes, false)
    )
  ) {
    return GUMBO_DOCTYPE_LIMITED_QUIRKS;
  }

  return GUMBO_DOCTYPE_NO_QUIRKS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x18(%rax)
jne 0xe904
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x24c5d(%rip), %rsi     # 0x334ed
callq 0x4170
cmpl $0x0, %eax
jne 0xe904
movq -0x18(%rbp), %rdi
leaq 0x646fb(%rip), %rsi     # 0x72fa0
xorl %edx, %edx
callq 0xea80
testb $0x1, %al
jne 0xe904
movq -0x18(%rbp), %rdi
leaq 0x64a65(%rip), %rsi     # 0x73320
movl $0x1, %edx
callq 0xea80
testb $0x1, %al
jne 0xe904
movq -0x20(%rbp), %rdi
leaq 0x64a8c(%rip), %rsi     # 0x73360
movl $0x1, %edx
callq 0xea80
testb $0x1, %al
jne 0xe904
movq -0x10(%rbp), %rax
testb $0x1, 0x1a(%rax)
jne 0xe90d
movq -0x18(%rbp), %rdi
leaq 0x64a89(%rip), %rsi     # 0x73380
xorl %edx, %edx
callq 0xea80
testb $0x1, %al
jne 0xe904
jmp 0xe90d
movl $0x1, -0x4(%rbp)
jmp 0xe955
movq -0x18(%rbp), %rdi
leaq 0x64a98(%rip), %rsi     # 0x733b0
xorl %edx, %edx
callq 0xea80
testb $0x1, %al
jne 0xe945
movq -0x10(%rbp), %rax
testb $0x1, 0x1a(%rax)
je 0xe94e
movq -0x18(%rbp), %rdi
leaq 0x64a48(%rip), %rsi     # 0x73380
xorl %edx, %edx
callq 0xea80
testb $0x1, %al
jne 0xe945
jmp 0xe94e
movl $0x2, -0x4(%rbp)
jmp 0xe955
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop