LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_start_dash_state
static StateResult handle_script_escaped_start_dash_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  if (c == '-') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_DASH_DASH);
    return emit_current_char(parser, output);
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
    tokenizer->_reconsume_current_input = true;
    return NEXT_CHAR;
  }
}

// Assembly:
movq 0x10(%rdi), %rax
cmpl $0x2d, %edx
jne 0xc9d9
pushq %rax
movl $0x17, (%rax)
movq %rcx, %rsi
callq 0xedf4
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
movl $0x5, (%rax)
movb $0x1, 0x4(%rsi)
pushq $0x2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_state
static StateResult handle_script_escaped_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_DASH);
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_LT);
      clear_temporary_buffer(parser);
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
    case '\0':
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      return emit_eof(parser, output);
    default:
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xca4b
testl %edx, %edx
je 0xca1b
cmpl $0x3c, %edx
je 0xca2a
cmpl $0x2d, %edx
jne 0xca0e
movq 0x10(%rbx), %rax
movl $0x16, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xedf4
jmp 0xca61
movq %rbx, %rdi
movq %r14, %rsi
callq 0xee81
xorl %eax, %eax
jmp 0xca64
movq 0x10(%rbx), %rax
movl $0x18, (%rax)
movq %rbx, %rdi
callq 0xed36
pushq $0x3c
popq %rsi
movq %rbx, %rdi
callq 0xed83
pushq $0x2
jmp 0xca63
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq %rbx, %rdi
movq %r14, %rsi
callq 0xeeaa
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_dash_state
static StateResult handle_script_escaped_dash_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_DASH_DASH);
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_LT);
      clear_temporary_buffer(parser);
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
    case '\0':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xcac7
testl %edx, %edx
je 0xca8f
cmpl $0x3c, %edx
je 0xcaa8
cmpl $0x2d, %edx
jne 0xcadd
movq 0x10(%rbx), %rax
movl $0x17, (%rax)
jmp 0xcae7
movq 0x10(%rbx), %rax
movl $0x15, (%rax)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xee81
xorl %eax, %eax
jmp 0xcaf5
movq 0x10(%rbx), %rax
movl $0x18, (%rax)
movq %rbx, %rdi
callq 0xed36
pushq $0x3c
popq %rsi
movq %rbx, %rdi
callq 0xed83
jmp 0xcad9
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
pushq $0x2
jmp 0xcaf4
movq 0x10(%rbx), %rax
movl $0x15, (%rax)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xedf4
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_dash_dash_state
static StateResult handle_script_escaped_dash_dash_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_LT);
      clear_temporary_buffer(parser);
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
      return emit_current_char(parser, output);
    case '\0':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xcb70
testl %edx, %edx
je 0xcb1f
cmpl $0x3e, %edx
je 0xcb57
cmpl $0x3c, %edx
je 0xcb38
cmpl $0x2d, %edx
je 0xcb61
movq 0x10(%rbx), %rax
movl $0x15, (%rax)
jmp 0xcb61
movq 0x10(%rbx), %rax
movl $0x15, (%rax)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xee81
xorl %eax, %eax
jmp 0xcb85
movq 0x10(%rbx), %rax
movl $0x18, (%rax)
movq %rbx, %rdi
callq 0xed36
pushq $0x3c
popq %rsi
movq %rbx, %rdi
callq 0xed83
jmp 0xcb82
movq 0x10(%rbx), %rax
movl $0x5, (%rax)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xedf4
pushq $0x1
jmp 0xcb84
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
pushq $0x2
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_lt_state
static StateResult handle_script_escaped_lt_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "<"));
  assert(!tokenizer->_script_data_buffer.length);
  if (c == '/') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_END_TAG_OPEN);
    append_char_to_temporary_buffer(parser, c);
    return NEXT_CHAR;
  } else if (is_alpha(c)) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_START);
    append_char_to_temporary_buffer(parser, c);
    gumbo_string_buffer_append_codepoint (
      ensure_lowercase(c),
      &tokenizer->_script_data_buffer
    );
    return emit_temporary_buffer(parser, output);
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xedfd(%rip), %rsi      # 0x1b99d
pushq $0x1
popq %rdx
callq 0xeeb5
testb %al, %al
je 0xcc3c
cmpq $0x0, 0x38(%r15)
jne 0xcc5b
cmpl $0x2f, %ebp
jne 0xcbda
movq 0x10(%rbx), %rax
movl $0x19, (%rax)
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0xed83
pushq $0x2
popq %rax
jmp 0xcc31
movl %ebp, %ecx
orl $0x20, %ecx
addl $-0x61, %ecx
movq 0x10(%rbx), %rax
cmpl $0x19, %ecx
ja 0xcc1d
addq $0x30, %r15
movl $0x1b, (%rax)
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed83
movzbl %bpl, %eax
leaq 0x9546(%rip), %rcx      # 0x16150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
movq %r15, %rsi
callq 0x42a0
jmp 0xcc23
movl $0x15, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xefc5
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xed5c(%rip), %rdi      # 0x1b99f
leaq 0xeb8a(%rip), %rsi      # 0x1b7d4
leaq 0xf3b9(%rip), %rcx      # 0x1c00a
movl $0x60d, %edx            # imm = 0x60D
callq 0x4100
leaq 0xf40c(%rip), %rdi      # 0x1c06e
leaq 0xeb6b(%rip), %rsi      # 0x1b7d4
leaq 0xf39a(%rip), %rcx      # 0x1c00a
movl $0x60e, %edx            # imm = 0x60E
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_end_tag_open_state
static StateResult handle_script_escaped_end_tag_open_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "</"));
  if (is_alpha(c)) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_END_TAG_NAME);
    start_new_tag(parser, false);
    append_char_to_temporary_buffer(parser, c);
    return NEXT_CHAR;
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %rbx
leaq 0xee46(%rip), %rsi      # 0x1bad3
pushq $0x2
popq %rdx
callq 0xeeb5
testb %al, %al
je 0xcce2
movl %ebp, %ecx
orl $0x20, %ecx
addl $-0x61, %ecx
movq 0x10(%rbx), %rax
cmpl $0x19, %ecx
ja 0xccc9
movl $0x1a, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xeed6
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed83
pushq $0x2
popq %rax
jmp 0xccdd
movl $0x15, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xefc5
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xeded(%rip), %rdi      # 0x1bad6
leaq 0xeae4(%rip), %rsi      # 0x1b7d4
leaq 0xf39e(%rip), %rcx      # 0x1c095
movl $0x628, %edx            # imm = 0x628
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_start_state
static StateResult handle_script_double_escaped_start_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
    case '/':
    case '>':
      gumbo_tokenizer_set_state (
        parser,
        string_piece_equal (
          &kScriptTag,
          (GumboStringPiece*) &tokenizer->_script_data_buffer
        )
        ? GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED
        : GUMBO_LEX_SCRIPT_ESCAPED
      );
      return emit_current_char(parser, output);
    default:
      if (is_alpha(c)) {
        gumbo_string_buffer_append_codepoint (
          ensure_lowercase(c),
          &tokenizer->_script_data_buffer
        );
        return emit_current_char(parser, output);
      } else {
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED);
        tokenizer->_reconsume_current_input = true;
        return NEXT_CHAR;
      }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x3e, %edx
ja 0xce60
movl %edx, %eax
movabsq $0x4000800100001600, %rcx # imm = 0x4000800100001600
btq %rax, %rcx
jae 0xce60
addq $0x30, %rsi
movq %rsi, %rdi
callq 0xf2f4
testb %al, %al
pushq $0x1c
popq %rax
pushq $0x15
popq %rcx
cmovnel %eax, %ecx
movq 0x10(%r14), %rax
movl %ecx, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xedf4
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %edx, %eax
orl $0x20, %eax
addl $-0x61, %eax
cmpl $0x19, %eax
ja 0xce8b
movzbl %dl, %eax
leaq 0x92d9(%rip), %rcx      # 0x16150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
addq $0x30, %rsi
callq 0x42a0
jmp 0xce4a
movq 0x10(%r14), %rax
movl $0x15, (%rax)
movb $0x1, 0x4(%rsi)
pushq $0x2
jmp 0xce57
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_state
static StateResult handle_script_double_escaped_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_DASH);
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_LT);
      return emit_current_char(parser, output);
    case '\0':
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xcee8
testl %edx, %edx
je 0xcec0
cmpl $0x3c, %edx
je 0xcecf
cmpl $0x2d, %edx
jne 0xced9
movq 0x10(%rbx), %rax
movl $0x1d, (%rax)
jmp 0xced9
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xee81
xorl %eax, %eax
jmp 0xcefd
movq 0x10(%rbx), %rax
movl $0x1f, (%rax)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xedf4
pushq $0x1
jmp 0xcefc
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
pushq $0x2
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_dash_state
static StateResult handle_script_double_escaped_dash_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(
          parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_DASH_DASH);
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_LT);
      return emit_current_char(parser, output);
    case '\0':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xcf47
