LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
leaq 0x31c6(%rip), %rcx      # 0x34c70
cmpq %rcx, 0x28(%rax)
jne 0x31ad3
movq -0x10(%rbp), %rax
leaq 0x7fc5(%rip), %rcx      # 0x39a80
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x38(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x31b09
movq -0x10(%rbp), %rax
leaq 0x3192(%rip), %rcx      # 0x34c70
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x31b02
movq -0x10(%rbp), %rax
movl $0x22, 0x30(%rax)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
leaq 0x3146(%rip), %rcx      # 0x34c70
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
leaq 0x7f47(%rip), %rcx      # 0x39a80
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x31b52
movq -0x8(%rbp), %rax
movl $0x22, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x38(%rax)
movl $0x5, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_select_yank_register
CeVimParseResult_t ce_vim_parse_select_yank_register(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(action->verb.integer == 0){
          action->verb.integer = '"';
          return CE_VIM_PARSE_CONSUME_ADDITIONAL_KEY;
     }else if(action->verb.integer == '"'){
          action->verb.integer = key;
          return CE_VIM_PARSE_CONTINUE;
     }

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x31b9d
movq -0x10(%rbp), %rax
movl $0x22, 0x30(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x31bc3
movq -0x10(%rbp), %rax
cmpl $0x22, 0x30(%rax)
jne 0x31bba
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movl $0x3, -0x4(%rbp)
jmp 0x31bc3
jmp 0x31bbc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x8(%rbp), %rax
leaq 0x841e(%rip), %rcx      # 0x3a010
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x31c0b
movq -0x8(%rbp), %rax
movl $0x22, 0x30(%rax)
movl $0x5, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x8(%rbp), %rax
leaq 0x846e(%rip), %rcx      # 0x3a0b0
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x31c5b
movq -0x8(%rbp), %rax
movl $0x22, 0x30(%rax)
movl $0x5, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_open_above
CeVimParseResult_t ce_vim_parse_verb_open_above(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(vim_mode_is_visual(vim->mode)){
          action->motion.function = &ce_vim_motion_other_end_of_selection;
          action->verb.function = &ce_vim_verb_motion;
          return CE_VIM_PARSE_COMPLETE;
     }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x2fe10
testb $0x1, %al
jne 0x31cf4
jmp 0x31d1b
movq -0x10(%rbp), %rax
leaq 0x8451(%rip), %rcx      # 0x3a150
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x2db2(%rip), %rcx      # 0x34ac0
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x31d39
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x10(%rbp), %rax
leaq 0x84b2(%rip), %rcx      # 0x3a1e0
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_open_below
CeVimParseResult_t ce_vim_parse_verb_open_below(CeVimAction_t* action, const CeVim_t* vim, CeRune_t key){
     if(vim_mode_is_visual(vim->mode)){
          action->motion.function = &ce_vim_motion_other_end_of_selection;
          action->verb.function = &ce_vim_verb_motion;
          return CE_VIM_PARSE_COMPLETE;
     }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x2fe10
testb $0x1, %al
jne 0x31d74
jmp 0x31d9b
movq -0x10(%rbp), %rax
leaq 0x83d1(%rip), %rcx      # 0x3a150
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x2d32(%rip), %rcx      # 0x34ac0
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x31db9
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x10(%rbp), %rax
leaq 0x85c2(%rip), %rcx      # 0x3a370
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x31e32
movq -0x10(%rbp), %rax
leaq 0x8aab(%rip), %rcx      # 0x3a8d0
movq %rcx, 0x28(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x31e5f
movq -0x10(%rbp), %rax
leaq 0x8a93(%rip), %rcx      # 0x3a8d0
cmpq %rcx, 0x28(%rax)
jne 0x31e56
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x31e5f
jmp 0x31e58
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x31eb5
movq -0x10(%rbp), %rax
leaq 0x8b0b(%rip), %rcx      # 0x3a9a0
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x1, (%rax)
jle 0x31eac
movl $0x5, -0x4(%rbp)
jmp 0x31ee2
movl $0x2, -0x4(%rbp)
jmp 0x31ee2
movq -0x10(%rbp), %rax
leaq 0x8ae0(%rip), %rcx      # 0x3a9a0
cmpq %rcx, 0x28(%rax)
jne 0x31ed9
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x31ee2
jmp 0x31edb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x31f2a
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x10(%rbp), %rax
leaq 0x8c03(%rip), %rcx      # 0x3ab20
movq %rcx, 0x28(%rax)
movl $0x4, -0x4(%rbp)
jmp 0x31f55
movq -0x10(%rbp), %rax
leaq 0x8beb(%rip), %rcx      # 0x3ab20
cmpq %rcx, 0x28(%rax)
jne 0x31f4c
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x31f55
jmp 0x31f4e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x31f9a
movq -0x10(%rbp), %rax
leaq 0x8dd3(%rip), %rcx      # 0x3ad60
movq %rcx, 0x28(%rax)
movl $0x4, -0x4(%rbp)
jmp 0x31fbd
movq -0x10(%rbp), %rax
leaq 0x8dbb(%rip), %rcx      # 0x3ad60
cmpq %rcx, 0x28(%rax)
jne 0x31fb4
movl $0x5, -0x4(%rbp)
jmp 0x31fbd
jmp 0x31fb6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_parse_verb_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x3d(%rax)
movq -0x8(%rbp), %rax
leaq 0x588e(%rip), %rcx      # 0x378b0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0x8f2f(%rip), %rcx      # 0x3af60
movq %rcx, 0x28(%rax)
movl $0x5, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x32072
movq -0x10(%rbp), %rax
leaq 0x911b(%rip), %rcx      # 0x3b180
movq %rcx, 0x28(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x3209f
movq -0x10(%rbp), %rax
leaq 0x9103(%rip), %rcx      # 0x3b180
cmpq %rcx, 0x28(%rax)
jne 0x32096
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x3209f
jmp 0x32098
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x5f, -0x10(%rbp)
jge 0x32171
movq -0x8(%rbp), %rdi
addq $0x1050, %rdi           # imm = 0x1050
imulq $0x18, -0x10(%rbp), %rax
addq %rax, %rdi
callq 0x321a0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x32144
movq -0x8(%rbp), %rdi
addq $0x19c8, %rdi           # imm = 0x19C8
callq 0x11f10
movq -0x8(%rbp), %rdi
addq $0x19d0, %rdi           # imm = 0x19D0
callq 0x11f10
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
decl %eax
subl $0x2, %eax
jb 0x321ca
jmp 0x321be
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x321e5
jmp 0x321c8
jmp 0x32243
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd090
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x32243
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x3221e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xd090
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x321ed
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd090
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x1008(%rcx), %rax
jge 0x322d6
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x322c6
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x28(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x32348
jmp 0x322c8
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x32277
movq -0x10(%rbp), %rax
cmpq $0x100, 0x1008(%rax) # imm = 0x100
jl 0x322ed
movb $0x0, -0x1(%rbp)
jmp 0x32348
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rdx
movq 0x1008(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rdx
movq 0x1008(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x1008(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1008(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1010, %rdi           # imm = 0x1010
callq 0x15790
movq %rax, -0x20(%rbp)
cmpq $0xf, -0x20(%rbp)
jge 0x323a5
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl %edx, 0x1010(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl $0x0, 0x1014(%rax,%rcx,4)
movb $0x1, -0x1(%rbp)
jmp 0x323a9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3385e
movb $0x0, -0x1(%rbp)
jmp 0x338a7
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3389f
callq 0xd700
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x33891
movb $0x0, -0x11(%rbp)
jmp 0x3389f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x33862
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xea70
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movb -0x21(%rbp), %al
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x1, %ecx
leaq -0x10(%rbp), %r8
leaq -0x48(%rbp), %r9
andb $0x1, %al
movq (%r9), %r10
movq %r10, (%rsp)
movq 0x8(%r9), %r9
movq %r9, 0x8(%rsp)
movzbl %al, %r9d
callq 0x110a0
movb $0x1, %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x30(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xea70
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x38(%rbp), %rax
jle 0x33a0a
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x2fdd0
movb $0x1, %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x30(%rbp), %rax
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
addq $0x1050, %rax           # imm = 0x1050
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %edi
callq 0x33a80
movq %rax, %rcx
movq -0x58(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x321a0
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x3e(%rax)
je 0x34d22
movq -0x60(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x40(%rcx), %rdi
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq $-0x1, %rcx
callq 0xfaf0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x60(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x40(%rcx), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movq 0x18(%rax), %r8
callq 0xf510
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x18(%rbp), %rcx
movq 0x40(%rcx), %rdi
movq -0x40(%rbp), %rcx
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x10900
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x30(%rbp), %rax
leaq 0x10(%rbp), %r10
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x30(%rbp), %rax
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x8(%rsp)
movq 0x10(%r10), %r11
movq %r11, 0x10(%rsp)
movq 0x18(%r10), %r10
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x34da0
testb $0x1, %al
jne 0x351ea
movb $0x0, -0x1(%rbp)
jmp 0x35202
movq -0x10(%rbp), %rax
movb $0x1, 0x19d8(%rax)
movq -0x10(%rbp), %rdi
callq 0x2fdd0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x35235
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jl 0x35242
movq $-0x1, -0x8(%rbp)
jmp 0x352c5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xedc0
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xedc0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xd700
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x352b9
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x352bb
jmp 0x352bd
jmp 0x35275
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movb %r8b, %al
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
andb $0x1, %al
movb %al, -0x2d(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xeba0
cmpq $0x0, %rax
jne 0x364eb
movq $-0x1, -0x10(%rbp)
movq $-0x1, -0x8(%rbp)
jmp 0x365d9
testb $0x1, -0x2d(%rbp)
je 0x364ff
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x58(%rbp)
jmp 0x3650b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x38(%rbp), %rsi
callq 0xeca0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3654b
movq $-0x1, -0x10(%rbp)
movq $-0x1, -0x8(%rbp)
jmp 0x365d9
jmp 0x3654d
movq -0x40(%rbp), %rax
cmpb $0x0, (%rax)
je 0x365c9
movq $0x0, -0x48(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xedc0
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x365af
leaq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, -0x2d(%rbp)
je 0x36592
movq -0x38(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x3659a
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x365d9
movq -0x48(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3654d
movq $-0x1, -0x10(%rbp)
movq $-0x1, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movb %r8b, %al
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
andb $0x1, %al
movb %al, -0x2d(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xeba0
cmpq $0x0, %rax
jne 0x3663b
movq $-0x1, -0x10(%rbp)
movq $-0x1, -0x8(%rbp)
jmp 0x36790
cmpq $0x0, -0x20(%rbp)
jne 0x36657
movq $-0x1, -0x10(%rbp)
movq $-0x1, -0x8(%rbp)
jmp 0x36790
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xeca0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x36697
movq $-0x1, -0x10(%rbp)
movq $-0x1, -0x8(%rbp)
jmp 0x36790
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
testb $0x1, -0x2d(%rbp)
je 0x366ee
movq -0x48(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x11c80
movq -0x50(%rbp), %rdx
movq -0x40(%rbp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x366f0
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x36780
movq $0x0, -0x58(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x11c80
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x3675b
leaq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
testb $0x1, -0x2d(%rbp)
je 0x3673e
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x36746
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x36790
movq -0x58(%rbp), %rdx
movq -0x40(%rbp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x366f0
movq $-0x1, -0x10(%rbp)
movq $-0x1, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_normal_mode
bool ce_vim_verb_normal_mode(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){
     vim->mode = CE_VIM_MODE_NORMAL;
     visual->block_top_left = (CePoint_t){0, 0};
     visual->block_bottom_right = (CePoint_t){0, 0};
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x28(%rax)
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_insert_at_soft_begin_line
bool ce_vim_verb_insert_at_soft_begin_line(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 result = ce_vim_soft_begin_line(view->buffer, cursor->y);
     if(result < 0) return false;
     cursor->x = result;
     ce_vim_insert_mode(vim);
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x30(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x35210
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jge 0x377ca
movb $0x0, -0x1(%rbp)
jmp 0x377e2
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2fdd0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: parse_motion_direction
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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x37810
movl $0x1, -0x4(%rbp)
jmp 0x37846
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x37830
movl $0x5, -0x4(%rbp)
jmp 0x37846
movq -0x10(%rbp), %rax
leaq -0x2d7b(%rip), %rcx     # 0x34ac0
movq %rcx, 0x28(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_up
CeVimMotionResult_t ce_vim_motion_up(CeVim_t* vim, CeVimAction_t* action, const CeView_t* view, const CePoint_t* cursor,
                                     CeVimVisualData_t* visual, const CeConfigOptions_t* config_options,
                                     CeVimBufferData_t* buffer_data, CeRange_t* motion_range){
     if(action->verb.function != ce_vim_verb_motion){
          if(motion_range->start.y > 0){
               // we use start instead of end so that we can sort them consistently through a motion multiplier
               motion_range->start.y--;
               motion_range->start.x = 0;
               motion_range->end.x = ce_utf8_last_index(view->buffer->lines[motion_range->end.y]);
               ce_range_sort(motion_range);
          }

          return CE_VIM_MOTION_RESULT_SUCCESS;
     }

     return motion_direction(view, (CePoint_t){0, -1}, config_options, motion_range);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
leaq -0x2e83(%rip), %rcx     # 0x34ac0
cmpq %rcx, 0x28(%rax)
je 0x379a8
movq 0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jle 0x3799f
movq 0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rax
movq 0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xf1f0
movq %rax, %rcx
movq 0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rbp), %rdi
callq 0x12840
movl $0x1, -0x4(%rbp)
jmp 0x379d4
movq -0x20(%rbp), %rdi
movq $0x0, -0x48(%rbp)
movq $-0x1, -0x40(%rbp)
movq -0x38(%rbp), %rcx
movq 0x18(%rbp), %r8
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x3b370
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_down
CeVimMotionResult_t ce_vim_motion_down(CeVim_t* vim, CeVimAction_t* action, const CeView_t* view, const CePoint_t* cursor,
                                       CeVimVisualData_t* visual, const CeConfigOptions_t* config_options,
                                       CeVimBufferData_t* buffer_data, CeRange_t* motion_range){
     if(action->verb.function != ce_vim_verb_motion){
          if(motion_range->end.y < view->buffer->line_count - 1){
               motion_range->end.y++;
               motion_range->end.x = ce_utf8_last_index(view->buffer->lines[motion_range->end.y]);
               motion_range->start.x = 0;
               ce_range_sort(motion_range);
          }
          return CE_VIM_MOTION_RESULT_SUCCESS;
     }

     return motion_direction(view, (CePoint_t){0, 1}, config_options, motion_range);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
leaq -0x2f53(%rip), %rcx     # 0x34ac0
cmpq %rcx, 0x28(%rax)
je 0x37a8a
movq 0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x37a81
movq 0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rax
movq 0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xf1f0
movq %rax, %rcx
movq 0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rbp), %rax
movq $0x0, (%rax)
movq 0x18(%rbp), %rdi
callq 0x12840
movl $0x1, -0x4(%rbp)
jmp 0x37ab6
movq -0x20(%rbp), %rdi
movq $0x0, -0x48(%rbp)
movq $0x1, -0x40(%rbp)
movq -0x38(%rbp), %rcx
movq 0x18(%rbp), %r8
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x3b370
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_little_word
CeVimMotionResult_t ce_vim_motion_little_word(CeVim_t* vim, CeVimAction_t* action, const CeView_t* view, const CePoint_t* cursor,
                                              CeVimVisualData_t* visual, const CeConfigOptions_t* config_options,
                                              CeVimBufferData_t* buffer_data, CeRange_t* motion_range){
     CePoint_t destination = ce_vim_move_little_word(view->buffer, motion_range->end);
     if(destination.x < 0) return CE_VIM_MOTION_RESULT_FAIL;
     motion_range->end = destination;
     action->exclude_end = true;
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
movq 0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x352d0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
cmpq $0x0, -0x48(%rbp)
jge 0x37b19
movl $0x0, -0x4(%rbp)
jmp 0x37b3c
movq 0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x3e(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_big_word
CeVimMotionResult_t ce_vim_motion_big_word(CeVim_t* vim, CeVimAction_t* action, const CeView_t* view, const CePoint_t* cursor,
                                           CeVimVisualData_t* visual, const CeConfigOptions_t* config_options,
                                           CeVimBufferData_t* buffer_data, CeRange_t* motion_range){
     CePoint_t destination = ce_vim_move_big_word(view->buffer, motion_range->end);
     if(destination.x < 0) return CE_VIM_MOTION_RESULT_FAIL;
     motion_range->end = destination;
     action->exclude_end = true;
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
movq 0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x35600
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
cmpq $0x0, -0x48(%rbp)
jge 0x37ba9
movl $0x0, -0x4(%rbp)
jmp 0x37bcc
movq 0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x3e(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_end_little_word
CeVimMotionResult_t ce_vim_motion_end_little_word(CeVim_t* vim, CeVimAction_t* action, const CeView_t* view, const CePoint_t* cursor,
                                                  CeVimVisualData_t* visual, const CeConfigOptions_t* config_options,
                                                  CeVimBufferData_t* buffer_data, CeRange_t* motion_range){
     CePoint_t destination = ce_vim_move_end_little_word(view->buffer, motion_range->end);
     if(destination.x < 0) return CE_VIM_MOTION_RESULT_FAIL;
     motion_range->end = destination;
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
movq 0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x35800
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
cmpq $0x0, -0x48(%rbp)
jge 0x37c39
movl $0x0, -0x4(%rbp)
jmp 0x37c54
movq 0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_end_big_word
CeVimMotionResult_t ce_vim_motion_end_big_word(CeVim_t* vim, CeVimAction_t* action, const CeView_t* view, const CePoint_t* cursor,
                                               CeVimVisualData_t* visual, const CeConfigOptions_t* config_options,
                                               CeVimBufferData_t* buffer_data, CeRange_t* motion_range){
     CePoint_t destination = ce_vim_move_end_big_word(view->buffer, motion_range->end);
     if(destination.x < 0) return CE_VIM_MOTION_RESULT_FAIL;
     motion_range->end = destination;
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
movq 0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x35b80
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
cmpq $0x0, -0x48(%rbp)
jge 0x37cb9
movl $0x0, -0x4(%rbp)
jmp 0x37cd4
movq 0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_begin_little_word
CeVimMotionResult_t ce_vim_motion_begin_little_word(CeVim_t* vim, CeVimAction_t* action, const CeView_t* view, const CePoint_t* cursor,
                                                    CeVimVisualData_t* visual, const CeConfigOptions_t* config_options,
                                                    CeVimBufferData_t* buffer_data, CeRange_t* motion_range){
     CePoint_t destination = ce_vim_move_begin_little_word(view->buffer, motion_range->end);
     if(destination.x < 0) return CE_VIM_MOTION_RESULT_FAIL;
     motion_range->end = destination;
     action->exclude_end = true;
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
movq 0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x35dd0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
cmpq $0x0, -0x48(%rbp)
jge 0x37d39
movl $0x0, -0x4(%rbp)
jmp 0x37d5c
movq 0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x3e(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)