LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_ls
bool c_ls(int argc, char **argv, bool force, struct range *range)
{
	RANGE_NO();
	ARGV_NO();

	buffer_t *b = buffer_new();
	attach_buffer(b, neighbour_down, NULL);

	list_t *files = NULL, *latest = NULL;

	for(tab *tab = tabs_first(); tab; tab = tab->next){
		window *win;
		ITER_WINDOWS_FROM(win, tab->win){
			buffer_t *buf = win->buf;
			const char *fname = buffer_fname(buf);
			if(fname){
				if(list_contains(files, fname))
					continue;

				list_t *new = list_new(NULL);
				new->line = ustrdup(fname);
				new->len_line = strlen(new->line);
				new->len_malloc = new->len_line + 1;

				files = list_append(files, latest, new);
				latest = new;
			}
		}
	}

	buffer_replace_list(b, files);

	ui_redraw();
	ui_cur_changed();

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %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 0xa5ef
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xada9(%rip), %rdi      # 0x15388
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xa778
cmpl $0x1, -0x8(%rbp)
je 0xa613
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xada0(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xa778
callq 0xb750
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xa790
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
callq 0x13ef0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xa75d
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x13010
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xa74a
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0xa737
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0xbb30
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0xa724
movq -0x30(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xea40
cmpq $0x0, %rax
je 0xa6bc
jmp 0xa726
xorl %eax, %eax
movl %eax, %edi
callq 0xc6e0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x5fa0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, (%rax)
movq -0x68(%rbp), %rax
movq (%rax), %rdi
callq 0x4170
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0xd320
movq %rax, -0x30(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xa726
movq -0x48(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xa67d
jmp 0xa739
movq -0x50(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xa66a
jmp 0xa74c
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xa647
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xb7a0
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: attach_buffer
static void attach_buffer(
		buffer_t *buf,
		const enum neighbour dir,
		window *const copy_pos_from)
{
	window *w = window_new(buf);
	buffer_release(buf);

	window_add_neighbour(windows_cur(), dir, w);
	windows_set_cur(w);

	if(copy_pos_from){
		*w->ui_pos = *copy_pos_from->ui_pos;

		w->ui_start = copy_pos_from->ui_start;
		if(neighbour_is_vertical(dir)){
			int diff = (w->ui_pos->y - w->ui_start.y) / 2;

			copy_pos_from->ui_start.y += diff;
			w->ui_start.y += diff;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13620
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xf55(%rip), %rsi       # 0xb710
callq 0x12040
callq 0x13c60
movq %rax, %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x133a0
movq -0x20(%rbp), %rdi
callq 0x13ca0
cmpq $0x0, -0x18(%rbp)
je 0xa851
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %edi
callq 0x13360
testb $0x1, %al
jne 0xa818
jmp 0xa84f
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0xc(%rcx), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
jmp 0xa851
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_p
bool c_p(int argc, char **argv, bool force, struct range *range)
{
	ARGV_NO();

	window *win = windows_cur();

	struct range rng;
	RANGE_DEFAULT(range, rng, win);

	buffer_t *const b = win->buf;

	list_t *l = list_seek(b->head, range->start, false);
	for(int i = range->start; i <= range->end; i++){
		ui_print(l ? l->line : "", l ? l->len_line : 0);
		if(l)
			l = l->next;
	}

	ui_want_return();

	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)
cmpl $0x1, -0x8(%rbp)
je 0xa89e
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xab15(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xa985
callq 0x13c60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa8c7
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movl %eax, -0x30(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x122d0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
xorl %edx, %edx
callq 0xcd50
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0xa97c
cmpq $0x0, -0x40(%rbp)
je 0xa91d
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xa92a
leaq 0xaf14(%rip), %rax      # 0x15838
movq %rax, -0x50(%rbp)
jmp 0xa92a
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xa947
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0xa94f
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0xa94f
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x5b30
cmpq $0x0, -0x40(%rbp)
je 0xa96f
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xa971
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xa8fd
callq 0x5b90
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: copy_move_common
static bool copy_move_common(
		int argc, char **argv,
		struct range **const range,
		struct range *const range_store,
		int *const out_addr)
{
	if(argc != 2){
		ui_err("Usage: %s address", *argv);
		return false;
	}

	char *addr_end;
	if(!parse_range_1(argv[1], &addr_end, out_addr) || *addr_end){
		ui_err("bad address: \"%s\"", argv[1]);
		return false;
	}

	window *win = windows_cur();

	RANGE_DEFAULT(*range, *range_store, win);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0xac1f
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xa95b(%rip), %rdi      # 0x1556a
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xaca8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0x12070
testb $0x1, %al
jne 0xac3a
jmp 0xac46
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xac62
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xaa27(%rip), %rdi      # 0x1567c
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xaca8
callq 0x13c60
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xac98
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x122d0
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: command_bufaction
static void command_bufaction(
		struct range *range, buffer_action_f *buf_fn, int end_add)
{
	window *win = windows_cur();

	struct range range_store;
	RANGE_DEFAULT(range, range_store, win);

	range->end += end_add;

	buffer_t *const b = win->buf;

	buf_fn(
			b,
			&(region_t){
				.begin.y = range->start,
				.end.y = range->end,
				.type = REGION_LINE
			},
			&(point_t){});

	*win->ui_pos = (point_t){ .y = range->end - end_add };

	ui_redraw();
	ui_cur_changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
callq 0x13c60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xafbc
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x122d0
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rdi
movl $0x0, -0x44(%rbp)
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, -0x38(%rbp)
movl $0x2, -0x34(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x48(%rbp)
leaq -0x44(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq *%rax
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movl $0x0, -0x54(%rbp)
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl -0x14(%rbp), %ecx
movl %ecx, -0x50(%rbp)
movq -0x54(%rbp), %rcx
movq %rcx, (%rax)
callq 0x4fd0
callq 0x5050
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_j
bool c_j(int argc, char **argv, bool force, struct range *range)
{
	ARGV_NO();

	if(range && range->start != range->end){
		/* :2j means :2,3j
		 * otherwise, we have :5,6j, in which case we want to say :5,5j */
		range->end--;
	}

	command_bufaction(range, buffer_joinregion_space.fn, 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)
cmpl $0x1, -0x8(%rbp)
je 0xb09b
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xa315(%rip), %rdi      # 0x153a3
movb $0x0, %al
callq 0x4f30
movb $0x0, -0x1(%rbp)
jmp 0xb0da
cmpq $0x0, -0x20(%rbp)
je 0xb0be
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0xb0be
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rdi
leaq 0x112af(%rip), %rax     # 0x1c378
movq (%rax), %rsi
movl $0x1, %edx
callq 0xaf80
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: g_exec
static bool g_exec(list_t *l, int y, struct g_ctx *ctx)
{
	if(*ctx->match /* "" match every line */
	&& !!tim_strstr(l->line, l->len_line, ctx->match) == ctx->g_inverse)
	{
		return true;
	}

	*ctx->win->ui_pos = (point_t){ .y = y };

	struct range range, *prange = &range;
	if(ctx->str_range){
		char *end;
		switch(parse_range(ctx->str_range, &end, prange)){
			case RANGE_PARSE_FAIL:
				return true; /* shouldn't hit this, should be caught in g_c() */
			case RANGE_PARSE_NONE:
				prange = NULL;
			case RANGE_PARSE_PASS:
				break;
		}
	}else{
		prange = NULL;
	}

	cmd_dispatch(ctx->cmd,
			ctx->argc, ctx->argv,
			ctx->force, prange);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xb468
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x10880
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0xb468
movb $0x1, -0x1(%rbp)
jmp 0xb519
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rax), %rax
movl $0x0, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb4e1
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0x121f0
movl %eax, %ecx
movl %ecx, -0x44(%rbp)
testl %eax, %eax
je 0xb4d5
jmp 0xb4bb
movl -0x44(%rbp), %eax
subl $0x1, %eax
je 0xb4cf
jmp 0xb4c5
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0xb4dd
jmp 0xb4df
movb $0x1, -0x1(%rbp)
jmp 0xb519
movq $0x0, -0x38(%rbp)
jmp 0xb4df
jmp 0xb4e9
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x20(%rbp), %rax
movb 0x38(%rax), %al
movq -0x38(%rbp), %r8
andb $0x1, %al
movzbl %al, %ecx
callq 0xb660
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: c_norm
bool c_norm(char *cmd, char *normcmd, bool force, struct range *range)
{
	enum io mode = IO_MAP; /* normal mode mappings */
	if(force)
		mode = IO_NOMAP;

	window *win = windows_cur();

	struct range rng;
	RANGE_DEFAULT(range, rng, win);

	size_t normcmdlen = strlen(normcmd);

	for(int n = range->start;
			n <= range->end;
			n++)
	{
		*win->ui_pos = (point_t){ .y = n };

		size_t const io_empty = io_bufsz();

		/* end with an escape */
		io_ungetch(K_ESC, false);

		/* don't io_map() here - may be in insert mode
		 * when we actually execute */
		for(size_t i = normcmdlen; i > 0; i--)
			io_ungetch(normcmd[i - 1], false);

		do{
			/* run the commands while the buffer is on this line */
			ui_normal_1(/*repeat:*/&(unsigned){ 0 }, mode);
		}while(io_bufsz() > io_empty);
	}

	ui_redraw();
	ui_cur_changed();

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x2, -0x24(%rbp)
testb $0x1, -0x11(%rbp)
je 0xb55f
movl $0x1, -0x24(%rbp)
callq 0x13c60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb588
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
movl %eax, -0x38(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x122d0
movq -0x10(%rbp), %rdi
callq 0x4170
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0xb64c
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movl $0x0, -0x4c(%rbp)
movl -0x44(%rbp), %ecx
movl %ecx, -0x48(%rbp)
movq -0x4c(%rbp), %rcx
movq %rcx, (%rax)
callq 0x112c0
movq %rax, -0x58(%rbp)
movl $0x1b, %edi
xorl %esi, %esi
callq 0x11540
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jbe 0xb61c
movq -0x10(%rbp), %rax
movq -0x60(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %edi
xorl %esi, %esi
callq 0x11540
movq -0x60(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0xb5f0
jmp 0xb61e
movl $0x0, -0x64(%rbp)
movl -0x24(%rbp), %esi
leaq -0x64(%rbp), %rdi
callq 0x53f0
callq 0x112c0
cmpq -0x58(%rbp), %rax
ja 0xb61e
jmp 0xb63e
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xb5a7
callq 0x4fd0
callq 0x5050
movb $0x1, %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/cmds.c
// Function: cmd_dispatch
bool cmd_dispatch(
		const cmd_t *cmd_f,
		int argc, char **argv,
		bool force, struct range *range)
{
	force ^= cmd_f->inverse;

	return cmd_f->single_arg
		? cmd_f->f_arg1(argv[0], argv[1], force, range)
		: cmd_f->f_argv(argc, argv, force, range);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movb 0x11(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
xorl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0xb6d9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rsi
movb -0x19(%rbp), %dl
movq -0x28(%rbp), %rcx
andb $0x1, %dl
movzbl %dl, %edx
callq *%rax
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb6ff
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movb -0x19(%rbp), %dl
movq -0x28(%rbp), %rcx
andb $0x1, %dl
movzbl %dl, %edx
callq *%rax
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_new
buffer_t *buffer_new()
{
	buffer_t *b = umalloc(sizeof *b);

	retain_init(b);

	b->head = list_new(NULL);
	b->eol = true; /* default to nice eol */
	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x50, %edi
callq 0x5f20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0xc6e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_replace_fname
void buffer_replace_fname(
		buffer_t *const b, const char *fname,
		const char **const err)
{
	*err = NULL;

	FILE *f = fopen(fname, "r");
	if(!f){
err:
		*err = strerror(errno);
		return;
	}

	if(!buffer_replace_file(b, f)){
		fclose(f);
		goto err;
	}
	fclose(f);

	buffer_set_fname(b, fname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x9cdf(%rip), %rsi      # 0x154d9
callq 0x4440
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb824
jmp 0xb80c
callq 0x40a0
movl (%rax), %edi
callq 0x44d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xb857
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb860
cmpl $0x0, %eax
jne 0xb841
movq -0x20(%rbp), %rdi
callq 0x4150
jmp 0xb80c
movq -0x20(%rbp), %rdi
callq 0x4150
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb8d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_replace_file
static int buffer_replace_file(buffer_t *b, FILE *f)
{
	list_t *l = list_new_file(f, &b->eol);

	if(!l)
		return 0;

	buffer_replace_list(b, l);

	b->mtime = time(NULL);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0xc7b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb895
movl $0x0, -0x4(%rbp)
jmp 0xb8bd
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb7a0
xorl %eax, %eax
movl %eax, %edi
callq 0x4360
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_new_file_nofind
buffer_t *buffer_new_file_nofind(FILE *f)
{
	buffer_t *b = buffer_new();

	if(buffer_replace_file(b, f))
		return b;

	buffer_free(b);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0xb750
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb860
cmpl $0x0, %eax
je 0xb951
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb962
movq -0x18(%rbp), %rdi
callq 0xb710
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_new_fname
void buffer_new_fname(
		buffer_t **pb, const char *fname,
		const char **const err)
{
	*err = NULL;

	/* look for an existing buffer first */
	buffer_t *b = buffers_find(fname);

	if(b){
		*pb = retain(b);
		return;
	}

	FILE *f = fopen(fname, "r");
	if(!f){
got_err:
		*err = strerror(errno);
		b = buffer_new();
		b->modified = false; /* editing a non-existant file, etc */
		goto fin;
	}

	b = buffer_new_file_nofind(f);
	fclose(f);

	if(!b){
		if(errno == EISDIR){
			DIR *d = opendir(fname);
			if(!d)
				goto got_err;

			list_t *l = list_from_dir(d);

			const int save_errno = errno;
			closedir(d);
			errno = save_errno;

			if(!l)
				goto got_err;

			b = buffer_new();
			buffer_replace_list(b, l);
		}else{
			goto got_err;
		}
	}

fin:
	buffer_set_fname(b, fname);
	*pb = b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x12bf0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xb9bb
movq -0x20(%rbp), %rdi
callq 0x12020
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbab6
movq -0x10(%rbp), %rdi
leaq 0x9b13(%rip), %rsi      # 0x154d9
callq 0x4440
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xba04
jmp 0xb9d8
callq 0x40a0
movl (%rax), %edi
callq 0x44d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
callq 0xb750
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, 0x39(%rax)
jmp 0xba9e
movq -0x28(%rbp), %rdi
callq 0xb920
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4150
cmpq $0x0, -0x20(%rbp)
jne 0xba9c
callq 0x40a0
cmpl $0x15, (%rax)
jne 0xba95
movq -0x10(%rbp), %rdi
callq 0x4160
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xba41
jmp 0xb9d8
movq -0x30(%rbp), %rdi
callq 0xc8f0
movq %rax, -0x38(%rbp)
callq 0x40a0
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4290
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0x40a0
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
cmpq $0x0, -0x38(%rbp)
jne 0xba7d
jmp 0xb9d8
callq 0xb750
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xb7a0
jmp 0xba9a
jmp 0xb9d8
jmp 0xba9c
jmp 0xba9e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb8d0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_write_file
int buffer_write_file(buffer_t *b, int n, FILE *f, bool eol)
{
	int r = list_write_file(b->head, n, f, eol);
	b->mtime = time(NULL);
	b->modified = false;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xcb60
movl %eax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x4360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x39(%rax)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_smartindent
void buffer_smartindent(buffer_t *buf, int *const x, int y)
{
	list_t *l = buffer_last_indent_line(buf, y);
	if(!l){
		*x = 0;
		return;
	}
	int indent = list_count_indent(l);

	/* don't insert space, just move */
	*x = indent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbbb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbb86
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0xbb9b
movq -0x20(%rbp), %rdi
callq 0xbc40
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_last_indent_line
static list_t *buffer_last_indent_line(buffer_t *buf, int y)
{
	list_t *l = list_seek(buf->head, y, false);

	if(!l)
		return NULL;

	/* scan backwards until we hit a non-empty line */
	while(l->prev){
		l = l->prev;
		if(!isallspace(l->line, l->len_line))
			return l;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0xcd50
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbbe6
movq $0x0, -0x8(%rbp)
jmp 0xbc2b
jmp 0xbbe8
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xbc23
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10960
testb $0x1, %al
jne 0xbc21
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbc2b
jmp 0xbbe8
movq $0x0, -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/buffer.c
// Function: list_count_indent
static int list_count_indent(list_t *l)
{
	int indent = 0;

	/* count indent */
	for(unsigned i = 0; i < l->len_line; i++, indent++)
		if(!isspace(l->line[i]))
			break;

	/* if it ends with a '{', increase indent */
	if(l->len_line > 0 && l->line[l->len_line - 1] == '{')
		indent++;

	return indent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xbca6
callq 0x4530
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl -0x10(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0xbc90
jmp 0xbca6
jmp 0xbc92
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbc5a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0xbcd6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7b, %eax
jne 0xbcd6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_inschar_at
void buffer_inschar_at(buffer_t *buf, char ch, int *x, int *y)
{
	bool indent = false;
	bool inschar = true;

	switch(ch){
		case CTRL_AND('?'):
		case CTRL_AND('H'):
		case 127:
			if(*x > 0)
				buffer_delchar(buf, x, y);
			inschar = false;
			break;

		case '}':
			/* if we've just started a new line, this unindents */
			buffer_unindent_empty(buf, x, *y);
			indent = false;
			break;

		case '\n':
			indent = true;
	}

	if(inschar){
		list_inschar(buf->head, x, y, ch, /*autogap*/0);
		if(indent)
			buffer_smartindent(buf, x, *y);
	}

	buf->modified = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movb $0x1, -0x22(%rbp)
movsbl -0x9(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x8, %eax
je 0xbd38
jmp 0xbd10
movl -0x28(%rbp), %eax
subl $0xa, %eax
je 0xbd71
jmp 0xbd1a
movl -0x28(%rbp), %eax
subl $0x1f, %eax
je 0xbd38
jmp 0xbd24
movl -0x28(%rbp), %eax
subl $0x7d, %eax
je 0xbd58
jmp 0xbd2e
movl -0x28(%rbp), %eax
subl $0x7f, %eax
jne 0xbd75
jmp 0xbd38
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jle 0xbd52
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xbdc0
movb $0x0, -0x22(%rbp)
jmp 0xbd75
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl (%rax), %edx
callq 0xbe00
movb $0x0, -0x21(%rbp)
jmp 0xbd75
movb $0x1, -0x21(%rbp)
testb $0x1, -0x22(%rbp)
je 0xbdb2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %r8d, %r8d
movsbl -0x9(%rbp), %ecx
callq 0xd000
testb $0x1, -0x21(%rbp)
je 0xbdb0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl (%rax), %edx
callq 0xbb50
jmp 0xbdb2
movq -0x8(%rbp), %rax
movb $0x1, 0x39(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_unindent_empty
static void buffer_unindent_empty(buffer_t *buf, int *const x, int y)
{
	if(y == 0)
		return;

	list_t *l = buffer_last_indent_line(buf, y);
	if(!l)
		return;
	if(!l->line || !isallspace(l->line, *x))
		return;
	int indent = list_count_indent(l);

	if(indent == 0)
		return;

	*x = indent - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xbe1b
jmp 0xbe77
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbbb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbe34
jmp 0xbe77
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xbe55
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x10960
testb $0x1, %al
jne 0xbe57
jmp 0xbe77
movq -0x20(%rbp), %rdi
callq 0xbc40
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xbe6b
jmp 0xbe77
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_inscolchar
void buffer_inscolchar(
		buffer_t *buf, char ch, unsigned ncols,
		point_t *const ui_pos)
{
	for(int i = ncols - 1; i >= 0; i--){
		int y = ui_pos->y + i;
		int x = ui_pos->x;
		int *px = &x;
		int *py = &y;

		/* update x and y in the last case */
		if(i == 0){
			px = &ui_pos->x;
			py = &ui_pos->y;
		}

		buffer_inschar_at(buf, ch, px, py);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xbf0a
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xbee8
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movsbl %al, %esi
callq 0xbce0
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbea2
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_delregion_f
static
void buffer_delregion_f(buffer_t *buf, const region_t *region, point_t *out)
{
	list_t *del = list_delregion(&buf->head, region);

	if(del){
		release(yank_push(yank_new(del, region->type)), yank_free);

		buf->modified = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xd3b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xbf6f
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x11720
movq %rax, %rdi
callq 0x117d0
movq %rax, %rdi
leaq 0x583e(%rip), %rsi      # 0x117a0
callq 0x12040
movq -0x8(%rbp), %rax
movb $0x1, 0x39(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_yankregion_f
static
void buffer_yankregion_f(buffer_t *buf, const region_t *region, point_t *out)
{
	list_t *yanked = list_delregion(&buf->head, region);

	if(yanked){
		yank *yank = yank_new(yanked, region->type);
		yank_push(yank);

		point_t ui_pos = region->begin;

		buffer_insyank(buf, yank, &ui_pos,
				/*prepend:*/true, /*modify:*/false);

		release(yank, yank_free);
	}

	/* restore ui pos (set in buffer_insyank) */
	*out = region->begin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xd3b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc001
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x11720
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x117d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xc020
movq -0x28(%rbp), %rdi
leaq 0x57a4(%rip), %rsi      # 0x117a0
callq 0x12040
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_insyank
void buffer_insyank(
		buffer_t *buf, const yank *y,
		point_t *ui_pos,
		bool prepend, bool modify)
{
	yank_put_in_list(y,
			&buf->head,
			prepend,
			&ui_pos->y,
			&ui_pos->x);

	if(modify)
		buf->modified = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movb -0x19(%rbp), %al
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
movq -0x18(%rbp), %r8
andb $0x1, %al
movzbl %al, %edx
callq 0x11830
testb $0x1, -0x1a(%rbp)
je 0xc075
movq -0x8(%rbp), %rax
movb $0x1, 0x39(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_caseregion
void buffer_caseregion(
		buffer_t *buf,
		enum case_tog tog_type,
		const region_t *r)
{
	int (*f)(int) = NULL;

	switch(tog_type){
		case CASE_TOGGLE: f = ctoggle; break;
		case CASE_UPPER:  f = toupper; break;
		case CASE_LOWER:  f = tolower; break;
	}
	assert(f);

	list_iter_region(buf->head, r, 0, buffer_case_cb, &f);
	buf->modified = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0xc1db
jmp 0xc1c7
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0xc1e8
jmp 0xc1d1
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xc1f5
jmp 0xc200
leaq 0x7e(%rip), %rax        # 0xc260
movq %rax, -0x20(%rbp)
jmp 0xc200
movq 0xfda9(%rip), %rax      # 0x1bf98
movq %rax, -0x20(%rbp)
jmp 0xc200
movq 0xfdcc(%rip), %rax      # 0x1bfc8
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc209
jmp 0xc228
leaq 0x9013(%rip), %rdi      # 0x15223
leaq 0x9477(%rip), %rsi      # 0x1568e
movl $0x1e2, %edx            # imm = 0x1E2
leaq 0x9474(%rip), %rcx      # 0x15697
callq 0x4210
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
leaq 0x73(%rip), %rcx        # 0xc2b0
leaq -0x20(%rbp), %r8
callq 0xe160
movq -0x8(%rbp), %rax
movb $0x1, 0x39(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_findat
bool buffer_findat(const buffer_t *buf, const char *search, point_t *at, int dir)
{
	list_t *l = list_seek(buf->head, at->y, 0);

	if(!l){
		if(dir < 0){
			l = list_last(buf->head, &at->y);
		}else{
			return false;
		}
	}

	/* search at the next char */
	l = list_advance_x(l, dir, &at->y, &at->x);

	while(l){
		char *p;
		if((unsigned)at->x < l->len_line
		&& (p = buffer_find2(l->line, l->len_line, search, at->x, dir)))
		{
			at->x = p - l->line;
			at->y = at->y;
			return true;
		}

		l = list_advance_y(l, dir, &at->y, &at->x);
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
xorl %edx, %edx
callq 0xcd50
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xc3b4
cmpl $0x0, -0x24(%rbp)
jge 0xc3a9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
callq 0xe560
movq %rax, -0x30(%rbp)
jmp 0xc3b2
movb $0x0, -0x1(%rbp)
jmp 0xc466
jmp 0xc3b4
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
movq -0x20(%rbp), %rcx
callq 0xe4b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xc462
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xc441
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movl -0x24(%rbp), %r8d
callq 0xc480
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xc441
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xc466
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
movq -0x20(%rbp), %rcx
callq 0xe400
movq %rax, -0x30(%rbp)
jmp 0xc3d0
movb $0x0, -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/buffer.c
// Function: buffer_joinregion_f
static
void buffer_joinregion_f(
		buffer_t *buf,
		const region_t *region,
		point_t *out,
		const bool space)
{
	/* could use 'how' here - columns and lines only make sense */
	list_t *l = list_seek(buf->head, region->begin.y, 0);
	const int mid = l ? l->len_line : 0;

	list_joinregion(&buf->head, region, space);

	if(l)
		out->x = mid;
	buf->modified = true;
}

// 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 -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
xorl %edx, %edx
callq 0xcd50
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc53a
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xc542
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xc542
movq -0x38(%rbp), %rax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xdc00
cmpq $0x0, -0x28(%rbp)
je 0xc572
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x39(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffer.c
// Function: buffer_indent2
static
void buffer_indent2(
		buffer_t *buf, const region_t *region,
		point_t *out, int dir)
{
	/* region is sorted by y */
	const int min_x = MIN(region->begin.x, region->end.x);
	list_t *pos = dir < 0
		? list_seek(buf->head, region->begin.y, 0)
		: NULL;

	for(int y = region->begin.y; y <= region->end.y; y++){
		int x = 0;

		switch(region->type){
			case REGION_CHAR:
			case REGION_LINE:
				break;
			case REGION_COL:
				/* indent from the first col onwards */
				x = min_x;
		}

		if(dir > 0){
			buffer_inschar_at(buf, '\t', &x, &y);
		}else{
			if(pos){
				if(pos->len_line > 0 && pos->line[0] == '\t')
					memmove(pos->line, pos->line + 1, --pos->len_line);

				pos = pos->next;
			}else{
				break;
			}
		}
	}
	buf->modified = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xc5b1
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0xc5bb
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xc5e3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
xorl %edx, %edx
callq 0xcd50
movq %rax, -0x40(%rbp)
jmp 0xc5eb
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0xc5eb
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0xc6c8
movl $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x44(%rbp)
testl %eax, %eax
je 0xc638
jmp 0xc624
movl -0x44(%rbp), %eax
subl $0x1, %eax
je 0xc63a
jmp 0xc62e
movl -0x44(%rbp), %eax
subl $0x2, %eax
jne 0xc640
jmp 0xc638
jmp 0xc640
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0xc65e
movq -0x8(%rbp), %rdi
movl $0x9, %esi
leaq -0x30(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
callq 0xbce0
jmp 0xc6b8
cmpq $0x0, -0x28(%rbp)
je 0xc6b4
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0xc6a6
movq -0x28(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0xc6a6
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
addq $0x1, %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
addq $-0x1, %rdx
movq %rdx, 0x8(%rax)
callq 0x4400
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc6b6
jmp 0xc6c8
jmp 0xc6b8
jmp 0xc6ba
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc5fd
movq -0x8(%rbp), %rax
movb $0x1, 0x39(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_copy_deep
list_t *list_copy_deep(const list_t *const l, list_t *prev)
{
	if(!l)
		return NULL;
	list_t *new = list_new(prev);
	new->len_line = l->len_line;
	new->len_malloc = l->len_line; /* len_line, not len_malloc */
	new->line = ustrdup_len(l->line, l->len_line);
	new->next = list_copy_deep(l->next, new);
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc731
movq $0x0, -0x8(%rbp)
jmp 0xc7a0
movq -0x18(%rbp), %rdi
callq 0xc6e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5fe0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xc710
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_new_fd
static list_t *list_new_fd(int fd, bool *eol)
{
	struct stat st;
	if(fstat(fd, &st) == -1)
		return NULL;

	if(st.st_size == 0)
		goto fallback; /* could be stdin */

	if(S_ISDIR(st.st_mode)){
		errno = EISDIR;
		return NULL;
	}

	void *mem = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);

	if(mem == MAP_FAILED){
		if(errno == EINVAL)
fallback:
			return list_new_fd_read(fd, eol);

		return NULL;
	}

	list_t *l = mmap_to_lines(mem, st.st_size, eol);
	munmap(mem, st.st_size);

	return l;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %edi
leaq -0xa8(%rbp), %rsi
callq 0x4500
cmpl $-0x1, %eax
jne 0xc813
movq $0x0, -0x8(%rbp)
jmp 0xc8da
cmpq $0x0, -0x78(%rbp)
jne 0xc81c
jmp 0xc888
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0xc846
callq 0x40a0
movl $0x15, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xc8da
movq -0x78(%rbp), %rsi
movl -0xc(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, %edx
movl $0x2, %ecx
movq %r9, %rdi
callq 0x4190
movq %rax, -0xb0(%rbp)
movq $-0x1, %rax
cmpq %rax, -0xb0(%rbp)
jne 0xc8a4
callq 0x40a0
cmpl $0x16, (%rax)
jne 0xc89a
jmp 0xc888
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xeaa0
movq %rax, -0x8(%rbp)
jmp 0xc8da
movq $0x0, -0x8(%rbp)
jmp 0xc8da
movq -0xb0(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xeb70
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x43f0
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_free
void list_free(list_t *l)
{
	while(l){
		list_t *next = l->next;

		free(l->line);
		free(l);

		l = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcb4e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4080
movq -0x8(%rbp), %rdi
callq 0x4080
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcb1c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/list.c
// Function: list_write_fd
static int list_write_fd(list_t *l, int n, int fd, bool eol)
{
	for(; l && (n == -1 || n --> 0); l = l->next){
		if(write(fd, l->line, l->len_line) != (int)l->len_line)
			goto got_err;

		if(l->next || eol)
			if(write(fd, "\n", 1) != 1)
				goto got_err;
	}

	return 0;
got_err:
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x1a(%rbp)
je 0xcbfa
movb $0x1, %al
cmpl $-0x1, -0x14(%rbp)
movb %al, -0x1b(%rbp)
je 0xcbf4
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0xcc03
jmp 0xcc6e
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x4110
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
je 0xcc2c
jmp 0xcc77
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xcc3d
testb $0x1, -0x19(%rbp)
je 0xcc5b
movl -0x18(%rbp), %edi
leaq 0x8bf0(%rip), %rsi      # 0x15837
movl $0x1, %edx
callq 0x4110
cmpq $0x1, %rax
je 0xcc59
jmp 0xcc77
jmp 0xcc5b
jmp 0xcc5d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xcbc9
movl $0x0, -0x4(%rbp)
jmp 0xcc7e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)