LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x90, %edi
callq 0x113d4
movq %rax, %rbx
movq $0x0, 0x8(%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x10(%rbx)
movl $0x1, (%rbx)
leaq 0x18(%rbx), %rsi
movl $0x1, %edi
callq 0x7af0
leaq 0x80(%rbx), %rsi
xorl %edi, %edi
callq 0x7af0
movl %ebp, 0x28(%rbx)
leaq 0x50(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rbx)
movups %xmm0, 0x3c(%rbx)
movl $0x0, 0x4c(%rbx)
movq 0x18(%r14), %rcx
movq 0x98(%rcx), %rcx
testq %rcx, %rcx
je 0x80a3
movq 0x18(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups 0x8(%rcx), %xmm0
movups %xmm0, (%rax)
jmp 0x80ae
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x8020
movq %rax, %r15
orl 0x14(%rax), %ebx
orl $0x1, %ebx
movl %ebx, 0x14(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x82d6
movl %ebp, %edi
callq 0x7694
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r15
movl 0x10(%r15), %r12d
leaq 0x1143e(%rip), %rax     # 0x1955c
testl %r12d, %r12d
jle 0x8298
movq 0x8(%r15), %rcx
movq -0x8(%rcx,%r12,8), %rcx
cmpq $0x1, %r12
jne 0x8141
movq 0x48(%r15), %rdx
testq %rdx, %rdx
cmovneq %rdx, %rcx
movl (%rcx), %edx
cmpl $0x1, %edx
je 0x8151
cmpl $0x6, %edx
jne 0x82b7
cmpl $0x0, 0x2c(%rcx)
je 0x816b
cmpq $0x1, %r12
je 0x81d0
xorl %ebp, %ebp
decq %r12
testl %ebp, %ebp
je 0x811e
jmp 0x828c
movl 0x28(%rcx), %ecx
movl $0x6, %ebp
cmpl $0x9, %ecx
jg 0x818d
jne 0x819e
movl 0x30(%r15), %ecx
testl %ecx, %ecx
je 0x815d
movq 0x28(%r15), %rdx
decl %ecx
movl (%rdx,%rcx,8), %ebp
jmp 0x815f
leal -0x5f(%rcx), %edx
cmpl $0x10, %edx
ja 0x81b0
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
testl %ecx, %ecx
je 0x826a
cmpl $0x1, %ecx
jne 0x81c5
jmp 0x825d
cmpl $0xa, %ecx
je 0x828c
cmpl $0x81, %ecx
je 0x827c
cmpq $0x1, %r12
jne 0x815d
jmp 0x828c
movl $0x6, %ebp
jmp 0x828c
movl $0xc, %ebp
jmp 0x828c
cmpq $0x1, %r12
je 0x828c
movl $0xe, %ebp
jmp 0x828c
movl $0xf, %ebp
cmpl $0x1, %r12d
je 0x828c
movq 0x8(%r15), %rax
movq -0x8(%rax,%r12,8), %r14
movq %r14, %rdi
xorl %esi, %esi
movl $0x9, %edx
callq 0x8739
testb %al, %al
jne 0x8288
movq %r14, %rdi
xorl %esi, %esi
movl $0x5f, %edx
callq 0x8739
testb %al, %al
jne 0x8283
decq %r12
cmpq $0x2, %r12
jge 0x8207
jmp 0x8288
movl $0xd, %ebp
jmp 0x828c
movl $0x8, %ebp
jmp 0x828c
movl $0xb, %ebp
jmp 0x828c
movl $0xa, %ebp
jmp 0x828c
cmpq $0x1, %r12
je 0x828c
movl $0x3, %ebp
jmp 0x828c
xorl %eax, %eax
cmpq $0x0, 0x38(%r15)
setne %al
leal (%rax,%rax,2), %ebp
addl $0x2, %ebp
jmp 0x828c
movl $0x13, %ebp
jmp 0x828c
movl $0x10, %ebp
movq 0x18(%rbx), %r15
movl %ebp, (%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x151a6(%rip), %rdi     # 0x1d445
leaq 0x1368a(%rip), %rsi     # 0x1b930
leaq 0x139fa(%rip), %rcx     # 0x1bca7
movl $0x2bd, %edx            # imm = 0x2BD
callq 0x4100
leaq 0x13a20(%rip), %rdi     # 0x1bcde
leaq 0x1366b(%rip), %rsi     # 0x1b930
leaq 0x13a58(%rip), %rcx     # 0x1bd24
movl $0x275, %edx            # imm = 0x275
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: maybe_flush_text_node_buffer
static void maybe_flush_text_node_buffer(GumboParser* parser) {
  GumboParserState* state = parser->_parser_state;
  TextNodeBufferState* buffer_state = &state->_text_node;
  if (buffer_state->_buffer.length == 0) {
    return;
  }

  assert (
    buffer_state->_type == GUMBO_NODE_WHITESPACE
    || buffer_state->_type == GUMBO_NODE_TEXT
    || buffer_state->_type == GUMBO_NODE_CDATA
  );
  GumboNode* text_node = create_node(buffer_state->_type);
  GumboText* text_node_data = &text_node->v.text;
  text_node_data->text = gumbo_string_buffer_to_string(&buffer_state->_buffer);
  text_node_data->original_text.data = buffer_state->_start_original_text;
  text_node_data->original_text.length =
      state->_current_token->original_text.data -
      buffer_state->_start_original_text;
  text_node_data->start_pos = buffer_state->_start_position;

  gumbo_debug (
    "Flushing text node buffer of %.*s.\n",
    (int) buffer_state->_buffer.length,
    buffer_state->_buffer.data
  );

  InsertionLocation location = get_appropriate_insertion_location(parser, NULL);
  if (location.target->type == GUMBO_NODE_DOCUMENT) {
    // The DOM does not allow Document nodes to have Text children, so per the
    // spec, they are dropped on the floor.
    destroy_node(text_node);
  } else {
    insert_node(text_node, location);
  }

  gumbo_string_buffer_clear(&buffer_state->_buffer);
  buffer_state->_type = GUMBO_NODE_WHITESPACE;
  assert(buffer_state->_buffer.length == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x18(%rdi), %r12
cmpq $0x0, 0x60(%r12)
je 0x83ef
movq %rdi, %r14
movl 0x90(%r12), %r13d
leal -0x2(%r13), %eax
cmpl $0x2, %eax
jb 0x834a
cmpl $0x5, %r13d
jne 0x8418
leaq 0x58(%r12), %rbx
movl $0x90, %edi
callq 0x113d4
movq %rax, %r15
movq $0x0, 0x8(%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x10(%r15)
movl %r13d, (%r15)
movq %rbx, %rdi
callq 0x7648
movq %rax, 0x18(%r15)
movq 0x70(%r12), %rax
movq %rax, 0x20(%r15)
movq 0x98(%r12), %rcx
movq 0x20(%rcx), %rcx
subq %rax, %rcx
movq %rcx, 0x28(%r15)
movups 0x78(%r12), %xmm0
movups %xmm0, 0x30(%r15)
movq 0x88(%r12), %rax
movq %rax, 0x40(%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x8437
cmpl $0x0, (%rax)
je 0x83cb
movq %r15, %rdi
movq %rax, %rsi
callq 0x854d
jmp 0x83d3
movq %r15, %rdi
callq 0x7e9b
movq %rbx, %rdi
callq 0x7680
movl $0x5, 0x90(%r12)
cmpq $0x0, 0x60(%r12)
jne 0x83f9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x136d0(%rip), %rdi     # 0x1bad0
leaq 0x13529(%rip), %rsi     # 0x1b930
leaq 0x13691(%rip), %rcx     # 0x1ba9f
movl $0x3ac, %edx            # imm = 0x3AC
callq 0x4100
leaq 0x135fe(%rip), %rdi     # 0x1ba1d
leaq 0x1350a(%rip), %rsi     # 0x1b930
leaq 0x13672(%rip), %rcx     # 0x1ba9f
movl $0x391, %edx            # imm = 0x391
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x8719
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x8705
cmpl $0x1, %eax
jne 0x8716
movl 0x28(%rdi), %eax
movl 0x2c(%rdi), %ecx
movzbl (%rsi,%rax), %eax
btl %ecx, %eax
setb %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x14e05(%rip), %rdi     # 0x1d526
leaq 0x13208(%rip), %rsi     # 0x1b930
leaq 0x133c3(%rip), %rcx     # 0x1baf2
movl $0x247, %edx            # imm = 0x247
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x8759
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x874a
cmpl $0x1, %eax
jne 0x8756
cmpl %edx, 0x28(%rdi)
jne 0x8756
cmpl %esi, 0x2c(%rdi)
sete %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x45015(%rip), %rdi     # 0x4d776
leaq 0x131c8(%rip), %rsi     # 0x1b930
leaq 0x133bc(%rip), %rcx     # 0x1bb2b
movl $0x258, %edx            # imm = 0x258
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rsi)
jne 0x87c8
movq %rsi, %r14
cmpl $-0x1, 0x10(%rsi)
jne 0x87e7
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
jb 0x87a0
cmpl $0x6, %eax
jne 0x8825
leaq 0x18(%rbx), %rsi
movq %rbx, 0x8(%r14)
movl 0x20(%rbx), %eax
movl %eax, 0x10(%r14)
movq %r14, %rdi
callq 0x7b25
movl 0x10(%r14), %eax
cmpl 0x20(%rbx), %eax
jae 0x8806
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x133a9(%rip), %rdi     # 0x1bb78
leaq 0x1315a(%rip), %rsi     # 0x1b930
leaq 0x1347b(%rip), %rcx     # 0x1bc58
movl $0x34e, %edx            # imm = 0x34E
callq 0x4100
leaq 0x133d0(%rip), %rdi     # 0x1bbbe
leaq 0x1313b(%rip), %rsi     # 0x1b930
leaq 0x1345c(%rip), %rcx     # 0x1bc58
movl $0x34f, %edx            # imm = 0x34F
callq 0x4100
leaq 0x1341e(%rip), %rdi     # 0x1bc2b
leaq 0x1311c(%rip), %rsi     # 0x1b930
leaq 0x1343d(%rip), %rcx     # 0x1bc58
movl $0x35d, %edx            # imm = 0x35D
callq 0x4100
leaq 0x13457(%rip), %rdi     # 0x1bc83
leaq 0x130fd(%rip), %rsi     # 0x1b930
leaq 0x1341e(%rip), %rcx     # 0x1bc58
movl $0x357, %edx            # imm = 0x357
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1106e(%rip), %rsi     # 0x198c0
callq 0x86f4
movb $0x1, %bl
testb %al, %al
jne 0x88ad
movq %r14, %rdi
movl $0x2, %esi
movl $0x5b, %edx
callq 0x8739
testb %al, %al
je 0x88ab
subq $-0x80, %r14
leaq 0x135ed(%rip), %rsi     # 0x1be6b
leaq 0x135ef(%rip), %rdx     # 0x1be74
movq %r14, %rdi
callq 0x88b7
testb %al, %al
jne 0x88ad
leaq 0x135d3(%rip), %rsi     # 0x1be6b
leaq 0x135df(%rip), %rdx     # 0x1be7e
movq %r14, %rdi
callq 0x88b7
testb %al, %al
jne 0x88ad
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_before_html
static bool handle_before_html(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_document_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_HTML)) {
    GumboNode* html_node = insert_element_from_token(parser, token);
    parser->_output->root = html_node;
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HEAD);
    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* html_node = insert_element_of_tag_type (
      parser,
      GUMBO_TAG_HTML,
      GUMBO_INSERTION_IMPLIED
    );
    assert(html_node);
    parser->_output->root = html_node;
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HEAD);
    parser->_parser_state->_reprocess_current_token = true;
    return true;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x4, %rax
ja 0x8c86
movq %rsi, %rdx
leaq 0x1097e(%rip), %rcx     # 0x195a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, 0x30(%rdx)
jne 0x8c86
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xade5
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x18(%rbx), %rax
movl $0x2, (%rax)
jmp 0x8cea
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xc990
movb $0x1, %al
cmpl $0x1, (%rbx)
jne 0x8cec
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
jmp 0x8cec
movl 0x30(%rdx), %eax
leaq 0x10ce0(%rip), %rcx     # 0x19960
cmpb $0x0, (%rax,%rcx)
je 0x8cad
movq %rbx, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x80c5
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x18(%rbx), %rax
movl $0x2, (%rax)
movb $0x1, 0x50(%rax)
jmp 0x8cea
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7d9d
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xc990
cmpl $0x1, (%rbx)
jne 0x8cd7
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
xorl %eax, %eax
jmp 0x8cec
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xac3d
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x4, %rax
ja 0x8d6d
movq %rsi, %r14
leaq 0x108ad(%rip), %rcx     # 0x195b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x1, 0x30(%r14)
jne 0x8d6d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xade5
movq 0x18(%rbx), %rcx
movl $0x3, (%rcx)
movq %rax, 0x38(%rcx)
jmp 0x8dd7
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xc990
movb $0x1, %al
cmpl $0x1, (%rbx)
jne 0x8dd9
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
jmp 0x8dd9
movl 0x30(%r14), %eax
leaq 0x10bf9(%rip), %rcx     # 0x19960
cmpb $0x0, (%rax,%rcx)
je 0x8d93
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0x80c5
movq 0x18(%rbx), %rcx
movl $0x3, (%rcx)
movq %rax, 0x38(%rcx)
movb $0x1, 0x50(%rcx)
jmp 0x8dd7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d9d
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xc990
cmpl $0x1, (%rbx)
jne 0x8dbd
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
xorl %eax, %eax
jmp 0x8dd9
movq %rbx, %rdi
callq 0x7d33
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xac3d
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %ebp
cmpl $0x7, %ebp
je 0x97d2
movl %ebp, %eax
andl $-0x2, %eax
cmpl $0x4, %eax
jne 0x97fb
movq %rbx, %rdi
callq 0xaf71
jmp 0x9849
movq %rbx, %rdi
callq 0x7d9d
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xc990
cmpl $0x1, (%rbx)
jne 0x9849
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
jmp 0x9849
movq 0x18(%rbx), %r14
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x9830
movq 0x58(%r14), %rcx
xorl %edx, %edx
movabsq $0x100003600, %rsi      # imm = 0x100003600
movzbl (%rcx,%rdx), %edi
cmpq $0x20, %rdi
ja 0x9854
btq %rdi, %rsi
jae 0x9854
incq %rdx
cmpq %rdx, %rax
jne 0x9818
movq %rbx, %rdi
callq 0x8313
movb $0x0, 0x54(%r14)
movb $0x1, 0x50(%r14)
movl 0x4(%r14), %eax
movl %eax, (%r14)
cmpl $0x7, %ebp
setne %al
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, 0x54(%r14)
movq %rbx, %rdi
callq 0xb487
jmp 0x9830
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x2, %eax
je 0xa441
cmpl $0x1, %eax
jne 0xa4a0
movl 0x30(%r14), %eax
leaq 0x11222(%rip), %rcx     # 0x1b650
cmpb $0x0, (%rax,%rcx)
je 0xa4a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d9d
jmp 0xa486
movl 0x30(%r14), %eax
leaq 0x11204(%rip), %rcx     # 0x1b650
cmpb $0x0, (%rax,%rcx)
je 0xa4a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d9d
movl 0x30(%r14), %eax
movq 0x18(%rbx), %r14
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x1066d(%rip), %r8      # 0x1aae0
movq %r14, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xb40a
testb %al, %al
je 0xa4b2
movq %rbx, %rdi
callq 0xc789
movq 0x18(%rbx), %rax
movb $0x1, 0x50(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa0be
movq 0x98(%r14), %rbx
movq %rbx, %rdi
callq 0xc990
cmpl $0x1, (%rbx)
jne 0xa496
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
jmp 0xa496
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_after_body
static bool handle_after_body(GumboParser* parser, GumboToken* token) {
  if (
    token->type == GUMBO_TOKEN_WHITESPACE
    || tag_is(token, kStartTag, GUMBO_TAG_HTML)
  ) {
    return handle_in_body(parser, token);
  } else if (token->type == GUMBO_TOKEN_COMMENT) {
    GumboNode* html_node = parser->_output->root;
    assert(html_node != NULL);
    append_comment_node(parser, html_node, token);
    return true;
  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  } else if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
    /* fragment case: ignore the closing HTML token */
    if (is_fragment_parser(parser)) {
      parser_add_parse_error(parser, token);
      ignore_token(parser);
      return false;
    }
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_AFTER_BODY);
    GumboNode* html = parser->_parser_state->_open_elements.data[0];
    assert(node_html_tag_is(html, GUMBO_TAG_HTML));
    record_end_of_element (
      parser->_parser_state->_current_token,
      &html->v.element
    );
    return true;
  } 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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rdx
movq %rdi, %r14
movl (%rsi), %eax
cmpq $0x8, %rax
ja 0xa7a9
movb $0x1, %bl
leaq 0xef7b(%rip), %rcx      # 0x196b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rdx, %rsi
callq 0x7d9d
movq 0x18(%r14), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xc990
cmpl $0x1, (%rbx)
jne 0xa7c2
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
jmp 0xa7c2
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0xa82c
movq %r14, %rdi
callq 0xac3d
jmp 0xa7c4
cmpl $0x0, 0x30(%rdx)
jne 0xa7a9
movq %r14, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4ece
cmpl $0x0, 0x30(%rdx)
je 0xa7cc
movq %r14, %rdi
movq %rdx, %rsi
callq 0x7d9d
movq 0x18(%r14), %rax
movl $0x6, (%rax)
movb $0x1, 0x50(%rax)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x18(%r14), %rax
cmpq $0x0, 0x48(%rax)
jne 0xa746
movl $0x15, (%rax)
movq 0x8(%rax), %rax
movq (%rax), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8739
testb %al, %al
je 0xa84b
movq 0x18(%r14), %rax
movq 0x98(%rax), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x78(%r15)
movups 0x8(%rax), %xmm0
movups %xmm0, 0x68(%r15)
addq $0x40, %r15
cmpl $0x2, (%rax)
jne 0xa823
movups 0x20(%rax), %xmm0
jmp 0xa826
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
jmp 0xa7c4
leaq 0x12cee(%rip), %rdi     # 0x1d521
leaq 0x110f6(%rip), %rsi     # 0x1b930
leaq 0x12cf2(%rip), %rcx     # 0x1d533
movl $0xf7b, %edx            # imm = 0xF7B
callq 0x4100
leaq 0x12d16(%rip), %rdi     # 0x1d568
leaq 0x110d7(%rip), %rsi     # 0x1b930
leaq 0x12cd3(%rip), %rcx     # 0x1d533
movl $0xf8b, %edx            # imm = 0xF8B
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_after_frameset
static bool handle_after_frameset(GumboParser* parser, GumboToken* token) {
  if (token->type == GUMBO_TOKEN_WHITESPACE) {
    insert_text_token(parser, token);
    return true;
  } else if (token->type == GUMBO_TOKEN_COMMENT) {
    append_comment_node(parser, get_current_node(parser), token);
    return true;
  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
    return handle_in_body(parser, token);
  } else if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
    GumboNode* html = parser->_parser_state->_open_elements.data[0];
    assert(node_html_tag_is(html, GUMBO_TAG_HTML));
    record_end_of_element (
      parser->_parser_state->_current_token,
      &html->v.element
    );
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_AFTER_FRAMESET);
    return true;
  } else if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
    return handle_in_head(parser, token);
  } else if (token->type == GUMBO_TOKEN_EOF) {
    return true;
  } else {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rsi), %eax
cmpq $0x8, %rax
ja 0xaa5f
movb $0x1, %bl
leaq 0xece4(%rip), %rcx      # 0x19700
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x30(%r15), %eax
cmpl $0x82, %eax
je 0xaaeb
testl %eax, %eax
jne 0xaa5f
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4ece
movq %r14, %rdi
movq %r15, %rsi
callq 0xaf71
jmp 0xab0c
cmpl $0x0, 0x30(%r15)
je 0xaaa5
movq %r14, %rdi
movq %r15, %rsi
callq 0x7d9d
movq 0x18(%r14), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xc990
cmpl $0x1, (%rbx)
jne 0xaa89
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
xorl %ebx, %ebx
jmp 0xab0c
movq %r14, %rdi
callq 0x7d33
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xac3d
jmp 0xab0c
movq 0x18(%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8739
testb %al, %al
je 0xab14
movq 0x18(%r14), %rax
movq 0x98(%rax), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x78(%r15)
movups 0x8(%rax), %xmm0
movups %xmm0, 0x68(%r15)
addq $0x40, %r15
cmpl $0x2, (%rax)
jne 0xaafb
movups 0x20(%rax), %xmm0
jmp 0xaafe
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x8de1
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x18(%r14), %rax
movl $0x16, (%rax)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x12a4d(%rip), %rdi     # 0x1d568
leaq 0x10e0e(%rip), %rsi     # 0x1b930
leaq 0x12a66(%rip), %rcx     # 0x1d58f
movl $0xfde, %edx            # imm = 0xFDE
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x8, %rax
ja 0xab6e
movb $0x1, %bpl
leaq 0xebd6(%rip), %rcx      # 0x19724
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4ece
cmpl $0x0, 0x30(%rdx)
je 0xab57
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7d9d
movq 0x18(%rbx), %rax
movl $0x6, (%rax)
movb $0x1, 0x50(%rax)
xorl %ebp, %ebp
jmp 0xab9a
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xac3d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x8, %rax
ja 0xabe6
movb $0x1, %bpl
leaq 0xeb8a(%rip), %rcx      # 0x19748
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4ece
movl 0x30(%rdx), %eax
cmpl $0x82, %eax
je 0xac2c
testl %eax, %eax
je 0xabc7
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7d9d
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xc990
cmpl $0x1, (%rbx)
jne 0xac10
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
xorl %ebp, %ebp
jmp 0xac23
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xac3d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8de1
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: is_in_static_list
static bool is_in_static_list (
  const char* needle,
  const GumboStringPiece* haystack,
  bool exact_match
) {
  for (size_t i = 0; haystack[i].length > 0; i++) {
    if (
      (exact_match && string_piece_equal_cstr(&haystack[i], needle))
      || (!exact_match && string_piece_equal_cstr_icase(&haystack[i], needle))
    ) {
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0xad50
movq %rsi, %r14
movq %rdi, %r15
movl %edx, 0x4(%rsp)
callq 0x40b0
movl 0x4(%rsp), %r8d
movq %rax, %r12
xorl %ebp, %ebp
leaq 0xd479(%rip), %rbx      # 0x18150
movq %rbp, %rax
shlq $0x4, %rax
addq %r14, %rax
testb %r8b, %r8b
je 0xad04
cmpq %r13, %r12
jne 0xad3c
movq (%rax), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4200
movl 0x4(%rsp), %r8d
testl %eax, %eax
jne 0xad3c
jmp 0xad54
cmpq %r13, %r12
jne 0xad3c
movq (%rax), %rax
xorl %ecx, %ecx
movzbl (%rax,%rcx), %edx
movb (%rbx,%rdx), %sil
andb $0x20, %sil
orb %dl, %sil
movzbl (%r15,%rcx), %edx
movb (%rbx,%rdx), %dil
andb $0x20, %dil
orb %dl, %dil
cmpb %dil, %sil
jne 0xad3c
incq %rcx
cmpq %rcx, %r13
jne 0xad0e
jmp 0xad54
incq %rbp
movq %rbp, %rax
shlq $0x4, %rax
movq 0x8(%r14,%rax), %r13
testq %r13, %r13
jne 0xacd7
xorl %eax, %eax
jmp 0xad56
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: doctype_matches
static bool doctype_matches (
  const GumboTokenDocType* doctype,
  const GumboStringPiece* public_id,
  const GumboStringPiece* system_id,
  bool allow_missing_system_id
) {
  return
    (allow_missing_system_id || doctype->has_system_identifier)
    && string_piece_equal_cstr(public_id, doctype->public_identifier)
    && string_piece_equal_cstr(system_id, doctype->system_identifier);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
testl %r9d, %r9d
jne 0xad8b
cmpb $0x1, 0x1a(%r15)
jne 0xadd4
movq 0x8(%r15), %rbp
movq %rbp, %rdi
callq 0x40b0
cmpq %r12, %rax
jne 0xadd4
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x4200
testl %eax, %eax
jne 0xadd4
movq 0x10(%r15), %r15
movq %r15, %rdi
callq 0x40b0
cmpq %rbx, %rax
jne 0xadd4
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4200
testl %eax, %eax
sete %al
jmp 0xadd6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: insert_element_from_token
static GumboNode* insert_element_from_token (
  GumboParser* parser,
  GumboToken* token
) {
  GumboNode* element = create_element_from_token(token, GUMBO_NAMESPACE_HTML);
  insert_element(parser, element, false);
  gumbo_debug (
    "Inserting <%s> element (@%p) from token.\n",
    gumbo_normalized_tagname(element->v.element.tag),
    (void*)element
  );
  return element;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0xae18
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x82d6
movl 0x28(%r14), %edi
callq 0x7694
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: create_element_from_token
static GumboNode* create_element_from_token (
  GumboToken* token,
  GumboNamespaceEnum tag_namespace
) {
  assert(token->type == GUMBO_TOKEN_START_TAG);
  GumboTokenStartTag* start_tag = &token->v.start_tag;

  GumboNodeType type =
    (
      tag_namespace == GUMBO_NAMESPACE_HTML
      && start_tag->tag == GUMBO_TAG_TEMPLATE
    )
    ? GUMBO_NODE_TEMPLATE
    : GUMBO_NODE_ELEMENT
  ;

  GumboNode* node = create_node(type);
  GumboElement* element = &node->v.element;
  gumbo_vector_init(1, &element->children);
  element->attributes = start_tag->attributes;
  element->tag = start_tag->tag;
  element->tag_namespace = tag_namespace;

  assert(token->original_text.length >= 2);
  assert(token->original_text.data[0] == '<');
  assert(token->original_text.data[token->original_text.length - 1] == '>');
  element->original_tag = token->original_text;
  element->start_pos = token->position;
  element->original_end_tag = STRING_PIECE_INIT;
  element->end_pos = kGumboEmptySourcePosition;

  // The element takes ownership of the attributes from the token, so any
  // allocated-memory fields should be nulled out.
  start_tag->attributes = GUMBO_VECTOR_INIT;
  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, (%rdi)
jne 0xaef5
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1, %r15d
testl %esi, %esi
jne 0xae47
xorl %eax, %eax
cmpl $0x9, 0x30(%rbx)
sete %al
leal (%rax,%rax,4), %r15d
incl %r15d
movl $0x90, %edi
callq 0x113d4
movq %rax, %r14
movq $0x0, 0x8(%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x10(%r14)
movl %r15d, (%r14)
leaq 0x18(%r14), %rsi
movl $0x1, %edi
callq 0x7af0
movups 0x38(%rbx), %xmm0
movups %xmm0, 0x80(%r14)
movl 0x30(%rbx), %eax
movl %eax, 0x28(%r14)
movl %ebp, 0x2c(%r14)
movq 0x28(%rbx), %rcx
cmpq $0x1, %rcx
jbe 0xaf14
leaq 0x20(%rbx), %rax
movq (%rax), %rdx
cmpb $0x3c, (%rdx)
jne 0xaf33
cmpb $0x3e, -0x1(%rdx,%rcx)
jne 0xaf52
leaq 0x38(%rbx), %rcx
movups (%rax), %xmm0
movups %xmm0, 0x30(%r14)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x50(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x60(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x68(%r14)
movq $0x0, 0x78(%r14)
movups %xmm0, (%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x119f1(%rip), %rdi     # 0x1c8ed
leaq 0x10a2d(%rip), %rsi     # 0x1b930
leaq 0x11a08(%rip), %rcx     # 0x1c912
movl $0x426, %edx            # imm = 0x426
callq 0x4100
leaq 0x11a3e(%rip), %rdi     # 0x1c959
leaq 0x10a0e(%rip), %rsi     # 0x1b930
leaq 0x119e9(%rip), %rcx     # 0x1c912
movl $0x439, %edx            # imm = 0x439
callq 0x4100
leaq 0x11a40(%rip), %rdi     # 0x1c97a
leaq 0x109ef(%rip), %rsi     # 0x1b930
leaq 0x119ca(%rip), %rcx     # 0x1c912
movl $0x43a, %edx            # imm = 0x43A
callq 0x4100
leaq 0x11a45(%rip), %rdi     # 0x1c99e
leaq 0x109d0(%rip), %rsi     # 0x1b930
leaq 0x119ab(%rip), %rcx     # 0x1c912
movl $0x43b, %edx            # imm = 0x43B
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: insert_text_token
static void insert_text_token(GumboParser* parser, GumboToken* token) {
  assert (
    token->type == GUMBO_TOKEN_WHITESPACE
    || token->type == GUMBO_TOKEN_CHARACTER
    || token->type == GUMBO_TOKEN_NULL
    || token->type == GUMBO_TOKEN_CDATA
  );
  TextNodeBufferState* buffer_state = &parser->_parser_state->_text_node;
  if (buffer_state->_buffer.length == 0) {
    // Initialize position fields.
    buffer_state->_start_original_text = token->original_text.data;
    buffer_state->_start_position = token->position;
  }
  gumbo_string_buffer_append_codepoint (
    token->v.character,
    &buffer_state->_buffer
  );
  if (token->type == GUMBO_TOKEN_CHARACTER) {
    buffer_state->_type = GUMBO_NODE_TEXT;
  } else if (token->type == GUMBO_TOKEN_CDATA) {
    buffer_state->_type = GUMBO_NODE_CDATA;
  }
  gumbo_debug("Inserting text token '%c'.\n", token->v.character);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rsi), %eax
andl $-0x4, %eax
cmpl $0x4, %eax
jne 0xafdc
movq %rsi, %rbx
movq 0x18(%rdi), %r14
leaq 0x58(%r14), %rsi
cmpq $0x0, 0x60(%r14)
jne 0xafad
movq 0x20(%rbx), %rax
movq %rax, 0x70(%r14)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x78(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x88(%r14)
movl 0x30(%rbx), %edi
callq 0x4322
movl (%rbx), %eax
cmpl $0x5, %eax
je 0xafc8
cmpl $0x6, %eax
jne 0xafd4
movl $0x3, %eax
jmp 0xafcd
movl $0x2, %eax
movl %eax, 0x90(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x11a56(%rip), %rdi     # 0x1ca39
leaq 0x10946(%rip), %rsi     # 0x1b930
leaq 0x11add(%rip), %rcx     # 0x1cace
movl $0x4ac, %edx            # imm = 0x4AC
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: run_generic_parsing_algorithm
static void run_generic_parsing_algorithm (
  GumboParser* parser,
  GumboToken* token,
  GumboTokenizerEnum lexer_state
) {
  insert_element_from_token(parser, token);
  gumbo_tokenizer_set_state(parser, lexer_state);
  GumboParserState* parser_state = parser->_parser_state;
  parser_state->_original_insertion_mode = parser_state->_insertion_mode;
  parser_state->_insertion_mode = GUMBO_INSERTION_MODE_TEXT;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
callq 0xade5
movq %r14, %rdi
movl %ebx, %esi
callq 0xc86e
movq 0x18(%r14), %rax
movl (%rax), %ecx
movl %ecx, 0x4(%rax)
movl $0x7, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: add_formatting_element
static void add_formatting_element(GumboParser* parser, const GumboNode* node) {
  assert (
    node == &kActiveFormattingScopeMarker
    || node->type == GUMBO_NODE_ELEMENT
  );
  GumboVector* elements = &parser->_parser_state->_active_formatting_elements;
  if (node == &kActiveFormattingScopeMarker) {
    gumbo_debug("Adding a scope marker.\n");
  } else {
    gumbo_debug("Adding a formatting element.\n");
  }

  // Hunt for identical elements.
  int earliest_identical_element = elements->length;
  int num_identical_elements = count_formatting_elements_of_tag (
    parser,
    node,
    &earliest_identical_element
  );

  // Noah's Ark clause: if there're at least 3, remove the earliest.
  if (num_identical_elements >= 3) {
    gumbo_debug (
      "Noah's ark clause: removing element at %d.\n",
      earliest_identical_element
    );
    gumbo_vector_remove_at(earliest_identical_element, elements);
  }

  gumbo_vector_add((void*) node, elements);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xe936(%rip), %rax      # 0x19b28
cmpq %rax, %rsi
je 0xb213
cmpl $0x1, (%rbx)
jne 0xb258
movq 0x18(%rdi), %r14
movl 0x20(%r14), %eax
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
jmp 0xb22c
movq 0x18(%rdi), %r14
movl 0x20(%r14), %eax
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
leaq 0xe8ff(%rip), %rsi      # 0x19b28
movq %r14, %rdi
callq 0xb2c4
addq $0x18, %r14
cmpl $0x3, %eax
jl 0xb246
movl 0x4(%rsp), %edi
movq %r14, %rsi
callq 0x7cb4
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7b25
leaq 0x11930(%rip), %rdi     # 0x1cb8f
leaq 0x106ca(%rip), %rsi     # 0x1b930
leaq 0x1196c(%rip), %rcx     # 0x1cbd9
movl $0x503, %edx            # imm = 0x503
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: generate_all_implied_end_tags_thoroughly
static void generate_all_implied_end_tags_thoroughly(GumboParser* parser) {
  static const TagSet tags = {
    TAG(CAPTION), TAG(COLGROUP), TAG(DD), TAG(DT), TAG(LI), TAG(OPTION),
    TAG(OPTGROUP), TAG(P), TAG(RP), TAG(RT), TAG(RTC), TAG(TBODY),
    TAG(TD), TAG(TFOOT), TAG(TH), TAG(HEAD), TAG(TR)
  };
  while (node_tag_in_set(get_current_node(parser), &tags)) {
    pop_current_node(parser);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7d33
leaq 0xe9d6(%rip), %rsi      # 0x19c60
movq %rax, %rdi
callq 0x86f4
testb %al, %al
je 0xb2bc
leaq 0xe9c3(%rip), %r14      # 0x19c60
movq %rbx, %rdi
callq 0xaffb
movq %rbx, %rdi
callq 0x7d33
movq %rax, %rdi
movq %r14, %rsi
callq 0x86f4
testb %al, %al
jne 0xb29d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: count_formatting_elements_of_tag
static int count_formatting_elements_of_tag (
  GumboParser* parser,
  const GumboNode* desired_node,
  int* earliest_matching_index
) {
  const GumboElement* desired_element = &desired_node->v.element;
  GumboVector* elements = &parser->_parser_state->_active_formatting_elements;
  int num_identical_elements = 0;
  for (int i = elements->length; --i >= 0;) {
    GumboNode* node = elements->data[i];
    if (node == &kActiveFormattingScopeMarker) {
      break;
    }
    assert(node->type == GUMBO_NODE_ELEMENT);
    if (
      node_qualified_tag_is(node, desired_element->tag_namespace, desired_element->tag)
      && all_attributes_match(&node->v.element.attributes, &desired_element->attributes)
    ) {
      num_identical_elements++;
      *earliest_matching_index = i;
    }
  }
  return num_identical_elements;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movslq 0x20(%rdi), %rbp
testq %rbp, %rbp
jle 0xb3b3
movq %rsi, %r15
movq %rdi, %r12
leaq 0x80(%rsi), %r13
xorl %edx, %edx
leaq 0xe82e(%rip), %rsi      # 0x19b28
decq %rbp
movq 0x18(%r12), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %r14
cmpq %rsi, %r14
je 0xb3b5
cmpl $0x1, (%r14)
jne 0xb3c6
movl 0x28(%r14), %eax
cmpl 0x28(%r15), %eax
jne 0xb3a9
movl 0x2c(%r14), %eax
cmpl 0x2c(%r15), %eax
jne 0xb3a9
movl 0x88(%r15), %eax
cmpl $0x0, 0x88(%r14)
je 0xb38f
movq %rax, 0x10(%rsp)
movq %rdx, (%rsp)
xorl %ebx, %ebx
movq 0x80(%r14), %rax
movq (%rax,%rbx,8), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rdx
movq %r13, %rdi
callq 0xb3e5
testb %al, %al
je 0xb39e
incq %rbx
movl 0x88(%r14), %eax
cmpq %rax, %rbx
jb 0xb34f
movq 0x10(%rsp), %rax
subl %ebx, %eax
movq (%rsp), %rdx
leaq 0xe799(%rip), %rsi      # 0x19b28
testl %eax, %eax
jne 0xb3a9
incl %edx
movq 0x8(%rsp), %rax
movl %ebp, (%rax)
jmp 0xb3a9
movq (%rsp), %rdx
leaq 0xe77f(%rip), %rsi      # 0x19b28
testl %ebp, %ebp
jg 0xb2fa
jmp 0xb3b5
xorl %edx, %edx
movl %edx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11a23(%rip), %rdi     # 0x1cdf0
leaq 0x1055c(%rip), %rsi     # 0x1b930
leaq 0x1183c(%rip), %rcx     # 0x1cc17
movl $0x4f2, %edx            # imm = 0x4F2
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: has_an_element_in_specific_scope
static bool has_an_element_in_specific_scope (
  const GumboParser* parser,
  int expected_size,
  const GumboTag* expected,
  bool negate,
  const TagSet* tags
) {
  const GumboVector* open_elements = &parser->_parser_state->_open_elements;
  for (int i = open_elements->length; --i >= 0;) {
    const GumboNode* node = open_elements->data[i];
    if (node->type != GUMBO_NODE_ELEMENT && node->type != GUMBO_NODE_TEMPLATE) {
      continue;
    }

    GumboTag node_tag = node->v.element.tag;
    GumboNamespaceEnum node_ns = node->v.element.tag_namespace;
    for (int j = 0; j < expected_size; ++j) {
      if (node_tag == expected[j] && node_ns == GUMBO_NAMESPACE_HTML) {
        return true;
      }
    }

    bool found = tagset_includes(tags, node_ns, node_tag);
    if (negate != found) {
      return false;
    }
  }
  return false;
}

// Assembly:
movslq 0x10(%rdi), %rax
testq %rax, %rax
jle 0xb47c
pushq %rbp
pushq %rbx
movq 0x8(%rdi), %rdi
movl %esi, %r9d
movq -0x8(%rdi,%rax,8), %r11
movl (%r11), %r10d
cmpl $0x6, %r10d
je 0xb430
cmpl $0x1, %r10d
jne 0xb463
movl 0x28(%r11), %r10d
movl 0x2c(%r11), %r11d
testl %esi, %esi
jle 0xb451
xorl %ebx, %ebx
movl (%rdx,%rbx,4), %ebp
xorl %r10d, %ebp
orl %r11d, %ebp
je 0xb474
incq %rbx
cmpq %rbx, %r9
jne 0xb43e
movzbl (%r8,%r10), %r10d
btl %r11d, %r10d
setb %r10b
xorb %cl, %r10b
jne 0xb481
leaq -0x1(%rax), %r10
cmpq $0x1, %rax
movq %r10, %rax
jg 0xb41c
xorl %eax, %eax
jmp 0xb483
movb $0x1, %al
movb $0x1, %cl
popq %rbx
popq %rbp
jmp 0xb47e
xorl %eax, %eax
andb %cl, %al
retq
movb $0x1, %al
xorl %ecx, %ecx
jmp 0xb478