testl %edx, %edx
je 0xcf22
cmpl $0x3c, %edx
je 0xcf3b
cmpl $0x2d, %edx
jne 0xcf5d
movq 0x10(%rbx), %rax
movl $0x1e, (%rax)
jmp 0xcf67
movq 0x10(%rbx), %rax
movl $0x1c, (%rax)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xee81
xorl %eax, %eax
jmp 0xcf75
movq 0x10(%rbx), %rax
movl $0x1f, (%rax)
jmp 0xcf67
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
pushq $0x2
jmp 0xcf74
movq 0x10(%rbx), %rax
movl $0x1c, (%rax)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xedf4
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_dash_dash_state
static StateResult handle_script_double_escaped_dash_dash_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      return emit_current_char(parser, output);
    case '<':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_LT);
      return emit_current_char(parser, output);
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
      return emit_current_char(parser, output);
    case '\0':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
      return emit_replacement_char(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SCRIPT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return NEXT_CHAR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
      return emit_current_char(parser, output);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xcfde
testl %edx, %edx
je 0xcf9f
cmpl $0x3e, %edx
je 0xcfc4
cmpl $0x3c, %edx
je 0xcfb8
cmpl $0x2d, %edx
je 0xcfce
movq 0x10(%rbx), %rax
movl $0x1c, (%rax)
jmp 0xcfce
movq 0x10(%rbx), %rax
movl $0x1c, (%rax)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xee81
xorl %eax, %eax
jmp 0xcfdc
movq 0x10(%rbx), %rax
movl $0x1f, (%rax)
jmp 0xcfce
movq 0x10(%rbx), %rax
movl $0x5, (%rax)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xedf4
pushq $0x1
popq %rax
popq %rbx
retq
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
pushq $0x2
jmp 0xcfdb
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_lt_state
static StateResult handle_script_double_escaped_lt_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  if (c == '/') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED_END);
    gumbo_string_buffer_clear(&tokenizer->_script_data_buffer);
    return emit_current_char(parser, output);
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
    tokenizer->_reconsume_current_input = true;
    return NEXT_CHAR;
  }
}

// Assembly:
movq 0x10(%rdi), %rax
cmpl $0x2f, %edx
jne 0xd02f
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movl $0x20, (%rax)
addq $0x30, %rsi
movq %rsi, %rdi
callq 0x72fb
movq %r14, %rdi
movq %rbx, %rsi
callq 0xedf4
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1c, (%rax)
movb $0x1, 0x4(%rsi)
pushq $0x2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_double_escaped_end_state
static StateResult handle_script_double_escaped_end_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
    case '/':
    case '>':
      gumbo_tokenizer_set_state(
          parser, string_piece_equal(&kScriptTag,
                      (GumboStringPiece*) &tokenizer->_script_data_buffer)
                      ? GUMBO_LEX_SCRIPT_ESCAPED
                      : GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
      return emit_current_char(parser, output);
    default:
      if (is_alpha(c)) {
        gumbo_string_buffer_append_codepoint (
          ensure_lowercase(c),
          &tokenizer->_script_data_buffer
        );
        return emit_current_char(parser, output);
      } else {
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DOUBLE_ESCAPED);
        tokenizer->_reconsume_current_input = true;
        return NEXT_CHAR;
      }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x3e, %edx
ja 0xd091
movl %edx, %eax
movabsq $0x4000800100001600, %rcx # imm = 0x4000800100001600
btq %rax, %rcx
jae 0xd091
addq $0x30, %rsi
movq %rsi, %rdi
callq 0xf2f4
testb %al, %al
pushq $0x15
popq %rax
pushq $0x1c
popq %rcx
cmovnel %eax, %ecx
movq 0x10(%r14), %rax
movl %ecx, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xedf4
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %edx, %eax
orl $0x20, %eax
addl $-0x61, %eax
cmpl $0x19, %eax
ja 0xd0bc
movzbl %dl, %eax
leaq 0x90a8(%rip), %rcx      # 0x16150
movzbl (%rcx,%rax), %edi
andl $0x20, %edi
orl %eax, %edi
addq $0x30, %rsi
callq 0x42a0
jmp 0xd07b
movq 0x10(%r14), %rax
movl $0x1c, (%rax)
movb $0x1, 0x4(%rsi)
pushq $0x2
jmp 0xd088
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_before_attr_name_state
static StateResult handle_before_attr_name_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      return NEXT_CHAR;
    case '/':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SELF_CLOSING_START_TAG);
      return NEXT_CHAR;
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return emit_current_tag(parser, output);
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_ATTR_NAME);
      append_char_to_temporary_buffer(parser, 0xfffd);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_NAME_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      abandon_current_tag(parser);
      return NEXT_CHAR;
    case '"':
    case '\'':
    case '<':
    case '=':
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_NAME_INVALID);
    // Fall through.
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_ATTR_NAME);
      append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rdi, %r14
