LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]init/daemon.c
// Function: listen_add
static void listen_add(int fd) {
  if ((listeners & 15) == 0) {
    pollfd = realloc(pollfd, (listeners + 16) * sizeof(struct pollfd));
    if (pollfd == NULL)
      err(EXIT_FAILURE, "realloc");
  }
  pollfd[listeners++].fd = fd;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x2c5d(%rip), %r14      # 0x6210
movq 0x2c7e(%rip), %rax      # 0x6238
testb $0xf, %r14b
jne 0x35dc
leaq 0x80(,%r14,8), %rsi
movq %rax, %rdi
callq 0x2270
movq %rax, 0x2c61(%rip)      # 0x6238
testq %rax, %rax
je 0x35f3
leaq 0x1(%r14), %rcx
movq %rcx, 0x2c29(%rip)      # 0x6210
movl %ebx, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xbcb(%rip), %rsi       # 0x41c5
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x2210
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]init/daemon.c
// Function: signal_get
static int signal_get(void) {
  unsigned char signal = 0;
  while (read(signals[0], &signal, 1) < 0)
    if (errno != EINTR)
      break;
  return signal;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x7(%rsp), %rbx
movb $0x0, (%rbx)
pushq $0x1
popq %r14
movl 0x2bfe(%rip), %edi      # 0x6218
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2180
testq %rax, %rax
jns 0x3634
callq 0x2040
cmpl $0x4, (%rax)
je 0x3614
movzbl 0x7(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]init/daemon.c
// Function: reap
static pid_t reap(int *status) {
  pid_t child;

  while ((child = waitpid(-1, status, WNOHANG)) < 0)
    if (errno != EINTR)
      break;
  return child > 0 ? child : 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
pushq $-0x1
popq %rbx
pushq $0x1
popq %rbp
movl %ebx, %edi
xorl %esi, %esi
movl %ebp, %edx
callq 0x22b0
movl %eax, %r14d
testl %eax, %eax
jns 0x3667
callq 0x2040
cmpl $0x4, (%rax)
je 0x364b
xorl %eax, %eax
testl %r14d, %r14d
cmovgl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/read3.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char *buf;
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkostemp(tmpfile, O_DIRECT);
	char *p;

	buf = aligned_alloc(getpagesize(), FILESIZE);
	memset(buf, 0, FILESIZE);
	assert(fd >= 0);
	assert(write(fd, buf, FILESIZE) == FILESIZE);
	unlink(tmpfile);

	p = malloc(BUFLEN + getpagesize());
	p = (char *)(((unsigned long)p + getpagesize()-1) & ~(getpagesize()-1));

	while (1) {
		int ret = read(fd, p, BUFLEN);
		assert(ret >= 0);
		if (ret == 0)
			lseek(fd, 0, SEEK_SET);

		(*iterations)++;
	}
	free(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movaps 0x6ec(%rip), %xmm0      # 0x32f0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movabsq $0x5858585858582e, %rax # imm = 0x5858585858582E
movq %rax, 0x10(%rdi)
movl $0x4000, %esi           # imm = 0x4000
callq 0x2130
movl %eax, %ebp
callq 0x2280
movslq %eax, %r14
movl $0x100000, %esi         # imm = 0x100000
movq %r14, %rdi
callq 0x22a0
movq %rax, %r15
movl $0x100000, %edx         # imm = 0x100000
movq %rax, %rdi
xorl %esi, %esi
callq 0x2160
testl %ebp, %ebp
js 0x2cae
movl $0x100000, %edx         # imm = 0x100000
movl %ebp, %edi
movq %r15, %rsi
callq 0x20d0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x2cc7
movq %rsp, %rdi
callq 0x2080
leal (%r14,%r14), %eax
movslq %eax, %rdi
callq 0x21f0
addq %r14, %rax
decq %rax
movl %r14d, %ecx
negl %ecx
movslq %ecx, %r15
andq %rax, %r15
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2190
testl %eax, %eax
js 0x2ce0
jne 0x2ca9
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2140
incq (%rbx)
jmp 0x2c8b
leaq 0x5bf(%rip), %rdi       # 0x3274
leaq 0x5c0(%rip), %rsi       # 0x327c
leaq 0x5c7(%rip), %rcx       # 0x328a
pushq $0x16
jmp 0x2cf7
leaq 0x5ef(%rip), %rdi       # 0x32bd
leaq 0x5a7(%rip), %rsi       # 0x327c
leaq 0x5ae(%rip), %rcx       # 0x328a
pushq $0x17
jmp 0x2cf7
leaq 0x5fb(%rip), %rdi       # 0x32e2
leaq 0x58e(%rip), %rsi       # 0x327c
leaq 0x595(%rip), %rcx       # 0x328a
pushq $0x1f
popq %rdx
callq 0x2150
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/heap.c
// Function: CreateHeap
Heap *
CreateHeap( uint chunk_size, uint chnk_hunk_ratio )
{	Heap    *heap;
	uint     unit;

	heap = (Heap *) e_malloc(sizeof(Heap));

	unit  = max(chunk_size, MIN_SZE);
	if (unit % ALGN_SZE != 0)
		unit += ALGN_SZE - (unit % ALGN_SZE);
	heap->chnk_sze = unit;

	if (chnk_hunk_ratio)
		heap->ch_ratio = chnk_hunk_ratio; 
	else
		heap->ch_ratio = DEFLT_RATIO;

	heap->num_alloc = 0; 
	heap->num_free  = 0; 
	heap->num_hunks = 0; 

	heap->next_chunk = 0;
	heap->hunk_array_sze = MIN_HUNK_ARRY;
	heap->free_list = (void *) NULL;

	heap->hunks = (void **) e_malloc(MIN_HUNK_ARRY * PNTR_SZE);

	return(heap);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
pushq $0x30
popq %rdi
callq 0x4739
movq %rax, %r14
cmpl $0x9, %ebp
pushq $0x8
popq %rax
cmovael %ebp, %eax
addl $0x7, %eax
andl $-0x8, %eax
movl %eax, (%r14)
testl %ebx, %ebx
movl $0x100, %eax            # imm = 0x100
cmovnel %ebx, %eax
movl %eax, 0x4(%r14)
andl $0x0, 0x18(%r14)
movaps 0x1bbe5(%rip), %xmm0    # 0x20010
movups %xmm0, 0x8(%r14)
andq $0x0, 0x20(%r14)
pushq $0x40
popq %rdi
callq 0x4739
movq %rax, 0x28(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/heap.c
// Function: check_chunks
int
check_chunks(void *y)
{	FC *x;

	for (x = free_chunks; x; x = x->fc.nxt)
	{	if (x < (FC *) 1000)
		{	printf("memory corrupted \n");
			abort();
		}
		if (x == y)
		{	printf("double release %p\n", x);
		//	abort();
			return 0;
		}
	}
	return 1;
}

// Assembly:
pushq %rbx
leaq 0x30557(%rip), %rsi     # 0x349a8
pushq $0x1
popq %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x447a
cmpq $0x3e7, %rsi            # imm = 0x3E7
jbe 0x447e
cmpq %rdi, %rsi
jne 0x4454
leaq 0x1bbaf(%rip), %rdi     # 0x20020
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4140
movl %ebx, %eax
popq %rbx
retq
leaq 0x1bbae(%rip), %rdi     # 0x20033
callq 0x40d0
callq 0x4060
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/heap.c
// Function: rel_chunk
void
rel_chunk(void *x)
{	FC *y;
#if 1
	if (!check_chunks(x)) exit(1);
#endif
	memset(x, 0, MX_NODE_SZE);
	y = (FC *) x;
	y->fc.nxt = free_chunks;
	free_chunks = y;
	gh_sz++;
if (0) printf("++ %p	-- %d\n", x, gh_sz);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4449
testl %eax, %eax
je 0x44cd
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
andq $0x0, 0x48(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movq 0x304ed(%rip), %rax     # 0x349a8
movq %rax, (%rbx)
movq %rbx, 0x304e3(%rip)     # 0x349a8
incl 0x304e5(%rip)           # 0x349b0
popq %rbx
retq
pushq $0x1
popq %rdi
callq 0x42b0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/heap.c
// Function: DestroyHeap
void
DestroyHeap( Heap *heap )
{	int j, k;
	char *v;

	if (heap)
	{	for (j = 0; j < (int) heap->num_hunks; j++)
		for (k = 0; k < (int) heap->ch_ratio; k++)
		{	v = (char *) heap->hunks[j] + (k * (MX_NODE_SZE));
			rel_chunk((void *) v);
		}
		memset(heap, 0, sizeof(Heap));
	}
}

// Assembly:
testq %rdi, %rdi
je 0x4537
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jge 0x451e
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0x4519
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
addq %r15, %rdi
callq 0x448f
incq %r12
addq $0x50, %r15
jmp 0x44f7
incq %r14
jmp 0x44e8
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/heap.c
// Function: HeapAlloc_Gen
void *
HeapAlloc_Gen(Heap *heap)
{	int     asze, chnk;
	void   *avail, *pnt;

	if (!heap)
		return ((void *) NULL);

	if (free_chunks)
	{	if (0) printf("-- %p	%d\n", free_chunks, --gh_sz);
		avail = (void *) free_chunks;
		free_chunks = free_chunks->fc.nxt;
		memset(avail, 0, sizeof(void *));
		return avail;
	}

	if (heap->num_hunks)
	{	chnk = (heap->next_chunk)++;

		if (chnk == (int) heap->ch_ratio)
		{
			if (heap->num_hunks == heap->hunk_array_sze)
			{	asze = heap->hunk_array_sze * 2;	/* double array size */
				pnt = (void *) e_malloc(asze * PNTR_SZE);
	
				memcpy(pnt, (void *) heap->hunks, (heap->hunk_array_sze * PNTR_SZE));
	
				e_free(heap->hunks);
				heap->hunks = pnt;
				heap->hunk_array_sze = asze;
			}
	
			heap->hunks[heap->num_hunks] =
				(void *) e_malloc(heap->chnk_sze * heap->ch_ratio);
	
			if (0) printf("2 chunk allocate at %p -- %d * %d bytes\n",
				heap->hunks[heap->num_hunks],
				heap->chnk_sze, heap->ch_ratio);

			(heap->num_hunks)++;
			heap->next_chunk = 1;
			(heap->num_alloc)++;
			return (heap->hunks[(heap->num_hunks)-1]);
		} else
		{	(heap->num_alloc)++;
			return((void *) ((char*) (heap->hunks[(heap->num_hunks)-1])
				+ (heap->chnk_sze * chnk))); 
		}
	} else
	{	heap->hunks[0] = (void *) e_malloc(heap->chnk_sze * heap->ch_ratio);
		if (0) printf("1 chunk allocate at %p -- %d * %d bytes\n",
			heap->hunks[0], heap->chnk_sze, heap->ch_ratio);
		heap->num_hunks = 1;
		heap->next_chunk = 1;
		(heap->num_alloc)++;
		return (heap->hunks[0]);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x4560
pushq %rbp
pushq %r14
pushq %rbx
movq 0x30460(%rip), %rax     # 0x349a8
testq %rax, %rax
je 0x4563
movq (%rax), %rcx
movq %rcx, 0x30451(%rip)     # 0x349a8
andq $0x0, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
movq %rdi, %rbx
movl 0x10(%rdi), %edi
testl %edi, %edi
je 0x45ea
movl 0x18(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x18(%rbx)
cmpl 0x4(%rbx), %eax
jne 0x4614
cmpl 0x14(%rbx), %edi
jne 0x45b8
leal (%rdi,%rdi), %ebp
shll $0x4, %edi
callq 0x4739
movq %rax, %r14
movq 0x28(%rbx), %rsi
movl 0x14(%rbx), %edx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x41f0
movq 0x28(%rbx), %rdi
callq 0x4738
movq %r14, 0x28(%rbx)
movl %ebp, 0x14(%rbx)
movl 0x4(%rbx), %eax
imull (%rbx), %eax
movl %eax, %edi
callq 0x4739
movq 0x28(%rbx), %rcx
movl 0x10(%rbx), %edx
movq %rax, (%rcx,%rdx,8)
leal 0x1(%rdx), %eax
movl %eax, 0x10(%rbx)
movl $0x1, 0x18(%rbx)
incl 0x8(%rbx)
movq 0x28(%rbx), %rax
movq (%rax,%rdx,8), %rax
jmp 0x455b
movl 0x4(%rbx), %edi
imull (%rbx), %edi
callq 0x4739
movq 0x28(%rbx), %rcx
movq %rax, (%rcx)
pushq $0x1
popq %rax
movl %eax, 0x10(%rbx)
movl %eax, 0x18(%rbx)
incl 0x8(%rbx)
movq 0x28(%rbx), %rax
movq (%rax), %rax
jmp 0x455b
incl 0x8(%rbx)
movq 0x28(%rbx), %rcx
decl %edi
imull (%rbx), %eax
addq (%rcx,%rdi,8), %rax
jmp 0x455b
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/nmetab.c
// Function: calc_hash
unsigned int
calc_hash(char *str)	/* pjw's hash */
{	unsigned int hsh = 0, i;

	while (*str)
	{	hsh = (hsh << ONE_EIGHTH) + *str++;
		if ((i = hsh & HIGH_BITS) != 0)
			hsh = (hsh ^ ( i >> THREE_QUARTERS)) & ~HIGH_BITS;
	}
	return hsh;
}

// Assembly:
xorl %eax, %eax
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0x4678
shll $0x4, %eax
incq %rdi
addl %ecx, %eax
movl %eax, %ecx
andl $0xf0000000, %ecx       # imm = 0xF0000000
movl %ecx, %edx
shrl $0x18, %edx
movl %eax, %esi
andl $0xfffffff, %esi        # imm = 0xFFFFFFF
xorl %edx, %esi
testl %ecx, %ecx
cmovnel %esi, %eax
jmp 0x464b
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/nmetab.c
// Function: nmelook
str_t *
nmelook(char *sym, int len)
{	HashItem *hptr;
	unsigned int hsh;
	int bckt;

	hsh  = calc_hash(sym);
	bckt = hsh % MAX_HASH_BCKTS;

	for (hptr=NmeTab[bckt]; hptr; hptr=hptr->next)
	{	if ((hptr->sym.hash == hsh)
		&&  (strcmp(sym, hptr->sym.str) == 0))
			return(&(hptr->sym));
	} 

	hptr = (HashItem *) e_malloc(HASH_ITEM_SZE);

	if (!len) len = strlen(sym);

	hptr->sym.str = e_malloc(len+1);
	hptr->sym.hash = hsh;
	strncpy(hptr->sym.str, sym, len);

	hptr->next = NmeTab[bckt];
	NmeTab[bckt] = hptr;

	return(&(hptr->sym));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x4649
movl %eax, %ebp
movl $0x3ff, %ecx            # imm = 0x3FF
xorl %edx, %edx
divl %ecx
leaq 0x30305(%rip), %rax     # 0x349c0
leaq (%rax,%rdx,8), %r12
movq %r12, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x46e5
cmpl %ebp, (%r15)
jne 0x46df
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0x472a
addq $0x10, %r15
jmp 0x46c2
pushq $0x18
popq %rdi
callq 0x4739
movq %rax, %r15
testl %r14d, %r14d
jne 0x4700
movq %rbx, %rdi
callq 0x4110
movq %rax, %r14
leal 0x1(%r14), %edi
callq 0x4739
movq %rax, 0x8(%r15)
movl %ebp, (%r15)
movslq %r14d, %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4090
movq (%r12), %rax
movq %rax, 0x10(%r15)
movq %r15, (%r12)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: e_malloc
void *
e_malloc(uint m)
{	char *tmp;
	long n = m + ALGN;	/* for possible alignment */

	assert(m != 0);

	tmp = not_malloc(n);

	if (((ulong) tmp)&(ALGN-1))
	{	tmp += (long) (ALGN  - (((ulong) tmp)&(ALGN-1)));
		memwaste += ALGN;
	} else
	{	left += ALGN;	/* return the extra bytes */
		have -= ALGN;
	}

	memcnt += m;

	return (void *) tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testl %edi, %edi
je 0x4807
movl %edi, %ebx
leal 0x8(%rbx), %r15d
movq 0x3226d(%rip), %r14     # 0x369c0
cmpq %r15, %r14
jge 0x47ac
cmpl $0x100001, %r15d        # imm = 0x100001
movl $0x100000, %eax         # imm = 0x100000
cmovael %r15d, %eax
movslq %eax, %r14
pushq $0x1
popq %rdi
movq %r14, %rsi
callq 0x41a0
movq %rax, 0x3224b(%rip)     # 0x369c8
testq %rax, %rax
jne 0x47b3
movq 0x2f86f(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x2fa0d(%rip), %rax     # 0x341a0
movq (%rax), %rdx
leaq 0x1ba01(%rip), %rsi     # 0x2019e
xorl %eax, %eax
callq 0x41c0
pushq $0x1
popq %rdi
callq 0x42b0
movq 0x32215(%rip), %rax     # 0x369c8
leaq (%rax,%r15), %rcx
movq %rcx, 0x3220a(%rip)     # 0x369c8
subq %r15, %r14
movq %r14, 0x321f8(%rip)     # 0x369c0
movq %rax, %rdx
andq $0x7, %rdx
je 0x47e2
subq %rdx, %rax
addq $0x8, %rax
addq $0x8, 0x321d8(%rip)     # 0x369b8
jmp 0x47f8
addq $0x8, %r14
movq %r14, 0x321d3(%rip)     # 0x369c0
addq $-0x8, %rcx
movq %rcx, 0x321d0(%rip)     # 0x369c8
movl %ebx, %ecx
addq %rcx, 0x321cf(%rip)     # 0x369d0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1b84a(%rip), %rdi     # 0x20058
leaq 0x1b84a(%rip), %rsi     # 0x2005f
leaq 0x1b84c(%rip), %rcx     # 0x20068
pushq $0x54
popq %rdx
callq 0x4160
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: mk_g
static symentry_t*
mk_g(str_t *sym, treenode *tn, int knd)	/* mk_generic */
{	symentry_t *that;

	that = new_symentry();

	that->kind = knd;
	that->nme  = sym;
	that->node = tn;
	that->nes = (scopetab_t *) 0;
	that->decl_level = 0;
	that->container = NULL;

	return that;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4824
movl %ebx, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
andq $0x0, 0x18(%rax)
andw $0x0, 0x20(%rax)
andq $0x0, 0x30(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: hashtab_lookup
symentry_t *
hashtab_lookup(hashtab_t *that, str_t *nme)
{	symentry_t *curr;
	int j;
  
	if (!nme || !that) return NULL;

	j = nme->hash % that->tsize;
	for (curr = that->tab[j]; curr; curr = curr->next)
		if (curr->nme
		&&  strcmp(curr->nme->str, nme->str) == 0) 
			return curr;

	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x492e
movq %rsi, %rbx
movl (%rsi), %eax
xorl %edx, %edx
divl (%rdi)
movslq %edx, %r14
shlq $0x3, %r14
addq 0x8(%rdi), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x492e
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x4928
movq 0x8(%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x41b0
testl %eax, %eax
je 0x4931
addq $0x38, %r14
jmp 0x4906
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: hashtab_insert
symentry_t*
hashtab_insert(hashtab_t *that, symentry_t *entry)
{	int j;
	symentry_t *ret;

	if ((ret = hashtab_lookup(that, entry->nme)))
	{
		return ret;
	}

	if (0) printf("insert in hashtab %p -- %s\n",
		that, entry->nme->str);

	j = entry->nme->hash % that->tsize;
	entry->next = that->tab[j];
	that->tab[j] = entry;

	return entry;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r15
movq %r15, %rsi
callq 0x48de
testq %rax, %rax
jne 0x4976
movl (%r15), %eax
xorl %edx, %edx
divl (%r14)
movq 0x8(%r14), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x38(%rbx)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: show_hashtab
void
show_hashtab(hashtab_t *that, int tabs, FILE *fp)
{	symentry_t *t;
	int j;

	for (j = 0; j < that->tsize; j++)
	for (t = that->tab[j]; t; t = t->next)
		show_symentry(t, tabs, fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %ebp
incl %ebp
xorl %ecx, %ecx
pushq $0x1
popq %r13
pushq $0xa
popq %r15
movq %rdi, 0x8(%rsp)
movslq (%rdi), %rax
cmpq %rax, %rcx
jge 0x4a8e
movq %rcx, 0x10(%rsp)
leaq (,%rcx,8), %r14
addq 0x8(%rdi), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x4a7c
movl %ebp, %edi
movq %rbx, %rsi
callq 0x599b
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x4170
movq 0x10(%r14), %r12
leaq 0x1b7ce(%rip), %rdi     # 0x201bc
pushq $0x2
popq %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x42c0
testq %r12, %r12
je 0x4a08
cmpl $0x3, (%r12)
jne 0x4a1f
leaq 0x1b7b0(%rip), %rdi     # 0x201bf
pushq $0x3
popq %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x42c0
jmp 0x4a32
movq %r12, %rdi
callq 0x8c38
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4170
pushq $0x5d
popq %rdi
movq %rbx, %rsi
callq 0x4180
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x4a68
cmpl $0x1, 0x1c(%rax)
je 0x4a68
cmpb $0x0, 0x22(%r14)
jne 0x4a68
leaq 0x1b757(%rip), %rdi     # 0x201b1
pushq $0x7
popq %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x42c0
movl %r15d, %edi
movq %rbx, %rsi
callq 0x4180
addq $0x38, %r14
jmp 0x49bd
movq 0x10(%rsp), %rcx
incq %rcx
movq 0x8(%rsp), %rdi
jmp 0x49a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: new_scopetab
scopetab_t*
new_scopetab(scopetab_t *mom)
{	scopetab_t *that;

	if (freestab)
	{	that = freestab;
		freestab = that->parent;
		memset(that, 0, sizeof(scopetab_t));
	} else
		that = (scopetab_t *) e_malloc(sizeof(scopetab_t));

	if (0)
	printf("new scope tab %p, level %d\n", that, mom?mom->level+1:EXTERN_SCOPE);

	that->size = INIT_CHILD_SIZE;

	that->children = getscoop(that->size);

	that->parent = mom;
	if (mom)
		that->level = mom->level + 1;
	else
		that->level = EXTERN_SCOPE;

	return that;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x38
popq %rdi
callq 0x4739
movq %rax, %rbx
movl $0x4, 0x2c(%rax)
pushq $0x20
popq %rdi
callq 0x4739
movq %rax, 0x30(%rbx)
movq %r14, 0x10(%rbx)
testq %r14, %r14
je 0x4adb
movl 0x4(%r14), %eax
incl %eax
jmp 0x4ade
pushq $0x1
popq %rax
movl %eax, 0x4(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: scopetab_find
symentry_t*
scopetab_find(scopetab_t *that, str_t *nme)
{	symentry_t *ret = NULL, *oret = NULL;
	int j;
	extern int structfieldflag;

if (DBG) {	printf("scopetab_find %s -- hashtab: <%p> -- ", nme->str, that?that->htab:0);
		printf("scopetab: %p, level: %d  nsyms: %d  nchild: %d -- structfield: %s -- owner_t: %d\n",
			that, that?that->level:-1, that?that->nsyms:-1, that?that->nchild:-1,
			structfieldflag?"YES":"no",
			that?that->owner_t:-1);
	}

	if (that)
	{	if (that->visited)
			return NULL;
		that->visited = 1;	/* prevent circularity */

		if (that->htab)
		{	if (!structfieldflag
			||   (that->level >= 3
			&&    that->owner_t == TN_OBJ_DEF))	/* Struct/Union, must have owner_t before ref */
			{	ret = hashtab_lookup(that->htab, nme);
			}
		}

		if (!ret && structfieldflag)	/* gjh */
		for (j = 0; j < that->nchild; j++)
		{	ret = scopetab_find(that->children[j], nme);
			if (ret)
			{	ret->used = 1;	/* set for all matches, return last */
				oret = ret;
if (DBG)			printf("Candidate Match %s: %p - %s:%d nes: %s\n",
					nme->str, ret, ret->fn, ret->ln,
					ret->nes && ret->nes->owner ? ret->nes->owner : "no owner");
		}	}
		if (!ret && oret) ret = oret;

		if (!ret) ret = scopetab_find(that->parent,nme);	/* goes up one level */

		that->visited = 0;
	}
	if (ret && structfieldflag) ret->used = 1;

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x4b0a
movq %rdi, %rbx
cmpl $0x0, 0x24(%rdi)
je 0x4b12
xorl %r15d, %r15d
jmp 0x4bcd
xorl %r15d, %r15d
jmp 0x4bb7
movq %rsi, %r14
movl $0x1, 0x24(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x453b9(%rip), %rax     # 0x49ee0
movl (%rax), %ebp
testq %rdi, %rdi
je 0x4b48
testl %ebp, %ebp
je 0x4b3e
cmpl $0x3, 0x4(%rbx)
jl 0x4b48
cmpl $0x18, 0x20(%rbx)
jne 0x4b48
movq %r14, %rsi
callq 0x48de
jmp 0x4b4a
xorl %eax, %eax
testq %rax, %rax
sete %cl
testl %ebp, %ebp
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x4b8e
xorl %r12d, %r12d
xorl %eax, %eax
xorl %r15d, %r15d
movslq 0x28(%rbx), %rcx
cmpq %rcx, %r12
jge 0x4b91
movq 0x30(%rbx), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x4aec
testq %rax, %rax
je 0x4b89
movb $0x1, 0x22(%rax)
movq %rax, %r15
incq %r12
jmp 0x4b64
xorl %r15d, %r15d
testq %r15, %r15
cmoveq %rax, %r15
testq %rax, %rax
cmovneq %rax, %r15
testq %r15, %r15
jne 0x4bb3
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x4aec
movq %rax, %r15
andl $0x0, 0x24(%rbx)
testq %r15, %r15
je 0x4bcd
leaq 0x4531d(%rip), %rax     # 0x49ee0
cmpl $0x0, (%rax)
je 0x4bcd
movb $0x1, 0x22(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: scopetab_insert
symentry_t *
scopetab_insert(scopetab_t *that, symentry_t *entry)
{
#if DBG
	int i;
	printf("	Inserting '%s' at level %d -- owner %s (%d) -- nchild %d\n",
		entry->nme->str, that->level, that->owner, that->owner_t, that->nchild);
	printf("	scopetab: %u; ", that);
	for (i = 0; i < that->nchild; i++)
		printf("%u, ", that->children[i]);
	printf("\n");
	
#endif
	if (!that->htab)
	{	that->htab = new_hashtab();
		if (!that->htab)
			return 0;
	}

	return hashtab_insert(that->htab,entry);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x4bfd
callq 0x48b5
movq %rax, %rdi
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x4c0c
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x493c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: find_glob_symentry
symentry_t *
find_glob_symentry(scopetab_t *that, char *s)
{	int j;
	symentry_t *fnd = (symentry_t *) 0;

	if (that->htab
	&&  that->level <= 2)
 		fnd = find_hashtab(that->htab, s);

	if (!fnd)
	for (j = 0; j < that->nchild; j++)
	{	if ((fnd = find_glob_symentry(that->children[j], s)) != NULL)
		{	break;
	}	}

	return fnd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0x4c82
cmpl $0x2, 0x4(%r14)
jg 0x4c82
movl (%r12), %r13d
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
cmpq %r13, %rbp
je 0x4c82
leaq (,%rbp,8), %r15
addq 0x8(%r12), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x4c7d
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x4c77
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0x4cb3
addq $0x38, %r15
jmp 0x4c56
incq %rbp
jmp 0x4c44
movl 0x28(%r14), %r12d
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x4cb3
movq 0x30(%r14), %rax
movq (%rax,%r13,8), %rdi
movq %rbx, %rsi
callq 0x4c16
incq %r13
testq %rax, %rax
je 0x4c93
movq %rax, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: show_scopetab
static void
show_scopetab(scopetab_t *that, int tabs, FILE *fp)
{	int j;
#if DBG
	fprintf(fp, "scopetab %u, level: %d  nsyms: %d  nchild: %d\n",
		that, that->level, that->nsyms, that->nchild);
#endif

	if (that->htab)
	{	scopetab_t *z;
		char prepped[512];
#if 1
		prepped[0] = '\0';
#else
		switch (that->level) {
		case  0: strcpy(prepped, "scope level 0?"); break;
		case  1: strcpy(prepped, "Global scope:"); break;
		case  2: strcpy(prepped, "File scope:"); break;
		case  3: strcpy(prepped, "Struct/FctParams:"); break;
		default: strcpy(prepped, "Block:"); break;
		}
#endif
		for (z = that; z; z = z->parent)
			if (z->owner
			&&  strcmp(z->owner, "-") != 0)
			{	strcat(prepped, "\t");
				strcat(prepped, z->owner);
				switch (z->owner_t) {
				case TN_OBJ_DEF:  strcat(prepped, " [struct/union]"); break;
				case TN_FUNC_DEF: strcat(prepped, " [fct]"); break;
				case 0: strcat(prepped, " [global]"); break;
				default: strcat(prepped, " [block]"); break;
				}
				break;
			}
#if DBG
			else strcat(prepped, "-u-");
#endif
		dotabs(tabs, fp);
		fprintf(fp, "%s\n", prepped);
		show_hashtab(that->htab, tabs, fp);
		fprintf(fp, "\n");
	}

	for (j = 0; j < that->nchild; j++)
		show_scopetab(that->children[j], tabs+1, fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x4f6f
movb $0x0, (%rsp)
movq %r14, %r12
testq %r12, %r12
je 0x4f38
movq 0x18(%r12), %rax
testq %rax, %rax
je 0x4eb1
cmpb $0x2d, (%rax)
jne 0x4eb8
cmpb $0x0, 0x1(%rax)
jne 0x4eb8
movq 0x10(%r12), %r12
jmp 0x4e93
movq %rsp, %r15
movq %r15, %rdi
callq 0x4110
movw $0x9, (%rsp,%rax)
movq 0x18(%r12), %rsi
movq %r15, %rdi
callq 0x4290
movl 0x20(%r12), %r12d
movq %r15, %rdi
callq 0x4110
addq %rsp, %rax
testl %r12d, %r12d
je 0x4f12
cmpl $0x1, %r12d
je 0x4f03
cmpl $0x18, %r12d
jne 0x4f27
movups 0x1b2c8(%rip), %xmm0    # 0x201c6
movups %xmm0, (%rax)
jmp 0x4f38
movl $0x5d7463, 0x3(%rax)    # imm = 0x5D7463
movl $0x63665b20, (%rax)     # imm = 0x63665B20
jmp 0x4f38
movabsq $0x6c61626f6c675b20, %rcx # imm = 0x6C61626F6C675B20
movq %rcx, (%rax)
movw $0x5d, 0x8(%rax)
jmp 0x4f38
movabsq $0x5d6b636f6c625b20, %rcx # imm = 0x5D6B636F6C625B20
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
movl %ebp, %edi
movq %rbx, %rsi
callq 0x599b
leaq 0x1d333(%rip), %rsi     # 0x2227c
movq %rsp, %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
movq 0x8(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x497c
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x4180
incl %ebp
xorl %r15d, %r15d
movslq 0x28(%r14), %rax
cmpq %rax, %r15
jge 0x4f94
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x4e6a
incq %r15
jmp 0x4f74
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: remove_struct
void
remove_struct(char *s)
{	char *p, *q, *x;
	int cnt, m = 0, n = strlen(s);

	p = strstr(s, "struct");

	if (p)	/* check if struct is unnamed */
	{	x = p + strlen("struct");
		while (*x == ' ' || *x == '\t')
		{	x++;
		}
		if (*x == '{')	/* unnamed */
		{	return;
	}	}

	cnt = 0;
	for (q = p; q-p < n; q++)
	{	switch (*q) {
		case '{': cnt++; m++; break;
		case '}': cnt--; break;
		default: break;
		}
		if (m > 0)
		{	*q = ' ';
			if (cnt == 0)
			{	break;
	}	}	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x4110
movq %rax, %rbx
leaq 0x1b134(%rip), %rsi     # 0x200ee
movq %r14, %rdi
callq 0x42d0
testq %rax, %rax
je 0x4fea
leaq 0x6(%rax), %rcx
movzbl (%rcx), %edx
cmpl $0x9, %edx
je 0x4fd8
cmpl $0x20, %edx
jne 0x4fdd
incq %rcx
jmp 0x4fcb
cmpl $0x7b, %edx
jne 0x4fea
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movslq %ebx, %rcx
xorl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
cmpq %rcx, %rdx
jge 0x4fe2
movzbl (%rax,%rdx), %r8d
cmpl $0x7d, %r8d
je 0x500f
cmpl $0x7b, %r8d
jne 0x5011
incl %esi
incl %edi
jmp 0x5011
decl %esi
testl %edi, %edi
jle 0x501d
movb $0x20, (%rax,%rdx)
testl %esi, %esi
je 0x4fe2
incq %rdx
jmp 0x4ff3
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: find_typedefs
void
find_typedefs(scopetab_t *that, FILE *fp)
{	scopetab_t *z;
	symentry_t *t;
	char *s;
	int j;

	if (that->htab)
	{	for (z = that; z; z = z->parent)
		for (j = 0; j < that->htab->tsize; j++)
		for (t = that->htab->tab[j]; t; t = t->next)
		{	if (t->kind == TYPEDEF_ENTRY
			&&  t->generated == 0)
			{	s = nx_stmnt(t->node);
				if (strstr(s, "struct"))
				{	t->generated = 1;
					remove_newlines(s);
					remove_struct(s);	/* if named, it will be declared separately below */
					fprintf(fp, "c_decl { %s } /* find_typedefs %p, %p */\n", s, z, t);
	}	}	}	}

	for (j = 0; j < that->nchild; j++)
		find_typedefs(that->children[j], fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rbp
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x50f0
leaq 0x1b0a7(%rip), %r15     # 0x200ee
movq %rbp, %r13
movq %rbp, (%rsp)
testq %r13, %r13
je 0x50f0
xorl %r12d, %r12d
movslq (%rax), %rcx
cmpq %rcx, %r12
jge 0x50e7
leaq (,%r12,8), %rbp
addq 0x8(%rax), %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x50d7
cmpl $0x1, (%rbp)
jne 0x50d1
cmpb $0x0, 0x23(%rbp)
jne 0x50d1
movq 0x10(%rbp), %rdi
callq 0xa49b
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x42d0
testq %rax, %rax
je 0x50d1
movb $0x1, 0x23(%rbp)
movq %r14, %rdi
callq 0x5120
movq %r14, %rdi
callq 0x4fa4
movq %rbx, %rdi
leaq 0x1b034(%rip), %rsi     # 0x200f5
movq %r14, %rdx
movq %r13, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x41c0
addq $0x38, %rbp
jmp 0x5072
incq %r12
movq (%rsp), %rbp
movq 0x8(%rbp), %rax
jmp 0x505a
movq 0x10(%r13), %r13
jmp 0x504e
xorl %r14d, %r14d
movslq 0x28(%rbp), %rax
cmpq %rax, %r14
jge 0x5111
movq 0x30(%rbp), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
callq 0x5022
incq %r14
jmp 0x50f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: remove_newlines
static void
remove_newlines(char *s)
{	char *u;
	for (;;)
	{	u = strstr(s, "\\n");
		if (u) { *u++ = ' '; *u = ' '; }
		else { break; }
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b095(%rip), %r14     # 0x201c3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
testq %rax, %rax
je 0x5145
movw $0x2020, (%rax)         # imm = 0x2020
jmp 0x512e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: set_owner
void
set_owner(scopetab_t *p, char *s, int tp)
{	int i;

	if (0) printf("	setowner for %p %s %d (%s)\n", p, s, tp,
			p->owner?p->owner:"not yet set");

	if (p->owner) return;	/* already named */

	p->owner = s;
	p->owner_t = tp;

	for (i = 0; i < p->nchild; i++)		/* propagate to nested unnamed scopes */
		set_owner(p->children[i], s, tp);
}

// Assembly:
cmpq $0x0, 0x18(%rdi)
je 0x5350
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, 0x18(%rdi)
movl %edx, 0x20(%rdi)
xorl %r12d, %r12d
movslq 0x28(%r15), %rax
cmpq %rax, %r12
jge 0x538a
movq 0x30(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5348
incq %r12
jmp 0x536a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: name_scope
void
name_scope(context_t *q, char *s, int tp)
{	symtab_t *p = q->syms;

	if (DBG) printf("name_scope %p -- owner=%s (owner_t=%d) clevel %d, level %d\n",
		p->current,
		s, tp,
		p->clevel,
		p->current->level);
	set_owner(p->current, s, tp);

	if (Verbose&2)
	printf("SET level %d,%d, %s\n",
		p->clevel,  p->current->level,  s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x10(%r14), %rdi
callq 0x5348
leaq 0x316cb(%rip), %rax     # 0x36a7c
testb $0x2, (%rax)
jne 0x53be
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x8(%r14), %esi
movq 0x10(%r14), %rax
movl 0x4(%rax), %edx
leaq 0x1ada4(%rip), %rdi     # 0x20174
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: symtab_insert
symentry_t*
symtab_insert(symtab_t *that, symentry_t *entry)
{	symentry_t *t;
#if DBG
	printf("	symtab insert %s (clevel %d currentlevel %d) %u\n",
		entry->nme->str, that->clevel, that->current->level, entry);
#endif
	while (that->clevel > that->current->level)
	{	scopetab_t *child = new_scopetab(that->current);

		if (!child || !child_insert(that->current,child))
			return NULL;

		that->current = child;
	}
	t = scopetab_insert(that->current,entry);
#if DBG
	printf("	inserted at %u\n", t);
#endif
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
movl 0x8(%r14), %eax
cmpl 0x4(%r15), %eax
jle 0x5452
movq %r15, %rdi
callq 0x4aa5
testq %rax, %rax
je 0x5462
movq %rax, %r15
movq 0x10(%r14), %rdi
movq %rax, %rsi
callq 0x546a
movq %r15, 0x10(%r14)
jmp 0x5426
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4bd9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: child_insert
static int
child_insert(scopetab_t *mom, scopetab_t *kid)
{	int j;

	if (0)
	printf("		child insert - level %d\n", mom->level);

	if (mom->nchild >= mom->size)
	{	scopetab_t **oldkids = mom->children;
		mom->size += mom->size;
		mom->children = (scopetab_t **) e_malloc( sizeof(scopetab_t*) * mom->size );

		for (j=0; j < mom->nchild; j++)
			mom->children[j] = oldkids[j];
	}

	mom->children[mom->nchild] = kid;
	(mom->nchild)++;

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x28(%rdi), %eax
movl 0x2c(%rdi), %edi
cmpl %edi, %eax
jge 0x5494
movq 0x30(%rbx), %rcx
cltq
movq %r14, (%rcx,%rax,8)
incl %eax
movl %eax, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x30(%rbx), %r15
leal (%rdi,%rdi), %eax
movl %eax, 0x2c(%rbx)
shll $0x4, %edi
callq 0x4739
movq %rax, 0x30(%rbx)
movl 0x28(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rcx, %rdx
je 0x547f
movq (%r15,%rcx,8), %rsi
movq 0x30(%rbx), %rdi
movq %rsi, (%rdi,%rcx,8)
incq %rcx
jmp 0x54b9
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: symtab_insert_at
symentry_t *
symtab_insert_at(symtab_t *that, symentry_t *entry, int level)
{	scopetab_t *scp;
	scopetab_t *child;

#ifdef  MORE_VERBOSE
	printf("scope level %d; ",   that->current->level);
	printf("current level %d; ", that->clevel);
	printf("request level %d\n", level);
#endif

	while ((that->clevel >  that->current->level)
	    && (that->clevel >= level))
	{
		child = new_scopetab(that->current);

		if (!child
		||  !child_insert(that->current,child))
			return (symentry_t *) 0;

		that->current = child;
	}

	scp = that->current;

	while (scp && (scp->level > level))
		scp = scp->parent;

	if (scp)
		return scopetab_insert(scp,entry);

	return (symentry_t *) 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %r14
movl 0x8(%r15), %eax
cmpl %ebp, %eax
jl 0x551c
cmpl 0x4(%r14), %eax
jle 0x551c
movq %r14, %rdi
callq 0x4aa5
testq %rax, %rax
je 0x5521
movq %rax, %r14
movq 0x10(%r15), %rdi
movq %rax, %rsi
callq 0x546a
movq %r14, 0x10(%r15)
jmp 0x54e2
cmpl %ebp, 0x4(%r14)
jle 0x552e
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x5512
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4bd9
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: add_fctnm
void
add_fctnm(char *s)
{	NameList *f;
	for (f = fctnms; f; f = f->nxt)
	{	if (strcmp(f->nm, s) == 0)
		{	return;
	}	}
	f = (NameList *) e_malloc(sizeof(NameList));
	f->nm = s;
	f->nxt = fctnms;
	fctnms = f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x31454(%rip), %r14     # 0x369e0
movq (%r14), %r14
testq %r14, %r14
je 0x55a9
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x41b0
addq $0x8, %r14
testl %eax, %eax
jne 0x558c
jmp 0x55c6
pushq $0x10
popq %rdi
callq 0x4739
movq %rbx, (%rax)
movq 0x31425(%rip), %rcx     # 0x369e0
movq %rcx, 0x8(%rax)
movq %rax, 0x3141a(%rip)     # 0x369e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: is_fctnm
int
is_fctnm(char *s)
{	NameList *f;
	for (f = fctnms; f; f = f->nxt)
	{	if (strcmp(f->nm, s) == 0)
		{	return 1;
	}	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x31403(%rip), %r15     # 0x369e0
pushq $0x1
popq %rbx
movq (%r15), %r15
testq %r15, %r15
je 0x55fd
movq (%r15), %rdi
movq %r14, %rsi
callq 0x41b0
addq $0x8, %r15
testl %eax, %eax
jne 0x55e0
jmp 0x55ff
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: save_fcts
void
save_fcts(scopetab_t *that, FILE *fp)
{	scopetab_t *z;
	int j;

	for (z = that; z; z = z->parent)
	{	if (z->owner
		&&  z->owner_t == TN_FUNC_DEF
		&&  strcmp(z->owner, "-") != 0)
		{	add_fctnm(z->owner);
	}	}

	for (j = 0; j < that->nchild; j++)
		save_fcts(that->children[j], fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
testq %r15, %r15
je 0x5640
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x563a
cmpl $0x1, 0x20(%r15)
jne 0x563a
cmpb $0x2d, (%rdi)
jne 0x5635
cmpb $0x0, 0x1(%rdi)
je 0x563a
callq 0x557e
movq 0x10(%r15), %r15
jmp 0x5615
xorl %r15d, %r15d
movslq 0x28(%r14), %rax
cmpq %rax, %r15
jge 0x5661
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x5607
incq %r15
jmp 0x5643
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: new_context
context_t*
new_context(void)
{	context_t *that = (context_t *) e_malloc( sizeof(context_t) );

	that->labels = new_symtab();
	that->tags   = new_symtab();
	that->syms   = new_symtab();

	return that;
}

// Assembly:
pushq %rbx
pushq $0x18
popq %rdi
callq 0x4739
movq %rax, %rbx
callq 0x53e1
movq %rax, (%rbx)
callq 0x53e1
movq %rax, 0x8(%rbx)
callq 0x53e1
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: exit_scopes
void
exit_scopes(context_t *that, int newlev)
{
	if (newlev < EXTERN_SCOPE)
		newlev = EXTERN_SCOPE;

	while (newlev < that->syms->current->level)
		exit_scope(that);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
pushq $0x1
popq %rbp
cmovgel %esi, %ebp
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
cmpl 0x4(%rax), %ebp
jge 0x56f1
movq %rbx, %rdi
callq 0x56ac
jmp 0x56da
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: add_constant
void
add_constant(char *p, int isvis)
{	Cname *s;

	for (s = cnames; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
			return;
	s = (Cname *) e_malloc(sizeof(Cname));
	s->vn = (char *) e_malloc(strlen(p)+1);
	strcpy(s->vn, p);
	s->hit = 0;
	s->isvis = isvis;
	s->nxt = cnames;
	cnames = s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x312df(%rip), %r15     # 0x369e8
movq (%r15), %r15
testq %r15, %r15
je 0x5726
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41b0
addq $0x18, %r15
testl %eax, %eax
jne 0x5709
jmp 0x576a
pushq $0x20
popq %rdi
callq 0x4739
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
andl $0x0, 0x8(%r15)
movl %ebx, 0xc(%r15)
movq 0x31289(%rip), %rax     # 0x369e8
movq %rax, 0x18(%r15)
movq %r15, 0x3127e(%rip)     # 0x369e8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: is_constant
int
is_constant(char *p)
{	Cname *s;

	for (s = cnames; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
		{	s->hit = 1;
			return 1;
		}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3126a(%rip), %r14     # 0x369e8
movq (%r14), %r14
testq %r14, %r14
je 0x579b
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0x579f
addq $0x18, %r14
jmp 0x577e
xorl %eax, %eax
jmp 0x57aa
movl $0x1, 0x8(%r14)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: do_constants
void
do_constants(FILE *fd)
{	Cname *s;
	int i = 1;

	if (!cnames) return;

	fprintf(fd, "\n");
	for (s = cnames; s; s = s->nxt)
	{	if (s->purged)
		{	continue;
		}
		s->purged = 1;
		if (s->isvis)
		{	fprintf(fd, "hidden int %s = %d;\n", s->vn, i++);
	}	}
	fprintf(fd, "\n");
}

// Assembly:
cmpq $0x0, 0x3122e(%rip)     # 0x369e8
je 0x5830
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x4180
pushq $0x1
popq %rcx
leaq 0x3120d(%rip), %r15     # 0x369e8
leaq 0x1a9a7(%rip), %r14     # 0x20189
movq (%r15), %r15
testq %r15, %r15
je 0x581b
cmpl $0x0, 0x10(%r15)
jne 0x5815
movl $0x1, 0x10(%r15)
cmpl $0x0, 0xc(%r15)
je 0x5815
movq (%r15), %rdx
leal 0x1(%rcx), %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x41c0
movl %ebp, %ecx
addq $0x18, %r15
jmp 0x57e2
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4180
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: add_icall
void
add_icall(char *p)
{	Cname *s;

	for (s = icalls; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
			return;
	s = (Cname *) e_malloc(sizeof(Cname));
	s->vn = (char *) e_malloc(strlen(p)+1);
	strcpy(s->vn, p);
	s->hit = 0;
	s->nxt = icalls;
	icalls = s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x311b1(%rip), %r14     # 0x369f0
movq (%r14), %r14
testq %r14, %r14
je 0x585c
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x41b0
addq $0x18, %r14
testl %eax, %eax
jne 0x583f
jmp 0x589c
pushq $0x20
popq %rdi
callq 0x4739
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
andl $0x0, 0x8(%r14)
movq 0x3115f(%rip), %rax     # 0x369f0
movq %rax, 0x18(%r14)
movq %r14, 0x31154(%rip)     # 0x369f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: is_icall
int
is_icall(char *p)
{	Cname *s;

	for (s = icalls; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
		{	s->hit = 1;
			return 1;
		}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3113e(%rip), %r14     # 0x369f0
movq (%r14), %r14
testq %r14, %r14
je 0x58cf
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0x58d3
addq $0x18, %r14
jmp 0x58b2
xorl %eax, %eax
jmp 0x58de
movl $0x1, 0x8(%r14)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: add_pname
void
add_pname(char *p)
{	Cname *s;

	for (s = pnames; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
			return;
	s = (Cname *) e_malloc(sizeof(Cname));
	s->vn = (char *) e_malloc(strlen(p)+1);
	strcpy(s->vn, p);
	s->hit = 0;
	s->nxt = pnames;
	pnames = s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x31104(%rip), %r14     # 0x369f8
movq (%r14), %r14
testq %r14, %r14
je 0x5911
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x41b0
addq $0x18, %r14
testl %eax, %eax
jne 0x58f4
jmp 0x5951
pushq $0x20
popq %rdi
callq 0x4739
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
andl $0x0, 0x8(%r14)
movq 0x310b2(%rip), %rax     # 0x369f8
movq %rax, 0x18(%r14)
movq %r14, 0x310a7(%rip)     # 0x369f8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/symtab.c
// Function: is_pname
int
is_pname(char *p)
{	Cname *s;

	for (s = pnames; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
		{	s->hit = 1;
			return 1;
		}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x31091(%rip), %r14     # 0x369f8
movq (%r14), %r14
testq %r14, %r14
je 0x5984
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0x5988
addq $0x18, %r14
jmp 0x5967
xorl %eax, %eax
jmp 0x5993
movl $0x1, 0x8(%r14)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/modex.c
// Function: new_cmd
void
new_cmd(char c, char *s, int h)
{	Cmd *cmd;

	if (!s)
	{	fprintf(stderr, "modex: bad argument to '%c'\n", c);
		exit(1);
	}

	if (c == 'e')	// instrumented function
	{	add_icall(s);
	}
	if (c == 'p')	// passive proctype
	{	add_pname(s);
	}

	cmd = (Cmd *) e_malloc(sizeof(Cmd));
	memset(cmd, 0, sizeof(Cmd));
	cmd->cmd = c;
	cmd->n = nrprocs;
	cmd->arg = (char *) e_malloc(strlen(s)+1);
	strcpy(cmd->arg, s);

	if (Verbose_cmds)
	{	printf("New cmd <%c> <%s> <called from: %d> (nrprocs %d)\n", c, s, h, nrprocs);
	}

	if (cmds)
	{	cmds->nxt = cmd;
	}
	cmds = cmd;

	if (!ncmd)
	{	ncmd = cmds;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x6082
movl %edx, %ebx
movq %rsi, %r14
movsbl %dil, %ebp
cmpl $0x70, %ebp
je 0x5fe5
cmpl $0x65, %ebp
jne 0x5fed
movq %r14, %rdi
callq 0x5831
jmp 0x5fed
movq %r14, %rdi
callq 0x58e6
pushq $0x18
popq %rdi
callq 0x4739
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl %ebp, (%rax)
movl 0x2e1f9(%rip), %eax     # 0x34200
movl %eax, 0x4(%r15)
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x4739
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
cmpl $0x0, 0x309eb(%rip)     # 0x36a1c
je 0x604f
movl 0x2e1c6(%rip), %r8d     # 0x34200
leaq 0x1b158(%rip), %rdi     # 0x21199
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x4140
movq 0x309ca(%rip), %rax     # 0x36a20
testq %rax, %rax
je 0x605f
movq %r15, 0x10(%rax)
movq %r15, 0x309ba(%rip)     # 0x36a20
cmpq $0x0, 0x309ba(%rip)     # 0x36a28
jne 0x6077
movq %r15, 0x309b1(%rip)     # 0x36a28
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2df6f(%rip), %rax     # 0x33ff8
movq (%rax), %rax
movsbl %dil, %edx
leaq 0x1b0e5(%rip), %rsi     # 0x2117c
movq %rax, %rdi
xorl %eax, %eax
callq 0x41c0
pushq $0x1
popq %rdi
callq 0x42b0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Modex/Src/modex.c
// Function: expand_cmd
void
expand_cmd(char c, char *s, int h)	// e.g., s="one,two,three"
{	char *z = s;

	while (s != NULL && (z = strchr(s, ',')) != NULL)
	{	*z = '\0';
		new_cmd(c, s, h);
		s = z+1;
	}
	if (s != NULL)	// last one in list
	{	new_cmd(c, s, h);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
pushq $0x2c
popq %r14
movsbl %dil, %ebp
testq %r15, %r15
je 0x60ed
movq %r15, %rdi
movl %r14d, %esi
callq 0x4130
testq %rax, %rax
je 0x60f6
movq %rax, %r12
movb $0x0, (%rax)
movl %ebp, %edi
movq %r15, %rsi
movl %ebx, %edx
callq 0x5fb8
incq %r12
movq %r12, %r15
jmp 0x60be
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
movq %r15, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5fb8