LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xa0eb
movq %rdi, %rax
movq 0x18(%rsi), %rcx
movq %rdx, 0x18(%rsi)
movq %rsi, 0x20(%rdx)
testq %rcx, %rcx
je 0xa0ea
movq %rdx, %rsi
movq 0x18(%rdx), %rdx
testq %rdx, %rdx
jne 0xa0d6
movq %rcx, 0x18(%rsi)
movq %rsi, 0x20(%rcx)
retq
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %edx, %edx
je 0xa604
movq (%rdi), %rax
testq %rax, %rax
je 0xa604
movq $0x0, 0x20(%rax)
leal -0x1(%rdx), %r8d
movq %rax, %rcx
testl %r8d, %r8d
jle 0xa5e7
movq %rax, %rcx
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
je 0xa607
decl %edx
cmpl $0x1, %edx
jg 0xa5d7
movq 0x18(%rcx), %rdx
movq %rdx, (%rdi)
movq $0x0, 0x18(%rcx)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0xa60e
movq %rsi, 0x20(%rcx)
jmp 0xa60e
xorl %eax, %eax
retq
movq $0x0, (%rdi)
movq $0x0, 0x20(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/list.c
// Function: list_joinregion
void list_joinregion(list_t **pl, const region_t *region, const bool space)
{
	if(region->begin.y == region->end.y)
		return;

	assert(region->begin.y < region->end.y);

	list_t *l, *start = list_seek(*pl, region->begin.y, false);

	if(!start)
		return;

	if(start->line)
		str_rtrim(start->line, &start->len_line);

	size_t i;

	for(l = start->next, i = region->begin.y + 1;
			l && i <= (unsigned)region->end.y;
			l = l->next, i++)
	{
		if(!l->line)
			continue;

		str_ltrim(l->line, &l->len_line);

		/* + 1 for \0, +1 for JOIN_CHAR */
		const size_t target = start->len_line + l->len_line + 2;

		if(start->len_malloc < target)
			start->len_malloc = target;

		start->line = urealloc(
				start->line,
				start->len_malloc);

		if(space)
			start->line[start->len_line++] = JOIN_CHAR;

		memcpy(start->line + start->len_line,
				l->line,
				l->len_line);

		start->len_line += l->len_line;
	}

	size_t ndelete = i - (region->begin.y + 1);
	if(ndelete)
		list_dellines(&start->next, start, ndelete);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x4(%rsi), %eax
cmpl 0xc(%rsi), %eax
je 0xa724
jge 0xa752
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xa724
movl %edx, %ebp
movq %rsi, %r14
testl %eax, %eax
jle 0xa660
leal 0x1(%rax), %ecx
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
je 0xa724
decl %ecx
cmpl $0x1, %ecx
jg 0xa64c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa675
leaq 0x8(%rbx), %rsi
callq 0xbf0f
movl 0x4(%r14), %eax
movq 0x18(%rbx), %r13
testq %r13, %r13
je 0xa724
leaq 0x18(%rbx), %r15
incl %eax
movslq %eax, %r12
movl 0xc(%r14), %eax
cmpq %rax, %r12
ja 0xa718
movq (%r13), %rdi
testq %rdi, %rdi
je 0xa708
leaq 0x8(%r13), %rsi
callq 0xbeb4
movq 0x8(%r13), %rax
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rsi
addq %rcx, %rax
addq $0x2, %rax
cmpq %rax, %rsi
jae 0xa6c9
movq %rax, 0x10(%rbx)
movq %rax, %rsi
movq (%rbx), %rdi
callq 0x584a
movq %rax, (%rbx)
testb %bpl, %bpl
je 0xa6ec
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb $0x20, (%rax,%rcx)
movq (%rbx), %rax
addq 0x8(%rbx), %rax
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rax, %rdi
callq 0x4360
movq 0x8(%r13), %rax
addq %rax, 0x8(%rbx)
incq %r12
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0xa68b
movslq 0x4(%r14), %rax
incq %rax
cmpq %rax, %r12
jne 0xa733
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
subl %eax, %r12d
movq %r15, %rdi
movq %rbx, %rsi
movl %r12d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa5b4
leaq 0x3f00(%rip), %rdi      # 0xe659
leaq 0x3e90(%rip), %rsi      # 0xe5f0
leaq 0x3f12(%rip), %rcx      # 0xe679
movl $0x273, %edx            # imm = 0x273
callq 0x4210
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/list.c
// Function: list_iter_region
void list_iter_region(
		list_t *l, const region_t *r,
		enum list_iter_flags flags,
		list_iter_f fn, void *ctx)
{
	size_t i = 0;
	size_t end = r->end.y - r->begin.y + 1;

	for(l = list_seek(l, r->begin.y, false);
			l && i < end; l = l->next, i++)
	{
		const size_t y = i + r->begin.y;
		bool next = true;

		switch(r->type){
			case REGION_LINE:
				if(flags & LIST_ITER_WHOLE_LINE)
					next = fn(l->line, l, y, ctx);
				else
					next = line_iter(l, 0, l->len_line, y, fn, ctx);
				break;
			case REGION_COL:
				next = line_iter(l, r->begin.x, r->end.x, y, fn, ctx);
				break;
			case REGION_CHAR:
				next = line_iter(l,
						i == 0 ? r->begin.x : 0,
						i+1 == end ? (unsigned)r->end.x : l->len_line,
						y, fn, ctx);
				break;
		}
		if(flags & LIST_ITER_EVAL_NL)
			list_evalnewlines1(l);
		if(!next)
			break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x18(%rsp)
testq %rdi, %rdi
je 0xa9f0
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r12
movl 0x4(%rsi), %ecx
movl 0xc(%rsi), %eax
testl %ecx, %ecx
jle 0xa9ea
leal 0x1(%rcx), %edx
movq 0x18(%r12), %r12
testq %r12, %r12
je 0xa9f0
decl %edx
cmpl $0x1, %edx
jg 0xa9d9
incl %eax
cmpl %ecx, %eax
jne 0xa9ff
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
subl %ecx, %eax
cltq
movq %rax, 0x20(%rsp)
xorl %r13d, %r13d
movl %r15d, 0xc(%rsp)
movq %rbx, 0x10(%rsp)
movl 0x4(%rbx), %ebp
movl 0x10(%rbx), %eax
addq %r13, %rbp
testl %eax, %eax
je 0xaac7
cmpl $0x1, %eax
je 0xaa83
cmpl $0x2, %eax
jne 0xab34
testb $0x2, %r15b
jne 0xaad1
movq 0x8(%r12), %rbx
testq %rbx, %rbx
je 0xab2f
xorl %r15d, %r15d
cmpq 0x8(%r12), %r15
jae 0xab2a
movq (%r12), %rdi
addq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq 0x18(%rsp), %rcx
callq *%r14
testb %al, %al
je 0xab6f
incq %r15
cmpq %r15, %rbx
jne 0xaa4f
jmp 0xab2a
movq %rbx, %rax
movslq (%rbx), %rbx
movslq 0x8(%rax), %r15
cmpl %r15d, %ebx
jae 0xab2a
cmpq 0x8(%r12), %rbx
jae 0xab2a
movq (%r12), %rdi
addq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq 0x18(%rsp), %rcx
callq *%r14
testb %al, %al
je 0xab6f
incq %rbx
cmpq %rbx, %r15
jne 0xaa96
jmp 0xab2a
testq %r13, %r13
je 0xaae6
xorl %r15d, %r15d
jmp 0xaae9
movq (%r12), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq 0x18(%rsp), %rcx
callq *%r14
movl %eax, %ebp
jmp 0xab37
movslq (%rbx), %r15
leaq 0x1(%r13), %rax
cmpq 0x20(%rsp), %rax
jne 0xaaf9
movl 0x8(%rbx), %ebx
jmp 0xaafe
movq 0x8(%r12), %rbx
cmpq %rbx, %r15
jae 0xab2a
cmpq 0x8(%r12), %r15
jae 0xab2a
movq (%r12), %rdi
addq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq 0x18(%rsp), %rcx
callq *%r14
testb %al, %al
je 0xab6f
incq %r15
cmpq %r15, %rbx
jne 0xab03
movl 0xc(%rsp), %r15d
movq 0x10(%rsp), %rbx
movb $0x1, %bpl
testb $0x1, %r15b
je 0xab45
movq %r12, %rdi
callq 0x9d52
testb %bpl, %bpl
je 0xa9f0
movq 0x18(%r12), %r12
testq %r12, %r12
je 0xa9f0
incq %r13
cmpq 0x20(%rsp), %r13
jb 0xaa15
jmp 0xa9f0
xorl %ebp, %ebp
movl 0xc(%rsp), %r15d
movq 0x10(%rsp), %rbx
jmp 0xab37
// File: /workspace/github_c_makefile_star2_O3/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:
addl %esi, (%rdx)
testl %esi, %esi
jle 0xab93
testq %rcx, %rcx
je 0xab8e
movl $0x0, (%rcx)
movq 0x18(%rdi), %rax
retq
movq 0x20(%rdi), %rax
testq %rcx, %rcx
setne %dl
testq %rax, %rax
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xab92
movq 0x8(%rax), %rdx
leal -0x1(%rdx), %esi
xorl %edi, %edi
testq %rdx, %rdx
cmovnel %esi, %edi
movl %edi, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdi, %rax
movl (%rcx), %edi
testl %esi, %esi
jle 0xabdc
incl %edi
movl %edi, (%rcx)
cmpq %rdi, 0x8(%rax)
ja 0xac00
movq 0x18(%rax), %rax
incl (%rdx)
xorl %edi, %edi
jmp 0xabfe
testl %edi, %edi
je 0xabe4
decl %edi
jmp 0xabfe
addl %esi, (%rdx)
movq 0x20(%rax), %rax
xorl %edx, %edx
testq %rax, %rax
je 0xac01
movq 0x8(%rax), %rsi
leal -0x1(%rsi), %edi
testq %rsi, %rsi
cmovel %edx, %edi
movl %edi, (%rcx)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0x0, (%rsi)
testq %rdi, %rdi
je 0xac2e
movq %rdi, %rax
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0xac2d
xorl %edx, %edx
movq %rcx, %rax
incl %edx
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xac1d
movl %edx, (%rsi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xace0
movq %rsi, %r14
movl 0x4(%rsi), %eax
testl %eax, %eax
jle 0xac65
incl %eax
xorl %ebx, %ebx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xace2
decl %eax
cmpl $0x1, %eax
jg 0xac51
movq (%r14), %rax
movq %rsp, %rdx
movq %rax, (%rdx)
xorl %ebx, %ebx
movl $0x1, %esi
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0xd1b8
testq %rax, %rax
je 0xace2
movq %rax, %r15
movl 0x4(%rsp), %eax
cmpl 0x4(%r14), %eax
jne 0xace0
movq %rsp, %rbx
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xd224
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %r15, %rdi
movl $0x1, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xd224
movslq (%rbx), %rdi
movl (%r14), %eax
subl %edi, %eax
addq (%r15), %rdi
incl %eax
movslq %eax, %rsi
callq 0x5889
movq %rax, %rbx
jmp 0xace2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/list.c
// Function: list_fname_at
char *list_fname_at(list_t *l, point_t const *pt)
{
	l = list_seek(l, pt->y, false);
	if(!l)
		return NULL;

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

	int start = pt->x;
	if(isfnamechar(l->line[start])){
		/* look backwards for the start */
		for(; start >= 0 && isfnamechar(l->line[start]); start--)
			;

		if(start < 0)
			start = 0;
		else /* !isfnamechar(line[start]) */
			start++;

	}else{
		/* look forwards for the beginning */
		for(; !isfnamechar(l->line[start]) && (unsigned)start < l->len_line; start++)
			;

		if((unsigned)start == l->len_line)
			return NULL;
	}


	int end = start;
	for(; (unsigned)end < l->len_line && isfnamechar(l->line[end]); end++)
		;

	/* end is either at the end of the line or not a fnamechar,
	 * either way: */
	end--;

	/* avoid '.' at the end */
	if(end > 0 && l->line[end] == '.')
		end--;

	if(end < start)
		return NULL;

	return ustrdup_len(&l->line[start], end - start + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xaddd
movl 0x4(%rsi), %eax
testl %eax, %eax
jle 0xad1d
incl %eax
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xaddd
decl %eax
cmpl $0x1, %eax
jg 0xad09
movl (%rsi), %r15d
movq 0x8(%rdi), %r14
cmpq %r15, %r14
jbe 0xaddd
movq (%rdi), %rbx
movslq %r15d, %r12
movsbl (%rbx,%r12), %edi
callq 0xae00
testb %al, %al
je 0xad61
xorl %ebp, %ebp
testl %r15d, %r15d
js 0xad94
incq %r15
movsbl -0x1(%rbx,%r15), %edi
callq 0xae00
testb %al, %al
je 0xad89
decq %r15
jg 0xad4b
jmp 0xad94
decl %r15d
movl %r15d, %ebp
movsbl (%rbx,%r12), %edi
callq 0xae00
movl %r12d, %ecx
incl %ebp
cmpq %rcx, %r14
jbe 0xad82
incq %r12
testb %al, %al
je 0xad67
cmpq %rcx, %r14
jne 0xad96
jmp 0xaddd
movq %r15, %rax
decq %rax
js 0xad94
movl %r15d, %ebp
movl %ebp, %ecx
movslq %ebp, %r15
movl %ebp, %r12d
cmpq %rcx, %r14
jbe 0xadbd
movq %r15, %r12
movsbl (%rbx,%r12), %edi
callq 0xae00
testb %al, %al
je 0xadbd
incq %r12
movl %r12d, %eax
cmpq %rax, %r14
ja 0xada4
leal -0x1(%r12), %eax
cmpl $0x2, %r12d
jl 0xadd9
movl %eax, %ecx
addl $-0x2, %r12d
cmpb $0x2e, (%rbx,%rcx)
cmovnel %eax, %r12d
movl %r12d, %eax
subl %ebp, %eax
jge 0xade8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq %r15, %rbx
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5889
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xae9c
movl (%rsi), %ecx
movl 0x4(%rsi), %eax
testl %ecx, %ecx
jle 0xae78
leal 0x1(%rcx), %esi
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xae9c
decl %esi
cmpl $0x1, %esi
jg 0xae68
incl %eax
cmpl %ecx, %eax
je 0xae9c
subl %ecx, %eax
cltq
decq %rax
movl %edx, 0x28(%rdi)
movq 0x18(%rdi), %rdi
addq $-0x1, %rax
setb %cl
testq %rdi, %rdi
je 0xae9c
testb %cl, %cl
jne 0xae85
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0x0, (%rdx)
testq %rdi, %rdi
je 0xaec2
movq %rdi, %rax
movl $0x1, %ecx
cmpl %esi, 0x28(%rax)
je 0xaec4
movq 0x18(%rax), %rax
movl %ecx, (%rdx)
incl %ecx
testq %rax, %rax
jne 0xaeb0
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
testl %esi, %esi
je 0xb019
decl %esi
jmp 0xb02d
xorl %esi, %esi
testb %dl, %dl
je 0xb02d
movq (%rbx), %rax
movq 0x8(%rax), %rdi
callq 0xa771
movl %eax, %esi
movl %esi, 0x4(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaf80
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r15
movq %rdx, %rdi
xorl %esi, %esi
callq 0xd868
testq %rax, %rax
je 0xb0aa
movq %rax, %r14
movq 0x8(%rax), %r12
testq %r12, %r12
je 0xb0aa
leal -0x1(%r12), %eax
movl %eax, (%rbx)
cmpl $0x0, (%r15)
je 0xb0b0
testl %eax, %eax
jle 0xb0b0
callq 0x4540
movq (%rax), %rax
movq (%r14), %rcx
leal -0x1(%r12), %edx
movsbq (%rcx,%rdx), %rsi
testb $0x20, 0x1(%rax,%rsi,2)
je 0xb0b0
addl $-0x2, %r12d
movl %r12d, (%rbx)
movl %edx, %r12d
cmpl $0x1, %edx
jg 0xb088
jmp 0xb0b0
movl $0x0, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq (%rdx), %rax
movq 0x8(%rax), %rdi
callq 0xa771
movl 0xc(%r14), %ecx
movl 0x1c(%r14), %edx
leal -0x1(%rdx), %esi
movl %eax, %edi
subl %ecx, %edi
cmpl %edx, %eax
cmovgel %esi, %edi
xorl %eax, %eax
testl %edi, %edi
cmovgl %edi, %eax
addl %ecx, %eax
movl %eax, 0x4(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaf80
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x4(%rdi), %eax
testl %eax, %eax
js 0xb18d
cmpl $0x1, %esi
movl %esi, %edx
adcl $0x0, %edx
imull %edx, %eax
movl %eax, 0x4(%rcx)
movl (%rdi), %eax
testl %eax, %eax
js 0xb19e
cmpl $0x1, %esi
adcl $0x0, %esi
imull %esi, %eax
movl %eax, (%rcx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r13
movq %rdx, %rdi
xorl %esi, %esi
callq 0xd868
movl $0x0, 0xc(%rsp)
movq 0x30(%r14), %rcx
movq (%rcx), %rcx
movq %rbx, 0x10(%rsp)
movq %rcx, (%rbx)
testq %rax, %rax
je 0xb2b1
cmpl $0x1, %ebp
adcl $0x0, %ebp
leaq 0xc(%rsp), %rbx
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq *%r12
testq %rax, %rax
je 0xb2b1
decl %ebp
jne 0xb28b
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
addl %eax, 0x4(%rcx)
jmp 0xb2cf
cmpb $0x0, (%r13)
movl $0x0, %ecx
jle 0xb2c7
movq (%r14), %rdi
callq 0x960e
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xb328
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorl %ebx, %ebx
movq (%r12), %rdi
testq %rdi, %rdi
je 0xb30d
movq 0x8(%r12), %rsi
callq 0xbdc5
testb %al, %al
je 0xb32c
movsbl (%r15), %esi
movq %r12, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xab7d
movq %rax, %r12
testq %rax, %rax
jne 0xb2f6
jmp 0xb363
xorl %ebx, %ebx
jmp 0xb363
xorl %ebx, %ebx
movq (%r12), %rdi
testq %rdi, %rdi
je 0xb360
movq 0x8(%r12), %rsi
callq 0xbdc5
testb %al, %al
jne 0xb360
movsbl (%r15), %esi
movq %r12, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xab7d
movq %rax, %r12
testq %rax, %rax
jne 0xb32e
jmp 0xb363
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xb400
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movl (%rcx), %ebp
cmpq $0x0, 0x8(%rsi)
je 0xb3d4
movq (%rax), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %ebp
jne 0xb3d4
movsbl (%r14), %esi
xorl %r15d, %r15d
movq %rax, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xab7d
testq %rax, %rax
je 0xb408
xorl %r15d, %r15d
cmpq $0x0, 0x8(%rax)
je 0xb3e8
movq (%rax), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %ebp
je 0xb405
movsbl (%r14), %esi
movq %rax, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xab7d
testq %rax, %rax
jne 0xb3d7
jmp 0xb408
xorl %r15d, %r15d
jmp 0xb408
movq %rax, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movl %esi, %ebp
movl (%rdi), %eax
movl %eax, %ecx
andl $0x1, %ecx
negl %ecx
orl $0x1, %ecx
movl %ecx, 0x4(%rsp)
movl %eax, %ecx
andl $0x2, %ecx
shrl %ecx
cmpl $0x1, %esi
adcl $0x0, %ebp
xorl %eax, %ecx
movl %ecx, 0x8(%rsp)
movl %eax, %r13d
andl $0x4, %r13d
shrl $0x2, %r13d
shrl $0x2, %eax
andl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movl 0x4(%rbx), %esi
xorl %edx, %edx
callq 0x9d35
movq %rax, %r14
movl (%rbx), %esi
movq %rax, %rdi
movl %r13d, %edx
callq 0xd154
movl %eax, %r15d
andl $0x6, %r15d
je 0xb4f7
testb $0x1, 0x8(%rsp)
je 0xb4b5
movl %eax, %r12d
movl (%rbx), %esi
addl 0x4(%rsp), %esi
movq %r14, %rdi
movl %r13d, %edx
callq 0xd154
cmpl %r12d, %eax
je 0xb51d
xorl $0x6, %r15d
movl %r15d, %ecx
orl $0x1, %ecx
movq %r14, %rdi
movl 0x4(%rsp), %esi
movq %rbx, %rdx
movl 0xc(%rsp), %r12d
movl %r12d, %r8d
callq 0xd1b8
movq %rax, %r14
movl (%rbx), %esi
movq %rax, %rdi
movl %r12d, %edx
callq 0xd154
testl %r15d, %eax
jne 0xb516
testq %r14, %r14
je 0xb539
cmpq $0x0, 0x8(%r14)
je 0xb516
movq %r14, %rdi
movl 0x4(%rsp), %esi
movq %rbx, %rdx
movl $0x6, %ecx
movl %r13d, %r8d
callq 0xd1b8
movq %rax, %r14
testq %rax, %rax
je 0xb545
testb $0x1, 0x8(%rsp)
je 0xb52f
movq %r14, %rdi
movl 0x4(%rsp), %esi
movq %rbx, %rdx
movl %r13d, %ecx
callq 0xd224
decl %ebp
jne 0xb466
jmp 0xb53e
xorl %r14d, %r14d
jmp 0xb516
movl $0x1, %eax
jmp 0xb547
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/motion.c
// Function: m_findnext2
static int m_findnext2(const int ch, enum find_type ftype, unsigned repeat, window *win, point_t *to)
{
	list_t *l = window_current_line(win, false); /* fine - repeat handled */

	if(!l)
		return MOTION_FAILURE;

	point_t bpos = *win->ui_pos;

	if(!(ftype & F_REV)){
		bpos.x++;
		if((unsigned)bpos.x >= l->len_line)
			return MOTION_FAILURE;
	}else{
		if(l->len_line == 0)
			return MOTION_FAILURE;

		/* if we're after the actual length, move from logical to it */
		if((unsigned)bpos.x >= l->len_line)
			bpos.x = l->len_line;

		bpos.x--;

		if(bpos.x < 0)
			return MOTION_FAILURE;
	}

	repeat = DEFAULT_REPEAT(repeat);

	for(;;){
		char *p = l->line + bpos.x;

		p = strchrdir(p, ch, ftype & F_REV, l->line, l->len_line);

		if(!p)
			return MOTION_FAILURE;

		bpos.x = p - l->line;

		if(--repeat == 0){
			const int adj = ftype & F_TIL ? ftype & F_REV ? 1 : -1 : 0;

			*to = bpos;
			to->x += adj;
			break;
		}else{
			bpos.x += ftype & F_REV ? -1 : +1;
		}
	}

	return MOTION_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %r14d
movl %edi, %r13d
xorl %ebp, %ebp
movq %rcx, %rdi
xorl %esi, %esi
callq 0xd868
testq %rax, %rax
je 0xb66b
movq %rax, %r12
movq 0x30(%rbx), %rax
movl (%rax), %ecx
movl 0x4(%rax), %edx
testb $0x2, %r14b
jne 0xb5c9
incl %ecx
movl $0x1, %ebx
cmpq %rcx, 0x8(%r12)
ja 0xb5ee
jmp 0xb66b
movq 0x8(%r12), %rax
testq %rax, %rax
je 0xb66b
cmpq %rcx, %rax
cmoval %ecx, %eax
testl %eax, %eax
jle 0xb66b
decl %eax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %eax, %ecx
movl %edx, 0xc(%rsp)
cmpl $0x1, %r15d
adcl $0x0, %r15d
movsbl %r13b, %r13d
movq (%r12), %rdx
movslq %ecx, %rax
leaq (%rdx,%rax), %rdi
testb $0x2, %r14b
jne 0xb621
movq 0x8(%r12), %rdx
subq %rax, %rdx
movl %r13d, %esi
callq 0x42a0
jmp 0xb629
movl %r13d, %esi
callq 0xbd04
testq %rax, %rax
je 0xb66b
movq (%r12), %rdx
subl %edx, %eax
leal (%rbx,%rax), %ecx
decl %r15d
jne 0xb602
movl %r14d, %ecx
andl $0x2, %ecx
andl $0x1, %r14d
negl %r14d
xorl %edx, %edx
cmpl $0x1, %ecx
sbbl %edx, %edx
orl $0x1, %edx
andl %r14d, %edx
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %esi
movl %esi, 0x4(%rcx)
addl %eax, %edx
movl %edx, (%rcx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0xace4(%rip)      # 0x163e8
je 0xb75d
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
cmpl $0x0, (%rdi)
setg %al
xorl %ecx, %ecx
cmpb %al, 0xacd4(%rip)       # 0x163f0
sete %cl
cmpl $0x1, %esi
adcl $0x1, %ebp
leal -0x1(,%rcx,2), %r15d
movq 0x30(%rdx), %rax
movq (%rax), %rax
movq %rax, (%rbx)
decl %ebp
je 0xb76f
movq (%r14), %rdi
movq 0xaca3(%rip), %rsi      # 0x163e8
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x9617
testb %al, %al
jne 0xb737
leaq 0x2f83(%rip), %rdi      # 0xe6de
jmp 0xb764
leaq 0x2f6b(%rip), %rdi      # 0xe6cf
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4de2
jmp 0xb782
leaq 0x2fd3(%rip), %rdi      # 0xe749
xorl %eax, %eax
callq 0x5273
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movl (%rdi), %r13d
xorl %edi, %edi
testl %r13d, %r13d
setle %dil
shll $0x4, %edi
orl $0x2f, %edi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0xbff0
testq %rax, %rax
je 0xb7fc
movq %rax, %r12
movq 0xac1b(%rip), %rdi      # 0x163e8
callq 0x4080
testl %r13d, %r13d
setg 0xac14(%rip)            # 0x163f0
movq %r12, 0xac05(%rip)      # 0x163e8
movq %rsp, %rdi
movl $0x1, (%rdi)
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xb6f5
movl %eax, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x40(%rdx), %eax
testb $0x38, %al
je 0xb82f
pushq %rbx
movq %rcx, %rbx
cmpl $0x8, %eax
je 0xb839
cmpl $0x10, %eax
je 0xb832
cmpl $0x20, %eax
jne 0xb840
movl $0x1, %eax
jmp 0xb83b
xorl %eax, %eax
retq
movl $0x4, %eax
jmp 0xb83b
xorl %eax, %eax
movq (%rdi), %rcx
movl %eax, (%rcx)
movq %rdx, %rdi
callq 0xd857
movq (%rax), %rax
movq %rax, (%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/motion.c
// Function: find_unnested_paren
static bool find_unnested_paren(
		const int ptofind, const int porig, const int dir,
		list_t **pl, point_t *pos)
{
	int nest = 0;

	for(list_t *l = *pl;
	    l;
	    l = *pl = list_advance_y(l, dir, &pos->y, &pos->x))
	{
		if((unsigned)pos->x >= l->len_line)
			continue;

		char in_quote = 0; /* scoped here - ignore multi-line quotes */

		char *p = l->line + pos->x;
		while(1){
			if((*p == '\'' || *p == '"')
			&& (!in_quote || in_quote == *p))
			{
				if(in_quote == *p){
					in_quote = 0;
				}else{
					in_quote = *p;
				}
			}else if(in_quote){
				/* skipping quotes */
			}else if(*p == ptofind){
				if(nest == 0){
					pos->x = p - l->line;
					return true;
				}
				nest--;
			}else if(*p == porig){
				nest++;
			}

			if(dir > 0){
				if(p == l->line + l->len_line - 1)
					break;
				p++;
			}else{
				if(p == l->line)
					break;
				p--;
			}
		}
	}

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0xc(%rsp)
movq (%rcx), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0xbb16
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %edi, %r13d
leaq 0x4(%r8), %rcx
movq %rcx, 0x10(%rsp)
xorl %r12d, %r12d
movl (%r14), %ecx
movq 0x8(%rax), %rsi
cmpq %rcx, %rsi
jbe 0xbaed
movslq %ecx, %rcx
movq (%rax), %rdx
addq %rdx, %rcx
addq %rdx, %rsi
decq %rsi
xorl %edi, %edi
movzbl (%rcx), %r9d
movsbl %r9b, %r8d
cmpl $0x27, %r9d
je 0xba91
cmpl $0x22, %r9d
jne 0xbaa7
testb %dil, %dil
movzbl %dil, %r9d
movl %r9d, %edi
cmovel %r8d, %edi
cmpb %r8b, %r9b
cmovel %ebx, %edi
jmp 0xbacb
testb %dil, %dil
jne 0xbacb
cmpl %r13d, %r8d
jne 0xbabb
testl %r12d, %r12d
je 0xbb0f
decl %r12d
jmp 0xbac9
xorl %edi, %edi
cmpl 0xc(%rsp), %r8d
sete %dil
addl %edi, %r12d
xorl %edi, %edi
testl %ebp, %ebp
jle 0xbadc
movl $0x1, %r8d
cmpq %rsi, %rcx
jne 0xbae8
jmp 0xbaed
movq $-0x1, %r8
cmpq %rdx, %rcx
je 0xbaed
addq %r8, %rcx
jmp 0xba7d
movq %rax, %rdi
movl %ebp, %esi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
callq 0xab7d
movq %rax, (%r15)
testq %rax, %rax
jne 0xba5c
xorl %ebx, %ebx
jmp 0xbb16
subl %edx, %ecx
movl %ecx, (%r14)
movb $0x1, %bl
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/motion.c
// Function: motion_apply_win_dry
int motion_apply_win_dry(
		const motion *m, unsigned repeat,
		window *win, point_t *out)
{
	*out = *win->ui_pos;
	int r = m->func(&m->arg, repeat, win, out);
	if(r == MOTION_SUCCESS){
		if(out->y < 0 || out->x < 0)
			r = MOTION_FAILURE;
	}
	return r;
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movq %rdi, %rax
movq 0x30(%rdx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rbx)
addq $0x8, %rdi
movq %rbx, %rcx
callq *(%rax)
cmpl $0x1, %eax
jne 0xbb58
cmpl $0x0, 0x4(%rbx)
js 0xbb56
movl $0x1, %eax
cmpl $0x0, (%rbx)
jns 0xbb58
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/motion.c
// Function: motion_apply_win
int motion_apply_win(const motion *m, unsigned repeat, window *win)
{
	point_t to;

	if(motion_apply_win_dry(m, repeat, win, &to)){
		if(memcmp(win->ui_pos, &to, sizeof to)){
			*win->ui_pos = to;
			ui_cur_changed();
		}
		return MOTION_SUCCESS;
	}
	return MOTION_FAILURE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rax
movq 0x30(%rdx), %rcx
movq (%rcx), %rdx
movq %rsp, %rcx
movq %rdx, (%rcx)
addq $0x8, %rdi
movq %r14, %rdx
callq *(%rax)
movl %eax, %ebx
testl %eax, %eax
je 0xbbb2
cmpl $0x1, %ebx
jne 0xbb94
xorl %ebx, %ebx
cmpl $0x0, 0x4(%rsp)
js 0xbbb2
cmpl $0x0, (%rsp)
js 0xbbb2
movq 0x30(%r14), %rax
movq (%rax), %rcx
movl $0x1, %ebx
cmpq (%rsp), %rcx
je 0xbbb2
movq (%rsp), %rcx
movq %rcx, (%rax)
callq 0x51ce
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/motion.c
// Function: motion_to_region
bool motion_to_region(
		const motion *m, unsigned repeat,
		window *win, region_t *out)
{
	region_t r = {
		.begin = *win->ui_pos
	};
	if(!motion_apply_win_dry(m, repeat, win, &r.end))
		return false;

	/* reverse if negative range */
	point_sort_yx(&r.begin, &r.end);

	if(m->how & M_COLUMN){
		r.type = REGION_COL;

		/* needs to be done before incrementing r.end.x/y below */
		point_sort_full(&r.begin, &r.end);

	}else if(m->how & M_LINEWISE){
		r.type = REGION_LINE;

	}else{
		r.type = REGION_CHAR;
	}

	if(win->ui_mode & UI_VISUAL_ANY){
		/* only increment y in the line case */
		r.end.x++;

	}else if(!(m->how & M_LINEWISE) && !(m->how & M_EXCLUSIVE)){
		/* linewise motions are always inclusive */
		++r.end.x;
	}

	*out = r;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movq 0x30(%rdx), %rax
movq (%rax), %rax
leaq 0x8(%rsp), %r12
movq %rax, -0x8(%r12)
movl $0x0, 0x8(%r12)
movq %rax, (%r12)
addq $0x8, %rdi
movq %r12, %rcx
callq *(%r14)
testl %eax, %eax
je 0xbc32
cmpl $0x1, %eax
jne 0xbc11
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
js 0xbc76
cmpl $0x0, 0x8(%rsp)
js 0xbc76
movq %rsp, %rdi
movq %r12, %rsi
callq 0xca00
movl 0x10(%r14), %eax
testb $0x4, %al
jne 0xbc36
testb $0x1, %al
jne 0xbc4a
movl $0x0, 0x10(%rsp)
jmp 0xbc52
xorl %eax, %eax
jmp 0xbc76
movq %rsp, %rdi
movl $0x1, 0x10(%rdi)
movq %r12, %rsi
callq 0xc9dd
jmp 0xbc52
movl $0x2, 0x10(%rsp)
testb $0x38, 0x40(%r15)
je 0xbc5f
incl 0x8(%rsp)
jmp 0xbc66
testb $0x3, 0x10(%r14)
je 0xbc59
movl 0x10(%rsp), %eax
movl %eax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/external.c
// Function: shellout_write
bool shellout_write(const char *cmd, list_t *seeked, int nlines)
{
	ui_term();

	FILE *subp = popen(cmd, "w");

	if(!subp){
		fprintf(stderr, "fork/exec: %s", strerror(errno));
		return false;
	}

	int r = list_write_file(seeked, nlines, subp, /*eol*/true);
	int errno_write = errno;

	int waitret = pclose(subp);
	int errno_wait = errno;

	if(r){
		fprintf(stderr, "write subprocess: %s", strerror(errno_write));
		return false;
	}

	if(WIFEXITED(waitret)){
		int ec = WEXITSTATUS(waitret);

		if(ec)
			fprintf(stderr, "command returned %d\n", ec);

	}else if(WIFSIGNALED(waitret)){
		fprintf(stderr, "command signalled with %d\n", WTERMSIG(waitret));
	}else if(WIFSTOPPED(waitret)){
		fprintf(stderr, "command stopped with %d\n", WSTOPSIG(waitret));
	}else{
		fprintf(stderr, "unknown state from wait()/pclose(): %d: %s",
				waitret, strerror(errno_wait));
	}

	shellout_wait_ret();

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x5737
leaq 0x2cef(%rip), %rsi      # 0xe98e
movq %r14, %rdi
callq 0x4430
testq %rax, %rax
jne 0xbcb3
callq 0x46a2
jmp 0xbcf6
movq %rax, %r14
movq %r15, %rdi
movl %ebx, %esi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x9c00
movl %eax, %r15d
callq 0x40a0
movq %rax, %rbx
movl (%rax), %ebp
movq %r14, %rdi
callq 0x41d0
testl %r15d, %r15d
jne 0xbcef
movl (%rbx), %esi
movl %eax, %edi
callq 0x4603
movb $0x1, %al
jmp 0xbcf8
movl %ebp, %edi
callq 0x45de
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/str.c
// Function: strchr_rev
char *strchr_rev(const char *s, int ch, const char *start)
{
	while(*s != ch){
		if(s == start)
			return NULL;
		s--;
	}
	return (char *)s; /* *s == ch */
}

// Assembly:
movq %rdi, %rax
movsbl (%rdi), %ecx
cmpl %esi, %ecx
je 0xbd1e
cmpq %rdx, %rax
je 0xbd1c
movsbl -0x1(%rax), %ecx
decq %rax
jmp 0xbd0a
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/str.c
// Function: tim_strrevstr
char *tim_strrevstr(char *restrict haystack, unsigned off, const char *restrict needle)
{
	const size_t nlen = strlen(needle);

	for(char *p = haystack + off;
			p >= haystack;
			p--)
	{
		if(!strncmp(p, needle, nlen))
			return p;
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
callq 0x4170
movq %rax, %r12
movl %ebp, %r15d
addq %r14, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x40c0
testl %eax, %eax
je 0xbd5d
decq %r15
cmpq %r14, %r15
jae 0xbd40
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/str.c
// Function: tim_strstr
char *tim_strstr(char *restrict haystack, size_t len, const char *restrict needle)
{
	if(!*needle)
		return NULL;

	/* memstr */
	for(size_t h = 0; h < len; h++)
		if(haystack[h] == *needle)
			/* can assume needle is 0-terminated */
			for(size_t n = 0; n < len - h;){
				if(haystack[h + n] != needle[n])
					break;
				n++;
				if(!needle[n])
					return haystack + h;
			}

	return NULL;
}

// Assembly:
movb (%rdx), %cl
testb %cl, %cl
sete %al
testq %rsi, %rsi
sete %r8b
orb %al, %r8b
jne 0xbdc2
pushq %rbx
movq %rdi, %r8
movq %rsi, %r9
xorl %r10d, %r10d
cmpb %cl, (%rdi,%r10)
jne 0xbdb0
leaq (%rdi,%r10), %rax
xorl %r11d, %r11d
cmpq %r11, %r9
je 0xbdb0
movb (%r8,%r11), %bl
cmpb (%rdx,%r11), %bl
jne 0xbdb0
cmpb $0x0, 0x1(%rdx,%r11)
leaq 0x1(%r11), %r11
jne 0xbd93
jmp 0xbdc0
incq %r10
decq %r9
incq %r8
cmpq %rsi, %r10
jne 0xbd86
xorl %eax, %eax
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/str.c
// Function: isallspace
bool isallspace(const char *s, size_t len)
{
	for(size_t i = 0; i < len; i++)
		if(!isspace(s[i]))
			return false;
	return true;
}

// Assembly:
testq %rsi, %rsi
je 0xbdeb
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4540
movq (%rax), %rax
movsbq (%r14), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xbdee
xorl %eax, %eax
jmp 0xbe11
movb $0x1, %al
retq
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %rbx
je 0xbe0b
movsbq (%r14,%rcx), %rsi
leaq 0x1(%rcx), %rdx
testb $0x20, 0x1(%rax,%rsi,2)
jne 0xbdf3
cmpq %rbx, %rcx
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/str.c
// Function: str_ltrim
void str_ltrim(char *s, size_t *pl)
{
	size_t i;
	for(i = 0; i < *pl && isspace(s[i]); i++);

	if(i)
		memmove(s, s + i, *pl -= i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %rbx
testq %rbx, %rbx
je 0xbf09
movq %rsi, %r15
movq %rdi, %r14
callq 0x4540
movq (%rax), %rcx
xorl %eax, %eax
movsbq (%r14,%rax), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0xbeea
incq %rax
cmpq %rax, %rbx
jne 0xbed1
movq %rbx, %rax
jmp 0xbeef
testq %rax, %rax
je 0xbf09
leaq (%r14,%rax), %rsi
subq %rax, %rbx
movq %rbx, (%r15)
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4400
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/str.c
// Function: str_rtrim
void str_rtrim(char *s, size_t *pl)
{
	size_t i = *pl;

	while(i > 0 && isspace(s[i - 1])){
		s[i - 1] = '\0';
		i--;
	}

	*pl = i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %r15
testq %r15, %r15
je 0xbf42
movq %rdi, %r14
callq 0x4540
movq (%rax), %rcx
movsbq -0x1(%r14,%r15), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0xbf45
movb $0x0, -0x1(%r14,%r15)
decq %r15
jne 0xbf27
xorl %r15d, %r15d
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/str.c
// Function: expand_tilde
char *expand_tilde(const char *in)
{
	if(*in != '~')
		return NULL;

	const char *user = in + 1;

	if(isalpha(*user)){
		const char *user_end;

		for(user_end = user; isalnum(*user_end); user_end++);
		/* TODO */

		return NULL;
	}else{
		/* plain ~ */
		const char *home = getenv("HOME");
		if(!home)
			return NULL;

		size_t homelen = strlen(home);
		size_t userlen = strlen(user);
		size_t len = homelen + userlen + 1;
		char *ret = umalloc(len);

		memcpy(ret, home, homelen);
		memcpy(ret + homelen, user, userlen);
		ret[homelen + userlen] = '\0';
		return ret;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x7e, (%rdi)
jne 0xbfdb
movq %rdi, %rbx
callq 0x4540
movq (%rax), %rax
movsbq 0x1(%rbx), %rcx
testb $0x4, 0x1(%rax,%rcx,2)
jne 0xbfdb
leaq 0x282d(%rip), %rdi      # 0xe7a9
callq 0x4040
testq %rax, %rax
je 0xbfdb
movq %rax, %r15
incq %rbx
movq %rax, %rdi
callq 0x4170
movq %rax, %r12
movq %rbx, %rdi
callq 0x4170
movq %rax, %r13
leaq (%rax,%r12), %rbp
leaq (%rax,%r12), %rdi
incq %rdi
callq 0x5830
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4360
addq %r14, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x4360
movb $0x0, (%r14,%rbp)
jmp 0xbfde
xorl %r14d, %r14d
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/bobrippling[P]tim/prompt.c
// Function: yesno
bool yesno(const char *fmt, ...)
{
	int y, x;
	nc_get_yx(&y, &x);
	nc_set_yx(nc_LINES() - 1, 0);

	va_list l;
	va_start(l, fmt);
	nc_vprintf(fmt, l);
	va_end(l);

	bool wasraw;
	int ch = io_getch(IO_NOMAP, &wasraw, /*domaps:*/true);

	nc_set_yx(y, x);

	return tolower(ch) == 'y';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %r15
leaq 0x30(%rsp), %r12
movq %rsi, 0x8(%r12)
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0xc331
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0xc(%rsp), %rbx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b65
callq 0x4cfb
leal -0x1(%rax), %edi
xorl %esi, %esi
callq 0x4b8c
leaq 0x10(%rsp), %rsi
movq %r12, 0x10(%rsi)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x4ce6
leaq 0x7(%rsp), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0xc3de
movl %eax, %ebp
movl (%rbx), %edi
movl (%r14), %esi
callq 0x4b8c
movl %ebp, %edi
callq 0x4558
cmpl $0x79, %eax
sete %al
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/io.c
// Function: io_getch
int io_getch(enum io ty, bool *wasraw, bool domaps)
{
	if(wasraw)
		*wasraw = false;

	int ch;
	bool need_map = false;
	if(io_fifoused)
		ch = io_fifo_pop(&need_map);
	else
		ch = nc_getch(ty & IO_MAPRAW, wasraw);

	/* don't run maps for raw keys */
	if(domaps && (!wasraw || !*wasraw || need_map)){
		const keymap_t *map = io_findmap(ch, ty & ~IO_MAPRAW);

		if(map){
			for(size_t i = strlen(map->to); i > 0; i--)
				io_ungetch(map->to[i-1], false);

			ch = io_fifo_pop(&need_map);
			assert(!need_map); /* corresponds to the false above */
			return ch;
		}
	}

	return ch;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %ebx
movb $0x0, (%rsi)
movq 0xa001(%rip), %rdx      # 0x163f8
testq %rdx, %rdx
je 0xc431
movq 0x9ffd(%rip), %rdi      # 0x16400
movzwl (%rdi), %r12d
movl %r12d, %r15d
shrl $0x8, %r15d
andl $0x1, %r15d
decq %rdx
movq %rdx, 0x9fdc(%rip)      # 0x163f8
je 0xc42b
leaq 0x4(%rdi), %rsi
shlq $0x2, %rdx
callq 0x4400
movzbl %r12b, %eax
jmp 0xc444
movl %ebx, %edi
andl $0x10, %edi
shrl $0x4, %edi
movq %r14, %rsi
callq 0x4bd5
xorl %r15d, %r15d
testb %bpl, %bpl
je 0xc4e5
movb (%r14), %cl
notb %cl
orb %r15b, %cl
testb $0x1, %cl
je 0xc4e5
leaq 0x947b(%rip), %rcx      # 0x158e0
cmpq $0x0, 0x8(%rcx)
je 0xc4e5
andl $-0x11, %ebx
addq $0x8, %rcx
testl %ebx, -0x8(%rcx)
je 0xc480
movsbl -0x4(%rcx), %edx
cmpl %edx, %eax
je 0xc48d
cmpq $0x0, 0x10(%rcx)
leaq 0x10(%rcx), %rcx
jne 0xc473
jmp 0xc4e5
movq (%rcx), %rbx
movq %rbx, %rdi
callq 0x4170
testq %rax, %rax
je 0xc4b2
movq %rax, %r14
movsbl -0x1(%rbx,%r14), %edi
xorl %esi, %esi
callq 0xc50d
decq %r14
jne 0xc4a0
movq 0x9f47(%rip), %rdi      # 0x16400
movzwl (%rdi), %ebx
movq 0x9f35(%rip), %rdx      # 0x163f8
decq %rdx
movq %rdx, 0x9f2b(%rip)      # 0x163f8
je 0xc4dc
leaq 0x4(%rdi), %rsi
shlq $0x2, %rdx
callq 0x4400
btl $0x8, %ebx
jb 0xc4ee
movzbl %bl, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23b7(%rip), %rdi      # 0xe8ac
leaq 0x23ba(%rip), %rsi      # 0xe8b6
leaq 0x23b8(%rip), %rcx      # 0xe8bb
movl $0x6a, %edx
callq 0x4210
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/io.c
// Function: io_read_repeat
unsigned io_read_repeat(enum io io_mode)
{
	unsigned repeat = 0;

	bool raw;
	int ch = io_getch(io_mode, &raw, true);
	(void)raw;

	if(isdigit(ch) && ch != '0'){
		repeat = ch - '0';
		/* more repeats */
		for(;;){
			ch = io_getch(io_mode, &raw, true);
			if('0' <= ch && ch <= '9')
				repeat = repeat * 10 + ch - '0';
			else
				break;
		}
	}

	io_ungetch(ch, false);
	return repeat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
callq 0xc3de
movl %eax, %ebp
movl %eax, %r14d
callq 0x4540
xorl %r15d, %r15d
cmpl $0x30, %ebp
je 0xc622
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
je 0xc622
addl $-0x30, %ebp
leaq 0xf(%rsp), %rsi
movl %ebx, %edi
movl $0x1, %edx
callq 0xc3de
movl %eax, %r14d
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0xc61f
leaq 0xf(%rsp), %r12
movl %ebp, %r15d
leal (%r15,%r15,4), %eax
leal (%r14,%rax,2), %r15d
addl $-0x30, %r15d
movl %ebx, %edi
movq %r12, %rsi
movl $0x1, %edx
callq 0xc3de
movl %eax, %r14d
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0xc5f7
jmp 0xc622
movl %ebp, %r15d
movl %r14d, %edi
xorl %esi, %esi
callq 0xc50d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/yank.c
// Function: yank_new
yank *yank_new(list_t *l, enum region_type as)
{
	yank *y = retain(umalloc(sizeof *y));
	assert(l && !l->prev);
	y->list = l;
	y->as = as;
	return y;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x10, %edi
callq 0x5830
movq %rax, %rdi
callq 0xcaf4
testq %r14, %r14
je 0xc671
cmpq $0x0, 0x20(%r14)
jne 0xc671
movq %r14, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2269(%rip), %rdi      # 0xe8e1
leaq 0x2270(%rip), %rsi      # 0xe8ef
leaq 0x2270(%rip), %rcx      # 0xe8f6
movl $0x19, %edx
callq 0x4210
// File: /workspace/github_c_makefile_star2_O3/bobrippling[P]tim/yank.c
// Function: yank_push
yank *yank_push(yank *y)
{
	if(yank_buf)
		release(yank_buf, yank_free);
	yank_buf = retain(y);
	return yank_buf;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x9d60(%rip), %rdi      # 0x16410
testq %rdi, %rdi
je 0xc6c1
leaq -0x2c(%rip), %rsi       # 0xc690
callq 0xcaff
movq %rbx, %rdi
callq 0xcaf4
movq %rax, 0x9d40(%rip)      # 0x16410
popq %rbx
retq