LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rcdata_end_tag_name_state
static StateResult handle_rcdata_end_tag_name_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  UNUSED_IF_NDEBUG(tokenizer);
  assert(tokenizer->_temporary_buffer.length >= 2);
  if (is_alpha(c)) {
    append_char_to_tag_buffer(parser, ensure_lowercase(c), true);
    append_char_to_temporary_buffer(parser, c);
    return NEXT_CHAR;
  } else if (is_appropriate_end_tag(parser)) {
    switch (c) {
      case '\t':
      case '\n':
      case '\f':
      case ' ':
        finish_tag_name(parser);
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_BEFORE_ATTR_NAME);
        return NEXT_CHAR;
      case '/':
        finish_tag_name(parser);
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_SELF_CLOSING_START_TAG);
        return NEXT_CHAR;
      case '>':
        finish_tag_name(parser);
        gumbo_tokenizer_set_state(parser, GUMBO_LEX_DATA);
        return emit_current_tag(parser, output);
    }
  }
  gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA);
  abandon_current_tag(parser);
  return emit_temporary_buffer(parser, output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x2, 0x18(%rax)
jb 0x12b84
jmp 0x12ba3
leaq 0x23e8d(%rip), %rdi     # 0x36a18
leaq 0x2389e(%rip), %rsi     # 0x36430
movl $0x4d5, %edx            # imm = 0x4D5
leaq 0x23ea3(%rip), %rcx     # 0x36a41
callq 0x4100
movl -0x1c(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x12bb1
jmp 0x12be9
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %edi
callq 0x17170
movq -0x30(%rbp), %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x174b0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x12cc9
movq -0x10(%rbp), %rdi
callq 0x175d0
testb $0x1, %al
jne 0x12bfb
jmp 0x12c9b
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x12c33
jmp 0x12c0b
movl -0x34(%rbp), %eax
subl $0xc, %eax
je 0x12c33
jmp 0x12c15
movl -0x34(%rbp), %eax
subl $0x20, %eax
je 0x12c33
jmp 0x12c1f
movl -0x34(%rbp), %eax
subl $0x2f, %eax
je 0x12c53
jmp 0x12c29
movl -0x34(%rbp), %eax
subl $0x3e, %eax
je 0x12c73
jmp 0x12c99
movq -0x10(%rbp), %rdi
callq 0x17260
movq -0x10(%rbp), %rdi
movl $0x21, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x12cc9
movq -0x10(%rbp), %rdi
callq 0x17260
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x12cc9
movq -0x10(%rbp), %rdi
callq 0x17260
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x172b0
movl %eax, -0x4(%rbp)
jmp 0x12cc9
jmp 0x12c9b
jmp 0x12c9d
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x17510
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rawtext_lt_state
static StateResult handle_rawtext_lt_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "<"));
  if (c == '/') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RAWTEXT_END_TAG_OPEN);
    append_char_to_temporary_buffer(parser, '/');
    return NEXT_CHAR;
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_RAWTEXT);
    tokenizer->_reconsume_current_input = true;
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x23962(%rip), %rsi     # 0x36664
movl $0x1, %edx
callq 0x16f40
testb $0x1, %al
jne 0x12d12
jmp 0x12d14
jmp 0x12d33
leaq 0x2394b(%rip), %rdi     # 0x36666
leaq 0x2370e(%rip), %rsi     # 0x36430
movl $0x4f9, %edx            # imm = 0x4F9
leaq 0x23dbf(%rip), %rcx     # 0x36aed
callq 0x4100
cmpl $0x2f, -0x1c(%rbp)
jne 0x12d5e
movq -0x10(%rbp), %rdi
movl $0xe, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x12d89
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_rawtext_end_tag_open_state
static StateResult handle_rawtext_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_RAWTEXT_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_RAWTEXT);
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x239eb(%rip), %rsi     # 0x367ad
movl $0x2, %edx
callq 0x16f40
testb $0x1, %al
jne 0x12dd2
jmp 0x12dd4
jmp 0x12df3
leaq 0x239d5(%rip), %rdi     # 0x367b0
leaq 0x2364e(%rip), %rsi     # 0x36430
movl $0x50c, %edx            # imm = 0x50C
leaq 0x23d5c(%rip), %rcx     # 0x36b4a
callq 0x4100
movl -0x1c(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x12e01
jmp 0x12e2f
movq -0x10(%rbp), %rdi
movl $0xf, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x16fc0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x12e52
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_lt_state
static StateResult handle_script_lt_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  assert(temporary_buffer_equals(parser, "<"));
  if (c == '/') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_END_TAG_OPEN);
    append_char_to_temporary_buffer(parser, '/');
    return NEXT_CHAR;
  } else if (c == '!') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_START);
    append_char_to_temporary_buffer(parser, '!');
    return emit_temporary_buffer(parser, output);
  } else {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
    tokenizer->_reconsume_current_input = true;
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x23642(%rip), %rsi     # 0x36664
movl $0x1, %edx
callq 0x16f40
testb $0x1, %al
jne 0x13032
jmp 0x13034
jmp 0x13053
leaq 0x2362b(%rip), %rdi     # 0x36666
leaq 0x233ee(%rip), %rsi     # 0x36430
movl $0x546, %edx            # imm = 0x546
leaq 0x23bfa(%rip), %rcx     # 0x36c48
callq 0x4100
cmpl $0x2f, -0x1c(%rbp)
jne 0x1307e
movq -0x10(%rbp), %rdi
movl $0x11, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x130e2
cmpl $0x21, -0x1c(%rbp)
jne 0x130b7
movq -0x10(%rbp), %rdi
movl $0x13, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl $0x21, %esi
callq 0x16c30
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x130e2
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_end_tag_open_state
static StateResult handle_script_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_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);
    return emit_temporary_buffer(parser, output);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2369b(%rip), %rsi     # 0x367ad
movl $0x2, %edx
callq 0x16f40
testb $0x1, %al
jne 0x13122
jmp 0x13124
jmp 0x13143
leaq 0x23685(%rip), %rdi     # 0x367b0
leaq 0x232fe(%rip), %rsi     # 0x36430
movl $0x55d, %edx            # imm = 0x55D
leaq 0x23b66(%rip), %rcx     # 0x36ca4
callq 0x4100
movl -0x1c(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x13151
jmp 0x1317f
movq -0x10(%rbp), %rdi
movl $0x12, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x16fc0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x131a2
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_escaped_start_state
static StateResult handle_script_escaped_start_state (
  GumboParser* parser,
  GumboTokenizerState* tokenizer,
  int c,
  GumboToken* output
) {
  if (c == '-') {
    gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_ESCAPED_START_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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2d, -0x1c(%rbp)
jne 0x13372
movq -0x10(%rbp), %rdi
movl $0x14, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1338f
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2d, -0x1c(%rbp)
jne 0x133e2
movq -0x10(%rbp), %rdi
movl $0x17, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x133ff
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x134bb
jmp 0x13438
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x134a9
jmp 0x13441
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
je 0x13458
jmp 0x1344b
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
je 0x1347d
jmp 0x134db
movq -0x10(%rbp), %rdi
movl $0x16, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x134f0
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x16bb0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x134f0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16ed0
movl %eax, -0x4(%rbp)
jmp 0x134f0
movq -0x10(%rbp), %rdi
movl $0xe, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16f10
movl %eax, -0x4(%rbp)
jmp 0x134f0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x135bc
jmp 0x13528
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x1359c
jmp 0x13531
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
je 0x13548
jmp 0x1353b
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
je 0x13570
jmp 0x135de
movq -0x10(%rbp), %rdi
movl $0x17, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13601
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x16bb0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x13601
movq -0x10(%rbp), %rdi
movl $0x15, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16ed0
movl %eax, -0x4(%rbp)
jmp 0x13601
movq -0x10(%rbp), %rdi
movl $0xe, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x13601
movq -0x10(%rbp), %rdi
movl $0x15, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_script_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x136f4
jmp 0x13638
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x136d4
jmp 0x13645
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
je 0x13666
jmp 0x1364f
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
je 0x13680
jmp 0x13659
movl -0x2c(%rbp), %eax
subl $0x3e, %eax
je 0x136af
jmp 0x13716
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13739
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x16bb0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x13739
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13739
movq -0x10(%rbp), %rdi
movl $0x15, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16ed0
movl %eax, -0x4(%rbp)
jmp 0x13739
movq -0x10(%rbp), %rdi
movl $0xe, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x13739
movq -0x10(%rbp), %rdi
movl $0x15, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x22ef2(%rip), %rsi     # 0x36664
movl $0x1, %edx
callq 0x16f40
testb $0x1, %al
jne 0x13782
jmp 0x13784
jmp 0x137a3
leaq 0x22edb(%rip), %rdi     # 0x36666
leaq 0x22c9e(%rip), %rsi     # 0x36430
movl $0x60d, %edx            # imm = 0x60D
leaq 0x235d2(%rip), %rcx     # 0x36d70
callq 0x4100
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x137b0
jmp 0x137cf
leaq 0x2361d(%rip), %rdi     # 0x36dd4
leaq 0x22c72(%rip), %rsi     # 0x36430
movl $0x60e, %edx            # imm = 0x60E
leaq 0x235a6(%rip), %rcx     # 0x36d70
callq 0x4100
cmpl $0x2f, -0x1c(%rbp)
jne 0x137f8
movq -0x10(%rbp), %rdi
movl $0x19, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x13871
movl -0x1c(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x13806
jmp 0x1384e
movq -0x10(%rbp), %rdi
movl $0x1b, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl -0x1c(%rbp), %edi
callq 0x17170
movl %eax, %edi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
callq 0x5c00
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13871
movq -0x10(%rbp), %rdi
movl $0x15, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x22f0b(%rip), %rsi     # 0x367ad
movl $0x2, %edx
callq 0x16f40
testb $0x1, %al
jne 0x138b2
jmp 0x138b4
jmp 0x138d3
leaq 0x22ef5(%rip), %rdi     # 0x367b0
leaq 0x22b6e(%rip), %rsi     # 0x36430
movl $0x628, %edx            # imm = 0x628
leaq 0x2352d(%rip), %rcx     # 0x36dfb
callq 0x4100
movl -0x1c(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x138e1
jmp 0x1390f
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x16fc0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x13932
movq -0x10(%rbp), %rdi
movl $0x15, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x170f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x13b0f
jmp 0x13ae7
movl -0x2c(%rbp), %eax
subl $0xc, %eax
je 0x13b0f
jmp 0x13af1
movl -0x2c(%rbp), %eax
subl $0x20, %eax
je 0x13b0f
jmp 0x13afb
movl -0x2c(%rbp), %eax
subl $0x2f, %eax
je 0x13b0f
jmp 0x13b05
movl -0x2c(%rbp), %eax
subl $0x3e, %eax
jne 0x13b5d
jmp 0x13b0f
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
leaq 0x5f94a(%rip), %rdi     # 0x73470
callq 0x17660
movq -0x38(%rbp), %rdi
movb %al, %cl
movl $0x15, %esi
movl $0x1c, %eax
testb $0x1, %cl
cmovnel %eax, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13bb6
movl -0x1c(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x13b6b
jmp 0x13b99
movl -0x1c(%rbp), %edi
callq 0x17170
movl %eax, %edi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
callq 0x5c00
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13bb6
movq -0x10(%rbp), %rdi
movl $0x15, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x13c5d
jmp 0x13be4
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x13c4b
jmp 0x13bed
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
je 0x13c01
jmp 0x13bf7
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
je 0x13c26
jmp 0x13c7f
movq -0x10(%rbp), %rdi
movl $0x1d, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13c94
movq -0x10(%rbp), %rdi
movl $0x1f, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13c94
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16ed0
movl %eax, -0x4(%rbp)
jmp 0x13c94
movq -0x10(%rbp), %rdi
movl $0xe, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x13c94
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x13d55
jmp 0x13cc8
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x13d35
jmp 0x13cd1
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
je 0x13ce8
jmp 0x13cdb
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
je 0x13d10
jmp 0x13d77
movq -0x10(%rbp), %rdi
movl $0x1e, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13d9a
movq -0x10(%rbp), %rdi
movl $0x1f, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13d9a
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16ed0
movl %eax, -0x4(%rbp)
jmp 0x13d9a
movq -0x10(%rbp), %rdi
movl $0xe, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x13d9a
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x13e8d
jmp 0x13dd8
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x13e6d
jmp 0x13de5
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
je 0x13e06
jmp 0x13def
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
je 0x13e20
jmp 0x13df9
movl -0x2c(%rbp), %eax
subl $0x3e, %eax
je 0x13e48
jmp 0x13eaf
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13ed2
movq -0x10(%rbp), %rdi
movl $0x1f, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13ed2
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13ed2
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16ed0
movl %eax, -0x4(%rbp)
jmp 0x13ed2
movq -0x10(%rbp), %rdi
movl $0xe, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x13ed2
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x2f, -0x1c(%rbp)
jne 0x13f2f
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x11a10
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x5f40
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x13f4c
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x13faf
jmp 0x13f87
movl -0x2c(%rbp), %eax
subl $0xc, %eax
je 0x13faf
jmp 0x13f91
movl -0x2c(%rbp), %eax
subl $0x20, %eax
je 0x13faf
jmp 0x13f9b
movl -0x2c(%rbp), %eax
subl $0x2f, %eax
je 0x13faf
jmp 0x13fa5
movl -0x2c(%rbp), %eax
subl $0x3e, %eax
jne 0x13ffd
jmp 0x13faf
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
leaq 0x5f4aa(%rip), %rdi     # 0x73470
callq 0x17660
movq -0x38(%rbp), %rdi
movb %al, %cl
movl $0x1c, %esi
movl $0x15, %eax
testb $0x1, %cl
cmovnel %eax, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x14056
movl -0x1c(%rbp), %edi
callq 0x16fa0
testb $0x1, %al
jne 0x1400b
jmp 0x14039
movl -0x1c(%rbp), %edi
callq 0x17170
movl %eax, %edi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
callq 0x5c00
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16dd0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x14056
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3f, %eax
ja 0x14151
movq -0x30(%rbp), %rax
leaq 0x212b2(%rip), %rcx     # 0x35348
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2, -0x4(%rbp)
jmp 0x14186
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x14186
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x172b0
movl %eax, -0x4(%rbp)
jmp 0x14186
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x16c30
movl $0x2, -0x4(%rbp)
jmp 0x14186
movq -0x10(%rbp), %rdi
movl $0xf, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x17510
movl $0x2, -0x4(%rbp)
jmp 0x14186
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0x11a10
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %edi
callq 0x17170
movq -0x38(%rbp), %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x174b0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3f, %eax
ja 0x142c4
movq -0x30(%rbp), %rax
leaq 0x21282(%rip), %rcx     # 0x35448
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x176c0
movq -0x10(%rbp), %rdi
movl $0x23, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x142eb
movq -0x10(%rbp), %rdi
callq 0x176c0
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x142eb
movq -0x10(%rbp), %rdi
callq 0x176c0
movq -0x10(%rbp), %rdi
movl $0x24, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x142eb
movq -0x10(%rbp), %rdi
callq 0x176c0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x172b0
movl %eax, -0x4(%rbp)
jmp 0x142eb
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
movl $0x1, %edx
callq 0x174b0
movl $0x2, -0x4(%rbp)
jmp 0x142eb
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x17510
movq -0x10(%rbp), %rdi
movl $0xf, %esi
callq 0x16c60
movl $0x2, -0x4(%rbp)
jmp 0x142eb
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x16c60
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %edi
callq 0x17170
movq -0x38(%rbp), %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x174b0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x27, %eax
ja 0x146c2
movq -0x30(%rbp), %rax
leaq 0x211ba(%rip), %rcx     # 0x357d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movl $0x29, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x146d7
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xbc(%rax)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x146d7
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
xorl %edx, %edx
callq 0x174b0
movl $0x2, -0x4(%rbp)
jmp 0x146d7
movq -0x10(%rbp), %rdi
movl $0x11, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x17510
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x146d7
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
callq 0x174b0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: handle_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $-0x1, %eax
je 0x14799
jmp 0x14708
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x14772
jmp 0x14711
movl -0x2c(%rbp), %eax
subl $0x26, %eax
je 0x14743
jmp 0x1471b
movl -0x2c(%rbp), %eax
subl $0x27, %eax
jne 0x147cc
jmp 0x14729
movq -0x10(%rbp), %rdi
movl $0x29, %esi
callq 0x11a10
movl $0x2, -0x4(%rbp)
jmp 0x147e1
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xbc(%rax)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x11a10
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x147e1
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
xorl %edx, %edx
callq 0x174b0
movl $0x2, -0x4(%rbp)
jmp 0x147e1
movq -0x10(%rbp), %rdi
movl $0x12, %esi
callq 0x16c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x17510
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x147e1
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
callq 0x174b0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)