LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/bwamem_pair.c
// Function: mem_infer_dir
static inline int mem_infer_dir(int64_t l_pac, int64_t b1, int64_t b2, int64_t *dist)
{
	int64_t p2;
	int r1 = (b1 >= l_pac), r2 = (b2 >= l_pac);
	p2 = r1 == r2? b2 : (l_pac<<1) - 1 - b2; // p2 is the coordinate of read 2 on the read 1 strand
	*dist = p2 > b1? p2 - b1 : b1 - p2;
	return (r1 == r2? 0 : 1) ^ (p2 > b1? 0 : 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x2dfac
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x2dfbf
movq -0x8(%rbp), %rax
shlq %rax
subq $0x1, %rax
subq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jle 0x2dfdf
movq -0x28(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x2dfeb
movq -0x10(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %esi
movl $0x1, %eax
xorl %ecx, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0x3, %ecx
xorl %edx, %edx
cmpq %rdi, %rsi
cmovgl %edx, %ecx
xorl %ecx, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x48, %esi
leaq 0xab9c(%rip), %rdx      # 0x3b3f9
movl $0x19, %ecx
leaq 0xab9f(%rip), %r8       # 0x3b408
callq 0x31bf0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, %edi
movl $0x18, %esi
leaq 0xab6b(%rip), %rdx      # 0x3b3f9
movl $0x1b, %ecx
leaq 0xab6e(%rip), %r8       # 0x3b408
callq 0x31bf0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x1, %edi
movl $0x18, %esi
leaq 0xab3e(%rip), %rdx      # 0x3b3f9
movl $0x1c, %ecx
leaq 0xab41(%rip), %r8       # 0x3b408
callq 0x31bf0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movl $0x1, %edi
movl $0x18, %esi
leaq 0xab11(%rip), %rdx      # 0x3b3f9
movl $0x1d, %ecx
leaq 0xab14(%rip), %r8       # 0x3b408
callq 0x31bf0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x1, %edi
movl $0x18, %esi
leaq 0xaae4(%rip), %rdx      # 0x3b3f9
movl $0x1e, %ecx
leaq 0xaae7(%rip), %r8       # 0x3b408
callq 0x31bf0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x7fffffff, 0x1c(%rax) # imm = 0x7FFFFFFF
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x3380
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3380
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x3380
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3380
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x3380
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3380
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x3380
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3380
movq -0x8(%rbp), %rdi
callq 0x3380
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x30ae2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jge 0x30aef
movq $0x0, -0x8(%rbp)
jmp 0x30bbb
jmp 0x30af1
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x14(%rdx), %ecx
movb %al, -0x15(%rbp)
jge 0x30b23
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
setg %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x30b2c
jmp 0x30b3b
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x30af1
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x30b55
movq $0x0, -0x8(%rbp)
jmp 0x30bbb
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %r8d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %r9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %r10
movq -0x10(%rbp), %rax
addq $0x38, %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x14b70
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, -0x58(%rbp)
movq 0x10(%rbp), %rax
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movslq -0x24(%rbp), %rdi
leaq 0xa7f3(%rip), %rsi      # 0x3b3f9
movl $0x52, %edx
leaq 0xa804(%rip), %rcx      # 0x3b416
callq 0x31ca0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq 0x10(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x3250
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
movq -0x30(%rbp), %rax
leaq -0x50(%rbp), %rdi
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x2be60
movq -0x78(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, (%rdi)
movq -0x48(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x40(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x38(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%rdi), %rax
movl %eax, -0x64(%rbp)
movq 0x18(%rdi), %rax
movq %rax, -0x60(%rbp)
callq 0x31f0
movq -0x70(%rbp), %rdi
movl -0x64(%rbp), %esi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
callq 0x26fb0
movq -0x30(%rbp), %rdi
callq 0x3380
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x31a0
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jne 0x31c91
movq 0xe3ad(%rip), %rax      # 0x3ffd8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
imulq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r8
movl -0x34(%rbp), %r9d
leaq 0x9829(%rip), %rsi      # 0x3b4a5
movq %rax, (%rsp)
movb $0x0, %al
callq 0x34e0
movl $0x1, %edi
callq 0x33b0
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3450
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x31d34
movq 0xe305(%rip), %rax      # 0x3ffd8
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %r8
movl -0x2c(%rbp), %r9d
leaq 0x9786(%rip), %rsi      # 0x3b4a5
movq %rax, (%rsp)
movb $0x0, %al
callq 0x34e0
movl $0x1, %edi
callq 0x33b0
movq -0x28(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x35f0
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jne 0x31ddc
movq 0xe25d(%rip), %rax      # 0x3ffd8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r8
movl -0x34(%rbp), %r9d
leaq 0x96de(%rip), %rsi      # 0x3b4a5
movq %rax, (%rsp)
movb $0x0, %al
callq 0x34e0
movl $0x1, %edi
callq 0x33b0
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x36f0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x31e89
movq 0xe1b5(%rip), %rax      # 0x3ffd8
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30f0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %r8
movl -0x2c(%rbp), %r9d
leaq 0x9631(%rip), %rsi      # 0x3b4a5
movq %rax, (%rsp)
movb $0x0, %al
callq 0x34e0
movl $0x1, %edi
callq 0x33b0
movq -0x28(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ToniWestbrook[P]paladin/ksw.c
// Function: push_cigar
static inline uint32_t *push_cigar(int *n_cigar, int *m_cigar, uint32_t *cigar, int op, int len)
{
	if (*n_cigar == 0 || op != (cigar[(*n_cigar) - 1]&0xf)) {
		if (*n_cigar == *m_cigar) {
			*m_cigar = *m_cigar? (*m_cigar)<<1 : 4;
			cigar = realloc(cigar, (*m_cigar) << 2);
		}
		cigar[(*n_cigar)++] = len<<4 | op;
	} else cigar[(*n_cigar)-1] += len<<4;
	return cigar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x36235
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
andl $0xf, %ecx
cmpl %ecx, %eax
je 0x362ba
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x36298
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x36259
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll %eax
movl %eax, -0x24(%rbp)
jmp 0x36263
movl $0x4, %eax
movl %eax, -0x24(%rbp)
jmp 0x36263
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll $0x2, %eax
movslq %eax, %rsi
leaq 0x5275(%rip), %rdx      # 0x3b4f8
movl $0x1f9, %ecx            # imm = 0x1F9
leaq 0x5343(%rip), %r8       # 0x3b5d2
callq 0x31d40
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %edx
shll $0x4, %edx
orl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x362d6
movl -0x20(%rbp), %edx
shll $0x4, %edx
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x150, %edi            # imm = 0x150
callq 0x2220
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x14d(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x40(%rax)
movq 0xcae1(%rip), %rax      # 0xefe8
movl (%rax), %eax
subl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x41(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x21d0
callq 0x2300
movq -0x8(%rbp), %rcx
leaq 0x8ac3(%rip), %rdi      # 0xb004
leaq 0x8ac8(%rip), %rsi      # 0xb010
leaq 0x8ac6(%rip), %rdx      # 0xb015
movb $0x0, %al
callq 0x2130
movl $0x1, %edi
callq 0x22e0
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2595
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xd358(%rip), %rdi      # 0xf940
leaq -0x20(%rbp), %rdx
callq 0x2260
movl $0x1, 0xd545(%rip)      # 0xfb40
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
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 0x2610
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x293d
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x30(%rcx)
movb -0x1(%rax), %cl
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rax
movq %rax, %rsi
addq $-0x1, %rsi
movq %rsi, 0x38(%rdx)
movb %cl, -0x1(%rax)
jmp 0x2901
jmp 0x293f
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x2979
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x38(%rcx)
movb (%rax), %cl
movq -0x8(%rbp), %rdx
movq 0x30(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x30(%rdx)
movb %cl, (%rax)
jmp 0x293f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x2690
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0xd1a9(%rip), %rdi      # 0xfb48
addq $0x4c, %rdi
leaq 0x896a(%rip), %rsi      # 0xb314
callq 0x2290
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x29d3
movq 0xd187(%rip), %rsi      # 0xfb48
addq $0x4c, %rsi
leaq 0x8696(%rip), %rdi      # 0xb062
movb $0x0, %al
callq 0x2560
movq 0xd16e(%rip), %rdi      # 0xfb48
xorl %eax, %eax
movl %eax, %esi
callq 0x28e0
movq 0xd15e(%rip), %rax      # 0xfb48
movq 0x28(%rax), %rax
movq 0xd153(%rip), %rcx      # 0xfb48
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movq 0xd141(%rip), %rax      # 0xfb48
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x22f0
cmpq -0x10(%rbp), %rax
je 0x2a3c
movq 0xd11e(%rip), %rsi      # 0xfb48
addq $0x4c, %rsi
leaq 0x8647(%rip), %rdi      # 0xb07c
movb $0x0, %al
callq 0x2560
movq -0x8(%rbp), %rdi
callq 0x20e0
movq 0xd0fc(%rip), %rax      # 0xfb48
movsbl 0x14d(%rax), %ecx
andl $-0x2, %ecx
movb %cl, 0x14d(%rax)
movq 0xd0e5(%rip), %rax      # 0xfb48
addq $0x4c, %rax
movq %rax, -0x18(%rbp)
movq 0xd0d6(%rip), %rdi      # 0xfb48
movq 0xd0cf(%rip), %rax      # 0xfb48
movq 0x28(%rax), %rsi
callq 0x2690
movq -0x18(%rbp), %rsi
movq %rax, %rdx
leaq 0x8607(%rip), %rdi      # 0xb097
movb $0x0, %al
callq 0x2560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x21f0
cmpl $0x0, %eax
jge 0x2ae1
movq -0x10(%rbp), %rsi
leaq 0x85e0(%rip), %rdi      # 0xb0b2
movb $0x0, %al
callq 0x2560
movl %eax, -0x4(%rbp)
jmp 0x2c4a
movq $-0x1, %rax
cmpq -0x88(%rbp), %rax
jae 0x2b03
movq -0x10(%rbp), %rsi
leaq 0x85d0(%rip), %rdi      # 0xb0cc
movb $0x0, %al
callq 0x2560
movq 0xd03e(%rip), %rax      # 0xfb48
movq 0x38(%rax), %rax
movq 0xd033(%rip), %rcx      # 0xfb48
movq 0x30(%rcx), %rcx
subq %rcx, %rax
movq -0x88(%rbp), %rcx
shlq $0x0, %rcx
cmpq %rcx, %rax
jae 0x2b50
movq 0xd015(%rip), %rdi      # 0xfb48
movq -0x88(%rbp), %rsi
callq 0x26f0
cmpl $0x0, %eax
jne 0x2b50
movl $0x0, -0x4(%rbp)
jmp 0x2c4a
movq -0x10(%rbp), %rdi
leaq 0x8b8c(%rip), %rsi      # 0xb6e7
callq 0x2290
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2b84
movq -0x10(%rbp), %rsi
leaq 0x84ed(%rip), %rdi      # 0xb062
movb $0x0, %al
callq 0x2560
movl %eax, -0x4(%rbp)
jmp 0x2c4a
movq 0xcfbd(%rip), %rdi      # 0xfb48
movq 0xcfb6(%rip), %rax      # 0xfb48
movq 0x8(%rax), %rsi
callq 0x28e0
movq %rax, %rcx
movq 0xcfa3(%rip), %rax      # 0xfb48
movq %rcx, 0x8(%rax)
movq 0xcf98(%rip), %rax      # 0xfb48
movq 0x30(%rax), %rdi
movq -0x88(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x2090
movq %rax, %rcx
movq %rcx, -0x28(%rbp)
movq 0xcf71(%rip), %rax      # 0xfb48
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rdi
callq 0x20e0
cmpl $0x0, %eax
je 0x2c04
movq -0x10(%rbp), %rsi
leaq 0x84f2(%rip), %rdi      # 0xb0ea
movb $0x0, %al
callq 0x2560
movl %eax, -0x4(%rbp)
jmp 0x2c4a
movl -0x14(%rbp), %ecx
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl $0x1, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
movq 0xcf2a(%rip), %rax      # 0xfb48
movsbl 0x14d(%rax), %ecx
andl %edx, %ecx
movb %cl, 0x14d(%rax)
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0x84c9(%rip), %rdi      # 0xb105
movb $0x0, %al
callq 0x2560
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $-0x1, %rsi
movq %rsi, -0x10(%rbp)
callq 0x2610
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x19(%rbp)
jae 0x2e6c
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2e30
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x2e93
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq %rax, -0x28(%rbp)
jmp 0x2e9b
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x2e9b
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x2f74
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2610
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x2f13
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2f32
movq 0xc0c6(%rip), %rax      # 0xefe0
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
jg 0x2f30
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2f32
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0x2f5c
movl -0x24(%rbp), %ecx
andl $0x7, %ecx
movl $0x8, %eax
subl %ecx, %eax
movl %eax, -0x34(%rbp)
jmp 0x2f66
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2f66
movl -0x34(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x2ed3
movl -0x24(%rbp), %eax
movq 0xc062(%rip), %rcx      # 0xefe0
cmpl (%rcx), %eax
jge 0x2f8c
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x2f94
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2eb0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2610
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x20(%rbp), %rax
jbe 0x2ffd
movq 0xbfea(%rip), %rax      # 0xefe0
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
jg 0x2fff
jmp 0x304c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3019
jmp 0x304c
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0x3037
movl -0x24(%rbp), %ecx
andl $0x7, %ecx
movl $0x8, %eax
subl %ecx, %eax
movl %eax, -0x34(%rbp)
jmp 0x3041
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3041
movl -0x34(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x2fd0
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x3064
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x3079
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x2690
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e20
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2eb0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x30eb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
callq 0x2eb0
movq %rax, -0x10(%rbp)
jmp 0x311c
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x2e20
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
callq 0x2eb0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2610
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x28(%rdx), %rcx
movb %al, -0x21(%rbp)
jae 0x31ca
movq -0x20(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x21(%rbp)
je 0x31ca
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x31d3
jmp 0x3215
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0x31f1
movl -0x18(%rbp), %ecx
andl $0x7, %ecx
movl $0x8, %eax
subl %ecx, %eax
movl %eax, -0x28(%rbp)
jmp 0x31fb
movl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x31fb
movl -0x28(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x318a
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xbd9d(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0x2040
movq 0xbd89(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movsbl 0x40(%rax), %esi
movq -0x8(%rbp), %rax
movsbl 0x41(%rax), %eax
addl %eax, %esi
xorl %edx, %edx
callq 0x22a0
movq -0x8(%rbp), %rax
movsbl 0x14d(%rax), %edx
andl $0x1, %edx
movl $0x3d, %eax
movl $0x2a, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, -0xd(%rbp)
movsbl -0xd(%rbp), %edx
movq -0x8(%rbp), %rcx
addq $0x4c, %rcx
leaq 0xc9b9(%rip), %rdi      # 0xfc50
leaq 0x7e81(%rip), %rsi      # 0xb11f
movb $0x0, %al
callq 0x22d0
movq 0xbd24(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0xc99a(%rip), %rsi      # 0xfc50
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2330
leaq 0xc989(%rip), %rdi      # 0xfc50
callq 0x20f0
addq $0x1, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq 0xbd03(%rip), %rcx      # 0xefe0
cmpl (%rcx), %eax
jg 0x3300
movq 0xbce8(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movl $0x3d, %esi
callq 0x22c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x32d3
movq 0xbcc9(%rip), %rax      # 0xefd0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/zepl.c
// Function: dispmsg
void dispmsg()
{
	move(MSGLINE, 0);
	if (msgflag) {
		addstr(msgline);
		msgflag = FALSE;
	}
	clrtoeol();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xbca5(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movq 0xbcb3(%rip), %rax      # 0xefe8
movl (%rax), %esi
subl $0x1, %esi
xorl %edx, %edx
callq 0x22a0
cmpl $0x0, 0xc7f8(%rip)      # 0xfb40
je 0x336f
movq 0xbc7f(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0xc5e5(%rip), %rsi      # 0xf940
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2330
movl $0x0, 0xc7d1(%rip)      # 0xfb40
movq 0xbc5a(%rip), %rax      # 0xefd0
movq (%rax), %rdi
callq 0x22b0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0xc15d(%rip), %rdi      # 0xfb48
movq 0xc156(%rip), %rax      # 0xfb48
movq 0x18(%rax), %rsi
callq 0x3090
movq %rax, %rcx
movq 0xc143(%rip), %rax      # 0xfb48
movq %rcx, 0x8(%rax)
movq 0xc138(%rip), %rax      # 0xfb48
movq %rcx, 0x10(%rax)
movq 0xc12d(%rip), %rax      # 0xfb48
movl 0x44(%rax), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, 0x44(%rax)
xorl %eax, %eax
cmpl %ecx, %eax
jge 0x3a33
callq 0x38c0
jmp 0x3a14
movq 0xc10e(%rip), %rdi      # 0xfb48
movq 0xc107(%rip), %rax      # 0xfb48
movq 0x28(%rax), %rsi
callq 0x2690
movq %rax, %rcx
movq 0xc0f4(%rip), %rax      # 0xfb48
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xc0d9(%rip), %rax      # 0xfb48
movsbl 0x41(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jge 0x3ab1
movq 0xc0bc(%rip), %rdi      # 0xfb48
movq 0xc0b5(%rip), %rax      # 0xfb48
movq 0x10(%rax), %rsi
callq 0x3090
movq %rax, %rcx
movq 0xc0a2(%rip), %rax      # 0xfb48
movq %rcx, 0x10(%rax)
callq 0x3860
jmp 0x3a76
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xc079(%rip), %rax      # 0xfb48
movq 0x30(%rax), %rax
movq 0xc06e(%rip), %rcx      # 0xfb48
cmpq 0x38(%rcx), %rax
jne 0x3afb
movq 0xc061(%rip), %rdi      # 0xfb48
movl $0x1fa0, %esi           # imm = 0x1FA0
callq 0x26f0
cmpl $0x0, %eax
jne 0x3afb
jmp 0x3b9f
movq 0xc046(%rip), %rdi      # 0xfb48
movq 0xc03f(%rip), %rax      # 0xfb48
movq 0x8(%rax), %rsi
callq 0x28e0
movq %rax, %rcx
movq 0xc02c(%rip), %rax      # 0xfb48
movq %rcx, 0x8(%rax)
movq 0xc331(%rip), %rax      # 0xfe58
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x3b39
movl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x3b46
movq 0xc318(%rip), %rax      # 0xfe58
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movb %al, %cl
movq 0xbff6(%rip), %rdx      # 0xfb48
movq 0x30(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x30(%rdx)
movb %cl, (%rax)
movq 0xbfde(%rip), %rdi      # 0xfb48
movq 0xbfd7(%rip), %rax      # 0xfb48
movq 0x38(%rax), %rsi
callq 0x2690
movq %rax, %rcx
movq 0xbfc4(%rip), %rax      # 0xfb48
movq %rcx, 0x8(%rax)
movq 0xbfb9(%rip), %rax      # 0xfb48
movsbl 0x14d(%rax), %ecx
orl $0x1, %ecx
movb %cl, 0x14d(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0xbf8d(%rip), %rdi      # 0xfb48
movq 0xbf86(%rip), %rax      # 0xfb48
movq 0x8(%rax), %rsi
callq 0x28e0
movq %rax, %rcx
movq 0xbf73(%rip), %rax      # 0xfb48
movq %rcx, 0x8(%rax)
movq 0xbf68(%rip), %rax      # 0xfb48
movq 0x20(%rax), %rax
movq 0xbf5d(%rip), %rcx      # 0xfb48
cmpq 0x30(%rcx), %rax
jae 0x3c1b
movq 0xbf50(%rip), %rax      # 0xfb48
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
movq 0xbf3d(%rip), %rax      # 0xfb48
movsbl 0x14d(%rax), %ecx
orl $0x1, %ecx
movb %cl, 0x14d(%rax)
movq 0xbf26(%rip), %rdi      # 0xfb48
movq 0xbf1f(%rip), %rax      # 0xfb48
movq 0x38(%rax), %rsi
callq 0x2690
movq %rax, %rcx
movq 0xbf0c(%rip), %rax      # 0xfb48
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0xbeed(%rip), %rdi      # 0xfb48
movq 0xbee6(%rip), %rax      # 0xfb48
movq 0x8(%rax), %rsi
callq 0x28e0
movq %rax, %rcx
movq 0xbed3(%rip), %rax      # 0xfb48
movq %rcx, 0x8(%rax)
movq 0xbec8(%rip), %rax      # 0xfb48
movq 0x38(%rax), %rax
movq 0xbebd(%rip), %rcx      # 0xfb48
cmpq 0x28(%rcx), %rax
jae 0x3cd5
movq 0xbeb0(%rip), %rdi      # 0xfb48
movq 0xbea9(%rip), %rax      # 0xfb48
movq 0x38(%rax), %rsi
addq $0x1, %rsi
movq %rsi, 0x38(%rax)
callq 0x2690
movq %rax, %rcx
movq 0xbe8e(%rip), %rax      # 0xfb48
movq %rcx, 0x8(%rax)
movq 0xbe83(%rip), %rax      # 0xfb48
movsbl 0x14d(%rax), %ecx
orl $0x1, %ecx
movb %cl, 0x14d(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3f9b
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x3fa8
movq -0x8(%rbp), %rdi
callq 0x20f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x3fc8
leaq 0x71c5(%rip), %rdi      # 0xb181
movb $0x0, %al
callq 0x2560
jmp 0x409a
movslq -0xc(%rbp), %rax
movq 0xbb75(%rip), %rcx      # 0xfb48
movq 0x38(%rcx), %rcx
movq 0xbb6a(%rip), %rdx      # 0xfb48
movq 0x30(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jl 0x4003
movq 0xbb57(%rip), %rdi      # 0xfb48
movslq -0xc(%rbp), %rsi
callq 0x26f0
cmpl $0x0, %eax
je 0x4098
movq 0xbb3e(%rip), %rdi      # 0xfb48
movq 0xbb37(%rip), %rax      # 0xfb48
movq 0x8(%rax), %rsi
callq 0x28e0
movq %rax, %rcx
movq 0xbb24(%rip), %rax      # 0xfb48
movq %rcx, 0x8(%rax)
movq 0xbb19(%rip), %rax      # 0xfb48
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
shlq $0x0, %rdx
callq 0x2210
movl -0xc(%rbp), %edx
movq 0xbafa(%rip), %rax      # 0xfb48
movq 0x30(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x30(%rax)
movq 0xbae5(%rip), %rdi      # 0xfb48
movq 0xbade(%rip), %rax      # 0xfb48
movq 0x38(%rax), %rsi
callq 0x2690
movq %rax, %rcx
movq 0xbacb(%rip), %rax      # 0xfb48
movq %rcx, 0x8(%rax)
movq 0xbac0(%rip), %rax      # 0xfb48
movsbl 0x14d(%rax), %ecx
orl $0x1, %ecx
movb %cl, 0x14d(%rax)
jmp 0x409a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x2690
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20f0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x4289
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x434a
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x4342
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2610
movl -0x48(%rbp), %ecx
movzbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x41(%rbp)
jne 0x42f4
movq -0x40(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
je 0x42f4
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
setl %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x42fd
jmp 0x4319
jmp 0x42ff
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x42af
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x432f
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x434a
jmp 0x4331
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4291
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x50, %edi
callq 0x2220
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0xc, %edx
callq 0x2070
movq -0x18(%rbp), %rdi
addq $0xd, %rdi
movq -0x10(%rbp), %rsi
movl $0xc, %edx
callq 0x2070
movq -0x18(%rbp), %rax
movb $0x0, 0xc(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x19(%rax)
movq -0x18(%rbp), %rax
leaq 0x2f(%rip), %rcx        # 0x4420
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rdi
addq $0x1a, %rdi
leaq 0x6d8f(%rip), %rsi      # 0xb193
callq 0x2080
movq -0x18(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0xba39(%rip), %rdi      # 0xfe68
addq $0x1a, %rdi
leaq 0x6d59(%rip), %rsi      # 0xb193
callq 0x21c0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4457
leaq 0x6d45(%rip), %rdi      # 0xb193
movb $0x0, %al
callq 0x2560
jmp 0x44b4
movb $0x0, %al
callq 0xa310
movq 0xba03(%rip), %rdi      # 0xfe68
addq $0x1a, %rdi
callq 0xa650
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6d58(%rip), %rsi      # 0xb1d5
callq 0x2350
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x44ad
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x2070
movb $0x0, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movb $0x0, %al
callq 0x2560
movb $0x0, %al
callq 0xa310
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)