LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/sequential-trie.c
// Function: print
void _print (struct trie_node *node, int printLevel, int nodePos) {
            //  printf ("Node at %p.  Key %.*s, IP %d.  Next %p, Children %p\n",
            //  node, node->strlen, node->key, node->ip4_address, node->next, node->children);
            printf("\nvvvvvvvv - The %d node on Level %d - vvvvvvvvvv\n", nodePos, printLevel);
            printf("|Node at: %p\n", node);
            printf("|Key: %.*s\n", node->strlen, node->key);
            printf("|IP: %d\n", node->ip4_address);
            printf("|Next: %p\n", node->next);
            printf("|Child: %p\n", node->children);
            printf("^^^^^^^^ - The %d node on Level %d - ^^^^^^^^^^\n", nodePos, printLevel);
            if (node->children) {
              printf("\nvvvvvvvvvvvvvv\n");
              printf("!!!Entering next level of trie!!!\n");
              printf("vvvvvvvvvvvvvv\n");
              // printf("Now on Level %d at Position %d\n", printLevel, nodePos);
              _print(node->children, printLevel+1, 0);
            }
            if (node->next) {
              printf("\n>>>>>>>>>>>>>>\n");
              printf("!!!Moving to next node of level!!!\n");
              printf(">>>>>>>>>>>>>>\n");
              //printf("Node on Level %d at Position %d\n", printLevel, nodePos);
              _print(node->next, printLevel, nodePos+1);
            }
          }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leal 0x1(%r14), %ebp
leaq 0x17e9(%rip), %r13      # 0x331e
leaq 0x17ee(%rip), %r12      # 0x332a
leaq 0x177b(%rip), %rdi      # 0x32be
movl %ebx, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1080
leaq 0x179a(%rip), %rdi      # 0x32f0
movq %r15, %rsi
xorl %eax, %eax
callq 0x1080
movl 0x8(%r15), %esi
leaq 0x18(%r15), %rdx
leaq 0x178f(%rip), %rdi      # 0x32fe
xorl %eax, %eax
callq 0x1080
movl 0xc(%r15), %esi
leaq 0x1789(%rip), %rdi      # 0x330a
xorl %eax, %eax
callq 0x1080
movq (%r15), %rsi
leaq 0x1781(%rip), %rdi      # 0x3313
xorl %eax, %eax
callq 0x1080
movq 0x10(%r15), %rsi
movq %r13, %rdi
xorl %eax, %eax
callq 0x1080
movq %r12, %rdi
movl %ebx, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1080
cmpq $0x0, 0x10(%r15)
je 0x1bee
leaq 0x17e5(%rip), %rdi      # 0x33a9
callq 0x1070
leaq 0x17e9(%rip), %rdi      # 0x33b9
callq 0x1070
leaq 0x17ce(%rip), %rdi      # 0x33aa
callq 0x1070
movq 0x10(%r15), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x1b17
cmpq $0x0, (%r15)
je 0x1c22
leaq 0x17e0(%rip), %rdi      # 0x33db
callq 0x1070
leaq 0x17e4(%rip), %rdi      # 0x33eb
callq 0x1070
leaq 0x17c9(%rip), %rdi      # 0x33dc
callq 0x1070
movq (%r15), %r15
incl %ebx
jmp 0x1b3c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/sequential-trie.c
// Function: print
void print() {
            printf ("Root is at %p\n", root);
            /* Do a simple depth-first search */
            if (root)
            _print(root, 0, 0);
          }

// Assembly:
pushq %rax
movq 0x44af(%rip), %rsi      # 0x60e8
leaq 0x171b(%rip), %rdi      # 0x335b
xorl %eax, %eax
callq 0x1080
movq 0x449a(%rip), %rdi      # 0x60e8
testq %rdi, %rdi
je 0x1c5d
xorl %esi, %esi
xorl %edx, %edx
popq %rax
jmp 0x1b17
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/main.c
// Function: help
void help() {
  printf ("DNS Simulator.  Usage: ./dns-[variant] [options]\n\n");
  printf ("Options:\n");
  printf ("\t-c numclients - Use numclients threads.\n");
  printf ("\t-h - Print this help.\n");
  printf ("\t-l length - Run clients for length seconds.\n");
  printf ("\t-q  - Allow a client to block (squat) if a requested name is taken.\n");
  printf ("\t-t  - Stress test name squatting.\n");
  printf ("\n\n");
}

// Assembly:
pushq %rax
leaq 0x17e1(%rip), %rdi      # 0x375b
callq 0x1070
leaq 0x1807(%rip), %rdi      # 0x378d
callq 0x1070
leaq 0x1804(%rip), %rdi      # 0x3796
callq 0x1070
leaq 0x1821(%rip), %rdi      # 0x37bf
callq 0x1070
leaq 0x182c(%rip), %rdi      # 0x37d6
callq 0x1070
leaq 0x184d(%rip), %rdi      # 0x3803
callq 0x1070
leaq 0x1886(%rip), %rdi      # 0x3848
callq 0x1070
leaq 0x111f(%rip), %rdi      # 0x30ed
popq %rax
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/main.c
// Function: squatter_stress
static void *
squatter_stress(void *arg)
{
  /* Just loop over 4 names, trying to create them
  * and then free them.  If all threads
  * try to create the same name, all but one should block
  * until a given name is available again.
  */
  int32_t ip = random();

  while (!finished) {
    insert ("abc", 3, ip);
    insert ("abe", 3, ip);
    insert ("bce", 3, ip);
    insert ("bcc", 3, ip);
    delete ("abc", 3);
    delete ("abe", 3);
    delete ("bce", 3);
    delete ("bcc", 3);
  }

  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x10e0
movq %rax, %rbx
leaq 0x135d(%rip), %r14      # 0x35bb
pushq $0x3
popq %r15
leaq 0x12be(%rip), %r12      # 0x3527
leaq 0x12bb(%rip), %r13      # 0x352b
leaq 0x12b8(%rip), %rbp      # 0x352f
cmpl $0x0, 0x3e76(%rip)      # 0x60f4
jne 0x22e2
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x189f
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x189f
movq %r13, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x189f
movq %rbp, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x189f
movq %r14, %rdi
movq %r15, %rsi
callq 0x1aec
movq %r12, %rdi
movq %r15, %rsi
callq 0x1aec
movq %r13, %rdi
movq %r15, %rsi
callq 0x1aec
movq %rbp, %rdi
movq %r15, %rsi
callq 0x1aec
jmp 0x2277
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_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: emalloc
void *
emalloc(size_t n)
{	char *s;

	s = (char *) malloc(n);
	if (!s)
	{	fprintf(stderr, "uno:global: out of memory\n");
		exit(1);
	}
	memset(s, 0, n);
	return (void *) s;
}

// Assembly:
pushq %rax
movq %rdi, %rsi
pushq $0x1
popq %rdi
callq 0x10e0
testq %rax, %rax
je 0x12af
popq %rcx
retq
movq 0x6d3a(%rip), %rax      # 0x7ff0
movq (%rax), %rcx
leaq 0x3dfc(%rip), %rdi      # 0x50bc
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x1170
pushq $0x1
popq %rdi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: path_query
int
path_query(Fct *g, Fct *h)	/* from, to */
{	Sym *r;
	Fct *f;
	int found;
	
	if (!g || g->visited) return 0;
	g->visited = 1;

	found = 0;
	for (r = g->calls; r; r = r->nxt)
	{	f = find_fct(r->s);

		if (f == h)
			found = 1;
		else
			found = path_query(g, f);

		if (found)
		{	fprintf(stdout, "N%s -> N%s;\n", g->fnm, r->s);
			break;
		}
#if 0
		fprintf(stdout, "N%s [label=\"%s:%d\"];\n",
				g->fnm, g->fnm, g->n->line);
#endif
	}

	return found;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1348
movq %rdi, %r14
cmpw $0x0, 0x38(%rdi)
jne 0x1348
movq %rsi, %r15
movw $0x1, 0x38(%r14)
leaq 0x30(%r14), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x1348
movq (%r12), %rdi
callq 0x1356
cmpq %r15, %rax
je 0x1326
movq %r14, %rdi
movq %rax, %rsi
callq 0x12d3
testl %eax, %eax
jne 0x1326
addq $0x18, %r12
jmp 0x12fa
movq 0x6ca3(%rip), %rax      # 0x7fd0
movq (%rax), %rdi
movq (%r14), %rdx
movq (%r12), %rcx
leaq 0x3d99(%rip), %rsi      # 0x50d7
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: find_fct
static Fct *
find_fct(char *nf)
{	Fct *f = (Fct *) 0;

	if (!nf) return f;

	for (f = fcts; f; f = f->nxt)
		if (strcmp(f->fnm, nf) == 0)
			break;

	if (!f)
	{	if (strcmp(nf, "_global_") == 0)
		{	Place *n;
			n = (Place *) emalloc(sizeof(Place));
			n->fnm = "_global_";
			new_fct(n, nf, 0);
			f = fcts;

			add_fct(nf);

		} else if (debug)
			fprintf(stderr, "uno:global: unknown fct %s\n", nf);
	}
	return f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x139c
movq %rdi, %rbx
leaq 0x6ecf(%rip), %r14      # 0x8238
movq (%r14), %r14
testq %r14, %r14
je 0x1386
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
testl %eax, %eax
je 0x139f
addq $0x40, %r14
jmp 0x1369
leaq 0x494d(%rip), %r14      # 0x5cda
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10f0
testl %eax, %eax
je 0x13aa
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x129c
movq %r14, (%rax)
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x23c8
movq 0x6e6f(%rip), %r14      # 0x8238
movq %rbx, %rdi
callq 0x2734
jmp 0x139f
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: add_glob_defs
void	/* called from uno_fcts.c */
add_glob_defs(void)
{	Fct *f;

	if (!(f = find_fct("_global_"))) return;

	handle_fct(": _global_	0");
	build_glob(f->defs);

	if (!(f = find_fct(want)))
	{	printf("uno:global: no fct '%s' found, cannot do global analysis\n", want);
		find_roots();
		return;
	}

	sprintf(g_buf, ">%d>", special++);
	handle_fct(g_buf);
	sprintf(g_buf, "[C\t%s\t%s %d]", want, f->n->fnm, f->n->line);
	handle_fct(g_buf);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x3b87(%rip), %rdi      # 0x5cda
callq 0x1356
testq %rax, %rax
je 0x21ee
movq %rax, %rbx
leaq 0x316a(%rip), %rdi      # 0x52d5
callq 0x2cf2
movq 0x18(%rbx), %rdi
callq 0x2217
movq 0x5f70(%rip), %rdi      # 0x80f0
callq 0x1356
testq %rax, %rax
je 0x21f6
movq %rax, %rbx
movl 0x5f65(%rip), %edx      # 0x80f8
leal 0x1(%rdx), %eax
movl %eax, 0x5f5c(%rip)      # 0x80f8
leaq 0x5f8d(%rip), %r14      # 0x8130
leaq 0x3172(%rip), %rsi      # 0x531c
movq %r14, %rdi
xorl %eax, %eax
callq 0x1150
movq %r14, %rdi
callq 0x2cf2
movq 0x5f2d(%rip), %rdx      # 0x80f0
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl 0x8(%rax), %r8d
leaq 0x314c(%rip), %rsi      # 0x5321
movq %r14, %rdi
xorl %eax, %eax
callq 0x1150
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2cf2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x5ef3(%rip), %rsi      # 0x80f0
leaq 0x30de(%rip), %rdi      # 0x52e2
xorl %eax, %eax
callq 0x10a0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28b8
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: build_glob
static void
build_glob(Sym *r)
{
	if (!r) return;
	build_glob(r->nxt);
	
	sprintf(g_buf, ">%d>", special++);
	handle_fct(g_buf);

	sprintf(g_buf, "[G\t%s\t%s %d]", r->s, r->n->fnm, r->n->line);	/* G: DEF|DCL */
	handle_fct(g_buf);
}

// Assembly:
testq %rdi, %rdi
je 0x2289
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x2217
movl 0x5ec6(%rip), %edx      # 0x80f8
leal 0x1(%rdx), %eax
movl %eax, 0x5ebd(%rip)      # 0x80f8
leaq 0x5eee(%rip), %r14      # 0x8130
leaq 0x30d3(%rip), %rsi      # 0x531c
movq %r14, %rdi
xorl %eax, %eax
callq 0x1150
movq %r14, %rdi
callq 0x2cf2
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl 0x8(%rax), %r8d
leaq 0x327a(%rip), %rsi      # 0x54ea
movq %r14, %rdi
xorl %eax, %eax
callq 0x1150
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2cf2
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: indirect_calls
extern int
indirect_calls(char *s)
{	Sym *p;

	for (p = indirects; p; p = p->nxt)
		if (strcmp(p->s, s) == 0)
			return 1;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x5f97(%rip), %r15      # 0x8230
pushq $0x1
popq %rbx
movq (%r15), %r15
testq %r15, %r15
je 0x22b9
movq (%r15), %rdi
movq %r14, %rsi
callq 0x10f0
addq $0x18, %r15
testl %eax, %eax
jne 0x229c
jmp 0x22bb
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: gen_fct
static void
gen_fct(FILE *fd, Fct *g)
{	Sym *r;
	Fct *f;

	if (!g || g->visited) return;
	g->visited = 1;

	fprintf(fd, "N%s [label=\"%s:%d\"];\n",
		g->fnm, g->fnm, g->n->line);

	if (reverse)
	{	for (f = fcts; f; f = f->nxt)
		for (r = f->calls; r; r = r->nxt)
			if (strcmp(r->s, g->fnm) == 0)
			{	fprintf(fd, "N%s -> N%s;\n", f->fnm, g->fnm);
				gen_fct(fd, f);
			}
	} else
	{	for (r = g->calls; r; r = r->nxt)
		{	if (!(r->bits & HIDE))
				fprintf(fd, "N%s -> N%s;\n", g->fnm, r->s);
			gen_fct(fd, find_fct(r->s));
	}	}
}

// Assembly:
testq %rsi, %rsi
je 0x22eb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpw $0x0, 0x38(%rsi)
je 0x22ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movw $0x1, 0x38(%rbx)
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
movl 0x8(%rax), %r8d
leaq 0x3051(%rip), %rsi      # 0x5358
movq %rcx, %rdx
xorl %eax, %eax
callq 0x1100
cmpb $0x1, 0x5e04(%rip)      # 0x811c
jne 0x237a
leaq 0x5f17(%rip), %r15      # 0x8238
leaq 0x2daf(%rip), %r12      # 0x50d7
movq (%r15), %r15
testq %r15, %r15
je 0x22dd
leaq 0x30(%r15), %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x2374
movq (%rbp), %rdi
movq (%rbx), %r13
movq %r13, %rsi
callq 0x10f0
testl %eax, %eax
jne 0x236e
movq (%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
movq %r14, %rdi
movq %r15, %rsi
callq 0x22c3
addq $0x18, %rbp
jmp 0x2334
addq $0x40, %r15
jmp 0x2328
leaq 0x30(%rbx), %r12
leaq 0x2d52(%rip), %r15      # 0x50d7
movq (%r12), %r12
testq %r12, %r12
je 0x22dd
testb $0x2, 0x11(%r12)
jne 0x23ae
movq (%rbx), %rdx
movq (%r12), %rcx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1100
movq (%r12), %rdi
callq 0x1356
movq %r14, %rdi
movq %rax, %rsi
callq 0x22c3
addq $0x18, %r12
jmp 0x2385
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: new_fct
static void
new_fct(Place *n, char *nf, int is_static_fct)
{	Fct *f;

	for (f = fcts; f; f = f->nxt)
		if (strcmp(f->fnm, nf) == 0)
		{	if (f->n->line == n->line
			&&  (strstr(f->n->fnm, n->fnm)
			||   strstr(n->fnm, f->n->fnm)))
				break;	/* probably from same source */

			if (!f->is_static || !is_static_fct)
			{	fprintf(stderr, "uno:global: fct '%s' appears twice\n", nf);
					fprintf(stderr, "	old: %s:%d%s\n",
				f->n->fnm, f->n->line, f->is_static?" (static)":"");
				fprintf(stderr, "	new: %s:%d%s (ignored)\n",
					n->fnm, n->line, is_static_fct?" (static)":"");
			}
			break;
		}

	if (!f)
	{	f = (Fct *) emalloc(sizeof(Fct));
		f->fnm = nf;
		f->n = n;
		f->is_static = is_static_fct;
		f->nxt = fcts;
		fcts = f;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5e56(%rip), %r13      # 0x8238
movq (%r13), %r13
testq %r13, %r13
je 0x2401
movq (%r13), %rdi
movq %r14, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2428
addq $0x40, %r13
jmp 0x23e2
pushq $0x48
popq %rdi
callq 0x129c
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movw %bp, 0x10(%rax)
movq 0x5e1d(%rip), %rcx      # 0x8238
movq %rcx, 0x40(%rax)
movq %rax, 0x5e12(%rip)      # 0x8238
jmp 0x2466
movq 0x8(%r13), %rax
movl 0x8(%rax), %ecx
cmpl 0x8(%rbx), %ecx
jne 0x245a
movq (%rax), %r15
movq (%rbx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1180
testq %rax, %rax
jne 0x2466
movq %r12, %rdi
movq %r15, %rsi
callq 0x1180
testq %rax, %rax
jne 0x2466
testl %ebp, %ebp
je 0x2475
cmpw $0x0, 0x10(%r13)
je 0x2475
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5b74(%rip), %r15      # 0x7ff0
movq (%r15), %rdi
leaq 0x300e(%rip), %rsi      # 0x5494
movq %r14, %rdx
xorl %eax, %eax
callq 0x1100
movq (%r15), %rdi
movq 0x8(%r13), %rax
movq (%rax), %rdx
movl 0x8(%rax), %ecx
cmpw $0x0, 0x10(%r13)
leaq 0x3810(%rip), %r12      # 0x5cba
leaq 0x3016(%rip), %r14      # 0x54c7
movq %r14, %r8
cmoveq %r12, %r8
leaq 0x2ff9(%rip), %rsi      # 0x54b8
xorl %eax, %eax
callq 0x1100
testl %ebp, %ebp
movq (%r15), %rdi
movq (%rbx), %rdx
cmoveq %r12, %r14
movl 0x8(%rbx), %ecx
leaq 0x2ff5(%rip), %rsi      # 0x54d1
movq %r14, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: glob_def
static void
glob_def(Place *n, char *nf, char *s)
{	Sym *r;
	Fct *f;

	if (!(f = find_fct(nf))) return;

	r = (Sym *) emalloc(sizeof(Sym));
	r->s = s;
	r->n = n;
	r->nxt = f->defs;
	f->defs = r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1356
testq %rax, %rax
je 0x2548
movq %rax, %r15
pushq $0x20
popq %rdi
callq 0x129c
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movq 0x18(%r15), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x18(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: loc_fcall
static void
loc_fcall(Place *n, char *nf, char *s, int bits)
{	Sym *r;
	Fct *f;

	if (!(f = find_fct(nf))) return;

	r = (Sym *) emalloc(sizeof(Sym));
	r->s = s;
	r->n = n;
	r->bits = bits;
	r->nxt = f->calls;
	f->calls = r;

	if (bits & HIDE)
	{	f = find_fct(s);
		if (f) f->special |= HIDE;
	}

	add_call(nf, s);	/* uno_fcts.c */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1356
testq %rax, %rax
je 0x25bb
movq %rax, %r12
pushq $0x20
popq %rdi
callq 0x129c
movq %rbx, (%rax)
movq %r15, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq 0x30(%r12), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x30(%r12)
btl $0x9, %ebp
jae 0x25a8
movq %rbx, %rdi
callq 0x1356
testq %rax, %rax
je 0x25a8
orb $0x2, 0x15(%rax)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27fd
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: glob_mark
static void
glob_mark(Place *n, char *s, int bits)
{	Sym *r;

	for (r = globuse; r; r = r->nxt)
		if (strcmp(r->s, s) == 0)
		{	r->bits |= bits;
			break;
		}
	if (!r)
	{	r = (Sym *) emalloc(sizeof(Sym));
		r->s = s;
		r->bits = bits;
		r->n = n;
		r->nxt = globuse;
		globuse = r;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x5c65(%rip), %r12      # 0x8240
movq (%r12), %r12
testq %r12, %r12
je 0x25fa
movq (%r12), %rdi
movq %r15, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2620
addq $0x18, %r12
jmp 0x25db
pushq $0x20
popq %rdi
callq 0x129c
movq %r15, (%rax)
movl %ebx, 0x10(%rax)
movq %r14, 0x8(%rax)
movq 0x5c2d(%rip), %rcx      # 0x8240
movq %rcx, 0x18(%rax)
movq %rax, 0x5c22(%rip)      # 0x8240
jmp 0x2625
orl %ebx, 0x10(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: struct_flds
static void
struct_flds(Place *n, char *nm, int used)
{	PlaceName *p;

	for (p = fields; p; p = p->nxt)
		if (p->n->line == n->line
		&&  strcmp(p->n->fnm, n->fnm) == 0
		&&  strcmp(p->s, nm) == 0)
		{	p->used |= used;
			break;
		}
	if (!p)
	{	p = (PlaceName *) emalloc(sizeof(PlaceName));
		p->n = n;
		p->s = nm;
		p->used = used;
		p->nxt = fields;
		fields = p;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x5c00(%rip), %r12      # 0x8248
movq (%r12), %r12
testq %r12, %r12
je 0x2684
movq (%r12), %rax
movl 0x8(%rax), %ecx
cmpl 0x8(%r15), %ecx
jne 0x267e
movq (%rax), %rdi
movq (%r15), %rsi
callq 0x10f0
testl %eax, %eax
jne 0x267e
movq 0x8(%r12), %rdi
movq %r14, %rsi
callq 0x10f0
testl %eax, %eax
je 0x26b4
addq $0x18, %r12
jmp 0x2648
pushq $0x20
popq %rdi
callq 0x129c
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq 0x5bab(%rip), %rcx      # 0x8248
movq %rcx, 0x18(%rax)
movq %rax, 0x5ba0(%rip)      # 0x8248
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
orl %ebx, 0x10(%r12)
jmp 0x26a8
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: dfs
static void
dfs(Fct *g)
{	Sym *r;

	if (!g || g->visited) return;

	g->visited = 1;

	for (r = g->calls; r; r = r->nxt)
		dfs(find_fct(r->s));
}

// Assembly:
testq %rdi, %rdi
je 0x26cc
pushq %rbx
movq %rdi, %rbx
cmpw $0x0, 0x38(%rdi)
je 0x26cd
popq %rbx
retq
movw $0x1, 0x38(%rbx)
addq $0x30, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x26cb
movq (%rbx), %rdi
callq 0x1356
movq %rax, %rdi
callq 0x26bb
addq $0x18, %rbx
jmp 0x26d7
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_global.c
// Function: wind_down
static void
wind_down(Fct *f)
{	Fct *g;
	Sym *c;

	if (f)
	for (c = f->calls; c; c = c->nxt)
	{	g = find_fct(c->s);
		if (g && !(g->rval & 4))
		{	g->rval |= 4;
			wind_down(g);
	}	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x30, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2730
movq (%rbx), %rdi
callq 0x1356
testq %rax, %rax
je 0x272a
movzwl 0x12(%rax), %ecx
testb $0x4, %cl
jne 0x272a
orl $0x4, %ecx
movw %cx, 0x12(%rax)
movq %rax, %rdi
callq 0x26f5
addq $0x18, %rbx
jmp 0x26fd
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_fcts.c
// Function: add_fct
void
add_fct(char *s)
{	BFct *f;

	if (0 && debug) printf("adding fct %s\n", s);

	for (f = fcts; f; f = f->nxt)
		if (strcmp(f->fnm, s) == 0)
			return;	/* reported in uno_global.c */

	f = (BFct *) emalloc(sizeof(BFct));
	f->fnm = new_str(s);
	f->nxt = fcts;
	fcts = f;

	f->root = (Node *) emalloc(sizeof(Node));
	f->root->nid = 0;
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5b1d(%rip), %r14      # 0x8260
movq (%r14), %r14
testq %r14, %r14
je 0x2760
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
addq $0x20, %r14
testl %eax, %eax
jne 0x2743
jmp 0x279b
pushq $0x28
popq %r14
movq %r14, %rdi
callq 0x129c
movq %rax, %r15
movq %rbx, %rdi
callq 0x27a1
movq %rax, (%r15)
movq 0x5adf(%rip), %rax      # 0x8260
movq %rax, 0x20(%r15)
movq %r15, 0x5ad4(%rip)      # 0x8260
movq %r14, %rdi
callq 0x129c
movq %rax, 0x10(%r15)
andl $0x0, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_fcts.c
// Function: new_str
static char *
new_str(char *s)
{	Pool *p;
	char *t;
	int n;

	n = strlen(s);
	if (n > 0 && n < 512 && pool[n])
	{	p = pool[n];
		pool[n] = p->nxt;
		p->nxt = free_pool;
		free_pool = p;
		t = p->s;
	} else
		t = (char *) emalloc(n+1);
	strcpy(t, s);
	return t;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1080
movl %eax, %ecx
decl %ecx
cmpl $0x1fe, %ecx            # imm = 0x1FE
ja 0x27e7
movl %eax, %edx
leaq 0x5b11(%rip), %rsi      # 0x82d0
movq (%rsi,%rdx,8), %rcx
testq %rcx, %rcx
je 0x27e7
movq 0x8(%rcx), %rax
movq %rax, (%rsi,%rdx,8)
movq 0x6af9(%rip), %rax      # 0x92d0
movq %rax, 0x8(%rcx)
movq %rcx, 0x6aee(%rip)      # 0x92d0
movq (%rcx), %rdi
jmp 0x27f4
incl %eax
movslq %eax, %rdi
callq 0x129c
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_fcts.c
// Function: add_call
void
add_call(char *fnm, char *c)
{	BFct *f;
	BSym *s;

	f = find_function(fnm);
	if (!f)
	{	fprintf(stderr, "error: bad input sequence (%s)\n",
			fnm);
		exit(1);
	}

	for (s = f->calls; s; s = s->nxt)
		if (strcmp(s->s, c) == 0)
			return;

	s = (BSym *) emalloc(sizeof(BSym));
	s->s = new_str(c);
	s->nxt = f->calls;
	f->calls = s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2882
testq %rax, %rax
je 0x285f
movq %rax, %rbx
addq $0x8, %rbx
movq %rbx, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x2839
movq (%r15), %rdi
movq %r14, %rsi
callq 0x10f0
addq $0x8, %r15
testl %eax, %eax
jne 0x281c
jmp 0x2859
pushq $0x10
popq %rdi
callq 0x129c
movq %rax, %r15
movq %r14, %rdi
callq 0x27a1
movq %rax, (%r15)
movq (%rbx), %rax
movq %rax, 0x8(%r15)
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x578a(%rip), %rax      # 0x7ff0
movq (%rax), %rdi
leaq 0x2e80(%rip), %rsi      # 0x56f0
movq %r15, %rdx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x59d0(%rip), %rbx      # 0x8260
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x28ad
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x10f0
testl %eax, %eax
je 0x28ad
addq $0x20, %rbx
jmp 0x2890
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x5996(%rip), %r14      # 0x8260
leaq 0x3409(%rip), %rbx      # 0x5cda
movq %r14, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x2949
movq (%r13), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2943
movq %r14, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x2925
cmpq %r13, %r12
je 0x291f
movq %r12, %rbp
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
je 0x291f
movq (%rbp), %rdi
movq %r15, %rsi
callq 0x10f0
testl %eax, %eax
jne 0x2904
jmp 0x2943
addq $0x20, %r12
jmp 0x28f3
movq %r15, %rdi
callq 0x228a
testl %eax, %eax
jne 0x2943
movq (%r13), %rsi
leaq 0x2dd4(%rip), %rdi      # 0x5710
xorl %eax, %eax
callq 0x10a0
addq $0x20, %r13
jmp 0x28d4
movq 0x5680(%rip), %rax      # 0x7fd0
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x58eb(%rip), %r12      # 0x8268
addq $0x10, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x29a0
movq (%r12), %rdi
movq %r15, %rsi
callq 0x10f0
testl %eax, %eax
je 0x29d8
addq $0x20, %r12
jmp 0x2981
movq %r15, %rdi
callq 0x2a06
movq %rax, %r15
movq %r14, %rdi
callq 0x27a1
movq %rax, 0x8(%r15)
movl $0x1, 0x10(%r15)
movl %ebx, 0x14(%r15)
movq 0x589e(%rip), %rax      # 0x8268
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%r15)
movq %r15, 0x10(%rax)
jmp 0x29fa
movq 0x10(%r12), %xmm0
movd %ebx, %xmm1
movdqa 0x2cf5(%rip), %xmm2     # 0x56e0
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
por %xmm0, %xmm2
movq %xmm2, 0x10(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68c4(%rip), %r14      # 0x92d8
testq %r14, %r14
je 0x2a37
movq 0x20(%r14), %rax
movq %rax, 0x68b4(%rip)      # 0x92d8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
andq $0x0, 0x20(%r14)
jmp 0x2a42
pushq $0x28
popq %rdi
callq 0x129c
movq %rax, %r14
movq %rbx, %rdi
callq 0x27a1
movq %rax, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x5809(%rip), %rcx      # 0x8268
addq $0x10, %rcx
xorl %eax, %eax
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x2a7e
cmpl $0x0, 0x10(%rcx)
je 0x2a78
movl %edi, 0x18(%rcx)
incl %eax
addq $0x20, %rcx
jmp 0x2a65
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x57d5(%rip)      # 0x8260
je 0x2bb0
leaq 0x57d8(%rip), %rax      # 0x8270
movq %rax, 0x57c9(%rip)      # 0x8268
xorps %xmm0, %xmm0
movups %xmm0, 0x57c7(%rip)     # 0x8270
movups %xmm0, 0x57d0(%rip)     # 0x8280
movups %xmm0, 0x57d9(%rip)     # 0x8290
movups %xmm0, 0x57e2(%rip)     # 0x82a0
leaq 0x2d55(%rip), %rdi      # 0x581a
callq 0x2882
movq %rax, 0x680f(%rip)      # 0x92e0
testq %rax, %rax
jne 0x2b37
leaq 0x5633(%rip), %rax      # 0x8110
cmpl $0x0, (%rax)
je 0x2aee
leaq 0x31fa(%rip), %rdi      # 0x5ce3
callq 0x1060
leaq 0x2d25(%rip), %rdi      # 0x581a
callq 0x2734
xorl %ebx, %ebx
leaq 0x519d(%rip), %r14      # 0x7ca0
cmpq $0x138, %rbx            # imm = 0x138
je 0x2b1b
movq (%rbx,%r14), %rdi
callq 0x2cf2
addq $0x8, %rbx
jmp 0x2b03
leaq 0x2cf8(%rip), %rdi      # 0x581a
callq 0x2882
movq %rax, 0x67b2(%rip)      # 0x92e0
testq %rax, %rax
je 0x2bb8
movq %rax, %rdi
xorl %esi, %esi
callq 0x3064
testq %rax, %rax
je 0x2b59
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2b59
movq (%rax), %rax
movq %rax, 0x678f(%rip)      # 0x92e8
callq 0x2148
leaq 0x3175(%rip), %rdi      # 0x5cda
callq 0x2882
testq %rax, %rax
je 0x2b7b
movq %rax, %rdi
xorl %esi, %esi
callq 0x2bdc
jmp 0x2b87
leaq 0x3139(%rip), %rdi      # 0x5cbb
callq 0x1060
leaq 0x5582(%rip), %rax      # 0x8110
cmpl $0x0, (%rax)
je 0x2bb0
movl 0x5563(%rip), %esi      # 0x80fc
decl %esi
leaq 0x2b78(%rip), %rdi      # 0x571a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x5431(%rip), %rax      # 0x7ff0
movq (%rax), %rcx
leaq 0x2c1d(%rip), %rdi      # 0x57e6
pushq $0x33
popq %rsi
pushq $0x1
popq %rdx
callq 0x1170
pushq $0x1
popq %rdi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_fcts.c
// Function: do_fct_call
static void
do_fct_call(BFct *f, Node *sys)
{	Rstack *r, *or;
	BFct *g;
	BSym *s;
	Node *n;

	f->visited = 1;	/* prevent fct call cycles */

	if (free_rstack)
	{	r = free_rstack;
		free_rstack = free_rstack->nxt;
		memset(r, 0, sizeof(Rstack));
	} else
		r = (Rstack *) emalloc(sizeof(Rstack));

	r->f = f;
	r->n = sys;	/* continuation point for return from fct in end_of_path */
	r->nxt = rstack;
	rstack = r;

	stack->fc = f;	/* remember for error trace */

	n = find_node(f, 0);
	if (n && n->succ)
	{	if (debug) printf("%3d: dive in\n", depth);
		check_prop(n->succ);
		if (debug) printf("%3d: undive\n", depth);
	} else
	{	if (debug) printf("%3d: no visible operations (calls: %p)\n", depth, f->calls);

		/* if we're here, then probably f->calls is also nil, or else
		 * there would be an abstract call graph for this fct with the
		 * call points recorded...
		 */

		if (!f->calls)	/* expected */
		{	end_of_path();	/* continuation with sys */
		} else
		{	fprintf(stderr, "%3d: unexpected...\n", depth);
			for (s = f->calls; s; s = s->nxt)
			{	g = find_function(s->s);
				if (g && !g->visited)
				{	if (debug) printf("	ByPass Call on %s\n", s->s);
					do_fct_call(g, (Node *) 0); /* no continuation within this fct */
					if (debug) printf("	Return from ByPass Call on %s\n", s->s);
	}	}	}	}

	stack->fc = (BFct *) 0;

	or = rstack;
	rstack = rstack->nxt;
	or->nxt = free_rstack;
	free_rstack = or;

	f->visited = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movw $0x1, 0x18(%rdi)
movq 0x66fd(%rip), %rax      # 0x92f0
testq %rax, %rax
je 0x2c10
movq 0x10(%rax), %rcx
movq %rcx, 0x66ed(%rip)      # 0x92f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
jmp 0x2c18
pushq $0x18
popq %rdi
callq 0x129c
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movq 0x66d2(%rip), %rcx      # 0x92f8
movq %rcx, 0x10(%rax)
movq %rax, 0x66c7(%rip)      # 0x92f8
movq 0x5630(%rip), %rax      # 0x8268
movq %rbx, 0x28(%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3064
testq %rax, %rax
je 0x2c5b
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x2c5b
callq 0x30a0
jmp 0x2c67
cmpq $0x0, 0x8(%rbx)
jne 0x2ca4
callq 0x33f9
movq 0x55fa(%rip), %rax      # 0x8268
andq $0x0, 0x28(%rax)
movq 0x667e(%rip), %rax      # 0x92f8
movq 0x10(%rax), %rcx
movq %rcx, 0x6673(%rip)      # 0x92f8
movq 0x6664(%rip), %rcx      # 0x92f0
movq %rcx, 0x10(%rax)
movq %rax, 0x6659(%rip)      # 0x92f0
andw $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rbx), %r14
movq 0x5341(%rip), %rax      # 0x7ff0
movq (%rax), %rdi
movl 0x6648(%rip), %edx      # 0x9300
leaq 0x2ce9(%rip), %rsi      # 0x59a8
xorl %eax, %eax
callq 0x1100
movq (%r14), %r14
testq %r14, %r14
je 0x2c67
movq (%r14), %rdi
callq 0x2882
testq %rax, %rax
je 0x2cec
cmpw $0x0, 0x18(%rax)
jne 0x2cec
movq %rax, %rdi
xorl %esi, %esi
callq 0x2bdc
addq $0x8, %r14
jmp 0x2cc6
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x129c
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x3064
movq %rax, %r12
movq %r14, %rdi
movl %ebx, %esi
callq 0x3064
movq %rax, (%r15)
movq 0x10(%r12), %rax
movq %rax, 0x10(%r15)
movq %r15, 0x10(%r12)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
addq $0x10, %rbx
movq %rbx, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x3085
cmpl %ebp, (%rax)
je 0x3099
addq $0x20, %rax
jmp 0x3073
pushq $0x28
popq %rdi
callq 0x129c
movl %ebp, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x20(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_fcts.c
// Function: end_of_path
static void
end_of_path(void)
{	Arc	*a;
	Rstack	*r;

	if (!rstack) return;

	r = rstack;
	rstack = rstack->nxt;

	stack->fr = rstack?rstack->f:(BFct *) 0;	/* remember for error traces */

	if (debug)
	printf("%3d:\tFCT EXITS -- %s -- return to %s\n", depth,
		r->f->fnm, rstack?rstack->f->fnm:"--");

	if (!r->n || !r->n->succ)		/* no continuation point */
	{	if (debug) printf("%3d: no continuation point\n", depth);
		end_of_path();			/* ? */
	} else
		for (a = r->n->succ; a; a = a->nxt)	/* continuation in caller */
		{	if (debug) printf("%3d:\tCONTinuation in %s [%d->%d]\n", depth,
				rstack?rstack->f->fnm:"--", r->n->nid, a->to->nid);
			check_prop(a);
			if (debug) printf("%3d:\tUN_CONT %s [%d->%d]\n", depth,
				rstack?rstack->f->fnm:"--", a->to->nid, r->n->nid);
		}
	r->nxt = rstack;
	rstack = r;

	stack->fr = (BFct *) 0;

	if (debug)
	printf("%3d:\tFCT UN_EXITS -- %s\n", depth, r->f->fnm);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x5ef4(%rip), %r14      # 0x92f8
testq %r14, %r14
je 0x3473
movq 0x10(%r14), %rax
movq %rax, 0x5ee4(%rip)      # 0x92f8
testq %rax, %rax
je 0x341e
movq (%rax), %rax
jmp 0x3420
xorl %eax, %eax
movq 0x4e41(%rip), %rcx      # 0x8268
movq %rax, 0x30(%rcx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x343d
movq 0x10(%rax), %rbx
testq %rbx, %rbx
jne 0x3450
callq 0x33f9
jmp 0x3455
movq %rbx, %rdi
callq 0x30a0
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x3444
movq 0x5e9c(%rip), %rax      # 0x92f8
movq %rax, 0x10(%r14)
movq %r14, 0x5e91(%rip)      # 0x92f8
movq 0x4dfa(%rip), %rax      # 0x8268
andq $0x0, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x42a1
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x4214
movq (%rbx), %rdi
callq 0x1080
movq %rax, %r14
decl %eax
cmpl $0x1fe, %eax            # imm = 0x1FE
ja 0x4284
movq 0x5088(%rip), %rax      # 0x92d0
testq %rax, %rax
je 0x4260
movq 0x8(%rax), %rcx
movq %rcx, 0x5078(%rip)      # 0x92d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
jmp 0x4268
pushq $0x10
popq %rdi
callq 0x129c
movq (%rbx), %rcx
movq %rcx, (%rax)
movl %r14d, %ecx
leaq 0x4058(%rip), %rdx      # 0x82d0
movq (%rdx,%rcx,8), %rsi
movq %rsi, 0x8(%rax)
movq %rax, (%rdx,%rcx,8)
andq $0x0, (%rbx)
movq 0x5049(%rip), %rax      # 0x92d8
movq %rax, 0x20(%rbx)
movq %rbx, 0x503e(%rip)      # 0x92d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x432f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x42a2
movq (%rbx), %rdi
callq 0x1080
movq %rax, %r14
decl %eax
cmpl $0x1fe, %eax            # imm = 0x1FE
ja 0x4312
movq 0x4ffa(%rip), %rax      # 0x92d0
testq %rax, %rax
je 0x42ee
movq 0x8(%rax), %rcx
movq %rcx, 0x4fea(%rip)      # 0x92d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
jmp 0x42f6
pushq $0x10
popq %rdi
callq 0x129c
movq (%rbx), %rcx
movq %rcx, (%rax)
movl %r14d, %ecx
leaq 0x3fca(%rip), %rdx      # 0x82d0
movq (%rdx,%rcx,8), %rsi
movq %rsi, 0x8(%rax)
movq %rax, (%rdx,%rcx,8)
andq $0x0, (%rbx)
movq 0x4ff3(%rip), %rax      # 0x9310
movq %rax, 0x8(%rbx)
movq %rbx, 0x4fe8(%rip)      # 0x9310
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4fd2(%rip), %r14      # 0x9310
testq %r14, %r14
je 0x4357
movq 0x8(%r14), %rax
movq %rax, 0x4fc2(%rip)      # 0x9310
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
jmp 0x4362
pushq $0x10
popq %rdi
callq 0x129c
movq %rax, %r14
movq %rbx, %rdi
callq 0x27a1
movq %rax, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4440
movq %rsi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x440e
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x440e
movq (%rax), %rdx
addq $0x2, %rdx
leaq 0x1728(%rip), %rdi      # 0x5b27
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10a0
pushq $0x1
popq %rbp
jmp 0x4442
movq (%rdi), %rax
movq (%rax), %r14
leaq 0x18bf(%rip), %rsi      # 0x5cda
movq %r14, %rdi
callq 0x10f0
pushq $0x1
popq %rbp
testl %eax, %eax
je 0x4442
leaq 0x16fe(%rip), %rdi      # 0x5b2f
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10a0
jmp 0x4442
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x4539
movl %esi, %ebx
movq %rdi, %r14
movq 0x38(%rdi), %rdi
leal -0x1(%rbx), %esi
callq 0x4449
movq (%r14), %r12
testq %r12, %r12
je 0x44c4
movq (%r12), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x44c4
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x44c4
leaq 0x16aa(%rip), %r15      # 0x5b39
xorl %ebp, %ebp
cmpl 0x4e81(%rip), %ebp      # 0x9318
jge 0x44a7
movq %r15, %rdi
xorl %eax, %eax
callq 0x10a0
incl %ebp
jmp 0x4491
movq (%r12), %rax
movl (%rax), %edx
movq 0x8(%rax), %rax
movq (%rax), %rcx
leaq 0x1682(%rip), %rdi      # 0x5b3d
movl %ebx, %esi
xorl %eax, %eax
callq 0x10a0
cmpq $0x0, 0x28(%r14)
je 0x4511
movl 0x4e47(%rip), %eax      # 0x9318
incl %eax
movl %eax, 0x4e3f(%rip)      # 0x9318
leaq 0x1659(%rip), %r15      # 0x5b39
xorl %ebp, %ebp
cmpl %eax, %ebp
jge 0x44fa
movq %r15, %rdi
xorl %eax, %eax
callq 0x10a0
incl %ebp
movl 0x4e20(%rip), %eax      # 0x9318
jmp 0x44e2
movq 0x28(%r14), %rax
movq (%rax), %rdx
leaq 0x1643(%rip), %rdi      # 0x5b4b
movl %ebx, %esi
xorl %eax, %eax
callq 0x10a0
cmpq $0x0, 0x30(%r14)
je 0x4539
leaq 0x161a(%rip), %r15      # 0x5b39
xorl %ebp, %ebp
movl 0x4df1(%rip), %eax      # 0x9318
cmpl %eax, %ebp
jge 0x4542
movq %r15, %rdi
xorl %eax, %eax
callq 0x10a0
incl %ebp
jmp 0x4521
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
decl %eax
movl %eax, 0x4dce(%rip)      # 0x9318
movq 0x30(%r14), %rax
movq (%rax), %rdx
leaq 0x1609(%rip), %rdi      # 0x5b61
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
xorl %r14d, %r14d
pushq $0xa
popq %rsi
movl %edi, %ecx
movl %ecx, %eax
cltd
idivl %esi
movl %edx, %r8d
negl %r8d
cmovsl %edx, %r8d
addb $0x30, %r8b
movb %r8b, (%rbx,%r14)
incq %r14
addl $0x9, %ecx
cmpl $0x12, %ecx
movl %eax, %ecx
ja 0x118b
testl %edi, %edi
jns 0x11bd
movl %r14d, %eax
incq %r14
movb $0x2d, (%rbx,%rax)
callq 0x1209
movslq %r14d, %rcx
shlq $0x20, %r14
addq %rbx, %rcx
movabsq $0x100000000, %rdx      # imm = 0x100000000
cmpl %ebp, %eax
jge 0x11e7
movb $0x20, (%rcx)
decl %ebp
addq %rdx, %r14
incq %rcx
jmp 0x11d6
sarq $0x20, %r14
movb $0x0, (%rbx,%r14)
movq %rbx, %rdi
callq 0x1040
leal -0x1(%rax), %edx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x1222
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edx, %ecx
pushq $0x2
popq %r8
movl %edx, %eax
cltd
idivl %r8d
movslq %esi, %rdx
movslq %ecx, %rcx
cltq
incq %rax
subq %rdx, %rcx
addq %rdi, %rcx
movb (%rdi,%rdx), %sil
movb (%rcx), %r8b
movb %r8b, (%rdi,%rdx)
movb %sil, (%rcx)
incq %rdx
decq %rcx
cmpq %rdx, %rax
jne 0x123f
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3afb
cmpw $0x3, %ax
jne 0x12b3
xorl %edi, %edi
callq 0x3b81
movq %r14, %rdi
movq %rax, %rsi
callq 0x3b22
movq %rax, %r15
pushq $0x1
popq %rdi
callq 0x3b81
movq %r14, %rdi
movq %rax, %rsi
callq 0x3b22
movq %rax, %rdi
movq %rbx, %rsi
callq 0x125a
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3e73
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3afb
cmpw $0x3, %ax
jne 0x1342
xorl %edi, %edi
callq 0x3b81
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b22
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x3b81
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b22
movq %rax, %rbx
movq %r14, %rdi
callq 0x1354
movq %rax, %r14
movq %rbx, %rdi
callq 0x12e0
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3e73
leaq 0x25edf(%rip), %rax     # 0x27228
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq