LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/ui.c
// Function: ui_main
int ui_main()
{
	ui_redraw(); /* this first, to frame buf_sel */
	ui_cur_changed(); /* this, in case there's an initial buf offset */

	while(1){
		ui_wait_return();

		switch(ui_run){
			case UI_RUNNING: break;
			case UI_EXIT_0: return 0;
			case UI_EXIT_1: return 1;
		}

		window *win = windows_cur();

		if(win->ui_mode & UI_VISUAL_ANY){
			point_t *alt = window_uipos_alt(win);

			ui_rstatus("%d,%d - %d,%d %dx%d",
					win->ui_pos->y, win->ui_pos->x,
					alt->y, alt->x,
					1 + abs(win->ui_pos->x - alt->x),
					1 + abs(win->ui_pos->y - alt->y));
		}

		const enum io io_mode = bufmode_to_iomap(win->ui_mode);

		unsigned repeat = 0;
		ui_normal_1(&repeat, io_mode | IO_MAPRAW);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x4fd0
callq 0x5050
callq 0x5790
movl 0x16d3f(%rip), %eax     # 0x1c3cc
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x56aa
jmp 0x5696
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x56ac
jmp 0x56a0
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x56b8
jmp 0x56c4
jmp 0x56c4
movl $0x0, -0x4(%rbp)
jmp 0x5782
movl $0x1, -0x4(%rbp)
jmp 0x5782
callq 0x13c60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x38, %eax
cmpl $0x0, %eax
je 0x5758
movq -0x10(%rbp), %rdi
callq 0x13750
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl (%rax), %r8d
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %r9d
movq -0x18(%rbp), %rax
subl (%rax), %r9d
movl %r9d, %eax
negl %eax
cmovnsl %eax, %r9d
addl $0x1, %r9d
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rdi
subl 0x4(%rdi), %eax
movl %eax, %edi
negl %edi
cmovnsl %edi, %eax
addl $0x1, %eax
leaq 0xf9d0(%rip), %rdi      # 0x1511e
movl %eax, (%rsp)
movb $0x0, %al
callq 0x57f0
movq -0x10(%rbp), %rax
movl 0x40(%rax), %edi
callq 0x112d0
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %esi
orl $0x10, %esi
leaq -0x20(%rbp), %rdi
callq 0x53f0
jmp 0x5682
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/ui.c
// Function: ui_wait_return
void ui_wait_return(void)
{
	if(!want_return)
		return;

	want_return = false;

	bool raw;
	int ch = io_getch(IO_NOMAP, &raw, true);
	(void)raw; /* pushed straight back */
	if(!isnewline(ch))
		io_ungetch(ch, false);

	ui_redraw();
	ui_cur_changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x16c31(%rip)     # 0x1c3d0
jne 0x57a3
jmp 0x57dd
movb $0x0, 0x16c26(%rip)     # 0x1c3d0
movl $0x1, %edx
leaq -0x1(%rbp), %rsi
movl %edx, %edi
callq 0x11310
movl %eax, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
je 0x57d3
cmpl $0xd, -0x8(%rbp)
je 0x57d3
movl -0x8(%rbp), %edi
xorl %esi, %esi
callq 0x11540
callq 0x4fd0
callq 0x5050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/ui.c
// Function: ui_draw_windows
static
void ui_draw_windows(
		window *any,
		unsigned const screentop,
		unsigned const screenheight,
		unsigned const screenwidth)
{
	window *win = window_topleftmost(any);

	window_calc_rects(win, screentop, screenwidth, screenheight);

	for(int i = 0; win; i++, win = win->neighbours.right){
		if(i){
			const rect_t *r = &win->screen_coord;
			/* r->y should be zero, r->h-1 should be screen height */
			ui_draw_vline(r->x - 1, r->y, screenheight - 1);
		}

		ui_draw_window_col(win);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13010
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x12e10
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x592f
cmpl $0x0, -0x24(%rbp)
je 0x590f
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %edi
subl $0x1, %edi
movq -0x30(%rbp), %rax
movl 0x4(%rax), %esi
movl -0x10(%rbp), %edx
subl $0x1, %edx
callq 0x5ba0
movq -0x20(%rbp), %rdi
callq 0x5bf0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x58db
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/ui.c
// Function: ui_draw_tabs
static void ui_draw_tabs(void)
{
	const unsigned ntabs = tabs_count();
	const unsigned ncols = nc_COLS();
	unsigned tabspace = ncols / ntabs;

	if(tabspace < 2)
		tabspace = 2;

	unsigned x = 0;
	char *const buf = umalloc(tabspace + 1);

	for(tab *t = tabs_first(); t; t = t->next){
		const char *fname = buffer_fname(t->win->buf);

		if(!fname)
			fname = "[No Name]";

		int printlen = snprintf(buf, tabspace + 1, "%s", fname);

		nc_set_yx(0, x);

		if(t == tabs_cur())
			nc_highlight(1);
		nc_addstr(buf);
		nc_highlight(0);
		nc_addch('|');

		x += printlen + 1;

		if(x >= ncols)
			break;
	}

	nc_clrtoeol();

	free(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x13f40
movl %eax, -0x4(%rbp)
callq 0x4e80
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
xorl %edx, %edx
divl -0x4(%rbp)
movl %eax, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jae 0x5970
movl $0x2, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5f20
movq %rax, -0x18(%rbp)
callq 0x13ef0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5a56
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xbb30
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x59c3
leaq 0xf7c9(%rip), %rax      # 0x15188
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
movq -0x28(%rbp), %rcx
leaq 0x10195(%rip), %rdx     # 0x15b71
movb $0x0, %al
callq 0x41e0
movl %eax, -0x2c(%rbp)
movl -0x10(%rbp), %esi
xorl %edi, %edi
callq 0x4b90
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x13ec0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x5a13
movl $0x1, %edi
callq 0x4a40
movq -0x18(%rbp), %rdi
callq 0x4e10
xorl %edi, %edi
callq 0x4a40
movl $0x7c, %edi
callq 0x4cf0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jb 0x5a43
jmp 0x5a56
jmp 0x5a45
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5993
callq 0x4e90
movq -0x18(%rbp), %rdi
callq 0x4080
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/ui.c
// Function: ui_print
void ui_print(const char *s, size_t n)
{
	nc_set_yx(nc_LINES() - 1, 0);
	while(n --> 0)
		nc_addch(*s++);
	nc_addch('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4e70
movl %eax, %edi
subl $0x1, %edi
xorl %esi, %esi
callq 0x4b90
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
jbe 0x5b7f
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %edi
callq 0x4cf0
jmp 0x5b51
movl $0xa, %edi
callq 0x4cf0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/ui.c
// Function: ui_draw_window_col
static
void ui_draw_window_col(window *win)
{
	for(unsigned i = 0; win; i++, win = win->neighbours.below){
		if(i){
			const rect_t *r = &win->screen_coord;
			ui_draw_hline(r->y - 1, r->x, r->w - 1);
		}

		ui_draw_win_1(win);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5c5b
cmpl $0x0, -0xc(%rbp)
je 0x5c3b
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
subl $0x1, %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
subl $0x1, %edx
callq 0x5c70
movq -0x8(%rbp), %rdi
callq 0x5cb0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5c03
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/ui.c
// Function: ui_mode_to_region
static enum region_type ui_mode_to_region(enum buf_mode m)
{
	switch(m){
		case UI_NORMAL:
		case UI_INSERT:
		case UI_INSERT_COL:
			break;
		case UI_VISUAL_CHAR: return REGION_CHAR;
		case UI_VISUAL_COL: return REGION_COL;
		case UI_VISUAL_LN: return REGION_LINE;
	}
	return REGION_CHAR; /* doesn't matter */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x1f, %eax
ja 0x5f08
movq -0x10(%rbp), %rax
leaq 0xf1ae(%rip), %rcx      # 0x15090
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x5f08
movl $0x0, -0x4(%rbp)
jmp 0x5f0f
movl $0x1, -0x4(%rbp)
jmp 0x5f0f
movl $0x2, -0x4(%rbp)
jmp 0x5f0f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/mem.c
// Function: umalloc
void *umalloc(size_t l)
{
	void *p = malloc(l);
	if(!p)
		abort();
	memset(p, 0, l);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5f45
callq 0x4090
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x4240
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/mem.c
// Function: urealloc
void *urealloc(void *p, size_t l)
{
	void *r = realloc(p, l);
	if(!r)
		abort();
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5f8d
callq 0x4090
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/mem.c
// Function: ustrdup_len
char *ustrdup_len(const char *s, size_t len)
{
	char *r = umalloc(len + 1);
	memcpy(r, s, len);
	r[len] = '\0';
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x5f20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4350
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/mem.c
// Function: join
char *join(const char *sep, char **vec, int n)
{
	const int len_sep = strlen(sep);
	int len = 1;

	for(int i = 0; i < n; i++)
		len += len_sep + strlen(vec[i]);

	char *p, *r = p = umalloc(len);
	const char *sep_actual = "";

	for(int i = 0; i < n; i++){
		p += sprintf(p, "%s%s", sep_actual, vec[i]);
		sep_actual = sep;
	}

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4170
movl %eax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x609a
movslq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4170
movq -0x48(%rbp), %rcx
addq %rax, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x605d
movslq -0x1c(%rbp), %rdi
callq 0x5f20
movq %rax, -0x28(%rbp)
movq %rax, -0x30(%rbp)
leaq 0xf786(%rip), %rax      # 0x15838
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x610a
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0xf0b2(%rip), %rsi      # 0x15192
movb $0x0, %al
callq 0x44a0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x60bd
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/mem.c
// Function: ustrvprintf
char *ustrvprintf(const char *fmt, va_list l)
{
	char *buf = NULL;
	int len = 8, ret;

	do{
		va_list lcp;

		len *= 2;
		buf = urealloc(buf, len);

		va_copy(lcp, l);
		ret = vsnprintf(buf, len, fmt, lcp);
		va_end(lcp);

	}while(ret >= len);

	return buf;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x8, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x5f60
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x4100
movl %eax, -0x20(%rbp)
leaq -0x40(%rbp), %rax
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x613f
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_escape
void k_escape(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	window *win = windows_cur();

	const bool was_insert = win->ui_mode & UI_INSERT_ANY;

	/* set normal mode before the move - lets us capture the position */
	ui_set_bufmode(UI_NORMAL);

	if(was_insert){
		motion move = {
			.func = m_move,
			.arg = { .pos = { -1, 0 } }
		};

		motion_apply_win(&move, /*repeat:*/1, win);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x13c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x6, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movl $0x1, %edi
callq 0x4eb0
testb $0x1, -0x19(%rbp)
je 0x6213
movq 0x15859(%rip), %rax     # 0x1ba40
movq %rax, -0x38(%rbp)
movq 0x15856(%rip), %rax     # 0x1ba48
movq %rax, -0x30(%rbp)
movq 0x15853(%rip), %rax     # 0x1ba50
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x10310
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_set_mode
void k_set_mode(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	window *win = windows_cur();

	/* if we're in visual-col and told to insert like that... */
	if(win->ui_mode == UI_VISUAL_COL && a->i == UI_INSERT_COL){
		region_t r;

		if(around_motion(repeat, from_ch, false, /*noop:*/NULL, &r)){
			win->buf->col_insert_height = r.end.y - r.begin.y + 1;
			ui_set_bufmode(UI_INSERT_COL);
		}
	}else{
		ui_set_bufmode(a->i);
	}
}

// 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), %rax
cmpl $0x10, 0x40(%rax)
jne 0x6288
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x6288
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x2c(%rbp), %r8
callq 0x82c0
testb $0x1, %al
jne 0x6269
jmp 0x6286
movl -0x20(%rbp), %ecx
subl -0x28(%rbp), %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x48(%rax)
movl $0x4, %edi
callq 0x4eb0
jmp 0x6293
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x4eb0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_open
void k_open(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	window *win = windows_cur();
	buffer_insline(win->buf, a->i, win->ui_pos);
	window_smartindent(win);

	ui_set_bufmode(UI_INSERT);
	ui_redraw();
	ui_cur_changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x13c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0xc2f0
movq -0x18(%rbp), %rdi
callq 0x13c20
movl $0x2, %edi
callq 0x4eb0
callq 0x4fd0
callq 0x5050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_del
void k_del(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	region_t region;

	bool deleted = around_motion_bufaction(
			repeat, from_ch, &buffer_delregion, &region);

	if(deleted && region.type == REGION_LINE){
		start_of_line(NULL, windows_cur());
		ui_cur_changed();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
leaq 0x15ff9(%rip), %rdx     # 0x1c358
leaq -0x24(%rbp), %rcx
callq 0x8490
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
je 0x638f
cmpl $0x2, -0x14(%rbp)
jne 0x638f
callq 0x13c60
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xed10
callq 0x5050
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_change
void k_change(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	region_t r;

	if(around_motion_bufaction(repeat, from_ch, &buffer_delregion, &r)){
		window *win = windows_cur();
		buffer_t *buf = win->buf;

		switch(r.type){
			case REGION_COL:
				buf->col_insert_height = r.end.y - r.begin.y + 1;
				ui_set_bufmode(UI_INSERT_COL);
				break;
			case REGION_LINE:
				k_open(&(keyarg_u){ .i = -1 }, 0, 0);
				break;
			case REGION_CHAR:
				ui_set_bufmode(UI_INSERT);
				/* handle S / 0c$ */
				list_t *curline;
				if(r.begin.x == 0
				&& (curline = window_current_line(win, false))
				&& (unsigned)r.end.x >= curline->len_line)
				{
					window_smartindent(win);
				}
				break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
leaq 0x15f99(%rip), %rdx     # 0x1c358
leaq -0x24(%rbp), %rcx
callq 0x8490
testb $0x1, %al
jne 0x63d1
jmp 0x6486
callq 0x13c60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x6c(%rbp)
testl %eax, %eax
je 0x6447
jmp 0x63f1
movl -0x6c(%rbp), %eax
subl $0x1, %eax
je 0x6405
jmp 0x63fb
movl -0x6c(%rbp), %eax
subl $0x2, %eax
je 0x6421
jmp 0x6484
movl -0x18(%rbp), %ecx
subl -0x20(%rbp), %ecx
addl $0x1, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x48(%rax)
movl $0x4, %edi
callq 0x4eb0
jmp 0x6484
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x4240
movl $0xffffffff, -0x60(%rbp) # imm = 0xFFFFFFFF
leaq -0x60(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x62a0
jmp 0x6484
movl $0x2, %edi
callq 0x4eb0
cmpl $0x0, -0x24(%rbp)
jne 0x6482
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x13790
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x6482
movl -0x1c(%rbp), %eax
movq -0x68(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x6482
movq -0x30(%rbp), %rdi
callq 0x13c20
jmp 0x6484
jmp 0x6486
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_put
void k_put(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	bool prepend = a->b;
	const yank *yank = retain(yank_top());
	if(!yank)
		return;

	window *win = windows_cur();
	if(win->ui_mode & UI_VISUAL_ANY){
		/* delete what we have, then paste */
		region_t r;
		unsigned mrepeat;
		const motion *m = motion_read_or_visual(&mrepeat, false);

		if(!motion_to_region(m, mrepeat, win, &r))
			return;

		/* necessary so we insert at the right place later on */
		point_sort_full(&win->ui_npos, &win->ui_vpos);

		buffer_t *buf = win->buf;

		buffer_delregion.fn(buf, &r, &(point_t){0});

		/* unconditional for visual-put */
		prepend = true;
	}

	repeat = DEFAULT_REPEAT(repeat);
	while(repeat --> 0)
		buffer_insyank(buffers_cur(), yank, win->ui_pos, prepend, /*modify:*/true);

	win->ui_mode = UI_NORMAL; /* remove visual */

	start_of_line(NULL, win);

	ui_redraw();
	ui_cur_changed();

	release(yank, yank_free);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
callq 0x11820
movq %rax, %rdi
callq 0x12020
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x64fa
jmp 0x6611
callq 0x13c60
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x38, %eax
cmpl $0x0, %eax
je 0x6588
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x81e0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x28(%rbp), %rdx
leaq -0x3c(%rbp), %rcx
callq 0x10390
testb $0x1, %al
jne 0x653e
jmp 0x6611
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
callq 0x11da0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
leaq 0x15df3(%rip), %rax     # 0x1c358
movq (%rax), %rax
movq -0x50(%rbp), %rdi
movl $0x0, -0x58(%rbp)
movl $0x0, -0x54(%rbp)
leaq -0x3c(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq *%rax
movb $0x1, -0x11(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x6596
movl -0xc(%rbp), %eax
movl %eax, -0x5c(%rbp)
jmp 0x65a0
movl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x65a0
movl -0x5c(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
jbe 0x65df
callq 0x13c60
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdx
movb -0x11(%rbp), %al
movl $0x1, %r8d
andb $0x1, %al
movzbl %al, %ecx
callq 0xc020
jmp 0x65a6
movq -0x28(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xed10
callq 0x4fd0
callq 0x5050
movq -0x20(%rbp), %rdi
leaq 0xb194(%rip), %rsi      # 0x117a0
callq 0x12040
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_join
void k_join(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	const bool space = a->b;

	around_motion_bufaction(
			repeat,
			from_ch,
			space ? &buffer_joinregion_space : &buffer_joinregion_nospace,
			NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movb -0x11(%rbp), %cl
leaq 0x15d3b(%rip), %rdx     # 0x1c388
leaq 0x15d24(%rip), %rax     # 0x1c378
testb $0x1, %cl
cmovneq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x8490
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_prompt_cmd
void k_prompt_cmd(const keyarg_u *arg, unsigned repeat, const int from_ch)
{
	char *initial = NULL;
	char initial_buf[32];

	window *win = windows_cur();

	if(win->ui_mode & UI_VISUAL_ANY){
		int y1 = 1 + win->ui_pos->y;
		int y2 = 1 + window_uipos_alt(win)->y;

		if(y2 < y1){
			int tmp = y1;
			y1 = y2;
			y2 = tmp;
		}

		snprintf(initial_buf, sizeof initial_buf, "%d,%d", y1, y2);

		initial = initial_buf;
	}

	char *const cmd = prompt(from_ch, initial);

	if(!cmd)
		goto cancel_cmd;

	prompt_finish(cmd);

cancel_cmd:
	free(cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x13c60
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x38, %eax
cmpl $0x0, %eax
je 0x6935
movq -0x48(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdi
callq 0x13750
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0x690f
movl -0x4c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
movl -0x4c(%rbp), %ecx
movl -0x50(%rbp), %r8d
movl $0x20, %esi
leaq 0xe93d(%rip), %rdx      # 0x15263
movb $0x0, %al
callq 0x41e0
leaq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rsi
movsbl %al, %edi
callq 0x10db0
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jne 0x6951
jmp 0x695a
movq -0x60(%rbp), %rdi
callq 0x8100
movq -0x60(%rbp), %rdi
callq 0x4080
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_filter
void k_filter(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	struct around_motion around = {
		.fn = filter,
		.filter = &a->filter
	};
	region_t r;

	if(around_motion(repeat, from_ch, /*always_linewise:*/true, &around, &r)){
		size_t n = r.end.y - r.begin.y;
		ui_status("filtered %lu line%s", n, n == 1 ? "" : "s");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x1b67(%rip), %rax      # 0x84f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movl $0x1, %edx
leaq -0x20(%rbp), %rcx
leaq -0x34(%rbp), %r8
callq 0x82c0
testb $0x1, %al
jne 0x69b3
jmp 0x69eb
movl -0x28(%rbp), %eax
subl -0x30(%rbp), %eax
cltq
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movq -0x40(%rbp), %rcx
leaq 0xf1a4(%rip), %rdx      # 0x15b72
leaq 0xee63(%rip), %rax      # 0x15838
cmpq $0x1, %rcx
cmoveq %rax, %rdx
leaq 0xe8ee(%rip), %rdi      # 0x152d2
movb $0x0, %al
callq 0x51a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_go_insert
void k_go_insert(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	window *win = windows_cur();
	buffer_t *buf = win->buf;

	*win->ui_pos = buf->prev_insert;
	ui_set_bufmode(UI_INSERT);

	ui_cur_changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x13c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x24(%rcx), %rcx
movq %rcx, (%rax)
movl $0x2, %edi
callq 0x4eb0
callq 0x5050
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_go_visual
void k_go_visual(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	window *win = windows_cur();
	buffer_t *buf = win->buf;

	ui_set_bufmode(buf->prev_visual.mode);

	*win->ui_pos = buf->prev_visual.npos;
	*window_uipos_alt(win) = buf->prev_visual.vpos;

	ui_cur_changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x13c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x20(%rax), %edi
callq 0x4eb0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x13750
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
callq 0x5050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: word_list
void word_list(const char *word, bool flag)
{
	buffer_t *b = buffers_cur();

	int hit = 0, n = 0;
	for(list_t *i = b->head; i; i = i->next, n++)
		if(tim_strstr(i->line, i->len_line, word))
			ui_printf("%d: %d %s", ++hit, n, i->line);

	ui_want_return();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0x13c60
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6c49
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rdx
callq 0x10880
cmpq $0x0, %rax
je 0x6c30
movl -0x1c(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movl -0x20(%rbp), %edx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
leaq 0xe6c2(%rip), %rdi      # 0x152eb
movb $0x0, %al
callq 0x5a80
jmp 0x6c32
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6bea
callq 0x5b90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: word_tag
void word_tag(const char *word, bool flag)
{
	struct ctag_result tag;

	if(buffers_cur()->modified){
		ui_err("buffer modified");
		return;
	}

	if(!ctag_search(word, &tag)){
		ui_err("couldn't find tag \"%s\"", word);
		return;
	}

	char *search = tag.line;

	{
		if(strncmp(search, "/^", 2))
			goto out_badtag;
		char *end = strchr(search, '\0');
		if(end - search < 5)
			goto out_badtag;
		if(!strcmp(end - 2, "$/"))
			end[-2] = '\0';
		search += 2;
	}

	const char *current = buffer_fname(buffers_cur());
	if(current && !strcmp(tag.fname, current)){
		/* we're the same file, don't need to replace/do modification check */
	}else if(!edit_common(tag.fname, false)){
		goto out;
	}

	{
		*windows_cur()->ui_pos = (point_t){ 0 };
		word_search(search, false);
	}

	ui_redraw();
	ui_cur_changed();

out:
	ctag_free(&tag);
	return;
out_badtag:
	ui_err("bad tag '%s'", tag.line);
	goto out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0x13c60
movq (%rax), %rax
testb $0x1, 0x39(%rax)
je 0x6c95
leaq 0xe66c(%rip), %rdi      # 0x152f5
movb $0x0, %al
callq 0x4f30
jmp 0x6dc7
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x14240
testb $0x1, %al
jne 0x6cbd
movq -0x8(%rbp), %rsi
leaq 0xe654(%rip), %rdi      # 0x15305
movb $0x0, %al
callq 0x4f30
jmp 0x6dc7
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0xe64c(%rip), %rsi      # 0x1531c
movl $0x2, %edx
callq 0x40c0
cmpl $0x0, %eax
je 0x6ce4
jmp 0x6db3
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x41c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
cmpq $0x5, %rax
jge 0x6d09
jmp 0x6db3
movq -0x30(%rbp), %rdi
addq $-0x2, %rdi
leaq 0xe607(%rip), %rsi      # 0x1531f
callq 0x42d0
cmpl $0x0, %eax
jne 0x6d2a
movq -0x30(%rbp), %rax
movb $0x0, -0x2(%rax)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
callq 0x13c60
movq (%rax), %rdi
callq 0xbb30
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x6d62
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x42d0
cmpl $0x0, %eax
jne 0x6d62
jmp 0x6d75
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x8ba0
testb $0x1, %al
jne 0x6d73
jmp 0x6da8
jmp 0x6d75
callq 0x13c60
movq 0x30(%rax), %rax
movl $0x0, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x6b40
callq 0x4fd0
callq 0x5050
leaq -0x20(%rbp), %rdi
callq 0x143d0
jmp 0x6dc7
movq -0x18(%rbp), %rsi
leaq 0xe564(%rip), %rdi      # 0x15322
movb $0x0, %al
callq 0x4f30
jmp 0x6da8
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: word_man
void word_man(const char *word, bool flag)
{
	/* if the word is all hexadecimal, try git show */
	bool hex = true;

	for(const char *p = word; *p; p++){
		if(!isxdigit(*p)){
			hex = false;
			break;
		}
	}

	char *cmd = join(" ",
			(char *[]){ hex ? "git show" : "man", (char *)word },
			2);

	shellout(cmd);

	free(cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movb $0x1, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6e2f
callq 0x4530
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
jne 0x6e1f
movb $0x0, -0xa(%rbp)
jmp 0x6e2f
jmp 0x6e21
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6df0
movb -0xa(%rbp), %dl
leaq 0xe4ff(%rip), %rax      # 0x15338
leaq 0xe4ef(%rip), %rcx      # 0x1532f
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rsi
leaq 0xe5ef(%rip), %rdi      # 0x1544d
movl $0x2, %edx
callq 0x6030
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10570
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: word_gofile
void word_gofile(const char *fname, const bool new_window)
{
	if(!new_window && buffers_modified_single(buffers_cur())){
		ui_err("buffer modified");
		return;
	}

	/* just expand ~ */
	bool free_expanded = true;
	char *expanded = expand_tilde(fname);
	if(!expanded){
		expanded = (char *)fname;
		free_expanded = false;
	}

	/* race condition testing existence, then opening,
	 * but this isn't race-important code / the race condition can't cause
	 * unexpected behaviour */
	if(access(expanded, F_OK) && errno == ENOENT){
		attempt_relative_fname(&expanded, &free_expanded);
	}

	if(new_window){
		buffer_t *new;
		const char *err;
		buffer_new_fname(&new, expanded, &err);

		if(err)
			ui_err("%s: %s", expanded, err);

		/* open a window there anyway */
		window *wnew = window_new(new);

		window_add_neighbour(windows_cur(), neighbour_up, wnew);
		buffer_release(new);

		windows_set_cur(wnew);

	}else{
		edit_common(expanded, false);
	}

	ui_redraw();
	ui_cur_changed();

	if(free_expanded)
		free(expanded);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x6f00
callq 0x13c60
movq (%rax), %rdi
callq 0x12ce0
testb $0x1, %al
jne 0x6eed
jmp 0x6f00
leaq 0xe401(%rip), %rdi      # 0x152f5
movb $0x0, %al
callq 0x4f30
jmp 0x6fde
movb $0x1, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10c70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6f24
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0xa(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x4420
cmpl $0x0, %eax
je 0x6f4b
callq 0x40a0
cmpl $0x2, (%rax)
jne 0x6f4b
leaq -0x18(%rbp), %rdi
leaq -0xa(%rbp), %rsi
callq 0x86b0
testb $0x1, -0x9(%rbp)
je 0x6fba
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0xb970
cmpq $0x0, -0x28(%rbp)
je 0x6f7f
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0xe69c(%rip), %rdi      # 0x15614
movb $0x0, %al
callq 0x4f30
movq -0x20(%rbp), %rdi
callq 0x13620
movq %rax, -0x30(%rbp)
callq 0x13c60
movq %rax, %rdi
movq -0x30(%rbp), %rdx
xorl %esi, %esi
callq 0x133a0
movq -0x20(%rbp), %rdi
leaq 0x4766(%rip), %rsi      # 0xb710
callq 0x12040
movq -0x30(%rbp), %rdi
callq 0x13ca0
jmp 0x6fc5
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x8ba0
callq 0x4fd0
callq 0x5050
testb $0x1, -0xa(%rbp)
je 0x6fde
movq -0x18(%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: k_go_tab
void k_go_tab(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	repeat = DEFAULT_REPEAT(repeat);

	tab *t = tabs_cur();
	unsigned nforward;

	if(a->pos.x > 0){
		nforward = repeat;
	}else{
		unsigned ntabs = tabs_count();
		unsigned nback = -a->pos.x;

		/* 5 tabs, go 2 back means go 5-2 forwards, i.e. 3 */
		nforward = repeat * (ntabs - nback);
	}

	while(nforward --> 0)
		t = tab_next(t);

	tabs_set_cur(t);

	ui_redraw();
	ui_cur_changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x7010
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x701a
movl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x701a
movl -0x28(%rbp), %eax
movl %eax, -0xc(%rbp)
callq 0x13ec0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x703a
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x705c
callq 0x13f40
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl -0x20(%rbp), %ecx
subl -0x24(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x705e
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
jbe 0x707d
movq -0x18(%rbp), %rdi
callq 0x13e00
movq %rax, -0x18(%rbp)
jmp 0x705e
movq -0x18(%rbp), %rdi
callq 0x13ed0
callq 0x4fd0
callq 0x5050
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_scroll
void k_scroll(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	window *win = windows_cur();

	if(a->pos.x){
		/* y: 0=mid, -1=top, 1=bot */
		int h = 0;
		switch(a->pos.y){
			case 0:
				h = win->screen_coord.h / 2;
				break;
			case -1:
				break;
			case 1:
				h = win->screen_coord.h - 1;
				break;
		}
		win->ui_start.y = win->ui_pos->y - h;
	}else{
		win->ui_start.y += a->pos.y;
	}

	if(win->ui_start.y < 0)
		win->ui_start.y = 0;

	if(win->ui_pos->y < win->ui_start.y)
		win->ui_pos->y = win->ui_start.y;
	else if(win->ui_pos->y >= win->ui_start.y + win->screen_coord.h)
		win->ui_pos->y = win->ui_start.y + win->screen_coord.h - 1;

	ui_redraw();
	ui_cur_changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x13c60
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7159
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
subl $-0x1, %eax
je 0x7133
jmp 0x710c
movl -0x20(%rbp), %eax
testl %eax, %eax
je 0x711f
jmp 0x7115
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x7135
jmp 0x7142
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
jmp 0x7142
jmp 0x7142
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %ecx
subl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x716a
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jge 0x717f
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x71a7
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl %ecx, 0x4(%rax)
jmp 0x71e2
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
movq -0x18(%rbp), %rdx
addl 0x1c(%rdx), %ecx
cmpl %ecx, %eax
jl 0x71e0
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
addl 0x1c(%rax), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl %ecx, 0x4(%rax)
jmp 0x71e2
callq 0x4fd0
callq 0x5050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_jumpscroll
void k_jumpscroll(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	window *w = windows_cur();
	const int height = w->screen_coord.h + 1;

	int inc = 0;

	switch(abs(a->i)){
		case 2:  inc = height;     break;
		case 1:  inc = height / 2; break;
	}

	if(a->i < 0)
		inc = -inc;

	w->ui_pos->y += inc;
	w->ui_start.y += inc;

	start_of_line(NULL, w);

	ui_cur_changed();
	ui_redraw();
}

// 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), %rax
movl 0x1c(%rax), %eax
incl %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x7257
jmp 0x7245
movl -0x24(%rbp), %eax
subl $0x2, %eax
jne 0x7265
jmp 0x724f
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x7265
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x7276
xorl %eax, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xed10
callq 0x5050
callq 0x4fd0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_winsel
void k_winsel(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	enum neighbour dir = pos2dir(&a->pos);

	window *const curwin = windows_cur();
	window *found = NULL;

	switch(dir){
		case neighbour_up:
			found = curwin->neighbours.above;
			break;

		case neighbour_down:
			found = curwin->neighbours.below;
			break;

		case neighbour_left:
		case neighbour_right:
			for(found = curwin; found->neighbours.above; found = found->neighbours.above);
			found = (dir == neighbour_left ? found->neighbours.left : found->neighbours.right);
			if(!found)
				break;

			const int to_match = curwin->screen_coord.y + curwin->ui_pos->y - curwin->ui_start.y;

			while(found->neighbours.below)
			{
				if(found->screen_coord.y <= to_match
				&& to_match <= found->screen_coord.y + found->screen_coord.h)
				{
					break;
				}
				found = found->neighbours.below;
			}
	}

	if(found && found != curwin){
		windows_set_cur(found);
		ui_redraw();
		ui_cur_changed();
	}else{
		ui_err("no buffers in that direction");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8180
movl %eax, -0x14(%rbp)
callq 0x13c60
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
testl %eax, %eax
je 0x7315
jmp 0x72fb
movl -0x30(%rbp), %eax
subl $0x1, %eax
je 0x7326
jmp 0x7305
movl -0x30(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x7337
jmp 0x73e5
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x73e5
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x73e5
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x735a
jmp 0x734c
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x733f
cmpl $0x2, -0x14(%rbp)
jne 0x736e
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x737a
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x738b
jmp 0x73e5
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x20(%rbp), %rcx
movq 0x30(%rcx), %rcx
addl 0x4(%rcx), %eax
movq -0x20(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x73e3
movq -0x28(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x2c(%rbp), %eax
jg 0x73d5
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
movl 0x14(%rcx), %ecx
movq -0x28(%rbp), %rdx
addl 0x1c(%rdx), %ecx
cmpl %ecx, %eax
jg 0x73d5
jmp 0x73e3
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x73a7
jmp 0x73e5
cmpq $0x0, -0x28(%rbp)
je 0x740b
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x740b
movq -0x28(%rbp), %rdi
callq 0x13ca0
callq 0x4fd0
callq 0x5050
jmp 0x7419
leaq 0xde57(%rip), %rdi      # 0x15269
movb $0x0, %al
callq 0x4f30
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_show
void k_show(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	window *win = windows_cur();
	buffer_t *buf = win->buf;
	(void)a;
	ui_status("%s%s%s, %sx=%d y=%d eol=%c",
			buf->fname ? "\"" : "",
			buf->fname ? buf->fname : "<no name>",
			buf->fname ? "\"" : "",
			buf->modified ? "[+] " : "",
			win->ui_pos->x, win->ui_pos->y,
			"ny"[buf->eol]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x13c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdx
leaq 0xe1d3(%rip), %rax      # 0x15838
leaq 0xe020(%rip), %rcx      # 0x1568c
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x7691
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x769e
leaq 0xdc09(%rip), %rax      # 0x152a1
movq %rax, -0x30(%rbp)
jmp 0x769e
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
leaq 0xe183(%rip), %rcx      # 0x15838
leaq 0xdfd0(%rip), %rax      # 0x1568c
cmpq $0x0, %rdi
cmovneq %rax, %rcx
movq -0x20(%rbp), %rax
movb 0x39(%rax), %dil
leaq 0xe165(%rip), %r8       # 0x15838
leaq 0xdbd1(%rip), %rax      # 0x152ab
testb $0x1, %dil
cmovneq %rax, %r8
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %r9d
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %r10d
movq -0x20(%rbp), %rax
movb 0x38(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, %edi
leaq 0xdba2(%rip), %rax      # 0x152b0
movsbl (%rax,%rdi), %eax
leaq 0xdb6d(%rip), %rdi      # 0x15286
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x51a0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_ins_colcopy
void k_ins_colcopy(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	window *win = windows_cur();

	list_t *line = window_current_line(win, false);
	if(!line)
		return;
	line = a->i > 0 ? line->next : line->prev;
	if(!line)
		return;

	if((unsigned)win->ui_pos->x >= line->len_line)
		return;

	window_inschar(win, line->line[win->ui_pos->x]);

	ui_redraw();
	ui_cur_changed();
}

// 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)
jne 0x7763
jmp 0x77d6
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x777a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x7786
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7797
jmp 0x77d6
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x77ad
jmp 0x77d6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %esi
callq 0x13a20
callq 0x4fd0
callq 0x5050
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/keys.c
// Function: k_normal1
void k_normal1(const keyarg_u *a, unsigned repeat, const int from_ch)
{
	window *win = windows_cur();

	const enum buf_mode save = win->ui_mode;
	win->ui_mode = UI_NORMAL;

	ui_normal_1(&repeat, IO_MAPRAW | bufmode_to_iomap(win->ui_mode));

	win->ui_mode = save;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x13c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %edi
callq 0x112d0
movl %eax, %esi
orl $0x10, %esi
leaq -0xc(%rbp), %rdi
callq 0x53f0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)