LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x64c(%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 0x2d50
movl $0x100000, %edx         # imm = 0x100000
movl %ebp, %edi
movq %r15, %rsi
callq 0x20d0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x2d6f
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 0x2d8e
testl %eax, %eax
jne 0x2d4b
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2140
incq (%rbx)
jmp 0x2d2b
leaq 0x51d(%rip), %rdi       # 0x3274
leaq 0x51e(%rip), %rsi       # 0x327c
leaq 0x525(%rip), %rcx       # 0x328a
movl $0x16, %edx
callq 0x2150
leaq 0x547(%rip), %rdi       # 0x32bd
leaq 0x4ff(%rip), %rsi       # 0x327c
leaq 0x506(%rip), %rcx       # 0x328a
movl $0x17, %edx
callq 0x2150
leaq 0x54d(%rip), %rdi       # 0x32e2
leaq 0x4e0(%rip), %rsi       # 0x327c
leaq 0x4e7(%rip), %rcx       # 0x328a
movl $0x1f, %edx
callq 0x2150
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/xtract.c
// Function: dump_lut
void
dump_lut(void)
{	int n;
	FILE *lf;
	char nlutfl[512];
	static char *prefs[] =
	{ "D: ", "C: ", "A: ", "F: ", "R: ", "case ", "", 0 };

	sprintf(nlutfl, "%s.%s", want, suffix);
	if (1 || Verbose_cmds)
		fprintf(stderr, "%s: writing %s\n", progname, nlutfl);

	if ((lf = fopen(nlutfl, MFLAGS)) == NULL)
	{	fprintf(stderr, "%s: cannot create %s\n", progname, nlutfl);
		return;
	}
if (debug_io) fprintf(stderr, "open %s -> %p\n", nlutfl, lf);
	fprintf(lf, "%s for target <%s>\n", Banner, want);
	dump_fct(lf);
	dump_substitute(lf);

	if (Verbose&2)
		dump_decls(stdout);

	for (n = 0; prefs[n]; n++)
		trav_lut(lf, prefs[n]);
if (debug_io) fprintf(stderr, "close v %p\n", lf);
	Fclose(lf);
	add_fnm(nlutfl);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
leaq 0x32d50(%rip), %r12     # 0x37198
movq (%r12), %rdx
leaq 0x32d35(%rip), %rax     # 0x37188
movq (%rax), %rcx
leaq 0x2168c(%rip), %rsi     # 0x25ae9
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4290
movq 0x32b87(%rip), %r14     # 0x36ff8
movq (%r14), %rdi
leaq 0x32d15(%rip), %r15     # 0x37190
movq (%r15), %rdx
leaq 0x2166a(%rip), %rsi     # 0x25aef
movq %rbx, %rcx
xorl %eax, %eax
callq 0x41c0
leaq 0x26449(%rip), %rsi     # 0x2a8df
movq %rbx, %rdi
callq 0x4260
testq %rax, %rax
je 0x4549
movq %rax, %rbx
leaq 0x35557(%rip), %r15     # 0x39a08
cmpl $0x0, (%r15)
jne 0x4562
movq (%r12), %rcx
leaq 0x20494(%rip), %rsi     # 0x2495a
leaq 0x204a1(%rip), %rdx     # 0x2496e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
movq %rbx, %rdi
callq 0xc6a2
movq %rbx, %rdi
callq 0xfc84
leaq 0x3557e(%rip), %rax     # 0x39a6c
testb $0x2, (%rax)
je 0x4502
movq 0x32ad6(%rip), %rax     # 0x36fd0
movq (%rax), %rdi
callq 0xdf4e
xorl %r12d, %r12d
leaq 0x31fe4(%rip), %r13     # 0x364f0
movq (%r12,%r13), %rsi
movq %rbx, %rdi
callq 0x11136
addq $0x8, %r12
cmpq $0x38, %r12
jne 0x450c
cmpl $0x0, (%r15)
jne 0x457e
movq %rbx, %rdi
callq 0x793c
movq %rsp, %rdi
callq 0xe728
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq (%r15), %rdx
leaq 0x215a9(%rip), %rsi     # 0x25aff
movq %rsp, %rcx
xorl %eax, %eax
callq 0x41c0
jmp 0x4538
movq (%r14), %rdi
leaq 0x20e97(%rip), %rsi     # 0x25403
movq %rsp, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x41c0
jmp 0x44bb
movq (%r14), %rdi
leaq 0x2158d(%rip), %rsi     # 0x25b15
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41c0
jmp 0x4528
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x30, %edi
callq 0x6469
movq %rax, %r14
cmpl $0x9, %ebp
movl $0x8, %eax
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)
movaps 0x1cf36(%rip), %xmm0    # 0x23010
movups %xmm0, 0x8(%r14)
movl $0x0, 0x18(%r14)
movq $0x0, 0x20(%r14)
movl $0x40, %edi
callq 0x6469
movq %rax, 0x28(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3188b(%rip), %rsi     # 0x37998
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x6135
cmpq $0x3e7, %rsi            # imm = 0x3E7
jbe 0x613e
cmpq %rdi, %rsi
jne 0x610d
leaq 0x1cef6(%rip), %rdi     # 0x23020
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4140
jmp 0x613a
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
leaq 0x1ceee(%rip), %rdi     # 0x23033
callq 0x40d0
callq 0x4060
// File: /workspace/github_c_makefile_star2_O1/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 0x6105
testl %eax, %eax
je 0x618b
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x3181f(%rip), %rax     # 0x37998
movq %rax, (%rbx)
movq %rbx, 0x31815(%rip)     # 0x37998
incl 0x31817(%rip)           # 0x379a0
popq %rbx
retq
movl $0x1, %edi
callq 0x42a0
// File: /workspace/github_c_makefile_star2_O1/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 0x61ff
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jle 0x61e6
xorl %r14d, %r14d
cmpl $0x0, 0x4(%rbx)
jle 0x61da
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
addq %r15, %rdi
callq 0x614f
incq %r12
movslq 0x4(%rbx), %rax
addq $0x50, %r15
cmpq %rax, %r12
jl 0x61ba
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x61ae
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_O1/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 0x622b
pushq %rbp
pushq %r14
pushq %rbx
movq 0x31788(%rip), %rax     # 0x37998
testq %rax, %rax
je 0x622e
movq (%rax), %rcx
movq %rcx, 0x31779(%rip)     # 0x37998
movq $0x0, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x62b5
movl 0x18(%rbx), %eax
leal 0x1(%rax), %edx
movl %edx, 0x18(%rbx)
cmpl 0x4(%rbx), %eax
jne 0x62e1
movl 0x14(%rbx), %edi
cmpl %edi, %ecx
jne 0x6282
leal (%rdi,%rdi), %ebp
shll $0x4, %edi
callq 0x6469
movq %rax, %r14
movq 0x28(%rbx), %rsi
movl 0x14(%rbx), %edx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x41f0
movq 0x28(%rbx), %rdi
callq 0x6468
movq %r14, 0x28(%rbx)
movl %ebp, 0x14(%rbx)
movl 0x4(%rbx), %edi
imull (%rbx), %edi
callq 0x6469
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 0x6226
movl 0x4(%rbx), %edi
imull (%rbx), %edi
callq 0x6469
movq 0x28(%rbx), %rcx
movq %rax, (%rcx)
movl $0x1, %eax
movl %eax, 0x10(%rbx)
movl %eax, 0x18(%rbx)
incl 0x8(%rbx)
movq 0x28(%rbx), %rax
movq (%rax), %rax
jmp 0x6226
incl 0x8(%rbx)
movq 0x28(%rbx), %rdx
decl %ecx
imull (%rbx), %eax
addq (%rdx,%rcx,8), %rax
jmp 0x6226
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rdi), %cl
testb %cl, %cl
je 0x6351
incq %rdi
xorl %eax, %eax
shll $0x4, %eax
movsbl %cl, %ecx
addl %eax, %ecx
movl %ecx, %edx
andl $0xf0000000, %edx       # imm = 0xF0000000
movl %edx, %esi
shrl $0x18, %esi
movl %ecx, %eax
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
xorl %esi, %eax
testl %edx, %edx
cmovel %ecx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x6324
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movb (%rdi), %cl
testb %cl, %cl
je 0x63b3
leaq 0x1(%rbx), %rax
xorl %ebp, %ebp
shll $0x4, %ebp
movsbl %cl, %ecx
addl %ebp, %ecx
movl %ecx, %edx
andl $0xf0000000, %edx       # imm = 0xF0000000
movl %edx, %esi
shrl $0x18, %esi
movl %ecx, %ebp
andl $0xfffffff, %ebp        # imm = 0xFFFFFFF
xorl %esi, %ebp
testl %edx, %edx
cmovel %ecx, %ebp
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x6384
jmp 0x63b5
xorl %ebp, %ebp
movl %ebp, %eax
imulq $0x401005, %rax, %rax   # imm = 0x401005
shrq $0x20, %rax
movl %ebp, %r12d
subl %eax, %r12d
shrl %r12d
addl %eax, %r12d
shrl $0x9, %r12d
movl %r12d, %eax
shll $0xa, %eax
subl %eax, %r12d
addl %ebp, %r12d
leaq 0x315cb(%rip), %r13     # 0x379b0
movq (%r13,%r12,8), %r15
testq %r15, %r15
je 0x640a
cmpl %ebp, (%r15)
jne 0x6404
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0x6453
movq 0x10(%r15), %r15
jmp 0x63ea
movl $0x18, %edi
callq 0x6469
movq %rax, %r15
testl %r14d, %r14d
jne 0x6427
movq %rbx, %rdi
callq 0x4110
movq %rax, %r14
leal 0x1(%r14), %edi
callq 0x6469
movq %rax, 0x8(%r15)
movl %ebp, (%r15)
movslq %r14d, %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4090
movq (%r13,%r12,8), %rax
movq %rax, 0x10(%r15)
movq %r15, (%r13,%r12,8)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x6526
movl %edi, %ebx
leal 0x8(%rbx), %r15d
cmpq %r15, 0x3352d(%rip)     # 0x399b0
jge 0x64c4
cmpl $0x100001, %r15d        # imm = 0x100001
movl $0x100000, %eax         # imm = 0x100000
cmovael %r15d, %eax
movslq %eax, %r14
movq %r14, %rdi
callq 0x4210
movq %rax, 0x33511(%rip)     # 0x399b8
testq %rax, %rax
je 0x6545
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x4180
movq %r14, 0x334ec(%rip)     # 0x399b0
movq 0x334ed(%rip), %rax     # 0x399b8
leaq (%rax,%r15), %rcx
movq %rcx, 0x334e2(%rip)     # 0x399b8
movq 0x334d3(%rip), %rdx     # 0x399b0
subq %r15, %rdx
movq %rdx, 0x334c9(%rip)     # 0x399b0
movq %rax, %rsi
andq $0x7, %rsi
je 0x6501
subq %rsi, %rax
addq $0x8, %rax
addq $0x8, 0x334a9(%rip)     # 0x399a8
jmp 0x6517
addq $0x8, %rdx
movq %rdx, 0x334a4(%rip)     # 0x399b0
addq $-0x8, %rcx
movq %rcx, 0x334a1(%rip)     # 0x399b8
movl %ebx, %ecx
addq %rcx, 0x334a0(%rip)     # 0x399c0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cb2b(%rip), %rdi     # 0x23058
leaq 0x1cb2b(%rip), %rsi     # 0x2305f
leaq 0x1cb2d(%rip), %rcx     # 0x23068
movl $0x54, %edx
callq 0x4160
callq 0x42f0
// File: /workspace/github_c_makefile_star2_O1/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 0x676e
movq %rsi, %rbx
movl (%rsi), %eax
xorl %edx, %edx
divl (%rdi)
movq 0x8(%rdi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x676e
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x6768
movq 0x8(%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x41b0
testl %eax, %eax
je 0x6771
movq 0x38(%r14), %r14
jmp 0x6749
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6721
testq %rax, %rax
jne 0x67b6
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_O1/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:
cmpl $0x0, (%rdi)
jle 0x6902
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r14d
leal 0x1(%r14), %ebp
xorl %ecx, %ecx
leaq 0x1c9d3(%rip), %r12     # 0x231b9
movq %rdi, 0x8(%rsp)
movq 0x8(%rdi), %rax
movq %rcx, 0x10(%rsp)
movq (%rax,%rcx,8), %r13
testq %r13, %r13
je 0x68db
testl %r14d, %r14d
js 0x6823
movl %ebp, %r15d
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x42b0
decl %r15d
jne 0x6809
movq 0x8(%r13), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x4170
movq 0x10(%r13), %r15
movl $0x2, %esi
movl $0x1, %edx
leaq 0x1c974(%rip), %rdi     # 0x231bc
movq %rbx, %rcx
callq 0x42b0
testq %r15, %r15
je 0x685b
cmpl $0x3, (%r15)
jne 0x6876
movl $0x3, %esi
movl $0x1, %edx
leaq 0x1c953(%rip), %rdi     # 0x231bf
movq %rbx, %rcx
callq 0x42b0
jmp 0x6889
movq %r15, %rdi
callq 0xad70
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4170
movl $0x5d, %edi
movq %rbx, %rsi
callq 0x4190
movq 0x10(%r13), %rax
testq %rax, %rax
je 0x68c5
cmpl $0x1, 0x1c(%rax)
je 0x68c5
cmpb $0x0, 0x22(%r13)
jne 0x68c5
movl $0x7, %esi
movl $0x1, %edx
leaq 0x1c8f4(%rip), %rdi     # 0x231b1
movq %rbx, %rcx
callq 0x42b0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4190
movq 0x38(%r13), %r13
jmp 0x67f8
movq 0x10(%rsp), %rcx
incq %rcx
movq 0x8(%rsp), %rdi
movslq (%rdi), %rax
cmpq %rax, %rcx
jl 0x67eb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6976
movq %rdi, %rbx
cmpl $0x0, 0x24(%rdi)
je 0x697e
xorl %r15d, %r15d
jmp 0x6a43
xorl %r15d, %r15d
jmp 0x6a2d
movq %rsi, %r14
movl $0x1, 0x24(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x69b3
leaq 0x46538(%rip), %rax     # 0x4ced0
cmpl $0x0, (%rax)
je 0x69a9
cmpl $0x3, 0x4(%rbx)
jl 0x69b3
cmpl $0x18, 0x20(%rbx)
jne 0x69b3
movq %r14, %rsi
callq 0x6721
jmp 0x69b5
xorl %eax, %eax
xorl %r15d, %r15d
testq %rax, %rax
jne 0x6a04
leaq 0x4650c(%rip), %rcx     # 0x4ced0
cmpl $0x0, (%rcx)
je 0x6a04
cmpl $0x0, 0x28(%rbx)
jle 0x69ff
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x6958
testq %rax, %rax
je 0x69f1
movb $0x1, 0x22(%rax)
movq %rax, %r15
incq %r12
movslq 0x28(%rbx), %rcx
cmpq %rcx, %r12
jl 0x69d5
jmp 0x6a04
xorl %eax, %eax
xorl %r15d, %r15d
testq %r15, %r15
cmoveq %rax, %r15
testq %rax, %rax
cmovneq %rax, %r15
testq %r15, %r15
jne 0x6a26
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x6958
movq %rax, %r15
movl $0x0, 0x24(%rbx)
testq %r15, %r15
je 0x6a43
leaq 0x46497(%rip), %rax     # 0x4ced0
cmpl $0x0, (%rax)
je 0x6a43
movb $0x1, 0x22(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
jne 0x6a91
movl $0x18, %edi
callq 0x6469
movq %rax, %r15
movl $0x11, (%rax)
movl $0x88, %edi
callq 0x6469
movq %rax, 0x8(%r15)
movl $0x0, 0x4(%r15)
movq %r15, 0x8(%r14)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x677c
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x6b0e
cmpl $0x2, 0x4(%r15)
jg 0x6b0e
movslq (%rax), %r12
testq %r12, %r12
jle 0x6b0e
movq 0x8(%rax), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%rsp), %rax
movq (%rax,%rbp,8), %r14
testq %r14, %r14
je 0x6b04
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x6afe
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0x6b56
movq 0x38(%r14), %r14
jmp 0x6ae0
incq %rbp
cmpq %r12, %rbp
jne 0x6ad8
jmp 0x6b11
xorl %r13d, %r13d
testq %r13, %r13
je 0x6b28
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq 0x28(%r15), %r14
testq %r14, %r14
jle 0x6b5b
movq 0x30(%r15), %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x6aa2
testq %rax, %rax
jne 0x6b60
incq %r12
cmpq %r12, %r14
jne 0x6b3b
jmp 0x6b16
movq %r14, %r13
jmp 0x6b11
xorl %r13d, %r13d
jmp 0x6b16
movq %rax, %r13
jmp 0x6b16
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/symtab.c
// Function: find_symbol
int
find_symbol(scopetab_t *st, symentry_t *se)
{	int i;
	hashtab_t *h;
	symentry_t *e;

	if (!st || !se) { printf("<%p,%p> ",st,se); return 0; }

	h = st->htab;

	if (h)
	for (i = 0; i < h->tsize; i++)
	for (e = h->tab[i]; e; e = e->next)
	{	if (e == se)
		{
same:			printf("%s:%d: (scopetab %p symentry %p)", se->fn, se->ln, st, se);

			if (se->container)
			{	printf("cont:<%s> ",
					x_stmnt(se->container));
			}

			if (Verbose&2)
			{	switch (st->level) {
				case  0: printf("Top"); break;
				case  1: printf("Global"); break;
				case  2: printf("File"); break;
				case  3: printf("Struct/FctParams"); break;
				default: printf("Block"); break;
				}
			}
			return 1;
		} else if (strcmp(e->nme->str, se->nme->str) == 0)
		{	if (1 || (Verbose&2))
			{	printf("<rogue match> ");
				goto same;
			}
			return 0;
	}	}

	if (find_symbol(st->parent, se))
		return 1;

	printf("\n===couldn't find it:===\n");
	visu = 1;
	show_scopetab(st, 0, stdout);
	visu = 0;
	printf("===\n\t");

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
je 0x6c3a
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x6bdf
movslq (%rax), %r15
testq %r15, %r15
jle 0x6bdf
movq 0x8(%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
testq %rbp, %rbp
je 0x6bd7
cmpq %r14, %rbp
je 0x6c6f
movq 0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
callq 0x41b0
testl %eax, %eax
je 0x6c61
movq 0x38(%rbp), %rbp
jmp 0x6ba6
incq %r13
cmpq %r15, %r13
jne 0x6ba2
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x6b65
movl $0x1, %ebp
testl %eax, %eax
jne 0x6c50
leaq 0x1c5f5(%rip), %rdi     # 0x231f0
callq 0x40d0
movl $0x1, 0x32dbe(%rip)     # 0x399c8
movq 0x303bf(%rip), %rax     # 0x36fd0
movq (%rax), %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d10
movl $0x0, 0x32d9e(%rip)     # 0x399c8
leaq 0x1c4b7(%rip), %rdi     # 0x230e8
xorl %eax, %eax
callq 0x4140
jmp 0x6c50
leaq 0x1c43c(%rip), %rdi     # 0x2307d
xorl %ebp, %ebp
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4140
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c471(%rip), %rdi     # 0x230d9
xorl %eax, %eax
callq 0x4140
movq 0x28(%r14), %rsi
movl 0x24(%r14), %edx
leaq 0x1c408(%rip), %rdi     # 0x23086
movq %rbx, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x4140
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x6caa
callq 0xad70
leaq 0x1c407(%rip), %rdi     # 0x230a7
movq %rax, %rsi
xorl %eax, %eax
callq 0x4140
leaq 0x32dbb(%rip), %rax     # 0x39a6c
movl $0x1, %ebp
testb $0x2, (%rax)
je 0x6c50
movl 0x4(%rbx), %eax
cmpq $0x3, %rax
ja 0x6d04
leaq 0x1c37d(%rip), %rcx     # 0x23048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1c3d7(%rip), %rdi     # 0x230b2
jmp 0x6c31
leaq 0x1c3d6(%rip), %rdi     # 0x230bd
jmp 0x6c31
leaq 0x1c3cf(%rip), %rdi     # 0x230c2
jmp 0x6c31
leaq 0x1c3b7(%rip), %rdi     # 0x230b6
jmp 0x6c31
leaq 0x1c3c8(%rip), %rdi     # 0x230d3
jmp 0x6c31
// File: /workspace/github_c_makefile_star2_O1/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 0x6dc0
movb $0x0, (%rsp)
testq %r14, %r14
je 0x6d69
leaq 0x1dd59(%rip), %r15     # 0x24a9b
movq %r14, %r12
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x6d5f
movq %r15, %rsi
callq 0x41b0
testl %eax, %eax
jne 0x6dfa
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x6d45
testl %ebp, %ebp
jle 0x6d91
leaq 0x1c445(%rip), %r15     # 0x231b9
movl %ebp, %r12d
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x42b0
decl %r12d
jne 0x6d77
leaq 0x1e5e4(%rip), %rsi     # 0x2537c
movq %rsp, %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x41c0
movq 0x8(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x67bc
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4190
cmpl $0x0, 0x28(%r14)
jle 0x6dea
incl %ebp
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x6d10
incq %r15
movslq 0x28(%r14), %rax
cmpq %rax, %r15
jl 0x6dcc
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %r15
movq %r15, %rdi
callq 0x4110
movw $0x9, (%rsp,%rax)
movq 0x18(%r12), %rsi
movq %r15, %rdi
callq 0x4280
movl 0x20(%r12), %r12d
movq %r15, %rdi
callq 0x4110
addq %rsp, %rax
testl %r12d, %r12d
je 0x6e5a
cmpl $0x1, %r12d
je 0x6e48
cmpl $0x18, %r12d
jne 0x6e72
movups 0x1c386(%rip), %xmm0    # 0x231c6
movups %xmm0, (%rax)
jmp 0x6d69
movl $0x5d7463, 0x3(%rax)    # imm = 0x5D7463
movl $0x63665b20, (%rax)     # imm = 0x63665B20
jmp 0x6d69
movabsq $0x6c61626f6c675b20, %rcx # imm = 0x6C61626F6C675B20
movq %rcx, (%rax)
movw $0x5d, 0x8(%rax)
jmp 0x6d69
movabsq $0x5d6b636f6c625b20, %rcx # imm = 0x5D6B636F6C625B20
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
jmp 0x6d69
// File: /workspace/github_c_makefile_star2_O1/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 0x1c250(%rip), %rsi     # 0x230ee
movq %r14, %rdi
callq 0x42c0
testq %rax, %rax
je 0x6ec6
leaq 0x6(%rax), %rcx
movzbl (%rcx), %edx
cmpl $0x9, %edx
je 0x6ebc
cmpl $0x20, %edx
jne 0x6ec1
incq %rcx
jmp 0x6eaf
cmpl $0x7b, %edx
je 0x6f06
movslq %ebx, %rcx
testq %rcx, %rcx
jle 0x6f06
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movzbl (%rsi), %r8d
cmpl $0x7d, %r8d
je 0x6eeb
cmpl $0x7b, %r8d
jne 0x6eed
incl %edi
incl %edx
jmp 0x6eed
decl %edi
testl %edx, %edx
jle 0x6ef8
movb $0x20, (%rsi)
testl %edi, %edi
je 0x6f06
incq %rsi
movq %rsi, %r8
subq %rax, %r8
cmpq %rcx, %r8
jl 0x6ed5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x6fcd
movq %rbx, %r13
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax)
jle 0x6fc0
xorl %r12d, %r12d
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %rbp
testq %rbp, %rbp
je 0x6fb1
cmpl $0x1, (%rbp)
jne 0x6fab
cmpb $0x0, 0x23(%rbp)
jne 0x6fab
movq 0x10(%rbp), %rdi
callq 0xc229
movq %rax, %r14
movq %rax, %rdi
leaq 0x1c17b(%rip), %rsi     # 0x230ee
callq 0x42c0
testq %rax, %rax
je 0x6fab
movb $0x1, 0x23(%rbp)
movq %r14, %rdi
callq 0x7001
movq %r14, %rdi
callq 0x6e88
movq %r15, %rdi
leaq 0x1c15a(%rip), %rsi     # 0x230f5
movq %r14, %rdx
movq %r13, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x41c0
movq 0x38(%rbp), %rbp
jmp 0x6f4c
incq %r12
movq 0x8(%rbx), %rax
movslq (%rax), %rcx
cmpq %rcx, %r12
jl 0x6f44
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x6f38
cmpl $0x0, 0x28(%rbx)
jle 0x6ff2
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x6f0e
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x6fd6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1c1b4(%rip), %rsi     # 0x231c3
callq 0x42c0
testq %rax, %rax
je 0x7035
leaq 0x1c1a3(%rip), %r14     # 0x231c3
movw $0x2020, (%rax)         # imm = 0x2020
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42c0
testq %rax, %rax
jne 0x7020
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x722f
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)
cmpl $0x0, 0x28(%rdi)
jle 0x726d
xorl %r12d, %r12d
movq 0x30(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7227
incq %r12
movslq 0x28(%r15), %rax
cmpq %rax, %r12
jl 0x724f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7227
leaq 0x327d8(%rip), %rax     # 0x39a6c
testb $0x2, (%rax)
jne 0x72a1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x8(%r14), %esi
movq 0x10(%r14), %rax
movl 0x4(%rax), %edx
leaq 0x1bec1(%rip), %rdi     # 0x23174
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/symtab.c
// Function: new_symtab
symtab_t*
new_symtab(void)
{	symtab_t *that;

	if (freesymt)
	{	that = freesymt;
		freesymt = that->nxt;
		memset(that, 0, sizeof(symtab_t));
	} else
		that = (symtab_t *) e_malloc(sizeof(symtab_t));

	that->root = new_scopetab(NULL);
	that->clevel = EXTERN_SCOPE;
	that->current = that->root;

	return that;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x20, %edi
callq 0x6469
movq %rax, %rbx
movl $0x38, %edi
callq 0x6469
movq %rax, %r14
movl $0x4, 0x2c(%rax)
movl $0x20, %edi
callq 0x6469
movq %rax, 0x30(%r14)
movq $0x0, 0x10(%r14)
movl $0x1, %eax
movl %eax, 0x4(%r14)
movq %r14, (%rbx)
movl %eax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl 0x8(%rdi), %eax
movq 0x10(%rdi), %r14
cmpl 0x4(%r14), %eax
jle 0x736f
movq %rdi, %r15
movq %r14, %rdi
callq 0x690b
testq %rax, %rax
je 0x737f
movq %rax, %r14
movq 0x10(%r15), %rdi
movq %rax, %rsi
callq 0x7387
movq %r14, 0x10(%r15)
movl 0x8(%r15), %eax
cmpl 0x4(%r14), %eax
jg 0x7345
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6a52
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2c(%rdi), %edi
cmpl %edi, 0x28(%rbx)
jl 0x73cf
movq 0x30(%rbx), %r15
leal (%rdi,%rdi), %eax
movl %eax, 0x2c(%rbx)
shll $0x4, %edi
callq 0x6469
movq %rax, 0x30(%rbx)
movslq 0x28(%rbx), %rax
testq %rax, %rax
jle 0x73cf
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
movq 0x30(%rbx), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x73bb
movq 0x30(%rbx), %rax
movslq 0x28(%rbx), %rcx
movq %r14, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movl 0x8(%rdi), %eax
cmpl %edx, %eax
jl 0x742f
movq 0x10(%r14), %r15
cmpl 0x4(%r15), %eax
jle 0x742f
movq %r15, %rdi
callq 0x690b
testq %rax, %rax
je 0x7443
movq %rax, %r15
movq 0x10(%r14), %rdi
movq %rax, %rsi
callq 0x7387
movq %r15, 0x10(%r14)
movl 0x8(%r14), %eax
cmpl %ebp, %eax
jge 0x7401
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x7443
cmpl %ebp, 0x4(%rdi)
jle 0x7450
movq 0x10(%rdi), %rdi
jmp 0x7433
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6a52
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x32525(%rip), %r14     # 0x399d0
testq %r14, %r14
je 0x74c5
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x41b0
testl %eax, %eax
je 0x74e4
movq 0x8(%r14), %r14
jmp 0x74ab
movl $0x10, %edi
callq 0x6469
movq %rbx, (%rax)
movq 0x324f7(%rip), %rcx     # 0x399d0
movq %rcx, 0x8(%rax)
movq %rax, 0x324ec(%rip)     # 0x399d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x324d8(%rip), %r15     # 0x399d0
xorl %ebx, %ebx
testq %r15, %r15
je 0x7521
movq %rdi, %r14
movq (%r15), %rdi
movq %r14, %rsi
callq 0x41b0
testl %eax, %eax
je 0x751c
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x7502
jmp 0x7521
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x7577
leaq 0x1d557(%rip), %r15     # 0x24a9b
movq %r14, %r13
movq 0x18(%r13), %r12
testq %r12, %r12
je 0x756e
cmpl $0x1, 0x20(%r13)
jne 0x756e
movq %r12, %rdi
movq %r15, %rsi
callq 0x41b0
testl %eax, %eax
je 0x756e
movq %r12, %rdi
callq 0x749d
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x7547
cmpl $0x0, 0x28(%r14)
jle 0x759d
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x7529
incq %r15
movslq 0x28(%r14), %rax
cmpq %rax, %r15
jl 0x7581
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x18, %edi
callq 0x6469
movq %rax, %rbx
callq 0x72c4
movq %rax, (%rbx)
callq 0x72c4
movq %rax, 0x8(%rbx)
callq 0x72c4
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Modex/Src/symtab.c
// Function: exit_scope
void
exit_scope(context_t *that)
{
#ifdef  MORE_VERBOSE
	printf("	Exit Scope: %d\n", that->syms->clevel);
#endif
	st_exit_scope(that->labels);
	st_exit_scope(that->tags);
	st_exit_scope(that->syms);
}

// Assembly:
movq (%rdi), %rax
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x760b
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rdi), %rax
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x7629
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rdi), %rax
movl 0x8(%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rax), %rcx
cmpl %edx, 0x4(%rcx)
jl 0x7647
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x2, %esi
movl $0x1, %ebp
cmovgel %esi, %ebp
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rax
cmpl 0x4(%rax), %ebp
jge 0x767b
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x75ee
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
cmpl 0x4(%rax), %ebp
jl 0x7666
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x32345(%rip), %r15     # 0x399d8
testq %r15, %r15
je 0x76ad
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41b0
testl %eax, %eax
je 0x76f6
movq 0x18(%r15), %r15
jmp 0x7693
movl $0x20, %edi
callq 0x6469
movq %rax, %r15
movq %r14, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6469
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b0
movl $0x0, 0x8(%r15)
movl %ebx, 0xc(%r15)
movq 0x322ed(%rip), %rax     # 0x399d8
movq %rax, 0x18(%r15)
movq %r15, 0x322e2(%rip)     # 0x399d8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq 0x322d0(%rip), %r15     # 0x399d8
xorl %ebx, %ebx
testq %r15, %r15
je 0x7739
movq %rdi, %r14
movq (%r15), %rsi
movq %r14, %rdi
callq 0x41b0
testl %eax, %eax
je 0x772c
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x7712
jmp 0x7739
movl $0x1, 0x8(%r15)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x3228f(%rip)     # 0x399d8
je 0x77c5
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4190
movq 0x3226f(%rip), %r15     # 0x399d8
testq %r15, %r15
je 0x77ae
movl $0x1, %ecx
leaq 0x1ba0f(%rip), %r14     # 0x23189
cmpl $0x0, 0x10(%r15)
jne 0x77a5
movl $0x1, 0x10(%r15)
cmpl $0x0, 0xc(%r15)
je 0x77a5
movq (%r15), %rdx
leal 0x1(%rcx), %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x41c0
movl %ebp, %ecx
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x777a
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4190
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x3220c(%rip), %r14     # 0x399e0
testq %r14, %r14
je 0x77ee
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x41b0
testl %eax, %eax
je 0x7833
movq 0x18(%r14), %r14
jmp 0x77d4
movl $0x20, %edi
callq 0x6469
movq %rax, %r14
movq %rbx, %rdi
callq 0x4110
leal 0x1(%rax), %edi
callq 0x6469
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movl $0x0, 0x8(%r14)
movq 0x321b8(%rip), %rax     # 0x399e0
movq %rax, 0x18(%r14)
movq %r14, 0x321ad(%rip)     # 0x399e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq