LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: ce_color_def_get
int ce_color_def_get(CeColorDefs_t* color_defs, int fg, int bg){
     // search for the already defined color
     for(int32_t i = 0; i < color_defs->count; ++i){
          if(color_defs->pairs[i].fg == fg && color_defs->pairs[i].bg == bg){
               return i;
          }
     }

     // increment the color pair we are going to define, but make sure it wraps around to 0 at the max
     color_defs->current++;
     color_defs->current %= 256;
     if(color_defs->current <= 0) color_defs->current = 1; // when we wrap around, start at 1, because curses doesn't like 0 index color pairs

#if defined(DISPLAY_TERMINAL)
     // create the pair definition
     init_pair(color_defs->current, fg, bg);
#endif

     // set our internal definition
     color_defs->pairs[color_defs->current].fg = fg;
     color_defs->pairs[color_defs->current].bg = bg;

     if(color_defs->current >= color_defs->count){
          color_defs->count = color_defs->current + 1;
     }

     return color_defs->current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2b72e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl 0x8(%rax,%rcx,8), %eax
cmpl -0x14(%rbp), %eax
jne 0x2b721
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl 0xc(%rax,%rcx,8), %eax
cmpl -0x18(%rbp), %eax
jne 0x2b721
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2b7da
jmp 0x2b723
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2b6e9
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x4(%rax), %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movl %edx, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jg 0x2b76a
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movw %ax, %dx
movl -0x14(%rbp), %eax
movw %ax, %cx
movl -0x18(%rbp), %eax
movswl %dx, %edi
movswl %cx, %esi
movswl %ax, %edx
callq 0xd4d0
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movl %edx, 0x8(%rax,%rcx,8)
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movl %edx, 0xc(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x2b7d0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %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/justy989[P]ce/ce_syntax.c
// Function: check_visual_start
void check_visual_start(CeRangeNode_t* range_node, int64_t line, CeDrawColorList_t* draw_color_list,
                        CeSyntaxDef_t* syntax_defs, bool* in_visual){
     if(range_node){
          CePoint_t start = {0, line};
          if(ce_point_after(start, range_node->range.start) && !ce_point_after(start, range_node->range.end)){
               int bg = ce_syntax_def_get_bg(syntax_defs, CE_SYNTAX_COLOR_VISUAL, ce_draw_color_list_last_bg_color(draw_color_list));
               int fg = ce_syntax_def_get_fg(syntax_defs, CE_SYNTAX_COLOR_VISUAL, ce_draw_color_list_last_fg_color(draw_color_list));
               ce_draw_color_list_insert(draw_color_list, fg, bg, start);
               *in_visual = true;
          }
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2b8cd
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0xf690
testb $0x1, %al
jne 0x2b848
jmp 0x2b8cb
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0xf690
testb $0x1, %al
jne 0x2b8cb
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2b630
movq -0x50(%rbp), %rdi
movl %eax, %edx
movl $0xc, %esi
callq 0x2b1c0
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2b600
movq -0x48(%rbp), %rdi
movl %eax, %edx
movl $0xc, %esi
callq 0x2b180
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x3c(%rbp), %edx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x2b200
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
jmp 0x2b8cd
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: check_visual_mode_end
void check_visual_mode_end(CeRangeNode_t* range_node, bool* in_visual, int64_t line, int64_t line_len,
                           CeDrawColorList_t* draw_color_list){
     if(!range_node) return;

     CePoint_t point = {line_len, line};
     if(in_visual){
          if(ce_point_after(point, range_node->range.end)){
               ce_draw_color_list_insert(draw_color_list, ce_draw_color_list_last_fg_color(draw_color_list),
                                         CE_COLOR_DEFAULT, point);
               range_node = range_node->next;
               *in_visual = false;
          }
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2bab5
jmp 0x2bb29
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2bb29
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
callq 0xf690
testb $0x1, %al
jne 0x2baeb
jmp 0x2bb27
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2b600
movq -0x40(%rbp), %rdi
movl %eax, %esi
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2b200
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x2bb29
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: match_c_multiline_comment
static int64_t match_c_multiline_comment(const char* str){
     if(strncmp("/*", str, 2) == 0){
          char* matching_comment = strstr(str, "*/");
          if(matching_comment) return (matching_comment - str);
          return utf8_strlen_until_trailing_whitespace(str);
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x189e1(%rip), %rdi     # 0x44e68
movl $0x2, %edx
callq 0xd0d0
cmpl $0x0, %eax
jne 0x2c4d1
movq -0x10(%rbp), %rdi
leaq 0x189c4(%rip), %rsi     # 0x44e65
callq 0xd6d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2c4c2
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x2c4d9
movq -0x10(%rbp), %rdi
callq 0x2fae0
movq %rax, -0x8(%rbp)
jmp 0x2c4d9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: match_trailing_whitespace
static int64_t match_trailing_whitespace(const char* str){
     const char* itr = str;
     while(*itr){
          if(!isspace((int)(*itr))) return 0;
          itr++;
     }

     return (itr - str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2c5d5
callq 0xd700
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x2c5c7
movq $0x0, -0x8(%rbp)
jmp 0x2c5e4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2c594
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: match_c_type
static int64_t match_c_type(const char* str, const char* beginning_of_line, bool cpp){
     if(!isalpha((int)(*str))) return false;

     const char* itr = str;
     while(*itr){
          if(!is_c_type_char(*itr)) break;
          itr++;
     }

     int64_t len = itr - str;
     if(len > 1){
          if(strncmp((itr - 2), "_t", 2) == 0) return len;
          if(strncmp((itr - 2), "_h", 2) == 0) return len;
          if(cpp && isupper((int)(*str))) return len;
     }

     static const char* keywords[] = {
          "bool",
          "char",
          "double",
          "float",
          "int",
          "long",
          "short",
          "signed",
          "unsigned",
          "void",
          "S8",
          "S16",
          "S32",
          "S64",
          "U8",
          "U16",
          "U32",
          "U64",
          "F32",
          "F64",
     };

     static const int64_t keyword_count = sizeof(keywords) / sizeof(keywords[0]);

     return match_words(str, beginning_of_line, keywords, keyword_count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
callq 0xd700
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x2c634
movq $0x0, -0x8(%rbp)
jmp 0x2c71e
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2c665
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
callq 0x2fb90
testb $0x1, %al
jne 0x2c657
jmp 0x2c665
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2c63c
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x30(%rbp)
jle 0x2c701
movq -0x28(%rbp), %rdi
addq $-0x2, %rdi
leaq 0x18999(%rip), %rsi     # 0x45027
movl $0x2, %edx
callq 0xd0d0
cmpl $0x0, %eax
jne 0x2c6a7
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c71e
movq -0x28(%rbp), %rdi
addq $-0x2, %rdi
leaq 0x187b5(%rip), %rsi     # 0x44e6b
movl $0x2, %edx
callq 0xd0d0
cmpl $0x0, %eax
jne 0x2c6cf
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c71e
testb $0x1, -0x19(%rbp)
je 0x2c6ff
callq 0xd700
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x2c6ff
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c71e
jmp 0x2c701
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x21d60(%rip), %rdx     # 0x4e470
movl $0x14, %ecx
callq 0x2fbd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: match_caps_var
static int64_t match_caps_var(const char* str, const char* beginning_of_line){
     const char* itr = str;
     if(!is_starting_caps_var_char(*itr)) return 0; // make sure the first char is not a number
     itr++;
     while(*itr){
          if(!is_caps_var_char(*itr)) break;
          itr++;
     }

     // check before and after the match for non c type chars
     if(str > beginning_of_line){
          if(is_c_type_char(*(str - 1))) return 0;
     }
     if(is_c_type_char(*itr)) return 0;

     int64_t len = itr - str;
     if(len > 1) return len;
     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x2fcc0
testb $0x1, %al
jne 0x2c7c5
movq $0x0, -0x8(%rbp)
jmp 0x2c867
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2c7fa
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x2fcf0
testb $0x1, %al
jne 0x2c7ec
jmp 0x2c7fa
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2c7d1
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x2c823
movq -0x10(%rbp), %rax
movsbl -0x1(%rax), %edi
callq 0x2fb90
testb $0x1, %al
jne 0x2c817
jmp 0x2c821
movq $0x0, -0x8(%rbp)
jmp 0x2c867
jmp 0x2c823
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x2fb90
testb $0x1, %al
jne 0x2c835
jmp 0x2c83f
movq $0x0, -0x8(%rbp)
jmp 0x2c867
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
jle 0x2c85f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c867
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: match_c_string
static int64_t match_c_string(const char* str){
     if(*str == '"'){
          const char* match = str;
          while(match){
               match = strchr(match + 1, '"');
               if(match && *(match - 1) != '\\'){
                    return (match - str) + 1;
               }
          }
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x2c93a
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2c938
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movl $0x22, %esi
callq 0xd220
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2c936
movq -0x18(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x5c, %eax
je 0x2c936
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2c942
jmp 0x2c8f0
jmp 0x2c93a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: match_c_character_literal
static int64_t match_c_character_literal(const char* str){
     // c character literals are one character long unless that character is escaped
     // in which case the literal will be 2 characters long before we see an end '
     if(*str == '\''){
          switch(str[1]){
          case 0: return 0;
          case '\'': return 2;
          case '\\':
               // our next character is escaped. skip it unless its the end of the string
               if(!str[2]) return 0;

               // our next character must be an end quote or we are not in a character literal
               if(str[3] == '\'') return 4;
               return 0;
          default:
               if(str[2] == '\'') return 3;
          }
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x2c9f1
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x2c98d
jmp 0x2c979
movl -0x14(%rbp), %eax
subl $0x27, %eax
je 0x2c997
jmp 0x2c983
movl -0x14(%rbp), %eax
subl $0x5c, %eax
je 0x2c9a1
jmp 0x2c9d6
movq $0x0, -0x8(%rbp)
jmp 0x2c9f9
movq $0x2, -0x8(%rbp)
jmp 0x2c9f9
movq -0x10(%rbp), %rax
cmpb $0x0, 0x2(%rax)
jne 0x2c9b5
movq $0x0, -0x8(%rbp)
jmp 0x2c9f9
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x27, %eax
jne 0x2c9cc
movq $0x4, -0x8(%rbp)
jmp 0x2c9f9
movq $0x0, -0x8(%rbp)
jmp 0x2c9f9
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x27, %eax
jne 0x2c9ed
movq $0x3, -0x8(%rbp)
jmp 0x2c9f9
jmp 0x2c9ef
jmp 0x2c9f1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: match_c_preproc
static int64_t match_c_preproc(const char* str){
     if(*str == '#'){
          const char* itr = str + 1;
          while(*itr){
               if(!isalpha((int)(*itr))) break;
               itr++;
          }

          return itr - str;
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x2cd2e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2cd1d
callq 0xd700
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x2cd0f
jmp 0x2cd1d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2cce4
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x2cd36
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: match_cpp_namespace
static int64_t match_cpp_namespace(const char* str, const char* beginning_of_line){
     bool saw_colon = false;
     bool saw_alpha = false;
     const char* itr = str;
     while(*itr){
          if(isalpha((int)(*itr)) || *itr == '_'){
               if(saw_colon) break;
               saw_alpha = true;
          }else if(*itr == ':'){
               if(!saw_alpha) break;

               if(!saw_colon){
                    saw_colon = true;
               }else{
                    return (itr - str) - 1;
               }
          }else{
               break;
          }
          itr++;
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2d793
callq 0xd700
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x2d739
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x2d747
testb $0x1, -0x19(%rbp)
je 0x2d741
jmp 0x2d793
movb $0x1, -0x1a(%rbp)
jmp 0x2d782
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x2d77e
testb $0x1, -0x1a(%rbp)
jne 0x2d75b
jmp 0x2d793
testb $0x1, -0x19(%rbp)
jne 0x2d767
movb $0x1, -0x19(%rbp)
jmp 0x2d77c
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2d79b
jmp 0x2d780
jmp 0x2d793
jmp 0x2d782
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2d700
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: match_python_docstring
static int64_t match_python_docstring(const char* str, PythonDocstring_t* python_docstring){
     if(strncmp(str, "\"\"\"", 3) == 0){
          *python_docstring = PYTHON_DOCSTRING_DOUBLE_QUOTE;
          char* match = strstr(str, "\"\"\"");
          if(match) return ce_utf8_strlen_between(str, match);
          return ce_utf8_strlen(str);
     }

     if(strncmp(str, "'''", 3) == 0){
          *python_docstring = PYTHON_DOCSTRING_SINGLE_QUOTE;
          char* match = strstr(str, "'''");
          if(match) return ce_utf8_strlen_between(str, match);
          return ce_utf8_strlen(str);
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1670f(%rip), %rsi     # 0x44e5a
movl $0x3, %edx
callq 0xd0d0
cmpl $0x0, %eax
jne 0x2e7a1
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x166eb(%rip), %rsi     # 0x44e5a
callq 0xd6d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2e792
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11a20
movq %rax, -0x8(%rbp)
jmp 0x2e80a
movq -0x10(%rbp), %rdi
callq 0xea70
movq %rax, -0x8(%rbp)
jmp 0x2e80a
movq -0x10(%rbp), %rdi
leaq 0x166b2(%rip), %rsi     # 0x44e5e
movl $0x3, %edx
callq 0xd0d0
cmpl $0x0, %eax
jne 0x2e802
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x1668e(%rip), %rsi     # 0x44e5e
callq 0xd6d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2e7f3
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x11a20
movq %rax, -0x8(%rbp)
jmp 0x2e80a
movq -0x10(%rbp), %rdi
callq 0xea70
movq %rax, -0x8(%rbp)
jmp 0x2e80a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: match_python_string
static int64_t match_python_string(const char* str){
     if(*str == '\'' || *str == '"'){
          const char* match = str;
          while(match){
               match = strchr(match + 1, *str);
               if(match && *(match - 1) != '\\'){
                    return ce_utf8_strlen_between(str, match);
               }
          }
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x2e8e4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x2e936
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2e934
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
callq 0xd220
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2e932
movq -0x18(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x5c, %eax
je 0x2e932
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11a20
movq %rax, -0x8(%rbp)
jmp 0x2e93e
jmp 0x2e8ec
jmp 0x2e936
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: utf8_strlen_until_trailing_whitespace
static int64_t utf8_strlen_until_trailing_whitespace(const char* str){
     const char* itr = str;
     while(*itr) itr++;
     itr--;
     while(itr > str && *itr && isblank((int)(*itr))) itr--;
     return ce_utf8_strlen_between(str, itr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2fb0b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2faf4
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x11(%rbp)
jbe 0x2fb59
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x2fb59
callq 0xd700
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x2fb62
jmp 0x2fb70
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2fb17
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11a20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_syntax.c
// Function: match_words
static int64_t match_words(const char* str, const char* beginning_of_line, const char** words, int64_t word_count){
     for(int64_t i = 0; i < word_count; ++i){
          int64_t word_len = strlen(words[i]);
          if(strncmp(words[i], str, word_len) == 0){
               // make sure word isn't in the middle of an identifier
               char post_char = str[word_len];
               if(is_c_type_char(post_char)) return 0;
               if(str > beginning_of_line){
                    char pre_char = *(str - 1);
                    if(is_c_type_char(pre_char)) return 0;
               }

               return word_len;
          }
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x2fca4
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xd200
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xd0d0
cmpl $0x0, %eax
jne 0x2fc91
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
movsbl -0x39(%rbp), %edi
callq 0x2fb90
testb $0x1, %al
jne 0x2fc4e
jmp 0x2fc58
movq $0x0, -0x8(%rbp)
jmp 0x2fcac
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x2fc87
movq -0x10(%rbp), %rax
movb -0x1(%rax), %al
movb %al, -0x3a(%rbp)
movsbl -0x3a(%rbp), %edi
callq 0x2fb90
testb $0x1, %al
jne 0x2fc7b
jmp 0x2fc85
movq $0x0, -0x8(%rbp)
jmp 0x2fcac
jmp 0x2fc87
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2fcac
jmp 0x2fc93
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2fbf0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_add_key_bind
void ce_vim_add_key_bind(CeVimKeyBind_t* key_binds, int64_t* key_bind_count, CeRune_t key, CeVimParseFunc_t* function){
     assert(*key_bind_count < CE_VIM_MAX_KEY_BINDS);
     key_binds[*key_bind_count].key = key;
     key_binds[*key_bind_count].function = function;
     (*key_bind_count)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x100, (%rax)          # imm = 0x100
jge 0x2fd66
jmp 0x2fd85
leaq 0x1566b(%rip), %rdi     # 0x453d8
leaq 0x1568b(%rip), %rsi     # 0x453ff
movl $0x1e, %edx
leaq 0x15688(%rip), %rcx     # 0x45408
callq 0xd270
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_motion_up
CeVimParseResult_t ce_vim_parse_motion_up(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->motion.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;
     action->motion.function = ce_vim_motion_up;

     if(action->verb.function){
          action->yank_type = CE_VIM_YANK_TYPE_LINE;
          return CE_VIM_PARSE_COMPLETE;
     }

     action->verb.function = ce_vim_verb_motion;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x30c53
movl $0x1, -0x4(%rbp)
jmp 0x30c97
movq -0x10(%rbp), %rax
leaq 0x6cb2(%rip), %rcx      # 0x37910
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x30c81
movq -0x10(%rbp), %rax
movl $0x2, 0x38(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x30c97
movq -0x10(%rbp), %rax
leaq 0x3e34(%rip), %rcx      # 0x34ac0
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_motion_down
CeVimParseResult_t ce_vim_parse_motion_down(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->motion.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;
     action->motion.function = ce_vim_motion_down;

     if(action->verb.function){
          action->yank_type = CE_VIM_YANK_TYPE_LINE;
          return CE_VIM_PARSE_COMPLETE;
     }

     action->verb.function = ce_vim_verb_motion;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x30cc3
movl $0x1, -0x4(%rbp)
jmp 0x30d07
movq -0x10(%rbp), %rax
leaq 0x6d12(%rip), %rcx      # 0x379e0
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x30cf1
movq -0x10(%rbp), %rax
movl $0x2, 0x38(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x30d07
movq -0x10(%rbp), %rax
leaq 0x3dc4(%rip), %rcx      # 0x34ac0
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_motion_inside
CeVimParseResult_t ce_vim_parse_motion_inside(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(!action->verb.function){
          if(vim->mode == CE_VIM_MODE_VISUAL || vim->mode == CE_VIM_MODE_VISUAL_LINE){
               action->verb.function = ce_vim_verb_motion;
          }else{
               return CE_VIM_PARSE_KEY_NOT_HANDLED;
          }
     }

     if(action->motion.function == NULL){
          action->motion.function = &ce_vim_motion_inside;
          return CE_VIM_PARSE_CONSUME_ADDITIONAL_KEY;
     }else if(action->motion.function == &ce_vim_motion_inside){
          action->motion.integer = key;
          return CE_VIM_PARSE_COMPLETE;
     }

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x30f48
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x30f2c
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x30f3d
movq -0x10(%rbp), %rax
leaq 0x3b89(%rip), %rcx      # 0x34ac0
movq %rcx, 0x28(%rax)
jmp 0x30f46
movl $0x1, -0x4(%rbp)
jmp 0x30f98
jmp 0x30f48
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x30f6b
movq -0x10(%rbp), %rax
leaq 0x7132(%rip), %rcx      # 0x38090
movq %rcx, 0x10(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x30f98
movq -0x10(%rbp), %rax
leaq 0x711a(%rip), %rcx      # 0x38090
cmpq %rcx, 0x10(%rax)
jne 0x30f8f
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x30f98
jmp 0x30f91
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_motion_around
CeVimParseResult_t ce_vim_parse_motion_around(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     // around requires a verb
     if(!action->verb.function){
          if(vim_mode_is_visual(vim->mode)){
               action->verb.function = ce_vim_verb_motion;
          }else{
               return CE_VIM_PARSE_KEY_NOT_HANDLED;
          }
     }

     if(action->motion.function == NULL){
          action->motion.function = &ce_vim_motion_around;
          return CE_VIM_PARSE_CONSUME_ADDITIONAL_KEY;
     }else if(action->motion.function == &ce_vim_motion_around){
          action->motion.integer = key;
          return CE_VIM_PARSE_COMPLETE;
     }

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x30feb
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x2fe10
testb $0x1, %al
jne 0x30fcf
jmp 0x30fe0
movq -0x10(%rbp), %rax
leaq 0x3ae6(%rip), %rcx      # 0x34ac0
movq %rcx, 0x28(%rax)
jmp 0x30fe9
movl $0x1, -0x4(%rbp)
jmp 0x3103b
jmp 0x30feb
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3100e
movq -0x10(%rbp), %rax
leaq 0x70df(%rip), %rcx      # 0x380e0
movq %rcx, 0x10(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x3103b
movq -0x10(%rbp), %rax
leaq 0x70c7(%rip), %rcx      # 0x380e0
cmpq %rcx, 0x10(%rax)
jne 0x31032
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x3103b
jmp 0x31034
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_motion_mark
CeVimParseResult_t ce_vim_parse_motion_mark(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(!action->motion.function){
          action->motion.function = ce_vim_motion_mark;
          return CE_VIM_PARSE_CONSUME_ADDITIONAL_KEY;
     }else if(action->motion.function == ce_vim_motion_mark){
          action->motion.integer = key;
          if(!action->verb.function) action->verb.function = ce_vim_verb_motion;
          return CE_VIM_PARSE_COMPLETE;
     }

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x31412
movq -0x10(%rbp), %rax
leaq 0x7d2b(%rip), %rcx      # 0x39130
movq %rcx, 0x10(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x31459
movq -0x10(%rbp), %rax
leaq 0x7d13(%rip), %rcx      # 0x39130
cmpq %rcx, 0x10(%rax)
jne 0x31450
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x31447
movq -0x10(%rbp), %rax
leaq 0x367d(%rip), %rcx      # 0x34ac0
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x31459
jmp 0x31452
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_motion_mark_soft_begin_line
CeVimParseResult_t ce_vim_parse_motion_mark_soft_begin_line(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(!action->motion.function){
          action->motion.function = ce_vim_motion_mark_soft_begin_line;
          return CE_VIM_PARSE_CONSUME_ADDITIONAL_KEY;
     }else if(action->motion.function == ce_vim_motion_mark_soft_begin_line){
          action->motion.integer = key;
          if(!action->verb.function) action->verb.function = ce_vim_verb_motion;
          return CE_VIM_PARSE_COMPLETE;
     }

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x31492
movq -0x10(%rbp), %rax
leaq 0x7d8b(%rip), %rcx      # 0x39210
movq %rcx, 0x10(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x314d9
movq -0x10(%rbp), %rax
leaq 0x7d73(%rip), %rcx      # 0x39210
cmpq %rcx, 0x10(%rax)
jne 0x314d0
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x314c7
movq -0x10(%rbp), %rax
leaq 0x35fd(%rip), %rcx      # 0x34ac0
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x314d9
jmp 0x314d2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_insert_mode
CeVimParseResult_t ce_vim_parse_verb_insert_mode(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->motion.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;
     if(action->verb.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;

     action->verb.function = &ce_vim_verb_insert_mode;
     action->repeatable = true;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x31503
movl $0x1, -0x4(%rbp)
jmp 0x31535
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x31517
movl $0x1, -0x4(%rbp)
jmp 0x31535
movq -0x10(%rbp), %rax
leaq 0x243e(%rip), %rcx      # 0x33960
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_replace_mode
CeVimParseResult_t ce_vim_parse_verb_replace_mode(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->motion.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;
     if(action->verb.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;

     action->verb.function = &ce_vim_verb_replace_mode;
     action->repeatable = true;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x31563
movl $0x1, -0x4(%rbp)
jmp 0x31595
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x31577
movl $0x1, -0x4(%rbp)
jmp 0x31595
movq -0x10(%rbp), %rax
leaq 0x607e(%rip), %rcx      # 0x37600
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_visual_mode
CeVimParseResult_t ce_vim_parse_verb_visual_mode(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->motion.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;
     if(action->verb.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;

     action->verb.function = &ce_vim_verb_visual_mode;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x315c3
movl $0x1, -0x4(%rbp)
jmp 0x315ed
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x315d7
movl $0x1, -0x4(%rbp)
jmp 0x315ed
movq -0x10(%rbp), %rax
leaq 0x607e(%rip), %rcx      # 0x37660
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_visual_line_mode
CeVimParseResult_t ce_vim_parse_verb_visual_line_mode(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->motion.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;
     if(action->verb.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;

     action->verb.function = &ce_vim_verb_visual_line_mode;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x31623
movl $0x1, -0x4(%rbp)
jmp 0x3164d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x31637
movl $0x1, -0x4(%rbp)
jmp 0x3164d
movq -0x10(%rbp), %rax
leaq 0x606e(%rip), %rcx      # 0x376b0
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_normal_mode
CeVimParseResult_t ce_vim_parse_verb_normal_mode(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->motion.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;
     if(action->verb.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;

     action->verb.function = &ce_vim_verb_normal_mode;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x31683
movl $0x1, -0x4(%rbp)
jmp 0x316ad
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x31697
movl $0x1, -0x4(%rbp)
jmp 0x316ad
movq -0x10(%rbp), %rax
leaq 0x605e(%rip), %rcx      # 0x37700
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_append
CeVimParseResult_t ce_vim_parse_verb_append(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->verb.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;

     action->verb.function = &ce_vim_verb_append;
     action->repeatable = true;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x316e3
movl $0x1, -0x4(%rbp)
jmp 0x31701
movq -0x10(%rbp), %rax
leaq 0x22b2(%rip), %rcx      # 0x339a0
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_append_at_end_of_line
CeVimParseResult_t ce_vim_parse_verb_append_at_end_of_line(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->verb.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;

     action->verb.function = &ce_vim_verb_append_at_end_of_line;
     action->repeatable = true;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x31733
movl $0x1, -0x4(%rbp)
jmp 0x31751
movq -0x10(%rbp), %rax
leaq 0x22e2(%rip), %rcx      # 0x33a20
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_insert_at_soft_begin_line
CeVimParseResult_t ce_vim_parse_verb_insert_at_soft_begin_line(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->verb.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;

     action->verb.function = &ce_vim_verb_insert_at_soft_begin_line;
     action->repeatable = true;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x31783
movl $0x1, -0x4(%rbp)
jmp 0x317a1
movq -0x10(%rbp), %rax
leaq 0x5ff2(%rip), %rcx      # 0x37780
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_delete
CeVimParseResult_t ce_vim_parse_verb_delete(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->repeatable = true;
     if(action->verb.function == ce_vim_verb_delete){
          action->motion.function = &ce_vim_motion_entire_line;
          action->yank_type = CE_VIM_YANK_TYPE_LINE;
          return CE_VIM_PARSE_COMPLETE;
     }

     action->verb.function = &ce_vim_verb_delete;
     action->yank_type = CE_VIM_YANK_TYPE_STRING;
     action->clamp_x = CE_CLAMP_X_INSIDE;
     return CE_VIM_PARSE_IN_PROGRESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x10(%rbp), %rax
leaq 0x35ce(%rip), %rcx      # 0x34da0
cmpq %rcx, 0x28(%rax)
jne 0x317fb
movq -0x10(%rbp), %rax
leaq 0x829d(%rip), %rcx      # 0x39a80
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x38(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x31827
movq -0x10(%rbp), %rax
leaq 0x359a(%rip), %rcx      # 0x34da0
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x40(%rax)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_delete_to_end_of_line
CeVimParseResult_t ce_vim_parse_verb_delete_to_end_of_line(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->repeatable = true;
     action->motion.function = &ce_vim_motion_end_line;
     action->verb.function = &ce_vim_verb_delete;
     action->yank_type = CE_VIM_YANK_TYPE_STRING;
     action->clamp_x = CE_CLAMP_X_INSIDE;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x8(%rbp), %rax
leaq 0x667e(%rip), %rcx      # 0x37ed0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0x353f(%rip), %rcx      # 0x34da0
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x40(%rax)
movl $0x5, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_change
CeVimParseResult_t ce_vim_parse_verb_change(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->repeatable = true;
     if(action->verb.function == ce_vim_verb_change){
          action->verb.function = &ce_vim_verb_substitute_soft_begin_line;
          return CE_VIM_PARSE_COMPLETE;
     }

     action->verb.function = &ce_vim_verb_change;
     action->yank_type = CE_VIM_YANK_TYPE_STRING;
     action->clamp_x = CE_CLAMP_X_ON;
     return CE_VIM_PARSE_IN_PROGRESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x10(%rbp), %rax
leaq 0x38be(%rip), %rcx      # 0x35170
cmpq %rcx, 0x28(%rax)
jne 0x318d0
movq -0x10(%rbp), %rax
leaq 0x826d(%rip), %rcx      # 0x39b30
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x318fc
movq -0x10(%rbp), %rax
leaq 0x3895(%rip), %rcx      # 0x35170
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x40(%rax)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_change_to_end_of_line
CeVimParseResult_t ce_vim_parse_verb_change_to_end_of_line(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->repeatable = true;
     action->motion.function = &ce_vim_motion_end_line;
     action->verb.function = &ce_vim_verb_change;
     action->yank_type = CE_VIM_YANK_TYPE_STRING;
     action->clamp_x = CE_CLAMP_X_ON;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x8(%rbp), %rax
leaq 0x659e(%rip), %rcx      # 0x37ed0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0x382f(%rip), %rcx      # 0x35170
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x40(%rax)
movl $0x5, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_set_character
CeVimParseResult_t ce_vim_parse_verb_set_character(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->repeatable = true;
     if(action->verb.function == NULL){
          action->verb.function = &ce_vim_verb_set_character;
          return CE_VIM_PARSE_CONSUME_ADDITIONAL_KEY;
     }else{
          if(!_is_print(key)) return CE_VIM_PARSE_INVALID;
          action->verb.integer = key;
          return CE_VIM_PARSE_COMPLETE;
     }

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x319ae
movq -0x10(%rbp), %rax
leaq 0x82cf(%rip), %rcx      # 0x39c70
movq %rcx, 0x28(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x319d7
movl -0x1c(%rbp), %eax
movsbl %al, %edi
callq 0x334f0
testb $0x1, %al
jne 0x319c6
movl $0x0, -0x4(%rbp)
jmp 0x319d7
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_delete_character
CeVimParseResult_t ce_vim_parse_verb_delete_character(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->repeatable = true;
     action->verb.function = &ce_vim_verb_delete_character;
     action->clamp_x = CE_CLAMP_X_INSIDE;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x8(%rbp), %rax
leaq 0x841e(%rip), %rcx      # 0x39e20
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x40(%rax)
movl $0x5, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_substitute_character
CeVimParseResult_t ce_vim_parse_verb_substitute_character(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->repeatable = true;
     action->verb.function = &ce_vim_verb_substitute_character;
     action->clamp_x = CE_CLAMP_X_ON;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x8(%rbp), %rax
leaq 0x852e(%rip), %rcx      # 0x39f70
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x40(%rax)
movl $0x5, %eax
popq %rbp
retq
nopl (%rax,%rax)