LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/glob.c
// Function: glob
extern List *glob(List *s) {
	List *top, *r;
	bool meta;
	for (r = s, meta = FALSE; r != NULL; r = r->n)
		if (r->m != NULL)
			meta = TRUE;
	if (!meta)
		return s; /* don't copy lists with no metacharacters in them */
	for (top = r = NULL; s != NULL; s = s->n) {
		if (s->m == NULL) { /* no metacharacters; just tack on to the return list */
			if (top == NULL)
				top = r = nnew(List);
			else
				r = r->n = nnew(List);
			r->w = s->w;
		} else {
			if (top == NULL)
				top = r = sort(doglob(s->w, s->m));
			else
				r->n = sort(doglob(s->w, s->m));
			while (r->n != NULL)
				r = r->n;
		}
	}
	r->n = NULL;
	return top;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x60f5
movq %rdi, %rbx
movl $0x1, %eax
movq %rdi, %rcx
cmpq $0x0, 0x8(%rcx)
cmovnel %eax, %r14d
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x605c
testl %r14d, %r14d
je 0x60f2
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x60a1
movq (%rbx), %rdi
callq 0x6161
movq %rax, %r15
movq %rax, %rdi
callq 0x6104
testq %r14, %r14
je 0x60c9
movq %r15, 0x10(%r12)
jmp 0x60cf
movl $0x18, %edi
callq 0x9e80
movq %rax, %rcx
testq %r14, %r14
je 0x60bb
movq %rax, 0x10(%r12)
movq %r14, %rcx
movq (%rbx), %rdx
movq %rdx, (%rax)
movq %rcx, %r14
movq %rax, %r12
jmp 0x60de
movq %r15, %r14
movq %r15, %r12
movq %r12, %rax
movq %rax, %r12
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x60d2
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x6079
movq $0x0, 0x10(%r12)
jmp 0x60f5
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/glob.c
// Function: sort
static List *sort(List *s) {
	size_t nel = listnel(s);
	if (nel > 1) {
		char **a;
		List *t;
		qsort(a = list2array(s, FALSE), nel, sizeof(char *), starstrcmp);
		for (t = s; t != NULL; t = t->n)
			t->w = *a++;
	}
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x9751
cmpl $0x2, %eax
jb 0x6158
movslq %eax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5110
movq %rax, %r14
leaq 0x6680(%rip), %rcx      # 0xc7ad
movl $0x8, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3080
testq %rbx, %rbx
je 0x6158
movq %rbx, %rax
movq (%r14), %rcx
addq $0x8, %r14
movq %rcx, (%rax)
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x6145
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/glom.c
// Function: word
extern List *word(char *w, char *m) {
	List *s = NULL;
	if (w != NULL) {
		s = nnew(List);
		s->w = w;
		s->m = m;
		s->n = NULL;
	}
	return s;
}

// Assembly:
testq %rdi, %rdi
je 0x6674
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0x9e80
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/glom.c
// Function: append
extern List *append(List *s1, List *s2) {
	List *r, *top;
	if (s1 == NULL)
		return s2;
	if (s2 == NULL)
		return s1;
	for (r = top = nnew(List); 1; r = r->n = nnew(List)) {
		r->w = s1->w;
		r->m = s1->m;
		if ((s1 = s1->n) == NULL)
			break;
	}
	r->n = s2;
	return top;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x66d7
movq %rdi, %r15
testq %rbx, %rbx
je 0x66dc
movl $0x18, %edi
callq 0x9e80
movq %rax, %r14
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x66d1
movq %r14, %r12
movl $0x18, %edi
callq 0x9e80
movq %rax, 0x10(%r12)
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r15), %r15
movq %rax, %r12
testq %r15, %r15
jne 0x66af
movq %rbx, 0x10(%rax)
jmp 0x66df
movq %rbx, %r14
jmp 0x66df
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/glom.c
// Function: concat
extern List *concat(List *s1, List *s2) {
	int n1, n2;
	List *r, *top;
	if (s1 == NULL)
		return s2;
	if (s2 == NULL)
		return s1;
	if ((n1 = listnel(s1)) != (n2 = listnel(s2)) && n1 != 1 && n2 != 1)
		rc_error("bad concatenation");
	for (r = top = nnew(List); 1; r = r->n = nnew(List)) {
		size_t x = strlen(s1->w);
		size_t y = strlen(s2->w);
		size_t z = x + y + 1;
		r->w = nalloc(z);
		strcpy(r->w, s1->w);
		strcat(r->w, s2->w);
		if (s1->m == NULL && s2->m == NULL) {
			r->m = NULL;
		} else {
			r->m = nalloc(z);
			if (s1->m == NULL)
				memzero(r->m, x);
			else
				memcpy(r->m, s1->m, x);
			if (s2->m == NULL)
				memzero(&r->m[x], y);
			else
				memcpy(&r->m[x], s2->m, y);
			r->m[z] = 0;
		}
		if (n1 > 1)
			s1 = s1->n;
		if (n2 > 1)
			s2 = s2->n;
		if (s1 == NULL || s2 == NULL || (n1 == 1 && n2 == 1))
			break;
	}
	r->n = NULL;
	return top;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x6877
movq %rdi, %r14
testq %rbx, %rbx
je 0x687c
movq %r14, %rdi
callq 0x9751
movl %eax, %r15d
movq %rbx, %rdi
callq 0x9751
movl %eax, 0x8(%rsp)
cmpl $0x1, %eax
je 0x6749
cmpl $0x1, %r15d
je 0x6749
cmpl 0x8(%rsp), %r15d
je 0x6749
leaq 0x8f88(%rip), %rdi      # 0xf6cc
callq 0x46c0
movl 0x8(%rsp), %ebp
xorl $0x1, %ebp
movl %r15d, 0xc(%rsp)
xorl $0x1, %r15d
movl $0x18, %edi
callq 0x9e80
orl %ebp, %r15d
setne 0x7(%rsp)
movq %rax, 0x10(%rsp)
movq %rax, %r15
movq (%r14), %rdi
callq 0x30f0
movq %rax, %r12
movq (%rbx), %rdi
callq 0x30f0
movq %rax, %rbp
leaq (%r12,%rax), %r13
incq %r13
movq %r13, %rdi
callq 0x9e80
movq %rax, (%r15)
movq (%r14), %rsi
movq %rax, %rdi
callq 0x3070
movq (%r15), %rdi
movq (%rbx), %rsi
callq 0x3310
cmpq $0x0, 0x8(%r14)
jne 0x67c3
cmpq $0x0, 0x8(%rbx)
je 0x685e
movq %r13, %rdi
callq 0x9e80
movq %rax, 0x8(%r15)
movq 0x8(%r14), %rsi
movq %rax, %rdi
testq %rsi, %rsi
je 0x67e5
movq %r12, %rdx
callq 0x3230
jmp 0x67ef
xorl %esi, %esi
movq %r12, %rdx
callq 0x3150
movq 0x8(%rbx), %rsi
addq 0x8(%r15), %r12
movq %r12, %rdi
testq %rsi, %rsi
je 0x6809
movq %rbp, %rdx
callq 0x3230
jmp 0x6813
xorl %esi, %esi
movq %rbp, %rdx
callq 0x3150
movq 0x8(%r15), %rax
movb $0x0, (%rax,%r13)
movl 0xc(%rsp), %eax
cmpl $0x2, %eax
jl 0x6829
movq 0x10(%r14), %r14
cmpl $0x2, 0x8(%rsp)
jl 0x6834
movq 0x10(%rbx), %rbx
testq %r14, %r14
setne %al
testq %rbx, %rbx
setne %cl
andb %al, %cl
andb 0x7(%rsp), %cl
cmpb $0x1, %cl
jne 0x6868
movl $0x18, %edi
callq 0x9e80
movq %rax, 0x10(%r15)
jmp 0x6770
movq $0x0, 0x8(%r15)
jmp 0x681c
movq $0x0, 0x10(%r15)
movq 0x10(%rsp), %rax
jmp 0x687f
movq %rbx, %rax
jmp 0x687f
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/glom.c
// Function: varsub
extern List *varsub(List *var, List *subs) {
	List *r, *top;
	int n = listnel(var);
	for (top = r = NULL; subs != NULL; subs = subs->n) {
		int i = a2u(subs->w);
		if (i < 1)
			rc_error("bad subscript");
		if (i <= n) {
			List *sub = var;
			while (--i)
				sub = sub->n; /* loop until sub == var(i) */
			if (top == NULL)
				top = r = nnew(List);
			else
				r = r->n = nnew(List);
			r->w = sub->w;
			r->m = sub->m;
		}
	}
	if (top != NULL)
		r->n = NULL;
	return top;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
callq 0x9751
testq %rbx, %rbx
je 0x6931
movl %eax, %ebp
xorl %r14d, %r14d
xorl %r12d, %r12d
movq (%rbx), %rdi
movl $0xa, %esi
callq 0xc780
movl %eax, %r13d
testl %eax, %eax
jg 0x68d6
leaq 0x8e0d(%rip), %rdi      # 0xf6de
callq 0x46c0
cmpl %ebp, %r13d
jg 0x6918
movq (%rsp), %r15
decl %r13d
je 0x68f1
movq (%rsp), %r15
movq 0x10(%r15), %r15
decl %r13d
jne 0x68e8
movl $0x18, %edi
callq 0x9e80
movq %rax, %rcx
testq %r14, %r14
je 0x690b
movq %rax, 0x10(%r12)
movq %r14, %rcx
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq %rax, %r12
movq %rcx, %r14
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x68b6
testq %r14, %r14
je 0x6931
movq $0x0, 0x10(%r12)
jmp 0x6934
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/glom.c
// Function: flatten
extern List *flatten(List *s) {
	List *r;
	size_t step;
	char *f;
	if (s == NULL || s->n == NULL)
		return s;
	r = nnew(List);
	f = r->w = nalloc(listlen(s) + 1);
	r->m = NULL; /* flattened lists come from variables, so no meta */
	r->n = NULL;
	strcpy(f, s->w);
	f += strlen(s->w);
	do {
		*f++ = ' ';
		s = s->n;
		step = strlen(s->w);
		memcpy(f, s->w, step);
		f += step;
	} while (s->n != NULL);
	*f = '\0';
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x69e8
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x69ed
movl $0x18, %edi
callq 0x9e80
movq %rax, %r14
movq %rbx, %rdi
callq 0x971d
leaq 0x1(%rax), %rdi
callq 0x9e80
movq %rax, %r12
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x3070
movq (%rbx), %rdi
callq 0x30f0
movq %rax, %r15
addq %r12, %r15
leaq 0x1(%r15), %r12
movb $0x20, (%r15)
movq 0x10(%rbx), %rbx
movq (%rbx), %r13
movq %r13, %rdi
callq 0x30f0
movq %rax, %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x3230
addq %rbp, %r15
incq %r15
cmpq $0x0, 0x10(%rbx)
jne 0x69ad
movb $0x0, (%r15)
jmp 0x69f0
xorl %r14d, %r14d
jmp 0x69f0
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/glom.c
// Function: assign
extern void assign(List *s1, List *s2, bool stack) {
	List *val = s2;
	if (s1 == NULL)
		rc_error("null variable name");
	if (s1->n != NULL)
		rc_error("multi-word variable name");
	if (*s1->w == '\0')
		rc_error("zero-length variable name");
	if (a2u(s1->w) != -1)
		rc_error("numeric variable name");
	if (strchr(s1->w, '=') != NULL)
		rc_error("'=' in variable name");
	if (*s1->w == '*' && s1->w[1] == '\0')
		val = append(varlookup("0"), s2); /* preserve $0 when * is assigned explicitly */
	if (s2 != NULL || stack) {
		if (dashex)
			prettyprint_var(2, s1->w, val);
		varassign(s1->w, val, stack);
		alias(s1->w, varlookup(s1->w), stack);
	} else {
		if (dashex)
			prettyprint_var(2, s1->w, NULL);
		varrm(s1->w, stack);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x6a23
leaq 0x8cce(%rip), %rdi      # 0xf6ec
callq 0x46c0
cmpq $0x0, 0x10(%rbx)
je 0x6a36
leaq 0x8cce(%rip), %rdi      # 0xf6ff
callq 0x46c0
movq (%rbx), %rdi
cmpb $0x0, (%rdi)
jne 0x6a4d
leaq 0x8cd3(%rip), %rdi      # 0xf718
callq 0x46c0
movq (%rbx), %rdi
movl $0xa, %esi
callq 0xc780
cmpl $-0x1, %eax
je 0x6a68
leaq 0x8ccf(%rip), %rdi      # 0xf732
callq 0x46c0
movq (%rbx), %r12
movq %r12, %rdi
movl $0x3d, %esi
callq 0x3120
testq %rax, %rax
je 0x6a8c
leaq 0x8cc4(%rip), %rdi      # 0xf748
callq 0x46c0
movq (%rbx), %r12
cmpb $0x2a, (%r12)
movq %r14, %r15
jne 0x6abb
cmpb $0x0, 0x1(%r12)
movq %r14, %r15
jne 0x6abb
leaq 0xd54c(%rip), %rdi      # 0x13ff4
callq 0xc9da
movq %rax, %rdi
movq %r14, %rsi
callq 0x6677
movq %rax, %r15
testq %r14, %r14
sete %cl
testl %ebp, %ebp
sete %dl
leaq 0x13123(%rip), %rax     # 0x19bf0
movl (%rax), %eax
movq (%rbx), %rsi
testb %dl, %cl
jne 0x6b17
testl %eax, %eax
je 0x6aea
movl $0x2, %edi
movq %r15, %rdx
callq 0xcd8c
movq (%rbx), %rsi
movq %rsi, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xc808
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0xc9da
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc995
testl %eax, %eax
je 0x6b2a
movl $0x2, %edi
xorl %edx, %edx
callq 0xcd8c
movq (%rbx), %rsi
movq %rsi, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xcb35
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/glom.c
// Function: qredir
extern void qredir(Node *n) {
	Rq *next;
	if (redirq == NULL) {
		next = redirq = nnew(Rq);
	} else {
		for (next = redirq; next->n != NULL; next = next->n)
			;
		next->n = nnew(Rq);
		next = next->n;
	}
	next->r = n;
	next->n = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x12f7e(%rip), %rax     # 0x19ac8
testq %rax, %rax
je 0x6b61
movq %rax, %r14
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x6b4f
addq $0x8, %r14
jmp 0x6b68
leaq 0x12f60(%rip), %r14     # 0x19ac8
movl $0x10, %edi
callq 0x9e80
movq %rax, (%r14)
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/glom.c
// Function: count
static List *count(List *l) {
	List *s = nnew(List);
	s->w = nprint("%d", listnel(l));
	s->n = NULL;
	s->m = NULL;
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %edi
callq 0x9e80
movq %rax, %r14
movq %rbx, %rdi
callq 0x9751
leaq 0x8521(%rip), %rdi      # 0xf795
movl %eax, %esi
xorl %eax, %eax
callq 0xb191
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/hash.c
// Function: inithash
extern void inithash() {
	Htab *fpp, *vpp;
	int i;
	fp = ealloc(sizeof(Htab) * HASHSIZE);
	vp = ealloc(sizeof(Htab) * HASHSIZE);
	fused = vused = 0;
	fsize = vsize = HASHSIZE;
	for (vpp = vp, fpp = fp, i = 0; i < HASHSIZE; i++, vpp++, fpp++)
		vpp->name = fpp->name = NULL;
}

// Assembly:
pushq %rax
movl $0x400, %edi            # imm = 0x400
callq 0xa00d
movq %rax, 0x1282a(%rip)     # 0x19ad0
movl $0x400, %edi            # imm = 0x400
callq 0xa00d
movq %rax, 0x12821(%rip)     # 0x19ad8
xorl %ecx, %ecx
movl %ecx, 0x12821(%rip)     # 0x19ae0
movl %ecx, 0x1281f(%rip)     # 0x19ae4
movl $0x40, %edx
movl %edx, 0x12818(%rip)     # 0x19ae8
movl %edx, 0x12816(%rip)     # 0x19aec
movq 0x127f3(%rip), %rdx     # 0x19ad0
xorl %esi, %esi
movq %rcx, (%rdx,%rsi)
movq %rcx, (%rax,%rsi)
addq $0x10, %rsi
cmpl $0x400, %esi            # imm = 0x400
jne 0x72df
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/hash.c
// Function: find
static int find(char *s, Htab *ht, int size) {
	int h = hash(s, size);
	while (ht[h].name != NULL && !streq(ht[h].name, s)) {
		h++;
		h &= size - 1;
	}
	return h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %esi
callq 0x7dfd
movl %eax, %ebx
movl %eax, %eax
shlq $0x4, %rax
movq (%r14,%rax), %rdi
testq %rdi, %rdi
je 0x7385
movb (%r15), %r12b
decl %ebp
cmpb %r12b, (%rdi)
jne 0x7371
movq %r15, %rsi
callq 0x31f0
testl %eax, %eax
je 0x7385
incl %ebx
andl %ebp, %ebx
movq %rbx, %rax
shlq $0x4, %rax
movq (%r14,%rax), %rdi
testq %rdi, %rdi
jne 0x7360
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/hash.c
// Function: get_fn_place
extern rc_Function *get_fn_place(char *s) {
	int h = fnfind(s);
	env_dirty = TRUE;
	if (fp[h].name == NULL) {
		if (rehash(fp))
			h = fnfind(s);
		fused++;
		fp[h].name = ecpy(s);
		fp[h].p = enew(rc_Function);
	} else
		free_fn(fp[h].p);
	return fp[h].p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x12731(%rip), %r14     # 0x19ad0
movl 0x12747(%rip), %edx     # 0x19aec
movq %r14, %rsi
callq 0x7333
movb $0x0, 0x1273c(%rip)     # 0x19af0
movl %eax, %r15d
movq %r15, %rax
shlq $0x4, %rax
cmpq $0x0, (%r14,%rax)
je 0x73df
addq %rax, %r14
movq 0x8(%r14), %rbx
movq (%rbx), %rdi
callq 0xc615
movq 0x8(%rbx), %rdi
callq 0x9fde
jmp 0x7450
movq %r14, %rdi
callq 0x7466
testl %eax, %eax
je 0x7403
movq 0x126de(%rip), %rsi     # 0x19ad0
movl 0x126f4(%rip), %edx     # 0x19aec
movq %rbx, %rdi
callq 0x7333
movl %eax, %r15d
incl 0x126db(%rip)           # 0x19ae4
movq %rbx, %rdi
callq 0x30f0
leaq 0x1(%rax), %rdi
callq 0xa00d
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3070
movq 0x126a1(%rip), %rax     # 0x19ad0
movq %r15, %rbx
shlq $0x4, %rbx
movq %r14, (%rax,%rbx)
movl $0x10, %edi
callq 0xa00d
movq 0x12685(%rip), %rcx     # 0x19ad0
movq %rax, 0x8(%rcx,%rbx)
movq 0x12679(%rip), %rax     # 0x19ad0
shlq $0x4, %r15
movq 0x8(%rax,%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/hash.c
// Function: rehash
static bool rehash(Htab *ht) {
	int i, j, size;
	int newsize, newused;
	Htab *newhtab;
	if (ht == fp) {
		if (fsize > 2 * fused)
			return FALSE;
		size = fsize;
	} else {
		if (vsize > 2 * vused)
			return FALSE;
		size = vsize;
	}
	newsize = 2 * size;
	newhtab = ealloc(newsize * sizeof(Htab));
	for (i = 0; i < newsize; i++)
		newhtab[i].name = NULL;
	for (i = newused = 0; i < size; i++)
		if (ht[i].name != NULL && ht[i].name != dead) {
			newused++;
			j = hash(ht[i].name, newsize);
			while (newhtab[j].name != NULL) {
				j++;
				j &= (newsize - 1);
			}
			newhtab[j].name = ht[i].name;
			newhtab[j].p = ht[i].p;
		}
	if (ht == fp) {
		fused = newused;
		fp = newhtab;
		fsize = newsize;
	} else {
		vused = newused;
		vp = newhtab;
		vsize = newsize;
	}
	efree(ht);
	return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq %rdi, 0x12655(%rip)     # 0x19ad0
je 0x748c
movl 0x12664(%rip), %r14d    # 0x19ae8
movl 0x12656(%rip), %eax     # 0x19ae0
jmp 0x7499
movl 0x12659(%rip), %r14d    # 0x19aec
movl 0x1264b(%rip), %eax     # 0x19ae4
addl %eax, %eax
cmpl %eax, %r14d
jle 0x74a7
xorl %eax, %eax
jmp 0x75fd
movq %rdi, (%rsp)
leal (%r14,%r14), %ebx
movslq %ebx, %rdi
shlq $0x4, %rdi
callq 0xa00d
movq %rax, %r15
testl %r14d, %r14d
jle 0x759e
movl %ebx, %eax
shlq $0x4, %rax
xorl %ecx, %ecx
movq %rbx, %rsi
movq (%rsp), %rdi
movq $0x0, (%r15,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x74d6
testl %r14d, %r14d
jle 0x75aa
leal -0x1(%rsi), %r13d
movl %r14d, %edx
xorl %ebp, %ebp
leaq 0x8927(%rip), %r8       # 0xfe27
xorl %r9d, %r9d
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rbp, %r14
shlq $0x4, %r14
movq (%rdi,%r14), %r12
testq %r12, %r12
sete %al
cmpq %r8, %r12
sete %cl
orb %al, %cl
jne 0x7590
movl %r9d, %ebx
movq %r12, %rdi
callq 0x7dfd
movl %eax, %ecx
shlq $0x4, %rcx
cmpq $0x0, (%r15,%rcx)
je 0x7564
movl %ebx, %r9d
incl %eax
andl %r13d, %eax
movq %rax, %rcx
shlq $0x4, %rcx
cmpq $0x0, (%r15,%rcx)
jne 0x7543
addq %r15, %rcx
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
jmp 0x7573
addq %r15, %rcx
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
movl %ebx, %r9d
movq 0x8(%rsp), %rdx
leaq 0x88a8(%rip), %r8       # 0xfe27
addq %rdi, %r14
incl %r9d
movq %r12, (%rcx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rcx)
incq %rbp
cmpq %rdx, %rbp
jne 0x750d
jmp 0x75ad
xorl %r9d, %r9d
movq %rbx, %rsi
movq (%rsp), %rdi
jmp 0x75ad
xorl %r9d, %r9d
cmpq %rdi, 0x1251c(%rip)     # 0x19ad0
leaq 0x12529(%rip), %rax     # 0x19ae4
leaq 0x1251e(%rip), %rcx     # 0x19ae0
cmoveq %rax, %rcx
leaq 0x12503(%rip), %rax     # 0x19ad0
leaq 0x12504(%rip), %rdx     # 0x19ad8
cmoveq %rax, %rdx
leaq 0x1250d(%rip), %rax     # 0x19aec
leaq 0x12502(%rip), %r8      # 0x19ae8
cmoveq %rax, %r8
movl %r9d, (%rcx)
movq %r15, (%rdx)
movl %esi, (%r8)
callq 0x9fde
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/hash.c
// Function: get_var_place
extern Variable *get_var_place(char *s, bool stack) {
	Variable *new;
	int h = varfind(s);

	env_dirty = TRUE;

	if (vp[h].name == NULL) {
		if (rehash(vp))
			h = varfind(s);
		vused++;
		vp[h].name = ecpy(s);
		vp[h].p = enew(Variable);
		((Variable *)vp[h].p)->n = NULL;
		return vp[h].p;
	} else {
		if (stack) {	/* increase the stack by 1 */
			new = enew(Variable);
			new->n = vp[h].p;
			return vp[h].p = new;
		} else {	/* trample the top of the stack */
			new = vp[h].p;
			efree(new->extdef);
			listfree(new->def);
			return new;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x124b8(%rip), %r14     # 0x19ad8
movl 0x124c2(%rip), %edx     # 0x19ae8
movq %r14, %rsi
callq 0x7333
movb $0x0, 0x124bb(%rip)     # 0x19af0
movl %eax, %r15d
movq %r15, %r12
shlq $0x4, %r12
cmpq $0x0, (%r14,%r12)
je 0x7675
testl %ebp, %ebp
je 0x76f9
movl $0x18, %edi
callq 0xa00d
movq %rax, %rbx
movq 0x12476(%rip), %rax     # 0x19ad8
movq 0x8(%rax,%r12), %rcx
movq %rcx, 0x10(%rbx)
movq %rbx, 0x8(%rax,%r12)
jmp 0x7711
movq %r14, %rdi
callq 0x7466
testl %eax, %eax
je 0x7699
movq 0x12450(%rip), %rsi     # 0x19ad8
movl 0x1245a(%rip), %edx     # 0x19ae8
movq %rbx, %rdi
callq 0x7333
movl %eax, %r15d
incl 0x12441(%rip)           # 0x19ae0
movq %rbx, %rdi
callq 0x30f0
leaq 0x1(%rax), %rdi
callq 0xa00d
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3070
movq 0x12413(%rip), %rax     # 0x19ad8
shlq $0x4, %r15
movq %r14, (%rax,%r15)
movl $0x18, %edi
callq 0xa00d
movq 0x123fa(%rip), %rcx     # 0x19ad8
movq %rax, 0x8(%rcx,%r15)
movq 0x123ee(%rip), %rax     # 0x19ad8
movq 0x8(%rax,%r15), %rbx
movq $0x0, 0x10(%rbx)
jmp 0x7711
addq %r12, %r14
movq 0x8(%r14), %rbx
movq 0x8(%rbx), %rdi
callq 0x9fde
movq (%rbx), %rdi
callq 0x9664
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/hash.c
// Function: delete_fn
extern void delete_fn(char *s) {
	int h = fnfind(s);
	if (fp[h].name == NULL)
		return; /* not found */
	env_dirty = TRUE;
	free_fn(fp[h].p);
	efree(fp[h].p);
	efree(fp[h].name);
	if (fp[(h+1)&(fsize-1)].name == NULL) {
		--fused;
		fp[h].name = NULL;
	} else {
		fp[h].name = dead;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x123a7(%rip), %rbx     # 0x19ad0
movl 0x123bd(%rip), %edx     # 0x19aec
movq %rbx, %rsi
callq 0x7333
movl %eax, %r15d
movq %r15, %r14
shlq $0x4, %r14
cmpq $0x0, (%rbx,%r14)
je 0x77be
movb $0x0, 0x123a1(%rip)     # 0x19af0
movq 0x8(%rbx,%r14), %rbx
movq (%rbx), %rdi
callq 0xc615
movq 0x8(%rbx), %rdi
callq 0x9fde
movq 0x12364(%rip), %rax     # 0x19ad0
movq 0x8(%rax,%r14), %rdi
callq 0x9fde
movq 0x12353(%rip), %rax     # 0x19ad0
movq (%rax,%r14), %rdi
callq 0x9fde
movq 0x12343(%rip), %rax     # 0x19ad0
incl %r15d
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addl 0x12351(%rip), %ecx     # 0x19aec
andl %r15d, %ecx
shlq $0x4, %rcx
cmpq $0x0, (%rax,%rcx)
je 0x77b2
leaq 0x8677(%rip), %rcx      # 0xfe27
jmp 0x77ba
decl 0x1232c(%rip)           # 0x19ae4
xorl %ecx, %ecx
movq %rcx, (%rax,%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/hash.c
// Function: delete_var
extern void delete_var(char *s, bool stack) {
	int h = varfind(s);
	Variable *v;
	if (vp[h].name == NULL)
		return; /* not found */
	env_dirty = TRUE;
	v = vp[h].p;
	efree(v->extdef);
	listfree(v->def);
	if (v->n != NULL) { /* This is the top of a stack */
		if (stack) { /* pop */
			vp[h].p = v->n;
			efree(v);
		} else { /* else just empty */
			v->extdef = NULL;
			v->def = NULL;
		}
	} else { /* needs to be removed from the hash table */
		efree(v);
		vp[h].p = NULL;
		efree(vp[h].name);
		if (vp[(h+1)&(vsize-1)].name == NULL) {
			--vused;
			vp[h].name = NULL;
		} else {
			vp[h].name = dead;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x12303(%rip), %r14     # 0x19ad8
movl 0x1230d(%rip), %edx     # 0x19ae8
movq %r14, %rsi
callq 0x7333
movl %eax, %r12d
movq %r12, %r15
shlq $0x4, %r15
cmpq $0x0, (%r14,%r15)
je 0x78b0
movb $0x0, 0x122f1(%rip)     # 0x19af0
movq 0x8(%r14,%r15), %r14
movq 0x8(%r14), %rdi
callq 0x9fde
movq (%r14), %rdi
callq 0x9664
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x7841
testl %ebx, %ebx
je 0x7899
movq 0x122af(%rip), %rcx     # 0x19ad8
movq %rax, 0x8(%rcx,%r15)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9fde
movq %r14, %rdi
callq 0x9fde
movq 0x12288(%rip), %rax     # 0x19ad8
movq $0x0, 0x8(%rax,%r15)
movq 0x12278(%rip), %rax     # 0x19ad8
movq (%rax,%r15), %rdi
callq 0x9fde
movq 0x12268(%rip), %rax     # 0x19ad8
incl %r12d
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addl 0x1226a(%rip), %ecx     # 0x19ae8
andl %r12d, %ecx
shlq $0x4, %rcx
cmpq $0x0, (%rax,%rcx)
je 0x78a2
leaq 0x8594(%rip), %rcx      # 0xfe27
movq %rcx, (%rax,%r15)
jmp 0x78b0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
jmp 0x78b0
decl 0x12238(%rip)           # 0x19ae0
movq $0x0, (%rax,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/hash.c
// Function: initenv
extern void initenv(char **envp) {
	int n;
	for (n = 0; envp[n] != NULL; n++)
		;
	n++; /* one for the null terminator */
	if (n < HASHSIZE)
		n = HASHSIZE;
	env = ealloc((envsize = 2 * n) * sizeof (char *));
	for (; *envp != NULL; envp++)
		if (strncmp(*envp, "fn_", conststrlen("fn_")) == 0) {
			if (!dashpee)
				fnassign_string(*envp);
		} else {
			if (!varassign_string(*envp)) /* add to bozo env */
				env[bozosize++] = *envp;
		}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x0, (%rbx,%rax,8)
leaq 0x1(%rax), %rax
jne 0x78c5
decl %eax
cmpl $0x40, %eax
movl $0x3f, %ecx
cmovael %eax, %ecx
leal 0x2(,%rcx,2), %eax
movl %eax, 0x1220a(%rip)     # 0x19af4
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0xa00d
movq %rax, 0x121fb(%rip)     # 0x19af8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7962
addq $0x8, %rbx
leaq 0x122d4(%rip), %r14     # 0x19be4
cmpb $0x66, (%rdi)
jne 0x792e
cmpb $0x6e, 0x1(%rdi)
jne 0x792e
cmpb $0x5f, 0x2(%rdi)
jne 0x792e
cmpl $0x0, (%r14)
jne 0x7956
callq 0x4f48
jmp 0x7956
callq 0xc881
testl %eax, %eax
jne 0x7956
movq -0x8(%rbx), %rax
movq 0x121b6(%rip), %rcx     # 0x19af8
movslq 0x121b7(%rip), %rdx     # 0x19b00
leal 0x1(%rdx), %esi
movl %esi, 0x121ae(%rip)     # 0x19b00
movq %rax, (%rcx,%rdx,8)
movq (%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x7910
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/hash.c
// Function: set_exportable
void set_exportable(char *s, bool b) {
	int i;
	for (i = 0; i < arraysize(maybeexport); ++i)
		if (maybeexport[i].flag != b && streq(s, maybeexport[i].name))
			maybeexport[i].flag = b;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movb $0x1, %bpl
xorl %r15d, %r15d
leaq 0x1197c(%rip), %r12     # 0x19300
shlq $0x4, %r15
cmpl %ebx, 0x8(%r15,%r12)
je 0x79ac
addq %r12, %r15
movb (%r14), %al
movq (%r15), %rsi
cmpb (%rsi), %al
jne 0x79ac
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
jne 0x79ac
movl %ebx, 0x8(%r15)
movl $0x1, %r15d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x7984
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/hash.c
// Function: whatare_all_vars
extern void whatare_all_vars(bool showfn, bool showvar) {
	int i;
	List *s;
	if (showvar)
		for (i = 0; i < vsize; i++)
			if (vp[i].name != NULL && (s = varlookup(vp[i].name)) != NULL)
				prettyprint_var(1, vp[i].name, s);
	if (showfn)
		for (i = 0; i < fsize; i++)
			if (fp[i].name != NULL && fp[i].name != dead)
				prettyprint_fn(1, fp[i].name, fnlookup(fp[i].name));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %esi, %esi
je 0x7c93
cmpl $0x0, 0x11ea2(%rip)     # 0x19ae8
jle 0x7c93
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x11e83(%rip), %rax     # 0x19ad8
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x7c80
callq 0xc9da
testq %rax, %rax
je 0x7c80
movq 0x11e69(%rip), %rcx     # 0x19ad8
movq (%rcx,%r14), %rsi
movl $0x1, %edi
movq %rax, %rdx
callq 0xcd8c
incq %r15
movslq 0x11e5e(%rip), %rax     # 0x19ae8
addq $0x10, %r14
cmpq %rax, %r15
jl 0x7c4e
testl %ebx, %ebx
setne %cl
movl 0x11e4e(%rip), %eax     # 0x19aec
testl %eax, %eax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x7d08
movq 0x11e1f(%rip), %rcx     # 0x19ad0
xorl %r14d, %r14d
leaq 0x816c(%rip), %r15      # 0xfe27
xorl %r12d, %r12d
movq (%rcx,%r14), %rbx
testq %rbx, %rbx
sete %dl
cmpq %r15, %rbx
sete %sil
orb %dl, %sil
jne 0x7cf9
movq %rbx, %rdi
callq 0x4f99
movl $0x1, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x50fa
movq 0x11ddd(%rip), %rcx     # 0x19ad0
movl 0x11df3(%rip), %eax     # 0x19aec
incq %r12
movslq %eax, %rdx
addq $0x10, %r14
cmpq %rdx, %r12
jl 0x7cbe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/hash.c
// Function: compl_name
extern char *compl_name(const char *text, int state, char **p, size_t count, ssize_t inc) {
	static char **n;
	static size_t i, len;
	char *name;

	if (!state) {
		n = p;
		i = 0;
		len = strlen(text);
	}
	for (name = NULL; name == NULL && i < count; i++, n += inc)
		if (*n != NULL && strncmp(*n, text, len) == 0)
			name = strdup(*n);
	return name;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
testl %esi, %esi
je 0x7d35
movq 0x11ddd(%rip), %rbp     # 0x19b10
jmp 0x7d58
movq %rdx, 0x11dcc(%rip)     # 0x19b08
movq $0x0, 0x11dc9(%rip) # 0x19b10
movq %r15, %rdi
callq 0x30f0
movq %rax, 0x11dc2(%rip)     # 0x19b18
xorl %ebp, %ebp
cmpq %r14, %rbp
jae 0x7dba
movq %r15, (%rsp)
movq 0x11da0(%rip), %r15     # 0x19b08
movq 0x11da9(%rip), %r12     # 0x19b18
shlq $0x3, %rbx
movq (%r15), %r13
testq %r13, %r13
je 0x7d8e
movq %r13, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0x3060
testl %eax, %eax
je 0x7d92
xorl %eax, %eax
jmp 0x7d9a
movq %r13, %rdi
callq 0x3350
incq %rbp
addq %rbx, %r15
testq %rax, %rax
jne 0x7daa
cmpq %r14, %rbp
jb 0x7d73
movq %rbp, 0x11d5f(%rip)     # 0x19b10
movq %r15, 0x11d50(%rip)     # 0x19b08
jmp 0x7dbc
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_O3/rakitzis[P]rc/hash.c
// Function: hash
static int hash(char *s, int size) {
	int c, n = 0;
	while (1) {
		ADV();
		n += (c << 17) ^ (c << 11) ^ (c << 5) ^ (c >> 1);
		ADV();
		n ^= (c << 14) + (c << 7) + (c << 4) + c;
		ADV();
		n ^= (~c << 11) | ((c << 3) ^ (c >> 1));
		ADV();
		n -= (c << 16) | (c << 9) | (c << 2) | (c & 3);
	}
	if (n < 0)
		n = ~n;
	return n & (size - 1); /* need power of 2 size */
}

// Assembly:
movl %esi, %eax
movb (%rdi), %dl
testb %dl, %dl
je 0x7e97
addq $0x4, %rdi
xorl %ecx, %ecx
movsbl %dl, %edx
movl %edx, %esi
shll $0x11, %esi
movl %edx, %r8d
shll $0xb, %r8d
xorl %esi, %r8d
movl %edx, %esi
shll $0x5, %esi
sarl %edx
xorl %esi, %edx
xorl %r8d, %edx
addl %ecx, %edx
movsbl -0x3(%rdi), %ecx
testl %ecx, %ecx
je 0x7e9b
imull $0x4091, %ecx, %esi     # imm = 0x4091
xorl %edx, %esi
movsbl -0x2(%rdi), %ecx
testl %ecx, %ecx
je 0x7e9f
movl %ecx, %edx
notl %edx
shll $0xb, %edx
leal (,%rcx,8), %r8d
sarl %ecx
xorl %r8d, %ecx
orl %edx, %ecx
xorl %esi, %ecx
movsbl -0x1(%rdi), %edx
testl %edx, %edx
je 0x7ea1
movl %edx, %esi
shll $0x10, %esi
movl %edx, %r8d
shll $0x9, %r8d
orl %esi, %r8d
leal (,%rdx,4), %esi
orl %r8d, %esi
andl $0x3, %edx
orl %esi, %edx
subl %edx, %ecx
movb (%rdi), %dl
addq $0x4, %rdi
testb %dl, %dl
jne 0x7e0f
jmp 0x7ea1
xorl %ecx, %ecx
jmp 0x7ea1
movl %edx, %ecx
jmp 0x7ea1
movl %esi, %ecx
movl %ecx, %edx
sarl $0x1f, %edx
xorl %ecx, %edx
decl %eax
andl %edx, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/heredoc.c
// Function: qdoc
extern int qdoc(Node *name, Node *n) {
	Hq *new, **prev;
	if (name->type != nWord) {
		yyerror("eof-marker not a single literal word");
		skiptonl();
		return FALSE;
	}
	for (prev = &hq; (new = *prev) != NULL; prev = &new->n)
		;
	*prev = new = nnew(Hq);
	new->name = name->u[0].s;
	new->quoted = name->u[2].i;
	new->doc = n;
	new->n = NULL;
	return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1e, (%rdi)
jne 0x81fc
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x11961(%rip), %rax     # 0x19b20
movq %rax, %r15
movq (%rax), %rcx
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
jne 0x81bf
movl $0x20, %edi
callq 0x9e80
movq %rax, (%r15)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movl 0x18(%r14), %ecx
movl %ecx, 0x18(%rax)
movq %rbx, (%rax)
movq $0x0, 0x10(%rax)
movl $0x1, %eax
jmp 0x820f
leaq 0x75c2(%rip), %rdi      # 0xf7c5
callq 0x952f
callq 0x8498
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: gchar
extern int gchar() {
	int c;

	if (istack->ungetcount)
		return lastchar = istack->ungetbuf[--istack->ungetcount];

	while ((c = (*istack->gchar)()) == '\0')
		pr_error("warning: null character ignored", 0);

	return c;
}

// Assembly:
pushq %rbx
movq 0x118d4(%rip), %rax     # 0x19b30
movslq 0x14(%rax), %rcx
testq %rcx, %rcx
je 0x8278
leaq -0x1(%rcx), %rdx
movl %edx, 0x14(%rax)
movl 0x2c(%rax,%rcx,4), %eax
movl %eax, 0x118c2(%rip)     # 0x19b38
jmp 0x829e
callq *0x38(%rax)
testl %eax, %eax
jne 0x829e
leaq 0x759e(%rip), %rbx      # 0xf824
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc694
movq 0x11899(%rip), %rax     # 0x19b30
callq *0x38(%rax)
testl %eax, %eax
je 0x8286
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: pushfd
extern void pushfd(int fd) {
	pushcommon();
	save_lineno = TRUE;
	istack->fd = fd;
	lineno = 1;
	if (editing && interactive && isatty(fd)) {
		istack->t = iEdit;
		istack->gchar = editgchar;
		istack->cookie = edit_begin(fd);
	} else {
		istack->t = iFd;
		istack->gchar = fdgchar;
		inbuf = ealloc(BUFSIZE);
	}
}

// Assembly:
pushq %rbx
movl %edi, %ebx
callq 0x876d
movl $0x1, %eax
movl %eax, 0x11020(%rip)     # 0x19320
movq 0x11829(%rip), %rcx     # 0x19b30
movl %ebx, 0x8(%rcx)
leaq 0x11887(%rip), %rdx     # 0x19b98
movl %eax, (%rdx)
leaq 0x1145a(%rip), %rax     # 0x19774
cmpl $0x0, (%rax)
je 0x8363
leaq 0x118ae(%rip), %rax     # 0x19bd4
cmpl $0x0, (%rax)
je 0x8363
movl %ebx, %edi
callq 0x3090
movq 0x117f7(%rip), %rcx     # 0x19b30
testl %eax, %eax
je 0x8363
movl $0x2, 0x4(%rcx)
leaq 0x4d2(%rip), %rax       # 0x881d
movq %rax, 0x38(%rcx)
movl %ebx, %edi
callq 0x43f0
movq 0x117d3(%rip), %rcx     # 0x19b30
movq %rax, 0x28(%rcx)
jmp 0x8386
movl $0x0, 0x4(%rcx)
leaq 0x619(%rip), %rax       # 0x898a
movq %rax, 0x38(%rcx)
movl $0x100, %edi            # imm = 0x100
callq 0xa00d
movq %rax, 0x117ca(%rip)     # 0x19b50
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: pushstring
extern void pushstring(char **a, bool save) {
	pushcommon();
	istack->t = iString;
	save_lineno = save;
	inbuf = mprint("%A", a);
	istack->gchar = stringgchar;
	if (save_lineno)
		lineno = 1;
	else
		--lineno;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x876d
movq 0x11793(%rip), %rax     # 0x19b30
movl $0x1, %ebp
movl %ebp, 0x4(%rax)
movl %ebx, 0x10f75(%rip)     # 0x19320
leaq 0x6d41(%rip), %rdi      # 0xf0f3
movq %r14, %rsi
xorl %eax, %eax
callq 0xb09e
movq %rax, 0x1178d(%rip)     # 0x19b50
movq 0x11766(%rip), %rax     # 0x19b30
leaq 0x702(%rip), %rcx       # 0x8ad3
movq %rcx, 0x38(%rax)
leaq 0x117bc(%rip), %rax     # 0x19b98
movl (%rax), %ecx
decl %ecx
cmpl $0x0, 0x10f39(%rip)     # 0x19320
cmovnel %ebp, %ecx
movl %ecx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: popinput
extern void popinput() {
	if (istack->t == iEdit)
		edit_end(istack->cookie);
	if (istack->t == iFd || istack->t == iEdit)
		close(istack->fd);
	efree(inbuf);
	--istack;
	lastchar = istack->last;
	inbuf = istack->ibuf;
	chars_out = istack->index;
	chars_in = istack->read;
	if (save_lineno)
		lineno = istack->lineno;
	else
		lineno++;
	save_lineno = istack->saved;
}

// Assembly:
pushq %rax
movq 0x11737(%rip), %rax     # 0x19b30
movl 0x4(%rax), %ecx
cmpl $0x2, %ecx
jne 0x8414
movq 0x28(%rax), %rdi
callq 0x4470
movq 0x1171f(%rip), %rax     # 0x19b30
movl 0x4(%rax), %ecx
testl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
jne 0x8424
movl 0x8(%rax), %edi
callq 0x3170
movq 0x11725(%rip), %rdi     # 0x19b50
callq 0x9fde
movq 0x116f9(%rip), %rcx     # 0x19b30
leaq -0x40(%rcx), %rax
movq %rax, 0x116ee(%rip)     # 0x19b30
movl -0x24(%rcx), %edx
movl %edx, 0x116ed(%rip)     # 0x19b38
movq -0x20(%rcx), %rdx
movq %rdx, 0x116fa(%rip)     # 0x19b50
movslq -0x34(%rcx), %rdx
movq %rdx, 0x116f7(%rip)     # 0x19b58
movslq -0x30(%rcx), %rdx
movq %rdx, 0x116f4(%rip)     # 0x19b60
cmpl $0x0, 0x10ead(%rip)     # 0x19320
je 0x847a
movl -0x28(%rcx), %ecx
jmp 0x8485
leaq 0x11717(%rip), %rcx     # 0x19b98
movl (%rcx), %ecx
incl %ecx
leaq 0x1170c(%rip), %rdx     # 0x19b98
movl %ecx, (%rdx)
movl (%rax), %eax
movl %eax, 0x10e8a(%rip)     # 0x19320
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: skiptonl
extern void skiptonl() {
	int c;
	if (lastchar == '\n' || lastchar == EOF)
		return;
	while ((c = gchar()) != '\n' && c != EOF)
		; /* skip to newline */
	if (c == EOF)
		ugchar(c);
}

// Assembly:
pushq %rax
movl 0x11699(%rip), %eax     # 0x19b38
cmpl $-0x1, %eax
je 0x84a9
cmpl $0xa, %eax
jne 0x84ab
popq %rax
retq
callq 0x8254
cmpl $0xa, %eax
je 0x84a9
cmpl $-0x1, %eax
jne 0x84ab
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
popq %rax
jmp 0x8218
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: parseline
extern Node *parseline(char *extdef) {
	bool i = interactive;
	char *in[2];
	Node *fun;
	in[0] = extdef;
	in[1] = NULL;
	interactive = FALSE;
	pushstring(in, TRUE);
	fun = doit(FALSE);
	interactive = i;
	return fun;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x1152a(%rip), %rbx     # 0x19bd4
movl (%rbx), %ebp
movq %rsp, %rax
movq %rdi, (%rax)
movq $0x0, 0x8(%rax)
movl $0x0, (%rbx)
movq %rax, %rdi
movl $0x1, %esi
callq 0x8388
xorl %edi, %edi
callq 0x84c5
movl %ebp, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: closefds
extern void closefds() {
	Input *i;
	for (i = istack; i != itop; --i)	/* close open scripts */
		if (i->t == iFd && i->fd > 2) {
			close(i->fd);
			i->fd = -1;
		}
}

// Assembly:
pushq %rbx
movq 0x1144b(%rip), %rbx     # 0x19b30
movq 0x1145c(%rip), %rax     # 0x19b48
cmpq %rax, %rbx
je 0x8718
cmpl $0x0, 0x4(%rbx)
jne 0x8712
movl 0x8(%rbx), %edi
cmpl $0x3, %edi
jl 0x8712
callq 0x3170
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
movq 0x11436(%rip), %rax     # 0x19b48
addq $-0x40, %rbx
jmp 0x86ec
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: nextline
extern void nextline() {
	lineno++;
	if (interactive) {
		if (istack->t == iFd)
			fprint(2, "%s", prompt2);
		else if (istack->t == iEdit)
			edit_prompt(istack->cookie, prompt2);
	}
}

// Assembly:
leaq 0x11477(%rip), %rax     # 0x19b98
incl (%rax)
leaq 0x114aa(%rip), %rax     # 0x19bd4
cmpl $0x0, (%rax)
je 0x875c
movq 0x113fa(%rip), %rax     # 0x19b30
movl 0x4(%rax), %ecx
cmpl $0x2, %ecx
je 0x875d
testl %ecx, %ecx
jne 0x875c
movq 0x1142f(%rip), %rdx     # 0x19b78
leaq 0x6e22(%rip), %rsi      # 0xf572
movl $0x2, %edi
xorl %eax, %eax
jmp 0xaf8c
retq
movq 0x28(%rax), %rdi
movq 0x11410(%rip), %rsi     # 0x19b78
jmp 0x4430
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: pushcommon
static void pushcommon() {
	size_t idiff;
	istack->index = chars_out;
	istack->read = chars_in;
	istack->ibuf = inbuf;
	istack->lineno = lineno;
	istack->saved = save_lineno;
	istack->last = lastchar;
	istack++;
	idiff = istack - itop;
	if (idiff >= istacksize / sizeof (Input)) {
		itop = erealloc(itop, istacksize *= 2);
		istack = itop + idiff;
	}
	chars_out = 0;
	chars_in = 0;
	istack->ungetcount = 0;
}

// Assembly:
pushq %rbx
movl 0x113e4(%rip), %ecx     # 0x19b58
movq 0x113b5(%rip), %rax     # 0x19b30
movl %ecx, 0xc(%rax)
movl 0x113dc(%rip), %ecx     # 0x19b60
movl %ecx, 0x10(%rax)
movq 0x113c2(%rip), %rcx     # 0x19b50
movq %rcx, 0x20(%rax)
leaq 0x113ff(%rip), %rcx     # 0x19b98
movl (%rcx), %ecx
movl %ecx, 0x18(%rax)
movl 0x10b7c(%rip), %ecx     # 0x19320
movl %ecx, (%rax)
movl 0x1138c(%rip), %ecx     # 0x19b38
movl %ecx, 0x1c(%rax)
addq $0x40, %rax
movq %rax, 0x11376(%rip)     # 0x19b30
movq 0x11387(%rip), %rdi     # 0x19b48
movq %rax, %rbx
subq %rdi, %rbx
movq %rbx, %rcx
sarq $0x6, %rcx
movq 0x1136b(%rip), %rsi     # 0x19b40
movq %rsi, %rdx
shrq $0x6, %rdx
cmpq %rdx, %rcx
jb 0x8804
addq %rsi, %rsi
movq %rsi, 0x11355(%rip)     # 0x19b40
callq 0xa05a
movq %rax, 0x11351(%rip)     # 0x19b48
addq %rax, %rbx
movq %rbx, 0x1132f(%rip)     # 0x19b30
movq %rbx, %rax
xorl %ecx, %ecx
movq %rcx, 0x1134b(%rip)     # 0x19b58
movq %rcx, 0x1134c(%rip)     # 0x19b60
movl $0x0, 0x14(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: editgchar
static int editgchar() {
	if (chars_out >= chars_in) { /* replenish empty buffer */
		edit_free(istack->cookie);
		inbuf = edit_alloc(istack->cookie, &chars_in);
		if (inbuf == NULL) {
			chars_in = 0;
			fprint(2, "exit\n");
			return lastchar = EOF;
		}

		chars_out = 0;
		if (dashvee)
			writeall(2, inbuf, chars_in);
		history();
	}

	return lastchar = inbuf[chars_out++];
}

// Assembly:
pushq %rax
movq 0x11333(%rip), %rax     # 0x19b58
cmpq 0x11334(%rip), %rax     # 0x19b60
jb 0x8898
movq 0x112fb(%rip), %rax     # 0x19b30
movq 0x28(%rax), %rdi
callq 0x4450
movq 0x112eb(%rip), %rax     # 0x19b30
movq 0x28(%rax), %rdi
leaq 0x11310(%rip), %rsi     # 0x19b60
callq 0x4410
movq %rax, 0x112f4(%rip)     # 0x19b50
testq %rax, %rax
je 0x88b6
movq $0x0, 0x112ec(%rip) # 0x19b58
leaq 0x11379(%rip), %rcx     # 0x19bec
cmpl $0x0, (%rcx)
je 0x888c
movq 0x112e1(%rip), %rdx     # 0x19b60
movl $0x2, %edi
movq %rax, %rsi
callq 0xbfdc
callq 0x88db
movq 0x112c0(%rip), %rax     # 0x19b58
movq 0x112b1(%rip), %rcx     # 0x19b50
leaq 0x1(%rax), %rdx
movq %rdx, 0x112ae(%rip)     # 0x19b58
movsbl (%rcx,%rax), %eax
movl %eax, 0x11284(%rip)     # 0x19b38
popq %rcx
retq
movq $0x0, 0x1129f(%rip) # 0x19b60
leaq 0x6f80(%rip), %rsi      # 0xf848
movl $0x2, %edi
xorl %eax, %eax
callq 0xaf8c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x88ae
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: history
static void history() {
	List *hist;
	size_t a;

	if (!interactive || (hist = varlookup("history")) == NULL)
		return;

	for (a = 0; a < chars_in; a++) {
		char c = inbuf[a];

		/* skip empty lines and comments */
		if (c == '#' || c == '\n')
			break;

		/* line matches [ \t]*[^#\n] so it's ok to write out */
		if (c != ' ' && c != '\t') {
			char *name = hist->w;
			int fd = rc_open(name, rAppend);
			if (fd < 0)
				uerror(name);
			else {
				writeall(fd, inbuf, chars_in);
				close(fd);
			}
			break;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x112ee(%rip), %rax     # 0x19bd4
cmpl $0x0, (%rax)
je 0x8935
leaq 0x6f5c(%rip), %rdi      # 0xf84e
callq 0xc9da
testq %rax, %rax
je 0x8935
movq 0x1125d(%rip), %rcx     # 0x19b60
testq %rcx, %rcx
je 0x8935
movq 0x11241(%rip), %rdx     # 0x19b50
xorl %esi, %esi
movzbl (%rdx,%rsi), %edi
cmpl $0x1f, %edi
jg 0x8921
cmpl $0x9, %edi
je 0x8926
jmp 0x893d
cmpl $0x20, %edi
jne 0x8930
incq %rsi
cmpq %rsi, %rcx
jne 0x8911
jmp 0x8935
cmpl $0x23, %edi
jne 0x8942
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0xa, %edi
je 0x8935
movq (%rax), %r14
movq %r14, %rdi
movl $0x2, %esi
callq 0xa08c
testl %eax, %eax
js 0x897b
movl %eax, %ebx
movq 0x111f1(%rip), %rsi     # 0x19b50
movq 0x111fa(%rip), %rdx     # 0x19b60
movl %eax, %edi
callq 0xbfdc
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3170
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc6dd
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/input.c
// Function: fdgchar
static int fdgchar() {
	if (chars_out >= chars_in) { /* replenish empty buffer */
		ssize_t r;
		do {
			r = rc_read(istack->fd, inbuf, BUFSIZE);
			sigchk();
			if (r == -1)
				switch (errno) {
				case EAGAIN:
					if (!makeblocking(istack->fd))
						panic("not O_NONBLOCK");
					errno = EINTR;
					break;
				case EIO:
					if (makesamepgrp(istack->fd))
						errno = EINTR;
					else
						errno = EIO;
					break;
				}
		} while (r < 0 && errno == EINTR);
		if (r < 0) {
			uerror("read");
			rc_raise(eError);
		}
		chars_in = (size_t) r;
		if (chars_in == 0)
			return lastchar = EOF;
		chars_out = 0;
		if (dashvee)
			writeall(2, inbuf, chars_in);
		history();
	}

	return lastchar = inbuf[chars_out++];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x111c2(%rip), %rax     # 0x19b58
cmpq 0x111c3(%rip), %rax     # 0x19b60
jb 0x8a9e
leaq 0x6eac(%rip), %r14      # 0xf856
movq 0x1117f(%rip), %rax     # 0x19b30
movl 0x8(%rax), %edi
movq 0x11195(%rip), %rsi     # 0x19b50
movl $0x100, %edx            # imm = 0x100
callq 0x31c0
movq %rax, %rbx
callq 0xb9f9
cmpq $-0x1, %rbx
je 0x89e5
testq %rbx, %rbx
jns 0x8a5e
callq 0x3040
movl (%rax), %eax
jmp 0x8a39
callq 0x3040
movq %rax, %r15
movl (%rax), %eax
cmpl $0x5, %eax
je 0x8a16
cmpl $0xb, %eax
jne 0x8a39
movq 0x11130(%rip), %rax     # 0x19b30
movl 0x8(%rax), %edi
callq 0xa0c6
testl %eax, %eax
jne 0x8a2d
movq %r14, %rdi
callq 0xc72e
jmp 0x8a2d
movq 0x11113(%rip), %rax     # 0x19b30
movl 0x8(%rax), %edi
callq 0xa13a
testl %eax, %eax
je 0x8ac7
movl $0x4, (%r15)
movl $0x4, %eax
cmpl $0x4, %eax
je 0x89aa
leaq 0x6d3f(%rip), %rdi      # 0xf788
callq 0xc6dd
xorl %edi, %edi
callq 0x4566
movq %rbx, 0x11104(%rip)     # 0x19b60
jmp 0x8a67
movq %rbx, 0x110fb(%rip)     # 0x19b60
je 0x8ac0
movq $0x0, 0x110e6(%rip) # 0x19b58
leaq 0x11173(%rip), %rax     # 0x19bec
cmpl $0x0, (%rax)
je 0x8a92
movq 0x110cb(%rip), %rsi     # 0x19b50
movl $0x2, %edi
movq %rbx, %rdx
callq 0xbfdc
callq 0x88db
movq 0x110ba(%rip), %rax     # 0x19b58
movq 0x110ab(%rip), %rcx     # 0x19b50
leaq 0x1(%rax), %rdx
movq %rdx, 0x110a8(%rip)     # 0x19b58
movsbl (%rcx,%rax), %eax
movl %eax, 0x1107e(%rip)     # 0x19b38
popq %rbx
popq %r14
popq %r15
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x8ab4
movl $0x5, (%r15)
jmp 0x8a42
// File: /workspace/github_c_makefile_star2_O3/rakitzis[P]rc/lex.c
// Function: getpair
static void getpair(int c) {
	int n;
	fd_left = fd_right = UNSET;
	if (c != '[') {
		ugchar(c);
		return;
	}
	if ((unsigned int) (n = gchar() - '0') > 9) {
		scanerror("expected digit after '['");
		return;
	}
	while ((unsigned int) (c = gchar() - '0') <= 9)
		n = n * 10 + c;
	fd_left = n;
	c += '0';
	switch (c) {
	default:
		scanerror("expected '=' or ']' after digit");
		return;
	case ']':
		return;
	case '=':
		if ((unsigned int) (n = gchar() - '0') > 9) {
			if (n != ']' - '0') {
				scanerror("expected digit or ']' after '='");
				return;
			}
			fd_right = CLOSED;
		} else {
			while ((unsigned int) (c = gchar() - '0') <= 9)
				n = n * 10 + c;
			if (c != ']' - '0') {
				scanerror("expected ']' after digit");
				return;
			}
			fd_right = n;
		}
	}
}

// Assembly:
movl $0xfffffff7, %eax       # imm = 0xFFFFFFF7
movl %eax, 0x1075c(%rip)     # 0x19ba4
movl %eax, 0x10752(%rip)     # 0x19ba0
cmpl $0x5b, %edi
jne 0x8218
pushq %rbx
callq 0x8254
movl %eax, %ebx
addl $-0x30, %ebx
cmpl $0x9, %ebx
jbe 0x9478
callq 0x8498
leaq 0x68d9(%rip), %rdi      # 0xfd4c
jmp 0x951a
callq 0x8254
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0x9498
leal (%rbx,%rbx,4), %eax
leal (%rcx,%rax,2), %ebx
callq 0x8254
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x9485
movl %ebx, 0x10702(%rip)     # 0x19ba0
cmpl $0x3d, %eax
je 0x94ba
cmpl $0x5d, %eax
je 0x952d
callq 0x8498
leaq 0x68ad(%rip), %rdi      # 0xfd65
jmp 0x951a
callq 0x8254
movl %eax, %ebx
addl $-0x30, %ebx
cmpl $0x9, %ebx
jbe 0x94e1
cmpl $0x2d, %ebx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x9506
callq 0x8498
leaq 0x68a6(%rip), %rdi      # 0xfd85
jmp 0x951a
callq 0x8254
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x9501
leal (%rbx,%rbx,4), %ecx
leal (%rax,%rcx,2), %ebx
callq 0x8254
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x94ee
cmpl $0x2d, %eax
jne 0x950e
movl %ebx, 0x10698(%rip)     # 0x19ba4
jmp 0x952d
callq 0x8498
leaq 0x688b(%rip), %rdi      # 0xfda5
callq 0x952f
movb $0x1, %al
movb %al, 0x10681(%rip)      # 0x19ba8
movb %al, 0x10663(%rip)      # 0x19b90
popq %rbx
retq