LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x878c
movq %rsi, %rdx
leaq 0xee3c(%rip), %rcx      # 0x17580
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, 0x30(%rdx)
jne 0x878c
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xa439
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x18(%rbx), %rax
movl $0x2, (%rax)
jmp 0x87d7
movq %rbx, %rdi
callq 0x83cf
jmp 0x87d7
movl 0x30(%rdx), %eax
leaq 0xf14a(%rip), %rcx      # 0x178d0
cmpb $0x0, (%rax,%rcx)
je 0x87b1
pushq $0x8
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7c99
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x18(%rbx), %rax
movl $0x2, (%rax)
movb $0x1, 0x50(%rax)
jmp 0x87d7
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x797d
movq %rbx, %rdi
callq 0x83cf
xorl %eax, %eax
jmp 0x87d9
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xa2ca
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x883a
movq %rsi, %r14
leaq 0xeda0(%rip), %rcx      # 0x17594
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x1, 0x30(%r14)
jne 0x883a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa439
movq 0x18(%rbx), %rcx
movl $0x3, (%rcx)
movq %rax, 0x38(%rcx)
jmp 0x8889
movq %rbx, %rdi
callq 0x83cf
jmp 0x8889
movl 0x30(%r14), %eax
leaq 0xf09c(%rip), %rcx      # 0x178d0
cmpb $0x0, (%rax,%rcx)
je 0x885c
pushq $0x1
popq %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x7c99
movq 0x18(%rbx), %rcx
movl $0x3, (%rcx)
movq %rax, 0x38(%rcx)
movb $0x1, 0x50(%rcx)
jmp 0x8889
movq %rbx, %rdi
movq %r14, %rsi
callq 0x797d
movq %rbx, %rdi
callq 0x83cf
xorl %eax, %eax
jmp 0x888b
movq %rbx, %rdi
callq 0x7913
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xa2ca
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9246
movl %ebp, %eax
andl $-0x2, %eax
cmpl $0x4, %eax
jne 0x9258
movq %rbx, %rdi
callq 0xa59b
jmp 0x92b0
movq %rbx, %rdi
callq 0x797d
movq %rbx, %rdi
callq 0x83cf
jmp 0x92b0
movq 0x18(%rbx), %r14
movq 0x58(%r14), %rax
movq 0x60(%r14), %rcx
xorl %edx, %edx
movabsq $0x100003600, %rsi      # imm = 0x100003600
cmpq %rdx, %rcx
je 0x9297
movzbl (%rax,%rdx), %edi
cmpq $0x20, %rdi
ja 0x928a
btq %rdi, %rsi
jae 0x928a
incq %rdx
jmp 0x9270
movb $0x1, 0x54(%r14)
movq %rbx, %rdi
callq 0xaa2f
movq %rbx, %rdi
callq 0x7ec1
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
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_in_cell
static bool handle_in_cell(GumboParser* parser, GumboToken* token) {
  if (tag_in(token, kEndTag, &td_th_tags)) {
    GumboTag token_tag = token->v.end_tag;
    if (!has_an_element_in_table_scope(parser, token_tag)) {
      parser_add_parse_error(parser, token);
      ignore_token(parser);
      return false;
    }
    return close_table_cell(parser, token, token_tag);
  } else if (
    tag_in(token, kStartTag, &(const TagSet) {
      TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(TBODY), TAG(TD),
      TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR)
    })
  ) {
    gumbo_debug("Handling <td> in cell.\n");
    if (
      !has_an_element_in_table_scope(parser, GUMBO_TAG_TH)
      && !has_an_element_in_table_scope(parser, GUMBO_TAG_TD)
    ) {
      gumbo_debug("Bailing out because there's no <td> or <th> in scope.\n");
      parser_add_parse_error(parser, token);
      ignore_token(parser);
      return false;
    }
    parser->_parser_state->_reprocess_current_token = true;
    return close_current_cell(parser, token);
  } else if (
    tag_in(token, kEndTag, &(const TagSet) {
      TAG(BODY), TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(HTML)
    })
  ) {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  } else if (
    tag_in(token, kEndTag, &(const TagSet) {
      TAG(TABLE), TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TR)
    })
  ) {
    if (!has_an_element_in_table_scope(parser, token->v.end_tag)) {
      parser_add_parse_error(parser, token);
      ignore_token(parser);
      return false;
    }
    parser->_parser_state->_reprocess_current_token = true;
    return close_current_cell(parser, token);
  } else {
    return handle_in_body(parser, token);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x2, %eax
jne 0x985e
movl 0x30(%r14), %r15d
leaq 0xf82f(%rip), %rcx      # 0x19060
cmpb $0x0, (%r15,%rcx)
je 0x985e
movq %rbx, %rdi
movl %r15d, %esi
callq 0xb4f0
testb %al, %al
je 0x98d2
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xba66
cmpl $0x1, %eax
jne 0x988b
movl 0x30(%r14), %ecx
leaq 0xfaea(%rip), %rdx      # 0x19358
cmpb $0x0, (%rcx,%rdx)
je 0x988b
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0xb4f0
testb %al, %al
jne 0x98ba
pushq $0x67
popq %rsi
movq %rbx, %rdi
jmp 0x98b1
cmpl $0x2, %eax
jne 0x98ed
movl 0x30(%r14), %esi
leaq 0xfb55(%rip), %rax      # 0x193f0
cmpb $0x0, (%rsi,%rax)
jne 0x98d2
leaq 0xfbe0(%rip), %rax      # 0x19488
cmpb $0x0, (%rsi,%rax)
je 0x98ed
movq %rbx, %rdi
callq 0xb4f0
testb %al, %al
je 0x98d2
movq 0x18(%rbx), %rax
movb $0x1, 0x50(%rax)
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xbad9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x797d
movq %rbx, %rdi
callq 0x83cf
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4d63
// File: /workspace/github_c_makefile_star2_O2/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 0x9bdc
cmpl $0x1, %eax
jne 0x9c1a
movl 0x30(%r14), %eax
leaq 0xf9f7(%rip), %rcx      # 0x195c0
cmpb $0x0, (%rax,%rcx)
je 0x9c1a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x797d
jmp 0x9c08
movl 0x30(%r14), %eax
leaq 0xf9d9(%rip), %rcx      # 0x195c0
cmpb $0x0, (%rax,%rcx)
je 0x9c1a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x797d
movl 0x30(%r14), %esi
movq %rbx, %rdi
callq 0xb4f0
testb %al, %al
je 0x9c2c
movq %rbx, %rdi
callq 0xbb85
movq 0x18(%rbx), %rax
movb $0x1, 0x50(%rax)
jmp 0x9c34
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x98fd
movq %rbx, %rdi
callq 0x83cf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9ead
movb $0x1, %bl
leaq 0xd7c8(%rip), %rcx      # 0x17620
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rdx, %rsi
callq 0x797d
movq %r14, %rdi
callq 0x83cf
jmp 0x9ec6
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x9f2a
movq %r14, %rdi
callq 0xa2ca
jmp 0x9ec8
cmpl $0x0, 0x30(%rdx)
jne 0x9ead
movq %r14, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4d63
cmpl $0x0, 0x30(%rdx)
je 0x9ed0
movq %r14, %rdi
movq %rdx, %rsi
callq 0x797d
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 0x9e61
movl $0x15, (%rax)
movq 0x8(%rax), %rax
movq (%rax), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x82b7
testb %al, %al
je 0x9f49
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 0x9f21
movups 0x20(%rax), %xmm0
jmp 0x9f24
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
jmp 0x9ec8
leaq 0x11560(%rip), %rdi     # 0x1b491
leaq 0xf968(%rip), %rsi      # 0x198a0
leaq 0x11564(%rip), %rcx     # 0x1b4a3
movl $0xf7b, %edx            # imm = 0xF7B
callq 0x4100
leaq 0x11588(%rip), %rdi     # 0x1b4d8
leaq 0xf949(%rip), %rsi      # 0x198a0
leaq 0x11545(%rip), %rcx     # 0x1b4a3
movl $0xf8b, %edx            # imm = 0xF8B
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x8, %rax
ja 0xa11e
movb $0x1, %bpl
leaq 0xd58c(%rip), %rcx      # 0x17668
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x30(%r14), %eax
cmpl $0x82, %eax
je 0xa191
testl %eax, %eax
jne 0xa11e
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x4d63
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa59b
jmp 0xa1b1
cmpl $0x0, 0x30(%r14)
je 0xa14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x797d
movq %rbx, %rdi
callq 0x83cf
xorl %ebp, %ebp
jmp 0xa1b1
movq %rbx, %rdi
callq 0x7913
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xa2ca
jmp 0xa1b1
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x82b7
testb %al, %al
je 0xa1b8
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x78(%r14)
movups 0x8(%rax), %xmm0
movups %xmm0, 0x68(%r14)
addq $0x40, %r14
cmpl $0x2, (%rax)
jne 0xa1a0
movups 0x20(%rax), %xmm0
jmp 0xa1a3
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x8893
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq 0x18(%rbx), %rax
movl $0x16, (%rax)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x11319(%rip), %rdi     # 0x1b4d8
leaq 0xf6da(%rip), %rsi      # 0x198a0
leaq 0x11332(%rip), %rcx     # 0x1b4ff
movl $0xfde, %edx            # imm = 0xFDE
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0xa212
movb $0x1, %bpl
leaq 0xd49a(%rip), %rcx      # 0x1768c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4d63
cmpl $0x0, 0x30(%rdx)
je 0xa1fb
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x797d
movq 0x18(%rbx), %rax
movl $0x6, (%rax)
movb $0x1, 0x50(%rax)
xorl %ebp, %ebp
jmp 0xa23e
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xa2ca
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa28a
movb $0x1, %bpl
leaq 0xd44e(%rip), %rcx      # 0x176b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4d63
movl 0x30(%rdx), %eax
cmpl $0x82, %eax
je 0xa2b9
testl %eax, %eax
je 0xa26b
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x797d
movq %rbx, %rdi
callq 0x83cf
xorl %ebp, %ebp
jmp 0xa2b0
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xa2ca
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 0x8893
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq 0x7ec1
pushq $0x4
popq %rdi
callq 0x7bec
movl $0x4, (%rax)
andl $0x0, 0x14(%rax)
movq 0x30(%rbx), %rcx
movq %rcx, 0x18(%rax)
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x20(%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x40(%rax)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x30(%rax)
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x82fd
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%r14), %r12
testq %r12, %r12
je 0xa36c
testb %bl, %bl
je 0xa347
movq %r14, %rdi
movq %r15, %rsi
callq 0xa37e
jmp 0xa362
movq %r15, %rdi
callq 0x40b0
cmpq %r12, %rax
jne 0xa366
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xa3b5
testb %al, %al
jne 0xa36c
addq $0x10, %r14
jmp 0xa32d
testq %r12, %r12
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/string_piece.h
// Function: string_piece_equal_cstr
static inline PURE NONNULL_ARGS bool string_piece_equal_cstr (
  const GumboStringPiece *piece,
  const char *cstr
) {
  const size_t cstr_len = strlen(cstr);
  return
    cstr_len == piece->length
    && memcmp(piece->data, cstr, cstr_len) == 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x40b0
cmpq 0x8(%r14), %rax
jne 0xa3ab
movq (%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x4200
testl %eax, %eax
sete %al
jmp 0xa3ad
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/ascii.h
// Function: mem_equal_icase
static inline bool mem_equal_icase(const void *p1, const void *p2, size_t n)
{
  const unsigned char *s1 = p1;
  const unsigned char *s2 = p2;
  while (n) {
    if (ascii_tolower(*s1++) != ascii_tolower(*s2++)) {
      return false;
    }
    n--;
  }
  return true;
}

// Assembly:
xorl %eax, %eax
leaq 0xbd92(%rip), %rcx      # 0x16150
cmpq %rax, %rdx
je 0xa3ed
movzbl (%rdi,%rax), %r8d
movb (%rcx,%r8), %r9b
andb $0x20, %r9b
orb %r8b, %r9b
movzbl (%rsi,%rax), %r8d
movb (%rcx,%r8), %r10b
andb $0x20, %r10b
orb %r8b, %r10b
cmpb %r10b, %r9b
jne 0xa3ed
incq %rax
jmp 0xa3be
cmpq %rax, %rdx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testl %ecx, %ecx
jne 0xa409
cmpb $0x1, 0x1a(%r14)
jne 0xa42f
movq 0x8(%r14), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0xa37e
testb %al, %al
je 0xa42f
movq 0x10(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa37e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa46c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7e84
movl 0x28(%r14), %edi
callq 0x730c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
cmpl $0x1, (%rdi)
jne 0xa51f
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
je 0xa487
pushq $0x1
popq %rdi
jmp 0xa495
xorl %eax, %eax
cmpl $0x9, 0x30(%rbx)
sete %al
leal (%rax,%rax,4), %edi
incl %edi
callq 0x7bec
movq %rax, %r14
leaq 0x18(%rax), %rsi
pushq $0x1
popq %rdi
callq 0x76f4
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 0xa53e
leaq 0x20(%rbx), %rax
movq (%rax), %rdx
cmpb $0x3c, (%rdx)
jne 0xa55d
cmpb $0x3e, -0x1(%rdx,%rcx)
jne 0xa57c
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)
andq $0x0, 0x78(%r14)
leaq 0x38(%rbx), %rax
movups %xmm0, 0x68(%r14)
movups %xmm0, (%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10337(%rip), %rdi     # 0x1a85d
leaq 0xf373(%rip), %rsi      # 0x198a0
leaq 0x1034e(%rip), %rcx     # 0x1a882
movl $0x426, %edx            # imm = 0x426
callq 0x4100
leaq 0x10384(%rip), %rdi     # 0x1a8c9
leaq 0xf354(%rip), %rsi      # 0x198a0
leaq 0x1032f(%rip), %rcx     # 0x1a882
movl $0x439, %edx            # imm = 0x439
callq 0x4100
leaq 0x10386(%rip), %rdi     # 0x1a8ea
leaq 0xf335(%rip), %rsi      # 0x198a0
leaq 0x10310(%rip), %rcx     # 0x1a882
movl $0x43a, %edx            # imm = 0x43A
callq 0x4100
leaq 0x1038b(%rip), %rdi     # 0x1a90e
leaq 0xf316(%rip), %rsi      # 0x198a0
leaq 0x102f1(%rip), %rcx     # 0x1a882
movl $0x43b, %edx            # imm = 0x43B
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0xa601
movq %rsi, %rbx
movq 0x18(%rdi), %r14
leaq 0x58(%r14), %rsi
cmpq $0x0, 0x60(%r14)
jne 0xa5d7
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 0x42a0
movl (%rbx), %eax
cmpl $0x5, %eax
je 0xa5ef
cmpl $0x6, %eax
jne 0xa5f9
pushq $0x3
jmp 0xa5f1
pushq $0x2
popq %rax
movl %eax, 0x90(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x103a1(%rip), %rdi     # 0x1a9a9
leaq 0xf291(%rip), %rsi      # 0x198a0
leaq 0x10428(%rip), %rcx     # 0x1aa3e
movl $0x4ac, %edx            # imm = 0x4AC
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0xa439
movq %r14, %rdi
movl %ebx, %esi
callq 0xbc80
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
leaq 0xd298(%rip), %rbp      # 0x17a98
cmpq %rbp, %rsi
je 0xa80e
cmpl $0x1, (%rbx)
jne 0xa927
movq 0x18(%rdi), %r14
movl 0x20(%r14), %r15d
addq $0x18, %r14
leaq 0x80(%rbx), %r12
movq $0x0, 0x8(%rsp)
movq %r15, (%rsp)
testl %r15d, %r15d
jle 0xa8dc
decq %r15
movq (%r14), %rax
movl %r15d, %ecx
movq (%rax,%rcx,8), %r13
cmpq %rbp, %r13
je 0xa8dc
cmpl $0x1, (%r13)
jne 0xa908
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %esi
movq %r13, %rdi
callq 0x82bd
testb %al, %al
je 0xa82e
movq %r14, %rbp
movl 0x88(%rbx), %eax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
movl 0x88(%r13), %eax
cmpq %rax, %r14
jae 0xa8ab
movq 0x80(%r13), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rdx
movq %r12, %rdi
callq 0xa99f
testb %al, %al
je 0xa8cd
incq %r14
jmp 0xa87b
xorl %eax, %eax
cmpl %r14d, 0x10(%rsp)
sete %al
movq (%rsp), %rcx
cmovel %r15d, %ecx
movq %rcx, (%rsp)
movq 0x8(%rsp), %rcx
addl %eax, %ecx
movq %rcx, 0x8(%rsp)
movq %rbp, %r14
leaq 0xd1c1(%rip), %rbp      # 0x17a98
jmp 0xa82e
cmpl $0x3, 0x8(%rsp)
jb 0xa8ef
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x7895
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7726
leaq 0x10451(%rip), %rdi     # 0x1ad60
leaq 0xef8a(%rip), %rsi      # 0x198a0
leaq 0x1026a(%rip), %rcx     # 0x1ab87
movl $0x4f2, %edx            # imm = 0x4F2
callq 0x4100
leaq 0x101d1(%rip), %rdi     # 0x1aaff
leaq 0xef6b(%rip), %rsi      # 0x198a0
leaq 0x1020d(%rip), %rcx     # 0x1ab49
movl $0x503, %edx            # imm = 0x503
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: clear_active_formatting_elements
static void clear_active_formatting_elements(GumboParser* parser) {
  GumboVector* elements = &parser->_parser_state->_active_formatting_elements;
  int num_elements_cleared = 0;
  const GumboNode* node;
  do {
    node = gumbo_vector_pop(elements);
    ++num_elements_cleared;
  } while (node && node != &kActiveFormattingScopeMarker);
  gumbo_debug (
    "Cleared %d elements from active formatting list.\n",
    num_elements_cleared
  );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rbx
addq $0x18, %rbx
leaq 0xd120(%rip), %r14      # 0x17a98
movq %rbx, %rdi
callq 0x77ca
testq %rax, %rax
je 0xa98a
cmpq %r14, %rax
jne 0xa978
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq 0x18(%rdi), %rax
movl 0x10(%rax), %edi
xorl %r9d, %r9d
testl %esi, %esi
cmovlel %r9d, %esi
testl %edi, %edi
jle 0xaa27
movq 0x8(%rax), %r9
movq -0x8(%r9,%rdi,8), %r10
decq %rdi
movl (%r10), %r9d
cmpl $0x6, %r9d
je 0xa9f4
cmpl $0x1, %r9d
jne 0xa9d5
movl 0x28(%r10), %r9d
movl 0x2c(%r10), %r10d
xorl %r11d, %r11d
cmpq %r11, %rsi
je 0xaa15
movl (%rdx,%r11,4), %ebx
xorl %r9d, %ebx
incq %r11
orl %r10d, %ebx
jne 0xa9ff
jmp 0xaa2b
movzbl (%r8,%r9), %r9d
btl %r10d, %r9d
setb %r9b
cmpb %cl, %r9b
je 0xa9d5
xorl %eax, %eax
jmp 0xaa2d
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: reconstruct_active_formatting_elements
static void reconstruct_active_formatting_elements(GumboParser* parser) {
  GumboVector* elements = &parser->_parser_state->_active_formatting_elements;
  // Step 1
  if (elements->length == 0) {
    return;
  }

  // Step 2 & 3
  unsigned int i = elements->length - 1;
  GumboNode* element = elements->data[i];
  if (
    element == &kActiveFormattingScopeMarker
    || is_open_element(parser, element)
  ) {
    return;
  }

  // Step 6
  do {
    if (i == 0) {
      // Step 4
      i = -1;  // Incremented to 0 below.
      break;
    }
    // Step 5
    element = elements->data[--i];
  } while (
    element != &kActiveFormattingScopeMarker
    && !is_open_element(parser, element)
  );

  ++i;
  gumbo_debug (
    "Reconstructing elements from %u on %s parent.\n",
    i,
    gumbo_normalized_tagname(get_current_node(parser)->v.element.tag)
  );
  for (; i < elements->length; ++i) {
    // Step 7 & 8.
    assert(elements->length > 0);
    assert(i < elements->length);
    element = elements->data[i];
    assert(element != &kActiveFormattingScopeMarker);
    GumboNode* clone = clone_node (
      element,
      GUMBO_INSERTION_RECONSTRUCTED_FORMATTING_ELEMENT
    );
    // Step 9.
    InsertionLocation location =
        get_appropriate_insertion_location(parser, NULL);
    insert_node(clone, location);
    gumbo_vector_add (
      (void*) clone,
      &parser->_parser_state->_open_elements
    );

    // Step 10.
    elements->data[i] = clone;
    gumbo_debug (
      "Reconstructed %s element at %u.\n",
      gumbo_normalized_tagname(clone->v.element.tag),
      i
    );
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdi), %r15
movl 0x20(%r15), %r14d
testl %r14d, %r14d
je 0xaa6b
decl %r14d
movq 0x18(%r15), %r13
movq (%r13,%r14,8), %rsi
leaq 0xd03e(%rip), %r12      # 0x17a98
cmpq %r12, %rsi
je 0xaa6b
movq %rdi, %rbx
callq 0xb776
testb %al, %al
je 0xaa7a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rbp
subq $0x1, %r14
jb 0xaa99
movq (%r13,%r14,8), %rsi
cmpq %r12, %rsi
je 0xaa99
movq %rbx, %rdi
callq 0xb776
testb %al, %al
je 0xaa7a
movq %rbx, %rdi
callq 0x7913
movl 0x28(%rax), %edi
callq 0x730c
movl %ebp, %r13d
movl 0x20(%r15), %eax
cmpq %rax, %r13
jae 0xaa6b
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %rdi
cmpq %r12, %rdi
je 0xab0a
movl $0x80, %esi
callq 0xb79c
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7fcf
movq %r14, %rdi
movq %rax, %rsi
callq 0x80dd
movq 0x18(%rbx), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x7726
movq 0x18(%r15), %rax
movq %r14, (%rax,%r13,8)
movl 0x28(%r14), %edi
callq 0x730c
incq %r13
jmp 0xaaac
leaq 0x102d5(%rip), %rdi     # 0x1ade6
leaq 0xed88(%rip), %rsi      # 0x198a0
leaq 0x1028c(%rip), %rcx     # 0x1adab
movl $0x577, %edx            # imm = 0x577
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: merge_attributes
static void merge_attributes (
  GumboToken* token,
  GumboNode* node
) {
  assert(token->type == GUMBO_TOKEN_START_TAG);
  assert(node->type == GUMBO_NODE_ELEMENT);
  const GumboVector* token_attr = &token->v.start_tag.attributes;
  GumboVector* node_attr = &node->v.element.attributes;

  for (unsigned int i = 0; i < token_attr->length; ++i) {
    GumboAttribute* attr = token_attr->data[i];
    if (!gumbo_get_attribute(node_attr, attr->name)) {
      // Ownership of the attribute is transferred by this gumbo_vector_add,
      // so it has to be nulled out of the original token so it doesn't get
      // double-deleted.
      gumbo_vector_add(attr, node_attr);
      token_attr->data[i] = NULL;
    }
  }
  // When attributes are merged, it means the token has been ignored and merged
  // with another token, so we need to free its memory. The attributes that are
  // transferred need to be nulled-out in the vector above so that they aren't
  // double-deleted.
  gumbo_token_destroy(token);

#ifndef NDEBUG
  // 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x1, (%rdi)
jne 0xaba5
movq %rsi, %r14
cmpl $0x1, (%rsi)
jne 0xabc4
movq %rdi, %rbx
leaq 0x38(%rdi), %r12
subq $-0x80, %r14
xorl %r13d, %r13d
movl 0x40(%rbx), %eax
cmpq %rax, %r13
jae 0xab8b
movq (%r12), %rax
movq (%rax,%r13,8), %r15
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x6b4c
testq %rax, %rax
jne 0xab86
movq %r15, %rdi
movq %r14, %rsi
callq 0x7726
movq (%r12), %rax
andq $0x0, (%rax,%r13,8)
incq %r13
jmp 0xab51
movq %rbx, %rdi
callq 0xbd9f
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xfcb1(%rip), %rdi      # 0x1a85d
leaq 0xeced(%rip), %rsi      # 0x198a0
leaq 0x10289(%rip), %rcx     # 0x1ae43
movl $0x72b, %edx            # imm = 0x72B
callq 0x4100
leaq 0x10195(%rip), %rdi     # 0x1ad60
leaq 0xecce(%rip), %rsi      # 0x198a0
leaq 0x1026a(%rip), %rcx     # 0x1ae43
movl $0x72c, %edx            # imm = 0x72C
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: maybe_implicitly_close_list_tag
static void maybe_implicitly_close_list_tag (
  GumboParser* parser,
  GumboToken* token,
  bool is_li
) {
  GumboParserState* state = parser->_parser_state;
  state->_frameset_ok = false;
  for (int i = state->_open_elements.length; --i >= 0;) {
    const GumboNode* node = state->_open_elements.data[i];
    bool is_list_tag = is_li
      ? node_html_tag_is(node, GUMBO_TAG_LI)
      : node_tag_in_set(node, &dd_dt_tags)
    ;
    if (is_list_tag) {
      implicitly_close_tags (
        parser,
        token,
        node->v.element.tag_namespace,
        node->v.element.tag
      );
      return;
    }
    if (
      is_special_node(node)
      && !node_tag_in_set(node, &(const TagSet){TAG(ADDRESS), TAG(DIV), TAG(P)})
    ) {
      return;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x18(%rdi), %r14
movb $0x0, 0x52(%r14)
movl 0x10(%r14), %r12d
pushq $0x1f
popq %r15
leaq 0xdb6c(%rip), %r13      # 0x187d0
testl %r12d, %r12d
jle 0xacb4
movq 0x8(%r14), %rax
movq -0x8(%rax,%r12,8), %rbx
movq %rbx, %rdi
testb %bpl, %bpl
je 0xac84
movl %r15d, %esi
callq 0x82b7
jmp 0xac8c
movq %r13, %rsi
callq 0x8272
testb %al, %al
jne 0xacc3
movq %rbx, %rdi
callq 0xb73e
testb %al, %al
je 0xacaf
movq %rbx, %rdi
leaq 0xda92(%rip), %rsi      # 0x18738
callq 0x8272
testb %al, %al
je 0xacb4
decq %r12
jmp 0xac64
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x28(%rbx), %ecx
movl 0x2c(%rbx), %edx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xace3
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: implicitly_close_tags
static bool implicitly_close_tags (
  GumboParser* parser,
  GumboToken* token,
  GumboNamespaceEnum target_ns,
  GumboTag target
) {
  bool result = true;
  generate_implied_end_tags(parser, target);
  if (!node_qualified_tag_is(get_current_node(parser), target_ns, target)) {
    parser_add_parse_error(parser, token);
    while (
      !node_qualified_tag_is(get_current_node(parser), target_ns, target)
    ) {
      pop_current_node(parser);
    }
    result = false;
  }
  assert(node_qualified_tag_is(get_current_node(parser), target_ns, target));
  pop_current_node(parser);
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
movl %ecx, %esi
callq 0xad93
movq %rbx, %rdi
callq 0x7913
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x82bd
movl %eax, %r15d
testb %al, %al
je 0xad46
movq %rbx, %rdi
callq 0x7913
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x82bd
testb %al, %al
je 0xad74
movq %rbx, %rdi
callq 0xa620
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r12, %rsi
callq 0x797d
movq %rbx, %rdi
callq 0x7913
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x82bd
testb %al, %al
jne 0xad19
movq %rbx, %rdi
callq 0xa620
jmp 0xad51
leaq 0x100f9(%rip), %rdi     # 0x1ae74
leaq 0xeb1e(%rip), %rsi      # 0x198a0
leaq 0x1012e(%rip), %rcx     # 0x1aeb7
movl $0x6ee, %edx            # imm = 0x6EE
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: generate_implied_end_tags
static void generate_implied_end_tags(GumboParser* parser, GumboTag exception) {
  static const TagSet tags = {
    TAG(DD), TAG(DT), TAG(LI), TAG(OPTION), TAG(OPTGROUP),
    TAG(P), TAG(RP), TAG(RB), TAG(RT), TAG(RTC)
  };
  while (
    node_tag_in_set(get_current_node(parser), &tags)
    && !node_html_tag_is(get_current_node(parser), exception)
  ) {
    pop_current_node(parser);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0xdacc(%rip), %r15      # 0x18870
movq %r14, %rdi
callq 0x7913
movq %rax, %rdi
movq %r15, %rsi
callq 0x8272
testb %al, %al
je 0xaddb
movq %r14, %rdi
callq 0x7913
movq %rax, %rdi
movl %ebx, %esi
callq 0x82b7
testb %al, %al
jne 0xaddb
movq %r14, %rdi
callq 0xa620
jmp 0xada4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: find_last_anchor_index
static bool find_last_anchor_index(GumboParser* parser, int* anchor_index) {
  GumboVector* elements = &parser->_parser_state->_active_formatting_elements;
  for (int i = elements->length; --i >= 0;) {
    GumboNode* node = elements->data[i];
    if (node == &kActiveFormattingScopeMarker) {
      return false;
    }
    if (node_html_tag_is(node, GUMBO_TAG_A)) {
      *anchor_index = i;
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rdi), %r15
movl 0x20(%r15), %r14d
movq %r14, %r12
decq %r12
leaq 0xcc75(%rip), %r13      # 0x17a98
pushq $0x27
popq %rbp
testl %r14d, %r14d
jle 0xae50
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rdi
cmpq %r13, %rdi
je 0xae50
movl %ebp, %esi
callq 0x82b7
decl %r14d
decq %r12
testb %al, %al
je 0xae26
movl %r14d, (%rbx)
movb $0x1, %al
jmp 0xae52
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_O2/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: adjust_mathml_attributes
static void adjust_mathml_attributes(GumboToken* token) {
  assert(token->type == GUMBO_TOKEN_START_TAG);
  GumboAttribute* attr = gumbo_get_attribute (
    &token->v.start_tag.attributes,
    "definitionurl"
  );
  if (!attr) {
    return;
  }
  gumbo_free((void*) attr->name);
  attr->name = gumbo_strdup("definitionURL");
}

// Assembly:
pushq %rbx
cmpl $0x1, (%rdi)
jne 0xb544
addq $0x38, %rdi
leaq 0xfcc1(%rip), %rsi      # 0x1b1dd
callq 0x6b4c
testq %rax, %rax
je 0xb542
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0xf6e0
leaq 0xfcb2(%rip), %rdi      # 0x1b1eb
callq 0xf6e5
movq %rax, 0x8(%rbx)
popq %rbx
retq
leaq 0xf312(%rip), %rdi      # 0x1a85d
leaq 0xe34e(%rip), %rsi      # 0x198a0
leaq 0xfc58(%rip), %rcx      # 0x1b1b1
movl $0x77b, %edx            # imm = 0x77B
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: adjust_foreign_attributes
static void adjust_foreign_attributes(GumboToken* token) {
  assert(token->type == GUMBO_TOKEN_START_TAG);
  const GumboVector* attributes = &token->v.start_tag.attributes;
  for (unsigned int i = 0, n = attributes->length; i < n; ++i) {
    GumboAttribute* attr = attributes->data[i];
    const ForeignAttrReplacement* entry = gumbo_get_foreign_attr_replacement (
      attr->name,
      strlen(attr->name)
    );
    if (!entry) {
      continue;
    }
    gumbo_free((void*) attr->name);
    attr->attr_namespace = entry->attr_namespace;
    attr->name = gumbo_strdup(entry->local_name);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x1, (%rdi)
jne 0xb5d4
movq %rdi, %rbx
movl 0x40(%rdi), %r15d
xorl %r12d, %r12d
cmpq %r12, %r15
je 0xb5ca
movq 0x38(%rbx), %rax
movq (%rax,%r12,8), %r13
movq 0x8(%r13), %r14
movq %r14, %rdi
callq 0x40b0
movq %r14, %rdi
movq %rax, %rsi
callq 0x152b4
testq %rax, %rax
je 0xb5c5
movq %rax, %r14
movq 0x8(%r13), %rdi
callq 0xf6e0
movl 0x10(%r14), %eax
movl %eax, (%r13)
movq 0x8(%r14), %rdi
callq 0xf6e5
movq %rax, 0x8(%r13)
incq %r12
jmp 0xb57b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xf282(%rip), %rdi      # 0x1a85d
leaq 0xe2be(%rip), %rsi      # 0x198a0
leaq 0xfc10(%rip), %rcx      # 0x1b1f9
movl $0x753, %edx            # imm = 0x753
callq 0x4100