LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_vim.c
// Function: ce_vim_move_big_word
CePoint_t ce_vim_move_big_word(CeBuffer_t* buffer, CePoint_t start){
     if(!ce_buffer_point_is_valid(buffer, start)) return (CePoint_t){-1, -1};

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

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

     if(isspace(rune)) state = WORD_INSIDE_SPACE;

     itr += rune_len;
     start.x++;

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

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

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

END_LOOP:

     return start;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xe4d4
testq %rax, %rax
je 0x262e6
movq %r15, 0x8(%rsp)
movq (%r15), %rax
movq (%rax,%rbx,8), %rdi
movq %r14, %rsi
callq 0xe577
movq %rax, %r13
leaq 0x10(%rsp), %r12
movq $0x0, (%r12)
movq %rax, %rdi
movq %r12, %rsi
callq 0xe602
movl %eax, %r15d
callq 0xd720
movq %rax, %rbp
movq (%rax), %rax
movslq %r15d, %rcx
addq (%r12), %r13
movzwl (%rax,%rcx,2), %r15d
incq %r14
shrl $0xd, %r15d
andl $0x1, %r15d
movq %r13, %rdi
movq %r12, %rsi
callq 0xe602
testl %r15d, %r15d
je 0x26293
cmpl $0x1, %r15d
je 0x2627e
cmpl $0x3, %r15d
jne 0x26309
movq (%rbp), %rcx
cltq
movl $0x1, %r15d
testb $0x20, 0x1(%rcx,%rax,2)
jne 0x262a6
jmp 0x262f4
movq (%rbp), %rcx
cltq
movzwl (%rcx,%rax,2), %r15d
shrl $0xd, %r15d
andl $0x1, %r15d
cmpb $0x0, (%r13)
je 0x262b7
addq 0x10(%rsp), %r13
incq %r14
jmp 0x2625e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
decq %rax
cmpq %rax, %rbx
jge 0x262f4
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax,%rbx,8), %r13
incq %rbx
movl $0x3, %r15d
xorl %r14d, %r14d
jmp 0x2625e
movq $-0x1, %r14
movq $-0x1, %rbx
movq %r14, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9a6e(%rip), %rdi      # 0x2fd7e
leaq 0x9fb0(%rip), %rsi      # 0x302c7
leaq 0xa006(%rip), %rcx      # 0x30324
movl $0x328, %edx            # imm = 0x328
callq 0xd280
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_vim.c
// Function: ce_vim_move_end_big_word
CePoint_t ce_vim_move_end_big_word(CeBuffer_t* buffer, CePoint_t start){
     start.x++;
     if(!ce_buffer_point_is_valid(buffer, start)){
          if(start.x == 1){
               // line is empty
               start.x = 0;
          }else{
               return (CePoint_t){-1, -1};
          }
     }

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

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

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

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

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

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

          itr += rune_len;
          start.x++;

          if(*itr == 0) break;
     }

END_LOOP:

     return start;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x1(%rsi), %r14
movq %r14, %rsi
callq 0xe4d4
testq %rax, %rax
je 0x26613
movq (%r12), %rax
movq (%rax,%rbx,8), %rdi
movq %r14, %rsi
callq 0xe577
movq $0x0, (%rsp)
cmpb $0x0, (%rax)
je 0x2662f
movq %rax, %r15
movq %rsp, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0xe602
movl %eax, %ebp
callq 0xd720
movslq %ebp, %rcx
addq %rcx, %rcx
addq (%rax), %rcx
addq (%r12), %r15
jmp 0x2667e
movq $-0x1, %r14
movq $-0x1, %rdx
testq %r15, %r15
jne 0x266d7
xorl %r14d, %r14d
jmp 0x265cf
movq 0x8(%r12), %rax
decq %rax
movq $-0x1, %r14
movq $-0x1, %rdx
cmpq %rbx, %rax
jle 0x266d7
movq (%r12), %rax
movq 0x8(%rax,%rbx,8), %r15
incq %rbx
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xe602
movl %eax, %ebp
addq (%r14), %r15
callq 0xd720
movslq %ebp, %rcx
addq %rcx, %rcx
addq (%rax), %rcx
xorl %r14d, %r14d
movzwl (%rcx), %r13d
shrl $0xd, %r13d
andl $0x1, %r13d
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xe602
movl %eax, %ebp
callq 0xd720
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
testl %r13d, %r13d
je 0x266b9
shrl $0xd, %eax
andl $0x1, %eax
movl %eax, %r13d
jmp 0x266c2
xorl %r13d, %r13d
btl $0xd, %eax
jb 0x266d4
movq (%rsp), %rax
incq %r14
cmpb $0x0, (%r15,%rax)
leaq (%r15,%rax), %r15
jne 0x2668d
movq %rbx, %rdx
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/justy989[P]ce/ce_vim.c
// Function: ce_vim_move_find_rune_forward
CePoint_t ce_vim_move_find_rune_forward(CeBuffer_t* buffer, CePoint_t start, CeRune_t match_rune, bool until){
     if(!ce_buffer_point_is_valid(buffer, start)) return (CePoint_t){-1, -1};
     int64_t match_x = until ? start.x + 2 : start.x + 1;
     char* str = ce_utf8_iterate_to(buffer->lines[start.y], match_x);
     if(!str) return (CePoint_t){-1, -1};

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0xe4d4
testq %rax, %rax
je 0x26b7a
movzbl %r14b, %r13d
leaq (%r12,%r13), %rsi
incq %rsi
movq (%r15), %rax
movq (%rax,%rbx,8), %rdi
callq 0xe577
testq %rax, %rax
je 0x26b7a
movq %rax, %r15
cmpb $0x0, (%rax)
je 0x26b7a
leaq 0x1(%r13), %r14
addq %r12, %r14
subq %r13, %r14
movq %rsp, %r12
movq $0x0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe602
cmpl %ebp, %eax
je 0x26b88
movq (%rsp), %rax
incq %r14
cmpb $0x0, (%r15,%rax)
leaq (%r15,%rax), %r15
jne 0x26b51
movq $-0x1, %r14
movq $-0x1, %rbx
movq %r14, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0xe4d4
testq %rax, %rax
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x26c46
movq (%r15), %rax
movq (%rax,%r14,8), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe577
testq %rax, %rax
je 0x26c46
movq %rax, %r12
decq %r12
testb %r13b, %r13b
je 0x26c0e
addq $-0x2, %rbx
movq %rsp, %rdx
movq $0x0, (%rdx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x100aa
movq %rsp, %rax
subq (%rax), %r12
jmp 0x26c11
decq %rbx
cmpq %r15, %r12
jb 0x26c46
movzbl %r13b, %eax
addq %rax, %rbx
movq %rsp, %r13
movq $0x0, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x100aa
cmpl %ebp, %eax
je 0x26c54
subq (%rsp), %r12
decq %rbx
cmpq %r15, %r12
jae 0x26c20
movq $-0x1, %rbx
movq $-0x1, %r14
movq %rbx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12
movq %rdx, %rbp
movq %rdi, %r13
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 0xe577
movq %rax, %r14
movsbq (%rax), %rbx
callq 0xd720
cmpq $0x5f, %rbx
je 0x26cc1
movq (%rax), %rcx
movzwl (%rcx,%rbx,2), %ecx
andl $0x8, %ecx
je 0x26d6e
movq %r13, 0x8(%rsp)
movq %r12, 0x10(%rsp)
leaq -0x1(%rbp), %rcx
movq %r14, %r13
movq %rax, %r12
movq %rcx, %rbx
cmpb $0x0, (%r13)
je 0x26d0e
movq $0x0, (%rsp)
movq %r13, %rdi
movq %rsp, %rsi
callq 0xe602
leaq 0x1(%rbx), %rcx
addq (%rsp), %r13
cmpl $0x5f, %eax
je 0x26cd5
movq (%r12), %rdx
cltq
movzwl (%rdx,%rax,2), %eax
andl $0x8, %eax
jne 0x26cd5
movq %r12, %r13
incq %rbp
movq %rbp, %r12
cmpq %r15, %r14
jb 0x26d4f
movq $0x0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rsp, %rdx
callq 0x100aa
leaq -0x1(%r12), %rbp
subq (%rsp), %r14
cmpl $0x5f, %eax
je 0x26d14
movq (%r13), %rcx
cltq
movzwl (%rcx,%rax,2), %eax
andl $0x8, %eax
jne 0x26d14
cmpq %rbx, %r12
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %r13
jg 0x26d6e
movq %r12, (%r13)
movq %rax, 0x8(%r13)
movq %rbx, 0x10(%r13)
movq %rax, 0x18(%r13)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x14(%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 0xe577
movq %rax, %r14
movq $0x0, 0x8(%rsp)
cmpb $0x0, (%rax)
movq $-0x1, 0x20(%rsp)
movq %r15, 0x18(%rsp)
je 0x26f58
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x8(%rsp), %r13
movq %r14, %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xe602
cmpl 0x14(%rsp), %eax
setne %cl
cmpl $0x5c, %ebp
sete %dl
orb %cl, %dl
je 0x26f43
incq %r15
movq 0x8(%rsp), %rcx
cmpb $0x0, (%rbx,%rcx)
leaq (%rbx,%rcx), %rbx
movl %eax, %ebp
jne 0x26f11
jmp 0x26f53
xorl %eax, %eax
cmpb $0x1, (%rbx)
sbbq %rax, %rax
orq %r15, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %r15
incq %r15
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x100aa
movl %eax, %ebx
movq %r14, %r13
movq %r15, %rbp
cmpq %r12, %r14
jbe 0x26fb8
movq %r13, %rdi
movq %r12, %rsi
leaq 0x8(%rsp), %rdx
callq 0x100aa
cmpl 0x14(%rsp), %ebx
sete %cl
cmpl $0x5c, %eax
setne %dl
cmpq 0x18(%rsp), %rbp
setl %sil
andb %cl, %sil
andb %dl, %sil
leaq -0x1(%rbp), %r15
movq %r13, %r14
subq 0x8(%rsp), %r14
movl %eax, %ebx
cmpb $0x1, %sil
jne 0x26f6d
cmpq %r12, %r13
movq $-0x1, %rax
cmoveq %rax, %rbp
movq 0x20(%rsp), %rdx
cmpq %rdx, %rbp
movq 0x30(%rsp), %rax
jg 0x26fe9
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_O3/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 0xe406
testb %al, %al
je 0x27515
xorl %eax, %eax
testq %r14, %r14
js 0x27517
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 0xe602
cmpl $0x29, %eax
jg 0x274b8
cmpl $0x22, %eax
je 0x274a0
cmpl $0x27, %eax
jne 0x274fb
cmpl %eax, %ebx
jne 0x274d5
cmpl $0x5c, %r12d
jne 0x274f9
cmpl $0x5c, %r13d
movl $0x0, %ecx
cmovel %ecx, %ebx
jmp 0x274fb
cmpl $0x2a, %eax
je 0x274dc
cmpl $0x2f, %eax
jne 0x274fb
cmpl $0x2f, %r12d
jne 0x274eb
testl %ebx, %ebx
jne 0x274eb
xorl %ebx, %ebx
movl $0x1, %ebp
jmp 0x274fb
testl %ebx, %ebx
cmovel %eax, %ebx
jmp 0x274fb
movl %r12d, %ecx
xorl $0x2f, %ecx
orl %ebx, %ecx
movl $0x1, %ecx
jmp 0x274f4
cmpl $0x2f, %r12d
movl $0x0, %ecx
cmovel %ecx, %ebp
jmp 0x274fb
xorl %ebx, %ebx
addq (%rsp), %r15
movl %r12d, %r13d
movl %eax, %r12d
decq %r14
jne 0x27486
orl %ebp, %ebx
setne %al
jmp 0x27517
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_O3/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 0x25f8c
movq %rax, %r14
testq %rax, %rax
js 0x275c0
movq %r14, (%r15)
movl $0x1, (%rbx)
cmpb $0x0, 0x19d9(%rbx)
jne 0x275c0
addq $0x19c8, %rbx           # imm = 0x19C8
movq %rbx, %rdi
callq 0x101e1
testq %r14, %r14
setns %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq 0x28(%rsp), %rbx
leaq -0x1b72(%rip), %rax     # 0x25b02
cmpq %rax, 0x28(%rsi)
je 0x276b9
movq 0x8(%rbx), %rax
movl $0x1, %r14d
testq %rax, %rax
jle 0x276f4
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 0xe8d0
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x10614
jmp 0x276f4
movq 0x40(%rdx), %rdi
movq 0x8(%r9), %r9
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movl $0x2, (%rsp)
xorl %r14d, %r14d
xorl %ecx, %ecx
movq $-0x1, %r8
callq 0xeca3
testq %rax, %rax
js 0x276f4
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq 0x28(%rsp), %rbx
leaq -0x1c0d(%rip), %rax     # 0x25b02
cmpq %rax, 0x28(%rsi)
je 0x27759
movq 0x18(%rbx), %rax
movq 0x40(%rdx), %rcx
movq 0x8(%rcx), %rdx
decq %rdx
movl $0x1, %r14d
cmpq %rdx, %rax
jge 0x27793
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%rbx)
movq (%rcx), %rcx
movq 0x8(%rcx,%rax,8), %rdi
callq 0xe8d0
movq %rax, 0x10(%rbx)
movq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x10614
jmp 0x27793
movq 0x40(%rdx), %rdi
movq 0x8(%r9), %r9
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movl $0x2, (%rsp)
xorl %r14d, %r14d
movl $0x1, %r8d
xorl %ecx, %ecx
callq 0xeca3
testq %rax, %rax
js 0x27793
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x26026
testq %rax, %rax
js 0x277d3
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
movl $0x1, %eax
jmp 0x277d5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x261e5
testq %rax, %rax
js 0x27812
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
movl $0x1, %eax
jmp 0x27814
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x26328
testq %rax, %rax
js 0x27847
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %eax
jmp 0x27849
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x265aa
testq %rax, %rax
js 0x27876
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %eax
jmp 0x27878
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x266e9
testq %rax, %rax
js 0x278af
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
movl $0x1, %eax
jmp 0x278b1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2691f
testq %rax, %rax
js 0x278ee
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movb $0x1, 0x3e(%rbx)
movl $0x1, %eax
jmp 0x278f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25f8c
testq %rax, %rax
js 0x2791b
movq %rax, 0x10(%rbx)
movl $0x1, %eax
jmp 0x2791d
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x26afd
testq %rax, %rax
js 0x27a4d
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_O3/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 0x26b9d
testq %rax, %rax
js 0x27aab
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_O3/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 0x26afd
testq %rax, %rax
js 0x27b0c
movq %rax, 0x10(%r15)
movq %rdx, 0x18(%r15)
movl 0x18(%r14), %eax
movl %eax, 0x19e0(%rbx)
movl $0x2, 0x19e4(%rbx)
jmp 0x27b0e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x26b9d
testq %rax, %rax
js 0x27b6f
movq %rax, 0x10(%r15)
movq %rdx, 0x18(%r15)
movl 0x18(%r14), %eax
movl %eax, 0x19e0(%rbx)
movl $0x3, 0x19e4(%rbx)
jmp 0x27b71
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x27c0d
leaq 0x86be(%rip), %r8       # 0x30260
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 0x27bd6
movq 0x40(%rcx), %rsi
movl 0x19e0(%rdi), %ecx
movq %rsi, %rdi
movq %rax, %rsi
movl $0x1, %r8d
callq 0x26afd
jmp 0x27c0d
movq 0x40(%rcx), %rsi
movl 0x19e0(%rdi), %ecx
movq %rsi, %rdi
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x27c08
movq 0x40(%rcx), %rsi
movl 0x19e0(%rdi), %ecx
movq %rsi, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0x26b9d
testq %rax, %rax
js 0x27c21
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %eax
jmp 0x27c23
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe50e
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 0x26ff8
movq (%rbx), %rdx
testq %rdx, %rdx
js 0x28137
movq 0x58(%rsp), %r14
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movq 0x18(%rsp), %rcx
callq 0xf03d
testb %al, %al
je 0x2810c
leaq 0x20(%rsp), %rbx
jmp 0x28127
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0xf03d
testb %al, %al
je 0x28137
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_O3/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 0x281f6
cmpq $0x0, 0x8(%rax)
je 0x28227
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 0xef79
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0x28225
// File: /workspace/github_c_makefile_star2_O3/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 0x28264
cmpq $0x0, 0x8(%rax)
je 0x282ac
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 0xef79
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq 0x40(%rbx), %rdi
movq %rdx, %rsi
callq 0x25f8c
movq %rax, 0x10(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x282a4
// File: /workspace/github_c_makefile_star2_O3/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 0xef79
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x29683
movl %eax, %ebx
movq 0x8(%r12), %r12
leaq 0x1(%rbp), %r13
cmpq %r12, %r13
jge 0x283d2
movq 0x8(%r15,%rbp,8), %rdi
callq 0x29683
movl %eax, %ecx
notb %cl
orb %bl, %cl
andb %al, %bl
movq %r13, %rbp
testb $0x1, %cl
jne 0x283a3
movq $0x0, 0x10(%r14)
movq %r13, 0x18(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x29683
movl %eax, %ebx
testq %r15, %r15
jle 0x28434
movq -0x8(%r12,%r15,8), %rdi
decq %r15
callq 0x29683
movl %eax, %ecx
notb %cl
orb %bl, %cl
andb %al, %bl
testb $0x1, %cl
jne 0x28409
movq $0x0, 0x10(%r14)
movq %r15, 0x18(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r13
incq %r13
movq 0x40(%rdx), %r12
xorl %eax, %eax
cmpq 0x8(%r12), %r13
jge 0x284f5
movq %rdx, %r14
movq 0x58(%r12), %rbp
movq (%r12), %rax
movq (%rax,%r13,8), %rdi
callq 0xe445
movq 0x40(%r14), %r12
testq %rax, %rax
je 0x284e9
movq 0x600(%rbp), %rax
cmpq 0x11ac7(%rip), %rax     # 0x39f60
setne %cl
cmpq 0x11ab5(%rip), %rax     # 0x39f58
setne %al
movq (%r12), %rdx
movq (%rdx,%r13,8), %r15
movzbl (%r15), %ebx
testb %al, %cl
jne 0x284c1
cmpq $0x23, %rbx
je 0x284e9
cmpl $0x2f, %ebx
je 0x284e9
leal -0x20(%rbx), %eax
cmpb $0x5e, %al
ja 0x284e9
callq 0xd720
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
jne 0x284e9
movq %r15, %rdi
movl $0x28, %esi
callq 0xd230
testq %rax, %rax
jne 0x28504
incq %r13
cmpq 0x8(%r12), %r13
jl 0x28475
xorl %eax, %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 %r13, 0x18(%rax)
movl $0x1, %eax
jmp 0x284f5