LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/error.c
// Function: gumbo_add_error
GumboError* gumbo_add_error(GumboParser* parser) {
  int max_errors = parser->_options->max_errors;
  if (max_errors >= 0 && parser->_output->errors.length >= (unsigned int) max_errors) {
    return NULL;
  }
  GumboError* error = gumbo_alloc(sizeof(GumboError));
  gumbo_vector_add(error, &parser->_output->errors);
  return error;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movl 0xc(%rax), %eax
testl %eax, %eax
js 0x72be
movq 0x8(%rbx), %rcx
cmpl %eax, 0x18(%rcx)
jae 0x72dd
movl $0x48, %edi
callq 0x11e58
movq %rax, %r14
movq 0x8(%rbx), %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x7ef9
jmp 0x72e0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/error.c
// Function: gumbo_caret_diagnostic_to_string
void gumbo_caret_diagnostic_to_string (
  const GumboError* error,
  const char* source_text,
  size_t source_length,
  GumboStringBuffer* output
) {
  gumbo_error_to_string(error, output);

  const char* line_start = find_prev_newline(source_text, error->original_text);
  const char* line_end = find_next_newline (
    source_text + source_length,
    error->original_text
  );
  GumboStringPiece original_line;
  original_line.data = line_start;
  original_line.length = line_end - line_start;

  gumbo_string_buffer_append_codepoint('\n', output);
  gumbo_string_buffer_append_string(&original_line, output);
  gumbo_string_buffer_append_codepoint('\n', output);
  gumbo_string_buffer_reserve(output->length + error->position.column, output);
  if (error->position.column >= 2) {
    size_t num_spaces = error->position.column - 1;
    memset(output->data + output->length, ' ', num_spaces);
    output->length += num_spaces;
  }
  gumbo_string_buffer_append_codepoint('^', output);
  gumbo_string_buffer_append_codepoint('\n', output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rcx, %rsi
callq 0x72eb
movq 0x20(%r14), %rax
cmpq %r12, %rax
jb 0x7663
cmpb $0xa, (%rax)
sete %cl
cmpq %r12, %rax
setne %dl
andb %cl, %dl
movzbl %dl, %ecx
movq %rax, %rdx
subq %rcx, %rdx
cmpq %r12, %rdx
je 0x75ab
cmpb $0xa, (%rdx)
je 0x75ab
decq %rdx
cmpq %r12, %rdx
jne 0x759b
movq %r12, %rdx
xorl %ecx, %ecx
cmpq %r12, %rdx
setne %cl
addq %rdx, %rcx
addq %r12, %r15
cmpq %r15, %rax
ja 0x7682
je 0x75d4
cmpb $0xa, (%rax)
je 0x75d4
incq %rax
cmpq %r15, %rax
jne 0x75c4
movq %r15, %rax
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
subq %rcx, %rax
movq %rax, 0x8(%r15)
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4322
movq %r15, %rdi
movq %rbx, %rsi
callq 0x788f
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4322
movq 0x10(%r14), %rdi
addq 0x8(%rbx), %rdi
movq %rbx, %rsi
callq 0x782f
movq 0x10(%r14), %r14
cmpq $0x2, %r14
jb 0x763d
decq %r14
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0x4120
addq %r14, 0x8(%rbx)
movl $0x5e, %edi
movq %rbx, %rsi
callq 0x4322
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4322
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1300d(%rip), %rdi     # 0x1a677
leaq 0x12f00(%rip), %rsi     # 0x1a571
leaq 0x1301d(%rip), %rcx     # 0x1a695
movl $0x75, %edx
callq 0x4100
leaq 0x13046(%rip), %rdi     # 0x1a6cf
leaq 0x12ee1(%rip), %rsi     # 0x1a571
leaq 0x1305a(%rip), %rcx     # 0x1a6f1
movl $0x87, %edx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/error.c
// Function: gumbo_print_caret_diagnostic
void gumbo_print_caret_diagnostic (
  const GumboError* error,
  const char* source_text,
  size_t source_length
) {
  GumboStringBuffer text;
  gumbo_string_buffer_init(&text);
  gumbo_caret_diagnostic_to_string(error, source_text, source_length, &text);
  printf("%.*s", (int) text.length, text.data);
  gumbo_string_buffer_destroy(&text);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0x780c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x7553
movl 0x8(%r12), %esi
movq (%r12), %rdx
leaq 0x12e3b(%rip), %rdi     # 0x1a51c
xorl %eax, %eax
callq 0x40f0
movq %r12, %rdi
callq 0x7a27
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/error.c
// Function: gumbo_error_destroy
void gumbo_error_destroy(GumboError* error) {
  if (
    error->type == GUMBO_ERR_PARSER
    || error->type == GUMBO_ERR_UNACKNOWLEDGED_SELF_CLOSING_TAG
  ) {
    gumbo_vector_destroy(&error->v.parser.tag_stack);
  } else if (error->type == GUMBO_ERR_DUPLICATE_ATTR) {
    gumbo_free((void*) error->v.duplicate_attr.name);
  }
  gumbo_free(error);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
leal -0x28(%rax), %ecx
cmpl $0x2, %ecx
jae 0x7715
leaq 0x38(%rbx), %rdi
callq 0x7eea
jmp 0x7723
cmpl $0x18, %eax
jne 0x7723
movq 0x28(%rbx), %rdi
callq 0x11e7c
movq %rbx, %rdi
popq %rbx
jmp 0x11e7c
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/error.c
// Function: print_tag_stack
static void print_tag_stack (
  const GumboParserError* error,
  GumboStringBuffer* output
) {
  print_message(output, "  Currently open tags: ");
  for (unsigned int i = 0; i < error->tag_stack.length; ++i) {
    if (i) {
      print_message(output, ", ");
    }
    GumboTag tag = (GumboTag) error->tag_stack.data[i];
    print_message(output, "%s", gumbo_normalized_tagname(tag));
  }
  gumbo_string_buffer_append_codepoint('.', output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x12ec2(%rip), %rsi     # 0x1a659
movq %rbx, %rdi
xorl %eax, %eax
callq 0x74cf
cmpl $0x0, 0x18(%r14)
je 0x77f4
leaq 0x12ec5(%rip), %r15     # 0x1a674
leaq 0x12ebb(%rip), %r12     # 0x1a671
xorl %r13d, %r13d
testq %r13, %r13
je 0x77cb
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x74cf
movq 0x10(%r14), %rax
movl (%rax,%r13,8), %edi
callq 0x7a30
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x74cf
incq %r13
movl 0x18(%r14), %eax
cmpq %rax, %r13
jb 0x77b9
movl $0x2e, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4322
nop
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/string_buffer.c
// Function: maybe_resize_string_buffer
static void maybe_resize_string_buffer (
  size_t additional_chars,
  GumboStringBuffer* buffer
) {
  size_t new_length = buffer->length + additional_chars;
  size_t new_capacity = buffer->capacity;
  while (new_capacity < new_length) {
    new_capacity *= 2;
  }
  if (new_capacity != buffer->capacity) {
    buffer->data = gumbo_realloc(buffer->data, new_capacity);
    buffer->capacity = new_capacity;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
addq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rax
movq %rax, %rcx
movq %rcx, %r14
addq %rcx, %rcx
cmpq %rdi, %r14
jb 0x7847
cmpq %rax, %r14
je 0x7869
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x11e6a
movq %rax, (%rbx)
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/string_buffer.c
// Function: gumbo_string_buffer_vsprintf
int gumbo_string_buffer_vsprintf (
  GumboStringBuffer* s,
  const char* fmt,
  va_list ap
) {
  va_list ap2;
  va_copy(ap2, ap);
  // Calculate the required size
  int n = vsnprintf(NULL, 0, fmt, ap2);
  va_end(ap2);
  if (n <= 0) {
    return n;
  }
  maybe_resize_string_buffer(n + 1, s);
  int wrote = vsnprintf(s->data + s->length, n + 1, fmt, ap);
  assert(wrote == n);
  s->length += wrote;
  return wrote;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdx), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4080
movl %eax, %r12d
testl %eax, %eax
jle 0x7932
leal 0x1(%r12), %r13d
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7835
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4080
cmpl %r12d, %eax
jne 0x7943
movl %eax, %ecx
addq %rcx, 0x8(%rbx)
movl %eax, %r12d
movl %r12d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x12de1(%rip), %rdi     # 0x1a72b
leaq 0x12de5(%rip), %rsi     # 0x1a736
leaq 0x12df2(%rip), %rcx     # 0x1a74a
movl $0x72, %edx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/string_buffer.c
// Function: gumbo_string_buffer_to_string
char* gumbo_string_buffer_to_string(const GumboStringBuffer* input) {
  char* buffer = gumbo_alloc(input->length + 1);
  memcpy(buffer, input->data, input->length);
  buffer[input->length] = '\0';
  return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
incq %rdi
callq 0x11e58
movq %rax, %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rbx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x4190
movb $0x0, (%r14,%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/tag.c
// Function: gumbo_normalized_tagname
const char* gumbo_normalized_tagname(GumboTag tag) {
  assert(tag <= GUMBO_TAG_LAST);
  const char *tagname = kGumboTagNames[tag];
  assert(tagname);
  return tagname;
}

// Assembly:
cmpl $0x98, %edi
jae 0x7a49
movl %edi, %ecx
shlq $0x4, %rcx
leaq 0x12e4b(%rip), %rax     # 0x1a890
addq %rcx, %rax
retq
pushq %rax
leaq 0x12d55(%rip), %rdi     # 0x1a7a6
leaq 0x12d64(%rip), %rsi     # 0x1a7bc
leaq 0x12d67(%rip), %rcx     # 0x1a7c6
movl $0xb5, %edx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/tag.c
// Function: gumbo_tag_from_original_text
void gumbo_tag_from_original_text(GumboStringPiece* text) {
  if (text->data == NULL) {
    return;
  }

  assert(text->length >= 2);
  assert(text->data[0] == '<');
  assert(text->data[text->length - 1] == '>');

  if (text->data[1] == '/') {
    // End tag
    assert(text->length >= 3);
    text->data += 2;  // Move past </
    text->length -= 3;
  } else {
    // Start tag
    text->data += 1;  // Move past <
    text->length -= 2;
    for (const char* c = text->data; c != text->data + text->length; ++c) {
      switch (*c) {
      case '\t':
      case '\n':
      case '\f':
      case ' ':
      case '/':
        text->length = c - text->data;
        return;
      }
    }
  }
}

// Assembly:
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x7ab2
movq 0x8(%rdi), %rcx
cmpq $0x1, %rcx
jbe 0x7aeb
cmpb $0x3c, (%rax)
jne 0x7b0a
cmpb $0x3e, -0x1(%rax,%rcx)
jne 0x7b29
cmpb $0x2f, 0x1(%rax)
jne 0x7ab4
cmpq $0x2, %rcx
je 0x7b48
addq $0x2, %rax
movq %rax, (%rdi)
addq $-0x3, %rcx
movq %rcx, %rdx
movq %rdx, 0x8(%rdi)
popq %rax
retq
incq %rax
movq %rax, (%rdi)
addq $-0x2, %rcx
movq %rcx, 0x8(%rdi)
je 0x7ab2
xorl %edx, %edx
movabsq $0x800100001600, %rsi   # imm = 0x800100001600
movzbl (%rax,%rdx), %r8d
cmpq $0x2f, %r8
ja 0x7ae1
btq %r8, %rsi
jb 0x7aae
incq %rdx
cmpq %rdx, %rcx
jne 0x7ad0
jmp 0x7ab2
leaq 0x12d03(%rip), %rdi     # 0x1a7f5
leaq 0x12cc3(%rip), %rsi     # 0x1a7bc
leaq 0x12d07(%rip), %rcx     # 0x1a807
movl $0xc0, %edx
callq 0x4100
leaq 0x12d2c(%rip), %rdi     # 0x1a83d
leaq 0x12ca4(%rip), %rsi     # 0x1a7bc
leaq 0x12ce8(%rip), %rcx     # 0x1a807
movl $0xc1, %edx
callq 0x4100
leaq 0x12d22(%rip), %rdi     # 0x1a852
leaq 0x12c85(%rip), %rsi     # 0x1a7bc
leaq 0x12cc9(%rip), %rcx     # 0x1a807
movl $0xc2, %edx
callq 0x4100
leaq 0x12d27(%rip), %rdi     # 0x1a876
leaq 0x12c66(%rip), %rsi     # 0x1a7bc
leaq 0x12caa(%rip), %rcx     # 0x1a807
movl $0xc6, %edx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/utf8.c
// Function: utf8_is_invalid_code_point
bool utf8_is_invalid_code_point(int c) {
  return
    (c >= 0x1 && c <= 0x8)
    || c == 0xB
    || (c >= 0xE && c <= 0x1F)
    || (c >= 0x7F && c <= 0x9F)
    || (c >= 0xFDD0 && c <= 0xFDEF)
    || ((c & 0xFFFF) == 0xFFFE)
    || ((c & 0xFFFF) == 0xFFFF)
  ;
}

// Assembly:
leal -0x1(%rdi), %ecx
cmpl $0xb, %ecx
jae 0x7b94
movb $0x1, %al
movl $0x4ff, %edx            # imm = 0x4FF
btl %ecx, %edx
jb 0x7bbc
leal -0xfdd0(%rdi), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
jb 0x7bbc
leal -0xe(%rdi), %ecx
cmpl $0x12, %ecx
jb 0x7bbc
leal -0x7f(%rdi), %ecx
cmpl $0x21, %ecx
jb 0x7bbc
notl %edi
testl $0xfffe, %edi           # imm = 0xFFFE
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/utf8.c
// Function: utf8iterator_maybe_consume_match
bool utf8iterator_maybe_consume_match (
  Utf8Iterator* iter,
  const char* prefix,
  size_t length,
  bool case_sensitive
) {
  bool matched =
    (iter->_start + length <= iter->_end)
    && (
      case_sensitive
        ? mem_equal(iter->_start, prefix, length)
        : mem_equal_icase(iter->_start, prefix, length)
    )
  ;
  if (matched) {
    for (size_t i = 0; i < length; ++i) {
      utf8iterator_next(iter);
    }
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq (%rdi,%rdx), %rax
cmpq 0x10(%r14), %rax
jbe 0x7d7a
xorl %ebp, %ebp
jmp 0x7df0
testb %cl, %cl
je 0x7d8e
movq %rbx, %rdx
callq 0x4200
testl %eax, %eax
sete %bpl
jmp 0x7df0
testq %rbx, %rbx
sete %bpl
je 0x7df0
movzbl (%rdi), %ecx
leaq 0x123af(%rip), %rax     # 0x1a150
movb (%rax,%rcx), %dl
andb $0x20, %dl
orb %cl, %dl
movzbl (%rsi), %ecx
movb (%rax,%rcx), %r8b
andb $0x20, %r8b
orb %cl, %r8b
cmpb %r8b, %dl
jne 0x7df0
movl $0x1, %ecx
cmpq %rcx, %rbx
sete %bpl
je 0x7df0
movzbl (%rdi,%rcx), %edx
movb (%rax,%rdx), %r8b
andb $0x20, %r8b
orb %dl, %r8b
movzbl (%rsi,%rcx), %edx
movb (%rax,%rdx), %r9b
andb $0x20, %r9b
orb %dl, %r9b
incq %rcx
cmpb %r9b, %r8b
je 0x7dc1
testq %rbx, %rbx
sete %al
movl %ebp, %ecx
xorb $0x1, %cl
orb %al, %cl
jne 0x7e0c
movq %r14, %rdi
callq 0x43e4
decq %rbx
jne 0x7dff
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/utf8.c
// Function: add_error
static void add_error(Utf8Iterator* iter, GumboErrorType type) {
  GumboParser* parser = iter->_parser;

  GumboError* error = gumbo_add_error(parser);
  if (!error) {
    return;
  }
  error->type = type;
  error->position = iter->_pos;
  error->original_text = iter->_start;

  // At the point the error is recorded, the code point hasn't been computed
  // yet (and can't be, because it's invalid), so we need to build up the raw
  // hex value from the bytes under the cursor.
  uint32_t code_point = 0;
  for (size_t i = 0; i < iter->_width; ++i) {
    code_point = (code_point << 8) | (unsigned char) iter->_start[i];
  }
  error->v.codepoint = code_point;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x72a4
testq %rax, %rax
je 0x7eba
movl %ebp, (%rax)
movups 0x28(%rbx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x38(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0x7eb5
xorl %esi, %esi
xorl %r8d, %r8d
shll $0x8, %r8d
movzbl (%rcx,%rsi), %edi
orl %r8d, %edi
incq %rsi
movl %edi, %r8d
cmpq %rsi, %rdx
jne 0x7e9d
jmp 0x7eb7
xorl %edi, %edi
movl %edi, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/vector.c
// Function: gumbo_vector_init
void gumbo_vector_init(unsigned int initial_capacity, GumboVector* vector) {
  vector->length = 0;
  vector->capacity = initial_capacity;
  if (initial_capacity > 0) {
    vector->data = gumbo_alloc(sizeof(void*) * initial_capacity);
  } else {
    vector->data = NULL;
  }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl $0x0, 0x8(%rsi)
movl %edi, 0xc(%rsi)
testl %edi, %edi
je 0x7ee3
movl %edi, %edi
shlq $0x3, %rdi
callq 0x11e58
jmp 0x7ee5
xorl %eax, %eax
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/vector.c
// Function: gumbo_vector_add
void gumbo_vector_add(void* ptr, GumboVector* vector) {
  enlarge_vector_if_full(vector);
  assert(vector->data);
  assert(vector->length < vector->capacity);
  vector->data[vector->length++] = ptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7f6e
movq (%r14), %rax
testq %rax, %rax
je 0x7f30
movl 0x8(%r14), %ecx
cmpl 0xc(%r14), %ecx
jae 0x7f4f
leal 0x1(%rcx), %edx
movl %edx, 0x8(%r14)
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x13485(%rip), %rdi     # 0x1b3bc
leaq 0x1348b(%rip), %rsi     # 0x1b3c9
leaq 0x13491(%rip), %rcx     # 0x1b3d6
movl $0x38, %edx
callq 0x4100
leaq 0x134ad(%rip), %rdi     # 0x1b403
leaq 0x1346c(%rip), %rsi     # 0x1b3c9
leaq 0x13472(%rip), %rcx     # 0x1b3d6
movl $0x39, %edx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/vector.c
// Function: enlarge_vector_if_full
static void enlarge_vector_if_full(GumboVector* vector) {
  if (vector->length >= vector->capacity) {
    if (vector->capacity) {
      vector->capacity *= 2;
      size_t num_bytes = sizeof(void*) * vector->capacity;
      vector->data = gumbo_realloc(vector->data, num_bytes);
    } else {
      // 0-capacity vector; no previous array to deallocate.
      vector->capacity = 2;
      vector->data = gumbo_alloc(sizeof(void*) * vector->capacity);
    }
  }
}

// Assembly:
movl 0xc(%rdi), %esi
cmpl %esi, 0x8(%rdi)
jb 0x7fa6
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x7f91
addl %esi, %esi
movl %esi, 0xc(%rbx)
shlq $0x3, %rsi
movq (%rbx), %rdi
callq 0x11e6a
jmp 0x7fa2
movl $0x2, 0xc(%rbx)
movl $0x10, %edi
callq 0x11e58
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/vector.c
// Function: gumbo_vector_insert_at
void gumbo_vector_insert_at (
  void* ptr,
  unsigned int index,
  GumboVector* vector
) {
  assert(index <= vector->length);
  enlarge_vector_if_full(vector);
  ++vector->length;
  memmove (
    &vector->data[index + 1],
    &vector->data[index],
    sizeof(void*) * (vector->length - index - 1)
  );
  vector->data[index] = ptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl %esi, 0x8(%rdx)
jb 0x8039
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movq %rdx, %rdi
callq 0x7f6e
movl 0x8(%rbx), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%rbx), %rax
leal 0x1(%r15), %ecx
leaq (%rax,%rcx,8), %rdi
movl %r15d, %r12d
leaq (%rax,%r12,8), %rsi
subl %r15d, %edx
shlq $0x3, %rdx
callq 0x4220
movq (%rbx), %rax
movq %r14, (%rax,%r12,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x133e5(%rip), %rdi     # 0x1b425
leaq 0x13382(%rip), %rsi     # 0x1b3c9
leaq 0x133ef(%rip), %rcx     # 0x1b43d
movl $0x52, %edx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/vector.c
// Function: gumbo_vector_remove
void gumbo_vector_remove(void* node, GumboVector* vector) {
  int index = gumbo_vector_index_of(vector, node);
  if (index == -1) {
    return;
  }
  gumbo_vector_remove_at(index, vector);
}

// Assembly:
movq %rdi, %rax
movl 0x8(%rsi), %ecx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x807f
movq (%rsi), %r8
xorl %edx, %edx
cmpq %rax, (%r8,%rdx,8)
je 0x807d
incq %rdx
cmpq %rdx, %rcx
jne 0x806d
jmp 0x807f
movl %edx, %edi
cmpl $-0x1, %edi
jne 0x8089
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/vector.c
// Function: gumbo_vector_remove_at
void* gumbo_vector_remove_at(unsigned int index, GumboVector* vector) {
  assert(index < vector->length);
  void* result = vector->data[index];
  memmove (
    &vector->data[index],
    &vector->data[index + 1],
    sizeof(void*) * (vector->length - index - 1)
  );
  --vector->length;
  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rsi), %edx
cmpl %edi, %edx
jbe 0x80c8
movq %rsi, %rbx
movq (%rsi), %rcx
movl %edi, %eax
leaq (%rcx,%rax,8), %rax
movq (%rax), %r14
leal 0x1(%rdi), %esi
leaq (%rcx,%rsi,8), %rsi
notl %edi
addl %edi, %edx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x4220
decl 0x8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x133af(%rip), %rdi     # 0x1b47e
leaq 0x132f3(%rip), %rsi     # 0x1b3c9
leaq 0x133b8(%rip), %rcx     # 0x1b495
movl $0x66, %edx
callq 0x4100
nop
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: gumbo_normalize_svg_tagname
const char* gumbo_normalize_svg_tagname(const GumboStringPiece* tag) {
  const StringReplacement *replacement = gumbo_get_svg_tag_replacement (
    tag->data,
    tag->length
  );
  return replacement ? replacement->to : NULL;
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0x19230
testq %rax, %rax
je 0x8103
movq 0x8(%rax), %rax
jmp 0x8105
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: get_current_node
static GumboNode* get_current_node(const GumboParser* parser) {
  const GumboVector* open_elements = &parser->_parser_state->_open_elements;
  if (open_elements->length == 0) {
    assert(!parser->_output->root);
    return NULL;
  }
  assert(open_elements->length > 0);
  assert(open_elements->data != NULL);
  return open_elements->data[open_elements->length - 1];
}

// Assembly:
pushq %rax
movq 0x18(%rdi), %rcx
movl 0x10(%rcx), %eax
testl %eax, %eax
je 0x8124
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x8133
decl %eax
movq (%rcx,%rax,8), %rax
jmp 0x8131
movq 0x8(%rdi), %rax
cmpq $0x0, 0x8(%rax)
jne 0x8152
xorl %eax, %eax
popq %rcx
retq
leaq 0x15b5e(%rip), %rdi     # 0x1dc98
leaq 0x156cf(%rip), %rsi     # 0x1d810
leaq 0x15b1f(%rip), %rcx     # 0x1dc67
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x4100
leaq 0x15af7(%rip), %rdi     # 0x1dc50
leaq 0x156b0(%rip), %rsi     # 0x1d810
leaq 0x15b00(%rip), %rcx     # 0x1dc67
movl $0x1dd, %edx            # imm = 0x1DD
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: parser_add_parse_error
static GumboError* parser_add_parse_error (
  GumboParser* parser,
  const GumboToken* token
) {
  gumbo_debug("Adding parse error.\n");
  GumboError* error = gumbo_add_error(parser);
  if (!error) {
    return NULL;
  }
  error->type = GUMBO_ERR_PARSER;
  error->position = token->position;
  error->original_text = token->original_text.data;
  GumboParserError* extra_data = &error->v.parser;
  extra_data->input_type = token->type;
  extra_data->input_tag = GUMBO_TAG_UNKNOWN;
  if (token->type == GUMBO_TOKEN_START_TAG) {
    extra_data->input_tag = token->v.start_tag.tag;
  } else if (token->type == GUMBO_TOKEN_END_TAG) {
    extra_data->input_tag = token->v.end_tag;
  }
  const GumboParserState* state = parser->_parser_state;
  extra_data->parser_state = state->_insertion_mode;
  gumbo_vector_init(state->_open_elements.length, &extra_data->tag_stack);
  for (unsigned int i = 0; i < state->_open_elements.length; ++i) {
    const GumboNode* node = state->_open_elements.data[i];
    assert (
      node->type == GUMBO_NODE_ELEMENT
      || node->type == GUMBO_NODE_TEMPLATE
    );
    gumbo_vector_add (
      (void*) node->v.element.tag,
      &extra_data->tag_stack
    );
  }
  return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
callq 0x72a4
testq %rax, %rax
je 0x8227
movq %rax, %r14
movq %rax, %rbx
movl $0x28, (%r14)
movups 0x8(%r12), %xmm0
movups %xmm0, 0x8(%r14)
movq 0x18(%r12), %rax
movq %rax, 0x18(%r14)
movq 0x20(%r12), %rax
movq %rax, 0x20(%r14)
movl (%r12), %eax
movl %eax, 0x28(%r14)
movl $0x96, 0x2c(%r14)
decl %eax
cmpl $0x1, %eax
ja 0x81d6
movl 0x30(%r12), %eax
movl %eax, 0x2c(%rbx)
movq 0x18(%r15), %r15
movl (%r15), %eax
movl %eax, 0x30(%rbx)
movl 0x10(%r15), %edi
addq $0x38, %r14
movq %r14, %rsi
callq 0x7ec4
cmpl $0x0, 0x10(%r15)
je 0x8229
xorl %r12d, %r12d
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %rax
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x820e
cmpl $0x6, %ecx
jne 0x8238
movl 0x28(%rax), %edi
movq %r14, %rsi
callq 0x7ef9
incq %r12
movl 0x10(%r15), %eax
cmpq %rax, %r12
jb 0x81fa
jmp 0x8229
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1597f(%rip), %rdi     # 0x1dbbe
leaq 0x155ca(%rip), %rsi     # 0x1d810
leaq 0x172d8(%rip), %rcx     # 0x1f525
movl $0x2dc, %edx            # imm = 0x2DC
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: gumbo_destroy_output
void gumbo_destroy_output(GumboOutput* output) {
  destroy_node(output->document);
  for (unsigned int i = 0; i < output->errors.length; ++i) {
    gumbo_error_destroy(output->errors.data[i]);
  }
  gumbo_vector_destroy(&output->errors);
  gumbo_free(output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8277
leaq 0x10(%rbx), %r14
cmpl $0x0, 0x18(%rbx)
je 0x83f6
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x76fc
incq %r15
movl 0x18(%rbx), %eax
cmpq %rax, %r15
jb 0x83de
movq %r14, %rdi
callq 0x7eea
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11e7c
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: create_element
static GumboNode* create_element(GumboParser* parser, GumboTag tag) {
  GumboNode* node = create_node(GUMBO_NODE_ELEMENT);
  GumboElement* element = &node->v.element;
  gumbo_vector_init(1, &element->children);
  gumbo_vector_init(0, &element->attributes);
  element->tag = tag;
  element->tag_namespace = GUMBO_NAMESPACE_HTML;
  element->original_tag = STRING_PIECE_INIT;
  element->original_end_tag = STRING_PIECE_INIT;
  element->start_pos = (parser->_parser_state->_current_token)
    ? parser->_parser_state->_current_token->position
    : kGumboEmptySourcePosition
  ;
  element->end_pos = kGumboEmptySourcePosition;
  return node;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x90, %edi
callq 0x11e58
movq %rax, %rbx
movq $0x0, 0x8(%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x10(%rbx)
movl $0x1, (%rbx)
leaq 0x18(%rbx), %rsi
movl $0x1, %edi
callq 0x7ec4
leaq 0x80(%rbx), %rsi
xorl %edi, %edi
callq 0x7ec4
movl %ebp, 0x28(%rbx)
leaq 0x50(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rbx)
movups %xmm0, 0x3c(%rbx)
movl $0x0, 0x4c(%rbx)
movq 0x18(%r14), %rcx
movq 0x98(%rcx), %rcx
testq %rcx, %rcx
je 0x848e
movq 0x18(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups 0x8(%rcx), %xmm0
movups %xmm0, (%rax)
jmp 0x8499
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: insert_element_of_tag_type
static GumboNode* insert_element_of_tag_type (
  GumboParser* parser,
  GumboTag tag,
  GumboParseFlags reason
) {
  GumboNode* element = create_element(parser, tag);
  element->parse_flags |= GUMBO_INSERTION_BY_PARSER | reason;
  insert_element(parser, element, false);
  gumbo_debug (
    "Inserting %s element (@%p) from tag type.\n",
    gumbo_normalized_tagname(tag),
    (void*)element
  );
  return element;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x840b
movq %rax, %r15
orl 0x14(%rax), %ebx
orl $0x1, %ebx
movl %ebx, 0x14(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x8703
movl %ebp, %edi
callq 0x7a30
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: reset_insertion_mode_appropriately
static void reset_insertion_mode_appropriately(GumboParser* parser) {
  const GumboVector* open_elements = &parser->_parser_state->_open_elements;
  for (int i = open_elements->length; --i >= 0;) {
    GumboInsertionMode mode = get_appropriate_insertion_mode(parser, i);
    if (mode != GUMBO_INSERTION_MODE_INITIAL) {
      set_insertion_mode(parser, mode);
      return;
    }
  }
  // Should never get here, because is_last will be set on the last iteration
  // and will force GUMBO_INSERTION_MODE_IN_BODY.
  assert(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
movl 0x10(%rax), %r15d
movl $0x6, %edx
movq %r15, %r12
testl %r12d, %r12d
jle 0x86c5
movq %r12, %r15
movq 0x18(%rdi), %r13
movq 0x8(%r13), %rax
movq -0x8(%rax,%r12,8), %rax
decq %r15
jne 0x8533
movq 0x48(%r13), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rax
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x8543
cmpl $0x6, %ecx
jne 0x86e4
cmpl $0x0, 0x2c(%rax)
je 0x855d
testq %r15, %r15
movl $0x0, %eax
cmovel %edx, %eax
testl %eax, %eax
je 0x8507
jmp 0x86b0
movl 0x28(%rax), %eax
cmpl $0x9, %eax
jle 0x8584
leal -0x5f(%rax), %ecx
cmpl $0x10, %ecx
ja 0x85a9
leaq 0x12fc4(%rip), %rsi     # 0x1b538
movslq (%rsi,%rcx,4), %rax
addq %rsi, %rax
jmpq *%rax
movl $0xc, %eax
jmp 0x8554
testl %eax, %eax
je 0x85c7
cmpl $0x1, %eax
je 0x85dc
cmpl $0x9, %eax
jne 0x8549
movl 0x30(%r13), %eax
testl %eax, %eax
je 0x8699
movq 0x28(%r13), %rcx
decl %eax
movl (%rcx,%rax,8), %eax
jmp 0x8554
cmpl $0xa, %eax
je 0x868f
cmpl $0x81, %eax
jne 0x8549
movl $0x13, %eax
jmp 0x8554
movl $0xe, %eax
jmp 0x85e1
xorl %eax, %eax
cmpq $0x0, 0x38(%r13)
setne %al
leal (%rax,%rax,2), %eax
addl $0x2, %eax
jmp 0x8554
movl $0x3, %eax
testq %r15, %r15
jne 0x8554
jmp 0x8549
movl $0xb, %eax
jmp 0x8554
movl $0x8, %eax
jmp 0x8554
movl $0xd, %eax
jmp 0x8554
movl $0xf, %eax
cmpq $0x1, %r12
je 0x8554
movq %rdi, (%rsp)
movq 0x8(%r13), %rax
movq -0x8(%rax,%r12,8), %r14
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
movl $0x9, %edx
callq 0x8b69
testb %al, %al
je 0x8645
movl $0xf, %ebx
jmp 0x8664
movq %r14, %rdi
xorl %esi, %esi
movl $0x5f, %edx
callq 0x8b69
movl %eax, %ebp
xorb $0x1, %bpl
testb %al, %al
movl $0x10, %eax
cmovnel %eax, %ebx
testb %bpl, %bpl
je 0x86a0
decq %r12
movl $0xf, %eax
cmpq $0x2, %r12
movl $0x6, %edx
movq (%rsp), %rdi
jge 0x8620
jmp 0x8554
movl $0xa, %eax
jmp 0x8554
movl $0x6, %eax
jmp 0x8554
xorl %eax, %eax
jmp 0x8554
movl %ebx, %eax
movl $0x6, %edx
movq (%rsp), %rdi
jmp 0x8554
movq 0x18(%rdi), %rcx
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16c59(%rip), %rdi     # 0x1f325
leaq 0x1513d(%rip), %rsi     # 0x1d810
leaq 0x154ad(%rip), %rcx     # 0x1db87
movl $0x2bd, %edx            # imm = 0x2BD
callq 0x4100
leaq 0x154d3(%rip), %rdi     # 0x1dbbe
leaq 0x1511e(%rip), %rsi     # 0x1d810
leaq 0x1550b(%rip), %rcx     # 0x1dc04
movl $0x275, %edx            # imm = 0x275
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: maybe_flush_text_node_buffer
static void maybe_flush_text_node_buffer(GumboParser* parser) {
  GumboParserState* state = parser->_parser_state;
  TextNodeBufferState* buffer_state = &state->_text_node;
  if (buffer_state->_buffer.length == 0) {
    return;
  }

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x18(%rdi), %r12
cmpq $0x0, 0x60(%r12)
je 0x881c
movq %rdi, %r14
movl 0x90(%r12), %r13d
leal -0x2(%r13), %eax
cmpl $0x2, %eax
jb 0x8777
cmpl $0x5, %r13d
jne 0x8845
leaq 0x58(%r12), %rbx
movl $0x90, %edi
callq 0x11e58
movq %rax, %r15
movq $0x0, 0x8(%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x10(%r15)
movl %r13d, (%r15)
movq %rbx, %rdi
callq 0x79e6
movq %rax, 0x18(%r15)
movq 0x70(%r12), %rax
movq %rax, 0x20(%r15)
movq 0x98(%r12), %rcx
movq 0x20(%rcx), %rcx
subq %rax, %rcx
movq %rcx, 0x28(%r15)
movups 0x78(%r12), %xmm0
movups %xmm0, 0x30(%r15)
movq 0x88(%r12), %rax
movq %rax, 0x40(%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x8864
cmpl $0x0, (%rax)
je 0x87f8
movq %r15, %rdi
movq %rax, %rsi
callq 0x897d
jmp 0x8800
movq %r15, %rdi
callq 0x8277
movq %rbx, %rdi
callq 0x7a1e
movl $0x5, 0x90(%r12)
cmpq $0x0, 0x60(%r12)
jne 0x8826
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x15183(%rip), %rdi     # 0x1d9b0
leaq 0x14fdc(%rip), %rsi     # 0x1d810
leaq 0x15144(%rip), %rcx     # 0x1d97f
movl $0x3ac, %edx            # imm = 0x3AC
callq 0x4100
leaq 0x150b1(%rip), %rdi     # 0x1d8fd
leaq 0x14fbd(%rip), %rsi     # 0x1d810
leaq 0x15125(%rip), %rcx     # 0x1d97f
movl $0x391, %edx            # imm = 0x391
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: node_tag_in_set
static bool node_tag_in_set(const GumboNode* node, const TagSet* tags) {
  assert(node != NULL);
  if (node->type != GUMBO_NODE_ELEMENT && node->type != GUMBO_NODE_TEMPLATE) {
    return false;
  }
  return tagset_includes (
    tags,
    node->v.element.tag_namespace,
    node->v.element.tag
  );
}

// Assembly:
testq %rdi, %rdi
je 0x8b49
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x8b35
cmpl $0x1, %eax
jne 0x8b46
movl 0x28(%rdi), %eax
movl 0x2c(%rdi), %ecx
movzbl (%rsi,%rax), %eax
btl %ecx, %eax
setb %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x168b5(%rip), %rdi     # 0x1f406
leaq 0x14cb8(%rip), %rsi     # 0x1d810
leaq 0x14e73(%rip), %rcx     # 0x1d9d2
movl $0x247, %edx            # imm = 0x247
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: node_qualified_tag_is
static bool node_qualified_tag_is (
  const GumboNode* node,
  GumboNamespaceEnum ns,
  GumboTag tag
) {
  assert(node);
  return
    (node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE)
    && node->v.element.tag == tag
    && node->v.element.tag_namespace == ns;
}

// Assembly:
testq %rdi, %rdi
je 0x8b89
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x8b7a
cmpl $0x1, %eax
jne 0x8b86
cmpl %edx, 0x28(%rdi)
jne 0x8b86
cmpl %esi, 0x2c(%rdi)
sete %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x46ac5(%rip), %rdi     # 0x4f656
leaq 0x14c78(%rip), %rsi     # 0x1d810
leaq 0x14e6c(%rip), %rcx     # 0x1da0b
movl $0x258, %edx            # imm = 0x258
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: append_node
static void append_node(GumboNode* parent, GumboNode* node) {
  assert(node->parent == NULL);
  assert(node->index_within_parent == (unsigned int) -1);
  GumboVector* children;
  if (
    parent->type == GUMBO_NODE_ELEMENT
    || parent->type == GUMBO_NODE_TEMPLATE
  ) {
    children = &parent->v.element.children;
  } else {
    assert(parent->type == GUMBO_NODE_DOCUMENT);
    children = &parent->v.document.children;
  }
  node->parent = parent;
  node->index_within_parent = children->length;
  gumbo_vector_add((void*) node, children);
  assert(node->index_within_parent < children->length);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rsi)
jne 0x8bf8
movq %rsi, %r14
cmpl $-0x1, 0x10(%rsi)
jne 0x8c17
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
jb 0x8bd0
cmpl $0x6, %eax
jne 0x8c55
leaq 0x18(%rbx), %rsi
movq %rbx, 0x8(%r14)
movl 0x20(%rbx), %eax
movl %eax, 0x10(%r14)
movq %r14, %rdi
callq 0x7ef9
movl 0x10(%r14), %eax
cmpl 0x20(%rbx), %eax
jae 0x8c36
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x14e59(%rip), %rdi     # 0x1da58
leaq 0x14c0a(%rip), %rsi     # 0x1d810
leaq 0x14f2b(%rip), %rcx     # 0x1db38
movl $0x34e, %edx            # imm = 0x34E
callq 0x4100
leaq 0x14e80(%rip), %rdi     # 0x1da9e
leaq 0x14beb(%rip), %rsi     # 0x1d810
leaq 0x14f0c(%rip), %rcx     # 0x1db38
movl $0x34f, %edx            # imm = 0x34F
callq 0x4100
leaq 0x14ece(%rip), %rdi     # 0x1db0b
leaq 0x14bcc(%rip), %rsi     # 0x1d810
leaq 0x14eed(%rip), %rcx     # 0x1db38
movl $0x35d, %edx            # imm = 0x35D
callq 0x4100
leaq 0x14f07(%rip), %rdi     # 0x1db63
leaq 0x14bad(%rip), %rsi     # 0x1d810
leaq 0x14ece(%rip), %rcx     # 0x1db38
movl $0x357, %edx            # imm = 0x357
callq 0x4100
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: is_html_integration_point
static bool is_html_integration_point(const GumboNode* node) {
  static const TagSet html_integration_point_svg_tags = {
      TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC), TAG_SVG(TITLE)
  };
  if (node_tag_in_set(node, &html_integration_point_svg_tags)) {
    return true;
  }

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

  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x12b1e(%rip), %rsi     # 0x1b7a0
callq 0x8b24
movb $0x1, %bl
testb %al, %al
jne 0x8cdd
movq %r14, %rdi
movl $0x2, %esi
movl $0x5b, %edx
callq 0x8b69
testb %al, %al
je 0x8cdb
subq $-0x80, %r14
leaq 0x1509d(%rip), %rsi     # 0x1dd4b
leaq 0x1509f(%rip), %rdx     # 0x1dd54
movq %r14, %rdi
callq 0x8ce7
testb %al, %al
jne 0x8cdd
leaq 0x15083(%rip), %rsi     # 0x1dd4b
leaq 0x1508f(%rip), %rdx     # 0x1dd5e
movq %r14, %rdi
callq 0x8ce7
testb %al, %al
jne 0x8cdd
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_before_html
static bool handle_before_html(GumboParser* parser, GumboToken* token) {
  if (token->type == GUMBO_TOKEN_DOCTYPE) {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  } else if (token->type == GUMBO_TOKEN_COMMENT) {
    append_comment_node(parser, get_document_node(parser), token);
    return true;
  } else if (token->type == GUMBO_TOKEN_WHITESPACE) {
    ignore_token(parser);
    return true;
  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
    GumboNode* html_node = insert_element_from_token(parser, token);
    parser->_output->root = html_node;
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HEAD);
    return true;
  } else if (
    token->type == GUMBO_TOKEN_END_TAG
    && !tag_in(token, false, &head_body_html_br_tags)
  ) {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  } else {
    GumboNode* html_node = insert_element_of_tag_type (
      parser,
      GUMBO_TAG_HTML,
      GUMBO_INSERTION_IMPLIED
    );
    assert(html_node);
    parser->_output->root = html_node;
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HEAD);
    parser->_parser_state->_reprocess_current_token = true;
    return true;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x4, %rax
ja 0x902f
movq %rsi, %rdx
leaq 0x12575(%rip), %rcx     # 0x1b57c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmpq *%rsi
cmpl $0x0, 0x30(%rdx)
je 0x90b8
cmpl $0x2, %eax
jne 0x902f
movl 0x30(%rdx), %eax
leaq 0x12817(%rip), %rcx     # 0x1b840
cmpb $0x0, (%rax,%rcx)
je 0x9056
movq %rbx, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x84b0
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x18(%rbx), %rax
movl $0x2, (%rax)
movb $0x1, 0x50(%rax)
jmp 0x90d5
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x8171
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xd3c9
cmpl $0x1, (%rbx)
jne 0x9080
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
xorl %eax, %eax
jmp 0x90d7
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xd3c9
movb $0x1, %al
cmpl $0x1, (%rbx)
jne 0x90d7
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
jmp 0x90d7
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xb4a3
jmp 0x90d5
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xb69f
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x18(%rbx), %rax
movl $0x2, (%rax)
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_before_head
static bool handle_before_head(GumboParser* parser, GumboToken* token) {
  if (token->type == GUMBO_TOKEN_DOCTYPE) {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  } else if (token->type == GUMBO_TOKEN_COMMENT) {
    append_comment_node(parser, get_current_node(parser), token);
    return true;
  } else if (token->type == GUMBO_TOKEN_WHITESPACE) {
    ignore_token(parser);
    return true;
  } else if (tag_is(token, kStartTag, GUMBO_TAG_HEAD)) {
    GumboNode* node = insert_element_from_token(parser, token);
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
    parser->_parser_state->_head_element = node;
    return true;
  } else if (
    token->type == GUMBO_TOKEN_END_TAG
    && !tag_in(token, false, &head_body_html_br_tags)
  ) {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  } else {
    GumboNode* node = insert_element_of_tag_type (
      parser,
      GUMBO_TAG_HEAD,
      GUMBO_INSERTION_IMPLIED
    );
    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
    parser->_parser_state->_head_element = node;
    parser->_parser_state->_reprocess_current_token = true;
    return true;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x4, %rax
ja 0x9179
movq %rsi, %r14
leaq 0x1249a(%rip), %rcx     # 0x1b590
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
cmpl $0x1, 0x30(%r14)
jne 0x9163
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb69f
movq 0x18(%rbx), %rcx
movl $0x3, (%rcx)
movq %rax, 0x38(%rcx)
jmp 0x919d
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xd3c9
movb $0x1, %al
cmpl $0x1, (%rbx)
jne 0x91cd
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
jmp 0x91cd
movq %rbx, %rdi
callq 0x8107
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xb4a3
jmp 0x919d
cmpl $0x2, %eax
jne 0x9179
movl 0x30(%r14), %eax
leaq 0x126cd(%rip), %rcx     # 0x1b840
cmpb $0x0, (%rax,%rcx)
je 0x91a1
movq %rbx, %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0x84b0
movq 0x18(%rbx), %rcx
movl $0x3, (%rcx)
movq %rax, 0x38(%rcx)
movb $0x1, 0x50(%rcx)
movb $0x1, %al
jmp 0x91cd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8171
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xd3c9
cmpl $0x1, (%rbx)
jne 0x91cb
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_in_table_text
static bool handle_in_table_text(GumboParser* parser, GumboToken* token) {
  if (token->type == GUMBO_TOKEN_NULL) {
    parser_add_parse_error(parser, token);
    ignore_token(parser);
    return false;
  } else if (
    token->type == GUMBO_TOKEN_CHARACTER
    || token->type == GUMBO_TOKEN_WHITESPACE
  ) {
    insert_text_token(parser, token);
    return true;
  } else {
    GumboParserState* state = parser->_parser_state;
    GumboStringBuffer* buffer = &state->_text_node._buffer;
    const char* data = buffer->data;
    // Note that TextNodeBuffer may contain UTF-8 characters, but the
    // presence of any one byte that is not whitespace means we flip
    // the flag, so this loop is still valid.
    for (size_t i = 0, n = buffer->length; i < n; ++i) {
      switch (data[i]) {
      case '\t':
      case '\n':
      case '\f':
      case '\r':
      case ' ':
        continue;
      default:
        state->_foster_parent_insertions = true;
        reconstruct_active_formatting_elements(parser);
        goto loopbreak;
      }
    }
    loopbreak:
    maybe_flush_text_node_buffer(parser);
    state->_foster_parent_insertions = false;
    state->_reprocess_current_token = true;
    state->_insertion_mode = state->_original_insertion_mode;
    return true;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %ebp
cmpl $0x7, %ebp
je 0x9df2
movl %ebp, %eax
andl $-0x2, %eax
cmpl $0x4, %eax
jne 0x9e1b
movq %rbx, %rdi
callq 0xb82b
jmp 0x9e69
movq %rbx, %rdi
callq 0x8171
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xd3c9
cmpl $0x1, (%rbx)
jne 0x9e69
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
jmp 0x9e69
movq 0x18(%rbx), %r14
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x9e50
movq 0x58(%r14), %rcx
xorl %edx, %edx
movabsq $0x100003600, %rsi      # imm = 0x100003600
movzbl (%rcx,%rdx), %edi
cmpq $0x20, %rdi
ja 0x9e74
btq %rdi, %rsi
jae 0x9e74
incq %rdx
cmpq %rdx, %rax
jne 0x9e38
movq %rbx, %rdi
callq 0x8740
movb $0x0, 0x54(%r14)
movb $0x1, 0x50(%r14)
movl 0x4(%r14), %eax
movl %eax, (%r14)
cmpl $0x7, %ebp
setne %al
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, 0x54(%r14)
movq %rbx, %rdi
callq 0xbd64
jmp 0x9e50
// File: /workspace/github_c_makefile_star2_O1/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: handle_in_select_in_table
static bool handle_in_select_in_table(GumboParser* parser, GumboToken* token) {
  static const TagSet tags = {
    TAG(CAPTION), TAG(TABLE), TAG(TBODY), TAG(TFOOT), TAG(THEAD),
    TAG(TR), TAG(TD), TAG(TH)
  };
  if (tag_in(token, kStartTag, &tags)) {
    parser_add_parse_error(parser, token);
    close_current_select(parser);
    parser->_parser_state->_reprocess_current_token = true;
    return false;
  } else if (tag_in(token, kEndTag, &tags)) {
    parser_add_parse_error(parser, token);
    if (!has_an_element_in_table_scope(parser, token->v.end_tag)) {
      ignore_token(parser);
      return false;
    } else {
      close_current_select(parser);
      // close_current_select already does the
      // reset_insertion_mode_appropriately
      // reset_insertion_mode_appropriately(parser);
      parser->_parser_state->_reprocess_current_token = true;
      return false;
    }
  } else {
    return handle_in_select(parser, token);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x2, %eax
je 0xac3a
cmpl $0x1, %eax
jne 0xac95
movl 0x30(%r14), %ecx
leaq 0x1290e(%rip), %rdx     # 0x1d530
cmpb $0x0, (%rcx,%rdx)
je 0xac35
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8171
jmp 0xac7b
cmpl $0x2, %eax
jne 0xac95
movl 0x30(%r14), %eax
leaq 0x128eb(%rip), %rcx     # 0x1d530
cmpb $0x0, (%rax,%rcx)
je 0xac95
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8171
movl 0x30(%r14), %eax
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x11d58(%rip), %r8      # 0x1c9c0
movq %rbx, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xbc6a
testb %al, %al
je 0xaca7
movq %rbx, %rdi
callq 0xd16e
movq 0x18(%rbx), %rax
movb $0x1, 0x50(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa7f0
movq 0x18(%rbx), %rax
movq 0x98(%rax), %rbx
movq %rbx, %rdi
callq 0xd3c9
cmpl $0x1, (%rbx)
jne 0xac8b
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
jmp 0xac8b