LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq -0x2(%rdi), %rax
cmpb $0x0, 0x2(%rax)
leaq 0x1(%rax), %rax
jne 0x20487
jmp 0x204af
movsbq (%r14), %r15
testq %r15, %r15
je 0x204b7
callq 0xd720
movq (%rax), %rcx
leaq -0x1(%r14), %rax
testb $0x1, (%rcx,%r15,2)
je 0x204b7
movq %rax, %r14
cmpq %rbx, %rax
ja 0x20493
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xfc01
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, (%rsp)
movq %rdi, %r14
xorl %r15d, %r15d
testq %rcx, %rcx
cmovleq %r15, %r12
cmpq %r15, %r12
je 0x20542
movq (%r13,%r15,8), %rbp
movq %rbp, %rdi
callq 0xd210
movq %rax, %rbx
movq %rbp, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd0d0
incq %r15
testl %eax, %eax
jne 0x2050a
movsbl (%r14,%rbx), %edi
callq 0x204c7
testb %al, %al
je 0x20556
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq (%rsp), %r14
jbe 0x20544
movsbl -0x1(%r14), %edi
callq 0x204c7
testb %al, %al
jne 0x20542
jmp 0x20544
// File: /workspace/github_c_makefile_star2_O2/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:
movq (%rsi), %rax
cmpq $0x100, %rax            # imm = 0x100
jge 0x2058e
movq %rax, %r8
shlq $0x4, %r8
movl %edx, (%rdi,%r8)
movq %rcx, 0x8(%rdi,%r8)
incq %rax
movq %rax, (%rsi)
retq
pushq %rax
leaq 0xcca2(%rip), %rdi      # 0x2d238
leaq 0xccc2(%rip), %rsi      # 0x2d25f
leaq 0xccc4(%rip), %rcx      # 0x2d268
pushq $0x1e
popq %rdx
callq 0xd280
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_motion_little_word
static CeVimParseResult_t parse_motion_direction(CeVimAction_t* action, CeVimMotionFunc_t* func){
     if(action->motion.function) return CE_VIM_PARSE_KEY_NOT_HANDLED;
     action->motion.function = func;

     if(action->verb.function) return CE_VIM_PARSE_COMPLETE;
     action->verb.function = ce_vim_verb_motion;

     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
cmpq $0x0, 0x10(%rdi)
je 0x20d3c
pushq $0x1
popq %rax
retq
leaq 0x3be4(%rip), %rax      # 0x24927
movq %rax, 0x10(%rdi)
pushq $0x5
popq %rax
cmpq $0x0, 0x28(%rdi)
je 0x20d52
retq
leaq 0x21b0(%rip), %rcx      # 0x22f09
movq %rcx, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x0, 0x10(%rdi)
je 0x20ea4
pushq $0x1
jmp 0x20ecc
leaq 0x39b1(%rip), %rax      # 0x2485c
movq %rax, 0x10(%rdi)
cmpq $0x0, 0x28(%rdi)
je 0x20ebf
movl $0x2, 0x38(%rdi)
jmp 0x20eca
leaq 0x2043(%rip), %rax      # 0x22f09
movq %rax, 0x28(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x0, 0x10(%rdi)
je 0x20ed9
pushq $0x1
jmp 0x20f01
leaq 0x39df(%rip), %rax      # 0x248bf
movq %rax, 0x10(%rdi)
cmpq $0x0, 0x28(%rdi)
je 0x20ef4
movl $0x2, 0x38(%rdi)
jmp 0x20eff
leaq 0x200e(%rip), %rax      # 0x22f09
movq %rax, 0x28(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x0, 0x28(%rdi)
jne 0x21054
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x21082
leaq 0x1eb9(%rip), %rax      # 0x22f09
movq %rax, 0x28(%rdi)
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x2106c
xorl %eax, %eax
leaq 0x3ac9(%rip), %rsi      # 0x24b2f
cmpq %rsi, %rcx
je 0x2107b
retq
leaq 0x3abc(%rip), %rax      # 0x24b2f
movq %rax, 0x10(%rdi)
pushq $0x2
jmp 0x21084
movl %edx, 0x18(%rdi)
pushq $0x5
jmp 0x21084
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x0, 0x28(%rdi)
jne 0x210a2
movl (%rsi), %eax
addl $-0x2, %eax
cmpl $0x2, %eax
ja 0x210d0
leaq 0x1e6b(%rip), %rax      # 0x22f09
movq %rax, 0x28(%rdi)
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x210ba
xorl %eax, %eax
leaq 0x3a91(%rip), %rsi      # 0x24b45
cmpq %rsi, %rcx
je 0x210c9
retq
leaq 0x3a84(%rip), %rax      # 0x24b45
movq %rax, 0x10(%rdi)
pushq $0x2
jmp 0x210d2
movl %edx, 0x18(%rdi)
pushq $0x5
jmp 0x210d2
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x213d3
xorl %eax, %eax
leaq 0x3f2c(%rip), %rsi      # 0x252f9
cmpq %rsi, %rcx
je 0x213e2
retq
leaq 0x3f1f(%rip), %rax      # 0x252f9
movq %rax, 0x10(%rdi)
pushq $0x2
popq %rax
retq
movl %edx, 0x18(%rdi)
pushq $0x5
popq %rax
cmpq $0x0, 0x28(%rdi)
jne 0x213d2
leaq 0x1b13(%rip), %rcx      # 0x22f09
movq %rcx, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x21413
xorl %eax, %eax
leaq 0x3f4c(%rip), %rsi      # 0x25359
cmpq %rsi, %rcx
je 0x21422
retq
leaq 0x3f3f(%rip), %rax      # 0x25359
movq %rax, 0x10(%rdi)
pushq $0x2
popq %rax
retq
movl %edx, 0x18(%rdi)
pushq $0x5
popq %rax
cmpq $0x0, 0x28(%rdi)
jne 0x21412
leaq 0x1ad3(%rip), %rcx      # 0x22f09
movq %rcx, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x1
popq %rax
cmpq $0x0, 0x10(%rdi)
je 0x21446
retq
cmpq $0x0, 0x28(%rdi)
jne 0x21445
leaq 0x10af(%rip), %rax      # 0x22503
movq %rax, 0x28(%rdi)
movb $0x1, 0x3d(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x1
popq %rax
cmpq $0x0, 0x10(%rdi)
je 0x2146b
retq
cmpq $0x0, 0x28(%rdi)
jne 0x2146a
leaq 0x332c(%rip), %rax      # 0x247a5
movq %rax, 0x28(%rdi)
movb $0x1, 0x3d(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x1
popq %rax
cmpq $0x0, 0x10(%rdi)
je 0x21490
retq
cmpq $0x0, 0x28(%rdi)
jne 0x2148f
leaq 0x332a(%rip), %rax      # 0x247c8
movq %rax, 0x28(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x1
popq %rax
cmpq $0x0, 0x10(%rdi)
je 0x214b1
retq
cmpq $0x0, 0x28(%rdi)
jne 0x214b0
leaq 0x3319(%rip), %rax      # 0x247d8
movq %rax, 0x28(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x1
popq %rax
cmpq $0x0, 0x10(%rdi)
je 0x214d2
retq
cmpq $0x0, 0x28(%rdi)
jne 0x214d1
leaq 0x3308(%rip), %rax      # 0x247e8
movq %rax, 0x28(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb $0x1, 0x3d(%rdi)
leaq 0x1bc0(%rip), %rax      # 0x2310d
cmpq %rax, 0x28(%rdi)
je 0x21565
movq %rax, 0x28(%rdi)
movl $0x2, 0x40(%rdi)
pushq $0x4
popq %rax
pushq $0x1
jmp 0x21575
leaq 0x4187(%rip), %rax      # 0x256f3
movq %rax, 0x10(%rdi)
pushq $0x5
popq %rax
pushq $0x2
popq %rcx
movl %ecx, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb $0x1, 0x3d(%rdi)
leaq 0x3523(%rip), %rax      # 0x24aa8
movq %rax, 0x10(%rdi)
leaq 0x1b7d(%rip), %rax      # 0x2310d
movq %rax, 0x28(%rdi)
movl $0x1, 0x38(%rdi)
movl $0x2, 0x40(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb $0x1, 0x3d(%rdi)
leaq 0x1d74(%rip), %rcx      # 0x23325
cmpq %rcx, 0x28(%rdi)
je 0x215c5
pushq $0x1
popq %rax
movl %eax, 0x38(%rdi)
movl %eax, 0x40(%rdi)
pushq $0x4
popq %rax
jmp 0x215cf
pushq $0x5
popq %rax
leaq 0x4153(%rip), %rcx      # 0x25722
movq %rcx, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb $0x1, 0x3d(%rdi)
leaq 0x34c9(%rip), %rax      # 0x24aa8
movq %rax, 0x10(%rdi)
leaq 0x1d3b(%rip), %rax      # 0x23325
movq %rax, 0x28(%rdi)
pushq $0x1
popq %rax
movl %eax, 0x38(%rdi)
movl %eax, 0x40(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb $0x1, 0x3d(%rdi)
cmpq $0x0, 0x28(%rdi)
je 0x21617
leal -0x20(%rdx), %ecx
xorl %eax, %eax
cmpb $0x5e, %cl
ja 0x21616
movl %edx, 0x30(%rdi)
pushq $0x5
popq %rax
retq
leaq 0x41ae(%rip), %rax      # 0x257cc
movq %rax, 0x28(%rdi)
pushq $0x2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb $0x1, 0x3d(%rdi)
leaq 0x4291(%rip), %rax      # 0x258c2
movq %rax, 0x28(%rdi)
movl $0x2, 0x40(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb $0x1, 0x3d(%rdi)
leaq 0x4348(%rip), %rax      # 0x25993
movq %rax, 0x28(%rdi)
movl $0x1, 0x40(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_yank
CeVimParseResult_t ce_vim_parse_verb_yank(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->verb.function == &ce_vim_verb_yank){
          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_yank;
     action->yank_type = CE_VIM_YANK_TYPE_STRING;
     if(action->verb.integer == 0) action->verb.integer = '"';

     return CE_VIM_PARSE_IN_PROGRESS;
}

// Assembly:
leaq 0x19e1(%rip), %rax      # 0x23055
cmpq %rax, 0x28(%rdi)
je 0x2168f
movq %rax, 0x28(%rdi)
movl $0x1, 0x38(%rdi)
pushq $0x4
popq %rax
cmpl $0x0, 0x30(%rdi)
je 0x216a5
retq
leaq 0x405d(%rip), %rax      # 0x256f3
movq %rax, 0x10(%rdi)
movl $0x2, 0x38(%rdi)
pushq $0x5
popq %rax
retq
movl $0x22, 0x30(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_yank_line
CeVimParseResult_t ce_vim_parse_verb_yank_line(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->verb.function = &ce_vim_verb_yank;
     action->motion.function = &ce_vim_motion_entire_line;
     if(action->verb.integer == 0) action->verb.integer = '"';
     action->yank_type = CE_VIM_YANK_TYPE_LINE;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
leaq 0x19a1(%rip), %rax      # 0x23055
movq %rax, 0x28(%rdi)
leaq 0x4034(%rip), %rax      # 0x256f3
movq %rax, 0x10(%rdi)
cmpl $0x0, 0x30(%rdi)
jne 0x216d0
movl $0x22, 0x30(%rdi)
movl $0x2, 0x38(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_paste_before
CeVimParseResult_t ce_vim_parse_verb_paste_before(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->repeatable = true;
     action->verb.function = &ce_vim_verb_paste_before;
     if(action->verb.integer == 0) action->verb.integer = '"';
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
movb $0x1, 0x3d(%rdi)
leaq 0x42cf(%rip), %rax      # 0x259d2
movq %rax, 0x28(%rdi)
cmpl $0x0, 0x30(%rdi)
jne 0x21714
movl $0x22, 0x30(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_paste_after
CeVimParseResult_t ce_vim_parse_verb_paste_after(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->repeatable = true;
     action->verb.function = &ce_vim_verb_paste_after;
     if(action->verb.integer == 0) action->verb.integer = '"';
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
movb $0x1, 0x3d(%rdi)
leaq 0x42ed(%rip), %rax      # 0x25a10
movq %rax, 0x28(%rdi)
cmpl $0x0, 0x30(%rdi)
jne 0x21734
movl $0x22, 0x30(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_z_command
CeVimParseResult_t ce_vim_parse_verb_z_command(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->verb.function == NULL){
          action->verb.function = ce_vim_verb_z_command;
          return CE_VIM_PARSE_CONSUME_ADDITIONAL_KEY;
     }else if(action->verb.function == ce_vim_verb_z_command){
          action->verb.integer = key;
          return CE_VIM_PARSE_COMPLETE;
     }

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x217df
xorl %eax, %eax
leaq 0x46d4(%rip), %rsi      # 0x25ead
cmpq %rsi, %rcx
je 0x217ee
retq
leaq 0x46c7(%rip), %rax      # 0x25ead
movq %rax, 0x28(%rdi)
pushq $0x2
jmp 0x217f3
movl %edx, 0x30(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_g_command
CeVimParseResult_t ce_vim_parse_verb_g_command(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->verb.function == NULL){
          action->verb.function = ce_vim_verb_g_command;
          if(action->multiplier > 1) return CE_VIM_PARSE_COMPLETE;
          return CE_VIM_PARSE_CONSUME_ADDITIONAL_KEY;
     }else if(action->verb.function == ce_vim_verb_g_command){
          action->verb.integer = key;
          return CE_VIM_PARSE_COMPLETE;
     }

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x2180d
xorl %eax, %eax
leaq 0x46ef(%rip), %rsi      # 0x25ef6
cmpq %rsi, %rcx
je 0x21828
retq
leaq 0x46e2(%rip), %rax      # 0x25ef6
movq %rax, 0x28(%rdi)
xorl %eax, %eax
cmpq $0x2, (%rdi)
setge %al
leal (%rax,%rax,2), %eax
addl $0x2, %eax
retq
movl %edx, 0x30(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_indent
CeVimParseResult_t ce_vim_parse_verb_indent(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->verb.function == NULL){
          action->repeatable = true;
          action->verb.function = ce_vim_verb_indent;
          return CE_VIM_PARSE_IN_PROGRESS;
     }else if(action->verb.function == ce_vim_verb_indent){
          action->repeatable = true;
          return CE_VIM_PARSE_COMPLETE;
     }

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x21847
xorl %eax, %eax
leaq 0x4754(%rip), %rdx      # 0x25f95
cmpq %rdx, %rcx
je 0x2185a
retq
movb $0x1, 0x3d(%rdi)
leaq 0x4743(%rip), %rax      # 0x25f95
movq %rax, 0x28(%rdi)
pushq $0x4
jmp 0x21860
movb $0x1, 0x3d(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_unindent
CeVimParseResult_t ce_vim_parse_verb_unindent(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->repeatable = true;
     if(action->verb.function == NULL){
          action->verb.function = ce_vim_verb_unindent;
          return CE_VIM_PARSE_IN_PROGRESS;
     }else if(action->verb.function == ce_vim_verb_unindent){
          return CE_VIM_PARSE_COMPLETE;
     }

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
movb $0x1, 0x3d(%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x21882
leaq 0x48b4(%rip), %rcx      # 0x2612a
xorl %edx, %edx
cmpq %rcx, %rax
sete %dl
leal (%rdx,%rdx,4), %eax
retq
leaq 0x48a1(%rip), %rax      # 0x2612a
movq %rax, 0x28(%rdi)
pushq $0x4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_flip_case
CeVimParseResult_t ce_vim_parse_verb_flip_case(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     action->repeatable = true;
     action->motion.function = ce_vim_motion_right;
     action->verb.function = ce_vim_verb_flip_case;
     return CE_VIM_PARSE_COMPLETE;
}

// Assembly:
movb $0x1, 0x3d(%rdi)
leaq 0x2f98(%rip), %rax      # 0x24847
movq %rax, 0x10(%rdi)
leaq 0x49da(%rip), %rax      # 0x26294
movq %rax, 0x28(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_set_mark
CeVimParseResult_t ce_vim_parse_verb_set_mark(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->verb.function == NULL){
          action->verb.function = ce_vim_verb_set_mark;
          return CE_VIM_PARSE_CONSUME_ADDITIONAL_KEY;
     }else if(action->verb.function == ce_vim_verb_set_mark){
          action->verb.integer = key;
          return CE_VIM_PARSE_COMPLETE;
     }

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x218da
xorl %eax, %eax
leaq 0x4b04(%rip), %rsi      # 0x263d8
cmpq %rsi, %rcx
je 0x218e9
retq
leaq 0x4af7(%rip), %rax      # 0x263d8
movq %rax, 0x28(%rdi)
pushq $0x2
jmp 0x218ee
movl %edx, 0x30(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_free
bool ce_vim_free(CeVim_t* vim){
     for(int64_t i = 0; i < CE_ASCII_PRINTABLE_CHARACTERS; i++){
          ce_vim_yank_free(vim->yanks + i);
     }
     ce_rune_node_free(&vim->insert_rune_head);
     ce_rune_node_free(&vim->last_insert_rune_head);
     return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1050(%rdi), %r14
xorl %r15d, %r15d
cmpq $0x8e8, %r15            # imm = 0x8E8
je 0x2194c
leaq (%r14,%r15), %rdi
callq 0x2196f
addq $0x18, %r15
jmp 0x21934
leaq 0x19c8(%rbx), %rdi
callq 0xfe39
addq $0x19d0, %rbx           # imm = 0x19D0
movq %rbx, %rdi
callq 0xfe39
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_yank_free
void ce_vim_yank_free(CeVimYank_t* yank){
     switch(yank->type){
     default:
          break;
     case CE_VIM_YANK_TYPE_STRING:
     case CE_VIM_YANK_TYPE_LINE:
          free(yank->text);
          yank->text = NULL;
          break;
     case CE_VIM_YANK_TYPE_BLOCK:
          for(int64_t i = 0; i < yank->block_line_count; i++){
               free(yank->block[i]);
          }
          free(yank->block);
          yank->block = NULL;
          yank->block_line_count = 0;
          break;
     }

     yank->type = CE_VIM_YANK_TYPE_STRING;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x21991
movq 0x8(%rbx), %rdi
callq 0xd090
andq $0x0, 0x8(%rbx)
jmp 0x219c1
cmpl $0x3, %eax
jne 0x219c1
leaq 0x8(%rbx), %r14
xorl %r15d, %r15d
movq 0x8(%rbx), %rdi
cmpq 0x10(%rbx), %r15
jge 0x219b5
movq (%rdi,%r15,8), %rdi
callq 0xd090
incq %r15
jmp 0x2199d
callq 0xd090
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movl $0x1, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_bind_key
bool ce_vim_bind_key(CeVim_t* vim, CeRune_t key, CeVimParseFunc_t function){
     for(int64_t i = 0; i < vim->key_bind_count; ++i){
          if(vim->key_binds[i].key == key){
               vim->key_binds[i].function = function;
               return true;
          }
     }

     if(vim->key_bind_count >= CE_VIM_MAX_KEY_BINDS) return false;

     vim->key_binds[vim->key_bind_count].key = key;
     vim->key_binds[vim->key_bind_count].function = function;
     vim->key_bind_count++;
     return true;
}

// Assembly:
movq 0x1008(%rdi), %rax
leaq 0x8(%rdi), %rcx
xorl %r8d, %r8d
testq %rax, %rax
cmovgq %rax, %r8
incq %r8
movq %rcx, %r9
decq %r8
je 0x219ff
leaq 0x10(%r9), %r10
cmpl %esi, (%r9)
movq %r10, %r9
jne 0x219e8
movq %rdx, -0x8(%r10)
jmp 0x21a24
cmpq $0xff, %rax
jle 0x21a0a
xorl %eax, %eax
retq
movq %rax, %r8
shlq $0x4, %r8
movl %esi, (%rcx,%r8)
movq %rdx, 0x8(%rcx,%r8)
incq %rax
movq %rax, 0x1008(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_append_key
bool ce_vim_append_key(CeVim_t* vim, CeRune_t key){
     int64_t command_len = istrlen(vim->current_command);
     if(command_len < (CE_VIM_MAX_COMMAND_LEN - 1)){
          vim->current_command[command_len] = key;
          vim->current_command[command_len + 1] = 0;
          return true;
     }

     return false;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
addq $0x1010, %rbx           # imm = 0x1010
movq %rbx, %rdi
callq 0x11a54
cmpq $0xe, %rax
jg 0x21a4c
movl %ebp, (%rbx,%rax,4)
andl $0x0, 0x4(%rbx,%rax,4)
cmpq $0xf, %rax
setl %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: string_is_whitespace
static bool string_is_whitespace(const char* string){
     if(*string == 0) return false;

     bool all_whitespace = true;
     while(*string){
          if(!isspace((int)(*string))){
               all_whitespace = false;
               break;
          }
          string++;
     }

     return all_whitespace;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movb (%rdi), %r14b
testb %r14b, %r14b
je 0x2248f
movq %rdi, %rbx
incq %rbx
testb %r14b, %r14b
sete %bpl
je 0x22491
callq 0xd720
movq (%rax), %rax
movsbq %r14b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x22491
movb (%rbx), %r14b
jmp 0x2246b
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_join_next_line
bool ce_vim_join_next_line(CeBuffer_t* buffer, int64_t line, CePoint_t cursor, bool chain_undo){
     CePoint_t point = {ce_utf8_strlen(buffer->lines[line]), line};
     CePoint_t after_point = {0, point.y + 1};
     ce_buffer_remove_string_change(buffer, point, 1, &cursor, after_point, chain_undo);
     return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %rdx, (%r12)
movq %rcx, 0x8(%r12)
movq (%rdi), %rax
movq (%rax,%rsi,8), %rdi
callq 0xe38c
andq $0x0, 0x18(%rsp)
leaq 0x1(%r14), %rcx
movq %rcx, 0x20(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r12, %r8
movl %ebx, %r9d
callq 0xf77c
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_append
bool ce_vim_verb_append(CeVim_t* vim, const CeVimAction_t* action, CeRange_t motion_range, CeView_t* view,
                        CePoint_t* cursor, CeVimVisualData_t* visual, CeVimBufferData_t* buffer_data,
                        const CeConfigOptions_t* config_options){
     int64_t last_valid_index = ce_utf8_strlen(view->buffer->lines[cursor->y]);
     cursor->x++;
     if(cursor->x > last_valid_index) cursor->x = last_valid_index;
     ce_vim_insert_mode(vim);
     return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x40(%rdx), %rax
movq (%rax), %rax
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xe38c
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
cmpq %rax, %rcx
cmovgeq %rax, %rdx
movq %rdx, (%rbx)
movq %r14, %rdi
callq 0x205ac
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_motion
bool ce_vim_verb_motion(CeVim_t* vim, const CeVimAction_t* action, CeRange_t motion_range, CeView_t* view,
                        CePoint_t* cursor, CeVimVisualData_t* visual, CeVimBufferData_t* buffer_data,
                        const CeConfigOptions_t* config_options){
     if(action->motion.function == ce_vim_motion_up || action->motion.function == ce_vim_motion_down){
          motion_range.end.x = buffer_data->motion_column;
     }
     *cursor = ce_buffer_clamp_point(view->buffer, motion_range.end, CE_CLAMP_X_INSIDE);
     if(ce_points_equal(motion_range.end, *cursor)) buffer_data->motion_column = cursor->x;
     CePoint_t before_follow = view->scroll;

     if(vim->mode == CE_VIM_MODE_VISUAL &&
        (action->motion.function == ce_vim_motion_inside ||
         action->motion.function == ce_vim_motion_around) &&
        ce_point_after(visual->point, motion_range.start)){
          visual->point = motion_range.start;
     }

     // if we are searching, and our cursor goes off the screen, center it
     if(!ce_points_equal(before_follow, view->scroll) &&
        (action->motion.function == ce_vim_motion_search_next ||
         action->motion.function == ce_vim_motion_search_prev)){
          ce_view_center(view);
     }

     return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, 0x8(%rsp)
movq %rcx, %rbp
movq %rdx, %rbx
movq %rdi, %r13
movq %rsi, 0x10(%rsp)
movq 0x10(%rsi), %rax
leaq 0x1924(%rip), %rcx      # 0x2485c
leaq 0x1980(%rip), %rdx      # 0x248bf
leaq 0x5f0(%r9), %rsi
cmpq %rdx, %rax
leaq 0x60(%rsp), %rdx
movq 0x8(%rdx), %r15
cmoveq %rsi, %rdx
cmpq %rcx, %rax
cmoveq %rsi, %rdx
movq (%rdx), %r14
movq 0x40(%rbx), %rdi
pushq $0x2
popq %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0xecee
movq %rdx, %rcx
movq %rax, (%rbp)
movq %rdx, 0x8(%rbp)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xedb2
testb %al, %al
je 0x22f9b
movq (%rbp), %rax
movq %rax, 0x5f0(%r12)
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %rbp
cmpl $0x2, (%r13)
jne 0x22ffe
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
leaq 0x1b75(%rip), %rcx      # 0x24b2f
cmpq %rcx, %rax
setne %cl
leaq 0x1b7e(%rip), %rdx      # 0x24b45
cmpq %rdx, %rax
setne %al
testb %al, %cl
jne 0x22ffe
leaq 0x50(%rsp), %r14
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
callq 0xea69
testb %al, %al
je 0x22ffe
movups (%r14), %xmm0
movq 0x8(%rsp), %rax
movups %xmm0, (%rax)
movq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rcx
movq %r12, %rdi
movq %rbp, %rsi
callq 0xedb2
testb %al, %al
jne 0x23044
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
leaq 0x1e3a(%rip), %rcx      # 0x24e5f
cmpq %rcx, %rax
setne %cl
leaq 0x200b(%rip), %rdx      # 0x2503d
cmpq %rdx, %rax
setne %al
testb %al, %cl
jne 0x23044
movq %rbx, %rdi
callq 0xfbc9
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_yank
bool ce_vim_verb_yank(CeVim_t* vim, const CeVimAction_t* action, CeRange_t motion_range, CeView_t* view,
                      CePoint_t* cursor, CeVimVisualData_t* visual, CeVimBufferData_t* buffer_data,
                      const CeConfigOptions_t* config_options){
     CeVimYank_t* yank = vim->yanks + ce_vim_register_index(action->verb.integer);
     ce_vim_yank_free(yank);
     int64_t yank_len = 0;
     if(action->exclude_end){
          motion_range.end = ce_buffer_advance_point(view->buffer, motion_range.end, -1);
     }
     yank_len = ce_buffer_range_len(view->buffer, motion_range.start, motion_range.end);
     yank->text = ce_buffer_dupe_string(view->buffer, motion_range.start, yank_len);
     yank->type = action->yank_type;
     vim->mode = CE_VIM_MODE_NORMAL;
     return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %rbp
movl 0x30(%rsi), %eax
leal -0x7f(%rax), %ecx
addl $-0x20, %eax
cmpl $-0x5f, %ecx
pushq $-0x1
popq %rcx
cmovaeq %rax, %rcx
imulq $0x18, %rcx, %rax
leaq (%rdi,%rax), %r12
addq $0x1050, %r12           # imm = 0x1050
movq %r12, %rdi
callq 0x2196f
cmpb $0x0, 0x3e(%r14)
je 0x230bb
movq 0x40(%r15), %rdi
movq 0x10(%rbp), %rsi
movq 0x18(%rbp), %rdx
pushq $-0x1
popq %rcx
callq 0xec3a
movq %rax, %rcx
movq %rdx, %r8
jmp 0x230c3
movq 0x10(%rbp), %rcx
movq 0x18(%rbp), %r8
movq 0x40(%r15), %rdi
movq (%rbp), %r13
movq 0x8(%rbp), %rbp
movq %r13, %rsi
movq %rbp, %rdx
callq 0xe98a
movq 0x40(%r15), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rax, %rcx
callq 0xf361
movq %rax, 0x8(%r12)
movl 0x38(%r14), %eax
movl %eax, (%r12)
andl $0x0, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_change
bool ce_vim_verb_change(CeVim_t* vim, const CeVimAction_t* action, CeRange_t motion_range, CeView_t* view,
                        CePoint_t* cursor, CeVimVisualData_t* visual, CeVimBufferData_t* buffer_data,
                        const CeConfigOptions_t* config_options){
     if(!ce_vim_verb_delete(vim, action, motion_range, view, cursor, visual, buffer_data, config_options)) return false;
     vim->chain_undo = true;
     ce_vim_insert_mode(vim);
     return true;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2310d
movl %eax, %ebp
testb %al, %al
je 0x2335b
movb $0x1, 0x19d8(%rbx)
movq %rbx, %rdi
callq 0x205ac
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_soft_begin_line
int64_t ce_vim_soft_begin_line(CeBuffer_t* buffer, int64_t line){
     if(line < 0 || line >= buffer->line_count) return -1;

     const char* itr = buffer->lines[line];
     int64_t index = 0;
     int64_t rune_len = 0;
     CeRune_t rune = ce_utf8_decode(itr, &rune_len);

     while(true){
          rune = ce_utf8_decode(itr, &rune_len);
          itr += rune_len;
          if(isspace(rune)) index++;
          else break;
     }

     return index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
testq %rsi, %rsi
js 0x233bc
cmpq %rsi, 0x8(%rdi)
jle 0x233bc
movq (%rdi), %rax
movq (%rax,%rsi,8), %r14
movq %rsp, %r15
andq $0x0, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xe53f
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rsi
callq 0xe53f
movl %eax, %ebp
callq 0xd720
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x233bc
addq (%rsp), %r14
incq %rbx
jmp 0x23394
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_move_big_word
CePoint_t ce_vim_move_big_word(CeBuffer_t* buffer, CePoint_t start){
     if(!ce_buffer_point_is_valid(buffer, start)) return (CePoint_t){-1, -1};

     char* itr = ce_utf8_iterate_to(buffer->lines[start.y], start.x);

     int64_t rune_len = 0;
     CeRune_t rune = ce_utf8_decode(itr, &rune_len);
     WordState_t state = WORD_INSIDE_WORD;

     if(isspace(rune)) state = WORD_INSIDE_SPACE;

     itr += rune_len;
     start.x++;

     while(true){
          rune = ce_utf8_decode(itr, &rune_len);

          switch(state){
          default:
               assert(0);
               break;
          case WORD_INSIDE_WORD:
               if(isspace(rune)) state = WORD_INSIDE_SPACE;
               break;
          case WORD_INSIDE_SPACE:
               if(!isspace(rune)) goto END_LOOP;
               break;
          case WORD_NEW_LINE:
               if(isspace(rune)) state = WORD_INSIDE_SPACE;
               else goto END_LOOP;
               break;
          }

          if(*itr == 0){
               if(start.y >= buffer->line_count - 1) break;
               start.x = 0;
               start.y++;
               itr = buffer->lines[start.y];
               state = WORD_NEW_LINE;
          }else{
               itr += rune_len;
               start.x++;
          }
     }

END_LOOP:

     return start;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xe425
testq %rax, %rax
je 0x2369e
movq %r15, 0x8(%rsp)
movq (%r15), %rax
movq %rbx, (%rsp)
movq (%rax,%rbx,8), %rdi
movq %r14, %rsi
callq 0xe4a6
movq %rax, %r13
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
movq %rax, %rdi
movq %r12, %rsi
callq 0xe53f
movl %eax, %r15d
callq 0xd720
movq %rax, %rbp
movq (%rax), %rax
movslq %r15d, %rcx
movzwl (%rax,%rcx,2), %r15d
addq (%r12), %r13
incq %r14
shrl $0xd, %r15d
andl $0x1, %r15d
pushq $0x1
popq %rbx
movq %r13, %rdi
movq %r12, %rsi
callq 0xe53f
cltq
testl %r15d, %r15d
je 0x23640
cmpl $0x1, %r15d
je 0x23630
cmpl $0x3, %r15d
jne 0x236b7
movq (%rbp), %rcx
testb $0x20, 0x1(%rcx,%rax,2)
movl %ebx, %r15d
jne 0x23651
jmp 0x23698
movq (%rbp), %rcx
movzwl (%rcx,%rax,2), %r15d
shrl $0xd, %r15d
andl $0x1, %r15d
cmpb $0x0, (%r13)
je 0x23662
addq 0x10(%rsp), %r13
incq %r14
jmp 0x2360e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
decq %rax
cmpq %rax, (%rsp)
jge 0x23698
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq 0x8(%rax,%rcx,8), %r13
incq %rcx
movq %rcx, (%rsp)
xorl %r14d, %r14d
pushq $0x3
popq %r15
jmp 0x2360e
movq (%rsp), %rdx
jmp 0x236a5
pushq $-0x1
popq %r14
movq %r14, %rdx
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9658(%rip), %rdi      # 0x2cd16
leaq 0x9b9a(%rip), %rsi      # 0x2d25f
leaq 0x9bf0(%rip), %rcx      # 0x2d2bc
movl $0x328, %edx            # imm = 0x328
callq 0xd280
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_move_end_big_word
CePoint_t ce_vim_move_end_big_word(CeBuffer_t* buffer, CePoint_t start){
     start.x++;
     if(!ce_buffer_point_is_valid(buffer, start)){
          if(start.x == 1){
               // line is empty
               start.x = 0;
          }else{
               return (CePoint_t){-1, -1};
          }
     }

     char* itr = ce_utf8_iterate_to(buffer->lines[start.y], start.x);

     int64_t rune_len = 0;
     CeRune_t rune = 0;
     WordState_t state = WORD_INSIDE_WORD;

     if(*itr == 0){
          if(start.y >= buffer->line_count - 1) return (CePoint_t){-1, -1};
          start.x = 0;
          start.y++;
          itr = buffer->lines[start.y];

          rune = ce_utf8_decode(itr, &rune_len);
          itr += rune_len;
          if(isspace(rune)) state = WORD_INSIDE_SPACE;
          else state = WORD_INSIDE_WORD;
     }else{
          rune = ce_utf8_decode(itr, &rune_len);
          if(isspace(rune)) state = WORD_INSIDE_SPACE;
          itr += rune_len;
     }

     while(true){
          rune = ce_utf8_decode(itr, &rune_len);

          switch(state){
          default:
               assert(0);
               break;
          case WORD_INSIDE_WORD:
               if(isspace(rune)) goto END_LOOP;
               break;
          case WORD_INSIDE_SPACE:
               if(!isspace(rune)) state = WORD_INSIDE_WORD;
               break;
          }

          itr += rune_len;
          start.x++;

          if(*itr == 0) break;
     }

END_LOOP:

     return start;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x1(%rsi), %r14
movq %r14, %rsi
callq 0xe425
testq %rax, %rax
je 0x2396f
movq (%r12), %rax
movq (%rax,%rbx,8), %rdi
movq %r14, %rsi
callq 0xe4a6
andq $0x0, (%rsp)
cmpb $0x0, (%rax)
je 0x2397d
movq %rax, %r15
movq %rsp, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0xe53f
movl %eax, %ebp
callq 0xd720
movslq %ebp, %rcx
addq %rcx, %rcx
addq (%rax), %rcx
addq (%r12), %r15
jmp 0x239be
testq %r15, %r15
jne 0x23a16
xorl %r14d, %r14d
jmp 0x2392e
movq 0x8(%r12), %rax
decq %rax
cmpq %rbx, %rax
jle 0x23a16
movq (%r12), %rax
movq 0x8(%rax,%rbx,8), %r15
incq %rbx
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xe53f
movl %eax, %ebp
addq (%r14), %r15
callq 0xd720
movslq %ebp, %rcx
addq %rcx, %rcx
addq (%rax), %rcx
xorl %r14d, %r14d
movzwl (%rcx), %r13d
shrl $0xd, %r13d
andl $0x1, %r13d
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xe53f
movl %eax, %ebp
callq 0xd720
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
testl %r13d, %r13d
je 0x239f9
shrl $0xd, %eax
andl $0x1, %eax
movl %eax, %r13d
jmp 0x23a02
xorl %r13d, %r13d
btl $0xd, %eax
jb 0x23a1d
movq (%rsp), %rax
incq %r14
cmpb $0x0, (%r15,%rax)
leaq (%r15,%rax), %r15
jne 0x239cd
jmp 0x23a1d
pushq $-0x1
popq %r14
movq %r14, %rbx
movq %r14, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_move_find_rune_forward
CePoint_t ce_vim_move_find_rune_forward(CeBuffer_t* buffer, CePoint_t start, CeRune_t match_rune, bool until){
     if(!ce_buffer_point_is_valid(buffer, start)) return (CePoint_t){-1, -1};
     int64_t match_x = until ? start.x + 2 : start.x + 1;
     char* str = ce_utf8_iterate_to(buffer->lines[start.y], match_x);
     if(!str) return (CePoint_t){-1, -1};

     while(*str){
          int64_t rune_len = 0;
          CeRune_t rune = ce_utf8_decode(str, &rune_len);
          if(rune == match_rune) return (CePoint_t){until ? match_x - 1 : match_x, start.y};
          str += rune_len;
          match_x++;
     }

     return (CePoint_t){-1, -1};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0xe425
pushq $-0x1
popq %rcx
testq %rax, %rax
je 0x23e59
movzbl %r14b, %r13d
leaq (%r12,%r13), %rsi
incq %rsi
movq (%r15), %rax
movq (%rax,%rbx,8), %rdi
callq 0xe4a6
testq %rax, %rax
je 0x23e61
movq %rax, %r15
leaq 0x1(%r13), %r14
addq %r12, %r14
subq %r13, %r14
movq %rsp, %r12
pushq $-0x1
popq %r13
cmpb $0x0, (%r15)
je 0x23e69
andq $0x0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe53f
cmpl %ebp, %eax
je 0x23e6f
addq (%rsp), %r15
incq %r14
jmp 0x23e36
movq %rcx, %r14
movq %rcx, %rbx
jmp 0x23e6f
pushq $-0x1
popq %rbx
movq %rbx, %r14
jmp 0x23e6f
movq %r13, %r14
movq %r13, %rbx
movq %r14, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq