LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xa2b9
movq %rdi, %rax
movq 0x18(%rsi), %rcx
movq %rdx, 0x18(%rsi)
movq %rsi, 0x20(%rdx)
testq %rcx, %rcx
je 0xa2bc
movq %rdx, %rsi
testq %rdx, %rdx
je 0xa2b0
movq 0x18(%rsi), %rdx
testq %rdx, %rdx
jne 0xa29f
movq %rcx, 0x18(%rsi)
movq %rsi, 0x20(%rcx)
retq
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa7f4
movq (%rdi), %rax
testq %rax, %rax
je 0xa7f4
movq $0x0, 0x20(%rax)
leal -0x1(%rdx), %ecx
movq %rax, -0x8(%rsp)
testl %ecx, %ecx
jle 0xa7f7
leaq -0x8(%rsp), %rcx
movq (%rcx), %rcx
cmpq $0x0, 0x18(%rcx)
je 0xa7fe
addq $0x18, %rcx
decl %edx
cmpl $0x1, %edx
jg 0xa7dd
jmp 0xa800
xorl %eax, %eax
retq
leaq -0x8(%rsp), %rcx
jmp 0xa800
xorl %ecx, %ecx
testq %rcx, %rcx
je 0xa80a
movq (%rcx), %rcx
jmp 0xa80c
xorl %ecx, %ecx
movq %rdi, %rdx
testq %rcx, %rcx
je 0xa822
movq 0x18(%rcx), %rdx
addq $0x18, %rcx
movq %rdx, (%rdi)
movq %rcx, %rdx
movq $0x0, (%rdx)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0xa835
movq %rsi, 0x20(%rcx)
movq $0x0, 0x20(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movl 0x4(%rsi), %eax
cmpl 0xc(%rsi), %eax
je 0xa976
jge 0xa983
movl %edx, %ebp
movq %rsi, %rbx
movq (%rdi), %rcx
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0xa890
testl %eax, %eax
jle 0xa894
incl %eax
leaq 0x8(%rsp), %rcx
movq (%rcx), %rcx
cmpq $0x0, 0x18(%rcx)
je 0xa890
addq $0x18, %rcx
decl %eax
cmpl $0x1, %eax
jg 0xa879
jmp 0xa899
xorl %ecx, %ecx
jmp 0xa899
leaq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0xa8a3
movq (%rcx), %r14
jmp 0xa8a6
xorl %r14d, %r14d
testq %r14, %r14
je 0xa976
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa8c0
leaq 0x8(%r14), %rsi
callq 0xc282
movslq 0x4(%rbx), %r15
incq %r15
movq 0x18(%r14), %r12
testq %r12, %r12
je 0xa958
movl 0xc(%rbx), %eax
cmpq %rax, %r15
ja 0xa958
movq (%r12), %rdi
testq %rdi, %rdi
je 0xa94b
leaq 0x8(%r12), %rsi
callq 0xc225
movq 0x8(%r12), %rax
movq 0x8(%r14), %rcx
addq %rcx, %rax
addq $0x2, %rax
cmpq %rax, 0x10(%r14)
jae 0xa909
movq %rax, 0x10(%r14)
movq (%r14), %rdi
movq 0x10(%r14), %rsi
callq 0x5851
movq %rax, (%r14)
testb %bpl, %bpl
je 0xa92d
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb $0x20, (%rax,%rcx)
movq (%r14), %rdi
addq 0x8(%r14), %rdi
movq (%r12), %rsi
movq 0x8(%r12), %rdx
callq 0x4350
movq 0x8(%r12), %rax
addq %rax, 0x8(%r14)
incq %r15
movq 0x18(%r12), %r12
jmp 0xa8cb
movslq 0x4(%rbx), %rax
incq %rax
cmpq %rax, %r15
je 0xa976
leaq 0x18(%r14), %rdi
subl %eax, %r15d
movq %r14, %rsi
movl %r15d, %edx
callq 0xa7b8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4cde(%rip), %rdi      # 0xf668
leaq 0x4c6e(%rip), %rsi      # 0xf5ff
leaq 0x4cf0(%rip), %rcx      # 0xf688
movl $0x273, %edx            # imm = 0x273
callq 0x4210
// File: /workspace/github_c_makefile_star2_O1/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 0xae10
testq %rcx, %rcx
je 0xae0b
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 0xae0f
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_O1/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 0xae59
incl %edi
movl %edi, (%rcx)
cmpq %rdi, 0x8(%rax)
ja 0xae7d
movq 0x18(%rax), %rax
incl (%rdx)
xorl %edi, %edi
jmp 0xae7b
testl %edi, %edi
je 0xae61
decl %edi
jmp 0xae7b
addl %esi, (%rdx)
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xae7d
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_O1/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 0xaea8
movq %rdi, %rax
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0xaea7
movl (%rsi), %edx
movq %rcx, %rax
incl %edx
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xae97
movl %edx, (%rsi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0xaee3
testl %ecx, %ecx
jle 0xaee7
incl %ecx
movq %rsp, %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0xaee3
addq $0x18, %rax
decl %ecx
cmpl $0x1, %ecx
jg 0xaecc
jmp 0xaeea
xorl %eax, %eax
jmp 0xaeea
movq %rsp, %rax
testq %rax, %rax
je 0xaef4
movq (%rax), %rdi
jmp 0xaef6
xorl %edi, %edi
testq %rdi, %rdi
je 0xaf76
movq (%rbx), %rax
movq %rsp, %rdx
movq %rax, (%rdx)
xorl %r15d, %r15d
movl $0x1, %esi
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0xd53c
testq %rax, %rax
je 0xaf79
movq %rax, %r14
movl 0x4(%rsp), %eax
cmpl 0x4(%rbx), %eax
jne 0xaf76
movq %rsp, %rbx
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xd5a3
movq (%rbx), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movl $0x1, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xd5a3
movslq (%rbx), %rdi
movl (%r15), %eax
subl %edi, %eax
addq (%r14), %rdi
incl %eax
movslq %eax, %rsi
callq 0x58a8
movq %rax, %r15
jmp 0xaf79
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x10, %rsp
movl 0x4(%rsi), %ecx
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0xafc1
testl %ecx, %ecx
jle 0xafc5
incl %ecx
leaq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0xafc1
addq $0x18, %rax
decl %ecx
cmpl $0x1, %ecx
jg 0xafaa
jmp 0xafca
xorl %eax, %eax
jmp 0xafca
leaq 0x8(%rsp), %rax
testq %rax, %rax
je 0xafd4
movq (%rax), %rax
jmp 0xafd6
xorl %eax, %eax
testq %rax, %rax
je 0xb0a7
movl (%rsi), %r15d
movq 0x8(%rax), %r14
cmpq %r15, %r14
jbe 0xb0a7
movslq %r15d, %r12
movq (%rax), %rbx
movsbl (%rbx,%r12), %edi
callq 0xb0c8
testb %al, %al
je 0xb036
testl %r15d, %r15d
js 0xb028
movsbl (%rbx,%r15), %edi
callq 0xb0c8
testb %al, %al
je 0xb028
leaq -0x1(%r15), %rax
testq %r15, %r15
movq %rax, %r15
jg 0xb008
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
leal 0x1(%r15), %eax
xorl %ebp, %ebp
testl %r15d, %r15d
cmovnsl %eax, %ebp
jmp 0xb05e
movl %r12d, %ebp
decl %ebp
movsbl (%rbx,%r12), %edi
callq 0xb0c8
movl %r12d, %ecx
incq %r12
incl %ebp
cmpq %rcx, %r14
jbe 0xb056
testb %al, %al
je 0xb03b
decl %r12d
cmpq %r12, %r14
je 0xb0a7
movl %ebp, %eax
movslq %ebp, %r15
movl %ebp, %r12d
cmpq %rax, %r14
jbe 0xb087
movq %r15, %r12
movsbl (%rbx,%r12), %edi
callq 0xb0c8
testb %al, %al
je 0xb087
incq %r12
movl %r12d, %eax
cmpq %rax, %r14
ja 0xb06e
leal -0x1(%r12), %eax
cmpl $0x2, %r12d
jl 0xb0a3
movl %eax, %ecx
addl $-0x2, %r12d
cmpb $0x2e, (%rbx,%rcx)
cmovnel %eax, %r12d
movl %r12d, %eax
subl %ebp, %eax
jge 0xb0b6
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq %r15, %rbx
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x58a8
jmp 0xb0a9
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %ecx
movl 0x4(%rsi), %eax
movq %rdi, -0x8(%rsp)
testq %rdi, %rdi
je 0xb151
testl %ecx, %ecx
jle 0xb155
leal 0x1(%rcx), %edi
leaq -0x8(%rsp), %rsi
movq (%rsi), %rsi
cmpq $0x0, 0x18(%rsi)
je 0xb151
addq $0x18, %rsi
decl %edi
cmpl $0x1, %edi
jg 0xb13a
jmp 0xb15a
xorl %esi, %esi
jmp 0xb15a
leaq -0x8(%rsp), %rsi
incl %eax
testq %rsi, %rsi
je 0xb166
movq (%rsi), %rsi
jmp 0xb168
xorl %esi, %esi
testq %rsi, %rsi
setne %dil
cmpl %ecx, %eax
setne %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
jne 0xb19c
subl %ecx, %eax
cltq
decq %rax
movl %edx, 0x28(%rsi)
movq 0x18(%rsi), %rsi
addq $-0x1, %rax
setb %cl
testq %rsi, %rsi
je 0xb19c
testb %cl, %cl
jne 0xb185
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb1c2
movq %rdi, %rax
movl $0x1, %ecx
cmpl %esi, 0x28(%rax)
je 0xb1c4
movq 0x18(%rax), %rax
movl %ecx, (%rdx)
incl %ecx
testq %rax, %rax
jne 0xb1b0
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %r12
subq (%rdx), %r12
leaq 0x1(%r12), %r13
movq %r13, %rdi
callq 0x5830
movq %rax, %rbp
movq (%rbx), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x4350
movb $0x0, (%rbp,%r12)
movq %r15, (%rsp)
movq (%r15), %r15
cmpq $0x0, (%r15)
je 0xb259
movl $0x30, %edi
callq 0x5830
movq %r15, 0x20(%rax)
movq %rax, 0x18(%r15)
movq %rax, %r15
movq %rbp, (%r15)
movq %r13, 0x10(%r15)
movq %r12, 0x8(%r15)
movq (%rsp), %rax
movq %r15, (%rax)
incq %r14
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb319
decl %esi
jmp 0xb32d
xorl %esi, %esi
testb %dl, %dl
je 0xb32d
movq (%rbx), %rax
movq 0x8(%rax), %rdi
callq 0xa9a2
movl %eax, %esi
movl %esi, 0x4(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb280
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r15
xorl %ebp, %ebp
movq %rdx, %rdi
xorl %esi, %esi
callq 0xdbe9
movq %rax, %r14
testq %rax, %rax
je 0xb371
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xb371
decl %eax
movl %eax, %ebp
movl %ebp, (%rbx)
cmpl $0x0, (%r15)
je 0xb3aa
movl (%rbx), %r15d
testl %r15d, %r15d
jle 0xb3aa
callq 0x4540
movq (%rax), %rax
movq (%r14), %rcx
movl %r15d, %edx
movsbq (%rcx,%rdx), %rdx
testb $0x20, 0x1(%rax,%rdx,2)
je 0xb3aa
leal -0x1(%r15), %edx
movl %edx, (%rbx)
cmpl $0x1, %r15d
movl %edx, %r15d
jg 0xb38c
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa9a2
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 0xb280
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb486
cmpl $0x1, %esi
movl %esi, %edx
adcl $0x0, %edx
imull %edx, %eax
movl %eax, 0x4(%rcx)
movl (%rdi), %eax
testl %eax, %eax
js 0xb497
cmpl $0x1, %esi
adcl $0x0, %esi
imull %esi, %eax
movl %eax, (%rcx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x1, %esi
adcl $0x0, %esi
movl 0x4(%rdi), %eax
imull %esi, %eax
addl 0x4(%rcx), %eax
movl %eax, 0x4(%rcx)
imull (%rdi), %esi
addl (%rcx), %esi
movl %esi, (%rcx)
orl %esi, %eax
notl %eax
shrl $0x1f, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdbe9
movl $0x0, 0xc(%rsp)
movq 0x30(%r14), %rcx
movq (%rcx), %rcx
movq %rbx, 0x10(%rsp)
movq %rcx, (%rbx)
testq %rax, %rax
je 0xb599
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 0xb599
decl %ebp
jne 0xb573
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
addl %eax, 0x4(%rcx)
jmp 0xb5b7
cmpb $0x0, (%r13)
movl $0x0, %ecx
jle 0xb5af
movq (%r14), %rdi
callq 0x977e
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_O1/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 %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0xb607
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb5ee
movq 0x8(%r14), %rsi
callq 0xc139
testb %al, %al
je 0xb607
movsbl (%r15), %esi
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xadfa
movq %rax, %r14
testq %rax, %rax
jne 0xb5d9
testq %r14, %r14
je 0xb63a
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb63a
movq 0x8(%r14), %rsi
callq 0xc139
testb %al, %al
jne 0xb63a
movsbl (%r15), %esi
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xadfa
movq %rax, %r14
testq %rax, %rax
jne 0xb60c
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl (%rcx), %ebp
testq %rsi, %rsi
je 0xb68b
movq %rsi, %rax
cmpq $0x0, 0x8(%rsi)
je 0xb6a0
movq (%rax), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %ebp
je 0xb68f
jmp 0xb6a0
xorl %eax, %eax
jmp 0xb6a0
movsbl (%r14), %esi
movq %rax, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xadfa
testq %rax, %rax
je 0xb6b6
cmpq $0x0, 0x8(%rax)
je 0xb68f
movq (%rax), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %ebp
jne 0xb68f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, (%rsp)
movl %eax, %ecx
andl $0x2, %ecx
shrl %ecx
cmpl $0x1, %esi
adcl $0x0, %ebp
xorl %eax, %ecx
movl %ecx, 0x8(%rsp)
movl %eax, %ecx
andl $0x4, %ecx
shrl $0x2, %ecx
movl %ecx, 0x4(%rsp)
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 0x9ede
movq %rax, %r14
movl (%rbx), %esi
movq %rax, %rdi
movl 0x4(%rsp), %edx
callq 0xd4d8
movl %eax, %r15d
movb $0x1, %r12b
andl $0x6, %r15d
je 0xb796
testb $0x1, 0x8(%rsp)
je 0xb75e
movl %eax, %r13d
movl (%rbx), %esi
addl (%rsp), %esi
movq %r14, %rdi
movl 0x4(%rsp), %edx
callq 0xd4d8
cmpl %r13d, %eax
je 0xb7c2
xorl $0x6, %r15d
movl %r15d, %ecx
orl $0x1, %ecx
movq %r14, %rdi
movl (%rsp), %esi
movq %rbx, %rdx
movl 0xc(%rsp), %r13d
movl %r13d, %r8d
callq 0xd53c
movq %rax, %r14
movl (%rbx), %esi
movq %rax, %rdi
movl %r13d, %edx
callq 0xd4d8
testl %r15d, %eax
je 0xb7de
xorl %r12d, %r12d
testb %r12b, %r12b
je 0xb7bb
movq %r14, %rdi
movl (%rsp), %esi
movq %rbx, %rdx
movl $0x6, %ecx
movl 0x4(%rsp), %r8d
callq 0xd53c
movq %rax, %r14
testq %rax, %rax
je 0xb7f3
testb $0x1, 0x8(%rsp)
je 0xb7d4
movq %r14, %rdi
movl (%rsp), %esi
movq %rbx, %rdx
movl 0x4(%rsp), %ecx
callq 0xd5a3
decl %ebp
jne 0xb70b
jmp 0xb7ec
testq %r14, %r14
je 0xb793
cmpq $0x0, 0x8(%r14)
jne 0xb796
jmp 0xb793
movl $0x1, %eax
jmp 0xb7f5
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_O1/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, %ebp
movl %edi, %r13d
xorl %r14d, %r14d
movq %rcx, %rdi
xorl %esi, %esi
callq 0xdbe9
testq %rax, %rax
je 0xb942
movq %rax, %r12
movq 0x30(%rbx), %rax
movl (%rax), %ebx
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
testb $0x2, %bpl
jne 0xb884
incl %ebx
cmpq %rbx, 0x8(%r12)
jbe 0xb942
movl $0x1, 0x8(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xb8b1
movq 0x8(%r12), %rcx
testq %rcx, %rcx
je 0xb942
cmpq %rbx, %rcx
cmoval %ebx, %ecx
testl %ecx, %ecx
jle 0xb942
decl %ecx
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
movl $0x1, %eax
movl %ecx, %ebx
cmpl $0x1, %r15d
adcl $0x0, %r15d
movsbl %r13b, %r13d
movl %ebp, %r14d
andl $0x1, %r14d
negl %r14d
andl %eax, %r14d
movq (%r12), %rdx
movslq %ebx, %rax
leaq (%rdx,%rax), %rdi
testb $0x2, %bpl
jne 0xb8ed
movq 0x8(%r12), %rdx
subq %rax, %rdx
movl %r13d, %esi
callq 0x42a0
jmp 0xb8f5
movl %r13d, %esi
callq 0xc064
testq %rax, %rax
je 0xb90d
movl %eax, %ebx
subl (%r12), %ebx
decl %r15d
je 0xb914
addl 0x8(%rsp), %ebx
xorl %eax, %eax
jmp 0xb92e
movl $0x1, %eax
jmp 0xb92e
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rcx)
leal (%r14,%rbx), %eax
movl %eax, (%rcx)
xorl %r15d, %r15d
movl $0x2, %eax
testl %eax, %eax
je 0xb8ca
cmpl $0x2, %eax
jne 0xb93f
movl $0x1, %r14d
jmp 0xb942
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xba0c(%rip)      # 0x173e8
je 0xba35
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
cmpl $0x0, (%rdi)
setg %al
xorl %ecx, %ecx
cmpb %al, 0xb9fc(%rip)       # 0x173f0
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 0xba47
movq (%r14), %rdi
movq 0xb9cb(%rip), %rsi      # 0x173e8
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x9787
testb %al, %al
jne 0xba0f
leaq 0x3cba(%rip), %rdi      # 0xf6ed
jmp 0xba3c
leaq 0x3ca2(%rip), %rdi      # 0xf6de
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4de2
jmp 0xba5a
leaq 0x3d0a(%rip), %rdi      # 0xf758
xorl %eax, %eax
callq 0x527a
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc364
testq %rax, %rax
je 0xbad4
movq %rax, %r12
movq 0xb943(%rip), %rdi      # 0x173e8
callq 0x4080
testl %r13d, %r13d
setg 0xb93c(%rip)            # 0x173f0
movq %r12, 0xb92d(%rip)      # 0x173e8
movq %rsp, %rdi
movl $0x1, (%rdi)
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xb9cd
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_O1/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 %rbx
movq %rcx, %rbx
movl 0x40(%rdx), %ecx
testb $0x38, %cl
je 0xbb20
cmpl $0x20, %ecx
ja 0xbb0b
xorl %eax, %eax
movl %ecx, %ecx
movl $0x116, %esi            # imm = 0x116
btq %rcx, %rsi
jae 0xbb24
movq (%rdi), %rcx
movl %eax, (%rcx)
movq %rdx, %rdi
callq 0xdbd8
movq (%rax), %rax
movq %rax, (%rbx)
movl $0x1, %eax
jmp 0xbb22
xorl %eax, %eax
popq %rbx
retq
cmpq $0x10, %rcx
je 0xbb37
cmpq $0x20, %rcx
jne 0xbb0b
movl $0x1, %eax
jmp 0xbb06
movl $0x4, %eax
jmp 0xbb06
// File: /workspace/github_c_makefile_star2_O1/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
movq %rcx, 0x10(%rsp)
movq (%rcx), %rax
testq %rax, %rax
setne %cl
je 0xbe60
movq %r8, %rbx
movl %edx, %ebp
movl %esi, %r15d
movl %edi, %r12d
leaq 0x4(%r8), %rdx
movq %rdx, 0x8(%rsp)
xorl %r13d, %r13d
xorl %r14d, %r14d
movl (%rbx), %edx
movq 0x8(%rax), %rdi
cmpq %rdx, %rdi
jbe 0xbe2d
movslq %edx, %rdx
movq (%rax), %rsi
addq %rsi, %rdx
addq %rsi, %rdi
decq %rdi
xorl %r8d, %r8d
movzbl (%rdx), %r10d
movsbl %r10b, %r9d
cmpl $0x27, %r10d
je 0xbdcb
cmpl $0x22, %r10d
jne 0xbdd5
testb %r8b, %r8b
je 0xbde9
cmpb %r10b, %r8b
je 0xbde9
testb %r8b, %r8b
jne 0xbe05
cmpl %r12d, %r9d
jne 0xbdf5
testl %r14d, %r14d
je 0xbe55
decl %r14d
jmp 0xbe02
cmpb %r10b, %r8b
cmovel %r13d, %r9d
movl %r9d, %r8d
jmp 0xbe05
xorl %r8d, %r8d
cmpl %r15d, %r9d
sete %r8b
addl %r8d, %r14d
xorl %r8d, %r8d
testl %ebp, %ebp
jle 0xbe16
movl $0x1, %r9d
cmpq %rdi, %rdx
jne 0xbe22
jmp 0xbe27
movq $-0x1, %r9
cmpq %rsi, %rdx
je 0xbe27
addq %r9, %rdx
jmp 0xbdb7
movb $0x1, %dl
testb %dl, %dl
je 0xbe60
movq %rax, %rdi
movl %ebp, %esi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0xadfa
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
testq %rax, %rax
setne %cl
jne 0xbd96
jmp 0xbe60
subl %esi, %edx
movl %edx, (%rbx)
xorl %r14d, %r14d
xorl %edx, %edx
jmp 0xbe29
andb $0x1, %cl
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbea5
cmpl $0x0, 0x4(%rbx)
js 0xbea3
movl $0x1, %eax
cmpl $0x0, (%rbx)
jns 0xbea5
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %rax
movq 0x30(%rdx), %rcx
movq (%rcx), %rdx
leaq 0x8(%rsp), %rcx
movq %rdx, (%rcx)
addq $0x8, %rdi
movq %rbx, %rdx
callq *(%rax)
cmpl $0x1, %eax
jne 0xbedc
movl 0x8(%rsp), %eax
orl 0xc(%rsp), %eax
notl %eax
shrl $0x1f, %eax
testl %eax, %eax
je 0xbf02
movq 0x30(%rbx), %rax
movq (%rax), %rcx
movl $0x1, %ebx
cmpq 0x8(%rsp), %rcx
je 0xbf04
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
callq 0x51d8
jmp 0xbf04
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movq 0x30(%rdx), %rax
movq (%rax), %rcx
leaq 0x10(%rsp), %r12
movq %rcx, -0x8(%r12)
movq $0x0, (%r12)
movl $0x0, 0x8(%r12)
movq (%rax), %rax
movq %rax, (%r12)
addq $0x8, %rdi
movq %r12, %rcx
callq *(%r14)
movl %eax, %ebp
cmpl $0x1, %eax
jne 0xbf68
movl 0x10(%rsp), %ebp
orl 0x14(%rsp), %ebp
notl %ebp
shrl $0x1f, %ebp
testl %ebp, %ebp
je 0xbfd0
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xcd9a
movl 0x10(%r14), %eax
testb $0x4, %al
jne 0xbf8f
testb $0x1, %al
jne 0xbfa5
movl $0x0, 0x18(%rsp)
jmp 0xbfad
leaq 0x8(%rsp), %rdi
movl $0x1, 0x10(%rdi)
movq %r12, %rsi
callq 0xcd79
jmp 0xbfad
movl $0x2, 0x18(%rsp)
testb $0x38, 0x40(%r15)
je 0xbfba
incl 0x10(%rsp)
jmp 0xbfc1
testb $0x3, 0x10(%r14)
je 0xbfb4
movl 0x18(%rsp), %eax
movl %eax, 0x10(%rbx)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rbx)
testl %ebp, %ebp
setne %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x399f(%rip), %rsi      # 0xf99e
movq %r14, %rdi
callq 0x4430
testq %rax, %rax
jne 0xc013
callq 0x46a2
jmp 0xc056
movq %rax, %r14
movq %r15, %rdi
movl %ebx, %esi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x9dab
movl %eax, %r15d
callq 0x40a0
movq %rax, %rbx
movl (%rax), %ebp
movq %r14, %rdi
callq 0x41d0
testl %r15d, %r15d
jne 0xc04f
movl (%rbx), %esi
movl %eax, %edi
callq 0x4603
movb $0x1, %al
jmp 0xc058
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_O1/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 0xc07e
cmpq %rdx, %rax
je 0xc07c
movsbl -0x1(%rax), %ecx
decq %rax
jmp 0xc06a
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc0bd
decq %r15
cmpq %r14, %r15
jae 0xc0a0
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc136
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r8
movq %rsi, %r9
xorl %r10d, %r10d
cmpb %cl, (%rdi,%r10)
jne 0xc121
leaq (%rdi,%r10), %rax
xorl %r14d, %r14d
movb $0x1, %bl
cmpq %r14, %r9
je 0xc117
movb (%r8,%r14), %bpl
cmpb (%rdx,%r14), %bpl
jne 0xc117
cmpb $0x0, 0x1(%rdx,%r14)
leaq 0x1(%r14), %r14
jne 0xc0f6
xorl %ebx, %ebx
jmp 0xc11a
movq %r11, %rax
movq %rax, %r11
testb %bl, %bl
je 0xc131
incq %r10
decq %r9
incq %r8
cmpq %rsi, %r10
jne 0xc0e9
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
sete %bpl
je 0xc183
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4540
movq (%rax), %rax
movsbq (%r14), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0xc183
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %rbx
je 0xc17c
movsbq (%r14,%rcx), %rsi
leaq 0x1(%rcx), %rdx
testb $0x20, 0x1(%rax,%rsi,2)
jne 0xc164
cmpq %rbx, %rcx
setae %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rdi, %r14
movq (%rsi), %rbx
testq %rbx, %rbx
je 0xc25b
callq 0x4540
movq (%rax), %rcx
xorl %eax, %eax
movsbq (%r14,%rax), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0xc25d
incq %rax
cmpq %rax, %rbx
jne 0xc242
movq %rbx, %rax
jmp 0xc25d
xorl %eax, %eax
testq %rax, %rax
je 0xc27c
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_O1/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 0xc2b8
movq %rdi, %r14
callq 0x4540
movq (%rax), %rcx
movsbq -0x1(%r14,%r15), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0xc2b8
movb $0x0, -0x1(%r14,%r15)
decq %r15
jne 0xc29a
xorl %r15d, %r15d
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc34e
movq %rdi, %rbx
callq 0x4540
movq (%rax), %rax
movsbq 0x1(%rbx), %rcx
testb $0x4, 0x1(%rax,%rcx,2)
jne 0xc34e
leaq 0x34c9(%rip), %rdi      # 0xf7b8
callq 0x4040
testq %rax, %rax
je 0xc34e
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 0x4350
addq %r14, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x4350
movb $0x0, (%r14,%rbp)
jmp 0xc351
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xc6c4
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 0x4b59
callq 0x4cfa
leal -0x1(%rax), %edi
xorl %esi, %esi
callq 0x4b81
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 0x4ce5
leaq 0x7(%rsp), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0xc772
movl %eax, %ebp
movl (%rbx), %edi
movl (%r14), %esi
callq 0x4b81
movl %ebp, %edi
callq 0x4558
cmpl $0x79, %eax
sete %al
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xac6d(%rip), %rdx      # 0x173f8
testq %rdx, %rdx
je 0xc7c5
movq 0xac69(%rip), %rdi      # 0x17400
movzwl (%rdi), %r12d
movl %r12d, %r15d
shrl $0x8, %r15d
andl $0x1, %r15d
decq %rdx
movq %rdx, 0xac48(%rip)      # 0x173f8
je 0xc7bf
leaq 0x4(%rdi), %rsi
shlq $0x2, %rdx
callq 0x4400
movzbl %r12b, %eax
jmp 0xc7d8
movl %ebx, %edi
andl $0x10, %edi
shrl $0x4, %edi
movq %r14, %rsi
callq 0x4bca
xorl %r15d, %r15d
testb %bpl, %bpl
je 0xc87d
movb (%r14), %cl
notb %cl
orb %r15b, %cl
testb $0x1, %cl
je 0xc87d
leaq 0xa0e7(%rip), %r14      # 0x168e0
cmpq $0x0, 0x8(%r14)
je 0xc81c
andl $-0x11, %ebx
testl %ebx, (%r14)
je 0xc811
movsbl 0x4(%r14), %ecx
cmpl %ecx, %eax
je 0xc81f
cmpq $0x0, 0x18(%r14)
leaq 0x10(%r14), %r14
jne 0xc803
xorl %r14d, %r14d
testq %r14, %r14
je 0xc87d
movq 0x8(%r14), %rdi
callq 0x4170
testq %rax, %rax
je 0xc84a
movq %rax, %rbx
movq 0x8(%r14), %rax
movsbl -0x1(%rax,%rbx), %edi
xorl %esi, %esi
callq 0xc8a5
decq %rbx
jne 0xc835
movq 0xabaf(%rip), %rdi      # 0x17400
movzwl (%rdi), %ebx
movq 0xab9d(%rip), %rdx      # 0x173f8
decq %rdx
movq %rdx, 0xab93(%rip)      # 0x173f8
je 0xc874
leaq 0x4(%rdi), %rsi
shlq $0x2, %rdx
callq 0x4400
btl $0x8, %ebx
jb 0xc886
movzbl %bl, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x302f(%rip), %rdi      # 0xf8bc
leaq 0x3032(%rip), %rsi      # 0xf8c6
leaq 0x3030(%rip), %rcx      # 0xf8cb
movl $0x6a, %edx
callq 0x4210
// File: /workspace/github_c_makefile_star2_O1/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 0xc772
movl %eax, %ebp
movl %eax, %r14d
callq 0x4540
xorl %r15d, %r15d
cmpl $0x30, %ebp
je 0xc9c0
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
je 0xc9c0
addl $-0x30, %ebp
leaq 0xf(%rsp), %rsi
movl %ebx, %edi
movl $0x1, %edx
callq 0xc772
movl %eax, %r14d
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0xc9bd
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 0xc772
movl %eax, %r14d
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0xc995
jmp 0xc9c0
movl %ebp, %r15d
movl %r14d, %edi
xorl %esi, %esi
callq 0xc8a5
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xce90
testq %r14, %r14
je 0xca11
cmpq $0x0, 0x20(%r14)
jne 0xca11
movq %r14, (%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2ed9(%rip), %rdi      # 0xf8f1
leaq 0x2ee0(%rip), %rsi      # 0xf8ff
leaq 0x2ee0(%rip), %rcx      # 0xf906
movl $0x19, %edx
callq 0x4210
// File: /workspace/github_c_makefile_star2_O1/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 0xa9c0(%rip), %rdi      # 0x17410
testq %rdi, %rdi
je 0xca61
leaq -0x2c(%rip), %rsi       # 0xca30
callq 0xce9b
movq %rbx, %rdi
callq 0xce90
movq %rax, 0xa9a0(%rip)      # 0x17410
popq %rbx
retq