LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/sequential-trie.c
// Function: search
int search  (const char *string, size_t strlen, int32_t *ip4_address) {
  struct trie_node *found;

  // Skip strings of length 0
  if (strlen == 0)
  return 0;

  found = _search(root, string, strlen);

  if (found && ip4_address)
  *ip4_address = found->ip4_address;

  return (found != NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15e4
movl $0x0, -0x4(%rbp)
jmp 0x1627
movq 0x3afd(%rip), %rdi      # 0x50e8
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1480
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1617
cmpq $0x0, -0x20(%rbp)
je 0x1617
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/sequential-trie.c
// Function: insert
int insert (const char *string, size_t strlen, int32_t ip4_address) {
          // Skip strings of length 0
          //int rv;
          while(allow_squatting && search(string, strlen, &ip4_address)) {
            printf("Thread: %ld entered the squatting deadlock\n", pthread_self());
            pthread_testcancel();
            //rv = pthread_cond_wait(&cv, &lock);
            //assert(rv == 0);
          }
          if (strlen == 0)
          return 0;

          /* Edge case: root is null */
          if (root == NULL) {
            root = new_leaf (string, strlen, ip4_address);
            return 1;
          }
          return _insert (string, strlen, ip4_address, root, NULL, NULL);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
xorl %eax, %eax
leaq 0x34c4(%rip), %rcx      # 0x50f0
cmpl $0x0, (%rcx)
movb %al, -0x1d(%rbp)
je 0x1c4e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x15c0
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x1c57
jmp 0x1c74
callq 0x1110
movq %rax, %rsi
leaq 0x1616(%rip), %rdi      # 0x327c
movb $0x0, %al
callq 0x1070
callq 0x10c0
jmp 0x1c23
cmpq $0x0, -0x18(%rbp)
jne 0x1c84
movl $0x0, -0x4(%rbp)
jmp 0x1cd0
cmpq $0x0, 0x345c(%rip)      # 0x50e8
jne 0x1cae
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x1290
movq %rax, 0x3443(%rip)      # 0x50e8
movl $0x1, -0x4(%rbp)
jmp 0x1cd0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq 0x3428(%rip), %rcx      # 0x50e8
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0x1630
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/sequential-trie.c
// Function: delete
int delete  (const char *string, size_t strlen) {
            // Skip strings of length 0
            if (strlen == 0)
            return 0;

            return (NULL != _delete(root, string, strlen));
          }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1fe0
movl $0x0, -0x4(%rbp)
jmp 0x2007
movq 0x3101(%rip), %rdi      # 0x50e8
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1ce0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x12e9(%rip), %rdi      # 0x3318
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rsi
leaq 0x1309(%rip), %rdi      # 0x334a
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rdx
addq $0x18, %rdx
leaq 0x12fa(%rip), %rdi      # 0x3358
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0x12f1(%rip), %rdi      # 0x3364
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x12e5(%rip), %rdi      # 0x336d
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x12da(%rip), %rdi      # 0x3378
movb $0x0, %al
callq 0x1070
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x12d2(%rip), %rdi      # 0x3384
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2103
leaq 0x12ea(%rip), %rdi      # 0x33b5
movb $0x0, %al
callq 0x1070
leaq 0x12ed(%rip), %rdi      # 0x33c6
movb $0x0, %al
callq 0x1070
leaq 0x12cf(%rip), %rdi      # 0x33b6
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
xorl %edx, %edx
callq 0x2010
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x214c
leaq 0x12d5(%rip), %rdi      # 0x33e9
movb $0x0, %al
callq 0x1070
leaq 0x12d8(%rip), %rdi      # 0x33fa
movb $0x0, %al
callq 0x1070
leaq 0x12ba(%rip), %rdi      # 0x33ea
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
addl $0x1, %edx
callq 0x2010
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0x2f7d(%rip), %rsi      # 0x50e8
leaq 0x12ac(%rip), %rdi      # 0x341e
movb $0x0, %al
callq 0x1070
cmpq $0x0, 0x2f67(%rip)      # 0x50e8
je 0x2193
movq 0x2f5e(%rip), %rdi      # 0x50e8
xorl %edx, %edx
movl %edx, %esi
callq 0x2010
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x1046(%rip), %rdi      # 0x3681
movb $0x0, %al
callq 0x1070
leaq 0x106b(%rip), %rdi      # 0x36b4
movb $0x0, %al
callq 0x1070
leaq 0x1067(%rip), %rdi      # 0x36be
movb $0x0, %al
callq 0x1070
leaq 0x1083(%rip), %rdi      # 0x36e8
movb $0x0, %al
callq 0x1070
leaq 0x108d(%rip), %rdi      # 0x3700
movb $0x0, %al
callq 0x1070
leaq 0x10ad(%rip), %rdi      # 0x372e
movb $0x0, %al
callq 0x1070
leaq 0x10e5(%rip), %rdi      # 0x3774
movb $0x0, %al
callq 0x1070
leaq 0x114d(%rip), %rdi      # 0x37ea
movb $0x0, %al
callq 0x1070
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x10e0
movl %eax, -0xc(%rbp)
movl 0x26da(%rip), %eax      # 0x50f4
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2a2b
jmp 0x2ac4
movl -0xc(%rbp), %edx
leaq 0xa43(%rip), %rdi       # 0x3478
movl $0x3, %esi
callq 0x1c10
movl -0xc(%rbp), %edx
leaq 0xebe(%rip), %rdi       # 0x3907
movl $0x3, %esi
callq 0x1c10
movl -0xc(%rbp), %edx
leaq 0xeae(%rip), %rdi       # 0x390b
movl $0x3, %esi
callq 0x1c10
movl -0xc(%rbp), %edx
leaq 0xe9e(%rip), %rdi       # 0x390f
movl $0x3, %esi
callq 0x1c10
leaq 0x9f6(%rip), %rdi       # 0x3478
movl $0x3, %esi
callq 0x1fc0
leaq 0xe74(%rip), %rdi       # 0x3907
movl $0x3, %esi
callq 0x1fc0
leaq 0xe67(%rip), %rdi       # 0x390b
movl $0x3, %esi
callq 0x1fc0
leaq 0xe5a(%rip), %rdi       # 0x390f
movl $0x3, %esi
callq 0x1fc0
jmp 0x2a14
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12b2
movq 0x9d61(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x5e43(%rip), %rsi      # 0x70e4
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1140
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x10a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12f4
movq -0x10(%rbp), %rax
movswl 0x38(%rax), %eax
cmpl $0x0, %eax
je 0x1300
movl $0x0, -0x4(%rbp)
jmp 0x139b
movq -0x10(%rbp), %rax
movw $0x1, 0x38(%rax)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1395
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x13b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x1347
movl $0x1, -0x2c(%rbp)
jmp 0x1357
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x12d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x1385
movq 0x9c74(%rip), %rax      # 0xafd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
leaq 0x5d83(%rip), %rsi      # 0x70ff
movb $0x0, %al
callq 0x10d0
jmp 0x1395
jmp 0x1387
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x131d
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%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_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x13d8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x149f
movq 0x9fa9(%rip), %rax      # 0xb388
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1411
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x1401
jmp 0x1411
jmp 0x1403
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13e3
cmpq $0x0, -0x18(%rbp)
jne 0x1497
movq -0x10(%rbp), %rdi
leaq 0x5ef8(%rip), %rsi      # 0x731b
callq 0x10c0
cmpl $0x0, %eax
jne 0x146e
movl $0x10, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x5ed5(%rip), %rcx      # 0x731b
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2780
movq 0x9f29(%rip), %rax      # 0xb388
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3330
jmp 0x1495
cmpl $0x0, 0x9f23(%rip)      # 0xb398
je 0x1493
movq 0x9b7a(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x6057(%rip), %rsi      # 0x74e3
movb $0x0, %al
callq 0x10d0
jmp 0x1495
jmp 0x1497
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_global.c
// Function: uno_load
static void
uno_load(char *f)
{	FILE	*fd;
	char	buf[2048];

	if (0) fprintf(stderr, "uno:global: load %s\n", f);

	if ((fd = fopen(f, "r")) == NULL)
	{	fprintf(stderr, "uno:global: cannot open %s\n", f);
		exit(1);
	}

	while (fgets(buf, sizeof(buf), fd))
		switch (buf[0]) {
		case '{':
		case '<':
		case '>':
		case '[':
		case ':':
			handle_fct(buf);
			break;
		default:
			handle_glb(buf, f);
			break;
		}

	fclose(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x820, %rsp            # imm = 0x820
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x57cf(%rip), %rsi      # 0x7129
callq 0x1110
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x198f
movq 0x9688(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x5c1c(%rip), %rsi      # 0x759a
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1140
jmp 0x1991
leaq -0x810(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x800, %esi            # imm = 0x800
callq 0x10b0
cmpq $0x0, %rax
je 0x1a17
movsbl -0x810(%rbp), %eax
movl %eax, -0x814(%rbp)
subl $0x3a, %eax
je 0x19f4
jmp 0x19c0
movl -0x814(%rbp), %eax
subl $0x3c, %eax
je 0x19f4
jmp 0x19cd
movl -0x814(%rbp), %eax
subl $0x3e, %eax
je 0x19f4
jmp 0x19da
movl -0x814(%rbp), %eax
subl $0x5b, %eax
je 0x19f4
jmp 0x19e7
movl -0x814(%rbp), %eax
subl $0x7b, %eax
jne 0x1a02
jmp 0x19f4
leaq -0x810(%rbp), %rdi
callq 0x3d00
jmp 0x1a12
leaq -0x810(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2940
jmp 0x1991
movq -0x10(%rbp), %rdi
callq 0x1050
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_global.c
// Function: all_fcg
static void
all_fcg(FILE *fd)
{	Fct *g;
	Sym *r;

	fprintf(fd, "digraph dodot {\n\tratio=auto;\n");
	for (g = fcts; g; g = g->nxt)
	{	fprintf(fd, "N%s [label=\"%s:%d\"];\n",
			g->fnm, g->fnm, g->n->line);

		for (r = g->calls; r; r = r->nxt)
			fprintf(fd, "N%s -> N%s;\n",
				g->fnm, r->s);
	}
	fprintf(fd, "}\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x58b3(%rip), %rsi      # 0x72fa
movb $0x0, %al
callq 0x10d0
movq 0x9933(%rip), %rax      # 0xb388
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ae4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %r8d
leaq 0x591e(%rip), %rsi      # 0x73a7
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1ad1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x5643(%rip), %rsi      # 0x70ff
movb $0x0, %al
callq 0x10d0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1a9c
jmp 0x1ad3
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1a59
movq -0x8(%rbp), %rdi
leaq 0x5829(%rip), %rsi      # 0x7318
movb $0x0, %al
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_global.c
// Function: gen_fcts
static void
gen_fcts(FILE *fd)
{
	fprintf(fd, "digraph dodot {\n\tratio=auto;\n");
	fcts_reset();
	gen_fct(fd, find_fct(want));
	fprintf(fd, "}\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x57e3(%rip), %rsi      # 0x72fa
movb $0x0, %al
callq 0x10d0
callq 0x1b60
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x95b6(%rip), %rdi      # 0xb0e8
callq 0x13b0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x2600
movq -0x8(%rbp), %rdi
leaq 0x57ca(%rip), %rsi      # 0x7318
movb $0x0, %al
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_global.c
// Function: struct_check
static void
struct_check(void)
{	PlaceName *p;

	for (p = fields; p; p = p->nxt)
		if (p->used == 0
		&&  strncmp(p->s, "unused", strlen("unused")) != 0)
			printf("uno:global: %s:%d possibly redundant field '%s'\n",
				p->n->fnm, p->n->line, p->s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x9801(%rip), %rax      # 0xb3a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c0c
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1bfc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x599f(%rip), %rsi      # 0x7562
movl $0x6, %edx
callq 0x1030
cmpl $0x0, %eax
je 0x1bfc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x5974(%rip), %rdi      # 0x7569
movb $0x0, %al
callq 0x1080
jmp 0x1bfe
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ba3
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_global.c
// Function: glob_check
static void
glob_check(void)
{	Sym *r;

	for (r = globuse; r; r = r->nxt)
	{
		if (find_fct(r->s))
			continue;	/* fct mistaken for a var */

		switch (r->bits) {	/* no match if ALIAS bits are set */
		case 0:	printf("uno:global: %s:%d '%s' never used or set\n",
				r->n->fnm, r->n->line, r->s);
			break;
		case USE:
			if (usecheck)
			printf("uno:global: %s:%d '%s' used but never set\n",
				r->n->fnm, r->n->line, r->s);
			break;
		case DEF:
			if (usecheck)
			printf("uno:global: %s:%d '%s' set but never used\n",
				r->n->fnm, r->n->line, r->s);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x9761(%rip), %rax      # 0xb390
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1d28
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x13b0
cmpq $0x0, %rax
je 0x1c55
jmp 0x1d17
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x1c7c
jmp 0x1c65
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x1cdf
jmp 0x1c6f
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x1ca9
jmp 0x1d15
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
leaq 0x571d(%rip), %rdi      # 0x73bd
movb $0x0, %al
callq 0x1080
jmp 0x1d15
cmpl $0x0, 0x95b4(%rip)      # 0xb264
je 0x1cdd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
leaq 0x5711(%rip), %rdi      # 0x73e7
movb $0x0, %al
callq 0x1080
jmp 0x1d15
cmpl $0x0, 0x957e(%rip)      # 0xb264
je 0x1d13
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
leaq 0x5706(%rip), %rdi      # 0x7412
movb $0x0, %al
callq 0x1080
jmp 0x1d15
jmp 0x1d17
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c33
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_global.c
// Function: unostats
static void
unostats(void)
{	Sym *r;
	Fct *f;
	int cnt = 0, d = 0, u = 0, c = 0, x = 0;

	for (f = fcts; f; f = f->nxt)
	{	cnt++;
		for (r = f->defs;  r; r = r->nxt)
			d++;
		for (r = f->uses;  r; r = r->nxt)
			u++;
		for (r = f->deref;  r; r = r->nxt)
			x++;
		for (r = f->calls; r; r = r->nxt)
			c++;
	}
	printf("%6d	function declarations\n", cnt-1);
	printf("%6d	function calls\n", c);
	printf("%6d	global variable definitions\n", d);
	printf("%6d	global variable uses\n", u);
	printf("%6d	global variable dereferences\n", x);

	cnt = 0;
	for (r = globuse; r; r = r->nxt)
		if (!find_fct(r->s))
			cnt++;
	printf("%6d	global ptr variables\n", cnt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq 0x9106(%rip), %rax      # 0xb388
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2355
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x22c4
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22a6
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x22ee
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22d0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2318
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22fa
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2342
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2324
jmp 0x2344
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2286
movl -0x14(%rbp), %esi
subl $0x1, %esi
leaq 0x50db(%rip), %rdi      # 0x743d
movb $0x0, %al
callq 0x1080
movl -0x20(%rbp), %esi
leaq 0x50e5(%rip), %rdi      # 0x7458
movb $0x0, %al
callq 0x1080
movl -0x18(%rbp), %esi
leaq 0x50e8(%rip), %rdi      # 0x746c
movb $0x0, %al
callq 0x1080
movl -0x1c(%rbp), %esi
leaq 0x50f8(%rip), %rdi      # 0x748d
movb $0x0, %al
callq 0x1080
movl -0x24(%rbp), %esi
leaq 0x5101(%rip), %rdi      # 0x74a7
movb $0x0, %al
callq 0x1080
movl $0x0, -0x14(%rbp)
movq 0x8fd5(%rip), %rax      # 0xb390
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x23f1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x13b0
cmpq $0x0, %rax
jne 0x23e1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x23e3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x23bf
movl -0x14(%rbp), %esi
leaq 0x50ce(%rip), %rdi      # 0x74c9
movb $0x0, %al
callq 0x1080
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4efc(%rip), %rdi      # 0x731b
callq 0x13b0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x2433
jmp 0x24ef
leaq 0x4eea(%rip), %rdi      # 0x7324
callq 0x3d00
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2500
movq 0x8c95(%rip), %rdi      # 0xb0e8
callq 0x13b0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x247e
movq 0x8c7f(%rip), %rsi      # 0xb0e8
leaq 0x4ec1(%rip), %rdi      # 0x7331
movb $0x0, %al
callq 0x1080
callq 0x35d0
jmp 0x24ef
movl 0x8c6c(%rip), %edx      # 0xb0f0
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x8c61(%rip)      # 0xb0f0
leaq 0x8dea(%rip), %rdi      # 0xb280
leaq 0x4ece(%rip), %rsi      # 0x736b
movb $0x0, %al
callq 0x1130
leaq 0x8dd5(%rip), %rdi      # 0xb280
callq 0x3d00
movq 0x8c31(%rip), %rdx      # 0xb0e8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %r8d
leaq 0x8dab(%rip), %rdi      # 0xb280
leaq 0x4e94(%rip), %rsi      # 0x7370
movb $0x0, %al
callq 0x1130
leaq 0x8d96(%rip), %rdi      # 0xb280
callq 0x3d00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2515
jmp 0x2593
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2500
movl 0x8bc8(%rip), %edx      # 0xb0f0
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x8bbd(%rip)      # 0xb0f0
leaq 0x8d46(%rip), %rdi      # 0xb280
leaq 0x4e2a(%rip), %rsi      # 0x736b
movb $0x0, %al
callq 0x1130
leaq 0x8d31(%rip), %rdi      # 0xb280
callq 0x3d00
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %r8d
leaq 0x8d07(%rip), %rdi      # 0xb280
leaq 0x4fd5(%rip), %rsi      # 0x7555
movb $0x0, %al
callq 0x1130
leaq 0x8cf2(%rip), %rdi      # 0xb280
callq 0x3d00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x8dcd(%rip), %rax      # 0xb380
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x25ec
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x25dc
movl $0x1, -0x4(%rbp)
jmp 0x25f3
jmp 0x25de
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x25b7
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_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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2624
movq -0x10(%rbp), %rax
movswl 0x38(%rax), %eax
cmpl $0x0, %eax
je 0x2629
jmp 0x276c
movq -0x10(%rbp), %rax
movw $0x1, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %r8d
leaq 0x4d4f(%rip), %rsi      # 0x73a7
movb $0x0, %al
callq 0x10d0
cmpl $0x0, 0x8c06(%rip)      # 0xb26c
je 0x26f8
movq 0x8d15(%rip), %rax      # 0xb388
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x26f6
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x26e6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x26d6
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0x4a3d(%rip), %rsi      # 0x70ff
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2600
jmp 0x26d8
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x268a
jmp 0x26e8
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2677
jmp 0x276c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x276a
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x273c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x49ca(%rip), %rsi      # 0x70ff
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x13b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x2600
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2704
jmp 0x276c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x8bee(%rip), %rax      # 0xb388
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x28e4
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x28d1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x2815
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x1150
cmpq $0x0, %rax
jne 0x2810
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0x1150
cmpq $0x0, %rax
je 0x2815
jmp 0x28e4
movq -0x20(%rbp), %rax
cmpw $0x0, 0x10(%rax)
je 0x282a
cmpl $0x0, -0x14(%rbp)
jne 0x28cf
movq 0x87c7(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x4cc0(%rip), %rsi      # 0x74ff
movb $0x0, %al
callq 0x10d0
movq 0x87ab(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movswl 0x10(%rax), %esi
leaq 0x579f(%rip), %r8       # 0x8014
leaq 0x4cb6(%rip), %rax      # 0x7532
cmpl $0x0, %esi
cmovneq %rax, %r8
leaq 0x4c99(%rip), %rsi      # 0x7523
movb $0x0, %al
callq 0x10d0
movq 0x8760(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movl -0x14(%rbp), %esi
leaq 0x5761(%rip), %r8       # 0x8014
leaq 0x4c78(%rip), %rax      # 0x7532
cmpl $0x0, %esi
cmovneq %rax, %r8
leaq 0x4c74(%rip), %rsi      # 0x753c
movb $0x0, %al
callq 0x10d0
jmp 0x28e4
jmp 0x28d3
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x279e
cmpq $0x0, -0x20(%rbp)
jne 0x2938
movl $0x48, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x10(%rax)
movq 0x8a63(%rip), %rcx      # 0xb388
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x8a50(%rip)      # 0xb388
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_global.c
// Function: mknm
static char *
mknm(char *s)
{	char *n;

	n = (char *) emalloc(strlen(s)+1);
	strcpy(n, s);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1270
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1040
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_global.c
// Function: retval
static void
retval(char *s, int status)
{	Fct *f;

	if (s)
	if ((f = find_fct(s)) != NULL)	/* assign f */
		f->rval = status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2e09
movq -0x8(%rbp), %rdi
callq 0x13b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2e07
movl -0xc(%rbp), %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x12(%rax)
jmp 0x2e09
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2e39
jmp 0x2e7a
movl $0x20, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_global.c
// Function: glob_use
static void
glob_use(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->uses;
	f->uses = r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2ea9
jmp 0x2eea
movl $0x20, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_global.c
// Function: glob_deref
static void
glob_deref(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->deref;
	f->deref = r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2f19
jmp 0x2f5a
movl $0x20, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13b0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x2f8f
jmp 0x301c
movl $0x20, %edi
callq 0x1270
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0x1c(%rbp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x300f
movq -0x18(%rbp), %rdi
callq 0x13b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x300d
movq -0x30(%rbp), %rax
movswl 0x14(%rax), %ecx
orl $0x200, %ecx            # imm = 0x200
movw %cx, 0x14(%rax)
jmp 0x300f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x8346(%rip), %rax      # 0xb390
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3089
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x3079
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x3089
jmp 0x307b
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x304e
cmpq $0x0, -0x20(%rbp)
jne 0x30d9
movl $0x20, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x82ca(%rip), %rcx      # 0xb390
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x82b7(%rip)      # 0xb390
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x82a6(%rip), %rax      # 0xb3a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3168
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x3158
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x3158
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x3158
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x3168
jmp 0x315a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x30fe
cmpq $0x0, -0x20(%rbp)
jne 0x31b8
movl $0x20, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq 0x81fb(%rip), %rcx      # 0xb3a0
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x81e8(%rip)      # 0xb3a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_global.c
// Function: get_indirect
static void
get_indirect(char *s, int b)
{	Sym *p;

	p = (Sym *) emalloc(sizeof(Sym));
	p->s = (char *) emalloc(strlen(s)+1);
	strcpy(p->s, s);
	p->bits = b;
	p->nxt = indirects;
	indirects = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x20, %edi
callq 0x1270
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1270
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x1040
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq 0x8163(%rip), %rcx      # 0xb380
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x8150(%rip)      # 0xb380
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3260
movq -0x8(%rbp), %rax
movswl 0x38(%rax), %eax
cmpl $0x0, %eax
je 0x3262
jmp 0x32a1
movq -0x8(%rbp), %rax
movw $0x1, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x32a1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13b0
movq %rax, %rdi
callq 0x3240
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3278
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3327
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3325
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x13b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3315
movq -0x10(%rbp), %rax
movswl 0x12(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x3315
movq -0x10(%rbp), %rax
movswl 0x12(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0x12(%rax)
movq -0x10(%rbp), %rdi
callq 0x32b0
jmp 0x3317
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x32cf
jmp 0x3327
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x806d(%rip), %rax      # 0xb3b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3375
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x3365
jmp 0x33d3
jmp 0x3367
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3347
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 0x8013(%rip), %rcx      # 0xb3b0
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x8000(%rip)      # 0xb3b0
movl $0x28, %edi
callq 0x1270
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x0, (%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: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x346a
cmpl $0x200, -0x1c(%rbp)     # imm = 0x200
jge 0x346a
movslq -0x1c(%rbp), %rcx
leaq 0x800e(%rip), %rax      # 0xb420
cmpq $0x0, (%rax,%rcx,8)
je 0x346a
movslq -0x1c(%rbp), %rcx
leaq 0x7ffc(%rip), %rax      # 0xb420
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movslq -0x1c(%rbp), %rcx
leaq 0x7fe1(%rip), %rax      # 0xb420
movq %rdx, (%rax,%rcx,8)
movq 0x8fd6(%rip), %rcx      # 0xc420
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x8fc3(%rip)      # 0xc420
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x347c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1270
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1040
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: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3570
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x34ea
movq 0x7b2d(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x432b(%rip), %rsi      # 0x7804
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1140
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3524
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x3514
jmp 0x3561
jmp 0x3516
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x34f6
movl $0x10, %edi
callq 0x1270
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)