LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0x102fa
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x102f1
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x102f8
movl $0x0, -0x24(%rbp)
jmp 0x102fa
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x10290
cmpl $0x0, %eax
je 0x10376
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x1036d
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
callq 0x5050
movl $0x1, -0x4(%rbp)
jmp 0x1037d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/motion.c
// Function: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq %rax, -0x3c(%rbp)
leaq -0x3c(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x4240
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x3c(%rbp), %rcx
addq $0x8, %rcx
callq 0x10290
cmpl $0x0, %eax
jne 0x103f7
movb $0x0, -0x1(%rbp)
jmp 0x104b2
leaq -0x3c(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
addq $0x8, %rsi
callq 0x11e00
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x10431
movl $0x1, -0x2c(%rbp)
leaq -0x3c(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
addq $0x8, %rsi
callq 0x11da0
jmp 0x10452
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x10449
movl $0x2, -0x2c(%rbp)
jmp 0x10450
movl $0x0, -0x2c(%rbp)
jmp 0x10452
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x38, %eax
cmpl $0x0, %eax
je 0x1046c
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x10495
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x10493
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x10493
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x10495
movq -0x28(%rbp), %rax
movq -0x3c(%rbp), %rcx
movq %rcx, (%rax)
movq -0x34(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/external.c
// Function: shellout
int shellout(const char *cmd)
{
	const char *shcmd;
	int r;

	if(cmd){
		shcmd = cmd;
	}else{
		const char *shell = getenv("SHELL");
		if(!shell)
			shell = "sh";
		shcmd = shell;
	}

	ui_term();

	r = system(shcmd);

	shellout_wait_ret();

	ui_init();

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1058d
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x105b7
leaq 0x5267(%rip), %rdi      # 0x157fb
callq 0x4040
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x105af
leaq 0x5201(%rip), %rax      # 0x157ac
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x5890
movq -0x10(%rbp), %rdi
callq 0x41a0
movl %eax, -0x14(%rbp)
callq 0x10530
callq 0x52d0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x107ed
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x107df
movq $0x0, -0x8(%rbp)
jmp 0x107f5
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x107bf
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4170
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x10868
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x40c0
cmpl $0x0, %eax
jne 0x10858
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10870
jmp 0x1085a
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1082e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x108a6
movq $0x0, -0x8(%rbp)
jmp 0x10955
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1094d
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x1093a
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jae 0x10938
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
addq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x1090e
jmp 0x10938
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x10936
movq -0x10(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10955
jmp 0x108db
jmp 0x1093a
jmp 0x1093c
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x108ae
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x109bd
callq 0x4530
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x109ad
movb $0x0, -0x1(%rbp)
jmp 0x109c1
jmp 0x109af
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x10978
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/str.c
// Function: paren_lookup
static const struct paren *paren_lookup(char c)
{
	unsigned char u = c;

	if(u >= sizeof parens / sizeof *parens)
		return &parens[0];
	return &parens[u];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
cmpq $0x7e, %rax
jb 0x10ac7
leaq 0x4ddf(%rip), %rax      # 0x158a0
movq %rax, -0x8(%rbp)
jmp 0x10ade
movzbl -0xa(%rbp), %eax
movl %eax, %ecx
leaq 0x4dcc(%rip), %rax      # 0x158a0
shlq %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x19(%rbp)
jae 0x10b93
callq 0x4530
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x10b9c
jmp 0x10bac
jmp 0x10b9e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10b58
cmpq $0x0, -0x18(%rbp)
je 0x10bd5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rdx
subq %rcx, %rdx
movq %rdx, (%rax)
callq 0x4400
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
jbe 0x10c34
callq 0x4530
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x10c3d
jmp 0x10c5b
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10bfb
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
je 0x10c95
movq $0x0, -0x8(%rbp)
jmp 0x10d9a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
callq 0x4530
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x10d04
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x4530
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x10cf7
jmp 0x10ce9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x10cc9
movq $0x0, -0x8(%rbp)
jmp 0x10d9a
leaq 0x4b8d(%rip), %rdi      # 0x15898
callq 0x4040
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x10d25
movq $0x0, -0x8(%rbp)
jmp 0x10d9a
movq -0x28(%rbp), %rdi
callq 0x4170
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4170
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5f20
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x4350
movq -0x48(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x4350
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
addq -0x38(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/prompt.c
// Function: prompt_ctrl_r
static void prompt_ctrl_r(char **const buf, size_t *const len, size_t *const i)
{
	int y, x;
	nc_get_yx(&y, &x);
	nc_addch('"');
	nc_set_yx(y, x);

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

	/* f: cursor filename
	 * w: cursor word
	 * W: cursor WORD
	 * %: filename [% register]
	 */
	char *to_insert = NULL;
	bool free_to_insert = true;

	switch(ch){
		case CTRL_AND('f'):
			to_insert = window_current_fname(windows_cur());
			break;
		case CTRL_AND('w'):
			to_insert = window_current_word(windows_cur());
			break;
		case '%':
			to_insert = (char *)buffer_fname(buffers_cur());
			free_to_insert = false;
			break;

		default:
			goto cancel;
	}

	if(!to_insert)
		goto cancel;

	size_t to_insert_len = strlen(to_insert);

	if(*i + to_insert_len + 1 >= *len){
		*len = *i + to_insert_len + 1;
		*buf = urealloc(*buf, *len);
	}

	memcpy(*buf + *i, to_insert, to_insert_len + 1);
	*i += to_insert_len;

	if(free_to_insert)
		free(to_insert);
	return;

cancel:
	nc_clrtoeol();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4b10
movl $0x22, %edi
callq 0x4cf0
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x4b90
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
movl %edx, %edi
callq 0x11310
movl %eax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movb $0x1, -0x31(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x6, %eax
je 0x110d6
jmp 0x110c2
movl -0x44(%rbp), %eax
subl $0x17, %eax
je 0x110e9
jmp 0x110cc
movl -0x44(%rbp), %eax
subl $0x25, %eax
je 0x110fc
jmp 0x11113
callq 0x13c60
movq %rax, %rdi
callq 0x13800
movq %rax, -0x30(%rbp)
jmp 0x11118
callq 0x13c60
movq %rax, %rdi
callq 0x137d0
movq %rax, -0x30(%rbp)
jmp 0x11118
callq 0x13c60
movq (%rax), %rdi
callq 0xbb30
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
jmp 0x11118
jmp 0x111ba
cmpq $0x0, -0x30(%rbp)
jne 0x11124
jmp 0x111ba
movq -0x30(%rbp), %rdi
callq 0x4170
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq -0x40(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x1117c
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq -0x40(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x5f60
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
addq (%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq $0x1, %rdx
callq 0x4350
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
testb $0x1, -0x31(%rbp)
je 0x111b8
movq -0x30(%rbp), %rdi
callq 0x4080
jmp 0x111bf
callq 0x4e90
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x1120b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4b10
callq 0x4e70
movl %eax, %edi
decl %edi
xorl %esi, %esi
callq 0x4b90
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x8, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4e40
leaq -0x31(%rbp), %rsi
movl $0x1, %edx
movl %edx, %edi
callq 0x11310
movl %eax, -0x38(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x4b90
movl -0x38(%rbp), %edi
callq 0x4548
subl $0x79, %eax
sete %al
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/io.c
// Function: bufmode_to_iomap
enum io bufmode_to_iomap(enum buf_mode bufmode)
{
	if(bufmode & UI_INSERT_ANY)
		return IO_MAPI;

	if(bufmode & UI_VISUAL_ANY)
		return IO_MAPV;

	return IO_MAP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x6, %eax
cmpl $0x0, %eax
je 0x112eb
movl $0x8, -0x4(%rbp)
jmp 0x11306
movl -0x8(%rbp), %eax
andl $0x38, %eax
cmpl $0x0, %eax
je 0x112ff
movl $0x4, -0x4(%rbp)
jmp 0x11306
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11334
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movb $0x0, -0x19(%rbp)
cmpq $0x0, 0xb0b0(%rip)      # 0x1c3f0
je 0x11350
leaq -0x19(%rbp), %rdi
callq 0x11440
movl %eax, -0x18(%rbp)
jmp 0x1136e
movl -0x8(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
setne %al
movq -0x10(%rbp), %rsi
movzbl %al, %edi
andl $0x1, %edi
callq 0x4c30
movl %eax, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
je 0x11429
cmpq $0x0, -0x10(%rbp)
je 0x11392
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x11392
testb $0x1, -0x19(%rbp)
je 0x11429
movl -0x18(%rbp), %edi
movl -0x8(%rbp), %esi
andl $-0x11, %esi
callq 0x114d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x11427
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4170
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x113ec
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %edi
xorl %esi, %esi
callq 0x11540
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x113bc
leaq -0x19(%rbp), %rdi
callq 0x11440
movl %eax, -0x18(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x11400
jmp 0x1141f
leaq 0x4595(%rip), %rdi      # 0x1599c
leaq 0x4598(%rip), %rsi      # 0x159a6
movl $0x6a, %edx
leaq 0x4591(%rip), %rcx      # 0x159ab
callq 0x4210
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1142f
jmp 0x11429
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/io.c
// Function: io_fifo_pop
static int io_fifo_pop(bool *need_map)
{
	/* pull a char from the fifo */
	int ret = io_fifo->ch;
	*need_map = io_fifo->needs_map;

	io_fifoused--;
	if(io_fifoused)
		memmove(io_fifo, io_fifo + 1, sizeof(*io_fifo) * io_fifoused);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xafa5(%rip), %rax      # 0x1c3f8
movw (%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
movl %eax, -0xc(%rbp)
movq 0xaf91(%rip), %rax      # 0x1c3f8
movw (%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
setne %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq 0xaf65(%rip), %rax      # 0x1c3f0
addq $-0x1, %rax
movq %rax, 0xaf5a(%rip)      # 0x1c3f0
cmpq $0x0, 0xaf52(%rip)      # 0x1c3f0
je 0x114c2
movq 0xaf51(%rip), %rdi      # 0x1c3f8
movq 0xaf4a(%rip), %rsi      # 0x1c3f8
addq $0x4, %rsi
movq 0xaf37(%rip), %rdx      # 0x1c3f0
shlq $0x2, %rdx
callq 0x4400
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/io.c
// Function: io_findmap
static const keymap_t *io_findmap(int ch, enum io mode_mask)
{
	extern const keymap_t maps[];

	for(const keymap_t *m = maps; m->to; m++)
		if(m->mode & mode_mask && m->from == ch)
			return m;

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
leaq 0xa3ff(%rip), %rax      # 0x1b8e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x11525
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x11515
movq -0x18(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x11515
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1152d
jmp 0x11517
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x114e5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/io.c
// Function: io_fifo_ins
static void io_fifo_ins(char c, bool need_map)
{
	io_fifo_realloc(1);
	memmove(io_fifo + 1, io_fifo, (io_fifoused - 1) * sizeof(*io_fifo));
	io_fifo->ch = c;
	io_fifo->needs_map = need_map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
andb $0x1, %al
movb %al, -0x2(%rbp)
movl $0x1, %edi
callq 0x116b0
movq 0xae61(%rip), %rdi      # 0x1c3f8
addq $0x4, %rdi
movq 0xae56(%rip), %rsi      # 0x1c3f8
movq 0xae47(%rip), %rdx      # 0x1c3f0
subq $0x1, %rdx
shlq $0x2, %rdx
callq 0x4400
movsbl -0x1(%rbp), %ecx
movq 0xae37(%rip), %rax      # 0x1c3f8
movw %cx, %dx
movw (%rax), %cx
andw $0xff, %dx
andw $0xff00, %cx            # imm = 0xFF00
orw %dx, %cx
movw %cx, (%rax)
movb -0x2(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movq 0xae12(%rip), %rax      # 0x1c3f8
movw %cx, %dx
movw (%rax), %cx
andw $0x1, %dx
shlw $0x8, %dx
andw $0xfeff, %cx            # imm = 0xFEFF
orw %dx, %cx
movw %cx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %edi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x11310
movl %eax, -0x10(%rbp)
callq 0x4530
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x11698
cmpl $0x30, -0x10(%rbp)
je 0x11698
movl -0x10(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x11310
movl %eax, -0x10(%rbp)
movl $0x30, %eax
cmpl -0x10(%rbp), %eax
jg 0x11692
cmpl $0x39, -0x10(%rbp)
jg 0x11692
imull $0xa, -0x8(%rbp), %eax
addl -0x10(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x8(%rbp)
jmp 0x11694
jmp 0x11696
jmp 0x1165f
jmp 0x11698
movl -0x10(%rbp), %edi
xorl %esi, %esi
callq 0x11540
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/io.c
// Function: io_fifo_realloc
static void io_fifo_realloc(size_t len)
{
	if(io_fifoused + len > io_fifosz){
		io_fifo = urealloc(io_fifo,
				sizeof(*io_fifo) * (io_fifosz = io_fifoused + len));
	}
	io_fifoused += len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xad2d(%rip), %rax      # 0x1c3f0
addq -0x8(%rbp), %rax
cmpq 0xad32(%rip), %rax      # 0x1c400
jbe 0x116f9
movq 0xad21(%rip), %rdi      # 0x1c3f8
movq 0xad12(%rip), %rsi      # 0x1c3f0
addq -0x8(%rbp), %rsi
movq %rsi, 0xad17(%rip)      # 0x1c400
shlq $0x2, %rsi
callq 0x5f60
movq %rax, 0xacff(%rip)      # 0x1c3f8
movq -0x8(%rbp), %rax
addq 0xacec(%rip), %rax      # 0x1c3f0
movq %rax, 0xace5(%rip)      # 0x1c3f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x10, %edi
callq 0x5f20
movq %rax, %rdi
callq 0x12020
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11759
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x11759
jmp 0x11778
leaq 0x4271(%rip), %rdi      # 0x159d1
leaq 0x4278(%rip), %rsi      # 0x159df
movl $0x19, %edx
leaq 0x4273(%rip), %rcx      # 0x159e6
callq 0x4210
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0xac24(%rip)      # 0x1c408
je 0x117f9
movq 0xac1b(%rip), %rdi      # 0x1c408
leaq -0x54(%rip), %rsi       # 0x117a0
callq 0x12040
movq -0x8(%rbp), %rdi
callq 0x12020
movq %rax, 0xabff(%rip)      # 0x1c408
movq 0xabf8(%rip), %rax      # 0x1c408
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/pos.c
// Function: point_sort_yx
void point_sort_yx(point_t *const a, point_t *const b)
{
	if(b->y < a->y){
		point_t tmp = *b;
		*b = *a;
		*a = tmp;
	}else if(b->y == a->y && b->x < a->x){
		int tmp = b->x;
		b->x = a->x;
		a->x = tmp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x11e42
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x11e80
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x11e7e
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x11e7e
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x11e80
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/region.c
// Function: region_contains
bool region_contains(const region_t *re, int x, int y)
{
	region_t sorted = *re;
	point_sort_full(&sorted.begin, &sorted.end);

	const struct
	{
		bool x, y;
	} in = {
		sorted.begin.x <= x && x <= sorted.end.x,
		sorted.begin.y <= y && y <= sorted.end.y
	};

	switch(re->type){
		case REGION_LINE:
			return in.y;

		case REGION_COL:
			return in.y && in.x;

		case REGION_CHAR:
			if(!in.y)
				return false;

			if(re->begin.y == re->end.y)
				return in.x;

			sorted = *re;
			point_sort_y(&sorted.begin, &sorted.end);

			if(y == sorted.begin.y)
				return x >= sorted.begin.x;
			if(y == sorted.end.y)
				return x <= sorted.end.x;

			return true;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x2c(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x24(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
addq $0x8, %rsi
callq 0x11da0
leaq -0x2e(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x2f(%rbp)
jg 0x11eed
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
setle %al
movb %al, -0x2f(%rbp)
movq -0x38(%rbp), %rax
movb -0x2f(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
leaq -0x2e(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movl -0x28(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x39(%rbp)
jg 0x11f1e
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
setle %al
movb %al, -0x39(%rbp)
movq -0x48(%rbp), %rax
movb -0x39(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4c(%rbp)
testl %eax, %eax
je 0x11f7d
jmp 0x11f3a
movl -0x4c(%rbp), %eax
subl $0x1, %eax
je 0x11f5f
jmp 0x11f44
movl -0x4c(%rbp), %eax
subl $0x2, %eax
jne 0x12003
jmp 0x11f52
movb -0x2d(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12007
xorl %eax, %eax
testb $0x1, -0x2d(%rbp)
movb %al, -0x4d(%rbp)
je 0x11f70
movb -0x2e(%rbp), %al
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12007
testb $0x1, -0x2d(%rbp)
jne 0x11f89
movb $0x0, -0x1(%rbp)
jmp 0x12007
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x11fa3
movb -0x2e(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12007
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x2c(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x24(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
addq $0x8, %rsi
callq 0x11d50
movl -0x18(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x11fe5
movl -0x14(%rbp), %eax
cmpl -0x2c(%rbp), %eax
setge %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12007
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x11ffd
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
setle %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12007
movb $0x1, -0x1(%rbp)
jmp 0x12007
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/range.c
// Function: parse_range_1
bool parse_range_1(
		char *range, char **end,
		int *out)
{
	bool handled = true;

	switch(*range){
		case '0' ... '9':
			/* go into 0-based */
			*out = strtol(range, &range, 10) - 1;
			break;

		case '.':
			*out = windows_cur()->ui_pos->y;
			range++;
			break;
		case '$':
			*out = buffer_nlines(buffers_cur());
			range++;
			break;
		/*case '\'': */

		default:
			/* don't touch range */
			handled = false;
			*out = windows_cur()->ui_pos->y;
			break;
	}

	for(;;){
		switch(*range){
			case '+':
			case '-':
			{
				const int dir = (*range == '+' ? 1 : -1);

				range++;
				int amt = isdigit(*range)
					? strtol(range, &range, 10)
					: 1;

				*out += dir * amt;

				handled = true;
				/* read more +/- */
				break;
			}
			default:
				*end = range;
				return handled;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x24, %eax
je 0x120f0
jmp 0x12099
movl -0x28(%rbp), %eax
subl $0x2e, %eax
je 0x120d0
jmp 0x120a3
movl -0x28(%rbp), %eax
addl $-0x30, %eax
subl $0x9, %eax
ja 0x12113
jmp 0x120b0
movq -0x8(%rbp), %rdi
leaq -0x8(%rbp), %rsi
movl $0xa, %edx
callq 0x4340
subq $0x1, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x12129
callq 0x13c60
movq 0x30(%rax), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x12129
callq 0x13c60
movq (%rax), %rdi
callq 0xc330
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x12129
movb $0x0, -0x19(%rbp)
callq 0x13c60
movq 0x30(%rax), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1212b
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x2b, %eax
je 0x1214a
jmp 0x1213c
movl -0x2c(%rbp), %eax
subl $0x2d, %eax
jne 0x121cf
jmp 0x1214a
movq -0x8(%rbp), %rax
movsbl (%rax), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl $0x2b, %edx
cmovel %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
callq 0x4530
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x121a8
movq -0x8(%rbp), %rdi
leaq -0x8(%rbp), %rsi
movl $0xa, %edx
callq 0x4340
movq %rax, -0x38(%rbp)
jmp 0x121b3
movl $0x1, %eax
movq %rax, -0x38(%rbp)
jmp 0x121b3
movq -0x38(%rbp), %rax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %ecx
imull -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movb $0x1, -0x19(%rbp)
jmp 0x121e5
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
jmp 0x1212b
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/range.c
// Function: parse_range
enum range_parse parse_range(
		char *cmd, char **end,
		struct range *r)
{
	if(*cmd == '%'){
		r->start = 0;
		r->end = buffer_nlines(buffers_cur());
		*end = cmd + 1;
		return RANGE_PARSE_PASS;
	}

	if(!parse_range_1(cmd, end, &r->start))
		return RANGE_PARSE_NONE; /* no range */

	cmd = *end;
	if(*cmd == ','){
		cmd++;
		if(!parse_range_1(cmd, end, &r->end))
			return RANGE_PARSE_FAIL;
	}else{
		r->end = r->start;
	}

	return RANGE_PARSE_PASS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x12248
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
callq 0x13c60
movq (%rax), %rdi
callq 0xc330
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x122c1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x12070
testb $0x1, %al
jne 0x12266
movl $0x0, -0x4(%rbp)
jmp 0x122c1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x122ad
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
callq 0x12070
testb $0x1, %al
jne 0x122ab
movl $0x1, -0x4(%rbp)
jmp 0x122c1
jmp 0x122ba
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/range.c
// Function: range_sort
void range_sort(struct range *r)
{
	if(r->start > r->end){
		int tmp = r->start;
		r->start = r->end;
		r->end = tmp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x12307
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/parse_cmd.c
// Function: parse_cmd
void parse_cmd(char *cmd, int *pargc, char ***pargv, bool shellglob)
{
	int argc = *pargc;
	char **argv = *pargv;

	char *anchor, *p;
	p = anchor = cmd;
	while(*p){
		if(*p == '\\'){
			p++;
			continue;
		}
		if(!isspace(*p)){
			p++;
			continue;
		}

		*p++ = '\0';

		add_argv(&argv, &argc, &anchor, p, shellglob);
	}

	if(anchor != p)
		add_argv(&argv, &argc, &anchor, p, shellglob);

	*pargv = argv;
	*pargc = argc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
je 0x123d1
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x1236e
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1234b
callq 0x4530
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x1239c
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1234b
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb $0x0, (%rax)
movq -0x38(%rbp), %rcx
movb -0x19(%rbp), %al
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
andb $0x1, %al
movzbl %al, %r8d
callq 0x12420
jmp 0x1234b
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x123f9
movq -0x38(%rbp), %rcx
movb -0x19(%rbp), %al
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
andb $0x1, %al
movzbl %al, %r8d
callq 0x12420
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/parse_cmd.c
// Function: add_argv
static void add_argv(
		char ***pargv, int *pargc,
		char **panchor, char *current,
		bool shellglob)
{
#define argv (*pargv)
#define argc (*pargc)
#define anchor (*panchor)
	char *failbuf;

	glob_t globbed = { 0 };
	int argc_inc;
	char **argv_add;

	int flags = GLOB_MARK | GLOB_BRACE | GLOB_TILDE;

	if(shellglob && 0 == glob(anchor, flags, /*errfunc*/NULL, &globbed)){
		argc_inc = globbed.gl_pathc;
		argv_add = globbed.gl_pathv;
	}else{
		argc_inc = 1;
		argv_add = &failbuf;
		failbuf = anchor;
	}

	argv = urealloc(argv, (argc + argc_inc + 1) * sizeof *argv);
	for(int i = 0; i < argc_inc; i++)
		argv[argc + i] = ustrdup(argv_add[i]);

	argc += argc_inc;

	globfree(&globbed);

	anchor = current;
#undef argv
#undef argc
#undef anchor
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x4240
movl $0x1402, -0x8c(%rbp)    # imm = 0x1402
testb $0x1, -0x21(%rbp)
je 0x12499
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0x8c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
leaq -0x78(%rbp), %rcx
callq 0x4490
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x12499
movq -0x78(%rbp), %rax
movl %eax, -0x7c(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x124b6
movl $0x1, -0x7c(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl -0x7c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x5f60
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x90(%rbp)
movl -0x90(%rbp), %eax
cmpl -0x7c(%rbp), %eax
jge 0x12539
movq -0x88(%rbp), %rax
movslq -0x90(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5fa0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
addl -0x90(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x90(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x90(%rbp)
jmp 0x124e9
movl -0x7c(%rbp), %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
leaq -0x78(%rbp), %rdi
callq 0x4050
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/parse_cmd.c
// Function: filter_argv
static void filter_argv(int *pargc, char ***pargv)
{
	/* check for '%', '#' and * wildcard expansion */
	int argc = *pargc;
	char **argv = *pargv;
	int i;
	const char *fnam = buffer_fname(buffers_cur());

	for(i = 0; i < argc; i++){
		char *p;

		for(p = argv[i]; *p; p++){
			if(*p == '\\')
				continue;

			switch(*p){
				/* TODO: '#' */
				case '%':
					if(fnam){
						const int di = p - argv[i];
						char *new;

						*p = '\0';

						new = join("", (char *[]){
								argv[i],
								(char *)fnam,
								p + 1 }, 3);

						free(argv[i]);
						argv[i] = new;
						p = argv[i] + di;
					}
					break;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x13c60
movq (%rax), %rdi
callq 0xbb30
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x129c8
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
je 0x129b8
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x128f6
jmp 0x129a7
movq -0x38(%rbp), %rax
movb (%rax), %al
subb $0x25, %al
jne 0x129a5
jmp 0x12906
cmpq $0x0, -0x30(%rbp)
je 0x129a3
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
subq %rcx, %rax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
leaq -0x60(%rbp), %rsi
leaq 0x2edb(%rip), %rdi      # 0x15838
movl $0x3, %edx
callq 0x6030
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4080
movq -0x48(%rbp), %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x129a5
jmp 0x129a7
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x128d8
jmp 0x129ba
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x128bc
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/word.c
// Function: word_state
enum word_state word_state(
		const list_t *l, int x, bool big_words)
{
	if(l && 0 <= x && (unsigned)x < l->len_line){
		const char ch = l->line[x];

		if(isspace(ch))
			return W_SPACE;
		else if(big_words)
			return W_KEYWORD;
		else if(isalnum(ch) || ch == '_')
			return W_KEYWORD;
		return W_NON_KWORD;
	}

	return W_NONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12add
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jg 0x12add
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x12add
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x16(%rbp)
callq 0x4530
movq (%rax), %rax
movsbl -0x16(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x12a94
movl $0x1, -0x4(%rbp)
jmp 0x12ae4
testb $0x1, -0x15(%rbp)
je 0x12aa3
movl $0x2, -0x4(%rbp)
jmp 0x12ae4
callq 0x4530
movq (%rax), %rax
movsbl -0x16(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x12ac7
movsbl -0x16(%rbp), %eax
cmpl $0x5f, %eax
jne 0x12ad0
movl $0x2, -0x4(%rbp)
jmp 0x12ae4
jmp 0x12ad2
jmp 0x12ad4
movl $0x4, -0x4(%rbp)
jmp 0x12ae4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/word.c
// Function: word_seek
list_t *word_seek(
		list_t *l, int dir, point_t *to,
		enum word_state target, bool big_words)
{
	while((word_state(l, to->x, big_words) & target) == 0){
		const int y = to->y;

		l = list_advance_x(l, dir, &to->y, &to->x);

		if(!l)
			break;
		if(y != to->y)
			break; /* newlines are a fresh start */
	}
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x12a20
andl -0x1c(%rbp), %eax
cmpl $0x0, %eax
jne 0x12b6c
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
addq $0x4, %rdx
movq -0x18(%rbp), %rcx
callq 0xe4b0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x12b5c
jmp 0x12b6c
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x12b6a
jmp 0x12b6c
jmp 0x12b0e
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)