LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x23a2a
movl (%rsi), %ecx
addl $-0x2, %ecx
movl $0x1, %eax
cmpl $0x2, %ecx
ja 0x23a41
leaq 0x220b(%rip), %rax      # 0x25c31
movq %rax, 0x28(%rdi)
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x23a42
xorl %eax, %eax
leaq 0x4057(%rip), %rsi      # 0x27a93
cmpq %rsi, %rcx
je 0x23a53
retq
leaq 0x404a(%rip), %rax      # 0x27a93
movq %rax, 0x10(%rdi)
movl $0x2, %eax
retq
movl %edx, 0x18(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x23d8c
xorl %eax, %eax
leaq 0x44e9(%rip), %rsi      # 0x2826f
cmpq %rsi, %rcx
je 0x23d9d
retq
leaq 0x44dc(%rip), %rax      # 0x2826f
movq %rax, 0x10(%rdi)
movl $0x2, %eax
retq
movl %edx, 0x18(%rdi)
movl $0x5, %eax
cmpq $0x0, 0x28(%rdi)
jne 0x23d8b
leaq 0x1e7e(%rip), %rcx      # 0x25c31
movq %rcx, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x23dd0
xorl %eax, %eax
leaq 0x450d(%rip), %rsi      # 0x282d7
cmpq %rsi, %rcx
je 0x23de1
retq
leaq 0x4500(%rip), %rax      # 0x282d7
movq %rax, 0x10(%rdi)
movl $0x2, %eax
retq
movl %edx, 0x18(%rdi)
movl $0x5, %eax
cmpq $0x0, 0x28(%rdi)
jne 0x23dcf
leaq 0x1e3a(%rip), %rcx      # 0x25c31
movq %rcx, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
cmpq $0x0, 0x10(%rdi)
je 0x23e09
retq
cmpq $0x0, 0x28(%rdi)
jne 0x23e08
leaq 0x12a5(%rip), %rax      # 0x250bc
movq %rax, 0x28(%rdi)
movb $0x1, 0x3d(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
cmpq $0x0, 0x10(%rdi)
je 0x23e32
retq
cmpq $0x0, 0x28(%rdi)
jne 0x23e31
leaq 0x3861(%rip), %rax      # 0x276a1
movq %rax, 0x28(%rdi)
movb $0x1, 0x3d(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
cmpq $0x0, 0x10(%rdi)
je 0x23e5b
retq
cmpq $0x0, 0x28(%rdi)
jne 0x23e5a
leaq 0x385b(%rip), %rax      # 0x276c4
movq %rax, 0x28(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
cmpq $0x0, 0x10(%rdi)
je 0x23e80
retq
cmpq $0x0, 0x28(%rdi)
jne 0x23e7f
leaq 0x3846(%rip), %rax      # 0x276d4
movq %rax, 0x28(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
cmpq $0x0, 0x10(%rdi)
je 0x23ea5
retq
cmpq $0x0, 0x28(%rdi)
jne 0x23ea4
leaq 0x3831(%rip), %rax      # 0x276e4
movq %rax, 0x28(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
cmpq $0x0, 0x28(%rdi)
je 0x23eca
retq
leaq 0x120e(%rip), %rax      # 0x250df
movq %rax, 0x28(%rdi)
movb $0x1, 0x3d(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
cmpq $0x0, 0x28(%rdi)
je 0x23eec
retq
leaq 0x1243(%rip), %rax      # 0x25136
movq %rax, 0x28(%rdi)
movb $0x1, 0x3d(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
cmpq $0x0, 0x28(%rdi)
je 0x23f0e
retq
leaq 0x37e5(%rip), %rax      # 0x276fa
movq %rax, 0x28(%rdi)
movb $0x1, 0x3d(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f24(%rip), %rax      # 0x25e52
cmpq %rax, 0x28(%rdi)
je 0x23f4b
movq %rax, 0x28(%rdi)
movl $0x1, 0x38(%rdi)
movl $0x4, %eax
movl $0x40, %ecx
jmp 0x23f60
leaq 0x478a(%rip), %rax      # 0x286dc
movq %rax, 0x10(%rdi)
movl $0x5, %eax
movl $0x38, %ecx
movl $0x2, (%rdi,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3a6d(%rip), %rax      # 0x279e0
movq %rax, 0x10(%rdi)
leaq 0x1ed4(%rip), %rax      # 0x25e52
movq %rax, 0x28(%rdi)
movl $0x1, 0x38(%rdi)
movl $0x2, 0x40(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20ef(%rip), %rax      # 0x26090
cmpq %rax, 0x28(%rdi)
je 0x23fbc
movq %rax, 0x28(%rdi)
movl $0x1, %eax
movl %eax, 0x38(%rdi)
movl %eax, 0x40(%rdi)
movl $0x4, %eax
retq
leaq 0x474d(%rip), %rax      # 0x28710
movq %rax, 0x28(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3a08(%rip), %rax      # 0x279e0
movq %rax, 0x10(%rdi)
leaq 0x20ad(%rip), %rax      # 0x26090
movq %rax, 0x28(%rdi)
movl $0x1, %eax
movl %eax, 0x38(%rdi)
movl %eax, 0x40(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24016
leal -0x20(%rdx), %ecx
xorl %eax, %eax
cmpb $0x5e, %cl
ja 0x24015
movl %edx, 0x30(%rdi)
movl $0x5, %eax
retq
leaq 0x47ed(%rip), %rax      # 0x2880a
movq %rax, 0x28(%rdi)
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x48dc(%rip), %rax      # 0x2890e
movq %rax, 0x28(%rdi)
movl $0x2, 0x40(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x49a2(%rip), %rax      # 0x289f0
movq %rax, 0x28(%rdi)
movl $0x1, 0x40(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d10(%rip), %rax      # 0x25d8b
cmpq %rax, 0x28(%rdi)
je 0x24098
movq %rax, 0x28(%rdi)
movl $0x1, 0x38(%rdi)
movl $0x4, %eax
cmpl $0x0, 0x30(%rdi)
je 0x240b0
retq
leaq 0x463d(%rip), %rax      # 0x286dc
movq %rax, 0x10(%rdi)
movl $0x2, 0x38(%rdi)
movl $0x5, %eax
retq
movl $0x22, 0x30(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ccc(%rip), %rax      # 0x25d8b
movq %rax, 0x28(%rdi)
leaq 0x4612(%rip), %rax      # 0x286dc
movq %rax, 0x10(%rdi)
cmpl $0x0, 0x30(%rdi)
jne 0x240db
movl $0x22, 0x30(%rdi)
movl $0x2, 0x38(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x492f(%rip), %rax      # 0x28a45
movq %rax, 0x28(%rdi)
cmpl $0x0, 0x30(%rdi)
jne 0x24127
movl $0x22, 0x30(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x494b(%rip), %rax      # 0x28a83
movq %rax, 0x28(%rdi)
cmpl $0x0, 0x30(%rdi)
jne 0x24149
movl $0x22, 0x30(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24200
xorl %eax, %eax
leaq 0x4db2(%rip), %rsi      # 0x28fac
cmpq %rsi, %rcx
je 0x24211
retq
leaq 0x4da5(%rip), %rax      # 0x28fac
movq %rax, 0x28(%rdi)
movl $0x2, %eax
retq
movl %edx, 0x30(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24232
xorl %eax, %eax
leaq 0x4dc9(%rip), %rsi      # 0x28ff5
cmpq %rsi, %rcx
je 0x2424d
retq
leaq 0x4dbc(%rip), %rax      # 0x28ff5
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)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2426e
xorl %eax, %eax
leaq 0x4e2c(%rip), %rdx      # 0x29094
cmpq %rdx, %rcx
je 0x24283
retq
movb $0x1, 0x3d(%rdi)
leaq 0x4e1b(%rip), %rax      # 0x29094
movq %rax, 0x28(%rdi)
movl $0x4, %eax
retq
movb $0x1, 0x3d(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x242ad
leaq 0x4fd4(%rip), %rcx      # 0x29275
xorl %edx, %edx
cmpq %rcx, %rax
sete %dl
leal (%rdx,%rdx,4), %eax
retq
leaq 0x4fc1(%rip), %rax      # 0x29275
movq %rax, 0x28(%rdi)
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3482(%rip), %rax      # 0x27760
movq %rax, 0x10(%rdi)
leaq 0x50ec(%rip), %rax      # 0x293d5
movq %rax, 0x28(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2430b
xorl %eax, %eax
leaq 0x5256(%rip), %rsi      # 0x2955b
cmpq %rsi, %rcx
je 0x2431c
retq
leaq 0x5249(%rip), %rax      # 0x2955b
movq %rax, 0x28(%rdi)
movl $0x2, %eax
retq
movl %edx, 0x30(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq (%r14,%r15), %rdi
callq 0x243a6
addq $0x18, %r15
cmpq $0x8e8, %r15            # imm = 0x8E8
jne 0x2436d
leaq 0x19c8(%rbx), %rdi
callq 0x10370
addq $0x19d0, %rbx           # imm = 0x19D0
movq %rbx, %rdi
callq 0x10370
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x243ca
movq 0x8(%rbx), %rdi
callq 0xd090
movq $0x0, 0x8(%rbx)
jmp 0x243ff
cmpl $0x3, %eax
jne 0x243ff
cmpq $0x0, 0x10(%rbx)
jle 0x243ef
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xd090
incq %r14
cmpq 0x10(%rbx), %r14
jl 0x243d9
movq 0x8(%rbx), %rdi
callq 0xd090
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movl $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rcx
testq %rcx, %rcx
setg %r8b
jle 0x2445d
cmpl %esi, 0x8(%rdi)
jne 0x24428
leaq 0x8(%rdi), %rax
jmp 0x24452
leaq 0x18(%rdi), %r10
leaq -0x1(%rcx), %r9
xorl %r8d, %r8d
cmpq %r8, %r9
je 0x2445d
leaq 0x10(%r10), %rax
incq %r8
cmpl %esi, (%r10)
movq %rax, %r10
jne 0x24433
cmpq %rcx, %r8
setl %r8b
addq $-0x10, %rax
movq %rdx, 0x8(%rax)
movb $0x1, %al
testb %r8b, %r8b
jne 0x24468
cmpq $0xff, %rcx
jle 0x24469
xorl %eax, %eax
retq
movq %rcx, %rax
shlq $0x4, %rax
movl %esi, 0x8(%rdi,%rax)
movq %rdx, 0x10(%rdi,%rax)
incq %rcx
movq %rcx, 0x1008(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x123d0
cmpq $0xe, %rax
jg 0x244ae
movl %ebp, (%rbx,%rax,4)
movl $0x0, 0x4(%rbx,%rax,4)
cmpq $0xf, %rax
setl %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x0, (%rdi)
je 0x25040
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
sete %al
je 0x25045
callq 0xd720
movq (%rax), %rcx
incq %rbx
movsbq %bpl, %rax
testb $0x20, 0x1(%rcx,%rax,2)
je 0x25043
movb (%rbx), %bpl
incq %rbx
testb %bpl, %bpl
sete %al
jne 0x25025
jmp 0x25045
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe485
movq $0x0, 0x18(%rsp)
leaq 0x1(%r14), %rcx
movq %rcx, 0x20(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movl $0x1, %ecx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r12, %r8
movl %ebx, %r9d
callq 0xfc21
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movq 0x40(%rdx), %rax
movq (%rax), %rax
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xe485
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
cmpq %rax, %rcx
cmovgeq %rax, %rdx
movq %rdx, (%r14)
movl $0x1, (%rbx)
cmpb $0x0, 0x19d9(%rbx)
jne 0x2512c
addq $0x19c8, %rbx           # imm = 0x19C8
movq %rbx, %rdi
callq 0x10370
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x50(%rsp), %r8
movq %rsi, 0x10(%rsp)
movq 0x10(%rsi), %rax
leaq 0x1b12(%rip), %rcx      # 0x27777
cmpq %rcx, %rax
setne %cl
leaq 0x1b6e(%rip), %rdx      # 0x277e0
cmpq %rdx, %rax
setne %al
testb %al, %cl
jne 0x25c88
movq 0x5f0(%r12), %rax
movq %rax, 0x10(%r8)
movq 0x40(%rbx), %rdi
movq 0x10(%r8), %r15
movq 0x18(%r8), %r14
movq %r15, %rsi
movq %r14, %rdx
movl $0x2, %ecx
callq 0xf112
movq %rdx, %rcx
movq %rax, (%rbp)
movq %rdx, 0x8(%rbp)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf1d6
testb %al, %al
je 0x25ccd
movq (%rbp), %rax
movq %rax, 0x5f0(%r12)
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %rbp
cmpl $0x2, (%r13)
jne 0x25d34
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
leaq 0x1d8f(%rip), %rcx      # 0x27a7b
cmpq %rcx, %rax
setne %cl
leaq 0x1d9a(%rip), %rdx      # 0x27a93
cmpq %rdx, %rax
setne %al
testb %al, %cl
jne 0x25d34
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
leaq 0x50(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0xedfb
testb %al, %al
je 0x25d34
leaq 0x50(%rsp), %rax
movups (%rax), %xmm0
movq 0x8(%rsp), %rax
movups %xmm0, (%rax)
movq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rcx
movq %r12, %rdi
movq %rbp, %rsi
callq 0xf1d6
testb %al, %al
jne 0x25d7a
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
leaq 0x203b(%rip), %rcx      # 0x27d96
cmpq %rcx, %rax
setne %cl
leaq 0x222a(%rip), %rdx      # 0x27f92
cmpq %rdx, %rax
setne %al
testb %al, %cl
jne 0x25d7a
movq %rbx, %rdi
callq 0x100c2
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_O1/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
leaq 0x40(%rsp), %rbx
movl 0x30(%rsi), %eax
leal -0x7f(%rax), %ecx
addl $-0x20, %eax
cmpl $-0x5f, %ecx
movq $-0x1, %rcx
cmovaeq %rax, %rcx
leaq (%rcx,%rcx,2), %rax
movq %rdi, (%rsp)
leaq (%rdi,%rax,8), %r12
addq $0x1050, %r12           # imm = 0x1050
movq %r12, %rdi
callq 0x243a6
cmpb $0x1, 0x3e(%r14)
jne 0x25dfa
movq 0x40(%r15), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq $-0x1, %rcx
callq 0xeffa
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movq 0x40(%r15), %rdi
movq (%rbx), %r13
movq 0x8(%rbx), %rbp
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %r8
movq %r13, %rsi
movq %rbp, %rdx
callq 0xecb5
movq 0x40(%r15), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rax, %rcx
callq 0xf79a
movq %rax, 0x8(%r12)
movl 0x38(%r14), %eax
movl %eax, (%r12)
movq (%rsp), %rax
movl $0x0, (%rax)
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_O1/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 0x25e52
movl %eax, %ebp
testb %al, %al
je 0x260dc
movb $0x1, 0x19d8(%rbx)
movl $0x1, (%rbx)
cmpb $0x0, 0x19d9(%rbx)
jne 0x260dc
addq $0x19c8, %rbx           # imm = 0x19C8
movq %rbx, %rdi
callq 0x10370
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq $-0x1, %r14
testq %rsi, %rsi
js 0x2616f
cmpq %rsi, 0x8(%rdi)
jle 0x2616f
movq (%rdi), %rax
movq (%rax,%rsi,8), %rbx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe649
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe649
movl %eax, %ebp
callq 0xd720
movq %rax, %r15
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x26148
xorl %r14d, %r14d
jmp 0x2616f
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
addq 0x8(%rsp), %rbx
incq %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe649
movq (%r15), %rcx
cltq
testb $0x20, 0x1(%rcx,%rax,2)
jne 0x26150
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe514
testq %rax, %rax
je 0x2643c
movq %r15, 0x8(%rsp)
movq (%r15), %rax
movq (%rax,%rbx,8), %rdi
movq %r14, %rsi
callq 0xe5be
movq %rax, %r13
leaq 0x10(%rsp), %r12
movq $0x0, (%r12)
movq %rax, %rdi
movq %r12, %rsi
callq 0xe649
movl %eax, %r15d
callq 0xd720
movq %rax, %rbp
movq (%rax), %rax
movslq %r15d, %rcx
movzwl (%rax,%rcx,2), %r15d
shrl $0xd, %r15d
andl $0x1, %r15d
addq (%r12), %r13
incq %r14
movq %r13, %rdi
movq %r12, %rsi
callq 0xe649
testl %r15d, %r15d
je 0x263ec
cmpl $0x1, %r15d
je 0x263d7
cmpl $0x3, %r15d
jne 0x2645f
movq (%rbp), %rcx
cltq
movl $0x1, %r15d
testb $0x20, 0x1(%rcx,%rax,2)
jne 0x263ff
jmp 0x2644a
movq (%rbp), %rcx
cltq
movzwl (%rcx,%rax,2), %r15d
shrl $0xd, %r15d
andl $0x1, %r15d
cmpb $0x0, (%r13)
jne 0x26432
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
decq %rax
cmpq %rax, %rbx
jge 0x2644a
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax,%rbx,8), %r13
incq %rbx
movl $0x3, %r15d
xorl %r14d, %r14d
jmp 0x263b7
addq 0x10(%rsp), %r13
jmp 0x263b4
movq $-0x1, %r14
movq $-0x1, %rbx
movq %r14, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa864(%rip), %rdi      # 0x30cca
leaq 0xadaa(%rip), %rsi      # 0x31217
leaq 0xae00(%rip), %rcx      # 0x31274
movl $0x328, %edx            # imm = 0x328
callq 0xd280
// File: /workspace/github_c_makefile_star2_O1/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 0xe514
testq %rax, %rax
je 0x26742
movq (%r12), %rax
movq (%rax,%rbx,8), %rdi
movq %r14, %rsi
callq 0xe5be
movq $0x0, (%rsp)
cmpb $0x0, (%rax)
je 0x2675e
movq %rax, %r15
movq %rsp, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0xe649
movl %eax, %ebp
callq 0xd720
movslq %ebp, %rcx
addq %rcx, %rcx
addq (%rax), %rcx
addq (%r12), %r15
jmp 0x267ad
movq $-0x1, %r14
movq $-0x1, %rdx
testq %r15, %r15
jne 0x26806
xorl %r14d, %r14d
jmp 0x266fe
movq 0x8(%r12), %rax
decq %rax
movq $-0x1, %r14
movq $-0x1, %rdx
cmpq %rbx, %rax
jle 0x26806
movq (%r12), %rax
movq 0x8(%rax,%rbx,8), %r15
incq %rbx
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xe649
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 0xe649
movl %eax, %ebp
callq 0xd720
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
testl %r13d, %r13d
je 0x267e8
shrl $0xd, %eax
andl $0x1, %eax
movl %eax, %r13d
jmp 0x267f1
xorl %r13d, %r13d
btl $0xd, %eax
jb 0x26803
movq (%rsp), %rax
incq %r14
cmpb $0x0, (%r15,%rax)
leaq (%r15,%rax), %r15
jne 0x267bc
movq %rbx, %rdx
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movl %r8d, %r14d
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
callq 0xe514
testq %rax, %rax
je 0x26ca6
movzbl %r14b, %ebx
leaq (%rbx,%r12), %r14
incq %r14
movq (%r15), %rax
movq (%rax,%r13,8), %rdi
movq %r14, %rsi
callq 0xe5be
testq %rax, %rax
je 0x26ca6
movq %rax, %r12
movq %r13, 0x8(%rsp)
negq %rbx
leaq 0x10(%rsp), %r13
cmpb $0x0, (%r12)
je 0x26ca6
movq $0x0, 0x10(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xe649
cmpl %ebp, %eax
jne 0x26c98
leaq (%r14,%rbx), %r15
jmp 0x26ca0
addq 0x10(%rsp), %r12
incq %r14
cmpl %ebp, %eax
jne 0x26c73
jmp 0x26cb6
movq $-0x1, %r15
movq $-0x1, 0x8(%rsp)
movq %r15, %rax
movq 0x8(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_vim.c
// Function: ce_vim_move_find_rune_backward
CePoint_t ce_vim_move_find_rune_backward(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};
     if(start.x == 0) return (CePoint_t){-1, -1};

     char* start_of_line = buffer->lines[start.y];
     char* str = ce_utf8_iterate_to(start_of_line, start.x);
     if(!str) return (CePoint_t){-1, -1};
     int64_t match_x = start.x - 1;
     str--;

     if(until){
          match_x--;
          int64_t rune_len = 0;
          ce_utf8_decode_reverse(str, start_of_line, &rune_len);
          str -= rune_len;
     }

     while(str >= start_of_line){
          int64_t rune_len = 0;
          CeRune_t rune = ce_utf8_decode_reverse(str, start_of_line, &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
subq $0x18, %rsp
movl %r8d, %r13d
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xe514
testq %rax, %rax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x26d89
movq (%rbx), %rax
movq %r15, 0x8(%rsp)
movq (%rax,%r15,8), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xe5be
testq %rax, %rax
je 0x26d89
movq %rax, %r12
decq %r12
testb %r13b, %r13b
je 0x26d4c
addq $-0x2, %r14
leaq 0x10(%rsp), %rbx
movq $0x0, (%rbx)
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1025d
subq (%rbx), %r12
jmp 0x26d4f
decq %r14
movzbl %r13b, %ebx
cmpq %r15, %r12
jb 0x26d89
movq $0x0, 0x10(%rsp)
movq %r12, %rdi
movq %r15, %rsi
leaq 0x10(%rsp), %rdx
callq 0x1025d
cmpl %ebp, %eax
jne 0x26d7b
leaq (%r14,%rbx), %r13
jmp 0x26d83
subq 0x10(%rsp), %r12
decq %r14
cmpl %ebp, %eax
jne 0x26d53
jmp 0x26d99
movq $-0x1, %r13
movq $-0x1, 0x8(%rsp)
movq %r13, %rax
movq 0x8(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_vim.c
// Function: ce_vim_find_little_word_boundaries
CeRange_t ce_vim_find_little_word_boundaries(CeBuffer_t* buffer, CePoint_t start){
     CeRange_t range = {(CePoint_t){-1, -1}, (CePoint_t){-1, -1}};
     char* line_start = buffer->lines[start.y];
     char* itr = ce_utf8_iterate_to(line_start, start.x);
     char* save_start = itr;
     if(!is_little_word_character(*itr)) return range;

     int64_t end_x = start.x - 1;
     while(*itr){
          int64_t rune_len = 0;
          CeRune_t rune = ce_utf8_decode(itr, &rune_len);
          if(!is_little_word_character(rune)) break;
          end_x++;
          itr += rune_len;
     }

     int64_t start_x = start.x + 1;
     itr = save_start;
     while(itr >= line_start){
          int64_t rune_len = 0;
          CeRune_t rune = ce_utf8_decode_reverse(itr, line_start, &rune_len);
          if(!is_little_word_character(rune)) break;
          start_x--;
          itr -= rune_len;
     }

     if(start_x > end_x) return range;

     range.start.x = start_x;
     range.start.y = start.y;
     range.end.x = end_x;
     range.end.y = start.y;

     return range;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %r15
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%rdi)
movq %rdi, 0x8(%rsp)
movdqu %xmm0, (%rdi)
movq (%rsi), %rax
movq (%rax,%rcx,8), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0xe5be
movq %rax, %r14
movsbq (%rax), %rbx
callq 0xd720
movq %rax, %rbp
cmpq $0x5f, %rbx
je 0x26e0e
movq (%rbp), %rax
movzwl (%rax,%rbx,2), %eax
andl $0x8, %eax
je 0x26ed3
movq %r13, 0x10(%rsp)
leaq -0x1(%r15), %rbx
movq %r14, %r13
cmpb $0x0, (%r13)
je 0x26e62
xorl %eax, %eax
movq %rax, (%rsp)
movq %r13, %rdi
movq %rsp, %rsi
callq 0xe649
movq (%rbp), %rcx
cltq
movzwl (%rcx,%rax,2), %edx
andl $0x8, %edx
shrl $0x3, %edx
cmpl $0x5f, %eax
sete %cl
orb %dl, %cl
movl $0x0, %eax
je 0x26e55
movq (%rsp), %rax
movzbl %cl, %ecx
addq %rcx, %rbx
addq %rax, %r13
testb %cl, %cl
jne 0x26e1a
incq %r15
movq %rsp, %r13
cmpq %r12, %r14
jb 0x26eb5
xorl %eax, %eax
movq %rax, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1025d
movq (%rbp), %rcx
cltq
movzwl (%rcx,%rax,2), %ecx
andl $0x8, %ecx
shrl $0x3, %ecx
cmpl $0x5f, %eax
sete %al
orb %cl, %al
jne 0x26e9f
xorl %ecx, %ecx
jmp 0x26ea8
movq (%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movzbl %al, %eax
subq %rax, %r15
addq %rcx, %r14
testb %al, %al
jne 0x26e68
cmpq %rbx, %r15
movq 0x10(%rsp), %rax
jg 0x26ed3
movq 0x8(%rsp), %rcx
movq %r15, (%rcx)
movq %rax, 0x8(%rcx)
movq %rbx, 0x10(%rcx)
movq %rax, 0x18(%rcx)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq