LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xb668
movq %rsi, %r14
cmpl $0x1, (%rsi)
jne 0xb687
movq %rdi, %rbx
leaq 0x38(%rdi), %r12
cmpl $0x0, 0x40(%rdi)
je 0xb64e
subq $-0x80, %r14
xorl %r13d, %r13d
movq (%r12), %rax
movq (%rax,%r13,8), %r15
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x6e94
testq %rax, %rax
jne 0xb643
movq %r15, %rdi
movq %r14, %rsi
callq 0x7b25
movq (%r12), %rax
movq $0x0, (%rax,%r13,8)
incq %r13
movl 0x40(%rbx), %eax
cmpq %rax, %r13
jb 0xb613
movq %rbx, %rdi
callq 0xc990
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1127e(%rip), %rdi     # 0x1c8ed
leaq 0x102ba(%rip), %rsi     # 0x1b930
leaq 0x11856(%rip), %rcx     # 0x1ced3
movl $0x72b, %edx            # imm = 0x72B
callq 0x4100
leaq 0x11762(%rip), %rdi     # 0x1cdf0
leaq 0x1029b(%rip), %rsi     # 0x1b930
leaq 0x11837(%rip), %rcx     # 0x1ced3
movl $0x72c, %edx            # imm = 0x72C
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: maybe_implicitly_close_p_tag
static bool maybe_implicitly_close_p_tag (
  GumboParser* parser,
  GumboToken* token
) {
  if (has_an_element_in_button_scope(parser, GUMBO_TAG_P)) {
    return implicitly_close_tags (
      parser,
      token,
      GUMBO_NAMESPACE_HTML,
      GUMBO_TAG_P
    );
  }
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x4(%rsp), %rdx
movl $0x19, (%rdx)
leaq 0xf2da(%rip), %r8       # 0x1a9a0
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xb40a
testb %al, %al
je 0xb6ef
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x19, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb7bc
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: 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
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x18(%rdi), %rbx
movb $0x0, 0x52(%rbx)
movl 0x10(%rbx), %r15d
testl %r15d, %r15d
jle 0xb78b
movl %edx, %ebp
leaq 0xf135(%rip), %r12      # 0x1a860
leal -0x1(%r15), %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %r13
movq %r13, %rdi
testb %bpl, %bpl
je 0xb74d
xorl %esi, %esi
movl $0x1f, %edx
callq 0x8739
jmp 0xb755
movq %r12, %rsi
callq 0x86f4
testb %al, %al
jne 0xb79a
movq %r13, %rdi
callq 0xc299
testb %al, %al
je 0xb780
movq %r13, %rdi
leaq 0xf059(%rip), %rsi      # 0x1a7c8
callq 0x86f4
testb %al, %al
je 0xb78b
cmpl $0x1, %r15d
ja 0xb786
jmp 0xb78b
cmpl $0x2, %r15d
jb 0xb78b
movl %r14d, %r15d
jmp 0xb72b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x28(%r13), %ecx
movl 0x2c(%r13), %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 0xb7bc
// File: /workspace/github_c_makefile_star2_O3/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 0xb86c
movq %rbx, %rdi
callq 0x7d33
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x8739
movl %eax, %r15d
testb %al, %al
je 0xb81f
movq %rbx, %rdi
callq 0x7d33
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x8739
testb %al, %al
je 0xb84d
movq %rbx, %rdi
callq 0xaffb
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7d9d
movq %rbx, %rdi
callq 0x7d33
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x8739
testb %al, %al
jne 0xb7f2
movq %rbx, %rdi
callq 0xaffb
jmp 0xb82a
leaq 0x116b0(%rip), %rdi     # 0x1cf04
leaq 0x100d5(%rip), %rsi     # 0x1b930
leaq 0x116e5(%rip), %rcx     # 0x1cf47
movl $0x6ee, %edx            # imm = 0x6EE
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/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
callq 0x7d33
leaq 0xf07e(%rip), %rsi      # 0x1a900
movq %rax, %rdi
callq 0x86f4
testb %al, %al
je 0xb8cc
leaq 0xf06b(%rip), %r15      # 0x1a900
movq %r14, %rdi
callq 0x7d33
movq %rax, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x8739
testb %al, %al
jne 0xb8cc
movq %r14, %rdi
callq 0xaffb
movq %r14, %rdi
callq 0x7d33
movq %rax, %rdi
movq %r15, %rsi
callq 0x86f4
testb %al, %al
jne 0xb895
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: has_node_in_scope
static bool has_node_in_scope(const GumboParser* parser, const GumboNode* node) {
  const TagSet* tags = &default_scope_tags;
  const GumboVector* open_elements = &parser->_parser_state->_open_elements;
  for (int i = open_elements->length; --i >= 0;) {
    const GumboNode* current = open_elements->data[i];
    const GumboNodeType type = current->type;
    if (current == node) {
      return true;
    } else if (type != GUMBO_NODE_ELEMENT && type != GUMBO_NODE_TEMPLATE) {
      continue;
    } else if (node_tag_in_set(current, tags)) {
      return false;
    }
  }
  assert(false);
  return false;
}

// Assembly:
pushq %rax
movslq 0x10(%rdi), %rax
testq %rax, %rax
jle 0xb91f
movq 0x8(%rdi), %rcx
incq %rax
leaq 0xeda6(%rip), %rdx      # 0x1a690
movq -0x10(%rcx,%rax,8), %rdi
cmpq %rsi, %rdi
je 0xb93e
movl (%rdi), %r8d
cmpl $0x6, %r8d
je 0xb903
cmpl $0x1, %r8d
jne 0xb916
movl 0x28(%rdi), %r8d
movl 0x2c(%rdi), %r9d
movzbl (%r8,%rdx), %r8d
btl %r9d, %r8d
jb 0xb93e
decq %rax
cmpq $0x1, %rax
ja 0xb8ea
leaq 0x11678(%rip), %rdi     # 0x1cf9e
leaq 0x10003(%rip), %rsi     # 0x1b930
leaq 0x11670(%rip), %rcx     # 0x1cfa4
movl $0x62f, %edx            # imm = 0x62F
callq 0x4100
cmpq %rsi, %rdi
sete %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x20(%rdi), %r15d
movq %r15, %r12
decq %r12
leaq 0xe1c2(%rip), %r13      # 0x19b28
testl %r15d, %r15d
jle 0xb995
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
cmpq %r13, %rdi
je 0xb995
xorl %esi, %esi
movl $0x27, %edx
callq 0x8739
decl %r15d
decq %r12
testb %al, %al
je 0xb966
movl %r15d, (%rbx)
movb $0x1, %al
jmp 0xb997
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc099
addq $0x38, %rdi
leaq 0x111fc(%rip), %rsi     # 0x1d26d
callq 0x6e94
testq %rax, %rax
je 0xc097
movq %rax, %rbx
movq 0x8(%rax), %rdi
callq 0x113f8
leaq 0x111ed(%rip), %rdi     # 0x1d27b
callq 0x113fd
movq %rax, 0x8(%rbx)
popq %rbx
retq
leaq 0x1084d(%rip), %rdi     # 0x1c8ed
leaq 0xf889(%rip), %rsi      # 0x1b930
leaq 0x11193(%rip), %rcx     # 0x1d241
movl $0x77b, %edx            # imm = 0x77B
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/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 0xc12c
movq %rdi, %rbx
movl 0x40(%rdi), %r15d
testq %r15, %r15
je 0xc122
xorl %r12d, %r12d
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 0x17010
testq %rax, %rax
je 0xc11a
movq %rax, %r14
movq 0x8(%r13), %rdi
callq 0x113f8
movl 0x10(%r14), %eax
movl %eax, (%r13)
movq 0x8(%r14), %rdi
callq 0x113fd
movq %rax, 0x8(%r13)
incq %r12
cmpq %r12, %r15
jne 0xc0d5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x107ba(%rip), %rdi     # 0x1c8ed
leaq 0xf7f6(%rip), %rsi      # 0x1b930
leaq 0x11148(%rip), %rcx     # 0x1d289
movl $0x753, %edx            # imm = 0x753
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: insert_foreign_element
static GumboNode* insert_foreign_element (
  GumboParser* parser,
  GumboToken* token,
  GumboNamespaceEnum tag_namespace
) {
  assert(token->type == GUMBO_TOKEN_START_TAG);
  GumboNode* element = create_element_from_token(token, tag_namespace);
  insert_element(parser, element, false);
  if (
    token_has_attribute(token, "xmlns")
    && !attribute_matches_case_sensitive (
      &token->v.start_tag.attributes,
      "xmlns",
      kLegalXmlns[tag_namespace]
    )
  ) {
    // TODO(jdtang): Since there're multiple possible error codes here, we
    // eventually need reason codes to differentiate them.
    parser_add_parse_error(parser, token);
  }
  if (
    token_has_attribute(token, "xmlns:xlink")
    && !attribute_matches_case_sensitive (
      &token->v.start_tag.attributes,
      "xmlns:xlink",
      "http://www.w3.org/1999/xlink"
    )
  ) {
    parser_add_parse_error(parser, token);
  }
  return element;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x1, (%rsi)
jne 0xc1f9
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl %edx, %esi
callq 0xae18
movq %r14, %rdi
movq %rax, %rsi
callq 0x82d6
leaq 0x1118d(%rip), %rsi     # 0x1d309
movq %rbx, %rdi
callq 0xc4a3
testb %al, %al
je 0xc1b7
leaq 0x38(%rbx), %rdi
movl %ebp, %eax
leaq 0xe9e3(%rip), %rcx      # 0x1ab78
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
leaq 0x11166(%rip), %rsi     # 0x1d309
callq 0xb3e5
testb %al, %al
jne 0xc1b7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7d9d
leaq 0x11151(%rip), %rsi     # 0x1d30f
movq %rbx, %rdi
callq 0xc4a3
testb %al, %al
je 0xc1e5
leaq 0x38(%rbx), %rdi
leaq 0x1113a(%rip), %rsi     # 0x1d30f
leaq 0x1113f(%rip), %rdx     # 0x1d31b
callq 0xb3e5
testb %al, %al
je 0xc1ea
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x7d9d
leaq 0x106ed(%rip), %rdi     # 0x1c8ed
leaq 0xf729(%rip), %rsi      # 0x1b930
leaq 0x110a8(%rip), %rcx     # 0x1d2b6
movl $0x48a, %edx            # imm = 0x48A
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: adjust_svg_attributes
static void adjust_svg_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 = (GumboAttribute*) attributes->data[i];
    const StringReplacement* replacement = gumbo_get_svg_attr_replacement (
      attr->name,
      attr->original_name.length
    );
    if (!replacement) {
      continue;
    }
    gumbo_free((void*) attr->name);
    attr->name = gumbo_strdup(replacement->to);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x1, (%rdi)
jne 0xc27a
movq %rdi, %rbx
movl 0x40(%rdi), %r15d
testq %r15, %r15
je 0xc270
xorl %r12d, %r12d
movq 0x38(%rbx), %rax
movq (%rax,%r12,8), %r13
movq 0x8(%r13), %rdi
movq 0x18(%r13), %rsi
callq 0x170a4
testq %rax, %rax
je 0xc268
movq %rax, %r14
movq 0x8(%r13), %rdi
callq 0x113f8
movq 0x8(%r14), %rdi
callq 0x113fd
movq %rax, 0x8(%r13)
incq %r12
cmpq %r12, %r15
jne 0xc235
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1066c(%rip), %rdi     # 0x1c8ed
leaq 0xf6a8(%rip), %rsi      # 0x1b930
leaq 0x11140(%rip), %rcx     # 0x1d3cf
movl $0x767, %edx            # imm = 0x767
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: clone_node
static GumboNode* clone_node (
  GumboNode* node,
  GumboParseFlags reason
) {
  assert(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
  GumboNode* new_node = gumbo_alloc(sizeof(GumboNode));
  *new_node = *node;
  new_node->parent = NULL;
  new_node->index_within_parent = -1;
  // Clear the GUMBO_INSERTION_IMPLICIT_END_TAG flag, as the cloned node may
  // have a separate end tag.
  new_node->parse_flags &= ~GUMBO_INSERTION_IMPLICIT_END_TAG;
  new_node->parse_flags |= reason | GUMBO_INSERTION_BY_PARSER;
  GumboElement* element = &new_node->v.element;
  gumbo_vector_init(1, &element->children);

  const GumboVector* old_attributes = &node->v.element.attributes;
  gumbo_vector_init(old_attributes->length, &element->attributes);
  for (unsigned int i = 0; i < old_attributes->length; ++i) {
    const GumboAttribute* old_attr = old_attributes->data[i];
    GumboAttribute* attr = gumbo_alloc(sizeof(GumboAttribute));
    *attr = *old_attr;
    attr->name = gumbo_strdup(old_attr->name);
    attr->value = gumbo_strdup(old_attr->value);
    gumbo_vector_add(attr, &element->attributes);
  }
  return new_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0xc2fd
cmpl $0x6, %eax
jne 0xc3d7
movl $0x90, %edi
callq 0x113d4
movq %rax, %r14
movl $0x90, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4190
movq $0x0, 0x8(%r14)
movl $0xffffffff, 0x10(%r14) # imm = 0xFFFFFFFF
movl 0x14(%r14), %eax
andl $-0x4, %eax
orl %ebp, %eax
orl $0x1, %eax
movl %eax, 0x14(%r14)
leaq 0x18(%r14), %rsi
movl $0x1, %edi
callq 0x7af0
movl 0x88(%rbx), %edi
movq %r14, %r15
subq $-0x80, %r15
movq %r15, %rsi
callq 0x7af0
cmpl $0x0, 0x88(%rbx)
je 0xc3c5
xorl %ebp, %ebp
movq 0x80(%rbx), %rax
movq (%rax,%rbp,8), %r12
movl $0x98, %edi
callq 0x113d4
movq %rax, %r13
movl $0x98, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4190
movq 0x8(%r12), %rdi
callq 0x113fd
movq %rax, 0x8(%r13)
movq 0x20(%r12), %rdi
callq 0x113fd
movq %rax, 0x20(%r13)
movq %r13, %rdi
movq %r15, %rsi
callq 0x7b25
incq %rbp
movl 0x88(%rbx), %eax
cmpq %rax, %rbp
jb 0xc368
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf900(%rip), %rdi      # 0x1bcde
leaq 0xf54b(%rip), %rsi      # 0x1b930
leaq 0x10ab3(%rip), %rcx     # 0x1ce9f
movl $0x530, %edx            # imm = 0x530
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: remove_from_parent
static void remove_from_parent(GumboNode* node) {
  if (!node->parent) {
    // The node may not have a parent if, for example, it is a newly-cloned copy
    // of an active formatting element. DOM manipulations continue with the
    // orphaned fragment of the DOM tree until it's appended/foster-parented to
    // the common ancestor at the end of the adoption agency algorithm.
    return;
  }
  assert(node->parent->type == GUMBO_NODE_ELEMENT);
  GumboVector* children = &node->parent->v.element.children;
  int index = gumbo_vector_index_of(children, node);
  assert(index != -1);

  gumbo_vector_remove_at(index, children);
  node->parent = NULL;
  node->index_within_parent = -1;
  for (unsigned int i = index; i < children->length; ++i) {
    GumboNode* child = children->data[i];
    child->index_within_parent = i;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0xc45a
cmpl $0x1, (%r15)
jne 0xc465
movq %rdi, %rbx
leaq 0x18(%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7bea
cmpl $-0x1, %eax
je 0xc484
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
callq 0x7cb4
movq $0x0, 0x8(%rbx)
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
movl 0x20(%r15), %eax
cmpl %eax, %ebp
jae 0xc45a
movq (%r14), %rcx
movl %ebp, %edx
movq (%rcx,%rdx,8), %rsi
movl %edx, 0x10(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0xc44b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10d87(%rip), %rdi     # 0x1d1f3
leaq 0xf4bd(%rip), %rsi      # 0x1b930
leaq 0x10da2(%rip), %rcx     # 0x1d21c
movl $0x7ba, %edx            # imm = 0x7BA
callq 0x4100
leaq 0x10d06(%rip), %rdi     # 0x1d191
leaq 0xf49e(%rip), %rsi      # 0x1b930
leaq 0x10d83(%rip), %rcx     # 0x1d21c
movl $0x7bd, %edx            # imm = 0x7BD
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: close_table
static bool close_table(GumboParser* parser) {
  if (!has_an_element_in_table_scope(parser, GUMBO_TAG_TABLE)) {
    return false;
  }

  GumboNode* node = pop_current_node(parser);
  while (!node_html_tag_is(node, GUMBO_TAG_TABLE)) {
    node = pop_current_node(parser);
  }
  reset_insertion_mode_appropriately(parser);
  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x4(%rsp), %rdx
movl $0x5f, (%rdx)
leaq 0xe59e(%rip), %r8       # 0x1aae0
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xb40a
movl %eax, %ebp
testb %al, %al
je 0xc577
movq %rbx, %rdi
callq 0xaffb
movq %rax, %rdi
xorl %esi, %esi
movl $0x5f, %edx
callq 0x8739
testb %al, %al
je 0xc554
movq %rbx, %rdi
callq 0x8104
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: clear_stack_to_table_body_context
static void clear_stack_to_table_body_context(GumboParser* parser) {
  static const TagSet tags = {
    TAG(HTML), TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TEMPLATE)
  };
  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 0xeabd(%rip), %rsi      # 0x1b050
movq %rax, %rdi
callq 0x86f4
testb %al, %al
jne 0xc5c5
leaq 0xeaaa(%rip), %r14      # 0x1b050
movq %rbx, %rdi
callq 0xaffb
movq %rbx, %rdi
callq 0x7d33
movq %rax, %rdi
movq %r14, %rsi
callq 0x86f4
testb %al, %al
je 0xc5a6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: close_table_cell
static bool close_table_cell (
  GumboParser* parser,
  const GumboToken* token,
  GumboTag cell_tag
) {
  bool result = true;
  generate_implied_end_tags(parser, GUMBO_TAG_LAST);
  const GumboNode* node = get_current_node(parser);
  if (!node_html_tag_is(node, cell_tag)) {
    parser_add_parse_error(parser, token);
    result = false;
  }
  do {
    node = pop_current_node(parser);
  } while (!node_html_tag_is(node, cell_tag));

  clear_active_formatting_elements(parser);
  set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl $0x97, %esi
callq 0xb86c
movq %rbx, %rdi
callq 0x7d33
movq %rax, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x8739
movl %eax, %ebp
testb %al, %al
jne 0xc65a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d9d
movq %rbx, %rdi
callq 0xaffb
movq %rax, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x8739
testb %al, %al
je 0xc65a
movq 0x18(%rbx), %r14
addq $0x18, %r14
leaq 0xd4a6(%rip), %r15      # 0x19b28
movq %r14, %rdi
callq 0x7bd3
testq %rax, %rax
je 0xc694
cmpq %r15, %rax
jne 0xc682
movq 0x18(%rbx), %rax
movl $0xd, (%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: close_current_cell
static bool close_current_cell(GumboParser* parser, const GumboToken* token) {
  if (has_an_element_in_table_scope(parser, GUMBO_TAG_TD)) {
    assert(!has_an_element_in_table_scope(parser, GUMBO_TAG_TH));
    return close_table_cell(parser, token, GUMBO_TAG_TD);
  } else {
    assert(has_an_element_in_table_scope(parser, GUMBO_TAG_TH));
    return close_table_cell(parser, token, GUMBO_TAG_TH);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
leaq 0x4(%rsp), %rdx
movl $0x67, (%rdx)
leaq 0xe410(%rip), %r8       # 0x1aae0
movq %r15, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xb40a
testb %al, %al
je 0xc72c
leaq 0x8(%rsp), %rdx
movl $0x68, (%rdx)
leaq 0xe3eb(%rip), %r8       # 0x1aae0
movq %r15, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xb40a
movl $0x67, %edx
testb %al, %al
je 0xc756
leaq 0x10d66(%rip), %rdi     # 0x1d47a
leaq 0xf215(%rip), %rsi      # 0x1b930
leaq 0x10d8d(%rip), %rcx     # 0x1d4af
movl $0x69f, %edx            # imm = 0x69F
callq 0x4100
leaq 0xc(%rsp), %rdx
movl $0x68, (%rdx)
leaq 0xe3a2(%rip), %r8       # 0x1aae0
movq %r15, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xb40a
movl $0x68, %edx
testb %al, %al
je 0xc76a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xc61a
leaq 0x10d0a(%rip), %rdi     # 0x1d47b
leaq 0xf1b8(%rip), %rsi      # 0x1b930
leaq 0x10d30(%rip), %rcx     # 0x1d4af
movl $0x6a2, %edx            # imm = 0x6A2
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: close_current_select
static void close_current_select(GumboParser* parser) {
  GumboNode* node = pop_current_node(parser);
  while (!node_html_tag_is(node, GUMBO_TAG_SELECT)) {
    node = pop_current_node(parser);
  }
  reset_insertion_mode_appropriately(parser);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xaffb
movq %rax, %rdi
xorl %esi, %esi
movl $0x6f, %edx
callq 0x8739
testb %al, %al
jne 0xc7aa
movq %rbx, %rdi
jmp 0xc78d
movq %rbx, %rdi
popq %rbx
jmp 0x8104
nop
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: gumbo_tokenizer_state_init
void gumbo_tokenizer_state_init (
  GumboParser* parser,
  const char* text,
  size_t text_length
) {
  GumboTokenizerState* tokenizer = gumbo_alloc(sizeof(GumboTokenizerState));
  parser->_tokenizer_state = tokenizer;
  gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
  tokenizer->_reconsume_current_input = false;
  tokenizer->_is_current_node_foreign = false;
  tokenizer->_is_in_cdata = false;
  tokenizer->_tag_state._last_start_tag = GUMBO_TAG_LAST;

  tokenizer->_buffered_emit_char = kGumboNoChar;
  gumbo_string_buffer_init(&tokenizer->_temporary_buffer);
  tokenizer->_temporary_buffer_emit = NULL;

  mark_tag_state_as_empty(&tokenizer->_tag_state);

  gumbo_string_buffer_init(&tokenizer->_script_data_buffer);
  tokenizer->_token_start = text;
  utf8iterator_init(parser, text, text_length, &tokenizer->_input);
  utf8iterator_get_position(&tokenizer->_input, &tokenizer->_token_start_pos);
  doc_type_state_init(parser);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl $0x148, %edi            # imm = 0x148
callq 0x113d4
movq %rax, %r15
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movl %eax, (%r15)
movl %eax, 0x3(%r15)
movl $0x97, 0xc0(%r15)
leaq 0x1414f(%rip), %rax     # 0x20940
movl (%rax), %eax
movl %eax, 0x8(%r15)
leaq 0x10(%r15), %rdi
callq 0x7470
movq $0x0, 0x28(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%r15)
leaq 0x30(%r15), %rdi
callq 0x7470
movq %r12, 0x48(%r15)
leaq 0xe8(%r15), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x7821
movq 0x120(%r15), %rax
movq %rax, 0x60(%r15)
movups 0x110(%r15), %xmm0
movups %xmm0, 0x50(%r15)
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xd3(%rax)
movups %xmm0, 0xc8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: gumbo_tokenizer_state_destroy
void gumbo_tokenizer_state_destroy(GumboParser* parser) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  assert(tokenizer->_doc_type_state.name == NULL);
  assert(tokenizer->_doc_type_state.public_identifier == NULL);
  assert(tokenizer->_doc_type_state.system_identifier == NULL);
  gumbo_string_buffer_destroy(&tokenizer->_temporary_buffer);
  gumbo_string_buffer_destroy(&tokenizer->_script_data_buffer);
  gumbo_free(tokenizer);
}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rbx
cmpq $0x0, 0xc8(%rbx)
jne 0xc8b3
cmpq $0x0, 0xd0(%rbx)
jne 0xc8d2
cmpq $0x0, 0xd8(%rbx)
jne 0xc8f1
leaq 0x10(%rbx), %rdi
callq 0x7689
leaq 0x30(%rbx), %rdi
callq 0x7689
movq %rbx, %rdi
popq %rbx
jmp 0x113f8
leaq 0x10f82(%rip), %rdi     # 0x1d83c
leaq 0x10fa3(%rip), %rsi     # 0x1d864
leaq 0x10fac(%rip), %rcx     # 0x1d874
movl $0x39a, %edx            # imm = 0x39A
callq 0x4100
leaq 0x10fcd(%rip), %rdi     # 0x1d8a6
leaq 0x10f84(%rip), %rsi     # 0x1d864
leaq 0x10f8d(%rip), %rcx     # 0x1d874
movl $0x39b, %edx            # imm = 0x39B
callq 0x4100
leaq 0x10fe3(%rip), %rdi     # 0x1d8db
leaq 0x10f65(%rip), %rsi     # 0x1d864
leaq 0x10f6e(%rip), %rcx     # 0x1d874
movl $0x39c, %edx            # imm = 0x39C
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: maybe_emit_from_temporary_buffer
static bool maybe_emit_from_temporary_buffer(
    GumboParser* parser, GumboToken* output) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  const char* c = tokenizer->_temporary_buffer_emit;
  GumboStringBuffer* buffer = &tokenizer->_temporary_buffer;

  if (!c || c >= buffer->data + buffer->length) {
    tokenizer->_temporary_buffer_emit = NULL;
    return false;
  }

  assert(*c == utf8iterator_current(&tokenizer->_input));
  // emit_char also advances the input stream. We need to do some juggling of
  // the _reconsume_current_input flag to get the proper behavior when emitting
  // previous tokens. Basically, _reconsume_current_input should *never* be set
  // when emitting anything from the temporary buffer, since those characters
  // have already been advanced past. However, it should be preserved so that
  // when the *next* character is encountered again, the tokenizer knows not to
  // advance past it.
  bool saved_reconsume_state = tokenizer->_reconsume_current_input;
  tokenizer->_reconsume_current_input = false;
  emit_char(parser, *c, output);
  ++tokenizer->_temporary_buffer_emit;
  tokenizer->_reconsume_current_input = saved_reconsume_state;
  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xc960
movq 0x10(%rbx), %rcx
addq 0x18(%rbx), %rcx
cmpq %rcx, %rax
jae 0xc960
movsbl (%rax), %ecx
cmpl %ecx, 0x100(%rbx)
jne 0xc971
movq %rsi, %rdx
movb 0x4(%rbx), %bpl
movb $0x0, 0x4(%rbx)
movsbl (%rax), %esi
callq 0x62f4
incq 0x28(%rbx)
movb %bpl, 0x4(%rbx)
movb $0x1, %al
jmp 0xc96a
movq $0x0, 0x28(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x11017(%rip), %rdi     # 0x1d98f
leaq 0x10ee5(%rip), %rsi     # 0x1d864
leaq 0x11038(%rip), %rcx     # 0x1d9be
movl $0x28d, %edx            # imm = 0x28D
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: gumbo_token_destroy
void gumbo_token_destroy(GumboToken* token) {
  if (!token) {
    return;
  }

  switch (token->type) {
    case GUMBO_TOKEN_DOCTYPE:
      gumbo_free((void*) token->v.doc_type.name);
      gumbo_free((void*) token->v.doc_type.public_identifier);
      gumbo_free((void*) token->v.doc_type.system_identifier);
      return;
    case GUMBO_TOKEN_START_TAG:
      for (unsigned int i = 0; i < token->v.start_tag.attributes.length; ++i) {
        GumboAttribute* attr = token->v.start_tag.attributes.data[i];
        if (attr) {
          // May have been nulled out if this token was merged with another.
          gumbo_destroy_attribute(attr);
        }
      }
      gumbo_free((void*) token->v.start_tag.attributes.data);
      return;
    case GUMBO_TOKEN_COMMENT:
      gumbo_free((void*) token->v.text);
      return;
    default:
      return;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xc9db
movq %rdi, %rbx
movl (%rdi), %eax
testl %eax, %eax
je 0xc9e7
cmpl $0x3, %eax
je 0xc9e1
cmpl $0x1, %eax
jne 0xc9db
leaq 0x38(%rbx), %r14
movl 0x40(%rbx), %eax
testl %eax, %eax
je 0xca00
xorl %r15d, %r15d
movq (%r14), %rcx
movq (%rcx,%r15,8), %rdi
testq %rdi, %rdi
je 0xc9cf
callq 0x6efa
movl 0x40(%rbx), %eax
incq %r15
movl %eax, %ecx
cmpq %rcx, %r15
jb 0xc9bb
jmp 0xca00
popq %rbx
popq %r14
popq %r15
retq
addq $0x30, %rbx
jmp 0xc9fd
movq 0x30(%rbx), %rdi
callq 0x113f8
movq 0x38(%rbx), %rdi
callq 0x113f8
addq $0x40, %rbx
movq %rbx, %r14
movq (%r14), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x113f8
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: finish_token
static void finish_token(GumboParser* parser, GumboToken* token) {
  GumboTokenizerState* tokenizer = parser->_tokenizer_state;
  if (!tokenizer->_reconsume_current_input) {
    utf8iterator_next(&tokenizer->_input);
  }

  token->position = tokenizer->_token_start_pos;
  token->original_text.data = tokenizer->_token_start;
  reset_token_start_point(tokenizer);
  token->original_text.length =
      tokenizer->_token_start - token->original_text.data;
  if (token->original_text.length > 0 &&
      token->original_text.data[token->original_text.length - 1] == '\r') {
    // The UTF8 iterator will ignore carriage returns in the input stream, which
    // means that the next token may start one past a \r character. The pointer
    // arithmetic above results in that \r being appended to the original text
    // of the preceding token, so we have to adjust its length here to chop the
    // \r off.
    --token->original_text.length;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x4(%rdi)
jne 0xca29
leaq 0xe8(%r14), %rdi
callq 0x43e3
movq 0x60(%r14), %rax
movq %rax, 0x18(%rbx)
movups 0x50(%r14), %xmm0
movups %xmm0, 0x8(%rbx)
movq 0x48(%r14), %rax
movq %rax, 0x20(%rbx)
movq 0xe8(%r14), %rax
movq %rax, 0x48(%r14)
movq 0x120(%r14), %rcx
movq %rcx, 0x60(%r14)
movups 0x110(%r14), %xmm0
movups %xmm0, 0x50(%r14)
movq 0x20(%rbx), %rcx
subq %rcx, %rax
movq %rax, 0x28(%rbx)
je 0xca80
cmpb $0xd, -0x1(%rcx,%rax)
jne 0xca80
decq %rax
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_data_state
static StateResult handle_data_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '&':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_CHAR_REF_IN_DATA);
      // The char_ref machinery expects to be on the & so it can mark that
      // and return to it if the text isn't a char ref, so we need to
      // reconsume it.
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_TAG_OPEN);
      clear_temporary_buffer(parser);
      append_char_to_temporary_buffer(parser, '<');
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      emit_char(parser, c, output);
      return RETURN_ERROR;
    default:
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xcad8
cmpl $0x3c, %edx
je 0xcab0
cmpl $0x26, %edx
jne 0xcb04
movq 0x10(%rbx), %rax
movl $0x1, (%rax)
movb $0x1, 0x4(%rsi)
jmp 0xcad1
movq 0x10(%rbx), %rdi
movl $0x7, (%rdi)
callq 0x10a14
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x3c, %edi
callq 0x4322
movl $0x2, %eax
jmp 0xcb1e
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movl $0x7, (%r14)
movl $0x0, 0x30(%r14)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xca0d
xorl %eax, %eax
jmp 0xcb1e
movq 0x10(%rbx), %rax
movl 0x100(%rax), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rcdata_state
static StateResult handle_rcdata_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '&':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_CHAR_REF_IN_RCDATA);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA_LT);
      clear_temporary_buffer(parser);
      append_char_to_temporary_buffer(parser, '<');
      return NEXT_CHAR;
    case '\0':
      return emit_replacement_char(parser, output);
    case -1:
      return emit_eof(parser, output);
    default:
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x25, %edx
jg 0xcb81
cmpl $-0x1, %edx
je 0xcbb2
testl %edx, %edx
jne 0xcb9b
movq %r14, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%rbx)
movl $0xfffd, 0x30(%rbx)     # imm = 0xFFFD
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
xorl %eax, %eax
jmp 0xcbf8
cmpl $0x3c, %edx
je 0xcbd2
cmpl $0x26, %edx
jne 0xcb9b
movq 0x10(%r14), %rax
movl $0x3, (%rax)
movb $0x1, 0x4(%rsi)
jmp 0xcbf3
movq 0x10(%r14), %rax
movl 0x100(%rax), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
jmp 0xcbcb
movl $0x8, (%rbx)
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
movl $0x1, %eax
jmp 0xcbf8
movq 0x10(%r14), %rdi
movl $0xa, (%rdi)
callq 0x10a14
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movl $0x3c, %edi
callq 0x4322
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rawtext_state
static StateResult handle_rawtext_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_RAWTEXT_LT);
      clear_temporary_buffer(parser);
      append_char_to_temporary_buffer(parser, '<');
      return NEXT_CHAR;
    case '\0':
      return emit_replacement_char(parser, output);
    case -1:
      return emit_eof(parser, output);
    default:
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $-0x1, %edx
je 0xcc83
testl %edx, %edx
je 0xcc52
cmpl $0x3c, %edx
jne 0xcc9e
movq 0x10(%r14), %rdi
movl $0xd, (%rdi)
callq 0x10a14
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movl $0x3c, %edi
callq 0x4322
movl $0x2, %eax
jmp 0xccb8
movq %r14, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%rbx)
movl $0xfffd, 0x30(%rbx)     # imm = 0xFFFD
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
xorl %eax, %eax
jmp 0xccb8
movl $0x8, (%rbx)
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
jmp 0xccb3
movq 0x10(%r14), %rax
movl 0x100(%rax), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_state
static StateResult handle_script_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_LT);
      clear_temporary_buffer(parser);
      append_char_to_temporary_buffer(parser, '<');
      return NEXT_CHAR;
    case '\0':
      return emit_replacement_char(parser, output);
    case -1:
      return emit_eof(parser, output);
    default:
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $-0x1, %edx
je 0xcd31
testl %edx, %edx
je 0xcd00
cmpl $0x3c, %edx
jne 0xcd4c
movq 0x10(%r14), %rdi
movl $0x10, (%rdi)
callq 0x10a14
movq 0x10(%r14), %rsi
addq $0x10, %rsi
movl $0x3c, %edi
callq 0x4322
movl $0x2, %eax
jmp 0xcd66
movq %r14, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%rbx)
movl $0xfffd, 0x30(%rbx)     # imm = 0xFFFD
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
xorl %eax, %eax
jmp 0xcd66
movl $0x8, (%rbx)
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
jmp 0xcd61
movq 0x10(%r14), %rax
movl 0x100(%rax), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_plaintext_state
static StateResult handle_plaintext_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\0':
      return emit_replacement_char(parser, output);
    case -1:
      return emit_eof(parser, output);
    default:
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $-0x1, %edx
je 0xcdb2
testl %edx, %edx
jne 0xcdcd
movq %r14, %rdi
movl $0x2, %esi
callq 0x10a60
movq 0x10(%r14), %rax
movzbl 0x6(%rax), %eax
addl $0x5, %eax
movl %eax, (%rbx)
movl $0xfffd, 0x30(%rbx)     # imm = 0xFFFD
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
xorl %eax, %eax
jmp 0xcde7
movl $0x8, (%rbx)
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xca0d
jmp 0xcde2
movq 0x10(%r14), %rax
movl 0x100(%rax), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x62f4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_tag_open_state
static StateResult handle_tag_open_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "<"));
  switch (c) {
    case '!':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_MARKUP_DECLARATION);
      clear_temporary_buffer(parser);
      return NEXT_CHAR;
    case '/':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_END_TAG_OPEN);
      append_char_to_temporary_buffer(parser, '/');
      return NEXT_CHAR;
    case '?':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_COMMENT);
      clear_temporary_buffer(parser);
      append_char_to_temporary_buffer(parser, '?');
      tokenizer_add_parse_error(parser, GUMBO_ERR_TAG_STARTS_WITH_QUESTION);
      return NEXT_CHAR;
    default:
      if (is_alpha(c)) {
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_TAG_NAME);
        start_new_tag(parser, true);
        return NEXT_CHAR;
      } else {
        tokenizer_add_parse_error(parser, GUMBO_ERR_TAG_INVALID);
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
        emit_temporary_buffer(parser, output);
        return RETURN_ERROR;
      }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rsi
cmpq $0x1, 0x18(%rsi)
jne 0xceca
movq 0x10(%rsi), %rax
cmpb $0x3c, (%rax)
jne 0xceca
movq %rdi, %rbx
cmpl $0x3f, %edx
je 0xce47
cmpl $0x2f, %edx
je 0xce31
cmpl $0x21, %edx
jne 0xce76
movl $0x2c, (%rsi)
movq %rsi, %rdi
callq 0x10a14
jmp 0xce94
movl $0x8, (%rsi)
addq $0x10, %rsi
movl $0x2f, %edi
callq 0x4322
jmp 0xce94
movl $0x2b, (%rsi)
movq %rsi, %rdi
callq 0x10a14
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl $0x3f, %edi
callq 0x4322
movq %rbx, %rdi
movl $0x8, %esi
callq 0x10a60
jmp 0xce94
orl $0x20, %edx
addl $-0x61, %edx
cmpl $0x19, %edx
ja 0xcea1
movl $0x9, (%rsi)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10b4f
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rcx, %r14
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10c82
xorl %eax, %eax
jmp 0xce99
leaq 0x10b5c(%rip), %rdi     # 0x1da2d
leaq 0x1098c(%rip), %rsi     # 0x1d864
leaq 0x10b73(%rip), %rcx     # 0x1da52
movl $0x444, %edx            # imm = 0x444
callq 0x4100
// File: /workspace/github_c_makefile_star2_O3/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_end_tag_open_state
static StateResult handle_end_tag_open_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "</"));
  switch (c) {
    case '>':
      tokenizer_add_parse_error(parser, GUMBO_ERR_CLOSE_TAG_EMPTY);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_CLOSE_TAG_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return emit_temporary_buffer(parser, output);
    default:
      if (is_alpha(c)) {
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_TAG_NAME);
        start_new_tag(parser, false);
      } else {
        tokenizer_add_parse_error(parser, GUMBO_ERR_CLOSE_TAG_INVALID);
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_COMMENT);
        clear_temporary_buffer(parser);
        append_char_to_temporary_buffer(parser, c);
      }
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rax
cmpq $0x2, 0x18(%rax)
jne 0xcfb1
movq %rcx, %r14
movq 0x10(%rax), %rcx
cmpw $0x2f3c, (%rcx)         # imm = 0x2F3C
jne 0xcfb1
movl %edx, %ebp
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xcf36
cmpl $0x3e, %ebp
jne 0xcf5d
movq %rbx, %rdi
movl $0xb, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
jmp 0xcfa7
movq %rbx, %rdi
movl $0xc, %esi
callq 0x10a60
movq 0x10(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10c82
movzbl %al, %eax
jmp 0xcfac
movl %ebp, %ecx
orl $0x20, %ecx
addl $-0x61, %ecx
cmpl $0x19, %ecx
ja 0xcf7c
movl $0x9, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10b4f
jmp 0xcfa7
movq %rbx, %rdi
movl $0xd, %esi
callq 0x10a60
movq 0x10(%rbx), %rdi
movl $0x2b, (%rdi)
callq 0x10a14
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movl %ebp, %edi
callq 0x4322
movl $0x2, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10bac(%rip), %rdi     # 0x1db64
leaq 0x108a5(%rip), %rsi     # 0x1d864
leaq 0x10bc4(%rip), %rcx     # 0x1db8a
movl $0x469, %edx            # imm = 0x469
callq 0x4100