LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movl %r8d, %ebp
movq %rdx, %r15
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%rdi)
movq %rdi, 0x20(%rsp)
movdqu %xmm0, (%rdi)
movq (%rsi), %rax
movq %rcx, 0x8(%rsp)
movq (%rax,%rcx,8), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0xe5be
movq %rax, %r13
movq %rsp, %rax
movq $0x0, (%rax)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movq %r15, 0x18(%rsp)
movq %r13, %rbx
cmpb $0x0, (%rbx)
je 0x270b4
movq %rbx, %rdi
movq %rsp, %rsi
callq 0xe649
cmpl %ebp, %eax
setne %dl
cmpl $0x5c, %r14d
sete %cl
orb %dl, %cl
je 0x270a1
movq (%rsp), %rdx
jmp 0x270a3
xorl %edx, %edx
movzbl %cl, %ecx
addq %rcx, %r15
addq %rdx, %rbx
testb %cl, %cl
cmovnel %eax, %r14d
jne 0x2707b
cmpb $0x1, (%rbx)
movl $0x0, %eax
sbbq %rax, %rax
orq %r15, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %r15
leaq 0x1(%r15), %rbx
movq %rsp, %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x1025d
movl %eax, %r14d
movsbl %bpl, %ebp
cmpq %r12, %r13
jbe 0x27133
movq %r13, %rdi
movq %r12, %rsi
movq %rsp, %rdx
callq 0x1025d
cmpl %ebp, %r14d
setne %cl
cmpl $0x5c, %eax
sete %dl
cmpq %r15, %rbx
setge %sil
orb %cl, %sil
orb %dl, %sil
xorl %ecx, %ecx
subq (%rsp), %rcx
movzbl %sil, %edx
subq %rdx, %rbx
testb %dl, %dl
movl $0x0, %esi
cmoveq %rsi, %rcx
addq %rcx, %r13
movl %eax, %r14d
testb %dl, %dl
jne 0x270e5
cmpq %r12, %r13
movq $-0x1, %rcx
cmovneq %rbx, %rcx
movq 0x10(%rsp), %rdx
cmpq %rdx, %rcx
movq 0x20(%rsp), %rax
jg 0x27164
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_vim.c
// Function: 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
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
callq 0xe446
testb %al, %al
je 0x27690
xorl %eax, %eax
testq %r14, %r14
js 0x27692
movq (%r12), %rax
movq (%rax,%r15,8), %r15
incq %r14
xorl %r13d, %r13d
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %ebx, %ebx
movq %r15, %rdi
movq %rsp, %rsi
callq 0xe649
cmpl $0x29, %eax
jg 0x27633
cmpl $0x22, %eax
je 0x2761b
cmpl $0x27, %eax
jne 0x27676
cmpl %eax, %ebx
jne 0x27650
cmpl $0x5c, %r12d
jne 0x27674
cmpl $0x5c, %r13d
movl $0x0, %ecx
cmovel %ecx, %ebx
jmp 0x27676
cmpl $0x2a, %eax
je 0x27657
cmpl $0x2f, %eax
jne 0x27676
cmpl $0x2f, %r12d
jne 0x27666
testl %ebx, %ebx
jne 0x27666
xorl %ebx, %ebx
movl $0x1, %ebp
jmp 0x27676
testl %ebx, %ebx
cmovel %eax, %ebx
jmp 0x27676
movl %r12d, %ecx
xorl $0x2f, %ecx
orl %ebx, %ecx
movl $0x1, %ecx
jmp 0x2766f
cmpl $0x2f, %r12d
movl $0x0, %ecx
cmovel %ecx, %ebp
jmp 0x27676
xorl %ebx, %ebx
addq (%rsp), %r15
movl %r12d, %r13d
movl %eax, %r12d
decq %r14
jne 0x27601
orl %ebp, %ebx
setne %al
jmp 0x27692
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_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, %r15
movq %rdi, %rbx
movq 0x40(%rdx), %rdi
movq 0x8(%rcx), %rsi
callq 0x260e5
movq %rax, %r14
testq %rax, %rax
js 0x2773b
movq %r14, (%r15)
movl $0x1, (%rbx)
cmpb $0x0, 0x19d9(%rbx)
jne 0x2773b
addq $0x19c8, %rbx           # imm = 0x19C8
movq %rbx, %rdi
callq 0x10370
testq %r14, %r14
setns %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 -0x1b53(%rip), %rax     # 0x25c31
cmpq %rax, 0x28(%rsi)
je 0x277c8
movq 0x8(%rbx), %rax
testq %rax, %rax
jle 0x277c1
decq %rax
movq %rax, 0x8(%rbx)
movq $0x0, (%rbx)
movq 0x40(%rdx), %rax
movq (%rax), %rax
movq 0x18(%rbx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xe97d
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x1079c
movl $0x1, %eax
popq %rbx
retq
movq %rdx, %rdi
xorl %esi, %esi
movq $-0x1, %rdx
movq %r9, %rcx
movq %rbx, %r8
popq %rbx
jmp 0x2962a
// File: /workspace/github_c_makefile_star2_O1/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 %rdx, %rdi
movq 0x18(%rsp), %rbx
leaq -0x1bbf(%rip), %rax     # 0x25c31
cmpq %rax, 0x28(%rsi)
je 0x27839
movq 0x18(%rbx), %rax
movq 0x40(%rdi), %rcx
movq 0x8(%rcx), %rdx
decq %rdx
cmpq %rdx, %rax
jge 0x27832
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%rbx)
movq (%rcx), %rcx
movq 0x8(%rcx,%rax,8), %rdi
callq 0xe97d
movq %rax, 0x10(%rbx)
movq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x1079c
movl $0x1, %eax
popq %rbx
retq
movl $0x1, %edx
xorl %esi, %esi
movq %r9, %rcx
movq %rbx, %r8
popq %rbx
jmp 0x2962a
// File: /workspace/github_c_makefile_star2_O1/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 0x2617f
testq %rax, %rax
js 0x27881
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
movl $0x1, %eax
jmp 0x27883
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2633e
testq %rax, %rax
js 0x278c0
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
movl $0x1, %eax
jmp 0x278c2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2647e
testq %rax, %rax
js 0x278f5
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %eax
jmp 0x278f7
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x266d9
testq %rax, %rax
js 0x27924
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %eax
jmp 0x27926
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x26818
testq %rax, %rax
js 0x2795d
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
movl $0x1, %eax
jmp 0x2795f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x26a4e
testq %rax, %rax
js 0x2799c
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
movl $0x1, %eax
jmp 0x2799e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x260e5
testq %rax, %rax
js 0x279c9
movq %rax, 0x10(%rbx)
movl $0x1, %eax
jmp 0x279cb
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x26c1e
testq %rax, %rax
js 0x27af9
movq %rax, 0x10(%r15)
movq %rdx, 0x18(%r15)
movl 0x18(%r14), %eax
movl %eax, 0x19e0(%rbx)
movl $0x0, 0x19e4(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x26ccd
testq %rax, %rax
js 0x27b57
movq %rax, 0x10(%r15)
movq %rdx, 0x18(%r15)
movl 0x18(%r14), %eax
movl %eax, 0x19e0(%rbx)
movl $0x1, 0x19e4(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %ebp
movl $0x1, %r8d
callq 0x26c1e
testq %rax, %rax
js 0x27bb8
movq %rax, 0x10(%r15)
movq %rdx, 0x18(%r15)
movl 0x18(%r14), %eax
movl %eax, 0x19e0(%rbx)
movl $0x2, 0x19e4(%rbx)
jmp 0x27bba
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %ebp
movl $0x1, %r8d
callq 0x26ccd
testq %rax, %rax
js 0x27c1b
movq %rax, 0x10(%r15)
movq %rdx, 0x18(%r15)
movl 0x18(%r14), %eax
movl %eax, 0x19e0(%rbx)
movl $0x3, 0x19e4(%rbx)
jmp 0x27c1d
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x27cb9
leaq 0x9562(%rip), %r8       # 0x311b0
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 0x27c82
movq 0x40(%rcx), %rsi
movl 0x19e0(%rdi), %ecx
movq %rsi, %rdi
movq %rax, %rsi
movl $0x1, %r8d
callq 0x26c1e
jmp 0x27cb9
movq 0x40(%rcx), %rsi
movl 0x19e0(%rdi), %ecx
movq %rsi, %rdi
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x27cb4
movq 0x40(%rcx), %rsi
movl 0x19e0(%rdi), %ecx
movq %rsi, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0x26ccd
testq %rax, %rax
js 0x27ccd
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %eax
jmp 0x27ccf
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe54e
movq 0x40(%r14), %rsi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movl $0x0, (%rsp)
leaq 0x10(%rsp), %rbx
xorl %ebp, %ebp
movq %rbx, %rdi
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x27173
movq (%rbx), %rdx
testq %rdx, %rdx
js 0x281e3
movq 0x58(%rsp), %r14
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movq 0x18(%rsp), %rcx
callq 0xf1d6
testb %al, %al
je 0x281b8
leaq 0x20(%rsp), %rbx
jmp 0x281d3
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0xf1d6
testb %al, %al
je 0x281e3
addq $0x10, %r14
movups (%rbx), %xmm0
movups %xmm0, (%r14)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq $-0x1, %rsi
cmovaeq %rax, %rsi
shlq $0x4, %rsi
leaq (%rcx,%rsi), %rax
cmpq $0x0, (%rcx,%rsi)
jne 0x282a2
cmpq $0x0, 0x8(%rax)
je 0x282d3
movq 0x18(%rsp), %rbx
movups (%rax), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x40(%rdx), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movl $0x2, %ecx
callq 0xf112
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0x282d1
// File: /workspace/github_c_makefile_star2_O1/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
movq $-0x1, %rdx
cmovaeq %rax, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
cmpq $0x0, (%rcx,%rdx)
jne 0x28310
cmpq $0x0, 0x8(%rax)
je 0x28358
movq 0x28(%rsp), %r14
movups (%rax), %xmm0
movups %xmm0, 0x10(%r14)
movq 0x40(%rbx), %rdi
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movl $0x2, %ecx
callq 0xf112
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq 0x40(%rbx), %rdi
movq %rdx, %rsi
callq 0x260e5
movq %rax, 0x10(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x28350
// File: /workspace/github_c_makefile_star2_O1/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 0x18(%rsp), %rbx
movq 0x18(%rdx), %rcx
subq 0x10(%rdx), %rcx
movq %rcx, %rax
shrq $0x3f, %rax
addq %rcx, %rax
sarq %rax
addq 0x28(%rdx), %rax
movq (%rbx), %rsi
movq %rsi, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq 0x40(%rdx), %rdi
movq %rax, %rdx
movl $0x2, %ecx
callq 0xf112
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rax, %rdx
movl $0x2, %ecx
callq 0xf112
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x38(%rsp), %r14
movq 0x40(%rdx), %r15
movq (%r15), %r12
movq 0x18(%r14), %r13
movq (%r12,%r13,8), %rdi
callq 0x297fa
movl %eax, %ebx
incq %r13
cmpq 0x8(%r15), %r13
jge 0x2847d
movq (%r12,%r13,8), %rdi
callq 0x297fa
movb $0x1, %cl
testb %al, %al
je 0x28474
testb $0x1, %bl
jne 0x28476
movq $0x0, 0x10(%r14)
movq %r13, 0x18(%r14)
xorl %ecx, %ecx
jmp 0x28476
xorl %ebx, %ebx
incq %r13
testb %cl, %cl
jne 0x2844a
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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), %r15
movq 0x18(%r14), %r12
movq (%r15,%r12,8), %rdi
callq 0x297fa
movl %eax, %ebx
testq %r12, %r12
jle 0x284e2
movq -0x8(%r15,%r12,8), %rdi
decq %r12
callq 0x297fa
movb $0x1, %cl
testb %al, %al
je 0x284dc
testb $0x1, %bl
jne 0x284de
movq $0x0, 0x10(%r14)
movq %r12, 0x18(%r14)
xorl %ecx, %ecx
jmp 0x284de
xorl %ebx, %ebx
testb %cl, %cl
jne 0x284af
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_vim.c
// Function: ce_vim_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 0x48(%rsp), %rax
movq 0x18(%rax), %r12
incq %r12
movq 0x40(%rdx), %rax
cmpq 0x8(%rax), %r12
setl %bpl
jge 0x285bd
movq %rdx, %rbx
movq 0x40(%rdx), %rcx
movq 0x58(%rcx), %r13
movq (%rax), %rax
movq (%rax,%r12,8), %rdi
callq 0xe485
testq %rax, %rax
je 0x285a8
movq 0x600(%r13), %rax
cmpq 0x12a1a(%rip), %rax     # 0x3af60
setne %cl
cmpq 0x12a08(%rip), %rax     # 0x3af58
setne %al
testb %al, %cl
jne 0x2856f
movq 0x40(%rbx), %rax
movq (%rax), %rax
movq (%rax,%r12,8), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x285a8
cmpl $0x2f, %eax
je 0x285a8
movq 0x40(%rbx), %rax
movq (%rax), %rax
movq (%rax,%r12,8), %r14
movzbl (%r14), %r15d
leal -0x20(%r15), %eax
cmpb $0x5e, %al
ja 0x285a8
callq 0xd720
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
jne 0x285a8
movq %r14, %rdi
movl $0x28, %esi
callq 0xd230
testq %rax, %rax
jne 0x285d3
incq %r12
movq 0x40(%rbx), %rax
cmpq 0x8(%rax), %r12
setl %bpl
jl 0x28527
movzbl %bpl, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%rsp), %rax
movq $0x0, 0x10(%rax)
movq %r12, 0x18(%rax)
jmp 0x285bd
// File: /workspace/github_c_makefile_star2_O1/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 0xe485
movq 0x18(%rbx), %rcx
movq $0x0, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x40(%rdx), %rdi
movq 0x8(%rcx), %rsi
callq 0x260e5
testq %rax, %rax
js 0x287d4
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 0xe97d
movq %rax, 0x10(%r13)
testq %rax, %rax
je 0x287d8
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 0x25e52
movl %eax, %ebp
testb %al, %al
je 0x287f9
movb $0x1, 0x19d8(%rbx)
movl $0x1, (%rbx)
cmpb $0x0, 0x19d9(%rbx)
jne 0x287c0
leaq 0x19c8(%rbx), %rdi
callq 0x10370
testb %bpl, %bpl
je 0x287f9
movb $0x1, 0x19d8(%rbx)
movl $0x1, (%rbx)
jmp 0x287e1
xorl %ebp, %ebp
jmp 0x287f9
movl $0x1, (%rbx)
movb $0x1, %bpl
cmpb $0x0, 0x19d9(%rbx)
jne 0x287f9
addq $0x19c8, %rbx           # imm = 0x19C8
movq %rbx, %rdi
callq 0x10370
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_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, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x1079c
xorl %r13d, %r13d
movq (%r12), %rdi
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq 0x18(%r12), %rcx
callq 0xedfb
movl %eax, %ebp
testb %al, %al
jne 0x288f9
movq 0x40(%r14), %rdi
movq (%r12), %rsi
movq 0x8(%r12), %rdx
callq 0xe446
movq 0x40(%r14), %rdi
movq 0x8(%r12), %r10
testb %al, %al
je 0x2887b
movq (%rdi), %rax
movq (%rax,%r10,8), %rax
cmpb $0x0, (%rax)
jne 0x288aa
movq (%r12), %rsi
movl $0x1, %ecx
movq %r10, %rdx
callq 0xeffa
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
movq 0x10(%r12), %r8
movq 0x18(%r12), %rcx
movq %rax, %rdi
movq %rdx, %rsi
movq %r8, %rdx
jmp 0x28841
movl 0x30(%r15), %r8d
movq (%r12), %rdx
movzbl %r13b, %r9d
andl $0x1, %r9d
movq %r14, %rdi
movq %rbx, %rsi
movq %r10, %rcx
callq 0x2983d
testb %al, %al
je 0x288f9
movq 0x40(%r14), %rdi
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movl $0x1, %ecx
callq 0xeffa
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
movb $0x1, %r13b
cmpq $-0x1, %rax
jne 0x2882e
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_delete_character
bool ce_vim_verb_delete_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);

     while(!ce_point_after(motion_range.start, motion_range.end)){
          ce_buffer_remove_string_change(view->buffer, *cursor, 1, cursor, *cursor, false);

          CePoint_t new_start = ce_buffer_advance_point(view->buffer, motion_range.start, 1);
          if(ce_points_equal(new_start, motion_range.start)) return false;
          motion_range.start = new_start;
     }

     *cursor = ce_buffer_clamp_point(view->buffer, motion_range.end, action->clamp_x);
     return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x1079c
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
callq 0xedfb
movl %eax, %ebp
testb %al, %al
jne 0x289ba
movq 0x40(%r12), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movl $0x1, %ecx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0xfc21
movq 0x40(%r12), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movl $0x1, %ecx
callq 0xeffa
movq %rax, %r13
movq %rdx, %r15
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rax, %rdi
movq %r15, %rsi
callq 0xf1d6
testb %al, %al
jne 0x289db
movq %r13, (%r14)
movq %r15, 0x8(%r14)
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movq %r13, %rdi
movq %r15, %rsi
jmp 0x28943
movq 0x40(%r12), %rdi
movq 0x10(%rsp), %rax
movl 0x40(%rax), %ecx
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
callq 0xf112
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
andb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/justy989[P]ce/ce_vim.c
// Function: ce_vim_verb_substitute_character
bool ce_vim_verb_substitute_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){
     bool success = ce_vim_verb_delete_character(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 %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2890e
movl %eax, %ebp
testb %al, %al
je 0x28a3c
movb $0x1, 0x19d8(%rbx)
movl $0x1, (%rbx)
cmpb $0x0, 0x19d9(%rbx)
jne 0x28a3c
addq $0x19c8, %rbx           # imm = 0x19C8
movq %rbx, %rdi
callq 0x10370
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq