LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: find_function
static BFct *
find_function(char *s)
{	BFct *f;

	for (f = fcts; f; f = f->nxt)
		if (strcmp(f->fnm, s) == 0)
			return f;
	return (BFct *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x7e2d(%rip), %rax      # 0xb3b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x35bd
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x35ad
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x35c5
jmp 0x35af
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3587
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: find_roots
void
find_roots(void)
{	BFct *f, *g;
	BSym *h;
	int ncalls;

	for (f = fcts; f; f = f->nxt)
	{	if (strcmp(f->fnm, "_global_") == 0)
			continue;
		ncalls = 0;
		for (g = fcts; g; g = g->nxt)
		{	if (g != f)
			{	for (h = g->calls; h; h = h->nxt)
				{	if (strcmp(h->s, f->fnm) == 0)
					{	ncalls++;
						break;
				}	}
				if (ncalls > 0)
				{	break;
		}	}	}
		if (ncalls == 0 && indirect_calls(f->fnm) == 0)
			printf("root: %s\n", f->fnm);
	}
	fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x7dd1(%rip), %rax      # 0xb3b0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x36cd
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3d1f(%rip), %rsi      # 0x731b
callq 0x10c0
cmpl $0x0, %eax
jne 0x360b
jmp 0x36bc
movl $0x0, -0x1c(%rbp)
movq 0x7d97(%rip), %rax      # 0xb3b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x368e
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x367e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3674
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x3664
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3674
jmp 0x3666
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x363a
cmpl $0x0, -0x1c(%rbp)
jle 0x367c
jmp 0x368e
jmp 0x367e
jmp 0x3680
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x361d
cmpl $0x0, -0x1c(%rbp)
jne 0x36ba
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x25a0
cmpl $0x0, %eax
jne 0x36ba
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x4171(%rip), %rdi      # 0x7824
movb $0x0, %al
callq 0x1080
jmp 0x36bc
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x35e3
movq 0x7904(%rip), %rax      # 0xafd8
movq (%rax), %rdi
callq 0x10f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: set_select
void
set_select(char *name, char *loc, int stat)
{	Var *v;

	for (v = stack->sels; v; v = v->nxt)
		if (strcmp(v->s, name) == 0)
		{	v->sel  |= 1;
			v->stat |= stat;
			if (debug) printf("	>Select old '%s' - stat %d\n", v->s, v->stat);
			return;
		}
	v = new_var(name);
	v->loc = new_str(loc);
	v->sel = 1;
	if (debug) printf("	>Select new '%s', stat %d\n", v->s, stat);
	v->stat = stat;
	v->nxt = stack->sels;
	stack->sels = v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x7cae(%rip), %rax      # 0xb3b8
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3782
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x3772
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
orl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
cmpl $0x0, 0x7c71(%rip)      # 0xb3c0
je 0x376d
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x14(%rax), %edx
leaq 0x40c8(%rip), %rdi      # 0x782e
movb $0x0, %al
callq 0x1080
jmp 0x37fb
jmp 0x3774
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3712
movq -0x8(%rbp), %rdi
callq 0x3810
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x10(%rax)
cmpl $0x0, 0x7c0b(%rip)      # 0xb3c0
je 0x37cf
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
leaq 0x4083(%rip), %rdi      # 0x784b
movb $0x0, %al
callq 0x1080
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq 0x7bd8(%rip), %rax      # 0xb3b8
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq 0x7bc1(%rip), %rax      # 0xb3b8
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: new_var
static Var *
new_var(char *s)
{	Var *f;

	if (free_var)
	{	f = free_var;
		free_var = f->nxt;
		memset(f, 0, sizeof(Var));
	} else
		f = (Var *) emalloc(sizeof(Var));

	f->s = new_str(s);
	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x8c04(%rip)      # 0xc428
je 0x3852
movq 0x8bfb(%rip), %rax      # 0xc428
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8be8(%rip)      # 0xc428
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10a0
jmp 0x3860
movl $0x28, %edi
callq 0x1270
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: mark_select
int
mark_select(int x)
{	Var *v;
	int cnt = 0;

	for (v = stack->sels; v; v = v->nxt)
		if (v->sel)
		{	v->mark = x;
			cnt++;
			if (debug) printf("\tset mark %s to %d\n", v->s, x);
		}
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x14(%rbp)
movq 0x7b1f(%rip), %rax      # 0xb3b8
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x38f8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x38e8
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, 0x7af4(%rip)      # 0xb3c0
je 0x38e6
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x4(%rbp), %edx
leaq 0x3f88(%rip), %rdi      # 0x7867
movb $0x0, %al
callq 0x1080
jmp 0x38e8
jmp 0x38ea
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x38a1
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: run_check
void
run_check(void)
{	BFct *f;

	if (!fcts) return;

	stack = &init;
	memset(stack, 0, sizeof(Stack));
	ini_prop();
	add_glob_defs();

	f = find_function("_global_");	/* start execution with global defs */
	if (f)
	{	if (debug) printf("	CHECK %s\n", f->fnm);
		do_fct_call(f, (Node *) 0);
	} else
		printf("uno:global: internal error, no _global_\n");
	if (verbose)
	printf("uno:global: %d scenarios reported in property check\n", ErrCnt-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x7a90(%rip)      # 0xb3b0
jne 0x3927
jmp 0x39c7
leaq 0x7a9a(%rip), %rax      # 0xb3c8
movq %rax, 0x7a83(%rip)      # 0xb3b8
movq 0x7a7c(%rip), %rdi      # 0xb3b8
xorl %esi, %esi
movl $0x40, %edx
callq 0x10a0
callq 0x39d0
callq 0x2410
leaq 0x39c2(%rip), %rdi      # 0x731b
callq 0x3570
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3996
cmpl $0x0, 0x7a50(%rip)      # 0xb3c0
je 0x3987
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x3efb(%rip), %rdi      # 0x787b
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3aa0
jmp 0x39a4
leaq 0x3ee9(%rip), %rdi      # 0x7886
movb $0x0, %al
callq 0x1080
leaq 0x78b5(%rip), %rax      # 0xb260
cmpl $0x0, (%rax)
je 0x39c7
movl 0x774a(%rip), %esi      # 0xb100
subl $0x1, %esi
leaq 0x3eef(%rip), %rdi      # 0x78af
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: ini_prop
static void
ini_prop(void)
{	Node *n;

	prop_fct = find_function(glob_prop);
	if (!prop_fct)
	{	if (verbose)
			printf("uno:global: using builtin property check\n");
		builtin_check();
		prop_fct = find_function(glob_prop);
		if (!prop_fct)
		{	fprintf(stderr, "uno:global: error, could not load builtin property\n");
			exit(1);
		}
	}
	n = find_node(prop_fct, 0);
	if (n && n->succ)
		prop_start = n->succ->to;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x7729(%rip), %rdi      # 0xb108
callq 0x3570
movq %rax, 0x8a45(%rip)      # 0xc430
cmpq $0x0, 0x8a3d(%rip)      # 0xc430
jne 0x3a55
leaq 0x7864(%rip), %rax      # 0xb260
cmpl $0x0, (%rax)
je 0x3a0f
leaq 0x3f73(%rip), %rdi      # 0x797b
movb $0x0, %al
callq 0x1080
callq 0x4230
movq 0x76ed(%rip), %rdi      # 0xb108
callq 0x3570
movq %rax, 0x8a09(%rip)      # 0xc430
cmpq $0x0, 0x8a01(%rip)      # 0xc430
jne 0x3a53
movq 0x75c0(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x3f63(%rip), %rsi      # 0x79a5
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1140
jmp 0x3a55
movq 0x89d4(%rip), %rdi      # 0xc430
xorl %esi, %esi
callq 0x4290
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3a8b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3a8b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, 0x89ad(%rip)      # 0xc438
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: add_arc
static Arc *
add_arc(BFct *f, int from, int to)
{	Arc *a;
	Node *n;

	a = (Arc *) emalloc(sizeof(Arc));
	n = find_node(f, from);
	a->to   = find_node(f, to);
	a->nxt  = n->succ;
	n->succ = a;

	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x18, %edi
callq 0x1270
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4290
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x4290
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: builtin_check
static void
builtin_check(void)
{	int i;

	add_fct(glob_prop);
	for (i = 0; BuiltinCheck[i]; i++)
		handle_fct(BuiltinCheck[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x6ec9(%rip), %rdi      # 0xb108
callq 0x3330
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x6eba(%rip), %rax      # 0xb110
cmpq $0x0, (%rax,%rcx,8)
je 0x427c
movslq -0x4(%rbp), %rcx
leaq 0x6ea8(%rip), %rax      # 0xb110
movq (%rax,%rcx,8), %rdi
callq 0x3d00
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x424b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: find_node
static Node *
find_node(BFct *f, int id)
{	Node *n;

	for (n = f->root; n; n = n->nxt)
		if (n->nid == id)
			break;

	if (!n)
	{	n = (Node *) emalloc(sizeof(Node));
		n->nid  = id;
		n->nxt  = f->root;
		f->root = n;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x42cf
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x42bf
jmp 0x42cf
jmp 0x42c1
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x42ab
cmpq $0x0, -0x18(%rbp)
jne 0x4309
movl $0x28, %edi
callq 0x1270
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: fct_in_lab
static BFct *
fct_in_lab(char *s)
{	BFct *f = (BFct *) 0;
	char *t;

	for (t = s+2; *t != '\0' && *t != ' '; t++)
		;

	if (*t == ' ')
	{	*t = '\0';
		f = find_function(s+2); /* 2 char prefix */
		*t = ' ';
	}
	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x4e91
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x4e9a
jmp 0x4eaa
jmp 0x4e9c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4e70
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x4ed5
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
callq 0x3570
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movb $0x20, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: list_sel
static void
list_sel(void)
{	Var *v;

	for (v = stack->sels; v; v = v->nxt)
		if (v->sel)
		printf("%3d:\t\tvars: %s (%s), mark %d, selection %d\n",
			depth, v->s, v->loc, v->mark, v->sel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x64c9(%rip), %rax      # 0xb3b8
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4f4b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x4f3b
movl 0x7542(%rip), %esi      # 0xc450
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
leaq 0x3235(%rip), %rdi      # 0x8169
movb $0x0, %al
callq 0x1080
jmp 0x4f3d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4ef7
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: rev_release
static Var *
rev_release(Var *v)
{	int n;

	if (!v) return (Var *) 0;
	rev_release(v->nxt);

	n = strlen(v->s);
	if (n > 0 && n < 512)
	{	Pool *p;
		if (free_pool)
		{	p = free_pool;
			free_pool = p->nxt;
			memset(p, 0, sizeof(Pool));
		} else
			p = (Pool *) emalloc(sizeof(Pool));
		p->s = v->s;
		p->nxt = pool[n];
		pool[n] = p;
	}
	v->s = (char *) 0;

	v->nxt = free_var;
	free_var = v;

	return (Var *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4f80
movq $0x0, -0x8(%rbp)
jmp 0x5058
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4f60
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1060
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x502b
cmpl $0x200, -0x14(%rbp)     # imm = 0x200
jge 0x502b
cmpq $0x0, 0x7469(%rip)      # 0xc420
je 0x4fe5
movq 0x7460(%rip), %rax      # 0xc420
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x744d(%rip)      # 0xc420
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10a0
jmp 0x4ff3
movl $0x10, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movslq -0x14(%rbp), %rcx
leaq 0x6414(%rip), %rax      # 0xb420
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdx
movslq -0x14(%rbp), %rcx
leaq 0x63f9(%rip), %rax      # 0xb420
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq 0x73eb(%rip), %rcx      # 0xc428
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x73d8(%rip)      # 0xc428
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: rev_symrel
static BSym *
rev_symrel(BSym *s)
{	int n;

	if (!s) return (BSym *) 0;
	rev_symrel(s->nxt);

	n = strlen(s->s);
	if (n > 0 && n < 512)
	{	Pool *p;
		if (free_pool)
		{	p = free_pool;
			free_pool = p->nxt;
			memset(p, 0, sizeof(Pool));
		} else
			p = (Pool *) emalloc(sizeof(Pool));
		p->s = s->s;
		p->nxt = pool[n];
		pool[n] = p;
	}
	s->s = (char *) 0;

	s->nxt = free_sym;
	free_sym = s;

	return (BSym *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5090
movq $0x0, -0x8(%rbp)
jmp 0x5168
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5070
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1060
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x513b
cmpl $0x200, -0x14(%rbp)     # imm = 0x200
jge 0x513b
cmpq $0x0, 0x7359(%rip)      # 0xc420
je 0x50f5
movq 0x7350(%rip), %rax      # 0xc420
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x733d(%rip)      # 0xc420
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10a0
jmp 0x5103
movl $0x10, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movslq -0x14(%rbp), %rcx
leaq 0x6304(%rip), %rax      # 0xb420
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdx
movslq -0x14(%rbp), %rcx
leaq 0x62e9(%rip), %rax      # 0xb420
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq 0x7323(%rip), %rcx      # 0xc470
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x7310(%rip)      # 0xc470
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: same_unostate
static int
same_unostate(Vis *v)
{
	if (v->uno_state & (1<<stack->uno_state))
		return 1;
	v->uno_state |= (1<<stack->uno_state);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x6221(%rip), %rcx      # 0xb3b8
movswl 0x8(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x51b9
movl $0x1, -0x4(%rbp)
jmp 0x51e1
movq 0x61f8(%rip), %rax      # 0xb3b8
movswl 0x8(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: same_callpts
static int
same_callpts(Vis *v)
{	Rstack *p;
	NList *q;
	int cnt = 0;

	if (!v->r && !rstack)
	{	if (v->zerostack)
			return 1;
		v->zerostack = 1;
		return 0;
	}

	for (p = rstack; p; p = p->nxt)
	{	for (q = v->r; q; q = q->nxt)
		{	if (p->n == q->n)
				break;
		}
		if (!q)	/* add p->n */
		{	if (free_v)
			{	q = free_n;
				free_n = q->nxt;
				memset(q, 0, sizeof(NList));
			} else
				q = (NList *) emalloc(sizeof(NList));
			q->n = p->n;
			q->nxt = v->r;
			v->r = q;
			cnt++;
	}	}

	return (cnt == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5245
cmpq $0x0, 0x7232(%rip)      # 0xc448
jne 0x5245
movq -0x10(%rbp), %rax
cmpw $0x0, 0x18(%rax)
je 0x522f
movl $0x1, -0x4(%rbp)
jmp 0x5332
movq -0x10(%rbp), %rax
movw $0x1, 0x18(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5332
movq 0x71fc(%rip), %rax      # 0xc448
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5323
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5291
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x5281
jmp 0x5291
jmp 0x5283
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5267
cmpq $0x0, -0x20(%rbp)
jne 0x5310
cmpq $0x0, 0x71c0(%rip)      # 0xc460
je 0x52ce
movq 0x71bf(%rip), %rax      # 0xc468
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x71ac(%rip)      # 0xc468
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10a0
jmp 0x52dc
movl $0x10, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5312
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5250
cmpl $0x0, -0x24(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: same_markings
static int
same_markings(Vis *v)
{	Var   *p;
	VList *q;
	int cnt = 0;

	if (!v->v && !stack->sels)
	{	if (v->zeromarks)
			return 1;
		v->zeromarks = 1;
		return 0;
	}

	for (p = stack->sels; p; p = p->nxt)
	{	for (q = v->v; q; q = q->nxt)
		{	if (strcmp(q->v->s, p->s) == 0
			&&  q->v->mark == p->mark)
				break;
		}
		if (!q)	/* add p */
		{	if (free_v)
			{	q = free_v;
				free_v = q->nxt;
				memset(q, 0, sizeof(VList));
			} else
				q = (VList *) emalloc(sizeof(VList));
			
			q->v = new_var(p->s);
			q->v->mark = p->mark;
			q->nxt = v->v;
			v->v = q;
			cnt++;
	}	}

	return (cnt == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5398
movq 0x6054(%rip), %rax      # 0xb3b8
cmpq $0x0, 0x10(%rax)
jne 0x5398
movq -0x10(%rbp), %rax
cmpw $0x0, 0x1a(%rax)
je 0x5382
movl $0x1, -0x4(%rbp)
jmp 0x54bf
movq -0x10(%rbp), %rax
movw $0x1, 0x1a(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x54bf
movq 0x6019(%rip), %rax      # 0xb3b8
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x54b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5404
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x53f4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x53f4
jmp 0x5404
jmp 0x53f6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x53bd
cmpq $0x0, -0x20(%rbp)
jne 0x549d
cmpq $0x0, 0x7049(%rip)      # 0xc460
je 0x5445
movq 0x7040(%rip), %rax      # 0xc460
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x702d(%rip)      # 0xc460
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10a0
jmp 0x5453
movl $0x10, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3810
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x549f
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x53a7
cmpl $0x0, -0x24(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: new_sym
static BSym *
new_sym(char *s)
{	BSym *f;

	if (free_sym)
	{	f = free_sym;
		free_sym = f->nxt;
		memset(f, 0, sizeof(BSym));
	} else
		f = (BSym *) emalloc(sizeof(BSym));

	f->s = new_str(s);
	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x6f8c(%rip)      # 0xc470
je 0x5512
movq 0x6f83(%rip), %rax      # 0xc470
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x6f70(%rip)      # 0xc470
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10a0
jmp 0x5520
movl $0x10, %edi
callq 0x1270
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: addtostack
static void
addtostack(char *s)	/* info on var known to be nonzero */
{	char *p;
	BSym *r;

	p = strchr(s, ' ');
	if (!p)
	{	fprintf(stderr, "bad label: %s\n", s);
		return;
	}
	*p = '\0'; /* p now points to location */
	r = new_sym(s);
	r->nxt = stack->knz;
	stack->knz = r;
	*p = ' ';	/* restore */
	if (debug) printf("KnownNonZero var: '%s'\n", s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x1070
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5583
movq 0x5a8c(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x27e9(%rip), %rsi      # 0x7d63
movb $0x0, %al
callq 0x10d0
jmp 0x55db
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x54d0
movq %rax, -0x18(%rbp)
movq 0x5e1a(%rip), %rax      # 0xb3b8
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq 0x5e03(%rip), %rax      # 0xb3b8
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movb $0x20, (%rax)
cmpl $0x0, 0x5df9(%rip)      # 0xb3c0
je 0x55db
movq -0x8(%rbp), %rsi
leaq 0x279e(%rip), %rdi      # 0x7d72
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: unselect
static void
unselect(void)
{	Var *v;

	if (stack)
	for (v = stack->sels; v; v = v->nxt)
		v->sel = 0;

	if (debug) printf("UnSeLecting\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x5538(%rip)      # 0xb3b8
je 0x5eb3
movq 0x552f(%rip), %rax      # 0xb3b8
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5eb1
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5e91
jmp 0x5eb3
cmpl $0x0, 0x5506(%rip)      # 0xb3c0
je 0x5eca
leaq 0x2185(%rip), %rdi      # 0x8048
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: n_reported
static int
n_reported(Stack *s)
{	Report *r;
	int n;

	if (s && s->move && s->move->to)
		n = s->move->to->nid;
	else
		return 0;

	for (r = report; r; r = r->nxt)
		if (r->n > n-3
		&&  r->n < n+3)	/* within a range of subsequent states */
			return 1;
	r = (Report *) emalloc(sizeof(Report));
	r->n = n;
	r->nxt = report;
	report = r;

	if (debug) printf("NID=%d\n", n);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x657b
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x657b
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0x657b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x6587
movl $0x0, -0x4(%rbp)
jmp 0x6624
movq 0x5ef2(%rip), %rax      # 0xc480
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x65d2
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl -0x1c(%rbp), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jle 0x65c2
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl -0x1c(%rbp), %ecx
addl $0x3, %ecx
cmpl %ecx, %eax
jge 0x65c2
movl $0x1, -0x4(%rbp)
jmp 0x6624
jmp 0x65c4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6592
movl $0x10, %edi
callq 0x1270
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq 0x5e90(%rip), %rcx      # 0xc480
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x5e7d(%rip)      # 0xc480
cmpl $0x0, 0x4db6(%rip)      # 0xb3c0
je 0x661d
movl -0x1c(%rbp), %esi
leaq 0x18ec(%rip), %rdi      # 0x7f02
movb $0x0, %al
callq 0x1080
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: print_fnm
static int
print_fnm(Rstack *s, char *p)
{
	if (!s) return 0;

	if (s->n && s->n->lab)
		printf("	%s %s\n", p, &s->n->lab->label[2]);
	else if (strcmp(s->f->fnm, "_global_") != 0)
		printf("	%s %s()\n", p, s->f->fnm);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6653
movl $0x0, -0x4(%rbp)
jmp 0x66d4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6694
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x6694
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
addq $0x2, %rdx
leaq 0x187f(%rip), %rdi      # 0x7f0a
movb $0x0, %al
callq 0x1080
jmp 0x66cd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
leaq 0xc76(%rip), %rsi       # 0x731b
callq 0x10c0
cmpl $0x0, %eax
je 0x66cb
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
leaq 0x184e(%rip), %rdi      # 0x7f12
movb $0x0, %al
callq 0x1080
jmp 0x66cd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: print_stack
static void
print_stack(Stack *s, int d)
{	Arc *a;
	int i;

	if (!s) return;
	print_stack(s->nxt, d-1);

	a = s->move;

	if (a
	&&  a->to->lab
	&&  strlen((char *) a->to->lab->label) > 0)
	{	for (i = 0; i < tabs; i++)
			printf("   ");
		printf("%3d:\t[%d]\t%s\n", d,
			a->to->nid, a->to->lab->label);
	}

	if (s->fc)
	{	tabs++;
		for (i = 0; i < tabs; i++)
			printf("   ");
		printf("%3d: BFct call to %s\n", d, s->fc->fnm);
	}
	if (s->fr)
	{	for (i = 0; i < tabs; i++)
			printf("   ");
		tabs--;
		printf("%3d: Return to %s\n", d, s->fr->fnm);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x673b
jmp 0x689c
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
callq 0x6720
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x67da
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x67da
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x1060
cmpq $0x0, %rax
jbe 0x67da
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x5ce1(%rip), %eax      # 0xc478
jge 0x67b2
leaq 0x177c(%rip), %rdi      # 0x7f1c
movb $0x0, %al
callq 0x1080
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x678e
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
leaq 0x174d(%rip), %rdi      # 0x7f20
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x683b
movl 0x5c8d(%rip), %eax      # 0xc478
addl $0x1, %eax
movl %eax, 0x5c84(%rip)      # 0xc478
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x5c74(%rip), %eax      # 0xc478
jge 0x681f
leaq 0x170f(%rip), %rdi      # 0x7f1c
movb $0x0, %al
callq 0x1080
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x67fb
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdx
leaq 0x16fa(%rip), %rdi      # 0x7f2e
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x689c
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x5c22(%rip), %eax      # 0xc478
jge 0x6871
leaq 0x16bd(%rip), %rdi      # 0x7f1c
movb $0x0, %al
callq 0x1080
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x684d
movl 0x5c01(%rip), %eax      # 0xc478
addl $-0x1, %eax
movl %eax, 0x5bf8(%rip)      # 0xc478
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdx
leaq 0x16af(%rip), %rdi      # 0x7f44
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: has_ref_match
static int
has_ref_match(int mark, int match, int dont)
{	Var *v;
	int hasmatch = 0;

	if (debug)
	for (v = stack->sels; v; v = v->nxt)
		printf("\tSel: '%s', stat %d, mark %d -- looking for mark %d, +%d -%d\n",
			v->s, v->stat, v->mark, mark, match, dont);

	for (v = stack->sels; v; v = v->nxt)
		if (v->sel == 1
		&&  v->mark == mark
		&& (v->stat & match)
		&& !(v->stat & dont))
		{	hasmatch = 1;
			break;
		}

	if (hasmatch)
	for (v = stack->sels; v; v = v->nxt)
		if (v->sel == 1
		&& (v->mark != mark
		|| !(v->stat & match)
		||  (v->stat & dont)))
			v->sel = 0;

	return hasmatch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, 0x4af1(%rip)      # 0xb3c0
je 0x6928
movq 0x4ae0(%rip), %rax      # 0xb3b8
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6926
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
movl -0x4(%rbp), %r8d
movl -0x8(%rbp), %r9d
movl -0xc(%rbp), %eax
leaq 0x16a7(%rip), %rdi      # 0x7fb5
movl %eax, (%rsp)
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x68e0
jmp 0x6928
movq 0x4a89(%rip), %rax      # 0xb3b8
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x698b
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x697b
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x697b
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
andl -0x8(%rbp), %eax
cmpl $0x0, %eax
je 0x697b
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
jne 0x697b
movl $0x1, -0x1c(%rbp)
jmp 0x698b
jmp 0x697d
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6937
cmpl $0x0, -0x1c(%rbp)
je 0x69f8
movq 0x4a20(%rip), %rax      # 0xb3b8
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x69f6
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x69e6
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x69db
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
andl -0x8(%rbp), %eax
cmpl $0x0, %eax
je 0x69db
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0x69e6
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x69e8
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x69a0
jmp 0x69f8
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_fcts.c
// Function: known_nz
static int
known_nz(void)
{	Var *v;
	BSym *s;

	for (v = stack->sels; v; v = v->nxt)
	{	if (v->sel == 1)
		{	if (debug) printf("	is %s known_nonzero? ", v->s);
			for (s = stack->knz; s; s = s->nxt)
				if (strcmp(v->s, s->s) == 0)
				{	if (debug) printf("yes!\n");
					break;
				}
			if (!s)
			{	if (debug)
				{	printf("no!\n");
					for (s = stack->knz; s; s = s->nxt)
						printf("	knownonzero: %s\n", s->s);
				}
				return 0;
			}
		}
	}
	if (debug) printf("all selected vars known nonzero\n");
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x4999(%rip), %rax      # 0xb3b8
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6b2c
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x6b19
cmpl $0x0, 0x4979(%rip)      # 0xb3c0
je 0x6a5e
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x159c(%rip), %rdi      # 0x7ff3
movb $0x0, %al
callq 0x1080
movq 0x4953(%rip), %rax      # 0xb3b8
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6ab5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x6aa5
cmpl $0x0, 0x492d(%rip)      # 0xb3c0
je 0x6aa3
leaq 0x156e(%rip), %rdi      # 0x800a
movb $0x0, %al
callq 0x1080
jmp 0x6ab5
jmp 0x6aa7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6a6d
cmpq $0x0, -0x18(%rbp)
jne 0x6b17
cmpl $0x0, 0x48fd(%rip)      # 0xb3c0
je 0x6b0e
leaq 0x1544(%rip), %rdi      # 0x8010
movb $0x0, %al
callq 0x1080
movq 0x48de(%rip), %rax      # 0xb3b8
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6b0c
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x151e(%rip), %rdi      # 0x8015
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6ae2
jmp 0x6b0e
movl $0x0, -0x4(%rbp)
jmp 0x6b4a
jmp 0x6b19
jmp 0x6b1b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6a27
cmpl $0x0, 0x488d(%rip)      # 0xb3c0
je 0x6b43
leaq 0x14eb(%rip), %rdi      # 0x8027
movb $0x0, %al
callq 0x1080
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_06/itoa.c
// Function: main
int main(void)
{
  int n = 1995;
  char number_str[MAXLEN];

  int_to_array(n, number_str, 6);
  printf("%s\n", number_str);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp            # imm = 0x3F0
movl $0x0, -0x4(%rbp)
movl $0x7cb, -0x8(%rbp)      # imm = 0x7CB
movl -0x8(%rbp), %edi
leaq -0x3f0(%rbp), %rsi
movl $0x6, %edx
callq 0x11a0
leaq -0x3f0(%rbp), %rsi
leaq 0xe79(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_06/itoa.c
// Function: int_to_array
void int_to_array(int n, char s[], int padding)
{
  int i = 0, sign = n;

  do
  {
    s[i++] = abs(n % 10) + '0';
  } while (n /= 10);

  if (sign < 0)
  {
    s[i++] = '-';
  }

  int len = ilen(sign);
  while (len < padding)
  {
    s[i++] = ' ';
    --padding;
  }

  s[i] = '\0';

  int s_len = strlen(s);
  str_reverse(s, 0, s_len - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
jne 0x11bf
cmpl $0x0, -0x1c(%rbp)
jge 0x121c
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
movl -0x1c(%rbp), %edi
callq 0x1280
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1250
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb $0x20, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1227
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x1030
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x12b0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_06/itoa.c
// Function: ilen
int ilen(int a)
{
  int i = 0;

  do
  {
    ++i;
  } while (a /= 10);

  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
jne 0x128e
movl -0x8(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_06/itoa.c
// Function: str_reverse
void str_reverse(char str1[], int index, int size)
{
  char temp;

  temp = str1[index];
  str1[index] = str1[size - index];
  str1[size - index] = temp;

  if (index == size / 2)
  {
    return;
  }

  str_reverse(str1, index + 1, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jne 0x131a
jmp 0x132c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x12b0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/bootstrap1.c
// Function: append
long append(long xs, long ys)
{
    long x2, x1, us, u;
    goto L1;
L1:
    switch (runtime_class(xs)) {
    case CLASS_Cons:
        u = prim_fetch(xs, runtime_makeNumber(0));
        us = prim_fetch(xs, runtime_makeNumber(1));
        goto L2;
    default:
        goto L3;
    }
L2:
    x1 = append(us, ys);
    goto L4;
L3:
    return ys;
L4:
    x2 = prim_cons(u, x1);
    return x2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5690
subw $0x3, %ax
jne 0x1306
jmp 0x12c1
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x57a0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x1, %edi
callq 0x57a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x30(%rbp)
jmp 0x1308
jmp 0x131b
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12a0
movq %rax, -0x28(%rbp)
jmp 0x1325
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x133e
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5cc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/bootstrap1.c
// Function: pass1
long pass1(long hi1)
{
    long x3, x2, x1, defs, def;
    goto L1;
L1:
    switch (runtime_class(hi1)) {
    case CLASS_Cons:
        def = prim_fetch(hi1, runtime_makeNumber(0));
        defs = prim_fetch(hi1, runtime_makeNumber(1));
        goto L2;
    default:
        goto L3;
    }
L2:
    x1 = pass1Toplevel(def);
    goto L4;
L3:
    return nil;
L4:
    x2 = pass1(defs);
    goto L5;
L5:
    x3 = prim_cons(x1, x2);
    return x3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5690
subw $0x3, %ax
jne 0x1412
jmp 0x13cd
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x57a0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x1, %edi
callq 0x57a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x30(%rbp)
jmp 0x1414
jmp 0x1423
movq -0x38(%rbp), %rdi
callq 0x1470
movq %rax, -0x28(%rbp)
jmp 0x1433
leaq 0x27e1e(%rip), %rax     # 0x29248
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1459
movq -0x30(%rbp), %rdi
callq 0x13b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5cc0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/bootstrap1.c
// Function: pass1CallExpr
long pass1CallExpr(long f, long args, long cont)
{
    long x5, x4, label, x3, x2, contBlocks, explicitCont, x1;
    goto L1;
L1:
    x1 = pass1ExplicitCont(cont);
    goto L2;
L2:
    switch (runtime_class(x1)) {
    case CLASS_Pair:
        explicitCont = prim_fetch(x1, runtime_makeNumber(0));
        contBlocks = prim_fetch(x1, runtime_makeNumber(1));
        goto L3;
    default:
        runtime_matchFailure(__LINE__);
    }
L3:
    switch (runtime_class(explicitCont)) {
    case CLASS_P1TailCont:
        goto L4;
    case CLASS_P1BlockCont:
        label = prim_fetch(explicitCont, runtime_makeNumber(0));
        goto L5;
    default:
        runtime_matchFailure(__LINE__);
    }
L4:
    x2 = FiCall(nil, f, args);
    x3 = Triple(nil, x2, nil);
    return x3;
L5:
    x4 = FiCall(label, f, args);
    x5 = Triple(nil, x4, contBlocks);
    return x5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x25f0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x5690
subw $0x1f, %ax
jne 0x23fa
jmp 0x23b5
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x57a0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x1, %edi
callq 0x57a0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x50(%rbp)
jmp 0x2406
movl $0x13e, %edi            # imm = 0x13E
callq 0x5c50
jmp 0x2406
movq -0x58(%rbp), %rdi
callq 0x5690
movzwl %ax, %ecx
movl %ecx, -0x74(%rbp)
subw $0x21, %ax
je 0x2427
jmp 0x241d
movl -0x74(%rbp), %eax
subl $0x22, %eax
je 0x2429
jmp 0x244c
jmp 0x2458
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x57a0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x38(%rbp)
jmp 0x249e
movl $0x148, %edi            # imm = 0x148
callq 0x5c50
jmp 0x2458
leaq 0x26de9(%rip), %rax     # 0x29248
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x27e0
movq %rax, -0x48(%rbp)
leaq 0x26dce(%rip), %rax     # 0x29248
movq (%rax), %rdi
movq -0x48(%rbp), %rsi
leaq 0x26dc0(%rip), %rax     # 0x29248
movq (%rax), %rdx
callq 0x1240
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24d6
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x27e0
movq %rax, -0x30(%rbp)
leaq 0x26d8e(%rip), %rax     # 0x29248
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x1240
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)