LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_docmd
void k_docmd(const keyarg_u *arg, unsigned repeat, const int from_ch)
{
	const char **i;
	char **argv;
	size_t l;

	for(l = 0, i = arg->cmd.argv; i && *i; i++, l++);

	argv = umalloc((l + 1) * sizeof *argv);

	for(l = 0, i = arg->cmd.argv; i && *i; i++, l++)
		argv[l] = ustrdup(*i);

	cmd_dispatch(&arg->cmd.fn, 1, argv, arg->cmd.force, /*range:*/NULL);

	if(arg->cmd.argv[0])
		for(l = 0; argv[l]; l++)
			free(argv[l]);
	free(argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
je 0x7880
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x7889
jmp 0x78a5
jmp 0x788b
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7866
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
callq 0x5f20
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x2a(%rbp)
je 0x78e8
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x78f1
jmp 0x7926
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5fa0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x78ce
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movb 0x20(%rax), %al
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %r8d
andb $0x1, %al
movzbl %al, %ecx
callq 0xb660
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, (%rax)
je 0x798f
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x798d
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4080
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x795f
jmp 0x798f
movq -0x20(%rbp), %rdi
callq 0x4080
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_showch
void k_showch(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	window *win = windows_cur();
	list_t *l = window_current_line(win, false);
	if(l){
		if((unsigned)win->ui_pos->x < l->len_line){
			const int ch = l->line[win->ui_pos->x];

			ui_status("<%s> %d Hex %x Octal %o",
					ch ? (char[]){ ch, 0 } : "^@",
					ch, ch, ch);
			return;
		}
	}

	ui_status("NUL");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x13c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x13790
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7d55
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x7d53
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x7d28
movl -0x24(%rbp), %eax
movb %al, -0x26(%rbp)
movb $0x0, -0x25(%rbp)
leaq -0x26(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x7d35
leaq 0xd59c(%rip), %rax      # 0x152cb
movq %rax, -0x30(%rbp)
jmp 0x7d35
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x24(%rbp), %r8d
leaq 0xd569(%rip), %rdi      # 0x152b3
movb $0x0, %al
callq 0x51a0
jmp 0x7d63
jmp 0x7d55
leaq 0xd572(%rip), %rdi      # 0x152ce
movb $0x0, %al
callq 0x51a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: motion_read
const motion *motion_read(unsigned *repeat, bool apply_maps)
{
	const enum io io_m =
		apply_maps ? bufmode_to_iomap(windows_cur()->ui_mode) : IO_NOMAP;

	*repeat = io_read_repeat(io_m);

	int i = keys_filter(
			io_m,
			(char *)motion_keys, motion_keys_cnt,
			offsetof(motionkey_t, keys), sizeof(motionkey_t),
			-1);

	if(i == -1)
		return NULL;
	return &motion_keys[i].motion;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x807c
callq 0x13c60
movl 0x40(%rax), %edi
callq 0x112d0
movl %eax, -0x20(%rbp)
jmp 0x8086
movl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8086
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0x11610
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %edi
leaq 0x1215a(%rip), %rsi     # 0x1a200
movl $0x2b, %edx
xorl %ecx, %ecx
movl $0x20, %r8d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0x7d70
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x80d1
movq $0x0, -0x8(%rbp)
jmp 0x80eb
movslq -0x1c(%rbp), %rcx
leaq 0x12124(%rip), %rax     # 0x1a200
shlq $0x5, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: prompt_finish
static void prompt_finish(char *cmd)
{
	const cmd_t *cmd_f;
	char **argv;
	int argc;
	bool force;
	struct range rstore, *range = &rstore;

	if(parse_ranged_cmd(
			cmd,
			&cmd_f,
			&argv, &argc,
			&force, &range))
	{
		cmd_dispatch(cmd_f, argc, argv, force, range);
	}
	else
	{
		ui_err("unknown command %s", cmd);
	}

	free_argv(argv, argc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
leaq -0x1d(%rbp), %r8
leaq -0x30(%rbp), %r9
callq 0x12570
testb $0x1, %al
jne 0x8137
jmp 0x8155
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
movb -0x1d(%rbp), %al
movq -0x30(%rbp), %r8
andb $0x1, %al
movzbl %al, %ecx
callq 0xb660
jmp 0x8167
movq -0x8(%rbp), %rsi
leaq 0xd1e1(%rip), %rdi      # 0x15341
movb $0x0, %al
callq 0x4f30
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x129d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: pos2dir
static enum neighbour pos2dir(const point_t *pos)
{
	/**/ if(pos->x > 0) return neighbour_right;
	else if(pos->x < 0) return neighbour_left;
	else if(pos->y > 0) return neighbour_down;
	else if(pos->y < 0) return neighbour_up;
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x819a
movl $0x3, -0x4(%rbp)
jmp 0x81d9
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x81ac
movl $0x2, -0x4(%rbp)
jmp 0x81d9
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jle 0x81bf
movl $0x1, -0x4(%rbp)
jmp 0x81d9
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x81d2
movl $0x0, -0x4(%rbp)
jmp 0x81d9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: motion_read_or_visual
static
const motion *motion_read_or_visual(unsigned *repeat, bool apply_maps)
{
	window *win = windows_cur();
	if(win->ui_mode & UI_VISUAL_ANY){
		static motion visual = {
			.func = m_visual,
			.arg.phow = &visual.how
		};

		*repeat = 0;

		return &visual;
	}

	return motion_read(repeat, apply_maps);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
callq 0x13c60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x38, %eax
cmpl $0x0, %eax
je 0x8223
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
leaq 0x14123(%rip), %rax     # 0x1c340
movq %rax, -0x8(%rbp)
jmp 0x8238
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x8050
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: around_motion_bufaction
static bool around_motion_bufaction(
		unsigned repeat, const int from_ch,
		struct buffer_action *buf_act, region_t *out_region)
{
	return around_motion(repeat, from_ch, buf_act->always_linewise,
			&(struct around_motion){
				.fn = buffer_forward,
				.forward = buf_act->fn
			}, out_region);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rax
movb 0x8(%rax), %al
leaq 0x3a6(%rip), %rcx       # 0x8860
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %r8
leaq -0x28(%rbp), %rcx
andb $0x1, %al
movzbl %al, %edx
callq 0x82c0
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: filter
static void filter(
		buffer_t *buf,
		const region_t *region,
		point_t *out,
		struct around_motion *around)
{
	const struct filter_input *pf = around->filter;
	bool free_cmd = false;
	char *cmd;

	switch(pf->type){
		case FILTER_CMD:
			cmd = pf->s;
			if(!cmd){
				char initial[32];

				snprintf(initial, sizeof initial, "%d,%d!",
						region->begin.y,
						region->end.y);

				cmd = prompt(':', initial);
				if(!cmd)
					return;

				prompt_finish(cmd);

				free(cmd);
				return;
			}else{
				break;
			}

		case FILTER_SELF:
			cmd = "sh";
	}

	if(buffer_filter(buf, region, cmd))
		ui_err("filter: %s", strerror(errno));

	if(free_cmd)
		free(cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x64(%rbp)
testl %eax, %eax
je 0x859b
jmp 0x8527
movl -0x64(%rbp), %eax
subl $0x1, %eax
jne 0x85a6
jmp 0x8531
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x8599
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %r8d
movl $0x20, %esi
leaq 0xce00(%rip), %rdx      # 0x15363
movb $0x0, %al
callq 0x41e0
leaq -0x60(%rbp), %rsi
movl $0x3a, %edi
callq 0x10db0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x8585
jmp 0x85e8
movq -0x38(%rbp), %rdi
callq 0x8100
movq -0x38(%rbp), %rdi
callq 0x4080
jmp 0x85e8
jmp 0x85a6
leaq 0xd20a(%rip), %rax      # 0x157ac
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xc0e0
cmpl $0x0, %eax
je 0x85d9
callq 0x40a0
movl (%rax), %edi
callq 0x44d0
movq %rax, %rsi
leaq 0xcd98(%rip), %rdi      # 0x1536a
movb $0x0, %al
callq 0x4f30
testb $0x1, -0x29(%rbp)
je 0x85e8
movq -0x38(%rbp), %rdi
callq 0x4080
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_on_wordfile
static void k_on_wordfile(const keyarg_u *a, char *fn(const window *), const char *desc)
{
	char *word = fn(windows_cur());

	if(!word){
		ui_err("no %s under cursor", desc);
		return;
	}

	a->word_action.fn(word, a->word_action.flag);

	free(word);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x13c60
movq %rax, %rdi
movq -0x28(%rbp), %rax
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8679
movq -0x18(%rbp), %rsi
leaq 0xcd05(%rip), %rdi      # 0x15375
movb $0x0, %al
callq 0x4f30
jmp 0x869c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rcx
movb 0x8(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %esi
callq *%rax
movq -0x20(%rbp), %rdi
callq 0x4080
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: attempt_relative_fname
static bool attempt_relative_fname(
		char **const pfname,
		bool *const free_expanded)
{
	char *fname = *pfname;

	if(*fname == '/')
		return false;

	buffer_t *buf = buffers_cur();
	const char *buf_fname = buffer_fname(buf);
	if(!buf_fname)
		return false;

	/* if it's a directory, we don't basename() the path */
	struct stat st;
	const bool is_dir = (stat(buf_fname, &st) == 0 && S_ISDIR(st.st_mode));

	char *fname_dup = NULL;
	if(!is_dir){
		/* basename */
		fname_dup = ustrdup(buf_fname);
		char *last_slash = strrchr(fname_dup, '/');

		if(last_slash)
			*last_slash = '\0';
	}

	char *joined = join(
			"/",
			(char *[]){
				fname_dup ? fname_dup : (char *)buf_fname,
				fname
			},
			2);

	free(fname_dup), fname_dup = NULL;

	if(*free_expanded)
		free(*pfname);
	*pfname = joined;
	*free_expanded = true;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x86e3
movb $0x0, -0x1(%rbp)
jmp 0x8846
callq 0x13c60
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xbb30
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x870c
movb $0x0, -0x1(%rbp)
jmp 0x8846
movq -0x30(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x4330
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xf1(%rbp)
jne 0x8744
movl -0xa8(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
sete %al
movb %al, -0xf1(%rbp)
movb -0xf1(%rbp), %al
andb $0x1, %al
movb %al, -0xc1(%rbp)
movq $0x0, -0xd0(%rbp)
testb $0x1, -0xc1(%rbp)
jne 0x87a4
movq -0x30(%rbp), %rdi
callq 0x5fa0
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rdi
movl $0x2f, %esi
callq 0x4200
movq %rax, -0xd8(%rbp)
cmpq $0x0, -0xd8(%rbp)
je 0x87a2
movq -0xd8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x87a4
cmpq $0x0, -0xd0(%rbp)
je 0x87be
movq -0xd0(%rbp), %rax
movq %rax, -0x100(%rbp)
jmp 0x87c9
movq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x100(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0xf0(%rbp), %rsi
leaq 0xcb30(%rip), %rdi      # 0x15320
movl $0x2, %edx
callq 0x6030
movq %rax, -0xe0(%rbp)
movq -0xd0(%rbp), %rdi
callq 0x4080
movq $0x0, -0xd0(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
je 0x882d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4080
movq -0xe0(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_cq
bool c_cq(int argc, char **argv, bool force, struct range *range)
{
	RANGE_NO();
	ARGV_NO();

	/* no buffer checks */
	ui_run = UI_EXIT_1;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8b5c
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xc839(%rip), %rdi      # 0x15388
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x8b8e
cmpl $0x1, -0x8(%rbp)
je 0x8b7d
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xc833(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x8b8e
leaq 0x13848(%rip), %rax     # 0x1c3cc
movl $0x2, (%rax)
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/cmds.c
// Function: c_n
bool c_n(int argc, char **argv, bool force, struct range *range)
{
	RANGE_NO();
	ARGV_NO();

	if(buffers_modified_single(buffers_cur()) && !force){
		ui_err("buffer modified");
		return false;
	}

	char *fname = args_next_fname(true);
	if(!fname){
		ui_err("no more files");
		return false;
	}

	return edit_common(fname, force);
}

// 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)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8d6f
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xc629(%rip), %rdi      # 0x15388
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x8dfc
cmpl $0x1, -0x8(%rbp)
je 0x8d90
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xc620(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x8dfc
callq 0x13c60
movq (%rax), %rdi
callq 0x12ce0
testb $0x1, %al
jne 0x8da3
jmp 0x8dbd
testb $0x1, -0x11(%rbp)
jne 0x8dbd
leaq 0xc545(%rip), %rdi      # 0x152f5
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x8dfc
movl $0x1, %edi
callq 0x4650
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8de6
leaq 0xc5eb(%rip), %rdi      # 0x153c4
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x8dfc
movq -0x28(%rbp), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x8ba0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_w
bool c_w(char *cmd, char *arg, bool force, struct range *range)
{
	arg = skipspace(arg);

	if(range)
		return write_range(arg, force, range);

	buffer_t *const buf = buffers_cur();

	bool newfname = false;
	if(*arg){
		const char *old = buffer_fname(buf);

		newfname = !old || strcmp(old, arg);

		buffer_set_fname(buf, arg);
	}

	if(!write_buf(buf, force, newfname))
		return false;

	ui_status("written to \"%s\"", buffer_fname(buf));
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10a20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8e5e
movq -0x18(%rbp), %rdi
movb -0x19(%rbp), %al
movq -0x28(%rbp), %rdx
andb $0x1, %al
movzbl %al, %esi
callq 0x8f10
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x8efd
callq 0x13c60
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8ebb
movq -0x30(%rbp), %rdi
callq 0xbb30
movq %rax, -0x40(%rbp)
movb $0x1, %al
cmpq $0x0, -0x40(%rbp)
movb %al, -0x41(%rbp)
je 0x8ea6
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x42d0
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb8d0
movq -0x30(%rbp), %rdi
movb -0x19(%rbp), %cl
movb -0x31(%rbp), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %edx
callq 0x9100
testb $0x1, %al
jne 0x8edf
movb $0x0, -0x1(%rbp)
jmp 0x8efd
movq -0x30(%rbp), %rdi
callq 0xbb30
movq %rax, %rsi
leaq 0xc4e0(%rip), %rdi      # 0x153d2
movb $0x0, %al
callq 0x51a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: write_buf
static bool write_buf(
		buffer_t *buf, bool const force, bool const newfname)
{
	const char *fname = buffer_fname(buf);
	if(!fname){
		ui_err("no filename");
		return false;
	}

	struct stat st;
	if(!force){
		if(stat(fname, &st) == 0){
			if(newfname && access(fname, F_OK) == 0){
				ui_err("file already exists");
				return false;
			}

			if(st.st_mtime > buf->mtime){
				ui_err("file modified externally");
				return false;
			}
		}else if(errno != ENOENT){
			ui_err("stat(%s): %s", fname, strerror(errno));
			return false;
		}
	}

	FILE *f = fopen(fname, "w");

	if(!f){
got_err:
		ui_err("%s: %s", fname, strerror(errno));
		if(f)
			fclose(f);
		return false;
	}

	if(buffer_write_file(buf, -1, f, buf->eol) != 0)
		goto got_err; /* file cleanup handled */

	if(fclose(f)){
		f = NULL;
		goto got_err;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbb30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x914a
leaq 0xc273(%rip), %rdi      # 0x153ad
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x92be
testb $0x1, -0x11(%rbp)
jne 0x9203
movq -0x20(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x4330
cmpl $0x0, %eax
jne 0x91bd
testb $0x1, -0x12(%rbp)
je 0x9196
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x4420
cmpl $0x0, %eax
jne 0x9196
leaq 0xc495(%rip), %rdi      # 0x1561b
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x92be
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jle 0x91bb
leaq 0xc484(%rip), %rdi      # 0x1562f
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x92be
jmp 0x9201
callq 0x40a0
cmpl $0x2, (%rax)
je 0x91ff
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x40a0
movl (%rax), %edi
callq 0x44d0
movq -0xc0(%rbp), %rsi
movq %rax, %rdx
leaq 0xc459(%rip), %rdi      # 0x15648
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x92be
jmp 0x9201
jmp 0x9203
movq -0x20(%rbp), %rdi
leaq 0xc870(%rip), %rsi      # 0x15a7e
callq 0x4440
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
jne 0x9271
jmp 0x9226
movq -0x20(%rbp), %rax
movq %rax, -0xc8(%rbp)
callq 0x40a0
movl (%rax), %edi
callq 0x44d0
movq -0xc8(%rbp), %rsi
movq %rax, %rdx
leaq 0xc3c6(%rip), %rdi      # 0x15614
movb $0x0, %al
callq 0x4f30
cmpq $0x0, -0xb8(%rbp)
je 0x926b
movq -0xb8(%rbp), %rdi
callq 0x4150
movb $0x0, -0x1(%rbp)
jmp 0x92be
movq -0x10(%rbp), %rdi
movq -0xb8(%rbp), %rdx
movq -0x10(%rbp), %rax
movb 0x38(%rax), %al
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
andb $0x1, %al
movzbl %al, %ecx
callq 0xbad0
cmpl $0x0, %eax
je 0x9299
jmp 0x9226
movq -0xb8(%rbp), %rdi
callq 0x4150
cmpl $0x0, %eax
je 0x92ba
movq $0x0, -0xb8(%rbp)
jmp 0x9226
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_wa
bool c_wa(int argc, char **argv, bool force, struct range *range)
{
	RANGE_NO();
	ARGV_NO();

	bool success = true;
	bool done_write = false;

	for(tab *tab = tabs_first(); tab; tab = tab->next){
		window *win;
		ITER_WINDOWS_FROM(win, tab->win){
			buffer_t *buf = win->buf;

			if(!force && !buf->modified)
				continue;

			bool subforce = false;
			if(!write_buf(buf, subforce, /*newfname:*/false)){
				tabs_set_cur(tab);
				tab_set_focus(tab, win);
				success = false;
			}else{
				done_write = true;
			}
		}
	}

	if(success){
		if(done_write)
			ui_status("saved all%s buffers", force ? "" : " modified");
		else
			ui_status("no modified buffers");

	}else{
		/* leave the error message emitted by write_buf() */
	}

	return success;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x930f
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xc089(%rip), %rdi      # 0x15388
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x945d
cmpl $0x1, -0x8(%rbp)
je 0x9333
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xc080(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x945d
movb $0x1, -0x21(%rbp)
movb $0x0, -0x22(%rbp)
callq 0x13ef0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x940f
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x13010
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x93fc
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x93e9
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x939e
movq -0x48(%rbp), %rax
testb $0x1, 0x39(%rax)
jne 0x939e
jmp 0x93db
movb $0x0, -0x49(%rbp)
movq -0x48(%rbp), %rdi
movb -0x49(%rbp), %al
xorl %edx, %edx
andb $0x1, %al
movzbl %al, %esi
callq 0x9100
testb $0x1, %al
jne 0x93d5
movq -0x30(%rbp), %rdi
callq 0x13ed0
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x13d80
movb $0x0, -0x21(%rbp)
jmp 0x93d9
movb $0x1, -0x22(%rbp)
jmp 0x93db
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x937a
jmp 0x93eb
movq -0x40(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x9367
jmp 0x93fe
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x9344
testb $0x1, -0x21(%rbp)
je 0x9453
testb $0x1, -0x22(%rbp)
je 0x9443
movb -0x11(%rbp), %cl
leaq 0xbed6(%rip), %rsi      # 0x152fb
leaq 0xc40c(%rip), %rax      # 0x15838
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0xbfa8(%rip), %rdi      # 0x153e2
movb $0x0, %al
callq 0x51a0
jmp 0x9451
leaq 0xbfac(%rip), %rdi      # 0x153f6
movb $0x0, %al
callq 0x51a0
jmp 0x9455
jmp 0x9455
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_x
bool c_x(int argc, char **argv, bool force, struct range *range)
{
	RANGE_NO();

	if(argc > 2){
		ui_err("usage: %s [filename]", *argv);
		return false;
	}

	buffer_t *buf = buffers_cur();

	/* if no modifications, don't try to write
	 * this is done in vi and helps ZZ */
	if(argc == 1 && buf->fname && !buf->modified)
		return c_q(argc, argv, false, range);

	return c_w("w", argc > 1 ? argv[1] : "", false, range)
		&& c_q(1, (char *[]){ "" }, false, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x94af
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xbee9(%rip), %rdi      # 0x15388
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x9582
cmpl $0x2, -0x8(%rbp)
jle 0x94d3
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xbf47(%rip), %rdi      # 0x1540a
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x9582
callq 0x13c60
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x9513
movq -0x28(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x9513
movq -0x28(%rbp), %rax
testb $0x1, 0x39(%rax)
jne 0x9513
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
callq 0x88a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9582
cmpl $0x1, -0x8(%rbp)
jle 0x9527
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x9534
leaq 0xc30a(%rip), %rax      # 0x15838
movq %rax, -0x38(%rbp)
jmp 0x9534
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0xc53b(%rip), %rdi      # 0x15a7e
xorl %edx, %edx
callq 0x8e10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0x9558
jmp 0x957a
leaq 0xc2d9(%rip), %rax      # 0x15838
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
movl $0x1, %edi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x88a0
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -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/cmds.c
// Function: c_xa
bool c_xa(int argc, char **argv, bool force, struct range *range)
{
	RANGE_NO();
	ARGV_NO();

	for(tab *tab = tabs_first(); tab; tab = tab->next){
		window *win;
		ITER_WINDOWS_FROM(win, tab->win){
			buffer_t *buf = win->buf;

			if(!buf->modified)
				continue;

			if(!write_buf(buf, force, false)){
				tabs_set_cur(tab);
				tab_set_focus(tab, win);
				return false;
			}
		}
	}

	ui_run = UI_EXIT_0;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x95cf
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xbdc9(%rip), %rdi      # 0x15388
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x96c3
cmpl $0x1, -0x8(%rbp)
je 0x95f3
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xbdc0(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x96c3
callq 0x13ef0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x96b2
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x13010
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x969f
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x968f
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
testb $0x1, 0x39(%rax)
jne 0x964c
jmp 0x9681
movq -0x40(%rbp), %rdi
movb -0x11(%rbp), %al
xorl %edx, %edx
andb $0x1, %al
movzbl %al, %esi
callq 0x9100
testb $0x1, %al
jne 0x967f
movq -0x28(%rbp), %rdi
callq 0x13ed0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x13d80
movb $0x0, -0x1(%rbp)
jmp 0x96c3
jmp 0x9681
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x962e
jmp 0x9691
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x961f
jmp 0x96a1
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x95fc
leaq 0x12d13(%rip), %rax     # 0x1c3cc
movl $0x1, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_e
bool c_e(int argc, char **argv, bool force, struct range *range)
{
	RANGE_NO();

	const char *fname;

	if(argc == 1){
		fname = NULL;
		if(!buffer_fname(buffers_cur())){
			ui_err("no filename");
			return false;
		}
	}else if(argc == 2){
		fname = argv[1];
	}else{
		if(buffers_modified_single(buffers_cur())){
			ui_err("buffer modified");
			return false;
		}

		if(!yesno("%d files given - open in vertical split? (y/N) ", argc - 1))
			return false;

		window *current = windows_cur();

		bool ret = c_split(
				neighbour_down,
				/*use current:*/true,
				argc,
				argv,
				/*force*/false,
				/*range*/NULL,
				/*allow_many:*/true);

		/* close current window */
		windows_set_cur(current);
		quit_common(false, 1, (char *[]){ "", NULL }, false, NULL);

		return ret;
	}

	return edit_common(fname, force);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x970f
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xbc89(%rip), %rdi      # 0x15388
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x9833
cmpl $0x1, -0x8(%rbp)
jne 0x974c
movq $0x0, -0x28(%rbp)
callq 0x13c60
movq (%rax), %rdi
callq 0xbb30
cmpq $0x0, %rax
jne 0x9747
leaq 0xbc76(%rip), %rdi      # 0x153ad
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x9833
jmp 0x981d
cmpl $0x2, -0x8(%rbp)
jne 0x9763
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x981b
callq 0x13c60
movq (%rax), %rdi
callq 0x12ce0
testb $0x1, %al
jne 0x9776
jmp 0x978d
leaq 0xbb78(%rip), %rdi      # 0x152f5
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x9833
movl -0x8(%rbp), %esi
subl $0x1, %esi
leaq 0xbc85(%rip), %rdi      # 0x1541f
movb $0x0, %al
callq 0x111d0
testb $0x1, %al
jne 0x97ae
movb $0x0, -0x1(%rbp)
jmp 0x9833
callq 0x13c60
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %edx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
movl %esi, %edi
movl $0x1, (%rsp)
callq 0x9840
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x30(%rbp), %rdi
callq 0x13ca0
leaq 0xc04a(%rip), %rax      # 0x15838
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x48(%rbp), %rdx
xorl %ecx, %ecx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movl %ecx, %edi
callq 0x88e0
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9833
jmp 0x981d
movq -0x28(%rbp), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x8ba0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_split
static
bool c_split(
		const enum neighbour dir,
		bool const withcurrent,
		int argc, char **argv,
		bool force, struct range *range,
		const bool allow_many)
{
	RANGE_NO();

	if(!allow_many && argc > 2){
		ui_err("usage: %s [filename]", *argv);
		return false;
	}

	buffer_t *b;

	if(argc > 1){
		for(int i = 1; i < argc; i++){
			const char *err;
			buffer_new_fname(&b, argv[i], &err);

			if(err){
				ui_err("%s: %s", argv[i], err);

				/* edit new file */
				b = buffer_new();
				buffer_set_fname(b, argv[i]);
			}

			attach_buffer(b, dir, NULL);
		}

	}else if(withcurrent){
		window *cur = windows_cur();
		b = retain(cur->buf);
		attach_buffer(b, dir, /*copy pos from:*/cur);

	}else{
		b = buffer_new();
		attach_buffer(b, dir, NULL);
	}

	ui_redraw();
	ui_cur_changed();

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %r8d, -0x64(%rbp)
movq %rcx, %rax
movl -0x64(%rbp), %ecx
movq %rax, -0x60(%rbp)
movl %edx, %eax
movq -0x60(%rbp), %rdx
movl %eax, -0x54(%rbp)
movl %esi, %eax
movl -0x54(%rbp), %esi
movl %edi, %r8d
movb %al, %dil
movb 0x10(%rbp), %al
movl %r8d, -0x8(%rbp)
andb $0x1, %dil
movb %dil, -0x9(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
movq %r9, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x98b4
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0xbae4(%rip), %rdi      # 0x15388
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x99ca
testb $0x1, -0x29(%rbp)
jne 0x98de
cmpl $0x2, -0x10(%rbp)
jle 0x98de
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0xbb3c(%rip), %rdi      # 0x1540a
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x99ca
cmpl $0x1, -0x10(%rbp)
jle 0x9970
movl $0x1, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x996e
movq -0x18(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0xb970
cmpq $0x0, -0x48(%rbp)
je 0x9953
movq -0x18(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x48(%rbp), %rdx
leaq 0xbce6(%rip), %rdi      # 0x15614
movb $0x0, %al
callq 0x4f30
callq 0xb750
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xb8d0
movq -0x38(%rbp), %rdi
movl -0x8(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xa790
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x98ef
jmp 0x99bc
testb $0x1, -0x9(%rbp)
je 0x99a1
callq 0x13c60
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x12020
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x50(%rbp), %rdx
callq 0xa790
jmp 0x99ba
callq 0xb750
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl -0x8(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xa790
jmp 0x99bc
callq 0x4fd0
callq 0x5050
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_ene
bool c_ene(int argc, char **argv, bool force, struct range *range)
{
	RANGE_NO();
	ARGV_NO();

	if(!force && buffers_modified_single(buffers_cur())){
		ui_err("buffer modified");
		return false;
	}

	buffer_t *new = buffer_new();
	window_replace_buffer(windows_cur(), new);
	buffer_release(new);

	ui_cur_changed();
	ui_redraw();

	return true;
}

// 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)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9a1f
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xb979(%rip), %rdi      # 0x15388
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x9aa5
cmpl $0x1, -0x8(%rbp)
je 0x9a40
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xb970(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x9aa5
testb $0x1, -0x11(%rbp)
jne 0x9a6d
callq 0x13c60
movq (%rax), %rdi
callq 0x12ce0
testb $0x1, %al
jne 0x9a59
jmp 0x9a6d
leaq 0xb895(%rip), %rdi      # 0x152f5
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x9aa5
callq 0xb750
movq %rax, -0x28(%rbp)
callq 0x13c60
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x13ac0
movq -0x28(%rbp), %rdi
leaq 0x1c7e(%rip), %rsi      # 0xb710
callq 0x12040
callq 0x5050
callq 0x4fd0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_only
bool c_only(int argc, char **argv, bool force, struct range *range)
{
	RANGE_NO();
	ARGV_NO();

	if(!force && buffers_modified_excluding(buffers_cur(), NULL)){
		ui_err("another buffer has changes");
		return false;
	}

	window *iter;
	size_t count = 0;
	ITER_WINDOWS(iter)
		count++;

	if(count == 1)
		return true;

	window *const anchor = windows_cur();
	windows_set_cur(window_next(anchor));
	window_evict(anchor);

	/* must iterate manually to avoid accessing free'd memory */
	iter = window_topleftmost(windows_cur());
	window *next_right;
	for(window *h = iter; h; h = next_right){
		next_right = h->neighbours.right;

		window *next_below;
		for(iter = h; iter; iter = next_below){
			next_below = iter->neighbours.below;
			window_free(iter);
		}
	}

	windows_set_cur(anchor);

	ui_cur_changed();
	ui_redraw();

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9aef
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xb8a9(%rip), %rdi      # 0x15388
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x9c58
cmpl $0x1, -0x8(%rbp)
je 0x9b13
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xb8a0(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x9c58
testb $0x1, -0x11(%rbp)
jne 0x9b47
callq 0x13c60
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12d20
cmpq $0x0, %rax
je 0x9b47
leaq 0xb918(%rip), %rdi      # 0x1544f
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0x9c58
movq $0x0, -0x30(%rbp)
callq 0x13c60
movq %rax, %rdi
callq 0x13010
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x9ba8
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9b98
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9b77
jmp 0x9b9a
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x9b68
cmpq $0x1, -0x30(%rbp)
jne 0x9bb8
movb $0x1, -0x1(%rbp)
jmp 0x9c58
callq 0x13c60
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x12f90
movq %rax, %rdi
callq 0x13ca0
movq -0x40(%rbp), %rdi
callq 0x130f0
callq 0x13c60
movq %rax, %rdi
callq 0x13010
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x9c41
movq -0x50(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9c35
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0x13690
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x9c0f
jmp 0x9c37
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x9bf4
movq -0x40(%rbp), %rdi
callq 0x13ca0
callq 0x5050
callq 0x4fd0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_all
bool c_all(int argc, char **argv, bool force, struct range *range)
{
	ARGV_NO();
	if(force){
		ui_err("usage: %s", *argv);
		return false;
	}

	if(!args_next_fname(false))
		ui_status("no remaining buffers");

	window *cur = windows_cur();
	for(;;){
		const char *fname = args_next_fname(true);
		if(!fname)
			break;

		buffer_t *buf;
		const char *err;
		buffer_new_fname(&buf, fname, &err);

		window *w = window_new(buf);
		buffer_release(buf);

		window_add_neighbour(cur, neighbour_down, w);

		cur = w;
	}

	ui_redraw();

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x1, -0x8(%rbp)
je 0xa13e
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xb275(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xa1f0
testb $0x1, -0x11(%rbp)
je 0xa162
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xb251(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xa1f0
xorl %edi, %edi
callq 0x4650
cmpq $0x0, %rax
jne 0xa17d
leaq 0xb31c(%rip), %rdi      # 0x15492
movb $0x0, %al
callq 0x51a0
callq 0x13c60
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x4650
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xa19d
jmp 0xa1e7
movq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0xb970
movq -0x38(%rbp), %rdi
callq 0x13620
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x154a(%rip), %rsi      # 0xb710
callq 0x12040
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rdx
movl $0x1, %esi
callq 0x133a0
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xa186
callq 0x4fd0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_tabe
bool c_tabe(int argc, char **argv, bool force, struct range *range)
{
	if(argc > 2){
		ui_err("usage: %s [path]", *argv);
		return false;
	}

	buffer_t *buf = buffer_new();

	window *win = window_new(buf);
	tab *tab = tab_new(win);
	buffer_release(buf);

	tab->next = tabs_cur()->next;
	tabs_cur()->next = tab;

	tabs_set_cur(tab);

	if(argc == 1){
		/* empty tab - fine */
	}else if(argc == 2){
		return edit_common(argv[1], force);
	}

	ui_redraw();
	ui_cur_changed();

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x2, -0x8(%rbp)
jle 0xa23e
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xb279(%rip), %rdi      # 0x154a7
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xa2da
callq 0xb750
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x13620
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x13cd0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x14a4(%rip), %rsi      # 0xb710
callq 0x12040
callq 0x13ec0
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x13ec0
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rdi
callq 0x13ed0
cmpl $0x1, -0x8(%rbp)
jne 0xa2a8
jmp 0xa2cc
cmpl $0x2, -0x8(%rbp)
jne 0xa2ca
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x8ba0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xa2da
jmp 0xa2cc
callq 0x4fd0
callq 0x5050
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_tabo
bool c_tabo(int argc, char **argv, bool force, struct range *range)
{
	RANGE_NO();
	ARGV_NO();

	tab *const tab_current = tabs_cur();

	if(!force){
		for(tab *tab = tabs_first(); tab; tab = tab->next){
			if(tab == tab_current)
				continue;

			window *win;
			ITER_WINDOWS_FROM(win, tab->win){
				buffer_t *buf = win->buf;

				/* if we contain this buffer, then it's fine */
				if(tab_contains_buffer(tab_current, buf))
					continue;

				if(buf->modified){
					ui_err("other tab contains modified buffer");
					return false;
				}
			}
		}
	}

	tab_evict(tab_current);

	tab *t = tabs_first();
	while(t){
		tab *next = t->next;

		assert(t != tab_current);
		tab_free(t);

		t = next;
	}

	tabs_set_cur(tab_current);
	tabs_set_first(tab_current);

	ui_redraw();
	ui_cur_changed();

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa32f
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xb069(%rip), %rdi      # 0x15388
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xa4b0
cmpl $0x1, -0x8(%rbp)
je 0xa353
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xb060(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xa4b0
callq 0x13ec0
movq %rax, -0x28(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa42d
callq 0x13ef0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa42b
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0xa389
jmp 0xa41a
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x13010
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xa418
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xa408
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x13e40
testb $0x1, %al
jne 0xa3d5
jmp 0xa3d7
jmp 0xa3fa
movq -0x48(%rbp), %rax
testb $0x1, 0x39(%rax)
je 0xa3f8
leaq 0xb0d0(%rip), %rdi      # 0x154b8
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xa4b0
jmp 0xa3fa
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xa3b0
jmp 0xa40a
movq -0x40(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xa3a1
jmp 0xa41a
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa36f
jmp 0xa42d
movq -0x28(%rbp), %rdi
callq 0x13da0
callq 0x13ef0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xa490
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xa45e
jmp 0xa47d
leaq 0xb076(%rip), %rdi      # 0x154db
leaq 0xb080(%rip), %rsi      # 0x154ec
movl $0x332, %edx            # imm = 0x332
leaq 0xb07b(%rip), %rcx      # 0x154f3
callq 0x4210
movq -0x50(%rbp), %rdi
callq 0x13d10
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xa43f
movq -0x28(%rbp), %rdi
callq 0x13ed0
movq -0x28(%rbp), %rdi
callq 0x13f00
callq 0x4fd0
callq 0x5050
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_run
bool c_run(char *cmd, char *rest, bool force, struct range *range)
{
	if(range){
		/* filter */
		buffer_t *buf = buffers_cur();

		int err = list_filter(
				&buf->head,
				&(region_t){
					.type = REGION_LINE,
					.begin.y = range->start,
					.end.y = range->end,
				},
				rest);

		const int eno = errno;

		ui_redraw();

		if(err){
			ui_err("filter: %s", strerror(eno));
			return false;
		}

		return true;
	}

	int r = shellout(rest);

	if(r){
		ui_err("command returned %d", r);
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa56c
callq 0x13c60
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movl $0x0, -0x48(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
movl $0x2, -0x38(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rsi
callq 0xde50
movl %eax, -0x34(%rbp)
callq 0x40a0
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
callq 0x4fd0
cmpl $0x0, -0x34(%rbp)
je 0xa566
movl -0x4c(%rbp), %edi
callq 0x44d0
movq %rax, %rsi
leaq 0xae11(%rip), %rdi      # 0x1536a
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xa599
movb $0x1, -0x1(%rbp)
jmp 0xa599
movq -0x18(%rbp), %rdi
callq 0x10570
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x50(%rbp)
je 0xa595
movl -0x50(%rbp), %esi
leaq 0xaf9d(%rip), %rdi      # 0x15525
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xa599
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)