LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/buildvm_lib.c
// Function: libdef_name
static void libdef_name(const char *p, int kind)
{
  size_t n = strlen(p);
  if (kind != LIBINIT_STRING) {
    if (n > modnamelen && p[modnamelen] == '_' &&
	!strncmp(p, modname, modnamelen)) {
      p += modnamelen+1;
      n -= modnamelen+1;
    }
  }
  if (n > LIBINIT_MAXSTR) {
    fprintf(stderr, "Error: string too long: '%s'\n",  p);
    exit(1);
  }
  if (optr+1+n+2 > obuf+sizeof(obuf)) {  /* +2 for caller. */
    fprintf(stderr, "Error: output buffer overflow\n");
    exit(1);
  }
  *optr++ = (uint8_t)(n | kind);
  memcpy(optr, p, n);
  optr += n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x50a0
movq %rax, %r14
cmpl $0xc0, %ebp
je 0xad38
movq 0xd4ee(%rip), %r15      # 0x181f8
cmpq %r15, %r14
jbe 0xad38
cmpb $0x5f, (%rbx,%r15)
jne 0xad38
leaq 0xd4e3(%rip), %rsi      # 0x18200
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5050
testl %eax, %eax
jne 0xad38
addq %r15, %rbx
incq %rbx
incq %r15
subq %r15, %r14
cmpq $0x3a, %r14
jae 0xad87
movq 0xd4ab(%rip), %rax      # 0x181f0
leaq (%rax,%r14), %rcx
addq $0x3, %rcx
leaq 0xd49c(%rip), %rdx      # 0x181f0
cmpq %rdx, %rcx
ja 0xad8f
leaq 0x1(%rax), %rdi
leaq (%rax,%r14), %r15
incq %r15
orl %r14d, %ebp
movb %bpl, (%rax)
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5140
movq %r15, 0xd474(%rip)      # 0x181f0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x552a
callq 0x5505
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/buildvm_fold.c
// Function: tryhash
static int tryhash(uint32_t *htab, uint32_t sz, uint32_t r, int dorol)
{
  uint32_t i;
  if (dorol && ((r & 31) == 0 || (r>>5) == 0))
    return 0;  /* Avoid zero rotates. */
  memset(htab, 0xff, (sz+1)*sizeof(uint32_t));
  for (i = 0; i < nkeys; i++) {
    uint32_t key = foldkeys[i];
    uint32_t k = key & 0xffffff;
    uint32_t h = (dorol ? lj_rol(lj_rol(k, r>>5) - k, r&31) :
			  (((k << (r>>5)) - k) << (r&31))) % sz;
    if (htab[h] != 0xffffffff) {  /* Collision on primary slot. */
      if (htab[h+1] != 0xffffffff) {  /* Collision on secondary slot. */
	/* Try to move the colliding key, if possible. */
	if (h < sz-1 && htab[h+2] == 0xffffffff) {
	  uint32_t k2 = htab[h+1] & 0xffffff;
	  uint32_t h2 = (dorol ? lj_rol(lj_rol(k2, r>>5) - k2, r&31) :
				 (((k2 << (r>>5)) - k2) << (r&31))) % sz;
	  if (h2 != h+1) return 0;  /* Cannot resolve collision. */
	  htab[h+2] = htab[h+1];  /* Move colliding key to secondary slot. */
	} else {
	  return 0;  /* Collision. */
	}
      }
      htab[h+1] = key;
    } else {
      htab[h] = key;
    }
  }
  return 1;  /* Success, all keys could be stored. */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, 0xc(%rsp)
movl %esi, %r14d
movq %rdi, %r15
testl %ecx, %ecx
je 0xb43e
movl 0xc(%rsp), %ecx
testb $0x1f, %cl
sete %al
cmpl $0x20, %ecx
setb %dl
xorl %ecx, %ecx
orb %al, %dl
jne 0xb544
movl %r14d, %eax
leaq 0x4(,%rax,4), %rdx
movq %r15, %rdi
movl $0xff, %esi
callq 0x50c0
movl 0xce4b(%rip), %r9d      # 0x182a8
testq %r9, %r9
je 0xb53f
leal -0x1(%r14), %eax
movl %eax, 0x14(%rsp)
movl 0xc(%rsp), %eax
movl %eax, %esi
shrl $0x5, %esi
andl $0x1f, %eax
movl %eax, 0x10(%rsp)
shlq $0x2, %r9
xorl %r11d, %r11d
leaq 0xce24(%rip), %rbp      # 0x182b0
movl (%r11,%rbp), %r13d
movl %r13d, %edx
andl $0xffffff, %edx         # imm = 0xFFFFFF
movl %edx, %eax
movl %esi, %ecx
testl %ebx, %ebx
je 0xb4ad
roll %cl, %eax
subl %edx, %eax
movl 0xc(%rsp), %ecx
roll %cl, %eax
jmp 0xb4b7
shll %cl, %eax
subl %edx, %eax
movl 0x10(%rsp), %ecx
shll %cl, %eax
xorl %edx, %edx
divl %r14d
movl %edx, %r8d
cmpl $-0x1, (%r15,%r8,4)
je 0xb50b
movl %r8d, %eax
leaq (%r15,%rax,4), %r10
addq $0x4, %r10
movl (%r10), %r12d
cmpl $-0x1, %r12d
je 0xb52f
xorl %ecx, %ecx
cmpl 0x14(%rsp), %r8d
jae 0xb544
movslq %r8d, %rdi
cmpl $-0x1, 0x8(%r15,%rdi,4)
jne 0xb544
movl %r12d, %edx
andl $0xffffff, %edx         # imm = 0xFFFFFF
movl %edx, %eax
movl %esi, %ecx
testl %ebx, %ebx
je 0xb511
roll %cl, %eax
subl %edx, %eax
movl 0xc(%rsp), %ecx
roll %cl, %eax
jmp 0xb51b
leaq (%r15,%r8,4), %r10
jmp 0xb52f
shll %cl, %eax
subl %edx, %eax
movl 0x10(%rsp), %ecx
shll %cl, %eax
incl %r8d
xorl %ecx, %ecx
xorl %edx, %edx
divl %r14d
cmpl %r8d, %edx
jne 0xb544
movl %r12d, 0x8(%r15,%rdi,4)
movl %r13d, (%r10)
addq $0x4, %r11
cmpq %r11, %r9
jne 0xb48c
movl $0x1, %ecx
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zenkj[P]luajit-arm64/src/host/buildvm_fold.c
// Function: printhash
static void printhash(BuildCtx *ctx, uint32_t *htab, uint32_t sz)
{
  uint32_t i;
  fprintf(ctx->fp, "static const uint32_t fold_hash[%d] = {\n0x%08x",
	  sz+1, htab[0]);
  for (i = 1; i < sz+1; i++)
    fprintf(ctx->fp, ",\n0x%08x", htab[i]);
  fprintf(ctx->fp, "\n};\n\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leal 0x1(%r15), %ebp
movl (%rsi), %ecx
leaq 0x711a(%rip), %rsi      # 0x12694
movl %ebp, %edx
xorl %eax, %eax
callq 0x5130
testl %r15d, %r15d
je 0xb5b2
movl %ebp, %r12d
movl $0x1, %r13d
leaq 0x712b(%rip), %r15      # 0x126c3
movq 0x10(%rbx), %rdi
movl (%r14,%r13,4), %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x5130
incq %r13
cmpq %r13, %r12
jne 0xb598
movq 0x10(%rbx), %rcx
leaq 0x6c6a(%rip), %rdi      # 0x12227
movl $0x5, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x51c0
// File: /workspace/github_c_makefile_star2_O3/stevenmherring[P]DNS/sequential-trie.c
// Function: new_leaf
struct trie_node * new_leaf (const char *string, size_t strlen, int32_t ip4_address) {
  struct trie_node *new_node = malloc(sizeof(struct trie_node));
  if (!new_node) {
    printf ("WARNING: Node memory allocation failed.  Results may be bogus.\n");
    return NULL;
  }
  assert(strlen < 64);
  assert(strlen > 0);
  new_node->next = NULL;
  new_node->strlen = strlen;
  strncpy(new_node->key, string, strlen);
  new_node->key[strlen] = '\0';
  new_node->ip4_address = ip4_address;
  new_node->children = NULL;

  return new_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0x58, %edi
callq 0x10f0
movq %rax, %rbx
testq %rax, %rax
je 0x12e4
cmpq $0x40, %r14
jae 0x12fc
testq %r14, %r14
je 0x131b
xorl %r12d, %r12d
movq %r12, (%rbx)
movl %r14d, 0x8(%rbx)
movq %rbx, %rdi
addq $0x18, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1050
movb $0x0, 0x18(%rbx,%r14)
movl %ebp, 0xc(%rbx)
movq %r12, 0x10(%rbx)
jmp 0x12f0
leaq 0x207f(%rip), %rdi      # 0x336a
callq 0x1070
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1df2(%rip), %rdi      # 0x30f5
leaq 0x1cfa(%rip), %rsi      # 0x3004
leaq 0x1d05(%rip), %rcx      # 0x3016
movl $0x1c, %edx
callq 0x1090
leaq 0x1d2e(%rip), %rdi      # 0x3050
leaq 0x1cdb(%rip), %rsi      # 0x3004
leaq 0x1ce6(%rip), %rcx      # 0x3016
movl $0x1d, %edx
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/stevenmherring[P]DNS/sequential-trie.c
// Function: compare_keys
int compare_keys (const char *string1, int len1, const char *string2, int len2, int *pKeylen) {
  int keylen, offset1, offset2;
  keylen = len1 < len2 ? len1 : len2;
  offset1 = len1 - keylen;
  offset2 = len2 - keylen;
  assert (keylen > 0);
  if (pKeylen)
  *pKeylen = keylen;
  return strncmp(&string1[offset1], &string2[offset2], keylen);
}

// Assembly:
cmpl %ecx, %esi
movl %ecx, %eax
cmovll %esi, %eax
testl %eax, %eax
jle 0x136a
testq %r8, %r8
je 0x134d
movl %eax, (%r8)
subl %eax, %ecx
subl %eax, %esi
movslq %esi, %rsi
addq %rsi, %rdi
movslq %ecx, %rcx
addq %rcx, %rdx
movl %eax, %eax
movq %rdx, %rsi
movq %rax, %rdx
jmp 0x1060
pushq %rax
leaq 0x1ce9(%rip), %rdi      # 0x305b
leaq 0x1c8b(%rip), %rsi      # 0x3004
leaq 0x1ce6(%rip), %rcx      # 0x3066
movl $0x2d, %edx
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/stevenmherring[P]DNS/sequential-trie.c
// Function: search
struct trie_node *
_search (struct trie_node *node, const char *string, size_t strlen) {

  int keylen, cmp;

  // First things first, check if we are NULL
  if (node == NULL) return NULL;

  assert(node->strlen < 64);

  // See if this key is a substring of the string passed in
  cmp = compare_keys(node->key, node->strlen, string, strlen, &keylen);
  if (cmp == 0) {
    // Yes, either quit, or recur on the children

    // If this key is longer than our search string, the key isn't here
    if (node->strlen > keylen) {
      return NULL;
    } else if (strlen > keylen) {
      // Recur on children list
      return _search(node->children, string, strlen - keylen);
    } else {
      assert (strlen == keylen);

      return node;
    }

  } else if (cmp < 0) {
    // No, look right (the node's key is "less" than the search key)
    return _search(node->next, string, strlen);
  } else {
    // Quit early
    return 0;
  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x13f8
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdi), %esi
cmpl $0x40, %esi
jae 0x1424
movq %rdx, %r14
leaq 0x18(%rbx), %rdi
leaq 0xc(%rsp), %r8
movq %r15, %rdx
movl %r14d, %ecx
callq 0x133a
testl %eax, %eax
je 0x13ee
jns 0x13f8
movq (%rbx), %rdi
jmp 0x1405
movslq 0xc(%rsp), %rax
cmpl %eax, 0x8(%rbx)
jbe 0x13fc
xorl %ebx, %ebx
jmp 0x1417
subq %rax, %r14
jbe 0x1415
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x13b0
movq %rax, %rbx
jmp 0x1417
jne 0x1443
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cc4(%rip), %rdi      # 0x30ef
leaq 0x1bd2(%rip), %rsi      # 0x3004
leaq 0x1cc8(%rip), %rcx      # 0x3101
movl $0x47, %edx
callq 0x1090
leaq 0x1cfb(%rip), %rdi      # 0x3145
leaq 0x1bb3(%rip), %rsi      # 0x3004
leaq 0x1ca9(%rip), %rcx      # 0x3101
movl $0x55, %edx
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdx, %rbx
movq %rsi, %rdx
testq %rsi, %rsi
je 0x149c
movq %rdi, %rsi
movq 0x3c70(%rip), %rdi      # 0x50e8
callq 0x13b0
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x1492
movl 0xc(%rax), %ecx
movl %ecx, (%rbx)
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
jmp 0x149e
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3835(%rip), %rax      # 0x50f0
cmpl $0x0, (%rax)
je 0x1930
testq %rbx, %rbx
je 0x1962
movq 0x3818(%rip), %rdi      # 0x50e8
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13b0
testq %rax, %rax
je 0x1935
movq %rax, %r13
callq 0x1110
movq %rax, %r15
leaq 0x1930(%rip), %r12      # 0x3222
movl 0xc(%r13), %ebp
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1080
callq 0x10c0
leaq 0x37e1(%rip), %rax      # 0x50f0
cmpl $0x0, (%rax)
je 0x1930
movq 0x37cd(%rip), %rdi      # 0x50e8
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13b0
movq %rax, %r13
testq %rax, %rax
jne 0x18f2
jmp 0x1935
testq %rbx, %rbx
je 0x1962
movq 0x37ac(%rip), %rcx      # 0x50e8
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
testq %rcx, %rcx
je 0x1966
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14a2
xorl %eax, %eax
jmp 0x1977
callq 0x128c
movq %rax, 0x3776(%rip)      # 0x50e8
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17a3(%rip), %r13      # 0x331e
leaq 0x17a8(%rip), %r12      # 0x332a
leaq 0x1735(%rip), %rdi      # 0x32be
movl %ebx, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1080
leaq 0x1754(%rip), %rdi      # 0x32f0
movq %r15, %rsi
xorl %eax, %eax
callq 0x1080
movl 0x8(%r15), %esi
leaq 0x18(%r15), %rdx
leaq 0x1749(%rip), %rdi      # 0x32fe
xorl %eax, %eax
callq 0x1080
movl 0xc(%r15), %esi
leaq 0x1743(%rip), %rdi      # 0x330a
xorl %eax, %eax
callq 0x1080
movq (%r15), %rsi
leaq 0x173b(%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 0x1c34
leaq 0x179f(%rip), %rdi      # 0x33a9
callq 0x1070
leaq 0x17a3(%rip), %rdi      # 0x33b9
callq 0x1070
leaq 0x1788(%rip), %rdi      # 0x33aa
callq 0x1070
movq 0x10(%r15), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x1b5d
cmpq $0x0, (%r15)
je 0x1c68
leaq 0x179a(%rip), %rdi      # 0x33db
callq 0x1070
leaq 0x179e(%rip), %rdi      # 0x33eb
callq 0x1070
leaq 0x1783(%rip), %rdi      # 0x33dc
callq 0x1070
movq (%r15), %r15
incl %ebx
jmp 0x1b82
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3469(%rip), %rsi      # 0x50e8
leaq 0x16d5(%rip), %rdi      # 0x335b
xorl %eax, %eax
callq 0x1080
movq 0x3454(%rip), %rdi      # 0x50e8
testq %rdi, %rdi
je 0x1ca3
xorl %esi, %esi
xorl %edx, %edx
popq %rax
jmp 0x1b5d
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x1763(%rip), %rdi      # 0x375b
callq 0x1070
leaq 0x1789(%rip), %rdi      # 0x378d
callq 0x1070
leaq 0x1786(%rip), %rdi      # 0x3796
callq 0x1070
leaq 0x17a3(%rip), %rdi      # 0x37bf
callq 0x1070
leaq 0x17ae(%rip), %rdi      # 0x37d6
callq 0x1070
leaq 0x17cf(%rip), %rdi      # 0x3803
callq 0x1070
leaq 0x1808(%rip), %rdi      # 0x3848
callq 0x1070
leaq 0x10a1(%rip), %rdi      # 0x30ed
popq %rax
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x10e0
cmpl $0x0, 0x2dd4(%rip)      # 0x50f4
jne 0x23be
movq %rax, %rbx
leaq 0x128b(%rip), %r14      # 0x35bb
leaq 0x11f0(%rip), %r15      # 0x3527
leaq 0x11ed(%rip), %r12      # 0x352b
leaq 0x11ea(%rip), %r13      # 0x352f
movl $0x3, %esi
movq %r14, %rdi
movl %ebx, %edx
callq 0x18a1
movl $0x3, %esi
movq %r15, %rdi
movl %ebx, %edx
callq 0x18a1
movl $0x3, %esi
movq %r12, %rdi
movl %ebx, %edx
callq 0x18a1
movl $0x3, %esi
movq %r13, %rdi
movl %ebx, %edx
callq 0x18a1
movl $0x3, %esi
movq %r14, %rdi
callq 0x1b32
movl $0x3, %esi
movq %r15, %rdi
callq 0x1b32
movl $0x3, %esi
movq %r12, %rdi
callq 0x1b32
movl $0x3, %esi
movq %r13, %rdi
callq 0x1b32
cmpl $0x0, 0x2d38(%rip)      # 0x50f4
je 0x2345
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15af
movq %rdi, %r14
cmpw $0x0, 0x38(%rdi)
jne 0x15af
movw $0x1, 0x38(%r14)
movq 0x30(%r14), %r12
testq %r12, %r12
je 0x15af
movq %rsi, %r15
movq (%r12), %rdi
callq 0x15bd
cmpq %r15, %rax
je 0x158b
movq %r14, %rdi
movq %rax, %rsi
callq 0x1536
testl %eax, %eax
jne 0x158b
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x1562
jmp 0x15af
movq 0x6a3e(%rip), %rax      # 0x7fd0
movq (%rax), %rdi
movq (%r14), %rdx
movq (%r12), %rcx
leaq 0x3b34(%rip), %rsi      # 0x50d7
xorl %eax, %eax
callq 0x1100
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1600
movq %rdi, %rbx
movq 0x6c68(%rip), %r14      # 0x8238
testq %r14, %r14
je 0x15ea
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
testl %eax, %eax
je 0x1603
movq 0x40(%r14), %r14
jmp 0x15d0
leaq 0x46e9(%rip), %r14      # 0x5cda
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10f0
testl %eax, %eax
je 0x160e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x151c
movq %r14, (%rax)
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x26ab
movq 0x6c09(%rip), %r14      # 0x8238
movq %rbx, %rdi
callq 0x2a08
jmp 0x1603
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x2fac(%rip), %rdi      # 0x52b4
movl $0x1d, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1170
movq 0x5f17(%rip), %r12      # 0x8238
testq %r12, %r12
je 0x2380
leaq 0x302b(%rip), %r14      # 0x5358
leaq 0x2da3(%rip), %r15      # 0x50d7
movq (%r12), %rcx
movq 0x8(%r12), %rax
movl 0x8(%rax), %r8d
movq %rbx, %rdi
movq %r14, %rsi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x1100
movq 0x30(%r12), %r13
testq %r13, %r13
je 0x2376
movq (%r12), %rdx
movq (%r13), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1100
movq 0x18(%r13), %r13
jmp 0x2356
movq 0x40(%r12), %r12
testq %r12, %r12
jne 0x2334
leaq 0x2f4b(%rip), %rdi      # 0x52d2
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x2f07(%rip), %rdi      # 0x52b4
movl $0x1d, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1170
movq 0x5e72(%rip), %rax      # 0x8238
testq %rax, %rax
je 0x23d7
movw $0x0, 0x38(%rax)
movq 0x40(%rax), %rax
jmp 0x23c6
movq 0x5d12(%rip), %rdi      # 0x80f0
callq 0x15bd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x25a0
leaq 0x2edd(%rip), %rdi      # 0x52d2
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O3/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 0x38ae(%rip), %rdi      # 0x5cda
callq 0x15bd
testq %rax, %rax
je 0x24c7
movq %rax, %rbx
leaq 0x2e91(%rip), %rdi      # 0x52d5
callq 0x2f50
movq 0x18(%rbx), %rdi
callq 0x24f0
movq 0x5c97(%rip), %rdi      # 0x80f0
callq 0x15bd
testq %rax, %rax
je 0x24cf
movq %rax, %rbx
movl 0x5c8c(%rip), %edx      # 0x80f8
leal 0x1(%rdx), %eax
movl %eax, 0x5c83(%rip)      # 0x80f8
leaq 0x5cb4(%rip), %r14      # 0x8130
leaq 0x2e99(%rip), %rsi      # 0x531c
movq %r14, %rdi
xorl %eax, %eax
callq 0x1150
movq %r14, %rdi
callq 0x2f50
movq 0x5c54(%rip), %rdx      # 0x80f0
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl 0x8(%rax), %r8d
leaq 0x2e73(%rip), %rsi      # 0x5321
movq %r14, %rdi
xorl %eax, %eax
callq 0x1150
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2f50
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x5c1a(%rip), %rsi      # 0x80f0
leaq 0x2e05(%rip), %rdi      # 0x52e2
xorl %eax, %eax
callq 0x10a0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b72
// File: /workspace/github_c_makefile_star2_O3/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 0x2562
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x24f0
movl 0x5bed(%rip), %edx      # 0x80f8
leal 0x1(%rdx), %eax
movl %eax, 0x5be4(%rip)      # 0x80f8
leaq 0x5c15(%rip), %r14      # 0x8130
leaq 0x2dfa(%rip), %rsi      # 0x531c
movq %r14, %rdi
xorl %eax, %eax
callq 0x1150
movq %r14, %rdi
callq 0x2f50
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl 0x8(%rax), %r8d
leaq 0x2fa1(%rip), %rsi      # 0x54ea
movq %r14, %rdi
xorl %eax, %eax
callq 0x1150
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2f50
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5cc1(%rip), %r15      # 0x8230
xorl %ebx, %ebx
testq %r15, %r15
je 0x2598
movq %rdi, %r14
movq (%r15), %rdi
movq %r14, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2593
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x2579
jmp 0x2598
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25c8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpw $0x0, 0x38(%rsi)
je 0x25c9
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 0x2d74(%rip), %rsi      # 0x5358
movq %rcx, %rdx
xorl %eax, %eax
callq 0x1100
cmpb $0x1, 0x5b27(%rip)      # 0x811c
jne 0x2658
movq 0x5c3a(%rip), %r15      # 0x8238
testq %r15, %r15
je 0x25ba
leaq 0x2acd(%rip), %r12      # 0x50d7
movq 0x30(%r15), %rbp
testq %rbp, %rbp
je 0x264a
movq (%rbp), %rdi
movq (%rbx), %r13
movq %r13, %rsi
callq 0x10f0
testl %eax, %eax
jne 0x2644
movq (%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
xorl %eax, %eax
callq 0x1100
movq %r14, %rdi
movq %r15, %rsi
callq 0x25a0
movq 0x18(%rbp), %rbp
jmp 0x260e
movq 0x40(%r15), %r15
testq %r15, %r15
jne 0x260a
jmp 0x25ba
movq 0x30(%rbx), %r12
testq %r12, %r12
je 0x25ba
leaq 0x2a6b(%rip), %r15      # 0x50d7
testb $0x2, 0x11(%r12)
jne 0x2688
movq (%rbx), %rdx
movq (%r12), %rcx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1100
movq (%r12), %rdi
callq 0x15bd
movq %r14, %rdi
movq %rax, %rsi
callq 0x25a0
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x266c
jmp 0x25ba
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x5b73(%rip), %r13      # 0x8238
testq %r13, %r13
je 0x26e0
movq (%r13), %rdi
movq %r14, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2716
movq 0x40(%r13), %r13
jmp 0x26c5
movl $0x48, %edi
callq 0x151c
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movw %bp, 0x10(%rax)
movq 0x5b3c(%rip), %rcx      # 0x8238
movq %rcx, 0x40(%rax)
movq %rax, 0x5b31(%rip)      # 0x8238
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r13), %rax
movl 0x8(%rax), %ecx
cmpl 0x8(%rbx), %ecx
jne 0x2748
movq (%rax), %r15
movq (%rbx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1180
testq %rax, %rax
jne 0x2707
movq %r12, %rdi
movq %r15, %rsi
callq 0x1180
testq %rax, %rax
jne 0x2707
testl %ebp, %ebp
je 0x2754
cmpw $0x0, 0x10(%r13)
jne 0x2707
movq 0x5895(%rip), %r15      # 0x7ff0
movq (%r15), %rdi
leaq 0x2d2f(%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 0x3531(%rip), %r12      # 0x5cba
leaq 0x2d37(%rip), %r14      # 0x54c7
movq %r14, %r8
cmoveq %r12, %r8
leaq 0x2d1a(%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 0x2d16(%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_O3/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 0x15bd
testq %rax, %rax
je 0x2829
movq %rax, %r15
movl $0x20, %edi
callq 0x151c
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_O3/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 0x15bd
testq %rax, %rax
je 0x289e
movq %rax, %r12
movl $0x20, %edi
callq 0x151c
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 0x288b
movq %rbx, %rdi
callq 0x15bd
testq %rax, %rax
je 0x288b
orb $0x2, 0x15(%rax)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2ad2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x5982(%rip), %r12      # 0x8240
testq %r12, %r12
je 0x28da
movq (%r12), %rdi
movq %r15, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2902
movq 0x18(%r12), %r12
jmp 0x28be
movl $0x20, %edi
callq 0x151c
movq %r15, (%rax)
movl %ebx, 0x10(%rax)
movq %r14, 0x8(%rax)
movq 0x594b(%rip), %rcx      # 0x8240
movq %rcx, 0x18(%rax)
movq %rax, 0x5940(%rip)      # 0x8240
jmp 0x2907
orl %ebx, 0x10(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x591e(%rip), %r12      # 0x8248
testq %r12, %r12
je 0x2966
movl 0x8(%r15), %ebp
movq (%r12), %rax
cmpl %ebp, 0x8(%rax)
jne 0x295c
movq (%rax), %rdi
movq (%r15), %rsi
callq 0x10f0
testl %eax, %eax
jne 0x295c
movq 0x8(%r12), %rdi
movq %r14, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2995
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x2933
movl $0x20, %edi
callq 0x151c
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq 0x58c7(%rip), %rcx      # 0x8248
movq %rcx, 0x18(%rax)
movq %rax, 0x58bc(%rip)      # 0x8248
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
orl %ebx, 0x10(%r12)
jmp 0x298c
// File: /workspace/github_c_makefile_star2_O3/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 0x29a8
cmpw $0x0, 0x38(%rdi)
je 0x29a9
retq
pushq %rbx
movw $0x1, 0x38(%rdi)
movq 0x30(%rdi), %rbx
testq %rbx, %rbx
je 0x29cf
movq (%rbx), %rdi
callq 0x15bd
movq %rax, %rdi
callq 0x299c
movq 0x18(%rbx), %rbx
jmp 0x29b4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x30(%rdi), %rbx
testq %rbx, %rbx
je 0x2a06
movq (%rbx), %rdi
callq 0x15bd
testq %rax, %rax
je 0x2a00
movzwl 0x12(%rax), %ecx
testb $0x4, %cl
jne 0x2a00
orl $0x4, %ecx
movw %cx, 0x12(%rax)
movq %rax, %rdi
callq 0x29d1
movq 0x18(%rbx), %rbx
jmp 0x29d6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x584a(%rip), %r14      # 0x8260
testq %r14, %r14
je 0x2a30
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2a6e
movq 0x20(%r14), %r14
jmp 0x2a16
movl $0x28, %edi
callq 0x151c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a76
movq %rax, (%r14)
movq 0x5811(%rip), %rax      # 0x8260
movq %rax, 0x20(%r14)
movq %r14, 0x5806(%rip)      # 0x8260
movl $0x28, %edi
callq 0x151c
movq %rax, 0x10(%r14)
movl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2abc
movl %eax, %edx
leaq 0x583c(%rip), %rsi      # 0x82d0
movq (%rsi,%rdx,8), %rcx
testq %rcx, %rcx
je 0x2abc
movq 0x8(%rcx), %rax
movq %rax, (%rsi,%rdx,8)
movq 0x6824(%rip), %rax      # 0x92d0
movq %rax, 0x8(%rcx)
movq %rcx, 0x6819(%rip)      # 0x92d0
movq (%rcx), %rdi
jmp 0x2ac9
incl %eax
movslq %eax, %rdi
callq 0x151c
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O3/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 0x2b3a
testq %rax, %rax
je 0x2b32
movq %rax, %rbx
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x2b08
movq (%r15), %rdi
movq %r14, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2b2c
movq 0x8(%r15), %r15
jmp 0x2aee
movl $0x10, %edi
callq 0x151c
movq %rax, %r15
movq %r14, %rdi
callq 0x2a76
movq %rax, (%r15)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r15)
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x12e5
// File: /workspace/github_c_makefile_star2_O3/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 0x571b(%rip), %rbx      # 0x8260
testq %rbx, %rbx
je 0x2b65
movq %rdi, %r14
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2b67
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x2b4d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x56dc(%rip), %r12      # 0x8260
testq %r12, %r12
je 0x2c03
leaq 0x314a(%rip), %rbx      # 0x5cda
leaq 0x2b79(%rip), %r14      # 0x5710
movq (%r12), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2bf9
movq 0x56af(%rip), %r13      # 0x8260
testq %r13, %r13
je 0x2bdf
cmpq %r12, %r13
je 0x2bd9
movq %r13, %rbp
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
je 0x2bd9
movq (%rbp), %rdi
movq %r15, %rsi
callq 0x10f0
testl %eax, %eax
jne 0x2bbe
jmp 0x2bf9
movq 0x20(%r13), %r13
jmp 0x2bb1
movq %r15, %rdi
callq 0x2563
testl %eax, %eax
jne 0x2bf9
movq (%r12), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10a0
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0x2b97
movq 0x53c6(%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_O3/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 0x5631(%rip), %rax      # 0x8268
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x2c57
movq (%r12), %rdi
movq %r15, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2c8f
movq 0x20(%r12), %r12
jmp 0x2c3b
movq %r15, %rdi
callq 0x2cbd
movq %rax, %r15
movq %r14, %rdi
callq 0x2a76
movq %rax, 0x8(%r15)
movl $0x1, 0x10(%r15)
movl %ebx, 0x14(%r15)
movq 0x55e7(%rip), %rax      # 0x8268
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%r15)
movq %r15, 0x10(%rax)
jmp 0x2cb1
movq 0x10(%r12), %xmm0
movd %ebx, %xmm1
movdqa 0x2a3e(%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_O3/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 0x660d(%rip), %r14      # 0x92d8
testq %r14, %r14
je 0x2cf1
movq 0x20(%r14), %rax
movq %rax, 0x65fd(%rip)      # 0x92d8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq $0x0, 0x20(%r14)
jmp 0x2cfe
movl $0x28, %edi
callq 0x151c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a76
movq %rax, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x554d(%rip), %rax      # 0x8268
movq 0x10(%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x2d37
cmpl $0x0, 0x10(%rcx)
je 0x2d31
movl %edi, 0x18(%rcx)
incl %eax
movq 0x20(%rcx), %rcx
jmp 0x2d21
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x551c(%rip)      # 0x8260
je 0x2e67
leaq 0x551f(%rip), %rax      # 0x8270
movq %rax, 0x5510(%rip)      # 0x8268
xorps %xmm0, %xmm0
movups %xmm0, 0x550e(%rip)     # 0x8270
movups %xmm0, 0x5517(%rip)     # 0x8280
movups %xmm0, 0x5520(%rip)     # 0x8290
movups %xmm0, 0x5529(%rip)     # 0x82a0
leaq 0x2a9c(%rip), %rdi      # 0x581a
callq 0x2b3a
movq %rax, 0x6556(%rip)      # 0x92e0
testq %rax, %rax
jne 0x2dee
leaq 0x537a(%rip), %rax      # 0x8110
cmpl $0x0, (%rax)
je 0x2da7
leaq 0x2f41(%rip), %rdi      # 0x5ce3
callq 0x1060
leaq 0x2a6c(%rip), %rdi      # 0x581a
callq 0x2a08
xorl %ebx, %ebx
leaq 0x4ee4(%rip), %r14      # 0x7ca0
movq (%rbx,%r14), %rdi
callq 0x2f50
addq $0x8, %rbx
cmpq $0x138, %rbx            # imm = 0x138
jne 0x2dbc
leaq 0x2a41(%rip), %rdi      # 0x581a
callq 0x2b3a
movq %rax, 0x64fb(%rip)      # 0x92e0
testq %rax, %rax
je 0x2e6f
movq %rax, %rdi
xorl %esi, %esi
callq 0x3299
testq %rax, %rax
je 0x2e10
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2e10
movq (%rax), %rax
movq %rax, 0x64d8(%rip)      # 0x92e8
callq 0x2421
leaq 0x2ebe(%rip), %rdi      # 0x5cda
callq 0x2b3a
testq %rax, %rax
je 0x2e32
movq %rax, %rdi
xorl %esi, %esi
callq 0x2e74
jmp 0x2e3e
leaq 0x2e82(%rip), %rdi      # 0x5cbb
callq 0x1060
leaq 0x52cb(%rip), %rax      # 0x8110
cmpl $0x0, (%rax)
je 0x2e67
movl 0x52ac(%rip), %esi      # 0x80fc
decl %esi
leaq 0x28c1(%rip), %rdi      # 0x571a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1309
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x32b4
cmpl %ebp, (%rax)
je 0x32cc
movq 0x20(%rax), %rax
jmp 0x32a5
movl $0x28, %edi
callq 0x151c
movl %ebp, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5c77(%rip), %r14      # 0x92f8
testq %r14, %r14
je 0x36f3
movq 0x10(%r14), %rax
movq %rax, 0x5c67(%rip)      # 0x92f8
testq %rax, %rax
je 0x369b
movq (%rax), %rax
jmp 0x369d
xorl %eax, %eax
movq 0x4bc4(%rip), %rcx      # 0x8268
movq %rax, 0x30(%rcx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x36cd
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0x36cd
movq %rbx, %rdi
callq 0x32d3
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x36ba
jmp 0x36d2
callq 0x3676
movq 0x5c1f(%rip), %rax      # 0x92f8
movq %rax, 0x10(%r14)
movq %r14, 0x5c14(%rip)      # 0x92f8
movq 0x4b7d(%rip), %rax      # 0x8268
movq $0x0, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4617
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x4585
movq (%rbx), %rdi
callq 0x1080
movq %rax, %r14
decl %eax
cmpl $0x1fe, %eax            # imm = 0x1FE
ja 0x45f7
movq 0x4d17(%rip), %rax      # 0x92d0
testq %rax, %rax
je 0x45d1
movq 0x8(%rax), %rcx
movq %rcx, 0x4d07(%rip)      # 0x92d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
jmp 0x45db
movl $0x10, %edi
callq 0x151c
movq (%rbx), %rcx
movq %rcx, (%rax)
movl %r14d, %ecx
leaq 0x3ce5(%rip), %rdx      # 0x82d0
movq (%rdx,%rcx,8), %rsi
movq %rsi, 0x8(%rax)
movq %rax, (%rdx,%rcx,8)
movq $0x0, (%rbx)
movq 0x4cd3(%rip), %rax      # 0x92d8
movq %rax, 0x20(%rbx)
movq %rbx, 0x4cc8(%rip)      # 0x92d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq