LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_seekp
list_t **list_seekp(list_t **pl, int y, bool creat)
{
	if(!*pl){
		if(creat)
			*pl = list_new(NULL);
		else
			return NULL;
	}

	while(y > 0){
		if(!(*pl)->next){
			if(creat)
				(*pl)->next = list_new(*pl);
			else
				return NULL;
		}

		pl = &(*pl)->next;
		y--;
	}

	return pl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xccd7
testb $0x1, -0x15(%rbp)
je 0xcccb
xorl %eax, %eax
movl %eax, %edi
callq 0xc6e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xccd5
movq $0x0, -0x8(%rbp)
jmp 0xcd3d
jmp 0xccd7
jmp 0xccd9
cmpl $0x0, -0x14(%rbp)
jle 0xcd35
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0xcd1b
testb $0x1, -0x15(%rbp)
je 0xcd0f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xc6e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0xcd19
movq $0x0, -0x8(%rbp)
jmp 0xcd3d
jmp 0xcd1b
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xccd9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_evalnewlines1
int list_evalnewlines1(list_t *l)
{
	if(l->len_line == 0)
		return 0;

	int r = 0;
	for(size_t i = l->len_line - 1; ; i--){
		char ch = l->line[i];

		if(ch == '\n' /* XXX: not '\r' / ^M */){
			int cut_len = l->len_line - i;
			char *cut;
			if(cut_len > 0){
				cut = umalloc(cut_len);
				/* cut_len-1, don't copy the \n */
				memcpy(cut, l->line + i + 1, cut_len-1);
			}else{
				cut = NULL;
				cut_len = 0;
			}

			l->len_line = i;

			/* insert a line after */
			list_insline(&l, &(int){0}, &(int){0}, 1);

			list_t *nl = l->next;
			nl->line = cut;
			nl->len_malloc = cut_len;
			nl->len_line = cut_len - 1;

			r = 1; /* we replaced */
		}

		if(i == 0)
			break;
	}

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xcdd3
movl $0x0, -0x4(%rbp)
jmp 0xcee9
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0xa, %eax
jne 0xcec7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x20(%rbp), %rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0xce4d
movslq -0x28(%rbp), %rdi
callq 0x5f20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq -0x20(%rbp), %rsi
addq $0x1, %rsi
movl -0x28(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x4350
jmp 0xce5c
movq $0x0, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl $0x1, %ecx
callq 0xcf00
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movslq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x28(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x14(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xced0
jmp 0xcee3
jmp 0xced2
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xcdea
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_insline
void list_insline(list_t **pl, int *x, int *y, int dir)
{
	list_t *l, *save;

	*x = 0;

	if(dir < 0 && *y == 0){
		/* special case */
		l = *pl;
		(*pl = list_new(NULL))->next = l;
		if(l)
			l->prev = *pl;
		return;
	}

	if(dir < 0)
		--*y;

	/* list_seekp() to create if necessary,
	 * and make that creation available in *pl */
	l = *list_seekp(pl, *y, true);

	save = l->next;
	l->next = list_new(l);
	l->next->next = save;
	if(save)
		save->prev = l->next;

	++*y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
cmpl $0x0, -0x1c(%rbp)
jge 0xcf73
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xcf73
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xc6e0
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x28(%rbp)
je 0xcf71
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0xcff1
cmpl $0x0, -0x1c(%rbp)
jge 0xcf84
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl $0x1, %edx
callq 0xcc90
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc6e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x30(%rbp)
je 0xcfe6
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_delchar
void list_delchar(list_t *l, int *x, int *y)
{
	l = list_seek(l, *y, false);

	--*x;

	if(!l)
		return;

	if((unsigned)*x >= l->len_line)
		return;

	memmove(l->line + *x, l->line + *x + 1, --l->len_line - *x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
xorl %edx, %edx
callq 0xcd50
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
cmpq $0x0, -0x8(%rbp)
jne 0xd26d
jmp 0xd2c4
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xd27f
jmp 0xd2c4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movslq (%rax), %rax
addq %rax, %rsi
addq $0x1, %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
addq $-0x1, %rdx
movq %rdx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq (%rax), %rax
subq %rax, %rdx
callq 0x4400
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_append
list_t *list_append(list_t *accum, list_t *at, list_t *new)
{
	if(!accum)
		return new;

	list_t *after = at->next;
	at->next = new;
	new->prev = at;

	if(after){
		list_t *newtail = list_tail(new);
		newtail->next = after;
		after->prev = newtail;
	}

	return accum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd345
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd39d
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x28(%rbp)
je 0xd395
movq -0x20(%rbp), %rdi
callq 0xd2d0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_dellines
static
list_t *list_dellines(list_t **pl, list_t *prev, unsigned n)
{
	if(n == 0)
		return NULL;

	list_t *l = *pl;

	if(!l)
		return NULL;
	l->prev = NULL;

	list_t *end_m1 = list_seek(l, n - 1, false);

	if(end_m1){
		*pl = end_m1->next;
		end_m1->next = NULL;
	}else{
		/* delete everything */
		*pl = NULL;
	}

	if(*pl)
		(*pl)->prev = prev;
	if(l)
		l->prev = NULL;

	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xdb46
movq $0x0, -0x8(%rbp)
jmp 0xdbe9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xdb65
movq $0x0, -0x8(%rbp)
jmp 0xdbe9
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
subl $0x1, %esi
xorl %edx, %edx
callq 0xcd50
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xdbaa
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0xdbb5
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdbce
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x28(%rbp)
je 0xdbe1
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: line_iter
static bool line_iter(
		list_t *l, size_t start, size_t end,
		size_t y,
		list_iter_f fn, void *ctx)
{
	for(size_t i = start; i < end && i < l->len_line; i++){
		bool r = fn(l->line + i, l, y, ctx);
		if(!r)
			return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x42(%rbp)
jae 0xe399
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
setb %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0xe3a2
jmp 0xe3e2
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
addq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl %ecx, %edx
movq -0x38(%rbp), %rcx
callq *%rax
andb $0x1, %al
movb %al, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0xe3d2
movb $0x0, -0x1(%rbp)
jmp 0xe3e6
jmp 0xe3d4
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xe378
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_advance_y
list_t *list_advance_y(
		list_t *l, const int dir, int *py, int *px)
{
	if(!l)
		return NULL;

	*py += dir;

	if(dir > 0){
		if(px)
			*px = 0;
		return l->next;
	}else{
		l = l->prev;
		if(px && l)
			*px = l->len_line > 0 ? l->len_line - 1 : 0;
		return l;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe427
movq $0x0, -0x8(%rbp)
jmp 0xe4aa
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x14(%rbp)
jle 0xe457
cmpq $0x0, -0x28(%rbp)
je 0xe449
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xe4aa
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe4a2
cmpq $0x0, -0x10(%rbp)
je 0xe4a2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0xe48e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xe496
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0xe496
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_advance_x
list_t *list_advance_x(
		list_t *l, const int dir, int *py, int *px)
{
	if(!l)
		return NULL;

	if(dir > 0){
		if((unsigned)++*px >= l->len_line){
			l = l->next;
			++*py;
			*px = 0;
		}
	}else{
		if(*px == 0)
			l = list_advance_y(l, dir, py, px);
		else
			--*px;
	}
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe4d8
movq $0x0, -0x8(%rbp)
jmp 0xe550
cmpl $0x0, -0x14(%rbp)
jle 0xe518
movq -0x28(%rbp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
movl %eax, %eax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xe516
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
jmp 0xe548
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xe53b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xe400
movq %rax, -0x10(%rbp)
jmp 0xe546
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xe548
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_last
list_t *list_last(list_t *l, int *py)
{
	*py = 0;
	if(!l)
		return NULL;
	for(; l->next; l = l->next, ++*py);
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
jne 0xe587
movq $0x0, -0x8(%rbp)
jmp 0xe5b7
jmp 0xe589
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xe5af
jmp 0xe596
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xe589
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_word_at
char *list_word_at(list_t *l, point_t const *pt)
{
	l = list_seek(l, pt->y, false);
	if(!l)
		return NULL;

	const bool bigwords = false;

	/* forwards until we hit a word */
	point_t found = *pt;
	l = word_seek(l, +1, &found, W_KEYWORD, bigwords);
	if(!l || found.y != pt->y)
		return NULL;

	/* back until the start of the word */
	word_seek_to_end(l, -1, &found, bigwords);

	/* forwards until the end of the word */
	point_t end = found;
	word_seek_to_end(l, +1, &end, bigwords);

	return ustrdup_len(l->line + found.x, end.x - found.x + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
xorl %edx, %edx
callq 0xcd50
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe5fa
movq $0x0, -0x8(%rbp)
jmp 0xe697
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x24(%rbp), %rdx
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x12af0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe63a
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0xe644
movq $0x0, -0x8(%rbp)
jmp 0xe697
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq -0x24(%rbp), %rdx
xorl %ecx, %ecx
callq 0x12b80
movq -0x24(%rbp), %rax
movq %rax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x2c(%rbp), %rdx
xorl %ecx, %ecx
callq 0x12b80
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movl -0x2c(%rbp), %eax
subl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x5fe0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: isfnamechar
static bool isfnamechar(char c)
{
	switch(c){
		case 'a' ... 'z':
		case 'A' ... 'Z':
		case '0' ... '9':
			return true;
	}

	const char *fname_chars = "/.-_+,#$%~=";
	return strchr(fname_chars, c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
movl %eax, -0x14(%rbp)
addl $-0x30, %eax
subl $0xa, %eax
jb 0xe8dd
jmp 0xe8bf
movl -0x14(%rbp), %eax
addl $-0x41, %eax
subl $0x1a, %eax
jb 0xe8db
jmp 0xe8cc
movl -0x14(%rbp), %eax
addl $-0x61, %eax
subl $0x19, %eax
ja 0xe8e3
jmp 0xe8d9
jmp 0xe8db
jmp 0xe8dd
movb $0x1, -0x1(%rbp)
jmp 0xe907
leaq 0x6ec8(%rip), %rax      # 0x157b2
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x2(%rbp), %esi
callq 0x41c0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_flag_range
void list_flag_range(list_t *l, const struct range *r, int v)
{
	size_t n = r->end - r->start + 1;
	for(l = list_seek(l, r->start, false);
	    l && n > 0;
	    l = l->next, n--)
	{
		l->flag = v;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
subl (%rcx), %eax
addl $0x1, %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
xorl %edx, %edx
callq 0xcd50
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x21(%rbp)
je 0xe9a5
cmpq $0x0, -0x20(%rbp)
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xe9ae
jmp 0xe9d2
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xe98e
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_flagfind
list_t *list_flagfind(list_t *l, int v, int *py)
{
	*py = 0;
	for(; l; l = l->next, ++*py)
		if(l->flag == v)
			return l;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0xea31
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xea16
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xea39
jmp 0xea18
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xe9f9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_contains
list_t *list_contains(list_t *l, const char *str)
{
	for(; l; l = l->next)
		if(!strcmp(l->line, str))
			return l;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xea86
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x42d0
cmpl $0x0, %eax
jne 0xea76
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xea8e
jmp 0xea78
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xea50
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_new_fd_read
static list_t *list_new_fd_read(int fd, bool *eol)
{
	list_t *l = list_new(NULL);

	int y = 0, x = 0;
	bool nl = false, empty = true;
	int ch = 0;
	int r;
	while((r = read(fd, &ch, 1)) == 1){
		if(nl){
			list_inschar(l, &x, &y, '\n', /*gap*/' ');
			nl = false;
		}

		if(ch == '\n')
			nl = true;
		else
			list_inschar(l, &x, &y, ch, /*gap*/' ');

		empty = false;
	}

	*eol = nl || empty;

	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xc6e0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movb $0x1, -0x22(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x4(%rbp), %edi
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x42b0
movl %eax, -0x2c(%rbp)
cmpl $0x1, %eax
jne 0xeb47
testb $0x1, -0x21(%rbp)
je 0xeb18
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
movl $0xa, %ecx
movl $0x20, %r8d
callq 0xd000
movb $0x0, -0x21(%rbp)
cmpl $0xa, -0x28(%rbp)
jne 0xeb24
movb $0x1, -0x21(%rbp)
jmp 0xeb41
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %eax
leaq -0x20(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
movl $0x20, %r8d
movsbl %al, %ecx
callq 0xd000
movb $0x0, -0x22(%rbp)
jmp 0xead9
movb $0x1, %al
testb $0x1, -0x21(%rbp)
movb %al, -0x2d(%rbp)
jne 0xeb58
movb -0x22(%rbp), %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: mmap_to_lines
static list_t *mmap_to_lines(char *mem, size_t len, bool *eol)
{
	list_t *head = list_new(NULL), *cur = head;
	char *const last = mem + len;

	char *p, *begin;
	for(p = begin = mem; p != last; p++)
		if(*p == '\n')
			mmap_new_line(&cur, p, &begin);

	int last_is_nl = (p == begin);
	*eol = last_is_nl;
	if(!last_is_nl)
		mmap_new_line(&cur, p, &begin);

	return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xc6e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0xebe8
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xebd8
movq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0xec30
jmp 0xebda
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xebb1
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
setne %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
cmpl $0x0, -0x44(%rbp)
jne 0xec22
movq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0xec30
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: mmap_new_line
static void mmap_new_line(list_t **pcur, char *p, char **panchor)
{
	const size_t nchars = p - *panchor;
	char *data = umalloc(nchars + 1);

	memcpy(data, *panchor, nchars);
	data[nchars] = '\0';

	list_t *cur = *pcur;
	if(cur->line){
		cur->next = list_new(cur);
		cur = cur->next;
	}
	cur->line = data;
	cur->len_malloc = nchars + 1;
	cur->len_line = nchars;
	*pcur = cur;

	*panchor = p + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
callq 0x5f20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x4350
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0xecbc
movq -0x30(%rbp), %rdi
callq 0xc6e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: start_of_line_given
static void start_of_line_given(list_t *l, point_t *to)
{
	if(l){
		unsigned i;
		for(i = 0; i < l->len_line && isspace(l->line[i]); i++);

		to->x = i < l->len_line ? i : 0;
	}else{
		to->x = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xedfe
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x15(%rbp)
jae 0xedc1
callq 0x4530
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl -0x14(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xedca
jmp 0xedd7
jmp 0xedcc
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xed82
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xedec
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xedf3
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xedf3
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0xee08
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_line_goto
static int m_line_goto(point_t *const pt, unsigned repeat, bool end, window *win)
{
	if(repeat == 0) /* default */
		pt->y = end ? list_count(win->buf->head) : 0;
	else
		pt->y = repeat - 1;

	start_of_line(pt, win);

	return MOTION_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xee9e
testb $0x1, -0xd(%rbp)
je 0xee8b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0xde10
movl %eax, -0x1c(%rbp)
jmp 0xee92
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xee92
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0xeeab
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xed10
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_eol
int m_eol(motion_arg const *m, unsigned repeat, window *win, point_t *to)
{
	list_t *l = window_current_line(win, false);

	to->x = l && l->len_line > 0 ? l->len_line - 1 : 0;

	bool nonblank = m->i;
	if(nonblank){
		for(; to->x > 0 && isspace(l->line[to->x]); to->x--);
	}

	return MOTION_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x13790
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xef1a
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0xef1a
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xef22
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xef22
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0xef9c
jmp 0xef45
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x39(%rbp)
jle 0xef82
callq 0x4530
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movslq (%rdx), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xef8b
jmp 0xef9a
jmp 0xef8d
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xef45
jmp 0xef9c
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_eos
int m_eos(motion_arg const *m, unsigned repeat, window *win, point_t *to)
{
	int y, h;
	screen_or_buf_dimensions(win, &y, &h);
	to->y = y + h;

	start_of_line(to, win);
	return MOTION_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xf040
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xed10
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: screen_or_buf_dimensions
static void screen_or_buf_dimensions(
		window *win, int *const y, int *const height)
{
	int nlines = list_count(win->buf->head);

	*y = UI_TOP(win);

	if(nlines < win->screen_coord.h)
		*height = nlines - *y;
	else
		*height = win->screen_coord.h - 1;

	if(*height < 0)
		*height = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0xde10
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0xf091
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
subl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0xf0a1
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jge 0xf0b4
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_goto
int m_goto(motion_arg const *m, unsigned repeat, window *win, point_t *to)
{
	if(m->pos.y > -1)
		to->y = m->pos.y * DEFAULT_REPEAT(repeat);

	if(m->pos.x > -1)
		to->x = m->pos.x * DEFAULT_REPEAT(repeat);

	return MOTION_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
jle 0xf16f
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xf155
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xf15f
movl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xf15f
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %eax
imull %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
jle 0xf1a8
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xf18f
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0xf199
movl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xf199
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %eax
imull %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_move
int m_move(motion_arg const *m, unsigned repeat, window *win, point_t *to)
{
	to->y += m->pos.y * DEFAULT_REPEAT(repeat);
	to->x += m->pos.x * DEFAULT_REPEAT(repeat);
	if(to->x < 0 || to->y < 0)
		return MOTION_FAILURE;
	return MOTION_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xf1db
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0xf1e5
movl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xf1e5
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %eax
imull %eax, %ecx
movq -0x28(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xf20f
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0xf219
movl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xf219
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %eax
imull %eax, %ecx
movq -0x28(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jl 0xf23d
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0xf246
movl $0x0, -0x4(%rbp)
jmp 0xf24d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_col
int m_col(motion_arg const *m, unsigned repeat, window *win, point_t *to)
{
	if(repeat == 0)
		to->x = 0;
	else
		to->x = repeat - 1;
	return MOTION_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xf2f5
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
jmp 0xf301
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_linesearch
static int m_linesearch(
		motion_arg const *arg, unsigned repeat, window *win, point_t *to,
		list_t *sfn(motion_arg const *, list_t *, int *, const void *),
		const void *ctx)
{
	list_t *l = window_current_line(win, false); /* fine - repeat handled */
	int n = 0;

	*to = *win->ui_pos;

	if(!l)
		goto limit;

	for(repeat = DEFAULT_REPEAT(repeat);
			repeat > 0;
			repeat--)
	{
		l = sfn(arg, l, &n, ctx);
		if(!l)
			goto limit;
	}

	to->y += n;

	return MOTION_SUCCESS;
limit:
	to->y = arg->dir > 0 ? buffer_nlines(win->buf) : 0;
	return MOTION_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x13790
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
cmpq $0x0, -0x40(%rbp)
jne 0xf3a0
jmp 0xf40a
cmpl $0x0, -0x14(%rbp)
je 0xf3ae
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0xf3b8
movl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xf3b8
movl -0x48(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jbe 0xf3f4
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rcx
leaq -0x44(%rbp), %rdx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xf3e7
jmp 0xf40a
jmp 0xf3e9
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf3be
movl -0x44(%rbp), %ecx
movq -0x28(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xf43f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jle 0xf427
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xc330
movl %eax, -0x4c(%rbp)
jmp 0xf42e
xorl %eax, %eax
movl %eax, -0x4c(%rbp)
jmp 0xf42e
movl -0x4c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_search_para
static list_t *m_search_para(
		motion_arg const *a, list_t *l,
		int *pn, const void *ctx)
{
	/* while in space, find non-space */
	for(; l && (!l->line || isallspace(l->line, l->len_line));
			l = list_advance_y(l, a->dir, pn, NULL));

	/* while in non-space, find space */
	for(; l && (l->line && !isallspace(l->line, l->len_line));
			l = list_advance_y(l, a->dir, pn, NULL));

	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0xf4a0
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, (%rcx)
movb %al, -0x22(%rbp)
je 0xf49a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10960
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xf4a9
jmp 0xf4c9
jmp 0xf4ab
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movsbl (%rax), %esi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xe400
movq %rax, -0x10(%rbp)
jmp 0xf468
jmp 0xf4cb
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x23(%rbp)
je 0xf505
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x24(%rbp)
je 0xf4ff
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10960
xorb $-0x1, %al
movb %al, -0x24(%rbp)
movb -0x24(%rbp), %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
testb $0x1, %al
jne 0xf50e
jmp 0xf52e
jmp 0xf510
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movsbl (%rax), %esi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xe400
movq %rax, -0x10(%rbp)
jmp 0xf4cb
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_func
int m_func(motion_arg const *m, unsigned repeat, window *win, point_t *to)
{
	int r = m_linesearch(m, repeat, win, to, m_search_func, &m->scan_ch);
	if(r == MOTION_SUCCESS)
		to->x = 0;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %r9
addq $0x1, %r9
leaq 0x2b(%rip), %r8         # 0xf5a0
callq 0xf350
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0xf58d
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_search_func
static list_t *m_search_func(
		motion_arg const *a, list_t *l,
		int *pn, const void *ctx)
{
	int ch = *(int *)ctx;

	if(l && l->len_line && *l->line == ch)
		l = list_advance_y(l, a->dir, pn, NULL);

	for(;
	    l && (l->len_line == 0 || *l->line != ch);
	    l = list_advance_y(l, a->dir, pn, NULL));

	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf5fe
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf5fe
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0xf5fe
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movsbl (%rax), %esi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xe400
movq %rax, -0x10(%rbp)
jmp 0xf600
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x25(%rbp)
je 0xf635
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x8(%rcx)
movb %al, -0x26(%rbp)
je 0xf62f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl -0x24(%rbp), %eax
setne %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xf63e
jmp 0xf65e
jmp 0xf640
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movsbl (%rax), %esi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xe400
movq %rax, -0x10(%rbp)
jmp 0xf600
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_word
int m_word(motion_arg const *m, unsigned repeat, window *win, point_t *to)
{
	const int dir = m->word_type & WORD_BACKWARD ? -1 : 1;
	const bool end = m->word_type & WORD_END;
	const bool space = m->word_type & WORD_SPACE;

	for(repeat = DEFAULT_REPEAT(repeat); repeat > 0; repeat--)
		if(m_word1(win->buf, dir, end, space, to) == MOTION_FAILURE)
			return MOTION_FAILURE;

	return MOTION_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edx
andl $0x1, %edx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x2d(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x2e(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xf6d9
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xf6e3
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xf6e3
movl -0x34(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jbe 0xf72e
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
movb -0x2d(%rbp), %cl
movb -0x2e(%rbp), %al
movq -0x28(%rbp), %r8
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %edx
movzbl %al, %ecx
callq 0xf740
cmpl $0x0, %eax
jne 0xf721
movl $0x0, -0x4(%rbp)
jmp 0xf735
jmp 0xf723
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf6e9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_findnext
int m_findnext(motion_arg const *m, unsigned repeat, window *win, point_t *to)
{
	return m_findnext2(
			last_find_ch,
			m->find_type ^ last_find_type,
			repeat,
			win,
			to);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl 0xcabb(%rip), %edi      # 0x1c3d8
movq -0x8(%rbp), %rax
movl (%rax), %esi
xorl 0xcab3(%rip), %esi      # 0x1c3dc
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0xf940
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_find
int m_find(motion_arg const *m, unsigned repeat, window *win, point_t *to)
{
	bool raw;
	return m_findnext2(
			last_find_ch = io_getch(IO_NOMAP /* vim doesn't mapraw here */, &raw, true),
			last_find_type = m->find_type,
			repeat, win, to);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, %edx
leaq -0x21(%rbp), %rsi
movl %edx, %edi
callq 0x11310
movl %eax, %edi
movl %edi, 0xc889(%rip)      # 0x1c3d8
movq -0x8(%rbp), %rax
movl (%rax), %esi
movl %esi, 0xc881(%rip)      # 0x1c3dc
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0xf940
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_searchnext
int m_searchnext(motion_arg const *m, unsigned repeat, window *win, point_t *to)
{
	if(!lastsearch){
		ui_err("no last search");
		return MOTION_FAILURE;
	}

	const bool forward = m->i > 0;
	const int dir = (forward == lastsearch_forward) ? 1 : -1;

	repeat = DEFAULT_REPEAT(repeat);
	*to = *win->ui_pos;
	while(repeat --> 0){
		if(!buffer_findat(win->buf, lastsearch, to, dir)){
			ui_err("search pattern not found");
			return MOTION_FAILURE;
		}
	}

	ui_status("");
	return MOTION_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, 0xc801(%rip)      # 0x1c3e0
jne 0xfbfb
leaq 0x5bd6(%rip), %rdi      # 0x157be
movb $0x0, %al
callq 0x4f30
movl $0x0, -0x4(%rbp)
jmp 0xfcbb
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
setg %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
movb 0xc7d0(%rip), %al       # 0x1c3e8
andb $0x1, %al
movzbl %al, %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xfc3d
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xfc47
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xfc47
movl -0x34(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jbe 0xfca6
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq 0xc763(%rip), %rsi      # 0x1c3e0
movq -0x28(%rbp), %rdx
movl -0x30(%rbp), %ecx
callq 0xc350
testb $0x1, %al
jne 0xfca4
leaq 0x5b39(%rip), %rdi      # 0x157cd
movb $0x0, %al
callq 0x4f30
movl $0x0, -0x4(%rbp)
jmp 0xfcbb
jmp 0xfc5f
leaq 0x5b8b(%rip), %rdi      # 0x15838
movb $0x0, %al
callq 0x51a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_search
int m_search(motion_arg const *m, unsigned repeat, window *win, point_t *to)
{
	const bool forward = m->i > 0;

	char *target = prompt(forward ? '/' : '?', NULL);
	if(!target)
		return MOTION_FAILURE;

	m_setlastsearch(target, forward);

	return m_searchnext(&(motion_arg){ 1 }, repeat, win, to);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
setg %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %dl
movl $0x3f, %eax
movl $0x2f, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
xorl %ecx, %ecx
movl %ecx, %esi
movsbl %al, %edi
callq 0x10db0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xfd29
movl $0x0, -0x4(%rbp)
jmp 0xfd58
movq -0x38(%rbp), %rdi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xfb80
movl $0x1, -0x40(%rbp)
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0xfbc0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: m_visual
int m_visual(
		motion_arg const *arg, unsigned repeat,
		window *win, point_t *to)
{
	(void)repeat;

	if(!(win->ui_mode & UI_VISUAL_ANY))
		return MOTION_FAILURE;

	/* line, char? */
	switch(win->ui_mode){
		case UI_NORMAL:
		case UI_INSERT: /* fall */
		case UI_INSERT_COL:
		case UI_VISUAL_CHAR: *arg->phow = M_NONE; break;
		case UI_VISUAL_LN:   *arg->phow = M_LINEWISE; break;
		case UI_VISUAL_COL:  *arg->phow = M_COLUMN; break;
	}

	/* set `to' to the opposite corner */
	*to = *window_uipos_alt(win);

	return MOTION_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x38, %eax
cmpl $0x0, %eax
jne 0xfda2
movl $0x0, -0x4(%rbp)
jmp 0xfe2d
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x2c(%rbp)
decl %eax
subl $0x2, %eax
jb 0xfddd
jmp 0xfdb5
movl -0x2c(%rbp), %eax
subl $0x4, %eax
je 0xfddd
jmp 0xfdbf
movl -0x2c(%rbp), %eax
subl $0x8, %eax
je 0xfddd
jmp 0xfdc9
movl -0x2c(%rbp), %eax
subl $0x10, %eax
je 0xfdfb
jmp 0xfdd3
movl -0x2c(%rbp), %eax
subl $0x20, %eax
je 0xfdec
jmp 0xfe08
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl $0x0, (%rax)
jmp 0xfe08
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl $0x1, (%rax)
jmp 0xfe08
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl $0x4, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x13750
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)