LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1121c
jmp 0x112ed
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, (%rax)
jne 0x1122b
jmp 0x1124a
leaq 0x23a6b(%rip), %rdi     # 0x34c9d
leaq 0x21c3b(%rip), %rsi     # 0x32e74
movl $0x7ba, %edx            # imm = 0x7BA
leaq 0x23a81(%rip), %rcx     # 0x34cc6
callq 0x4100
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6bf0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x11272
jmp 0x11291
leaq 0x23983(%rip), %rdi     # 0x34bfc
leaq 0x21bf4(%rip), %rsi     # 0x32e74
movl $0x7bd, %edx            # imm = 0x7BD
leaq 0x23a3a(%rip), %rcx     # 0x34cc6
callq 0x4100
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x6d40
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x112ed
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x112ba
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x5f, %esi
callq 0x10bf0
testb $0x1, %al
jne 0x113c4
movb $0x0, -0x1(%rbp)
jmp 0x11403
movq -0x10(%rbp), %rdi
callq 0xf060
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x5f, %esi
callq 0x8700
xorb $-0x1, %al
testb $0x1, %al
jne 0x113e7
jmp 0x113f6
movq -0x10(%rbp), %rdi
callq 0xf060
movq %rax, -0x18(%rbp)
jmp 0x113d1
movq -0x10(%rbp), %rdi
callq 0x7f40
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7550
movq %rax, %rdi
leaq 0x21091(%rip), %rsi     # 0x324c0
callq 0x8680
xorb $-0x1, %al
testb $0x1, %al
jne 0x1143c
jmp 0x11447
movq -0x8(%rbp), %rdi
callq 0xf060
jmp 0x1141c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x1, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movl $0x97, %esi
callq 0xfea0
movq -0x8(%rbp), %rdi
callq 0x7550
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8700
testb $0x1, %al
jne 0x114e3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x78a0
movb $0x0, -0x15(%rbp)
jmp 0x114e5
movq -0x8(%rbp), %rdi
callq 0xf060
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8700
xorb $-0x1, %al
testb $0x1, %al
jne 0x114e5
movq -0x8(%rbp), %rdi
callq 0xf420
movq -0x8(%rbp), %rdi
movl $0xd, %esi
callq 0x8b40
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x67, %esi
callq 0x10bf0
testb $0x1, %al
jne 0x11554
jmp 0x115a0
movq -0x10(%rbp), %rdi
movl $0x68, %esi
callq 0x10bf0
testb $0x1, %al
jne 0x11568
jmp 0x11587
leaq 0x23a04(%rip), %rdi     # 0x34f73
leaq 0x218fe(%rip), %rsi     # 0x32e74
movl $0x69f, %edx            # imm = 0x69F
leaq 0x23a26(%rip), %rcx     # 0x34fa8
callq 0x4100
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x67, %edx
callq 0x11490
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x115ec
movq -0x10(%rbp), %rdi
movl $0x68, %esi
callq 0x10bf0
testb $0x1, %al
jne 0x115b4
jmp 0x115b6
jmp 0x115d5
leaq 0x239b7(%rip), %rdi     # 0x34f74
leaq 0x218b0(%rip), %rsi     # 0x32e74
movl $0x6a2, %edx            # imm = 0x6A2
leaq 0x239d8(%rip), %rcx     # 0x34fa8
callq 0x4100
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x68, %edx
callq 0x11490
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf060
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x6f, %esi
callq 0x8700
xorb $-0x1, %al
testb $0x1, %al
jne 0x1166f
jmp 0x1167e
movq -0x8(%rbp), %rdi
callq 0xf060
movq %rax, -0x10(%rbp)
jmp 0x11659
movq -0x8(%rbp), %rdi
callq 0x7f40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: tree_traverse
static HOT void tree_traverse(GumboNode* node, TreeTraversalCallback callback) {
  GumboNode* current_node = node;
  unsigned int offset = 0;

tailcall:
  switch (current_node->type) {
    case GUMBO_NODE_DOCUMENT:
    case GUMBO_NODE_TEMPLATE:
    case GUMBO_NODE_ELEMENT: {
      GumboVector* children = (current_node->type == GUMBO_NODE_DOCUMENT)
        ? &current_node->v.document.children
        : &current_node->v.element.children
      ;
      if (offset >= children->length) {
        assert(offset == children->length);
        break;
      } else {
        current_node = children->data[offset];
        offset = 0;
        goto tailcall;
      }
    }
    case GUMBO_NODE_TEXT:
    case GUMBO_NODE_CDATA:
    case GUMBO_NODE_COMMENT:
    case GUMBO_NODE_WHITESPACE:
      assert(offset == 0);
      break;
  }

  offset = current_node->index_within_parent + 1;
  GumboNode* next_node = current_node->parent;
  callback(current_node);
  if (current_node == node) {
    return;
  }
  current_node = next_node;
  goto tailcall;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x2, %eax
jb 0x1172e
jmp 0x1170f
movl -0x34(%rbp), %eax
addl $-0x2, %eax
subl $0x4, %eax
jb 0x117b2
jmp 0x11720
movl -0x34(%rbp), %eax
subl $0x6, %eax
jne 0x117db
jmp 0x1172e
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x11745
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
jmp 0x11751
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x11794
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x11773
jmp 0x11792
leaq 0x23a6e(%rip), %rdi     # 0x351e8
leaq 0x216f3(%rip), %rsi     # 0x32e74
movl $0x18b, %edx            # imm = 0x18B
leaq 0x23a76(%rip), %rcx     # 0x35203
callq 0x4100
jmp 0x117db
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
jmp 0x116ff
cmpl $0x0, -0x1c(%rbp)
jne 0x117ba
jmp 0x117d9
leaq 0x23a79(%rip), %rdi     # 0x3523a
leaq 0x216ac(%rip), %rsi     # 0x32e74
movl $0x197, %edx            # imm = 0x197
leaq 0x23a2f(%rip), %rcx     # 0x35203
callq 0x4100
jmp 0x117db
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x1180e
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x116ff
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: destroy_node_callback
static void destroy_node_callback(GumboNode* node) {
  switch (node->type) {
    case GUMBO_NODE_DOCUMENT: {
      GumboDocument* doc = &node->v.document;
      gumbo_free((void*) doc->children.data);
      gumbo_free((void*) doc->name);
      gumbo_free((void*) doc->public_identifier);
      gumbo_free((void*) doc->system_identifier);
    } break;
    case GUMBO_NODE_TEMPLATE:
    case GUMBO_NODE_ELEMENT:
      for (unsigned int i = 0; i < node->v.element.attributes.length; ++i) {
        gumbo_destroy_attribute(node->v.element.attributes.data[i]);
      }
      gumbo_free(node->v.element.attributes.data);
      gumbo_free(node->v.element.children.data);
      break;
    case GUMBO_NODE_TEXT:
    case GUMBO_NODE_CDATA:
    case GUMBO_NODE_COMMENT:
    case GUMBO_NODE_WHITESPACE:
      gumbo_free((void*) node->v.text.text);
      break;
  }
  gumbo_free(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x6, %rax
ja 0x118f9
movq -0x20(%rbp), %rax
leaq 0x1ef3d(%rip), %rcx     # 0x30788
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17d80
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x17d80
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x17d80
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x17d80
jmp 0x118f9
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x88(%rcx), %eax
jae 0x118cd
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x51a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1189c
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x17d80
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x17d80
jmp 0x118f9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x17d80
movq -0x8(%rbp), %rdi
callq 0x17d80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x148, %edi            # imm = 0x148
callq 0x17cf0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x20(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x5(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x6(%rax)
movq -0x20(%rbp), %rax
movl $0x97, 0xc0(%rax)
leaq 0x27caa(%rip), %rax     # 0x39620
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x5ad0
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
callq 0x11a30
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x5ad0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0xe8, %rcx
callq 0x62a0
movq -0x20(%rbp), %rdi
addq $0xe8, %rdi
movq -0x20(%rbp), %rsi
addq $0x50, %rsi
callq 0x11a70
movq -0x8(%rbp), %rdi
callq 0x11aa0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: doc_type_state_init
static void doc_type_state_init(GumboParser* parser) {
  GumboTokenDocType* doc_type_state =
      &parser->_tokenizer_state->_doc_type_state;
  // We initialize these to NULL here so that we don't end up leaking memory if
  // we never see a doctype token. When we do see a doctype token, we reset
  // them to a freshly-allocated empty string so that we can present a uniform
  // interface to client code and not make them check for null. Ownership is
  // transferred to the doctype token when it's emitted.
  doc_type_state->name = NULL;
  doc_type_state->public_identifier = NULL;
  doc_type_state->system_identifier = NULL;
  doc_type_state->force_quirks = false;
  doc_type_state->has_public_identifier = false;
  doc_type_state->has_system_identifier = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0xc8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x19(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1a(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
jne 0x11b28
jmp 0x11b47
leaq 0x248d9(%rip), %rdi     # 0x36408
leaq 0x248fa(%rip), %rsi     # 0x36430
movl $0x39a, %edx            # imm = 0x39A
leaq 0x248fe(%rip), %rcx     # 0x36440
callq 0x4100
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
jne 0x11b57
jmp 0x11b76
leaq 0x24914(%rip), %rdi     # 0x36472
leaq 0x248cb(%rip), %rsi     # 0x36430
movl $0x39b, %edx            # imm = 0x39B
leaq 0x248cf(%rip), %rcx     # 0x36440
callq 0x4100
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
jne 0x11b86
jmp 0x11ba5
leaq 0x2491a(%rip), %rdi     # 0x364a7
leaq 0x2489c(%rip), %rsi     # 0x36430
movl $0x39c, %edx            # imm = 0x39C
leaq 0x248a0(%rip), %rcx     # 0x36440
callq 0x4100
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x5f60
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x5f60
movq -0x10(%rbp), %rdi
callq 0x17d80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: gumbo_tokenizer_set_is_current_node_foreign
void gumbo_tokenizer_set_is_current_node_foreign (
  GumboParser* parser,
  bool is_foreign
) {
  if (is_foreign != parser->_tokenizer_state->_is_current_node_foreign) {
    gumbo_debug (
      "Toggling is_current_node_foreign to %s.\n",
      is_foreign ? "true" : "false"
    );
  }
  parser->_tokenizer_state->_is_current_node_foreign = is_foreign;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb 0x5(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x11c27
movb -0x9(%rbp), %cl
leaq 0x22bfd(%rip), %rsi     # 0x34808
leaq 0x248f3(%rip), %rax     # 0x36505
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x248bc(%rip), %rdi     # 0x364dc
movb $0x0, %al
callq 0x11c40
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
andb $0x1, %cl
movb %cl, 0x5(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x11e93
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movq -0x30(%rbp), %rdx
addq 0x8(%rdx), %rcx
cmpq %rcx, %rax
jb 0x11ea8
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x11f35
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
addq $0xe8, %rdi
callq 0x11f40
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jne 0x11ecd
jmp 0x11eec
leaq 0x246f2(%rip), %rdi     # 0x365c6
leaq 0x24555(%rip), %rsi     # 0x36430
movl $0x28d, %edx            # imm = 0x28D
leaq 0x2470e(%rip), %rcx     # 0x365f5
callq 0x4100
movq -0x20(%rbp), %rax
movb 0x4(%rax), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movsbl (%rax), %esi
movq -0x18(%rbp), %rdx
callq 0x11df0
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movb -0x31(%rbp), %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11f78
jmp 0x1202e
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x11fa2
jmp 0x11f87
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x11fcb
jmp 0x11f91
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x1201d
jmp 0x1202c
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x17d80
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x17d80
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x17d80
jmp 0x1202e
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jae 0x1200e
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12001
movq -0x18(%rbp), %rdi
callq 0x51a0
jmp 0x12003
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11fd2
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x17d80
jmp 0x1202e
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x17d80
jmp 0x1202e
jmp 0x1202e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: get_char_token_type
static GumboTokenType get_char_token_type(bool is_in_cdata, int c) {
  if (is_in_cdata && c > 0) {
    return GUMBO_TOKEN_CDATA;
  }

  switch (c) {
    case '\t':
    case '\n':
    case '\r':
    case '\f':
    case ' ':
      return GUMBO_TOKEN_WHITESPACE;
    case 0:
      gumbo_debug("Emitted null byte.\n");
      return GUMBO_TOKEN_NULL;
    case -1:
      return GUMBO_TOKEN_EOF;
    default:
      return GUMBO_TOKEN_CHARACTER;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x5(%rbp)
movl %esi, -0xc(%rbp)
testb $0x1, -0x5(%rbp)
je 0x12068
cmpl $0x0, -0xc(%rbp)
jle 0x12068
movl $0x6, -0x4(%rbp)
jmp 0x120d2
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $-0x1, %eax
je 0x120c2
jmp 0x12075
movl -0x10(%rbp), %eax
testl %eax, %eax
je 0x120ab
jmp 0x1207e
movl -0x10(%rbp), %eax
addl $-0x9, %eax
subl $0x2, %eax
jb 0x120a2
jmp 0x1208b
movl -0x10(%rbp), %eax
addl $-0xc, %eax
subl $0x2, %eax
jb 0x120a2
jmp 0x12098
movl -0x10(%rbp), %eax
subl $0x20, %eax
jne 0x120cb
jmp 0x120a2
movl $0x4, -0x4(%rbp)
jmp 0x120d2
leaq 0x24500(%rip), %rdi     # 0x365b2
movb $0x0, %al
callq 0x11c40
movl $0x7, -0x4(%rbp)
jmp 0x120d2
movl $0x8, -0x4(%rbp)
jmp 0x120d2
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x4(%rax)
jne 0x12116
movq -0x18(%rbp), %rdi
addq $0xe8, %rdi
callq 0x6500
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x50(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x58(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x60(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdi
callq 0x121b0
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jbe 0x121a2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x121a2
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x122a4
jmp 0x12243
movl -0x2c(%rbp), %eax
subl $0x26, %eax
je 0x12257
jmp 0x1224d
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
je 0x12276
jmp 0x122cb
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x122e0
movq -0x10(%rbp), %rdi
movl $0x7, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x16bb0
movq -0x10(%rbp), %rdi
movl $0x3c, %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x122e0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x11df0
movl $0x0, -0x4(%rbp)
jmp 0x122e0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x123d0
jmp 0x12354
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x123be
jmp 0x1235d
movl -0x2c(%rbp), %eax
subl $0x26, %eax
je 0x12371
jmp 0x12367
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
je 0x12390
jmp 0x123e2
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x123f7
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x16bb0
movq -0x10(%rbp), %rdi
movl $0x3c, %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x123f7
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16ed0
movl %eax, -0x4(%rbp)
jmp 0x123f7
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16f10
movl %eax, -0x4(%rbp)
jmp 0x123f7
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x124b7
jmp 0x12464
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x124a5
jmp 0x1246d
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
jne 0x124c9
jmp 0x12477
movq -0x10(%rbp), %rdi
movl $0xd, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x16bb0
movq -0x10(%rbp), %rdi
movl $0x3c, %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x124de
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16ed0
movl %eax, -0x4(%rbp)
jmp 0x124de
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16f10
movl %eax, -0x4(%rbp)
jmp 0x124de
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x12567
jmp 0x12514
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x12555
jmp 0x1251d
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
jne 0x12579
jmp 0x12527
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x16bb0
movq -0x10(%rbp), %rdi
movl $0x3c, %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x1258e
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16ed0
movl %eax, -0x4(%rbp)
jmp 0x1258e
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16f10
movl %eax, -0x4(%rbp)
jmp 0x1258e
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x125df
jmp 0x125c4
movl -0x2c(%rbp), %eax
testl %eax, %eax
jne 0x125f1
jmp 0x125cd
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16ed0
movl %eax, -0x4(%rbp)
jmp 0x12606
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16f10
movl %eax, -0x4(%rbp)
jmp 0x12606
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x24032(%rip), %rsi     # 0x36664
movl $0x1, %edx
callq 0x16f40
testb $0x1, %al
jne 0x12642
jmp 0x12644
jmp 0x12663
leaq 0x2401b(%rip), %rdi     # 0x36666
leaq 0x23dde(%rip), %rsi     # 0x36430
movl $0x444, %edx            # imm = 0x444
leaq 0x2402d(%rip), %rcx     # 0x3668b
callq 0x4100
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x21, %eax
je 0x12687
jmp 0x12670
movl -0x2c(%rbp), %eax
subl $0x2f, %eax
je 0x126aa
jmp 0x1267a
movl -0x2c(%rbp), %eax
subl $0x3f, %eax
je 0x126d2
jmp 0x1270e
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x16bb0
movl $0x2, -0x4(%rbp)
jmp 0x1276e
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x1276e
movq -0x10(%rbp), %rdi
movl $0x2b, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x16bb0
movq -0x10(%rbp), %rdi
movl $0x3f, %esi
callq 0x16c30
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x16c60
movl $0x2, -0x4(%rbp)
jmp 0x1276e
movl -0x1c(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x1271c
jmp 0x12741
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x16fc0
movl $0x2, -0x4(%rbp)
jmp 0x1276e
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2400b(%rip), %rsi     # 0x367ad
movl $0x2, %edx
callq 0x16f40
testb $0x1, %al
jne 0x127b2
jmp 0x127b4
jmp 0x127d3
leaq 0x23ff5(%rip), %rdi     # 0x367b0
leaq 0x23c6e(%rip), %rsi     # 0x36430
movl $0x469, %edx            # imm = 0x469
leaq 0x24008(%rip), %rcx     # 0x367d6
callq 0x4100
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x1280f
jmp 0x127e0
movl -0x2c(%rbp), %eax
subl $0x3e, %eax
jne 0x1283f
jmp 0x127ea
movq -0x10(%rbp), %rdi
movl $0xb, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x128a0
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x128a0
movl -0x1c(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x1284d
jmp 0x12868
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x16fc0
jmp 0x12899
movq -0x10(%rbp), %rdi
movl $0xd, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0x2b, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x16bb0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_tag_name_state
static StateResult handle_tag_name_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      finish_tag_name(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
      return NEXT_CHAR;
    case '/':
      finish_tag_name(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SELF_CLOSING_START_TAG);
      return NEXT_CHAR;
    case '>':
      finish_tag_name(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return emit_current_tag(parser, output);
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_tag_buffer(parser, UNICODE_REPLACEMENT_CHAR, true);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_TAG_EOF);
      abandon_current_tag(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3f, %eax
ja 0x129b0
movq -0x30(%rbp), %rax
leaq 0x22962(%rip), %rcx     # 0x35248
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x17260
movq -0x10(%rbp), %rdi
movl $0x21, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x129d7
movq -0x10(%rbp), %rdi
callq 0x17260
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x129d7
movq -0x10(%rbp), %rdi
callq 0x17260
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x172b0
movl %eax, -0x4(%rbp)
jmp 0x129d7
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
movl $0x1, %edx
callq 0x174b0
movl $0x2, -0x4(%rbp)
jmp 0x129d7
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
callq 0x17510
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x129d7
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %edi
callq 0x17170
movq -0x38(%rbp), %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x174b0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rcdata_lt_state
static StateResult handle_rcdata_lt_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "<"));
  if (c == '/') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA_END_TAG_OPEN);
    append_char_to_temporary_buffer(parser, '/');
    return NEXT_CHAR;
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA);
    tokenizer->_reconsume_current_input = true;
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x23c62(%rip), %rsi     # 0x36664
movl $0x1, %edx
callq 0x16f40
testb $0x1, %al
jne 0x12a12
jmp 0x12a14
jmp 0x12a33
leaq 0x23c4b(%rip), %rdi     # 0x36666
leaq 0x23a0e(%rip), %rsi     # 0x36430
movl $0x4ae, %edx            # imm = 0x4AE
leaq 0x23f28(%rip), %rcx     # 0x36956
callq 0x4100
cmpl $0x2f, -0x1c(%rbp)
jne 0x12a5e
movq -0x10(%rbp), %rdi
movl $0xb, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x12a89
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rcdata_end_tag_open_state
static StateResult handle_rcdata_end_tag_open_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "</"));
  if (is_alpha(c)) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA_END_TAG_NAME);
    start_new_tag(parser, false);
    append_char_to_temporary_buffer(parser, c);
    return NEXT_CHAR;
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA);
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x23ceb(%rip), %rsi     # 0x367ad
movl $0x2, %edx
callq 0x16f40
testb $0x1, %al
jne 0x12ad2
jmp 0x12ad4
jmp 0x12af3
leaq 0x23cd5(%rip), %rdi     # 0x367b0
leaq 0x2394e(%rip), %rsi     # 0x36430
movl $0x4c1, %edx            # imm = 0x4C1
leaq 0x23ec4(%rip), %rcx     # 0x369b2
callq 0x4100
movl -0x1c(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x12b01
jmp 0x12b2f
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x16fc0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x12b52
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)