pushq $0x2
popq %rbx
cmpl $0x3e, %edx
ja 0xd150
movl %r15d, %eax
movabsq $0x3000008400000000, %rdx # imm = 0x3000008400000000
btq %rax, %rdx
jae 0xd12d
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0xed94
movq 0x10(%r14), %rax
movl $0x22, (%rax)
movzbl %r15b, %eax
leaq 0x903c(%rip), %rcx      # 0x16150
movzbl (%rcx,%rax), %esi
andl $0x20, %esi
orl %eax, %esi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0xf1ea
jmp 0xd1bb
cmpq $0x2f, %rax
je 0xd1b1
cmpq $0x3e, %rax
jne 0xd150
movq 0x10(%r14), %rax
andl $0x0, (%rax)
movq %r14, %rdi
movq %rcx, %rsi
callq 0xf08d
pushq $0x1
popq %rbx
jmp 0xd1bb
leal -0x9(%r15), %eax
cmpl $0x2, %eax
jb 0xd1bb
cmpl $-0x1, %r15d
je 0xd172
testl %r15d, %r15d
je 0xd18e
cmpl $0xc, %r15d
je 0xd1bb
cmpl $0x20, %r15d
je 0xd1bb
jmp 0xd0ff
pushq $0xf
popq %rsi
movq %r14, %rdi
callq 0xed94
movq 0x10(%r14), %rax
andl $0x0, (%rax)
movq %r14, %rdi
callq 0xf234
jmp 0xd1bb
movq %r14, %rdi
movl %ebx, %esi
callq 0xed94
movq 0x10(%r14), %rax
movl $0x22, (%rax)
movq %r14, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xed83
jmp 0xd1bb
movq 0x10(%r14), %rax
movl $0x2a, (%rax)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_attr_name_state
static StateResult handle_attr_name_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      finish_attribute_name(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_ATTR_NAME);
      return NEXT_CHAR;
    case '/':
      finish_attribute_name(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SELF_CLOSING_START_TAG);
      return NEXT_CHAR;
    case '=':
      finish_attribute_name(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_VALUE);
      return NEXT_CHAR;
    case '>':
      finish_attribute_name(parser);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return emit_current_tag(parser, output);
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_tag_buffer(parser, UNICODE_REPLACEMENT_CHAR, true);
      return NEXT_CHAR;
    case -1:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      abandon_current_tag(parser);
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_NAME_EOF);
      return NEXT_CHAR;
    case '"':
    case '\'':
    case '<':
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_NAME_INVALID);
    // Fall through.
    default:
      append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
leal -0x9(%r14), %eax
cmpl $0x2, %eax
jb 0xd220
cmpl $-0x1, %r14d
je 0xd2ce
testl %r14d, %r14d
je 0xd28e
cmpl $0xc, %r14d
je 0xd220
cmpl $0x3e, %r14d
je 0xd2ad
cmpl $0x22, %r14d
je 0xd237
cmpl $0x27, %r14d
je 0xd237
cmpl $0x2f, %r14d
je 0xd266
cmpl $0x3c, %r14d
je 0xd237
cmpl $0x3d, %r14d
je 0xd27a
cmpl $0x20, %r14d
jne 0xd242
movq %rbx, %rdi
callq 0xf31b
movq 0x10(%rbx), %rax
movl $0x23, (%rax)
jmp 0xd2e8
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0xed94
movzbl %r14b, %eax
leaq 0x8f03(%rip), %rcx      # 0x16150
movzbl (%rcx,%rax), %esi
andl $0x20, %esi
orl %eax, %esi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0xf1ea
jmp 0xd2e8
movq %rbx, %rdi
callq 0xf31b
movq 0x10(%rbx), %rax
movl $0x2a, (%rax)
jmp 0xd2e8
movq %rbx, %rdi
callq 0xf31b
movq 0x10(%rbx), %rax
movl $0x24, (%rax)
jmp 0xd2e8
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed94
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xf1ea
jmp 0xd2eb
movq %rcx, %r15
movq %rbx, %rdi
callq 0xf31b
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf08d
pushq $0x1
jmp 0xd2ea
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
callq 0xf234
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0xed94
pushq $0x2
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_attr_value_double_quoted_state
static StateResult handle_attr_value_double_quoted_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* UNUSED_ARG(output)
) {
  switch (c) {
    case '"':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_ATTR_VALUE_QUOTED);
      return NEXT_CHAR;
    case '&':
      tokenizer->_tag_state._attr_value_state = tokenizer->_state;
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_CHAR_REF_IN_ATTR_VALUE);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_tag_buffer(parser, UNICODE_REPLACEMENT_CHAR, false);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_DOUBLE_QUOTE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      abandon_current_tag(parser);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    default:
      append_char_to_tag_buffer(parser, c, false);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xd5b9
testl %edx, %edx
je 0xd58e
cmpl $0x26, %edx
je 0xd5a3
cmpl $0x22, %edx
jne 0xd5da
movq 0x10(%rbx), %rax
movl $0x29, (%rax)
jmp 0xd5e6
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
jmp 0xd5df
movl (%r14), %eax
movl %eax, 0xbc(%r14)
movq 0x10(%rbx), %rax
movl $0x28, (%rax)
jmp 0xd5d3
pushq $0x11
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
callq 0xf234
movb $0x1, 0x4(%r14)
jmp 0xd5e6
movq %rbx, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0xf1ea
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_attr_value_single_quoted_state
static StateResult handle_attr_value_single_quoted_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* UNUSED_ARG(output)
) {
  switch (c) {
    case '\'':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_AFTER_ATTR_VALUE_QUOTED);
      return NEXT_CHAR;
    case '&':
      tokenizer->_tag_state._attr_value_state = tokenizer->_state;
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_CHAR_REF_IN_ATTR_VALUE);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_tag_buffer(parser, UNICODE_REPLACEMENT_CHAR, false);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_SINGLE_QUOTE_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      abandon_current_tag(parser);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    default:
      append_char_to_tag_buffer(parser, c, false);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xd645
testl %edx, %edx
je 0xd61a
cmpl $0x26, %edx
je 0xd62f
cmpl $0x27, %edx
jne 0xd666
movq 0x10(%rbx), %rax
movl $0x29, (%rax)
jmp 0xd672
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
jmp 0xd66b
movl (%r14), %eax
movl %eax, 0xbc(%r14)
movq 0x10(%rbx), %rax
movl $0x28, (%rax)
jmp 0xd65f
pushq $0x12
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
callq 0xf234
movb $0x1, 0x4(%r14)
jmp 0xd672
movq %rbx, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0xf1ea
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_attr_value_unquoted_state
static StateResult handle_attr_value_unquoted_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
      finish_attribute_value(parser);
      return NEXT_CHAR;
    case '&':
      tokenizer->_tag_state._attr_value_state = tokenizer->_state;
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_CHAR_REF_IN_ATTR_VALUE);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      finish_attribute_value(parser);
      return emit_current_tag(parser, output);
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_tag_buffer(parser, UNICODE_REPLACEMENT_CHAR, true);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_UNQUOTED_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_reconsume_current_input = true;
      abandon_current_tag(parser);
      return NEXT_CHAR;
    case '<':
    case '=':
    case '"':
    case '\'':
    case '`':
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_UNQUOTED_EQUALS);
    // Fall through.
    default:
      append_char_to_tag_buffer(parser, c, true);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
leal -0x20(%r14), %eax
cmpl $0x7, %eax
jbe 0xd6d0
leal -0x9(%r14), %eax
cmpl $0x2, %eax
jb 0xd6fe
leal -0x3c(%r14), %eax
cmpl $0x2, %eax
jb 0xd6e0
cmpl $-0x1, %r14d
je 0xd770
testl %r14d, %r14d
je 0xd730
cmpl $0x60, %r14d
je 0xd6e0
cmpl $0x3e, %r14d
je 0xd74f
cmpl $0xc, %r14d
jne 0xd6eb
jmp 0xd6fe
leaq 0xdfa5(%rip), %rcx      # 0x1b67c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x15
popq %rsi
movq %rbx, %rdi
callq 0xed94
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0xf1ea
jmp 0xd790
movq 0x10(%rbx), %rax
movl $0x21, (%rax)
movq %rbx, %rdi
callq 0xf535
jmp 0xd790
movl (%r12), %eax
movl %eax, 0xbc(%r12)
movq 0x10(%rbx), %rax
movl $0x28, (%rax)
movb $0x1, 0x4(%r12)
jmp 0xd790
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed94
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xf1ea
jmp 0xd793
movq %rcx, %r15
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
callq 0xf535
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf08d
pushq $0x1
jmp 0xd792
pushq $0x13
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movb $0x1, 0x4(%r12)
movq %rbx, %rdi
callq 0xf234
pushq $0x2
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_char_ref_in_attr_value_state
static StateResult handle_char_ref_in_attr_value_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int UNUSED_ARG(c),
  GumboToken* UNUSED_ARG(output)
) {
  OneOrTwoCodepoints char_ref;
  int allowed_char;
  bool is_unquoted = false;
  switch (tokenizer->_tag_state._attr_value_state) {
    case GUMBO_LEX_ATTR_VALUE_DOUBLE_QUOTED:
      allowed_char = '"';
      break;
    case GUMBO_LEX_ATTR_VALUE_SINGLE_QUOTED:
      allowed_char = '\'';
      break;
    case GUMBO_LEX_ATTR_VALUE_UNQUOTED:
      allowed_char = '>';
      is_unquoted = true;
      break;
    default:
      // -Wmaybe-uninitialized is a little overzealous here, and doesn't
      // get that the assert(0) means this codepath will never happen.
      allowed_char = ' ';
      assert(0);
  }

  // Ignore the status, since we don't have a convenient way of signalling that
  // a parser error has occurred when the error occurs in the middle of a
  // multi-state token. We'd need a flag inside the TokenizerState to do this,
  // but that's a low priority fix.
  gumbo_consume_char_ref (
    parser,
    &tokenizer->_input,
    allowed_char,
    true,
    &char_ref
  );
  if (char_ref.first != kGumboNoChar) {
    tokenizer->_reconsume_current_input = true;
    append_char_to_tag_buffer(parser, char_ref.first, is_unquoted);
    if (char_ref.second != kGumboNoChar) {
      append_char_to_tag_buffer(parser, char_ref.second, is_unquoted);
    }
  } else {
    append_char_to_tag_buffer(parser, '&', is_unquoted);
  }
  gumbo_tokenizer_set_state(parser, tokenizer->_tag_state._attr_value_state);
  return NEXT_CHAR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0xbc(%rsi), %eax
cmpl $0x25, %eax
je 0xd7d0
cmpl $0x27, %eax
je 0xd7c8
cmpl $0x26, %eax
jne 0xd845
pushq $0x27
jmp 0xd7d2
movb $0x1, %bpl
pushq $0x3e
popq %rdx
jmp 0xd7d5
pushq $0x22
popq %rdx
xorl %ebp, %ebp
leaq 0xe8(%r14), %rsi
pushq $0x1
popq %rcx
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %r8
callq 0xf714
movl (%r15), %esi
leaq 0x110c9(%rip), %rax     # 0x1e8c0
movl (%rax), %r15d
movzbl %bpl, %ebp
cmpl %r15d, %esi
jne 0xd808
pushq $0x26
popq %rsi
jmp 0xd820
movb $0x1, 0x4(%r14)
movq %rbx, %rdi
movl %ebp, %edx
callq 0xf1ea
movl 0x4(%rsp), %esi
cmpl %r15d, %esi
je 0xd82a
movq %rbx, %rdi
movl %ebp, %edx
callq 0xf1ea
movl 0xbc(%r14), %eax
movq 0x10(%rbx), %rcx
movl %eax, (%rcx)
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdb69(%rip), %rdi      # 0x1b3b5
leaq 0xdf81(%rip), %rsi      # 0x1b7d4
leaq 0xe97e(%rip), %rcx      # 0x1c1d8
movl $0x849, %edx            # imm = 0x849
callq 0x4100
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_after_attr_value_quoted_state
static StateResult handle_after_attr_value_quoted_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  finish_attribute_value(parser);
  switch (c) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
      return NEXT_CHAR;
    case '/':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_SELF_CLOSING_START_TAG);
      return NEXT_CHAR;
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      return emit_current_tag(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_AFTER_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      abandon_current_tag(parser);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_ATTR_AFTER_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf535
cmpl $0x3e, %ebp
ja 0xd8c0
movl %ebp, %eax
movabsq $0x100001600, %rcx      # imm = 0x100001600
btq %rax, %rcx
jae 0xd89e
movq 0x10(%rbx), %rax
movl $0x21, (%rax)
jmp 0xd907
cmpq $0x2f, %rax
je 0xd8fd
cmpq $0x3e, %rax
jne 0xd8c0
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf08d
pushq $0x1
jmp 0xd909
cmpl $-0x1, %ebp
jne 0xd8e1
pushq $0x16
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
callq 0xf234
jmp 0xd8f6
pushq $0x17
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x21, (%rax)
movb $0x1, 0x4(%r14)
jmp 0xd907
movq 0x10(%rbx), %rax
movl $0x2a, (%rax)
pushq $0x2
popq %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/tokenizer.c
// Function: handle_self_closing_start_tag_state
static StateResult handle_self_closing_start_tag_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  switch (c) {
    case '>':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      tokenizer->_tag_state._is_self_closing = true;
      return emit_current_tag(parser, output);
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SOLIDUS_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      abandon_current_tag(parser);
      return NEXT_CHAR;
    default:
      tokenizer_add_parse_error(parser, GUMBO_ERR_SOLIDUS_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
      tokenizer->_reconsume_current_input = true;
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xd947
movq %rsi, %r14
cmpl $0x3e, %edx
jne 0xd963
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movb $0x1, 0xc5(%r14)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xf08d
pushq $0x1
jmp 0xd97f
pushq $0x19
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
callq 0xf234
jmp 0xd97d
pushq $0x1a
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x21, (%rax)
movb $0x1, 0x4(%r14)
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_bogus_comment_state
static StateResult handle_bogus_comment_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  while (c != '>' && c != -1) {
    if (c == '\0') {
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      c = 0xFFFD;
    }
    append_char_to_temporary_buffer(parser, c);
    utf8iterator_next(&tokenizer->_input);
    c = utf8iterator_current(&tokenizer->_input);
  }
  gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
  return emit_comment(parser, output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xe8(%rsi), %r12
pushq $0x2
popq %rbp
testl %edx, %edx
je 0xd9b3
cmpl $-0x1, %edx
je 0xd9dd
cmpl $0x3e, %edx
jne 0xd9c2
jmp 0xd9dd
movq %r14, %rdi
movl %ebp, %esi
callq 0xed94
movl $0xfffd, %edx           # imm = 0xFFFD
movq %r14, %rdi
movl %edx, %esi
callq 0xed83
movq %r12, %rdi
callq 0x4337
movl 0x100(%r15), %edx
jmp 0xd9a3
movq 0x10(%r14), %rax
andl $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf5a2
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_markup_declaration_state
static StateResult handle_markup_declaration_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int UNUSED_ARG(c),
  GumboToken* UNUSED_ARG(output)
) {
  Utf8Iterator *input = &tokenizer->_input;
  if (utf8iterator_maybe_consume_literal(input, "--")) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT_START);
    tokenizer->_reconsume_current_input = true;
  } else if (utf8iterator_maybe_consume_literal_icase(input, "DOCTYPE")) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_DOCTYPE);
    tokenizer->_reconsume_current_input = true;
    // If we get here, we know we'll eventually emit a doctype token, so now is
    // the time to initialize the doctype strings. (Not in doctype_state_init,
    // since then they'll leak if ownership never gets transferred to the
    // doctype token.
    tokenizer->_doc_type_state.name = gumbo_strdup("");
    tokenizer->_doc_type_state.public_identifier = gumbo_strdup("");
    tokenizer->_doc_type_state.system_identifier = gumbo_strdup("");
  } else if (
    tokenizer->_is_current_node_foreign
    && utf8iterator_maybe_consume_literal(input, "[CDATA[")
  ) {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_CDATA);
    tokenizer->_is_in_cdata = true;
    tokenizer->_reconsume_current_input = true;
  } else {
    tokenizer_add_parse_error(parser, GUMBO_ERR_DASHES_OR_DOCTYPE);
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_BOGUS_COMMENT);
    tokenizer->_reconsume_current_input = true;
    clear_temporary_buffer(parser);
  }
  return NEXT_CHAR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe8(%rsi), %r15
leaq 0xe82d(%rip), %rsi      # 0x1c241
pushq $0x2
popq %rdx
pushq $0x1
popq %rcx
movq %r15, %rdi
callq 0x75d7
testb %al, %al
je 0xda39
movq 0x10(%r14), %rax
movl $0x2d, (%rax)
movb $0x1, 0x4(%rbx)
jmp 0xdae9
leaq 0xe804(%rip), %rsi      # 0x1c244
pushq $0x7
popq %rdx
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x75d7
testb %al, %al
je 0xda95
movq 0x10(%r14), %rax
movl $0x33, (%rax)
movb $0x1, 0x4(%rbx)
leaq 0x8bf2(%rip), %r14      # 0x16658
movq %r14, %rdi
callq 0xf6e5
movq %rax, 0xc8(%rbx)
movq %r14, %rdi
callq 0xf6e5
movq %rax, 0xd0(%rbx)
movq %r14, %rdi
callq 0xf6e5
movq %rax, 0xd8(%rbx)
jmp 0xdae9
cmpb $0x1, 0x5(%rbx)
jne 0xdac8
leaq 0xe7aa(%rip), %rsi      # 0x1c24c
pushq $0x7
popq %rdx
pushq $0x1
popq %rcx
movq %r15, %rdi
callq 0x75d7
testb %al, %al
je 0xdac8
movq 0x10(%r14), %rax
movl $0x43, (%rax)
movb $0x1, %al
movb %al, 0x6(%rbx)
movb %al, 0x4(%rbx)
jmp 0xdae9
pushq $0x1b
popq %rsi
movq %r14, %rdi
callq 0xed94
movq 0x10(%r14), %rax
movl $0x2b, (%rax)
movb $0x1, 0x4(%rbx)
movq %r14, %rdi
callq 0xed36
pushq $0x2
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_comment_start_state
static StateResult handle_comment_start_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT_START_DASH);
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT);
      append_char_to_temporary_buffer(parser, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case '>':
      tokenizer_add_parse_error(parser, GUMBO_ERR_COMMENT_INVALID);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      emit_comment(parser, output);
      return RETURN_ERROR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_COMMENT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      emit_comment(parser, output);
      return RETURN_ERROR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT);
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xdb45
testl %edx, %edx
je 0xdb1b
cmpl $0x3e, %edx
je 0xdb41
cmpl $0x2d, %edx
jne 0xdb66
movq 0x10(%rbx), %rax
movl $0x2e, (%rax)
jmp 0xdb7a
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x2f, (%rax)
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xed83
jmp 0xdb7d
pushq $0x1d
jmp 0xdb47
pushq $0x1c
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5a2
xorl %ebp, %ebp
jmp 0xdb7d
movq 0x10(%rbx), %rax
movl $0x2f, (%rax)
movq %rbx, %rdi
movl %edx, %esi
callq 0xed83
pushq $0x2
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_comment_state
static StateResult handle_comment_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT_END_DASH);
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      append_char_to_temporary_buffer(parser, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_COMMENT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      emit_comment(parser, output);
      return RETURN_ERROR;
    default:
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xdc6b
testl %edx, %edx
je 0xdc4f
cmpl $0x2d, %edx
jne 0xdc8f
movq 0x10(%rbx), %rax
movl $0x30, (%rax)
jmp 0xdc99
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed94
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xed83
jmp 0xdc9c
movq %rcx, %r14
pushq $0x1c
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5a2
xorl %ebp, %ebp
jmp 0xdc9c
movq %rbx, %rdi
movl %edx, %esi
callq 0xed83
pushq $0x2
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_comment_end_dash_state
static StateResult handle_comment_end_dash_state (
  GumboParser* parser,
  GumboTokenizerState* UNUSED_ARG(tokenizer),
  int c,
  GumboToken* output
) {
  switch (c) {
    case '-':
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT_END);
      return NEXT_CHAR;
    case '\0':
      tokenizer_add_parse_error(parser, GUMBO_ERR_UTF8_NULL);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT);
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, UNICODE_REPLACEMENT_CHAR);
      return NEXT_CHAR;
    case -1:
      tokenizer_add_parse_error(parser, GUMBO_ERR_COMMENT_EOF);
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
      emit_comment(parser, output);
      return RETURN_ERROR;
    default:
      gumbo_tokenizer_set_state(parser, GUMBO_LEX_COMMENT);
      append_char_to_temporary_buffer(parser, '-');
      append_char_to_temporary_buffer(parser, c);
      return NEXT_CHAR;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xdcf7
movl %edx, %ebp
testl %edx, %edx
je 0xdcc6
cmpl $0x2d, %ebp
jne 0xdd1b
movq 0x10(%rbx), %rax
movl $0x31, (%rax)
jmp 0xdd3a
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed94
movq 0x10(%rbx), %rax
movl $0x2f, (%rax)
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0xed83
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0xed83
jmp 0xdd3d
movq %rcx, %r14
pushq $0x1c
popq %rsi
movq %rbx, %rdi
callq 0xed94
movq 0x10(%rbx), %rax
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf5a2
xorl %ebp, %ebp
jmp 0xdd3d
movq 0x10(%rbx), %rax
movl $0x2f, (%rax)
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0xed83
movq %rbx, %rdi
movl %ebp, %esi
callq 0xed83
pushq $0x2
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq