LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x50f3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5110
testb $0x1, %al
jne 0x50dc
jmp 0x50e6
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50fb
jmp 0x50e8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x50a7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/ascii.h
// Function: ascii_streq_icase
static inline bool ascii_streq_icase(const char *s1, const char *s2)
{
  unsigned char c1, c2;
  bool chars_equal;
  size_t i = 0;
  do {
    c1 = ascii_tolower(s1[i]);
    c2 = ascii_tolower(s2[i]);
    chars_equal = (c1 == c2);
    i++;
  } while (c1 && chars_equal);
  return chars_equal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x51e0
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x51e0
movb %al, -0x12(%rbp)
movzbl -0x11(%rbp), %eax
movzbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x13(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movzbl -0x11(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x5182
movb -0x13(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5128
movb -0x13(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x5249
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jb 0x5249
movq $0x0, -0x8(%rbp)
jmp 0x5274
movl $0x48, %edi
callq 0x17cf0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x10, %rsi
callq 0x6a80
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/error.c
// Function: print_message
static int PRINTF(2) print_message (
  GumboStringBuffer* output,
  const char* format,
  ...
) {
  va_list args;
  va_start(args, format);
  int n = gumbo_string_buffer_vsprintf(output, format, args);
  va_end(args);
  return (n <= 0) ? 0 : n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x548b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x5d60
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
cmpl $0x0, -0x34(%rbp)
jg 0x54fb
xorl %eax, %eax
movl %eax, -0xf4(%rbp)
jmp 0x5504
movl -0x34(%rbp), %eax
movl %eax, -0xf4(%rbp)
movl -0xf4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/error.c
// Function: handle_parser_error
static void handle_parser_error (
  const GumboParserError* error,
  GumboStringBuffer* output
) {
  if (
    error->parser_state == GUMBO_INSERTION_MODE_INITIAL
    && error->input_type != GUMBO_TOKEN_DOCTYPE
  ) {
    print_message (
      output,
      "The doctype must be the first token in the document"
    );
    return;
  }

  switch (error->input_type) {
    case GUMBO_TOKEN_DOCTYPE:
      print_message(output, "This is not a legal doctype");
      return;
    case GUMBO_TOKEN_COMMENT:
      // Should never happen; comments are always legal.
      assert(0);
      // But just in case...
      print_message(output, "Comments aren't legal here");
      return;
    case GUMBO_TOKEN_CDATA:
    case GUMBO_TOKEN_WHITESPACE:
    case GUMBO_TOKEN_CHARACTER:
      print_message(output, "Character tokens aren't legal here");
      return;
    case GUMBO_TOKEN_NULL:
      print_message(output, "Null bytes are not allowed in HTML5");
      return;
    case GUMBO_TOKEN_EOF:
      if (error->parser_state == GUMBO_INSERTION_MODE_INITIAL) {
        print_message(output, "You must provide a doctype");
      } else {
        print_message(output, "Premature end of file");
        print_tag_stack(error, output);
      }
      return;
    case GUMBO_TOKEN_START_TAG:
    case GUMBO_TOKEN_END_TAG:
      print_message(output, "That tag isn't allowed here");
      print_tag_stack(error, output);
      // TODO(jdtang): Give more specific messaging.
      return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x555a
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x555a
movq -0x10(%rbp), %rdi
leaq 0x2a04b(%rip), %rsi     # 0x2f599
movb $0x0, %al
callq 0x5450
jmp 0x563e
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x8, %rax
ja 0x563e
movq -0x18(%rbp), %rax
leaq 0x29d6f(%rip), %rcx     # 0x2f2e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
leaq 0x2a040(%rip), %rsi     # 0x2f5cd
movb $0x0, %al
callq 0x5450
jmp 0x563e
leaq 0x2f94f(%rip), %rdi     # 0x34eef
leaq 0x2a042(%rip), %rsi     # 0x2f5e9
movl $0x51, %edx
leaq 0x2a042(%rip), %rcx     # 0x2f5f5
callq 0x4100
movq -0x10(%rbp), %rdi
leaq 0x2a07a(%rip), %rsi     # 0x2f63d
movb $0x0, %al
callq 0x5450
jmp 0x563e
movq -0x10(%rbp), %rdi
leaq 0x2a089(%rip), %rsi     # 0x2f660
movb $0x0, %al
callq 0x5450
jmp 0x563e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x55fe
movq -0x10(%rbp), %rdi
leaq 0x2a08f(%rip), %rsi     # 0x2f684
movb $0x0, %al
callq 0x5450
jmp 0x561d
movq -0x10(%rbp), %rdi
leaq 0x2a096(%rip), %rsi     # 0x2f69f
movb $0x0, %al
callq 0x5450
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5a20
jmp 0x563e
movq -0x10(%rbp), %rdi
leaq 0x2a08b(%rip), %rsi     # 0x2f6b5
movb $0x0, %al
callq 0x5450
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5a20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5280
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x5770
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x5840
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
movl $0xa, %edi
callq 0x5c00
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x5d00
movq -0x20(%rbp), %rsi
movl $0xa, %edi
callq 0x5c00
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x5b10
movq -0x8(%rbp), %rax
cmpq $0x2, 0x10(%rax)
jb 0x5744
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x48(%rbp), %rdx
movl $0x20, %esi
callq 0x4120
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rsi
movl $0x5e, %edi
callq 0x5c00
movq -0x20(%rbp), %rsi
movl $0xa, %edi
callq 0x5c00
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/error.c
// Function: find_prev_newline
static const char* find_prev_newline (
  const char* source_text,
  const char* error_location
) {
  assert(error_location >= source_text);
  const char* c = error_location;
  if (*c == '\n' && c != source_text) {
    --c;
  }
  while (c != source_text && *c != '\n') {
    --c;
  }
  return c == source_text ? c : c + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jb 0x578c
jmp 0x57ab
leaq 0x29f5c(%rip), %rdi     # 0x2f6ef
leaq 0x29e4f(%rip), %rsi     # 0x2f5e9
movl $0x75, %edx
leaq 0x29f67(%rip), %rcx     # 0x2f70d
callq 0x4100
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x57d5
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x57d5
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x57d7
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x19(%rbp)
je 0x57f6
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x57ff
jmp 0x580d
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x57d7
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x5821
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x582d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/error.c
// Function: find_next_newline
static const char* find_next_newline (
  const char* source_text_end,
  const char* error_location
) {
  assert(error_location <= source_text_end);
  const char* c = error_location;
  while (c != source_text_end && *c != '\n') {
    ++c;
  }
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
ja 0x585c
jmp 0x587b
leaq 0x29ee4(%rip), %rdi     # 0x2f747
leaq 0x29d7f(%rip), %rsi     # 0x2f5e9
movl $0x87, %edx
leaq 0x29ef3(%rip), %rcx     # 0x2f769
callq 0x4100
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x19(%rbp)
je 0x58a2
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x58ab
jmp 0x58b9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5883
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5ad0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x5650
movq -0x28(%rbp), %rax
movl %eax, %esi
movq -0x30(%rbp), %rdx
leaq 0x29c81(%rip), %rdi     # 0x2f594
movb $0x0, %al
callq 0x40f0
leaq -0x30(%rbp), %rdi
callq 0x5f60
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x28, (%rax)
je 0x594e
movq -0x8(%rbp), %rax
cmpl $0x29, (%rax)
jne 0x5961
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
addq $0x10, %rdi
callq 0x6a50
jmp 0x5979
movq -0x8(%rbp), %rax
cmpl $0x18, (%rax)
jne 0x5977
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x17d80
jmp 0x5979
movq -0x8(%rbp), %rdi
callq 0x17d80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x29c96(%rip), %rsi     # 0x2f6d1
movb $0x0, %al
callq 0x5450
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x5aaf
cmpl $0x0, -0x14(%rbp)
je 0x5a6d
movq -0x10(%rbp), %rdi
leaq 0x29c83(%rip), %rsi     # 0x2f6e9
movb $0x0, %al
callq 0x5450
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %edi
callq 0x5f80
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x29c4f(%rip), %rsi     # 0x2f6ec
movb $0x0, %al
callq 0x5450
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5a49
movq -0x10(%rbp), %rsi
movl $0x2e, %edi
callq 0x5c00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5b83
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
jmp 0x5b6c
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x5bb7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x17d30
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/string_buffer.c
// Function: gumbo_string_buffer_append_codepoint
HOT void gumbo_string_buffer_append_codepoint (
  int c,
  GumboStringBuffer* output
) {
  // num_bytes is actually the number of continuation bytes, 1 less than the
  // total number of bytes. This is done to keep the loop below simple and
  // should probably change if we unroll it.
  int num_bytes;
  int prefix;
  if (c <= 0x7f) {
    num_bytes = 0;
    prefix = 0;
  } else if (c <= 0x7ff) {
    num_bytes = 1;
    prefix = 0xc0;
  } else if (c <= 0xffff) {
    num_bytes = 2;
    prefix = 0xe0;
  } else {
    num_bytes = 3;
    prefix = 0xf0;
  }
  maybe_resize_string_buffer(num_bytes + 1, output);
  output->data[output->length++] = prefix | (c >> (num_bytes * 6));
  for (int i = num_bytes - 1; i >= 0; --i) {
    output->data[output->length++] = 0x80 | (0x3f & (c >> (i * 6)));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x7f, -0x4(%rbp)
jg 0x5c25
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
jmp 0x5c69
cmpl $0x7ff, -0x4(%rbp)      # imm = 0x7FF
jg 0x5c3e
movl $0x1, -0x14(%rbp)
movl $0xc0, -0x18(%rbp)
jmp 0x5c67
cmpl $0xffff, -0x4(%rbp)     # imm = 0xFFFF
jg 0x5c57
movl $0x2, -0x14(%rbp)
movl $0xe0, -0x18(%rbp)
jmp 0x5c65
movl $0x3, -0x14(%rbp)
movl $0xf0, -0x18(%rbp)
jmp 0x5c67
jmp 0x5c69
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movq -0x10(%rbp), %rsi
callq 0x5b40
movl -0x18(%rbp), %eax
movl -0x4(%rbp), %edx
imull $0x6, -0x14(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x5cf4
movl -0x4(%rbp), %eax
imull $0x6, -0x1c(%rbp), %ecx
sarl %cl, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5cb3
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x4080
movl %eax, -0x44(%rbp)
leaq -0x40(%rbp), %rax
cmpl $0x0, -0x44(%rbp)
jg 0x5db3
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5e2c
movl -0x44(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movq -0x10(%rbp), %rsi
callq 0x5b40
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rdi
movl -0x44(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4080
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jne 0x5df7
jmp 0x5e16
leaq 0x299a5(%rip), %rdi     # 0x2f7a3
leaq 0x299a9(%rip), %rsi     # 0x2f7ae
movl $0x72, %edx
leaq 0x299b1(%rip), %rcx     # 0x2f7c2
callq 0x4100
movslq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x1, %rdi
callq 0x17cf0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x41a0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x97, -0x4(%rbp)
ja 0x5f96
jmp 0x5fb5
leaq 0x29881(%rip), %rdi     # 0x2f81e
leaq 0x29890(%rip), %rsi     # 0x2f834
movl $0xb5, %edx
leaq 0x2988e(%rip), %rcx     # 0x2f83e
callq 0x4100
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x2994f(%rip), %rax     # 0x2f910
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5fd5
jmp 0x5ff4
leaq 0x29891(%rip), %rdi     # 0x2f86d
leaq 0x29851(%rip), %rsi     # 0x2f834
movl $0xb7, %edx
leaq 0x2984f(%rip), %rcx     # 0x2f83e
callq 0x4100
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x601b
jmp 0x61b0
movq -0x8(%rbp), %rax
cmpq $0x2, 0x8(%rax)
jb 0x6028
jmp 0x6047
leaq 0x29846(%rip), %rdi     # 0x2f875
leaq 0x297fe(%rip), %rsi     # 0x2f834
movl $0xc0, %edx
leaq 0x29845(%rip), %rcx     # 0x2f887
callq 0x4100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x6058
jmp 0x6077
leaq 0x2985e(%rip), %rdi     # 0x2f8bd
leaq 0x297ce(%rip), %rsi     # 0x2f834
movl $0xc1, %edx
leaq 0x29815(%rip), %rcx     # 0x2f887
callq 0x4100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3e, %eax
jne 0x6095
jmp 0x60b4
leaq 0x29836(%rip), %rdi     # 0x2f8d2
leaq 0x29791(%rip), %rsi     # 0x2f834
movl $0xc2, %edx
leaq 0x297d8(%rip), %rcx     # 0x2f887
callq 0x4100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x6113
movq -0x8(%rbp), %rax
cmpq $0x3, 0x8(%rax)
jb 0x60d1
jmp 0x60f0
leaq 0x2981e(%rip), %rdi     # 0x2f8f6
leaq 0x29755(%rip), %rsi     # 0x2f834
movl $0xc6, %edx
leaq 0x2979c(%rip), %rcx     # 0x2f887
callq 0x4100
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0x3, %rcx
movq %rcx, 0x8(%rax)
jmp 0x61b0
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0x2, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
addq 0x8(%rdx), %rcx
cmpq %rcx, %rax
je 0x61ae
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x6186
jmp 0x6168
movl -0x14(%rbp), %eax
subl $0xc, %eax
je 0x6186
jmp 0x6172
movl -0x14(%rbp), %eax
subl $0x20, %eax
je 0x6186
jmp 0x617c
movl -0x14(%rbp), %eax
subl $0x2f, %eax
jne 0x619e
jmp 0x6186
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x61b0
jmp 0x61a0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x613c
jmp 0x61b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jl 0x6228
movb $0x1, %al
cmpl $0x8, -0x4(%rbp)
movb %al, -0x5(%rbp)
jle 0x6298
movb $0x1, %al
cmpl $0xb, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x6298
cmpl $0xe, -0x4(%rbp)
jl 0x6244
movb $0x1, %al
cmpl $0x1f, -0x4(%rbp)
movb %al, -0x5(%rbp)
jle 0x6298
cmpl $0x7f, -0x4(%rbp)
jl 0x6258
movb $0x1, %al
cmpl $0x9f, -0x4(%rbp)
movb %al, -0x5(%rbp)
jle 0x6298
cmpl $0xfdd0, -0x4(%rbp)     # imm = 0xFDD0
jl 0x626f
movb $0x1, %al
cmpl $0xfdef, -0x4(%rbp)     # imm = 0xFDEF
movb %al, -0x5(%rbp)
jle 0x6298
movl -0x4(%rbp), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movb $0x1, %al
cmpl $0xfffe, %ecx           # imm = 0xFFFE
movb %al, -0x5(%rbp)
je 0x6298
movl -0x4(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cmpl $0xffff, %eax           # imm = 0xFFFF
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/utf8.c
// Function: utf8iterator_init
void utf8iterator_init (
  GumboParser* parser,
  const char* source,
  size_t source_length,
  Utf8Iterator* iter
) {
  iter->_start = source;
  iter->_end = source + source_length;
  iter->_pos.line = 1;
  iter->_pos.column = 1;
  iter->_pos.offset = 0;
  iter->_parser = parser;
  read_char(iter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x1, 0x28(%rax)
movq -0x20(%rbp), %rax
movq $0x1, 0x30(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rdi
callq 0x6320
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/utf8.c
// Function: utf8iterator_next
HOT void utf8iterator_next(Utf8Iterator* iter) {
  // We update positions based on the *last* character read, so that the first
  // character following a newline is at column 1 in the next line.
  update_position(iter);
  iter->_start += iter->_width;
  read_char(iter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6540
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x6320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/utf8.c
// Function: update_position
static void update_position(Utf8Iterator* iter) {
  iter->_pos.offset += iter->_width;
  switch (iter->_current) {
  case '\n':
    ++iter->_pos.line;
    iter->_pos.column = 1;
    break;
  case '\t': {
    int tab_stop = iter->_parser->_options->tab_stop;
    iter->_pos.column = ((iter->_pos.column / tab_stop) + 1) * tab_stop;
    break;
  }
  case -1:
    break;
  default:
    ++iter->_pos.column;
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
movq 0x38(%rax), %rcx
addq %rdx, %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x10(%rbp)
subl $-0x1, %eax
je 0x65d8
jmp 0x656c
movl -0x10(%rbp), %eax
subl $0x9, %eax
je 0x659e
jmp 0x6576
movl -0x10(%rbp), %eax
subl $0xa, %eax
jne 0x65da
jmp 0x6580
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x30(%rax)
jmp 0x65ea
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
addq $0x1, %rcx
movslq -0xc(%rbp), %rax
imulq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x65ea
jmp 0x65ea
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x31(%rbp)
ja 0x6671
testb $0x1, -0x21(%rbp)
je 0x6649
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66c0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x38(%rbp)
jmp 0x6665
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6700
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x22(%rbp)
testb $0x1, -0x22(%rbp)
je 0x66ae
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x66a8
movq -0x10(%rbp), %rdi
callq 0x6500
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6687
movb $0x1, -0x1(%rbp)
jmp 0x66b2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/ascii.h
// Function: mem_equal_icase
static inline bool mem_equal_icase(const void *p1, const void *p2, size_t n)
{
  const unsigned char *s1 = p1;
  const unsigned char *s2 = p2;
  while (n) {
    if (ascii_tolower(*s1++) != ascii_tolower(*s2++)) {
      return false;
    }
    n--;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x677f
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %edi
callq 0x69c0
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movzbl (%rax), %edi
callq 0x69c0
movb %al, %cl
movl -0x34(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x6771
movb $0x0, -0x1(%rbp)
jmp 0x6783
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6724
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/utf8.c
// Function: decode
static inline uint32_t decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
  uint32_t type = utf8d[byte];

  *codep =
    (*state != UTF8_ACCEPT)
      ? (byte & 0x3fu) | (*codep << 6)
      : (0xff >> type) & (byte);

  *state = utf8d[256 + *state + type];
  return *state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x29a55(%rip), %rax     # 0x302d0
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x68a1
movl -0x14(%rbp), %eax
andl $0x3f, %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
shll $0x6, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x68b1
movl -0x18(%rbp), %ecx
movl $0xff, %eax
sarl %cl, %eax
andl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x100, %eax            # imm = 0x100
addl -0x18(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x299fd(%rip), %rax     # 0x302d0
movzbl (%rax,%rcx), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5210
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6924
jmp 0x69ab
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x30(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x38(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x69a1
movl -0x24(%rbp), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x30(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x696b
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
cmpl $0x0, -0x4(%rbp)
jbe 0x6a34
movl -0x4(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x17cf0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6a3f
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6b20
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6aa5
jmp 0x6ac4
leaq 0x29990(%rip), %rdi     # 0x3043c
leaq 0x29996(%rip), %rsi     # 0x30449
movl $0x38, %edx
leaq 0x29997(%rip), %rcx     # 0x30456
callq 0x4100
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x6ad6
jmp 0x6af5
leaq 0x299a6(%rip), %rdi     # 0x30483
leaq 0x29965(%rip), %rsi     # 0x30449
movl $0x39, %edx
leaq 0x29966(%rip), %rcx     # 0x30456
callq 0x4100
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rsi
movl 0x8(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x8(%rsi)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x6ba6
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x6b7d
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
shll %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shlq $0x3, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x17d30
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6ba4
movq -0x8(%rbp), %rax
movl $0x2, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x17cf0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6ba6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x6c3e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x6c31
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6c45
jmp 0x6c33
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6c0d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
ja 0x6c71
jmp 0x6c90
leaq 0x2982d(%rip), %rdi     # 0x304a5
leaq 0x297ca(%rip), %rsi     # 0x30449
movl $0x52, %edx
leaq 0x29832(%rip), %rcx     # 0x304bd
callq 0x4100
movq -0x18(%rbp), %rdi
callq 0x6b20
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl -0xc(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x3, %rdx
callq 0x4220
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6bf0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x6d28
jmp 0x6d34
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x6d40
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x6d5d
jmp 0x6d7c
leaq 0x2979a(%rip), %rdi     # 0x304fe
leaq 0x296de(%rip), %rsi     # 0x30449
movl $0x66, %edx
leaq 0x2979e(%rip), %rcx     # 0x30515
callq 0x4100
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x4(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
subl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x3, %rdx
callq 0x4220
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2e930
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6e29
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6e31
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x6e31
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: output_init
static void output_init(GumboParser* parser) {
  GumboOutput* output = gumbo_alloc(sizeof(GumboOutput));
  output->root = NULL;
  output->document = new_document_node();
  output->status = GUMBO_STATUS_OK;
  parser->_output = output;
  gumbo_init_errors(parser);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x17cf0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
callq 0x7c90
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x5990
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/parser.c
// Function: parser_state_init
static void parser_state_init(GumboParser* parser) {
  GumboParserState* parser_state = gumbo_alloc(sizeof(GumboParserState));
  parser_state->_insertion_mode = GUMBO_INSERTION_MODE_INITIAL;
  parser_state->_reprocess_current_token = false;
  parser_state->_frameset_ok = true;
  parser_state->_ignore_next_linefeed = false;
  parser_state->_foster_parent_insertions = false;
  parser_state->_text_node._type = GUMBO_NODE_WHITESPACE;
  gumbo_string_buffer_init(&parser_state->_text_node._buffer);
  gumbo_vector_init(10, &parser_state->_open_elements);
  gumbo_vector_init(5, &parser_state->_active_formatting_elements);
  gumbo_vector_init(5, &parser_state->_template_insertion_modes);
  parser_state->_head_element = NULL;
  parser_state->_form_element = NULL;
  parser_state->_fragment_ctx = NULL;
  parser_state->_current_token = NULL;
  parser_state->_closed_body_tag = false;
  parser_state->_closed_html_tag = false;
  parser->_parser_state = parser_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xa8, %edi
callq 0x17cf0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x52(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x53(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x54(%rax)
movq -0x10(%rbp), %rax
movl $0x5, 0x90(%rax)
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x5ad0
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movl $0xa, %edi
callq 0x69f0
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x5, %edi
callq 0x69f0
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movl $0x5, %edi
callq 0x69f0
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0xa0(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0xa1(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq