LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ToniWestbrook[P]paladin/bwamem_pair.c
// Function: cal_sub
static int cal_sub(const mem_opt_t *opt, mem_alnreg_v *r)
{
	int j;
	for (j = 1; j < r->n; ++j) { // choose unique alignment
		int b_max = r->a[j].qb > r->a[0].qb? r->a[j].qb : r->a[0].qb;
		int e_min = r->a[j].qe < r->a[0].qe? r->a[j].qe : r->a[0].qe;
		if (e_min > b_max) { // have overlap
			int min_l = r->a[j].qe - r->a[j].qb < r->a[0].qe - r->a[0].qb? r->a[j].qe - r->a[j].qb : r->a[0].qe - r->a[0].qb;
			if (e_min - b_max >= min_l * opt->mask_level) break; // significant overlap
		}
	}
	return j < r->n? r->a[j].score : opt->min_seed_len * opt->a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %rax
cmpq $0x2, %rax
setae %cl
jb 0x1fbcf
movq 0x18(%rsi), %rdx
movl 0x10(%rdx), %r8d
movl 0x14(%rdx), %r9d
movl %r9d, %r11d
subl %r8d, %r11d
movl $0x1, %ebx
subq %rax, %rbx
movl $0x2, %r14d
xorl %r10d, %r10d
movl 0x70(%rdx,%r10), %r15d
movl 0x74(%rdx,%r10), %ebp
cmpl %r8d, %r15d
cmovlel %r8d, %r15d
cmpl %r9d, %ebp
cmovgel %r9d, %ebp
subl %r15d, %ebp
jle 0x1fba3
movl 0x74(%rdx,%r10), %r15d
subl 0x70(%rdx,%r10), %r15d
cmpl %r11d, %r15d
cmovgel %r11d, %r15d
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %r15d, %xmm1
mulss 0x9c(%rdi), %xmm1
ucomiss %xmm1, %xmm0
jae 0x1fbbf
cmpq %r14, %rax
seta %cl
addq $0x60, %r10
leaq (%rbx,%r14), %r15
incq %r15
incq %r14
cmpq $0x2, %r15
jne 0x1fb59
jmp 0x1fbcf
testb $0x1, %cl
je 0x1fbcf
movq 0x18(%rsi), %rax
movl 0x7c(%rax,%r10), %eax
jmp 0x1fbd5
movl (%rdi), %eax
imull 0x78(%rdi), %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ToniWestbrook[P]paladin/bwamem_extra.c
// Function: smem_itr_init
smem_i *smem_itr_init(const bwt_t *bwt)
{
	smem_i *itr;
	itr = calloc(1, sizeof(smem_i));
	itr->bwt = bwt;
	itr->tmpvec[0] = calloc(1, sizeof(bwtintv_v));
	itr->tmpvec[1] = calloc(1, sizeof(bwtintv_v));
	itr->matches   = calloc(1, sizeof(bwtintv_v));
	itr->sub       = calloc(1, sizeof(bwtintv_v));
	itr->min_intv = 1;
	itr->max_len  = INT_MAX;
	itr->max_intv = 0;
	return itr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x7dee(%rip), %r14      # 0x29518
leaq 0x7df6(%rip), %rbx      # 0x29527
movl $0x1, %edi
movl $0x48, %esi
movq %r14, %rdx
movl $0x19, %ecx
movq %rbx, %r8
callq 0x22cb4
movq %rax, %r15
movq %r12, (%rax)
movl $0x1, %edi
movl $0x18, %esi
movq %r14, %rdx
movl $0x1b, %ecx
movq %rbx, %r8
callq 0x22cb4
movq %rax, 0x38(%r15)
movl $0x1, %edi
movl $0x18, %esi
movq %r14, %rdx
movl $0x1c, %ecx
movq %rbx, %r8
callq 0x22cb4
movq %rax, 0x40(%r15)
movl $0x1, %edi
movl $0x18, %esi
movq %r14, %rdx
movl $0x1d, %ecx
movq %rbx, %r8
callq 0x22cb4
movq %rax, 0x28(%r15)
movl $0x1, %edi
movl $0x18, %esi
movq %r14, %rdx
movl $0x1e, %ecx
movq %rbx, %r8
callq 0x22cb4
movq %rax, 0x30(%r15)
movabsq $0x7fffffff00000001, %rax # imm = 0x7FFFFFFF00000001
movq %rax, 0x18(%r15)
movq $0x0, 0x20(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ToniWestbrook[P]paladin/bwamem_extra.c
// Function: smem_itr_destroy
void smem_itr_destroy(smem_i *itr)
{
	free(itr->tmpvec[0]->a); free(itr->tmpvec[0]);
	free(itr->tmpvec[1]->a); free(itr->tmpvec[1]);
	free(itr->matches->a);   free(itr->matches);
	free(itr->sub->a);       free(itr->sub);
	free(itr);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x10(%rax), %rdi
callq 0x3390
movq 0x38(%rbx), %rdi
callq 0x3390
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x3390
movq 0x40(%rbx), %rdi
callq 0x3390
movq 0x28(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x3390
movq 0x28(%rbx), %rdi
callq 0x3390
movq 0x30(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x3390
movq 0x30(%rbx), %rdi
callq 0x3390
movq %rbx, %rdi
popq %rbx
jmp 0x3390
// File: /workspace/github_c_makefile_star2_O1/ToniWestbrook[P]paladin/bwamem_extra.c
// Function: smem_next
const bwtintv_v *smem_next(smem_i *itr)
{
	int ori_start;
	itr->tmpvec[0]->n = itr->tmpvec[1]->n = itr->matches->n = itr->sub->n = 0;
	if (itr->start >= itr->len || itr->start < 0) return 0;
	while (itr->start < itr->len && itr->query[itr->start] > 3) ++itr->start; // skip ambiguous bases
	if (itr->start == itr->len) return 0;
	ori_start = itr->start;
	itr->start = bwt_smem1a(itr->bwt, itr->len, itr->query, ori_start, itr->min_intv, itr->max_intv, itr->matches, itr->tmpvec); // search for SMEM
	return itr->matches;
}

// Assembly:
pushq %rbx
movq 0x30(%rdi), %rcx
xorl %eax, %eax
movq %rax, (%rcx)
movq 0x28(%rdi), %r10
movq %rax, (%r10)
movq 0x40(%rdi), %rcx
movq %rax, (%rcx)
movq 0x38(%rdi), %rcx
movq %rax, (%rcx)
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %esi
cmpl %esi, %ecx
setge %dl
testl %ecx, %ecx
sets %cl
orb %dl, %cl
jne 0x218f2
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
cmpl %esi, %ecx
jge 0x218c4
movslq %ecx, %rax
addq 0x8(%rbx), %rax
cmpb $0x4, (%rax)
jb 0x218c4
incl %ecx
movl %ecx, 0x10(%rbx)
incq %rax
cmpl %ecx, %esi
jne 0x218b1
movl %esi, %ecx
cmpl %esi, %ecx
jne 0x218cc
xorl %eax, %eax
jmp 0x218f2
leaq 0x38(%rbx), %rax
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movl 0x18(%rbx), %r8d
movq 0x20(%rbx), %r9
pushq %rax
pushq %r10
callq 0xf47b
addq $0x10, %rsp
movl %eax, 0x10(%rbx)
movq 0x28(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ToniWestbrook[P]paladin/bwamem_extra.c
// Function: mem_align1
mem_alnreg_v mem_align1(const mem_opt_t *opt, const bwt_t *bwt, const bntseq_t *bns, const uint8_t *pac, int l_seq, const char *seq_)
{ // the difference from mem_align1_core() is that this routine: 1) calls mem_mark_primary_se(); 2) does not modify the input sequence
	extern mem_alnreg_v mem_align1_core(const mem_opt_t *opt, const bwt_t *bwt, const bntseq_t *bns, const uint8_t *pac, int l_seq, char *seq, void *buf);
	extern void mem_mark_primary_se(const mem_opt_t *opt, int n, mem_alnreg_t *a, int64_t id);
	mem_alnreg_v ar;
	char *seq;
	seq = malloc(l_seq);
	memcpy(seq, seq_, l_seq); // makes a copy of seq_
	ar = mem_align1_core(opt, bwt, bns, pac, l_seq, seq, 0);
	mem_mark_primary_se(opt, ar.n, ar.a, lrand48());
	free(seq);
	return ar;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movslq %r9d, %r12
leaq 0x7bff(%rip), %rsi      # 0x29518
leaq 0x7c15(%rip), %rcx      # 0x29535
movq %r12, %rdi
movl $0x52, %edx
callq 0x22d2b
movq %rax, %r15
movq %rax, %rdi
movq 0x40(%rsp), %rsi
movq %r12, %rdx
callq 0x3260
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq (%rsp), %r8
movl %r12d, %r9d
pushq $0x0
pushq %r15
callq 0x1e8ac
addq $0x10, %rsp
movl (%rbx), %ebp
movq 0x18(%rbx), %r12
callq 0x3200
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %rax, %rcx
callq 0x1a040
movq %r15, %rdi
callq 0x3390
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ToniWestbrook[P]paladin/malloc_wrap.c
// Function: wrap_calloc
void *wrap_calloc(size_t nmemb, size_t size,
				  const char *file, unsigned int line, const char *func) {
	void *p = calloc(nmemb, size);
	if (NULL == p) {
		fprintf(stderr,
				"[%s] Failed to allocate %zd bytes at %s line %u: %s\n",
				func, nmemb * size, file, line, strerror(errno));
		exit(EXIT_FAILURE);
	}
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
callq 0x31b0
testq %rax, %rax
je 0x22ce6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd2e3(%rip), %rax      # 0x2ffd0
movq (%rax), %rbp
imulq %r13, %r12
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, (%rsp)
leaq 0x68b9(%rip), %rsi      # 0x295c4
movq %rbp, %rdi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq 0x3500
movl $0x1, %edi
callq 0x33c0
// File: /workspace/github_c_makefile_star2_O1/ToniWestbrook[P]paladin/malloc_wrap.c
// Function: wrap_malloc
void *wrap_malloc(size_t size,
				  const char *file, unsigned int line, const char *func) {
	void *p = malloc(size);
	if (NULL == p) {
		fprintf(stderr,
				"[%s] Failed to allocate %zd bytes at %s line %u: %s\n",
				func, size, file, line, strerror(errno));
		exit(EXIT_FAILURE);
	}
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
callq 0x3470
testq %rax, %rax
je 0x22d54
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x43de
// File: /workspace/github_c_makefile_star2_O1/ToniWestbrook[P]paladin/malloc_wrap.c
// Function: wrap_realloc
void *wrap_realloc(void *ptr, size_t size,
				   const char *file, unsigned int line, const char *func) {
	void *p = realloc(ptr, size);
	if (NULL == p) {
		fprintf(stderr,
				"[%s] Failed to allocate %zd bytes at %s line %u: %s\n",
				func, size, file, line, strerror(errno));
		exit(EXIT_FAILURE);
	}
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
callq 0x3610
testq %rax, %rax
je 0x22d8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x4435
// File: /workspace/github_c_makefile_star2_O1/ToniWestbrook[P]paladin/malloc_wrap.c
// Function: wrap_strdup
char *wrap_strdup(const char *s,
				  const char *file, unsigned int line, const char *func) {
	char *p = strdup(s);
	if (NULL == p) {
		fprintf(stderr,
				"[%s] Failed to allocate %zd bytes at %s line %u: %s\n",
				func, strlen(s), file, line, strerror(errno));
		exit(EXIT_FAILURE);
	}
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
callq 0x3710
testq %rax, %rax
je 0x22dc6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x448c
nop
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: new_buffer
buffer_t* new_buffer()
{
	buffer_t *bp = (buffer_t *)malloc(sizeof(buffer_t));
	assert(bp != NULL);
	bp->b_point = 0;
	bp->b_mark = NOMARK;
	bp->b_page = 0;
	bp->b_epage = 0;
	bp->b_flags = 0;
	bp->b_buf = NULL;
	bp->b_ebuf = NULL;
	bp->b_gap = NULL;
	bp->b_egap = NULL;
	bp->b_fname[0] = '\0';
	bp->w_top = 0;	
	bp->w_rows = LINES - 2;
	return bp;
}

// Assembly:
pushq %rax
movl $0x150, %edi            # imm = 0x150
callq 0x21f0
movq $0x0, 0x8(%rax)
movq $-0x1, (%rax)
xorl %ecx, %ecx
movb %cl, 0x14d(%rax)
movb %cl, 0x4c(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movb %cl, 0x40(%rax)
movq 0xab5e(%rip), %rcx      # 0xcfe8
movb (%rcx), %cl
addb $-0x2, %cl
movb %cl, 0x41(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: fatal
void fatal(char *msg)
{
	noraw();
	endwin();
	printf("\n%s %s:\n%s\n", E_NAME, E_VERSION, msg);
	exit(1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x21a0
callq 0x22e0
leaq 0x5b5b(%rip), %rdi      # 0x8004
leaq 0x5b60(%rip), %rsi      # 0x8010
leaq 0x5b5e(%rip), %rdx      # 0x8015
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2110
movl $0x1, %edi
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: msg
int msg(char *msg, ...)
{
	va_list args;
	va_start(args, msg);
	(void)vsprintf(msgline, msg, args);
	va_end(args);
	msgflag = TRUE;
	return FALSE;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2529
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0xb3a0(%rip), %rdi      # 0xd8f0
movq %r10, %rsi
callq 0x2240
movl $0x1, 0xb58e(%rip)      # 0xdaf0
xorl %eax, %eax
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: growgap
int growgap(buffer_t *bp, point_t n)
{
	char_t *new;
	point_t buflen, newlen, xgap, xegap;
		
	assert(bp->b_buf <= bp->b_gap);
	assert(bp->b_gap <= bp->b_egap);
	assert(bp->b_egap <= bp->b_ebuf);

	xgap = bp->b_gap - bp->b_buf;
	xegap = bp->b_egap - bp->b_buf;
	buflen = bp->b_ebuf - bp->b_buf;
    
	/* reduce number of reallocs by growing by a minimum amount */
	n = (n < MIN_GAP_EXPAND ? MIN_GAP_EXPAND : n);
	newlen = buflen + n * sizeof (char_t);

	if (buflen == 0) {
		if (newlen < 0 || MAX_SIZE_T < newlen) fatal("Failed to allocate required memory.\n");
		new = (char_t*) malloc((size_t) newlen);
		if (new == NULL) fatal("Failed to allocate required memory.\n");
	} else {
		if (newlen < 0 || MAX_SIZE_T < newlen) return msg("Failed to allocate required memory");
		new = (char_t*) realloc(bp->b_buf, (size_t) newlen);
		if (new == NULL) return msg("Failed to allocate required memory");
	}

	/* Relocate pointers in new buffer and append the new
	 * extension to the end of the gap.
	 */
	bp->b_buf = new;
	bp->b_gap = bp->b_buf + xgap;      
	bp->b_ebuf = bp->b_buf + buflen;
	bp->b_egap = bp->b_buf + newlen;
	while (xegap < buflen--)
		*--bp->b_egap = *--bp->b_ebuf;
	bp->b_ebuf = bp->b_buf + newlen;

	assert(bp->b_buf < bp->b_ebuf);          /* Buffer must exist. */
	assert(bp->b_buf <= bp->b_gap);
	assert(bp->b_gap < bp->b_egap);          /* Gap must grow only. */
	assert(bp->b_egap <= bp->b_ebuf);
	return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rbp
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
movq 0x38(%rdi), %r13
subq %r15, %r12
cmpq $0x201, %rsi            # imm = 0x201
movl $0x200, %r14d           # imm = 0x200
cmovgeq %rsi, %r14
addq %r12, %r14
testq %r12, %r12
je 0x2613
testq %r14, %r14
js 0x2601
movq %r15, %rdi
movq %r14, %rsi
callq 0x2220
testq %rax, %rax
jne 0x2620
leaq 0x5a37(%rip), %rdi      # 0x803f
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x24cb
jmp 0x2675
movq %r14, %rdi
callq 0x21f0
testq %rax, %rax
je 0x2686
subq %r15, %rbp
subq %r15, %r13
movq %rax, 0x20(%rbx)
addq %rax, %rbp
movq %rbp, 0x30(%rbx)
leaq (%rax,%r12), %rcx
movq %rcx, 0x28(%rbx)
addq %r14, %rax
movq %rax, 0x38(%rbx)
cmpq %r12, %r13
jge 0x2668
decq %r12
movq 0x28(%rbx), %rax
movq 0x38(%rbx), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x28(%rbx)
movb -0x1(%rax), %al
leaq -0x1(%rcx), %rdx
movq %rdx, 0x38(%rbx)
movb %al, -0x1(%rcx)
jmp 0x2640
addq 0x20(%rbx), %r14
movq %r14, 0x28(%rbx)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x598d(%rip), %rdi      # 0x801a
callq 0x2494
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: movegap
point_t movegap(buffer_t *bp, point_t offset)
{
	char_t *p = ptr(bp, offset);
	while (p < bp->b_gap)
		*--bp->b_egap = *--bp->b_gap;
	while (bp->b_egap < p)
		*bp->b_gap++ = *bp->b_egap++;
	assert(bp->b_gap <= bp->b_egap);
	assert(bp->b_buf <= bp->b_gap);
	assert(bp->b_egap <= bp->b_ebuf);
	return (pos(bp, bp->b_egap));
}

// Assembly:
movq 0x20(%rdi), %rax
testq %rsi, %rsi
js 0x26d1
addq %rsi, %rax
movq 0x30(%rdi), %rdx
cmpq %rdx, %rax
jae 0x26ab
xorl %ecx, %ecx
jmp 0x26b2
movq 0x38(%rdi), %rcx
subq %rdx, %rcx
addq %rcx, %rax
jmp 0x26d1
leaq -0x1(%rcx), %rdx
movq %rdx, 0x30(%rdi)
movb -0x1(%rcx), %cl
movq 0x38(%rdi), %rdx
leaq -0x1(%rdx), %rsi
movq %rsi, 0x38(%rdi)
movb %cl, -0x1(%rdx)
movq 0x30(%rdi), %rcx
cmpq %rcx, %rax
jb 0x26b7
jmp 0x26f4
leaq 0x1(%rcx), %rdx
movq %rdx, 0x38(%rdi)
movb (%rcx), %cl
movq 0x30(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x30(%rdi)
movb %cl, (%rdx)
movq 0x38(%rdi), %rcx
cmpq %rax, %rcx
jb 0x26dc
movq 0x30(%rdi), %rax
subq 0x20(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: save_buffer
void save_buffer()
{
	FILE *fp;
	point_t length;

	fp = fopen(curbp->b_fname, "w");
	if (fp == NULL) msg("Failed to open file \"%s\".", curbp->b_fname);
	(void) movegap(curbp, (point_t) 0);
	length = (point_t) (curbp->b_ebuf - curbp->b_egap);
	if (fwrite(curbp->b_egap, sizeof (char), (size_t) length, fp) != length) 
		msg("Failed to write file \"%s\".", curbp->b_fname);
	fclose(fp);
	curbp->b_flags &= ~B_MODIFIED;
	msg("File \"%s\" %ld bytes saved.", curbp->b_fname, pos(curbp, curbp->b_ebuf));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xb3e7(%rip), %rdi      # 0xdaf8
addq $0x4c, %rdi
leaq 0x5bd2(%rip), %rsi      # 0x82ee
callq 0x2270
movq %rax, %rbx
testq %rax, %rax
jne 0x2742
movq 0xb3c8(%rip), %rsi      # 0xdaf8
addq $0x4c, %rsi
leaq 0x5927(%rip), %rdi      # 0x8062
xorl %eax, %eax
callq 0x24cb
movq 0xb3af(%rip), %rdi      # 0xdaf8
xorl %esi, %esi
callq 0x2692
movq 0xb3a1(%rip), %rax      # 0xdaf8
movq 0x28(%rax), %r14
movq 0x38(%rax), %rdi
subq %rdi, %r14
movl $0x1, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x22d0
cmpq %r14, %rax
je 0x2790
movq 0xb37a(%rip), %rsi      # 0xdaf8
addq $0x4c, %rsi
leaq 0x58f3(%rip), %rdi      # 0x807c
xorl %eax, %eax
callq 0x24cb
movq %rbx, %rdi
callq 0x20d0
movq 0xb359(%rip), %rsi      # 0xdaf8
andb $-0x2, 0x14d(%rsi)
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rdx
movq 0x38(%rsi), %rdi
cmpq %rdx, %rdi
jbe 0x27bb
xorl %ecx, %ecx
jmp 0x27c2
movq 0x30(%rsi), %rcx
subq %rdi, %rcx
addq $0x4c, %rsi
subq %rax, %rdx
addq %rcx, %rdx
leaq 0x58c4(%rip), %rdi      # 0x8097
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24cb
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: insert_file
int insert_file(char *fn, int modflag)
{
	FILE *fp;
	size_t len;
	struct stat sb;

	if (stat(fn, &sb) < 0) return msg("Failed to find file \"%s\".", fn);
	if (MAX_SIZE_T < sb.st_size) msg("File \"%s\" is too big to load.", fn);

	if (curbp->b_egap - curbp->b_gap < sb.st_size * sizeof (char_t) && !growgap(curbp, sb.st_size))
		return (FALSE);
	if ((fp = fopen(fn, "r")) == NULL) return msg("Failed to open file \"%s\".", fn);

	curbp->b_point = movegap(curbp, curbp->b_point);
	curbp->b_gap += len = fread(curbp->b_gap, sizeof (char), (size_t) sb.st_size, fp);

	if (fclose(fp) != 0) return msg("Failed to close file \"%s\".", fn);
	curbp->b_flags &= (modflag ? B_MODIFIED : ~B_MODIFIED);
	msg("File \"%s\" %ld bytes read.", fn, len);
	return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x21c0
testl %eax, %eax
js 0x2897
movq 0xb2ec(%rip), %rdi      # 0xdaf8
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
movq 0x38(%rsp), %r14
cmpq %r14, %rax
jae 0x282e
movq %r14, %rsi
callq 0x25b2
testl %eax, %eax
je 0x28f5
leaq 0x5e7a(%rip), %rsi      # 0x86af
movq %rbx, %rdi
callq 0x2270
testq %rax, %rax
je 0x28a0
movq %rax, %r15
movq 0xb2ac(%rip), %rdi      # 0xdaf8
movq 0x8(%rdi), %rsi
callq 0x2692
movq 0xb29c(%rip), %rcx      # 0xdaf8
movq %rax, 0x8(%rcx)
movq 0x30(%rcx), %rdi
movl $0x1, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2080
movq %rax, %r14
movq 0xb27a(%rip), %rax      # 0xdaf8
addq %r14, 0x30(%rax)
movq %r15, %rdi
callq 0x20d0
testl %eax, %eax
je 0x28c3
leaq 0x5837(%rip), %rdi      # 0x80cc
jmp 0x28a7
leaq 0x5814(%rip), %rdi      # 0x80b2
jmp 0x28a7
leaq 0x57bb(%rip), %rdi      # 0x8062
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x24cb
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
movl $0xfe, %eax
movl $0x1, %ebp
cmovnel %ebp, %eax
movq 0xb21f(%rip), %rcx      # 0xdaf8
andb %al, 0x14d(%rcx)
leaq 0x5801(%rip), %rdi      # 0x80e7
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x24cb
jmp 0x28b3
xorl %ebp, %ebp
jmp 0x28b3
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: get_key
char_t *get_key(keymap_t *keys, keymap_t **key_return)
{
	keymap_t *k;
	int submatch;
	static char_t buffer[K_BUFFER_LENGTH];
	static char_t *record = buffer;

	*key_return = NULL;

	/* if recorded bytes remain, return next recorded byte. */
	if (*record != '\0') {
		*key_return = NULL;
		return record++;
	}
	/* reset record buffer. */
	record = buffer;

	do {
		assert(K_BUFFER_LENGTH > record - buffer);
		/* read and record one byte. */
		*record++ = (unsigned)getch();
		*record = '\0';

		/* if recorded bytes match any multi-byte sequence... */
		for (k = keys, submatch = 0; k != NULL; k = k->k_next) {
			char_t *p, *q;

			if (k->k_func == NULL) continue;
			assert(k->k_bytes != NULL);

			for (p = buffer, q = (char_t *)k->k_bytes; *p == *q; ++p, ++q) {
			        /* an exact match */
				if (*q == '\0' && *p == '\0') {
	    				record = buffer;
					*record = '\0';
					*key_return = k;
					return record; /* empty string */
				}
			}
			/* record bytes match part of a command sequence */
			if (*p == '\0' && *q != '\0') {
				submatch = 1;
			}
		}
	} while (submatch);
	/* nothing matched, return recorded bytes. */
	record = buffer;
	return (record++);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq $0x0, (%rsi)
movq 0xa8ad(%rip), %rbx      # 0xd1c0
cmpb $0x0, (%rbx)
je 0x292f
movq $0x0, (%r14)
leaq 0x1(%rbx), %r12
movq %r12, 0xa896(%rip)      # 0xd1c0
jmp 0x29ff
movq %rdi, %r15
leaq 0xb1c7(%rip), %rbx      # 0xdb00
movq %rbx, 0xa880(%rip)      # 0xd1c0
movq 0xa689(%rip), %r13      # 0xcfd0
leaq 0xb1b3(%rip), %r12      # 0xdb01
movq (%r13), %rdi
callq 0x20c0
movq 0xa862(%rip), %rcx      # 0xd1c0
leaq 0x1(%rcx), %rdx
movq %rdx, 0xa857(%rip)      # 0xd1c0
movb %al, (%rcx)
movb $0x0, 0x1(%rcx)
testq %r15, %r15
je 0x2923
xorl %eax, %eax
movq %r15, %rcx
cmpq $0x0, 0x40(%rcx)
je 0x29bc
movb 0xb17a(%rip), %dl       # 0xdb00
movb 0xd(%rcx), %dil
cmpb %dil, %dl
jne 0x29a8
movl $0xe, %esi
testb %dl, %dl
je 0x29c3
movb -0xd(%rsi,%rbx), %dl
movb (%rcx,%rsi), %dil
incq %rsi
cmpb %dil, %dl
je 0x2994
testb %dil, %dil
movl $0x1, %esi
cmovel %eax, %esi
testb %dl, %dl
cmovel %esi, %eax
xorl %edx, %edx
jmp 0x29d9
movl $0x6, %edx
jmp 0x29d9
movq %rbx, 0xa7f6(%rip)      # 0xd1c0
movb $0x0, 0xb12f(%rip)      # 0xdb00
movq %rcx, (%r14)
movl $0x1, %edx
cmpl $0x6, %edx
je 0x29e2
testl %edx, %edx
jne 0x29f8
movq 0x48(%rcx), %rcx
testq %rcx, %rcx
jne 0x2979
testl %eax, %eax
jne 0x294e
jmp 0x2923
leaq 0xb101(%rip), %rbx      # 0xdb00
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: lnstart
point_t lnstart(buffer_t *bp, register point_t off)
{
	register char_t *p;
	do
		p = ptr(bp, --off);
	while (bp->b_buf < p && *p != '\n');
	return (bp->b_buf < p ? ++off : 0);
}

// Assembly:
movq 0x20(%rdi), %rcx
decq %rsi
xorl %eax, %eax
leaq 0x1(%rsi), %rdx
testq %rdx, %rdx
jle 0x2a34
movq 0x20(%rdi), %rdx
movq 0x30(%rdi), %r9
leaq (%rdx,%rsi), %r8
cmpq %r9, %r8
jae 0x2a3a
xorl %r8d, %r8d
jmp 0x2a41
movq 0x20(%rdi), %rdx
jmp 0x2a47
movq 0x38(%rdi), %r8
subq %r9, %r8
addq %rsi, %r8
addq %r8, %rdx
cmpq %rdx, %rcx
jae 0x2a5b
decq %rsi
cmpb $0xa, (%rdx)
jne 0x2a15
addq $0x2, %rsi
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: segstart
point_t segstart(buffer_t *bp, point_t start, point_t finish)
{
	char_t *p;
	int c = 0;
	point_t scan = start;

	while (scan < finish) {
		p = ptr(bp, scan);
		if (*p == '\n') {
			c = 0;
			start = scan+1;
		} else if (COLS <= c) {
			c = 0;
			start = scan;
		}
		++scan;
		c += *p == '\t' ? 8 - (c & 7) : 1;
	}
	return (c < COLS ? start : finish);
}

// Assembly:
pushq %rbx
movq %rdx, %rax
xorl %ecx, %ecx
cmpq %rdx, %rsi
jge 0x2aed
movq 0xa56e(%rip), %rcx      # 0xcfe0
movl (%rcx), %r8d
xorl %ecx, %ecx
movl $0x1, %r9d
movq %rsi, %rdx
testq %rsi, %rsi
js 0x2a9b
movq 0x20(%rdi), %r10
movq 0x30(%rdi), %rbx
leaq (%r10,%rsi), %r11
cmpq %rbx, %r11
jae 0x2aa1
xorl %r11d, %r11d
jmp 0x2aa8
movq 0x20(%rdi), %r10
jmp 0x2aae
movq 0x38(%rdi), %r11
subq %rbx, %r11
addq %rsi, %r11
addq %r11, %r10
xorl %r11d, %r11d
cmpl %ecx, %r8d
jg 0x2abb
movq %rsi, %rdx
xorl %ecx, %ecx
movb (%r10), %r10b
incq %rsi
cmpb $0xa, %r10b
cmoveq %rsi, %rdx
cmovel %r11d, %ecx
movl %ecx, %r11d
andl $0x7, %r11d
movl $0x8, %ebx
subl %r11d, %ebx
cmpb $0x9, %r10b
cmovnel %r9d, %ebx
addl %ebx, %ecx
cmpq %rsi, %rax
jne 0x2a80
jmp 0x2af0
movq %rsi, %rdx
movq 0xa4e9(%rip), %rsi      # 0xcfe0
cmpl (%rsi), %ecx
cmovlq %rdx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: segnext
point_t segnext(buffer_t *bp, point_t start, point_t finish)
{
	char_t *p;
	int c = 0;

	point_t scan = segstart(bp, start, finish);
	for (;;) {
		p = ptr(bp, scan);
		if (bp->b_ebuf <= p || COLS <= c)
			break;
		++scan;
		if (*p == '\n')
			break;
		c += *p == '\t' ? 8 - (c & 7) : 1;
	}
	return (p < bp->b_ebuf ? scan : pos(bp, bp->b_ebuf));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2a5c
movq 0x28(%rbx), %rcx
movq 0xa4cd(%rip), %rdx      # 0xcfe0
movl (%rdx), %edx
xorl %esi, %esi
movl $0x1, %edi
testq %rax, %rax
js 0x2b37
movq 0x20(%rbx), %r8
movq 0x30(%rbx), %r10
leaq (%r8,%rax), %r9
cmpq %r10, %r9
jae 0x2b3d
xorl %r9d, %r9d
jmp 0x2b44
movq 0x20(%rbx), %r8
jmp 0x2b4a
movq 0x38(%rbx), %r9
subq %r10, %r9
addq %rax, %r9
addq %r9, %r8
cmpq %r8, %rcx
jbe 0x2b7f
cmpl %esi, %edx
jle 0x2b7f
movb (%r8), %r9b
cmpb $0xa, %r9b
je 0x2b7c
movl %esi, %r8d
andl $0x7, %r8d
movl $0x8, %r10d
subl %r8d, %r10d
cmpb $0x9, %r9b
cmovnel %edi, %r10d
addl %r10d, %esi
incq %rax
jmp 0x2b1c
incq %rax
cmpq %r8, %rcx
ja 0x2ba5
movq 0x20(%rbx), %rax
movq 0x38(%rbx), %rsi
cmpq %rcx, %rsi
jbe 0x2b95
xorl %edx, %edx
jmp 0x2b9c
movq 0x30(%rbx), %rdx
subq %rsi, %rdx
subq %rax, %rcx
addq %rdx, %rcx
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: upup
point_t upup(buffer_t *bp, point_t off)
{
	point_t curr = lnstart(bp, off);
	point_t seg = segstart(bp, curr, off);
	if (curr < seg)
		off = segstart(bp, curr, seg-1);
	else
		off = segstart(bp, lnstart(bp,curr-1), curr-1);
	return (off);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x20(%rdi), %r15
leaq -0x1(%r15), %rcx
xorl %r14d, %r14d
movq %rsi, %rax
movq %r15, %rsi
testq %rax, %rax
jle 0x2be6
leaq (%rcx,%rax), %rsi
movq 0x30(%rbx), %rdi
cmpq %rdi, %rsi
jae 0x2bd9
xorl %esi, %esi
jmp 0x2be0
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
addq %rax, %rsi
addq %rcx, %rsi
cmpq %rsi, %r15
jae 0x2bf9
decq %rax
cmpb $0xa, (%rsi)
jne 0x2bc0
incq %rax
movq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a5c
cmpq %rax, %r14
jge 0x2c17
decq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
jmp 0x2c5d
leaq -0x1(%r14), %rdx
leaq -0x2(%r15), %rax
leaq -0x1(%r14), %rsi
movq %r15, %rcx
testq %rsi, %rsi
jle 0x2c49
leaq (%rax,%r14), %rcx
movq 0x30(%rbx), %rdi
cmpq %rdi, %rcx
jae 0x2c3c
xorl %ecx, %ecx
jmp 0x2c43
movq 0x38(%rbx), %rcx
subq %rdi, %rcx
addq %r14, %rcx
addq %rax, %rcx
cmpq %rcx, %r15
jae 0x2c58
cmpb $0xa, (%rcx)
movq %rsi, %r14
jne 0x2c1f
jmp 0x2c5a
xorl %esi, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2a5c
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: lncolumn
point_t lncolumn(buffer_t *bp, point_t offset, int column)
{
	int c = 0;
	char_t *p;
	while ((p = ptr(bp, offset)) < bp->b_ebuf && *p != '\n' && c < column) {
		c += *p == '\t' ? 8 - (c & 7) : 1;
		++offset;
	}
	return (offset);
}

// Assembly:
movq %rsi, %rax
movq 0x28(%rdi), %rcx
xorl %esi, %esi
movl $0x1, %r8d
testq %rax, %rax
js 0x2ce5
movq 0x20(%rdi), %r9
movq 0x30(%rdi), %r11
leaq (%r9,%rax), %r10
cmpq %r11, %r10
jae 0x2ceb
xorl %r10d, %r10d
jmp 0x2cf2
movq 0x20(%rdi), %r9
jmp 0x2cf8
movq 0x38(%rdi), %r10
subq %r11, %r10
addq %rax, %r10
addq %r10, %r9
cmpq %rcx, %r9
jae 0x2d2a
movb (%r9), %r9b
cmpb $0xa, %r9b
je 0x2d2a
cmpl %edx, %esi
jge 0x2d2a
movl %esi, %r10d
andl $0x7, %r10d
movl $0x8, %r11d
subl %r10d, %r11d
cmpb $0x9, %r9b
cmovnel %r8d, %r11d
addl %r11d, %esi
incq %rax
jmp 0x2cca
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: modeline
void modeline(buffer_t *bp)
{
	int i;
	char mch;
	
	standout();
	move(bp->w_top + bp->w_rows, 0);
	mch = ((bp->b_flags & B_MODIFIED) ? '*' : '=');
	sprintf(temp, "=%c " E_LABEL " == %s ", mch, bp->b_fname);
	addstr(temp);

	for (i = strlen(temp) + 1; i <= COLS; i++)
		addch('=');
	standend();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xa296(%rip), %r15      # 0xcfd0
movq (%r15), %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0x2040
movq (%r15), %rdi
movsbl 0x40(%rbx), %eax
movsbl 0x41(%rbx), %esi
addl %eax, %esi
xorl %edx, %edx
callq 0x2280
testb $0x1, 0x14d(%rbx)
movl $0x3d, %eax
movl $0x2a, %edx
cmovel %eax, %edx
addq $0x4c, %rbx
leaq 0xae86(%rip), %r14      # 0xdc00
leaq 0x5380(%rip), %rsi      # 0x8101
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x22b0
movq (%r15), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2310
movq %r14, %rdi
callq 0x20e0
movq %rax, %rbx
incl %ebx
movq 0xa22e(%rip), %r14      # 0xcfe0
cmpl (%r14), %ebx
jg 0x2dc8
movq (%r15), %rdi
movl $0x3d, %esi
callq 0x22a0
incl %ebx
jmp 0x2db2
movq (%r15), %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: dispmsg
void dispmsg()
{
	move(MSGLINE, 0);
	if (msgflag) {
		addstr(msgline);
		msgflag = FALSE;
	}
	clrtoeol();
}

// Assembly:
pushq %rbx
movq 0xa1f1(%rip), %rbx      # 0xcfd0
movq (%rbx), %rdi
movq 0xa1ff(%rip), %rax      # 0xcfe8
movl (%rax), %esi
decl %esi
xorl %edx, %edx
callq 0x2280
cmpl $0x0, 0xacf5(%rip)      # 0xdaf0
je 0x2e1b
movq (%rbx), %rdi
leaq 0xaae9(%rip), %rsi      # 0xd8f0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2310
movl $0x0, 0xacd5(%rip)      # 0xdaf0
movq (%rbx), %rdi
popq %rbx
jmp 0x2290
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: pgdown
void pgdown()
{
	curbp->b_page = curbp->b_point = upup(curbp, curbp->b_epage);
	while (0 < curbp->b_row--)
		down();
	curbp->b_epage = pos(curbp, curbp->b_ebuf);
}

// Assembly:
pushq %rbx
movq 0xa859(%rip), %rbx      # 0xdaf8
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x2ba7
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq 0xa83e(%rip), %rax      # 0xdaf8
movl 0x44(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x44(%rax)
testl %ecx, %ecx
jle 0x32ce
callq 0x31c7
jmp 0x32b3
movq 0x20(%rax), %rdx
movq 0x28(%rax), %rcx
movq 0x38(%rax), %rdi
cmpq %rcx, %rdi
jbe 0x32e3
xorl %esi, %esi
jmp 0x32ea
movq 0x30(%rax), %rsi
subq %rdi, %rsi
subq %rdx, %rcx
addq %rsi, %rcx
movq %rcx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: pgup
void pgup()
{
	int i = curbp->w_rows;
	while (0 < --i) {
		curbp->b_page = upup(curbp, curbp->b_page);
		up();
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq 0xa7f8(%rip), %rax      # 0xdaf8
movsbl 0x41(%rax), %ebp
cmpl $0x2, %ebp
jl 0x332e
incl %ebp
movq 0xa7e6(%rip), %rbx      # 0xdaf8
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x2ba7
movq %rax, 0x10(%rbx)
callq 0x319f
decl %ebp
cmpl $0x2, %ebp
jg 0x330b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: insert
void insert()
{
	assert(curbp->b_gap <= curbp->b_egap);
	if (curbp->b_gap == curbp->b_egap && !growgap(curbp, CHUNK)) return;
	curbp->b_point = movegap(curbp, curbp->b_point);
	*curbp->b_gap++ = *input == '\r' ? '\n' : *input;
	curbp->b_point = pos(curbp, curbp->b_egap);
	curbp->b_flags |= B_MODIFIED;
}

// Assembly:
pushq %rax
movq 0xa7bb(%rip), %rdi      # 0xdaf8
movq 0x30(%rdi), %rax
cmpq 0x38(%rdi), %rax
jne 0x3355
movl $0x1fa0, %esi           # imm = 0x1FA0
callq 0x25b2
testl %eax, %eax
je 0x33ac
movq 0xa79c(%rip), %rdi      # 0xdaf8
movq 0x8(%rdi), %rsi
callq 0x2692
movq 0xa78c(%rip), %rcx      # 0xdaf8
movq %rax, 0x8(%rcx)
movq 0xaa91(%rip), %rax      # 0xde08
movzbl (%rax), %eax
cmpb $0xd, %al
movl $0xa, %edx
cmovnel %eax, %edx
movq 0x30(%rcx), %rax
leaq 0x1(%rax), %rsi
movq %rsi, 0x30(%rcx)
movb %dl, (%rax)
movq 0xa75f(%rip), %rax      # 0xdaf8
movq 0x30(%rax), %rcx
subq 0x20(%rax), %rcx
movq %rcx, 0x8(%rax)
orb $0x1, 0x14d(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: backspace
void backspace()
{
	curbp->b_point = movegap(curbp, curbp->b_point);
	if (curbp->b_buf < curbp->b_gap) {
		--curbp->b_gap;
		curbp->b_flags |= B_MODIFIED;
	}
	curbp->b_point = pos(curbp, curbp->b_egap);
}

// Assembly:
pushq %rax
movq 0xa742(%rip), %rdi      # 0xdaf8
movq 0x8(%rdi), %rsi
callq 0x2692
movq 0xa732(%rip), %rcx      # 0xdaf8
movq %rax, 0x8(%rcx)
movq 0x20(%rcx), %rax
movq 0x30(%rcx), %rdx
cmpq %rdx, %rax
jae 0x33e5
decq %rdx
movq %rdx, 0x30(%rcx)
orb $0x1, 0x14d(%rcx)
movq 0x30(%rcx), %rdx
subq %rax, %rdx
movq %rdx, 0x8(%rcx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: delete
void delete()
{
	curbp->b_point = movegap(curbp, curbp->b_point);
	if (curbp->b_egap < curbp->b_ebuf) {
		curbp->b_point = pos(curbp, ++curbp->b_egap);
		curbp->b_flags |= B_MODIFIED;
	}
}

// Assembly:
pushq %rax
movq 0xa6fe(%rip), %rdi      # 0xdaf8
movq 0x8(%rdi), %rsi
callq 0x2692
movq 0xa6ee(%rip), %rcx      # 0xdaf8
movq %rax, 0x8(%rcx)
movq 0x38(%rcx), %rax
cmpq 0x28(%rcx), %rax
jae 0x3432
incq %rax
movq %rax, 0x38(%rcx)
movq 0x30(%rcx), %rax
subq 0x20(%rcx), %rax
movq %rax, 0x8(%rcx)
orb $0x1, 0x14d(%rcx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: insert_string
void insert_string(char *str)
{
	int len = (str == NULL) ? 0 : strlen(str);

	if (len <= 0) {
		msg("nothing to insert");
	} else if (len < curbp->b_egap - curbp->b_gap || growgap(curbp, len)) {
		curbp->b_point = movegap(curbp, curbp->b_point);
		memcpy(curbp->b_gap, str, len * sizeof (char_t));
		curbp->b_gap += len;
		curbp->b_point = pos(curbp, curbp->b_egap);
		curbp->b_flags |= B_MODIFIED;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x35ea
movq %rbx, %rdi
callq 0x20e0
jmp 0x35ec
xorl %eax, %eax
testl %eax, %eax
jle 0x3663
movl %eax, %r14d
movq 0xa4fe(%rip), %rdi      # 0xdaf8
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
cmpq %r14, %rax
jg 0x3613
movq %r14, %rsi
callq 0x25b2
testl %eax, %eax
je 0x365b
movq 0xa4de(%rip), %rdi      # 0xdaf8
movq 0x8(%rdi), %rsi
callq 0x2692
movq 0xa4ce(%rip), %rcx      # 0xdaf8
movq %rax, 0x8(%rcx)
movq 0x30(%rcx), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21e0
movq 0xa4b4(%rip), %rax      # 0xdaf8
addq 0x30(%rax), %r14
movq %r14, 0x30(%rax)
subq 0x20(%rax), %r14
movq %r14, 0x8(%rax)
orb $0x1, 0x14d(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4af9(%rip), %rdi      # 0x8163
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24cb
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: search_forward
point_t search_forward(buffer_t *bp, point_t start_p, char *stext)
{
	point_t end_p = pos(bp, bp->b_ebuf);
	point_t p,pp;
	char* s;

	if (0 == strlen(stext)) return start_p;

	for (p=start_p; p < end_p; p++) {
		for (s=stext, pp=p; *s == *(ptr(bp, pp)) && *s !='\0' && pp < end_p; s++, pp++)
			;
		if (*s == '\0') return pp;
	}
	return -1;
}

// Assembly:
movq 0x28(%rdi), %rax
movq 0x38(%rdi), %rcx
cmpq %rax, %rcx
jbe 0x3776
xorl %r8d, %r8d
jmp 0x377d
movq 0x30(%rdi), %r8
subq %rcx, %r8
cmpb $0x0, (%rdx)
je 0x37f7
movq 0x20(%rdi), %r9
subq %r9, %rax
addq %rax, %r8
cmpq %rsi, %r8
jle 0x37fb
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
xorl %r10d, %r10d
movq %rsi, %rax
movq %rdx, %r11
movq %r9, %r14
testq %rax, %rax
js 0x37c0
leaq (%r9,%rax), %rbx
movq 0x30(%rdi), %r15
movq %rcx, %r14
subq %r15, %r14
cmpq %r15, %rbx
cmovbq %r10, %r14
addq %rbx, %r14
movsbl (%r11), %ebx
movzbl (%r14), %ebp
cmpl %ebp, %ebx
jne 0x37dd
testb %bl, %bl
je 0x37dd
cmpq %r8, %rax
jge 0x37dd
incq %r11
incq %rax
jmp 0x37a0
testb %bl, %bl
je 0x37f0
incq %rsi
cmpq %r8, %rsi
jl 0x379a
movq $-0x1, %rax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rax
retq
movq $-0x1, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: new_key
keymap_t *new_key(char *name, char *bytes)
{
	keymap_t *kp = (keymap_t *)malloc(sizeof(keymap_t));
	assert(kp != NULL);

 	strncpy(kp->k_name, name, MAX_KNAME);
	strncpy(kp->k_bytes, bytes, MAX_KBYTES);
	kp->k_name[MAX_KNAME] ='\0';
	kp->k_bytes[MAX_KBYTES] ='\0';
	kp->k_func = user_func;
	strcpy(kp->k_funcname, E_NOT_BOUND);
	kp->k_next = NULL;
	return kp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x50, %edi
callq 0x21f0
movq %rax, %r15
movl $0xc, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2070
leaq 0xd(%r15), %rdi
movl $0xc, %edx
movq %rbx, %rsi
callq 0x2070
xorl %eax, %eax
movb %al, 0xc(%r15)
movb %al, 0x19(%r15)
leaq 0x2b(%rip), %rax        # 0x388a
movq %rax, 0x40(%r15)
movabsq $0x756f6220746f6e3c, %rax # imm = 0x756F6220746F6E3C
movq %rax, 0x1a(%r15)
movl $0x3e646e, 0x22(%r15)   # imm = 0x3E646E
movq $0x0, 0x48(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: user_func
void user_func()
{
	char *output;
	assert(key_return != NULL);
	if (0 == strcmp(key_return->k_funcname, E_NOT_BOUND)) {
		msg(E_NOT_BOUND);
		return;
	}

	reset_output_stream();
	output = call_lisp(key_return->k_funcname);

	/* show errors on message line */
	if (NULL != strstr(output, "error:")) {
		char buf[81];
		strncpy(buf, output, 80);
		buf[80] ='\0';
		msg(buf);
	}	
	reset_output_stream();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0xa580(%rip), %rdi      # 0xde18
addq $0x1a, %rdi
leaq 0x48d2(%rip), %rsi      # 0x8175
callq 0x2190
testl %eax, %eax
je 0x390b
xorl %eax, %eax
callq 0x76e5
movq 0xa55e(%rip), %rdi      # 0xde18
addq $0x1a, %rdi
callq 0x7a07
movq %rax, %rbx
leaq 0x48e2(%rip), %rsi      # 0x81af
movq %rax, %rdi
callq 0x2330
testq %rax, %rax
je 0x38fc
movq %rsp, %r14
movl $0x50, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2070
movb $0x0, 0x50(%r14)
movq %r14, %rdi
xorl %eax, %eax
callq 0x24cb
xorl %eax, %eax
callq 0x76e5
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x4863(%rip), %rdi      # 0x8175
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
jmp 0x24cb
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: create_keys
void create_keys()
{
	char ch;
	char ctrx_map[] = "c-x c-|";
	char ctrl_map[] = "c-|";
	char esc_map[] = "esc-|";
	char ctrx_bytes[] = "\x18\x01";
	char ctrl_bytes[] = "\x01";
	char esc_bytes[] = "\x1B\x61";

	assert(khead == NULL);
	khead = ktail = new_key("c-space", "\x00");

	/* control-a to z */
	for (ch = 1; ch <= 26; ch++) {
		if (ch == 9 || ch == 10 || ch == 24) continue;  /* skip tab, linefeed, ctrl-x */
		ctrl_map[2] = ch + 96;   /* ASCII a is 97 */
		ctrl_bytes[0] = ch;
		make_key(ctrl_map, ctrl_bytes);
	}

	/* esc-a to z */
	for (ch = 1; ch <= 26; ch++) {
		esc_map[4] = ch + 96;
		esc_bytes[1] = ch + 96;
		make_key(esc_map, esc_bytes);
	}

	/* control-x control-a to z */
	for (ch = 1; ch <= 26; ch++) {
		ctrx_map[6] = ch + 96;
		ctrx_bytes[1] = ch;
		make_key(ctrx_map, ctrx_bytes);
	}

	make_key("c-x ?", "\x18\x3F");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movabsq $0x7c2d6320782d63, %rax # imm = 0x7C2D6320782D63
movq %rax, 0x20(%rsp)
leaq 0x1c(%rsp), %rbx
movl $0x7c2d63, (%rbx)       # imm = 0x7C2D63
movw $0x7c, 0x18(%rsp)
movl $0x2d637365, 0x14(%rsp) # imm = 0x2D637365
xorl %eax, %eax
movb %al, 0x10(%rsp)
movw $0x118, 0xe(%rsp)       # imm = 0x118
leaq 0x12(%rsp), %r14
movw $0x1, (%r14)
movb %al, 0xc(%rsp)
movw $0x611b, 0xa(%rsp)      # imm = 0x611B
leaq 0x47f6(%rip), %rdi      # 0x818d
leaq 0x4a79(%rip), %rsi      # 0x8417
callq 0x3815
movq %rax, 0x9f2e(%rip)      # 0xd8d8
movq %rax, 0x9f1f(%rip)      # 0xd8d0
movb $0x61, %r15b
movl $0x1000600, %ebp        # imm = 0x1000600
leal -0x60(%r15), %eax
cmpb $0x18, %al
ja 0x39c9
movzbl %al, %ecx
btl %ecx, %ebp
jb 0x39ef
movb %r15b, 0x1e(%rsp)
movb %al, 0x12(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3815
movq 0x9ef4(%rip), %rcx      # 0xd8d8
movq %rax, 0x48(%rcx)
movq %rax, 0x9ee9(%rip)      # 0xd8d8
incb %r15b
cmpb $0x7b, %r15b
jne 0x39b9
movb $0x61, %bpl
leaq 0x14(%rsp), %rbx
leaq 0xa(%rsp), %r14
movb %bpl, 0x18(%rsp)
movb %bpl, 0xb(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3815
movq 0x9eb7(%rip), %rcx      # 0xd8d8
movq %rax, 0x48(%rcx)
movq %rax, 0x9eac(%rip)      # 0xd8d8
incb %bpl
cmpb $0x7b, %bpl
jne 0x3a05
movb $0x61, %r15b
leaq 0x20(%rsp), %rbx
leaq 0xe(%rsp), %r14
leal -0x60(%r15), %eax
movb %r15b, 0x26(%rsp)
movb %al, 0xf(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3815
movq 0x9e77(%rip), %rcx      # 0xd8d8
movq %rax, 0x48(%rcx)
movq %rax, 0x9e6c(%rip)      # 0xd8d8
incb %r15b
cmpb $0x7b, %r15b
jne 0x3a42
leaq 0x4719(%rip), %rdi      # 0x8195
leaq 0x4718(%rip), %rsi      # 0x819b
callq 0x3815
movq 0x9e49(%rip), %rcx      # 0xd8d8
movq %rax, 0x48(%rcx)
movq %rax, 0x9e3e(%rip)      # 0xd8d8
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: set_key_internal
int set_key_internal(char *name, char *funcname, char *bytes, void (*func)(void))
{
	keymap_t *kp;
	
	for (kp = khead; kp->k_next != NULL; kp = kp->k_next) {
		if (0 == strcmp(kp->k_name, name)) {
			strncpy(kp->k_funcname, funcname, MAX_KFUNC);
			kp->k_funcname[MAX_KFUNC] ='\0';
			if (func != NULL)  /* dont set if its a user_func */
				kp->k_func = func;
			return 1;
		}
	}

	/* not found, create it and add onto the tail */
	if (func != NULL) {
		kp = new_key(name, bytes);
		strncpy(kp->k_funcname, funcname, MAX_KFUNC);
		kp->k_funcname[MAX_KFUNC] ='\0';
		kp->k_func = func;
		ktail->k_next = kp;
		ktail = kp;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movq 0x9e0d(%rip), %rbp      # 0xd8d0
movq %rbp, %r15
movq 0x48(%rbp), %rbp
testq %rbp, %rbp
je 0x3b04
movq %r15, %rdi
movq %r13, %rsi
callq 0x2190
testl %eax, %eax
jne 0x3ac3
leaq 0x1a(%r15), %rdi
movl $0x1e, %edx
movq %r14, %rsi
callq 0x2070
movb $0x0, 0x38(%r15)
movl $0x1, %eax
testq %rbx, %rbx
je 0x3b4c
movq %rbx, 0x40(%r15)
jmp 0x3b4c
testq %rbx, %rbx
je 0x3b4a
movq %r13, %rdi
movq %r12, %rsi
callq 0x3815
movq %rax, %r15
leaq 0x1a(%rax), %rdi
movl $0x1e, %edx
movq %r14, %rsi
callq 0x2070
movb $0x0, 0x38(%r15)
movq %rbx, 0x40(%r15)
movq 0x9da0(%rip), %rax      # 0xd8d8
movq %r15, 0x48(%rax)
movq %r15, 0x9d95(%rip)      # 0xd8d8
movl $0x1, %eax
jmp 0x3b4c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: eval_block
void eval_block()
{
	char *output;

	if (curbp->b_mark == NOMARK || curbp->b_mark >= curbp->b_point) {
		msg("no block defined");
		return;
	}

	copy_cut(FALSE, FALSE);
	assert(scrap != NULL);
	assert(strlen(scrap) > 0);

	reset_output_stream();
	output = call_lisp((char *)scrap);
	insert_string("\n");
	insert_string(output);
	reset_output_stream();
}

// Assembly:
movq 0x9f88(%rip), %rax      # 0xdaf8
movq (%rax), %rcx
cmpq $-0x1, %rcx
je 0x3bbb
cmpq 0x8(%rax), %rcx
jge 0x3bbb
pushq %rbx
xorl %edi, %edi
xorl %esi, %esi
callq 0x346d
xorl %eax, %eax
callq 0x76e5
movq 0x9d51(%rip), %rdi      # 0xd8e8
callq 0x7a07
movq %rax, %rbx
leaq 0x4497(%rip), %rdi      # 0x803d
callq 0x35d4
movq %rbx, %rdi
callq 0x35d4
xorl %eax, %eax
popq %rbx
jmp 0x76e5
leaq 0x45dc(%rip), %rdi      # 0x819e
xorl %eax, %eax
jmp 0x24cb
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: load_config
void load_config()
{
	char fname[300];
	char *output;
	int fd;

	reset_output_stream();
	(void)snprintf(fname, 300, "%s/%s", getenv("HOME"), E_INITFILE);

	if ((fd = open(fname, O_RDONLY)) == -1)
		fatal("failed to open " E_INITFILE " in HOME directory");

	reset_output_stream();
	output = load_file(fd);
	assert(output != NULL);
	close(fd);

	/* all exceptions start with the word error: */
	if (NULL != strstr(output, "error:"))
		fatal(output);
	reset_output_stream();
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
xorl %eax, %eax
callq 0x76e5
leaq 0x45dc(%rip), %rdi      # 0x81bc
callq 0x2030
leaq 0x45ca(%rip), %rdx      # 0x81b6
leaq 0x45ce(%rip), %r8       # 0x81c1
movq %rsp, %rbx
movl $0x12c, %esi            # imm = 0x12C
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x2120
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2260
cmpl $-0x1, %eax
je 0x3c57
movl %eax, %ebp
xorl %eax, %eax
callq 0x76e5
movl %ebp, %edi
callq 0x6444
movq %rax, %rbx
movl %ebp, %edi
callq 0x2150
leaq 0x4575(%rip), %rsi      # 0x81af
movq %rbx, %rdi
callq 0x2330
testq %rax, %rax
jne 0x3c63
xorl %eax, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %rbp
jmp 0x76e5
leaq 0x456b(%rip), %rdi      # 0x81c9
callq 0x2494
movq %rbx, %rdi
callq 0x2494
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]zepl/zepl.c
// Function: main
int main(int argc, char **argv)
{
	if (argc != 2) fatal("usage: " E_NAME " filename\n");

	setup_keys();
	(void)init_lisp();
	load_config();
	initscr();	
	raw();
	noecho();
	
	curbp = new_buffer();
	(void)insert_file(argv[1], FALSE);
	/* Save filename irregardless of load() success. */
	strncpy(curbp->b_fname, argv[1], MAX_FNAME);
	curbp->b_fname[MAX_FNAME] = '\0'; /* force truncation */

	if (!growgap(curbp, CHUNK)) fatal("Failed to allocate required memory.\n");

	while (!done) {
		display();
		input = get_key(khead, &key_return);

		if (key_return != NULL) {
			(key_return->k_func)();
		} else {
			/* allow TAB and NEWLINE, any other control char is 'Not Bound' */
			if (*input > 31 || *input == 10 || *input == 9)
				insert();
                        else {
				fflush(stdin);
				msg(E_NOT_BOUND);
			}
		}
	}

	noraw();
	endwin();
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x41f6
movq %rsi, %rbx
callq 0x3c6b
callq 0x7906
callq 0x3bc9
callq 0x2130
callq 0x21b0
callq 0x20f0
movl $0x150, %edi            # imm = 0x150
callq 0x21f0
movq $0x0, 0x8(%rax)
movq $-0x1, (%rax)
xorl %ebp, %ebp
movb %bpl, 0x14d(%rax)
movb %bpl, 0x4c(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movb %bpl, 0x40(%rax)
movq 0x8ed6(%rip), %rcx      # 0xcfe8
movb (%rcx), %cl
addb $-0x2, %cl
movb %cl, 0x41(%rax)
movq %rax, 0x99d7(%rip)      # 0xdaf8
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x27e1
movq 0x99c5(%rip), %r14      # 0xdaf8
leaq 0x4c(%r14), %rdi
movq 0x8(%rbx), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x2070
movb %bpl, 0x14c(%r14)
movl $0x1fa0, %esi           # imm = 0x1FA0
movq %r14, %rdi
callq 0x25b2
testl %eax, %eax
je 0x4202
cmpl $0x0, 0x9c98(%rip)      # 0xde00
jne 0x41df
leaq 0x9ca7(%rip), %rbx      # 0xde18
movq 0x8e50(%rip), %r15      # 0xcfc8
leaq 0x3ff6(%rip), %r14      # 0x8175
callq 0x2e24
movq 0x9745(%rip), %rdi      # 0xd8d0
movq %rbx, %rsi
callq 0x28f9
movq %rax, 0x9c6e(%rip)      # 0xde08
movq 0x9c77(%rip), %rcx      # 0xde18
testq %rcx, %rcx
je 0x41ab
callq *0x40(%rcx)
jmp 0x41d6
movb (%rax), %al
cmpb $0x20, %al
setb %cl
addb $-0x9, %al
cmpb $0x2, %al
setae %al
testb %al, %cl
jne 0x41c4
callq 0x3335
jmp 0x41d6
movq (%r15), %rdi
callq 0x2200
movq %r14, %rdi
xorl %eax, %eax
callq 0x24cb
cmpl $0x0, 0x9c23(%rip)      # 0xde00
je 0x417f
callq 0x21a0
callq 0x22e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4204(%rip), %rdi      # 0x8401
callq 0x2494
leaq 0x3e11(%rip), %rdi      # 0x801a
callq 0x2494
nop