LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movl %r8d, %r13d
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0xe425
testq %rax, %rax
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
pushq $-0x1
popq %rax
je 0x23ebd
movq %rax, %r13
movq %rax, %rbx
jmp 0x23f35
movq (%r14), %rax
movq (%rax,%rbx,8), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xe4a6
testq %rax, %rax
je 0x23f2f
movq %rax, %r15
decq %r15
testb %r13b, %r13b
je 0x23efd
addq $-0x2, %r12
movq %rsp, %rdx
andq $0x0, (%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0xfd39
movq %rsp, %rax
subq (%rax), %r15
jmp 0x23f00
decq %r12
movzbl %r13b, %r13d
addq %r12, %r13
movq %rsp, %r12
cmpq %r14, %r15
jb 0x23f2f
andq $0x0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xfd39
cmpl %ebp, %eax
je 0x23f35
subq (%rsp), %r15
decq %r13
jmp 0x23f0a
pushq $-0x1
popq %rbx
movq %rbx, %r13
movq %r13, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_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, %r14
movq %rdx, %r13
movq %rdi, %rbx
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%rdi)
movdqu %xmm0, (%rdi)
movq (%rsi), %rax
movq (%rax,%rcx,8), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0xe4a6
movq %rax, %r12
movb (%rax), %bpl
movsbl %bpl, %edi
callq 0x23570
testb %al, %al
je 0x2402a
movq %rbx, 0x8(%rsp)
movq %r14, 0x10(%rsp)
leaq -0x1(%r13), %r14
movq %r12, %rbx
testb %bpl, %bpl
je 0x23fd8
andq $0x0, (%rsp)
movq %rbx, %rdi
movq %rsp, %rsi
callq 0xe53f
movl %eax, %edi
callq 0x23570
testb %al, %al
je 0x23fd8
movq (%rsp), %rax
movb (%rbx,%rax), %bpl
addq %rax, %rbx
incq %r14
jmp 0x23fa8
incq %r13
movq %rsp, %rbx
movq %r13, %rbp
cmpq %r15, %r12
jb 0x2400c
andq $0x0, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xfd39
movl %eax, %edi
callq 0x23570
leaq -0x1(%rbp), %r13
subq (%rsp), %r12
testb %al, %al
jne 0x23fde
cmpq %r14, %rbp
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rbx
jg 0x2402a
movq %rbp, (%rbx)
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_find_string_boundaries
CeRange_t ce_vim_find_string_boundaries(CeBuffer_t* buffer, CePoint_t start, char string_char){
     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;
     int64_t rune_len = 0;

     CeRune_t previous_rune = CE_UTF8_INVALID;
     int64_t end_x = start.x;
     while(*itr){
          CeRune_t rune = ce_utf8_decode(itr, &rune_len);
          if(rune == string_char && previous_rune != '\\') break;
          previous_rune = rune;
          end_x++;
          itr += rune_len;
     }

     if(!(*itr)) end_x = -1;

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

     if(itr == line_start) start_x = -1;

     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 $0x38, %rsp
movl %r8d, 0xc(%rsp)
movq %rdx, %r15
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%rdi)
movq %rdi, 0x30(%rsp)
movdqu %xmm0, (%rdi)
movq (%rsi), %rax
movq %rcx, 0x28(%rsp)
movq (%rax,%rcx,8), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0xe4a6
movq %rax, %r14
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
pushq $-0x1
popq %rbp
pushq $-0x1
popq %rax
movq %rax, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, %r13
cmpb $0x0, (%r13)
je 0x241fb
movq %r13, %rdi
movq %rbx, %rsi
callq 0xe53f
cmpl 0xc(%rsp), %eax
setne %cl
cmpl $0x5c, %ebp
sete %dl
orb %cl, %dl
je 0x241e9
incq %r15
addq 0x10(%rsp), %r13
movl %eax, %ebp
jmp 0x241ba
xorl %eax, %eax
cmpb $0x1, (%r13)
sbbq %rax, %rax
orq %r15, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
leaq 0x1(%rax), %r15
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0xfd39
movl %eax, %ebx
movq %r14, %r13
movq %r15, %rbp
cmpq %r12, %r14
jbe 0x24261
movq %r13, %rdi
movq %r12, %rsi
leaq 0x10(%rsp), %rdx
callq 0xfd39
cmpl 0xc(%rsp), %ebx
sete %cl
cmpl $0x5c, %eax
setne %dl
cmpq 0x20(%rsp), %rbp
setl %sil
andb %cl, %sil
andb %dl, %sil
leaq -0x1(%rbp), %r15
movq %r13, %r14
subq 0x10(%rsp), %r14
movl %eax, %ebx
cmpb $0x1, %sil
jne 0x24216
cmpq %r12, %r13
pushq $-0x1
popq %rax
cmoveq %rax, %rbp
movq 0x18(%rsp), %rdx
cmpq %rdx, %rbp
movq 0x30(%rsp), %rax
jg 0x2428e
movq %rbp, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: point_in_string_or_comment
static bool point_in_string_or_comment(CeBuffer_t* buffer, CePoint_t point){
     if(!ce_buffer_contains_point(buffer, point)) return false;
     CeRune_t in_string = 0;
     CeRune_t in_comment = 0;
     CeRune_t prev_rune = 0;
     CeRune_t prev_prev_rune = 0;
     char* str = buffer->lines[point.y];
     int64_t rune_len;
     for(int64_t i = 0; i <= point.x; i++){
          CeRune_t rune = ce_utf8_decode(str, &rune_len);
          switch(rune){
          default:
               break;
          case '/':
               if(prev_rune == rune && !in_string){
                    in_comment = true;
               }else if(in_comment && prev_rune == '/'){
                    in_comment = false;
               }
               break;
          case '*':
               if(prev_rune == '/' && !in_string){
                    in_comment = true;
               }
               break;
          case '"':
          case '\'':
               if(in_string == rune){
                    if(prev_rune != '\\'){
                         in_string = 0;
                    // handle case where backslash getting backslashed
                    }else if(prev_prev_rune == '\\'){
                         in_string = 0;
                    }
               }else if(in_string == 0){
                    in_string = rune;
               }
               break;
          }
          prev_prev_rune = prev_rune;
          prev_rune = rune;
          str += rune_len;
     }

     return in_string || in_comment;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
callq 0xe34d
xorl %ecx, %ecx
testb %al, %al
je 0x24794
movq (%r12), %rax
movq (%rax,%r15,8), %r15
xorl %r13d, %r13d
movl $0x0, 0xc(%rsp)
xorl %eax, %eax
xorl %ebp, %ebp
xorl %r12d, %r12d
cmpq %rbx, %r12
jg 0x2478c
movl %ebp, %r14d
movl %eax, %ebp
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0xe53f
cmpl $0x22, %eax
je 0x24731
cmpl $0x27, %eax
je 0x24731
cmpl $0x2a, %eax
je 0x24753
cmpl $0x2f, %eax
jne 0x2477f
cmpl $0x2f, %ebp
jne 0x2476c
testl %r13d, %r13d
jne 0x2476c
xorl %r13d, %r13d
pushq $0x1
popq %rcx
movl %ecx, 0xc(%rsp)
jmp 0x2477f
cmpl %eax, %r13d
jne 0x2474a
cmpl $0x5c, %ebp
jne 0x24767
cmpl $0x5c, %r14d
movl $0x0, %ecx
cmovel %ecx, %r13d
jmp 0x2477f
testl %r13d, %r13d
cmovel %eax, %r13d
jmp 0x2477f
movl %ebp, %ecx
xorl $0x2f, %ecx
orl %r13d, %ecx
pushq $0x1
popq %rcx
movl 0xc(%rsp), %edx
cmovel %ecx, %edx
jmp 0x2477b
xorl %r13d, %r13d
jmp 0x2477f
cmpl $0x2f, %ebp
movl $0x0, %ecx
movl 0xc(%rsp), %edx
cmovel %ecx, %edx
movl %edx, 0xc(%rsp)
addq 0x10(%rsp), %r15
incq %r12
jmp 0x246ec
orl 0xc(%rsp), %r13d
setne %cl
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
movq 0x40(%rdx), %rdi
movq 0x8(%rcx), %rsi
callq 0x23364
movq %rax, %r15
testq %rax, %rax
js 0x24826
movq %r15, (%r14)
movq %rbx, %rdi
callq 0x205ac
testq %r15, %r15
setns %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x18(%rsp), %rbx
leaq -0x1960(%rip), %rax     # 0x22f09
cmpq %rax, 0x28(%rsi)
je 0x248a8
movq 0x8(%rbx), %rax
testq %rax, %rax
jle 0x248a3
decq %rax
movq %rax, 0x8(%rbx)
andq $0x0, (%rbx)
movq 0x40(%rdx), %rax
movq (%rax), %rax
movq 0x18(%rbx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xe784
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x1021f
pushq $0x1
popq %rax
popq %rbx
retq
pushq $-0x1
popq %rax
movq %rdx, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r9, %rcx
movq %rbx, %r8
popq %rbx
jmp 0x2649c
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x18(%rsp), %rbx
leaq -0x19c3(%rip), %rax     # 0x22f09
cmpq %rax, 0x28(%rsi)
je 0x24910
movq 0x18(%rbx), %rax
movq 0x40(%rdx), %rcx
movq 0x8(%rcx), %rdx
decq %rdx
cmpq %rdx, %rax
jge 0x2490b
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%rbx)
movq (%rcx), %rcx
movq 0x8(%rcx,%rax,8), %rdi
callq 0xe784
movq %rax, 0x10(%rbx)
andq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x1021f
pushq $0x1
popq %rax
popq %rbx
retq
pushq $0x1
popq %rax
movq %rdx, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r9, %rcx
movq %rbx, %r8
popq %rbx
jmp 0x2649c
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rsp), %r14
movq 0x40(%rdx), %rdi
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
callq 0x233ca
testq %rax, %rax
js 0x2495a
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
pushq $0x1
popq %rax
jmp 0x2495c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rsp), %r14
movq 0x40(%rdx), %rdi
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
callq 0x23591
testq %rax, %rax
js 0x24997
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
pushq $0x1
popq %rax
jmp 0x24999
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x18(%rsp), %rbx
movq 0x40(%rdx), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
callq 0x236d6
testq %rax, %rax
js 0x249ca
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
pushq $0x1
popq %rax
jmp 0x249cc
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x18(%rsp), %rbx
movq 0x40(%rdx), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
callq 0x23909
testq %rax, %rax
js 0x249f7
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
pushq $0x1
popq %rax
jmp 0x249f9
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rsp), %r14
movq 0x40(%rdx), %rdi
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
callq 0x23a32
testq %rax, %rax
js 0x24a2e
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
pushq $0x1
popq %rax
jmp 0x24a30
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_begin_big_word
CeVimMotionResult_t ce_vim_motion_begin_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_begin_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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rsp), %r14
movq 0x40(%rdx), %rdi
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
callq 0x23c2d
testq %rax, %rax
js 0x24a6b
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
pushq $0x1
popq %rax
jmp 0x24a6d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_soft_begin_line
CeVimMotionResult_t ce_vim_motion_soft_begin_line(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){
     int64_t result = ce_vim_soft_begin_line(view->buffer, motion_range->end.y);
     if(result < 0) return CE_VIM_MOTION_RESULT_FAIL;
     motion_range->end.x = result;
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbx
movq 0x18(%rsp), %rbx
movq 0x40(%rdx), %rdi
movq 0x18(%rbx), %rsi
callq 0x23364
testq %rax, %rax
js 0x24a96
movq %rax, 0x10(%rbx)
pushq $0x1
popq %rax
jmp 0x24a98
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: vim_parse_motion_find
static CeVimParseResult_t vim_parse_motion_find(CeVimAction_t* action, CeRune_t key, CeVimMotionFunc_t* func){
     if(action->verb.function == NULL) action->verb.function = &ce_vim_verb_motion;

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

     return CE_VIM_PARSE_INVALID;
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
jne 0x24b6c
leaq -0x1c5f(%rip), %rax     # 0x22f09
movq %rax, 0x28(%rdi)
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x24b7d
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x24b85
retq
movq %rdx, 0x10(%rdi)
pushq $0x2
jmp 0x24b8a
movl %esi, 0x18(%rdi)
pushq $0x5
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_find_forward
CeVimMotionResult_t ce_vim_motion_find_forward(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 new_position = ce_vim_move_find_rune_forward(view->buffer, motion_range->end, action->motion.integer, false);
     if(new_position.x < 0) return CE_VIM_MOTION_RESULT_FAIL;
     motion_range->end = new_position;
     vim->find_char.rune = action->motion.integer;
     vim->find_char.state = CE_VIM_FIND_CHAR_STATE_FIND_FORWARD;
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsp), %r15
movq 0x40(%rdx), %rdi
movl 0x18(%rsi), %ecx
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
xorl %ebp, %ebp
xorl %r8d, %r8d
callq 0x23de0
testq %rax, %rax
js 0x24bd8
movq %rax, 0x10(%r15)
movq %rdx, 0x18(%r15)
movl 0x18(%r14), %eax
movl %eax, 0x19e0(%rbx)
andl $0x0, 0x19e4(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_find_backward
CeVimMotionResult_t ce_vim_motion_find_backward(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 new_position = ce_vim_move_find_rune_backward(view->buffer, motion_range->end, action->motion.integer, false);
     if(new_position.x < 0) return CE_VIM_MOTION_RESULT_FAIL;
     motion_range->end = new_position;
     vim->find_char.rune = action->motion.integer;
     vim->find_char.state = CE_VIM_FIND_CHAR_STATE_FIND_BACKWARD;
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsp), %r15
movq 0x40(%rdx), %rdi
movl 0x18(%rsi), %ecx
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
xorl %ebp, %ebp
xorl %r8d, %r8d
callq 0x23e84
testq %rax, %rax
js 0x24c34
movq %rax, 0x10(%r15)
movq %rdx, 0x18(%r15)
movl 0x18(%r14), %eax
movl %eax, 0x19e0(%rbx)
movl $0x1, 0x19e4(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_until_forward
CeVimMotionResult_t ce_vim_motion_until_forward(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 new_position = ce_vim_move_find_rune_forward(view->buffer, motion_range->end, action->motion.integer, true);
     if(new_position.x < 0) return CE_VIM_MOTION_RESULT_FAIL;
     motion_range->end = new_position;
     vim->find_char.rune = action->motion.integer;
     vim->find_char.state = CE_VIM_FIND_CHAR_STATE_UNTIL_FORWARD;
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsp), %r15
movq 0x40(%rdx), %rdi
movl 0x18(%rsi), %ecx
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
pushq $0x1
popq %rbp
movl %ebp, %r8d
callq 0x23de0
testq %rax, %rax
js 0x24c90
movq %rax, 0x10(%r15)
movq %rdx, 0x18(%r15)
movl 0x18(%r14), %eax
movl %eax, 0x19e0(%rbx)
movl $0x2, 0x19e4(%rbx)
jmp 0x24c92
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_until_backward
CeVimMotionResult_t ce_vim_motion_until_backward(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 new_position = ce_vim_move_find_rune_backward(view->buffer, motion_range->end, action->motion.integer, true);
     if(new_position.x < 0) return CE_VIM_MOTION_RESULT_FAIL;
     motion_range->end = new_position;
     vim->find_char.rune = action->motion.integer;
     vim->find_char.state = CE_VIM_FIND_CHAR_STATE_UNTIL_BACKWARD;
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsp), %r15
movq 0x40(%rdx), %rdi
movl 0x18(%rsi), %ecx
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
pushq $0x1
popq %rbp
movl %ebp, %r8d
callq 0x23e84
testq %rax, %rax
js 0x24cee
movq %rax, 0x10(%r15)
movq %rdx, 0x18(%r15)
movl 0x18(%r14), %eax
movl %eax, 0x19e0(%rbx)
movl $0x3, 0x19e4(%rbx)
jmp 0x24cf0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_next_find_char
CeVimMotionResult_t ce_vim_motion_next_find_char(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 new_position = motion_range->end;

     switch(vim->find_char.state){
     default:
          break;
     case CE_VIM_FIND_CHAR_STATE_FIND_FORWARD:
          new_position = ce_vim_move_find_rune_forward(view->buffer, motion_range->end, vim->find_char.rune, false);
          break;
     case CE_VIM_FIND_CHAR_STATE_FIND_BACKWARD:
          new_position = ce_vim_move_find_rune_backward(view->buffer, motion_range->end, vim->find_char.rune, false);
          break;
     case CE_VIM_FIND_CHAR_STATE_UNTIL_FORWARD:
          new_position = ce_vim_move_find_rune_forward(view->buffer, motion_range->end, vim->find_char.rune, true);
          break;
     case CE_VIM_FIND_CHAR_STATE_UNTIL_BACKWARD:
          new_position = ce_vim_move_find_rune_backward(view->buffer, motion_range->end, vim->find_char.rune, true);
          break;
     }

     if(new_position.x < 0) return CE_VIM_MOTION_RESULT_FAIL;
     motion_range->end = new_position;
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq 0x18(%rsp), %rbx
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rdx
movl 0x19e4(%rdi), %esi
cmpq $0x3, %rsi
ja 0x24d88
leaq 0x84d7(%rip), %r8       # 0x2d1f8
movslq (%r8,%rsi,4), %rsi
addq %r8, %rsi
jmpq *%rsi
movq 0x40(%rcx), %rsi
movl 0x19e0(%rdi), %ecx
movq %rsi, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
jmp 0x24d53
movq 0x40(%rcx), %rsi
movl 0x19e0(%rdi), %ecx
pushq $0x1
popq %r8
movq %rsi, %rdi
movq %rax, %rsi
callq 0x23de0
jmp 0x24d88
movq 0x40(%rcx), %rsi
movl 0x19e0(%rdi), %ecx
pushq $0x1
popq %r8
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x24d83
movq 0x40(%rcx), %rsi
movl 0x19e0(%rdi), %ecx
movq %rsi, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0x23e84
testq %rax, %rax
js 0x24d9a
pushq $0x1
popq %rcx
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
jmp 0x24d9c
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_match_pair
CeVimMotionResult_t ce_vim_motion_match_pair(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){
     CeRune_t rune = ce_buffer_get_rune(view->buffer, *cursor);
     CeRange_t result = ce_vim_find_pair(view->buffer, *cursor, rune, false, 0);
     if(result.start.x < 0) return CE_VIM_MOTION_RESULT_FAIL;
     if(ce_points_equal(motion_range->end, result.start)){
          motion_range->end = result.end;
          return CE_VIM_MOTION_RESULT_SUCCESS;
     }else if(ce_points_equal(motion_range->end, result.end)){
          motion_range->end = result.start;
          return CE_VIM_MOTION_RESULT_SUCCESS;
     }

     return CE_VIM_MOTION_RESULT_FAIL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq 0x40(%rdx), %rdi
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
callq 0xe45f
movq 0x40(%r14), %rsi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
andl $0x0, (%rsp)
leaq 0x10(%rsp), %rbx
xorl %ebp, %ebp
movq %rbx, %rdi
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x2429d
movq (%rbx), %rdx
testq %rdx, %rdx
js 0x2526d
movq 0x58(%rsp), %r14
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movq 0x18(%rsp), %rcx
callq 0xedb2
testb %al, %al
je 0x25244
leaq 0x20(%rsp), %rbx
jmp 0x2525f
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0xedb2
testb %al, %al
je 0x2526d
addq $0x10, %r14
movups (%rbx), %xmm0
movups %xmm0, (%r14)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_mark
CeVimMotionResult_t ce_vim_motion_mark(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 = buffer_data->marks + ce_vim_register_index(action->motion.integer);
     // TODO: come up with better method of determining if a destination is set or not
     if(destination->x != 0 || destination->y != 0){
          motion_range->end = *destination;
          motion_range->end = ce_buffer_clamp_point(view->buffer, motion_range->end, CE_CLAMP_X_INSIDE);
          return CE_VIM_MOTION_RESULT_SUCCESS;
     }

     return CE_VIM_MOTION_RESULT_FAIL;
}

// Assembly:
pushq %rbx
movq 0x10(%rsp), %rcx
movl 0x18(%rsi), %eax
leal -0x7f(%rax), %esi
addl $-0x20, %eax
cmpl $-0x5f, %esi
pushq $-0x1
popq %rsi
cmovaeq %rax, %rsi
shlq $0x4, %rsi
leaq (%rcx,%rsi), %rax
cmpq $0x0, (%rcx,%rsi)
jne 0x25328
cmpq $0x0, 0x8(%rax)
je 0x25355
movq 0x18(%rsp), %rbx
movups (%rax), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x40(%rdx), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
pushq $0x2
popq %rcx
callq 0xecee
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
xorl %eax, %eax
jmp 0x25353
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_mark_soft_begin_line
CeVimMotionResult_t ce_vim_motion_mark_soft_begin_line(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 = buffer_data->marks + ce_vim_register_index(action->motion.integer);
     // TODO: come up with better method of determining if a destination is set or not
     if(destination->x != 0 || destination->y != 0){
          motion_range->end = *destination;
          motion_range->end = ce_buffer_clamp_point(view->buffer, motion_range->end, CE_CLAMP_X_INSIDE);
          motion_range->end.x = ce_vim_soft_begin_line(view->buffer, motion_range->end.y);
          return CE_VIM_MOTION_RESULT_SUCCESS;
     }

     return CE_VIM_MOTION_RESULT_FAIL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x20(%rsp), %rcx
movl 0x18(%rsi), %eax
leal -0x7f(%rax), %edx
addl $-0x20, %eax
cmpl $-0x5f, %edx
pushq $-0x1
popq %rdx
cmovaeq %rax, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
cmpq $0x0, (%rcx,%rdx)
jne 0x2538e
cmpq $0x0, 0x8(%rax)
je 0x253d2
movq 0x28(%rsp), %r14
movups (%rax), %xmm0
movups %xmm0, 0x10(%r14)
movq 0x40(%rbx), %rdi
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
pushq $0x2
popq %rcx
callq 0xecee
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq 0x40(%rbx), %rdi
movq %rdx, %rsi
callq 0x23364
movq %rax, 0x10(%r14)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x253ca
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_middle_of_view
CeVimMotionResult_t ce_vim_motion_middle_of_view(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){
     int64_t view_height = view->rect.bottom - view->rect.top;
     motion_range->end = (CePoint_t){motion_range->start.x, view->scroll.y + (view_height / 2)};
     motion_range->end = ce_buffer_clamp_point(view->buffer, motion_range->end, CE_CLAMP_X_INSIDE);
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq 0x18(%rsp), %rbx
movq 0x18(%rdx), %rax
subq 0x10(%rdx), %rax
movq (%rbx), %rsi
pushq $0x2
popq %rdi
cqto
idivq %rdi
addq 0x28(%rcx), %rax
movq %rsi, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq 0x40(%rcx), %rdi
pushq $0x2
popq %rcx
movq %rax, %rdx
callq 0xecee
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_bottom_of_view
CeVimMotionResult_t ce_vim_motion_bottom_of_view(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){
     int64_t view_height = view->rect.bottom - view->rect.top;
     motion_range->end = (CePoint_t){motion_range->start.x, view->scroll.y + (view_height - config_options->vertical_scroll_off)};
     motion_range->end = ce_buffer_clamp_point(view->buffer, motion_range->end, CE_CLAMP_X_INSIDE);
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbx
movq 0x18(%rsp), %rbx
movq 0x10(%rdx), %rcx
movq 0x18(%rdx), %rax
movq (%rbx), %rsi
addq 0x28(%rdx), %rax
addq 0x18(%r9), %rcx
subq %rcx, %rax
movq %rsi, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq 0x40(%rdx), %rdi
pushq $0x2
popq %rcx
movq %rax, %rdx
callq 0xecee
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_next_blank_line
CeVimMotionResult_t ce_vim_motion_next_blank_line(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){
     bool start_blank = string_is_blank(view->buffer->lines[motion_range->end.y]);
     for(int64_t y = motion_range->end.y + 1; y < view->buffer->line_count; y++){
          bool current_blank = string_is_blank(view->buffer->lines[y]);
          if(current_blank){
               if(!start_blank){
                    motion_range->end = (CePoint_t){0, y};
                    break;
               }
          }else{
               start_blank = false;
          }
     }
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x48(%rsp), %r14
movq 0x40(%rdx), %r12
movq (%r12), %r15
movq 0x18(%r14), %rbp
movq (%r15,%rbp,8), %rdi
callq 0x26661
movl %eax, %ebx
movq 0x8(%r12), %r12
leaq 0x1(%rbp), %r13
cmpq %r12, %r13
jge 0x254e7
movq 0x8(%r15,%rbp,8), %rdi
callq 0x26661
movl %eax, %ecx
notb %cl
orb %bl, %cl
andb %al, %bl
movq %r13, %rbp
testb $0x1, %cl
jne 0x254bb
andq $0x0, 0x10(%r14)
movq %r13, 0x18(%r14)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_previous_blank_line
CeVimMotionResult_t ce_vim_motion_previous_blank_line(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){
     bool start_blank = string_is_blank(view->buffer->lines[motion_range->end.y]);
     for(int64_t y = motion_range->end.y - 1; y >= 0; y--){
          bool current_blank = string_is_blank(view->buffer->lines[y]);
          if(current_blank){
               if(!start_blank){
                    motion_range->end = (CePoint_t){0, y};
                    break;
               }
          }else{
               start_blank = false;
          }
     }
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x38(%rsp), %r14
movq 0x40(%rdx), %rax
movq (%rax), %r12
movq 0x18(%r14), %r15
movq (%r12,%r15,8), %rdi
callq 0x26661
movl %eax, %ebx
testq %r15, %r15
jle 0x25544
movq -0x8(%r12,%r15,8), %rdi
decq %r15
callq 0x26661
movl %eax, %ecx
notb %cl
orb %bl, %cl
andb %al, %bl
testb $0x1, %cl
jne 0x2551c
andq $0x0, 0x10(%r14)
movq %r15, 0x18(%r14)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_next_zero_indentation_line
CeVimMotionResult_t ce_vim_motion_next_zero_indentation_line(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){
     CeAppBufferData_t* buffer_app_data = view->buffer->app_data;
     for(int64_t y = motion_range->end.y + 1; y < view->buffer->line_count; y++){
          if(ce_utf8_strlen(view->buffer->lines[y]) == 0) continue;
          if(buffer_app_data->syntax_function == ce_syntax_highlight_c ||
             buffer_app_data->syntax_function == ce_syntax_highlight_cpp){
               if(view->buffer->lines[y][0] == '#' ||
                  view->buffer->lines[y][0] == '/'){
                    continue;
               }
          }

          if(_is_print((int)(view->buffer->lines[y][0])) && !isspace((int)(view->buffer->lines[y][0])) && strchr(view->buffer->lines[y], '(')){
               motion_range->end = (CePoint_t){0, y};
               return CE_VIM_MOTION_RESULT_SUCCESS;
          }
     }
     return CE_VIM_MOTION_RESULT_FAIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x48(%rsp), %rax
movq 0x40(%rdx), %r15
movq 0x58(%r15), %rcx
movq %rcx, (%rsp)
movq 0x18(%rax), %r12
incq %r12
movq 0x8(%r15), %rbp
cmpq %rbp, %r12
jge 0x2560f
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0xe38c
movq 0x40(%rbx), %r15
testq %rax, %rax
je 0x25576
movq (%rsp), %rax
movq 0x600(%rax), %rax
cmpq 0x139b3(%rip), %rax     # 0x38f60
setne %cl
cmpq 0x139a1(%rip), %rax     # 0x38f58
setne %al
movq (%r15), %rdx
movq (%rdx,%r12,8), %r14
movzbl (%r14), %r13d
testb %al, %cl
jne 0x255d5
cmpq $0x2f, %r13
je 0x25576
cmpl $0x23, %r13d
je 0x25576
leal -0x20(%r13), %eax
cmpb $0x5e, %al
ja 0x25576
callq 0xd720
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
jne 0x25576
movq %r14, %rdi
pushq $0x28
popq %rsi
callq 0xd230
testq %rax, %rax
je 0x25576
movq 0x48(%rsp), %rax
andq $0x0, 0x10(%rax)
movq %r12, 0x18(%rax)
xorl %eax, %eax
cmpq %rbp, %r12
setl %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_motion_entire_line
CeVimMotionResult_t ce_vim_motion_entire_line(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){
     int64_t line_length = ce_utf8_strlen(view->buffer->lines[motion_range->end.y]);
     motion_range->start = (CePoint_t){0, motion_range->end.y};
     motion_range->end = (CePoint_t){line_length, motion_range->end.y};
     return CE_VIM_MOTION_RESULT_SUCCESS;
}

// Assembly:
pushq %rbx
movq 0x18(%rsp), %rbx
movq 0x40(%rdx), %rax
movq (%rax), %rax
movq 0x18(%rbx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xe38c
movq 0x18(%rbx), %rcx
andq $0x0, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_substitute_soft_begin_line
bool ce_vim_verb_substitute_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 soft_begin_index = ce_vim_soft_begin_line(view->buffer, cursor->y);
     if(soft_begin_index < 0) return false;

     cursor->x = soft_begin_index;
     motion_range.start = *cursor;
     motion_range.end.x = ce_utf8_last_index(view->buffer->lines[motion_range.end.y]);

     // if the line is empty, just enter insert mode
     if(motion_range.end.x == 0){
          ce_vim_insert_mode(vim);
          return true;
     }

     bool success = ce_vim_verb_change(vim, action, motion_range, view, cursor, visual, buffer_data, config_options);
     if(success){
          vim->chain_undo = true;
          ce_vim_insert_mode(vim);
     }
     return success;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x40(%rdx), %rdi
movq 0x8(%rcx), %rsi
callq 0x23364
testq %rax, %rax
js 0x257bc
leaq 0x60(%rsp), %r13
movq %rax, (%r14)
movq (%r14), %rax
movq %rax, (%r13)
movq 0x8(%r14), %rax
movq %rax, 0x8(%r13)
movq 0x40(%r15), %rax
movq (%rax), %rax
movq 0x18(%r13), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xe784
movq %rax, 0x10(%r13)
testq %rax, %rax
je 0x257b0
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x23325
testb %al, %al
je 0x257bc
movb $0x1, 0x19d8(%rbx)
movq %rbx, %rdi
callq 0x205ac
movb $0x1, %al
jmp 0x257be
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_set_character
bool ce_vim_verb_set_character(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){
     ce_range_sort(&motion_range);

     bool chain_undo = false;
     while(!ce_point_after(motion_range.start, motion_range.end)){
          // do nothing if we aren't on the buffer, or the line is empty
          if(!ce_buffer_contains_point(view->buffer, motion_range.start)){
               motion_range.start = ce_buffer_advance_point(view->buffer, motion_range.start, 1);
               continue;
          }else if(view->buffer->lines[motion_range.start.y][0] == 0){
               motion_range.start = ce_buffer_advance_point(view->buffer, motion_range.start, 1);
               continue;
          }

          if(!change_character(view, cursor, motion_range.start, action->verb.integer, chain_undo)) return false;

          motion_range.start = ce_buffer_advance_point(view->buffer, motion_range.start, 1);
          if(motion_range.start.x == -1) return false;
          chain_undo = true;
     }

     return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x1021f
movq (%r12), %rdi
movq 0x8(%r12), %rsi
xorl %ebx, %ebx
pushq $0x1
popq %r13
movq 0x10(%r12), %rdx
movq 0x18(%r12), %rcx
callq 0xea69
movl %eax, %ebp
testb %al, %al
jne 0x258b1
movq 0x40(%r14), %rdi
movq (%r12), %rsi
movq 0x8(%r12), %rdx
callq 0xe34d
movq 0x40(%r14), %rdi
movq 0x8(%r12), %rcx
testb %al, %al
je 0x25841
movq (%rdi), %rax
movq (%rax,%rcx,8), %rax
cmpb $0x0, (%rax)
jne 0x25861
movq (%r12), %rsi
movq %rcx, %rdx
movq %r13, %rcx
callq 0xec3a
movq %rax, %rdi
movq %rdx, %rsi
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
jmp 0x257fd
movl 0x30(%r15), %r8d
movq (%r12), %rdx
movzbl %bl, %r9d
andl $0x1, %r9d
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x26691
testb %al, %al
je 0x258b1
movq 0x40(%r14), %rdi
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rcx
callq 0xec3a
movq %rax, %rdi
movq %rdx, %rsi
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
movb $0x1, %bl
cmpq $-0x1, %rax
jne 0x257fd
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq