LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/gumbo/parse.c
// Function: set_tag
static void set_tag(lua_State *L, const GumboElement *element)
{
    if (element->tag_namespace == GUMBO_NAMESPACE_SVG) {
        set_literal(L, "namespace", "svg");
        GumboStringPiece original_tag = element->original_tag;
        gumbo_tag_from_original_text(&original_tag);
        const char *normalized = gumbo_normalize_svg_tagname(&original_tag);
        if (normalized) {
            set_string(L, "localName", normalized);
            return;
        }
    } else if (element->tag_namespace == GUMBO_NAMESPACE_MATHML) {
        set_literal(L, "namespace", "math");
    }
    if (element->tag == GUMBO_TAG_UNKNOWN) {
        GumboStringPiece original_tag = element->original_tag;
        gumbo_tag_from_original_text(&original_tag);
        pushstring_lower(L, original_tag.data, original_tag.length);
    } else {
        lua_pushstring(L, gumbo_normalized_tagname(element->tag));
    }
    lua_setfield(L, -2, "localName");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2030, %rsp           # imm = 0x2030
movq %rsi, %r14
movq %rdi, %rbx
movl 0x14(%rsi), %eax
cmpl $0x2, %eax
je 0x67ff
cmpl $0x1, %eax
jne 0x6828
leaq 0xf990(%rip), %rsi      # 0x1611d
movq %rbx, %rdi
callq 0x4260
leaq 0x14b7c(%rip), %rsi     # 0x1b318
movq %rbx, %rdi
callq 0x4260
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x40c0
movups 0x18(%r14), %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movq %r15, %rdi
callq 0x7345
movq %r15, %rdi
callq 0x78f4
testq %rax, %rax
je 0x6828
movq %rax, %r15
leaq 0xf8ef(%rip), %rsi      # 0x160cb
movq %rbx, %rdi
callq 0x4260
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4260
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x40c0
jmp 0x68b8
leaq 0xf917(%rip), %rsi      # 0x1611d
movq %rbx, %rdi
callq 0x4260
leaq 0xf823(%rip), %rsi      # 0x16038
movq %rbx, %rdi
callq 0x4260
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x40c0
movl 0x10(%r14), %edi
cmpl $0x96, %edi
jne 0x6886
movups 0x18(%r14), %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x7345
movq (%r14), %r15
movq 0x8(%r14), %r14
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x41d0
xorl %ecx, %ecx
leaq 0xf8e8(%rip), %rdx      # 0x16150
cmpq %rcx, %r14
je 0x6898
movzbl (%r15,%rcx), %esi
movb (%rdx,%rsi), %dil
andb $0x20, %dil
orb %sil, %dil
movb %dil, (%rax,%rcx)
incq %rcx
jmp 0x6868
callq 0x730c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4260
jmp 0x68a6
leaq 0x10(%rsp), %rdi
addq %r14, 0x10(%rdi)
callq 0x40e0
leaq 0xf81e(%rip), %rdx      # 0x160cb
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x4110
addq $0x2030, %rsp           # imm = 0x2030
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/gumbo/parse.c
// Function: set_sourcepos
static void set_sourcepos(lua_State *L, const GumboSourcePosition pos)
{
    if (pos.line != 0) {
        set_integer(L, "line", pos.line);
        set_integer(L, "column", pos.column);
        set_integer(L, "offset", pos.offset);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rsp), %r14
testq %r14, %r14
je 0x695a
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
leaq 0xf83e(%rip), %rsi      # 0x16127
callq 0x4260
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4130
pushq $-0x3
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40c0
leaq 0xf81f(%rip), %rsi      # 0x1612c
movq %rbx, %rdi
callq 0x4260
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x4130
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40c0
leaq 0x4500f(%rip), %rsi     # 0x4b941
movq %rbx, %rdi
callq 0x4260
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x4130
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x40c0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/gumbo/parse.c
// Function: set_attributes
static void set_attributes(lua_State *L, const GumboVector *attrs)
{
    static const char attrnsmap[][6] = {"none", "xlink", "xml", "xmlns"};
    const unsigned int length = attrs->length;
    if (length > 0) {
        lua_createtable(L, length, length);
        for (unsigned int i = 0; i < length; i++) {
            const GumboAttribute *attr = (const GumboAttribute *)attrs->data[i];
            if (attr->attr_namespace == GUMBO_ATTR_NAMESPACE_NONE) {
                lua_createtable(L, 0, 5);
            } else {
                lua_createtable(L, 0, 6);
                set_string(L, "prefix", attrnsmap[attr->attr_namespace]);
            }
            set_string(L, "name", attr->name);
            set_string(L, "value", attr->value);
            set_sourcepos(L, attr->name_start);
            lua_pushvalue(L, -1);
            lua_setfield(L, -3, attr->name);
            setmetatable(L, Attribute);
            lua_rawseti(L, -2, i + 1);
        }
        setmetatable(L, AttributeList);
        lua_setfield(L, -2, "attributes");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x8(%rsi), %r15d
testq %r15, %r15
je 0x6ad0
movq %rsi, %r14
movq %rdi, %rbx
movl %r15d, %esi
movl %r15d, %edx
callq 0x40a0
negq %r15
pushq $0x1
popq %r12
pushq $-0x3
popq %rbp
leaq (%r15,%r12), %rax
cmpq $0x1, %rax
je 0x6aa5
movq (%r14), %rax
movq -0x8(%rax,%r12,8), %r13
cmpl $0x0, (%r13)
je 0x69fa
movq %rbx, %rdi
xorl %esi, %esi
pushq $0x6
popq %rdx
callq 0x40a0
movq %rbx, %rdi
leaq 0xf764(%rip), %rsi      # 0x16133
callq 0x4260
movl (%r13), %eax
imulq $0x6, %rax, %rsi
leaq 0xf63d(%rip), %rax      # 0x16020
addq %rax, %rsi
movq %rbx, %rdi
callq 0x4260
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40c0
jmp 0x6a07
movq %rbx, %rdi
xorl %esi, %esi
pushq $0x5
popq %rdx
callq 0x40a0
movq %rbx, %rdi
leaq 0xfa54(%rip), %rsi      # 0x16465
callq 0x4260
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0x4260
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40c0
movq %rbx, %rdi
leaq 0x12f51(%rip), %rsi     # 0x19987
callq 0x4260
movq 0x20(%r13), %rsi
movq %rbx, %rdi
callq 0x4260
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40c0
movq 0x48(%r13), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%r13), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x68c5
movq %rbx, %rdi
pushq $-0x1
popq %rsi
callq 0x4150
movq 0x8(%r13), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4110
movq %rbx, %rdi
pushq $0x4
popq %rsi
callq 0x6741
movq %rbx, %rdi
pushq $-0x2
popq %rsi
movq %r12, %rdx
callq 0x4180
incq %r12
jmp 0x699b
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x6741
leaq 0xf683(%rip), %rdx      # 0x1613a
pushq $-0x2
popq %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4110
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/gumbo/parse.c
// Function: create_text_node
static void create_text_node(lua_State *L, const GumboText *t, Upvalue i)
{
    lua_createtable(L, 0, 5);
    set_string(L, "data", t->text);
    set_sourcepos(L, t->start_pos);
    setmetatable(L, i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x5
popq %rdx
xorl %esi, %esi
callq 0x40a0
leaq 0x14f94(%rip), %rsi     # 0x1ba95
movq %r14, %rdi
callq 0x4260
movq (%r15), %rsi
movq %r14, %rdi
callq 0x4260
pushq $-0x3
popq %rsi
movq %r14, %rdi
callq 0x40c0
movq 0x28(%r15), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%r15), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x68c5
movq %r14, %rdi
movl %ebx, %esi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6741
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/attribute.c
// Function: gumbo_get_attribute
GumboAttribute* gumbo_get_attribute (
  const GumboVector* attrs,
  const char* name
) {
  for (unsigned int i = 0; i < attrs->length; ++i) {
    GumboAttribute* attr = attrs->data[i];
    if (ascii_streq_icase(attr->name, name)) {
      return attr;
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x8(%rdi), %ecx
xorl %edx, %edx
leaq 0xf5f3(%rip), %r8       # 0x16150
cmpq %rcx, %rdx
je 0x6ba3
movq (%rdi), %rax
movq (%rax,%rdx,8), %rax
movq 0x8(%rax), %r9
xorl %r10d, %r10d
movzbl (%r9,%r10), %r14d
movb (%r8,%r14), %r11b
andb $0x20, %r11b
movzbl (%rsi,%r10), %r15d
movb (%r8,%r15), %bl
andb $0x20, %bl
orb %r15b, %bl
orb %r14b, %r11b
je 0x6b99
incq %r10
cmpb %bl, %r11b
je 0x6b70
incq %rdx
cmpb %bl, %r11b
jne 0x6b5d
jmp 0x6ba5
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6be6
movq 0x8(%rbx), %rcx
cmpl %eax, 0x18(%rcx)
jae 0x6c03
pushq $0x48
popq %rdi
callq 0xf6a4
movq %rax, %r14
movq 0x8(%rbx), %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x7726
jmp 0x6c06
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rcx, %rsi
callq 0x6c11
movq 0x20(%r14), %rax
cmpq %r12, %rax
jb 0x6f64
cmpb $0xa, (%rax)
sete %cl
cmpq %r12, %rax
setne %dl
andb %cl, %dl
movzbl %dl, %edx
movq %rax, %rcx
subq %rdx, %rcx
cmpq %r12, %rcx
je 0x6ead
cmpb $0xa, (%rcx)
je 0x6eb0
decq %rcx
jmp 0x6e9e
movq %r12, %rcx
xorl %edx, %edx
cmpq %r12, %rcx
setne %sil
addq %r12, %r15
cmpq %r15, %rax
ja 0x6f81
movb %sil, %dl
addq %rdx, %rcx
cmpq %r15, %rax
je 0x6edd
cmpb $0xa, (%rax)
je 0x6eda
incq %rax
jmp 0x6ecb
movq %rax, %r15
movq %rsp, %r12
movq %rcx, (%r12)
subq %rcx, %r15
movq %r15, 0x8(%r12)
pushq $0xa
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x42a0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7170
movl %ebp, %edi
movq %rbx, %rsi
callq 0x42a0
movq 0x10(%r14), %rdi
addq 0x8(%rbx), %rdi
movq %rbx, %rsi
callq 0x7112
movq 0x10(%r14), %r14
cmpq $0x2, %r14
jb 0x6f41
decq %r14
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
pushq $0x20
popq %rsi
movq %r14, %rdx
callq 0x4120
addq %r14, 0x8(%rbx)
pushq $0x5e
popq %rdi
movq %rbx, %rsi
callq 0x42a0
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x42a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf6f1(%rip), %rdi      # 0x1665c
leaq 0xf5ff(%rip), %rsi      # 0x16571
leaq 0xf701(%rip), %rcx      # 0x1667a
pushq $0x75
popq %rdx
callq 0x4100
leaq 0xf72c(%rip), %rdi      # 0x166b4
leaq 0xf5e2(%rip), %rsi      # 0x16571
leaq 0xf740(%rip), %rcx      # 0x166d6
movl $0x87, %edx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0x70f4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x6e5a
movl 0x8(%r12), %esi
movq (%r12), %rdx
leaq 0xf53c(%rip), %rdi      # 0x1651c
xorl %eax, %eax
callq 0x40f0
movq %r12, %rdi
callq 0x7301
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7014
leaq 0x38(%rbx), %rdi
callq 0x7717
jmp 0x7022
cmpl $0x18, %eax
jne 0x7022
movq 0x28(%rbx), %rdi
callq 0xf6e0
movq %rbx, %rdi
popq %rbx
jmp 0xf6e0
// File: /workspace/github_c_makefile_star2_O2/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 0xf5b6(%rip), %rsi      # 0x1663e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6dd6
leaq 0xf5c0(%rip), %r15      # 0x16659
leaq 0xf5b6(%rip), %r12      # 0x16656
xorl %r13d, %r13d
movl 0x18(%r14), %eax
cmpq %rax, %r13
jae 0x70e0
testq %r13, %r13
je 0x70be
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x6dd6
movq 0x10(%r14), %rax
movl (%rax,%r13,8), %edi
callq 0x730c
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x6dd6
incq %r13
jmp 0x70a3
pushq $0x2e
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x42a0
// File: /workspace/github_c_makefile_star2_O2/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 0x712a
cmpq %rax, %r14
je 0x714c
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xf6c2
movq %rax, (%rbx)
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7211
leal 0x1(%r12), %r13d
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7118
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4080
cmpl %r12d, %eax
jne 0x7222
movl %r12d, %eax
addq %rax, 0x8(%rbx)
movl %r12d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xf4e7(%rip), %rdi      # 0x16710
leaq 0xf4eb(%rip), %rsi      # 0x1671b
leaq 0xf4f8(%rip), %rcx      # 0x1672f
pushq $0x72
popq %rdx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0xf6a4
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_O2/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 0x7325
movl %edi, %ecx
shlq $0x4, %rcx
leaq 0xf54f(%rip), %rax      # 0x16870
addq %rcx, %rax
retq
pushq %rax
leaq 0xf45e(%rip), %rdi      # 0x1678b
leaq 0xf46d(%rip), %rsi      # 0x167a1
leaq 0xf470(%rip), %rcx      # 0x167ab
movl $0xb5, %edx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0x738e
movq 0x8(%rdi), %rcx
cmpq $0x1, %rcx
jbe 0x73c5
cmpb $0x3c, (%rax)
jne 0x73e4
cmpb $0x3e, -0x1(%rax,%rcx)
jne 0x7403
cmpb $0x2f, 0x1(%rax)
jne 0x7390
cmpq $0x2, %rcx
je 0x7422
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)
xorl %edx, %edx
movabsq $0x800100001600, %rsi   # imm = 0x800100001600
cmpq %rdx, %rcx
je 0x738e
movzbl (%rax,%rdx), %r8d
cmpq $0x2f, %r8
ja 0x73c0
btq %r8, %rsi
jb 0x738a
incq %rdx
jmp 0x73aa
leaq 0xf40e(%rip), %rdi      # 0x167da
leaq 0xf3ce(%rip), %rsi      # 0x167a1
leaq 0xf412(%rip), %rcx      # 0x167ec
movl $0xc0, %edx
callq 0x4100
leaq 0xf437(%rip), %rdi      # 0x16822
leaq 0xf3af(%rip), %rsi      # 0x167a1
leaq 0xf3f3(%rip), %rcx      # 0x167ec
movl $0xc1, %edx
callq 0x4100
leaq 0xf42d(%rip), %rdi      # 0x16837
leaq 0xf390(%rip), %rsi      # 0x167a1
leaq 0xf3d4(%rip), %rcx      # 0x167ec
movl $0xc2, %edx
callq 0x4100
leaq 0xf432(%rip), %rdi      # 0x1685b
leaq 0xf371(%rip), %rsi      # 0x167a1
leaq 0xf3b5(%rip), %rcx      # 0x167ec
movl $0xc6, %edx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0x746c
movb $0x1, %al
movl $0x4ff, %edx            # imm = 0x4FF
btl %ecx, %edx
jb 0x7493
leal -0xfdd0(%rdi), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
jb 0x7493
leal -0xe(%rdi), %ecx
cmpl $0x12, %ecx
jb 0x7493
leal -0x7f(%rdi), %ecx
cmpl $0x21, %ecx
jb 0x7493
notl %edi
testw $0xfffe, %di            # imm = 0xFFFE
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
leaq (%rdi,%rdx), %rax
cmpq 0x10(%r14), %rax
ja 0x75fe
movq %rdx, %rbx
testb %cl, %cl
je 0x7602
movq %rbx, %rdx
callq 0x4200
testl %eax, %eax
je 0x7640
xorl %eax, %eax
jmp 0x7648
xorl %eax, %eax
leaq 0xeb45(%rip), %rcx      # 0x16150
cmpq %rax, %rbx
je 0x7640
movzbl (%rdi,%rax), %edx
movb (%rcx,%rdx), %r8b
andb $0x20, %r8b
orb %dl, %r8b
movzbl (%rsi,%rax), %edx
movb (%rcx,%rdx), %r9b
andb $0x20, %r9b
orb %dl, %r9b
cmpb %r9b, %r8b
jne 0x75fe
incq %rax
jmp 0x760b
movq %r14, %rdi
callq 0x4337
subq $0x1, %rbx
jae 0x7638
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6bcc
testq %rax, %rax
je 0x76ec
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), %rsi
xorl %edx, %edx
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x76e9
shll $0x8, %edx
movzbl (%rcx,%rdi), %r8d
orl %r8d, %edx
incq %rdi
jmp 0x76d4
movl %edx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x8(%rsi)
movl %edi, 0xc(%rsi)
testl %edi, %edi
je 0x7710
movl %edi, %edi
shlq $0x3, %rdi
callq 0xf6a4
jmp 0x7712
xorl %eax, %eax
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7793
movq (%r14), %rax
testq %rax, %rax
je 0x775d
movl 0x8(%r14), %ecx
cmpl 0xc(%r14), %ecx
jae 0x7776
leal 0x1(%rcx), %edx
movl %edx, 0x8(%r14)
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xfc38(%rip), %rdi      # 0x1739c
leaq 0xfc3e(%rip), %rsi      # 0x173a9
leaq 0xfc44(%rip), %rcx      # 0x173b6
pushq $0x38
jmp 0x778d
leaq 0xfc66(%rip), %rdi      # 0x173e3
leaq 0xfc25(%rip), %rsi      # 0x173a9
leaq 0xfc2b(%rip), %rcx      # 0x173b6
pushq $0x39
popq %rdx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0x77c9
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x77b6
addl %esi, %esi
movl %esi, 0xc(%rbx)
shlq $0x3, %rsi
movq (%rbx), %rdi
callq 0xf6c2
jmp 0x77c5
movl $0x2, 0xc(%rbx)
pushq $0x10
popq %rdi
callq 0xf6a4
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/vector.c
// Function: gumbo_vector_index_of
int gumbo_vector_index_of(GumboVector* vector, const void* ptr) {
  for (unsigned int i = 0, n = vector->length; i < n; ++i) {
    if (vector->data[i] == ptr) {
      return i;
    }
  }
  return -1;
}

// Assembly:
movl 0x8(%rdi), %edx
xorl %ecx, %ecx
pushq $-0x1
popq %rax
cmpq %rcx, %rdx
je 0x77fe
movq (%rdi), %r8
cmpq %rsi, (%r8,%rcx,8)
je 0x77fc
incq %rcx
jmp 0x77e9
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7857
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movq %rdx, %rdi
callq 0x7793
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 0xfba7(%rip), %rdi      # 0x17405
leaq 0xfb44(%rip), %rsi      # 0x173a9
leaq 0xfbb1(%rip), %rcx      # 0x1741d
pushq $0x52
popq %rdx
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x77e1
cmpl $-0x1, %eax
je 0x7893
movl %eax, %edi
movq %rbx, %rsi
popq %rbx
jmp 0x7895
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x78d5
movq %rsi, %rbx
movq (%rsi), %rcx
movl %edi, %esi
leaq (%rcx,%rsi,8), %rax
movq (%rax), %r14
leaq (%rcx,%rsi,8), %rsi
addq $0x8, %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 0xfb82(%rip), %rdi      # 0x1745e
leaq 0xfac6(%rip), %rsi      # 0x173a9
leaq 0xfb8b(%rip), %rcx      # 0x17475
pushq $0x66
popq %rdx
callq 0x4100
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x15400
testq %rax, %rax
je 0x790f
movq 0x8(%rax), %rax
jmp 0x7911
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7930
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x793f
decl %eax
movq (%rcx,%rax,8), %rax
jmp 0x793d
movq 0x8(%rdi), %rax
cmpq $0x0, 0x8(%rax)
jne 0x795e
xorl %eax, %eax
popq %rcx
retq
leaq 0x123e2(%rip), %rdi     # 0x19d28
leaq 0x11f53(%rip), %rsi     # 0x198a0
leaq 0x123a3(%rip), %rcx     # 0x19cf7
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x4100
leaq 0x1237b(%rip), %rdi     # 0x19ce0
leaq 0x11f34(%rip), %rsi     # 0x198a0
leaq 0x12384(%rip), %rcx     # 0x19cf7
movl $0x1dd, %edx            # imm = 0x1DD
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0x6bcc
movq %rax, %rbx
testq %rax, %rax
je 0x7a28
movq %rax, %r14
movl $0x28, (%rbx)
movups 0x8(%r12), %xmm0
movups %xmm0, 0x8(%rbx)
movq 0x18(%r12), %rax
movq %rax, 0x18(%rbx)
movq 0x20(%r12), %rax
movq %rax, 0x20(%rbx)
movl (%r12), %eax
movl %eax, 0x28(%rbx)
movl $0x96, 0x2c(%rbx)
decl %eax
cmpl $0x1, %eax
ja 0x79de
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 0x76f4
xorl %r12d, %r12d
movl 0x10(%r15), %eax
cmpq %rax, %r12
jae 0x7a28
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %rax
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x7a18
cmpl $0x6, %ecx
jne 0x7a37
movl 0x28(%rax), %edi
movq %r14, %rsi
callq 0x7726
incq %r12
jmp 0x79fb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x12210(%rip), %rdi     # 0x19c4e
leaq 0x11e5b(%rip), %rsi     # 0x198a0
leaq 0x13b69(%rip), %rcx     # 0x1b5b5
movl $0x2dc, %edx            # imm = 0x2DC
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0x7a76
leaq 0x10(%rbx), %r14
xorl %r15d, %r15d
movl 0x18(%rbx), %eax
cmpq %rax, %r15
jae 0x7bd7
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x6ffb
incq %r15
jmp 0x7bbe
movq %r14, %rdi
callq 0x7717
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf6e0
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: create_node
static GumboNode* create_node(GumboNodeType type) {
  GumboNode* node = gumbo_alloc(sizeof(GumboNode));
  node->parent = NULL;
  node->index_within_parent = -1;
  node->type = type;
  node->parse_flags = GUMBO_INSERTION_NORMAL;
  return node;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl $0x90, %edi
callq 0xf6a4
andq $0x0, 0x8(%rax)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x10(%rax)
movl %ebx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %r15
movl %r15d, %edi
callq 0x7bec
movq %rax, %rbx
leaq 0x18(%rax), %rsi
movl %r15d, %edi
callq 0x76f4
leaq 0x80(%rbx), %rsi
xorl %edi, %edi
callq 0x76f4
movl %ebp, 0x28(%rbx)
leaq 0x50(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rbx)
andl $0x0, 0x4c(%rbx)
movups %xmm0, 0x3c(%rbx)
movq 0x18(%r14), %rcx
movq 0x98(%rcx), %rcx
testq %rcx, %rcx
je 0x7c77
movq 0x18(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups 0x8(%rcx), %xmm0
movups %xmm0, (%rax)
jmp 0x7c7f
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
andq $0x0, 0x78(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7c0b
movq %rax, %r15
orl 0x14(%rax), %ebx
orl $0x1, %ebx
movl %ebx, 0x14(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x7e84
movl %ebp, %edi
callq 0x730c
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbx
movq 0x18(%rdi), %r12
movl 0x10(%r12), %r14d
pushq $0x6
popq %r13
leaq 0xf830(%rip), %rax      # 0x1753c
testl %r14d, %r14d
jle 0x7e46
movq 0x8(%r12), %rcx
movq -0x8(%rcx,%r14,8), %rcx
cmpq $0x1, %r14
jne 0x7d31
movq 0x48(%r12), %rdx
testq %rdx, %rdx
cmovneq %rdx, %rcx
movl (%rcx), %edx
cmpl $0x1, %edx
je 0x7d41
cmpl $0x6, %edx
jne 0x7e65
cmpl $0x0, 0x2c(%rcx)
je 0x7d58
cmpq $0x1, %r14
je 0x7dcb
xorl %ecx, %ecx
decq %r14
testl %ecx, %ecx
je 0x7d0c
jmp 0x7da8
movl 0x28(%rcx), %ecx
cmpl $0x9, %ecx
je 0x7d71
leal -0x5f(%rcx), %edx
cmpl $0x10, %edx
ja 0x7d86
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x30(%r12), %ecx
testl %ecx, %ecx
je 0x7d4d
movq 0x28(%r12), %rdx
decl %ecx
movl (%rdx,%rcx,8), %ecx
jmp 0x7d4f
testl %ecx, %ecx
je 0x7e27
cmpl $0x1, %ecx
je 0x7e3c
cmpl $0xa, %ecx
je 0x7dcb
cmpl $0x81, %ecx
jne 0x7d47
pushq $0x13
jmp 0x7dc9
movl %ecx, %r13d
jmp 0x7dcb
pushq $0xc
jmp 0x7dc9
cmpq $0x1, %r14
je 0x7dcb
pushq $0xe
jmp 0x7dc9
pushq $0xd
jmp 0x7dc9
pushq $0xa
jmp 0x7dc9
pushq $0x8
jmp 0x7dc9
pushq $0xb
popq %r13
movl %r13d, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0xf
popq %r13
cmpq $0x1, %r14
je 0x7dcb
pushq $0x9
popq %rbp
leal -0x1(%r14), %eax
testl %eax, %eax
jle 0x7e21
movq 0x8(%r12), %rax
movq -0x8(%rax,%r14,8), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x82b7
testb %al, %al
jne 0x7e21
movq %r15, %rdi
pushq $0x5f
popq %rsi
callq 0x82b7
decq %r14
testb %al, %al
je 0x7deb
pushq $0x10
popq %r13
movq 0x18(%rbx), %r12
jmp 0x7dcb
xorl %eax, %eax
cmpq $0x0, 0x38(%r12)
setne %al
leal (%rax,%rax,2), %r13d
addl $0x2, %r13d
jmp 0x7dcb
cmpq $0x1, %r14
je 0x7dcb
pushq $0x3
jmp 0x7dc9
leaq 0x13568(%rip), %rdi     # 0x1b3b5
leaq 0x11a4c(%rip), %rsi     # 0x198a0
leaq 0x11dbc(%rip), %rcx     # 0x19c17
movl $0x2bd, %edx            # imm = 0x2BD
callq 0x4100
leaq 0x11de2(%rip), %rdi     # 0x19c4e
leaq 0x11a2d(%rip), %rsi     # 0x198a0
leaq 0x11e1a(%rip), %rcx     # 0x19c94
movl $0x275, %edx            # imm = 0x275
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq 0x18(%rdi), %r12
cmpq $0x0, 0x60(%r12)
je 0x7f85
movq %rdi, %r14
movl 0x90(%r12), %edi
cmpl $0x5, %edi
ja 0x7fb0
pushq $0x2c
popq %rax
btl %edi, %eax
jae 0x7fb0
leaq 0x58(%r12), %rbx
callq 0x7bec
movq %rax, %r15
movq %rbx, %rdi
callq 0x72c3
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 0x7fcf
cmpl $0x0, (%rax)
je 0x7f61
movq %r15, %rdi
movq %rax, %rsi
callq 0x80dd
jmp 0x7f69
movq %r15, %rdi
callq 0x7a76
movq %rbx, %rdi
callq 0x72fb
movl $0x5, 0x90(%r12)
cmpq $0x0, 0x60(%r12)
jne 0x7f91
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x11aa8(%rip), %rdi     # 0x19a40
leaq 0x11901(%rip), %rsi     # 0x198a0
leaq 0x11a69(%rip), %rcx     # 0x19a0f
movl $0x3ac, %edx            # imm = 0x3AC
callq 0x4100
leaq 0x119d6(%rip), %rdi     # 0x1998d
leaq 0x118e2(%rip), %rsi     # 0x198a0
leaq 0x11a4a(%rip), %rcx     # 0x19a0f
movl $0x391, %edx            # imm = 0x391
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0x8297
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x8283
cmpl $0x1, %eax
jne 0x8294
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 0x131f7(%rip), %rdi     # 0x1b496
leaq 0x115fa(%rip), %rsi     # 0x198a0
leaq 0x117b5(%rip), %rcx     # 0x19a62
movl $0x247, %edx            # imm = 0x247
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0x82dd
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x82ce
cmpl $0x1, %eax
jne 0x82da
cmpl %edx, 0x28(%rdi)
jne 0x82da
cmpl %esi, 0x2c(%rdi)
sete %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x43411(%rip), %rdi     # 0x4b6f6
leaq 0x115b4(%rip), %rsi     # 0x198a0
leaq 0x117a8(%rip), %rcx     # 0x19a9b
movl $0x258, %edx            # imm = 0x258
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0x8353
movq %rsi, %r14
cmpl $-0x1, 0x10(%rsi)
jne 0x8372
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x6, %eax
ja 0x83b0
pushq $0x43
popq %rcx
btl %eax, %ecx
jae 0x83b0
leaq 0x18(%rbx), %rsi
movq %rbx, 0x8(%r14)
movl 0x20(%rbx), %eax
movl %eax, 0x10(%r14)
movq %r14, %rdi
callq 0x7726
movl 0x10(%r14), %eax
cmpl 0x20(%rbx), %eax
jae 0x8391
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1178e(%rip), %rdi     # 0x19ae8
leaq 0x1153f(%rip), %rsi     # 0x198a0
leaq 0x11860(%rip), %rcx     # 0x19bc8
movl $0x34e, %edx            # imm = 0x34E
callq 0x4100
leaq 0x117b5(%rip), %rdi     # 0x19b2e
leaq 0x11520(%rip), %rsi     # 0x198a0
leaq 0x11841(%rip), %rcx     # 0x19bc8
movl $0x34f, %edx            # imm = 0x34F
callq 0x4100
leaq 0x11803(%rip), %rdi     # 0x19b9b
leaq 0x11501(%rip), %rsi     # 0x198a0
leaq 0x11822(%rip), %rcx     # 0x19bc8
movl $0x35d, %edx            # imm = 0x35D
callq 0x4100
leaq 0x1183c(%rip), %rdi     # 0x19bf3
leaq 0x114e2(%rip), %rsi     # 0x198a0
leaq 0x11803(%rip), %rcx     # 0x19bc8
movl $0x357, %edx            # imm = 0x357
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/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 0xf409(%rip), %rsi      # 0x17830
callq 0x8272
movb $0x1, %bl
testb %al, %al
jne 0x847e
pushq $0x2
popq %rsi
pushq $0x5b
popq %rdx
movq %r14, %rdi
callq 0x82bd
testb %al, %al
je 0x847c
subq $-0x80, %r14
leaq 0x1198c(%rip), %rsi     # 0x19ddb
leaq 0x1198e(%rip), %rdx     # 0x19de4
movq %r14, %rdi
callq 0x8488
testb %al, %al
jne 0x847e
leaq 0x11972(%rip), %rsi     # 0x19ddb
leaq 0x1197e(%rip), %rdx     # 0x19dee
movq %r14, %rdi
callq 0x8488
testb %al, %al
jne 0x847e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq