LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: string_merge
static void
string_merge(TS *from)	/* merge subsequent strings */
{	char *s;
	TS *n;

	for (n = from; n; n = n->nxt)
		if (n->tok == NAME
		&&  n->name[0] == '"'
		&&  n->nxt
		&&  n->nxt->tok == NAME
		&&  n->nxt->name[0] == '"')
		{	s = emalloc(strlen(n->name)+strlen(n->nxt->name)+1);
			strncpy(s, n->name, strlen(n->name)-1);
			strncat(s, &n->nxt->name[1], strlen(n->nxt->name)-1);
			n->name = s;
			n->nxt = n->nxt->nxt;
			if (n->nxt && n->nxt->nxt) n->nxt->nxt->prv = n;
			if (n->prv) n = n->prv; else n = from;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x52cd
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x52ba
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x52ba
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x52ba
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x1, (%rax)
jne 0x52ba
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x52ba
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4080
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4080
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movl %eax, %edi
callq 0x4320
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4080
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
subq $0x1, %rdx
callq 0x4040
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4080
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
subq $0x1, %rdx
callq 0x40e0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x5297
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x5297
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x52b0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x52b8
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x52ba
jmp 0x52bc
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5134
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: preconfigure
void
preconfigure(void)
{	int i;

	for (i = 0; cnfm[i] != NULL; i++)
	{	strcpy(ibuf, cnfm[i]);
		preprocess();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xeee6(%rip), %rax      # 0x141e0
cmpq $0x0, (%rax,%rcx,8)
je 0x532c
movslq -0x4(%rbp), %rcx
leaq 0xeed4(%rip), %rax      # 0x141e0
movq (%rax,%rcx,8), %rsi
leaq 0x12269(%rip), %rdi     # 0x17580
callq 0x4060
callq 0x4a80
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x52ef
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: add_def
static void
add_def(char *s)	/* e.g., NAME or NAME=... */
{	char *p, *z;

	z = emalloc(strlen(s)+1);
	strcpy(z, s);

	if ((p = strchr(z, '=')) != NULL)
	{	*p = '\0';
		newmacro(z);
		*p++ = '=';
		white = 0;
		if (isdigit(*p))
			addbody(VAL, atoi(p));
		else
		{	addbody(NAME, 0);
			cb->name = p;
		}
	} else
		newmacro(z);

	closemacro();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4080
addq $0x1, %rax
movl %eax, %edi
callq 0x4320
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4060
movq -0x18(%rbp), %rdi
movl $0x3d, %esi
callq 0x4090
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x572d
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x7250
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x3d, (%rax)
movl $0x0, 0xf8bf(%rip)      # 0x14f98
callq 0x41a0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x5710
movq -0x10(%rbp), %rdi
callq 0x4150
movl %eax, %esi
movl $0x4, %edi
callq 0x74b0
jmp 0x572b
movl $0x1, %edi
xorl %esi, %esi
callq 0x74b0
movq -0x10(%rbp), %rcx
movq 0x10d09(%rip), %rax     # 0x16430
movq %rcx, 0x8(%rax)
jmp 0x5736
movq -0x18(%rbp), %rdi
callq 0x7250
callq 0x7750
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: rm_def
static void
rm_def(char *s)
{	MD *m, *lm = (MD *) 0;

	for (m = md; m; lm = m, m = m->nxt)
		if (strcmp(m->nm, s) == 0)
			break;
	if (m)
	{	if (!lm)
			md = m->nxt;
		else
			lm->nxt = m->nxt;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x10cad(%rip), %rax     # 0x16418
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x57a5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4100
cmpl $0x0, %eax
jne 0x578d
jmp 0x57a5
jmp 0x578f
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x576f
cmpq $0x0, -0x10(%rbp)
je 0x57d6
cmpq $0x0, -0x18(%rbp)
jne 0x57c4
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x10c56(%rip)     # 0x16418
jmp 0x57d4
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x57d6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: tokfull
static void
tokfull(TS *n, FILE *fd)
{
	tokname(n->tok, fd);
	switch (n->tok) {
	case NAME: fprintf(fd, " <%s> ", n->name); break;
	case CHAR: fprintf(fd, " <%c> ", n->val); break;
	case ECHAR: fprintf(fd, " <\\%c> ", n->val); break;
	case VAL: fprintf(fd, " <%d> ", n->val); break;
	default: fprintf(fd, " <?> "); break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
callq 0x4370
movq -0x8(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x5897
movq -0x18(%rbp), %rax
leaq 0x79bb(%rip), %rcx      # 0xd1dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xb292(%rip), %rsi      # 0x10acf
movb $0x0, %al
callq 0x4110
jmp 0x58a9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0xb27e(%rip), %rsi      # 0x10ad6
movb $0x0, %al
callq 0x4110
jmp 0x58a9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0xb26a(%rip), %rsi      # 0x10add
movb $0x0, %al
callq 0x4110
jmp 0x58a9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0xb257(%rip), %rsi      # 0x10ae5
movb $0x0, %al
callq 0x4110
jmp 0x58a9
movq -0x10(%rbp), %rdi
leaq 0xb24a(%rip), %rsi      # 0x10aec
movb $0x0, %al
callq 0x4110
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: release_ml
static void
release_ml(ML *m)
{
	if (!m) return;
	release_ml(m->nxt);
	m->nxt = free_ml;
	free_ml = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x58c5
jmp 0x58ec
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x58b0
movq 0x10b2f(%rip), %rcx     # 0x16408
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x10b1c(%rip)     # 0x16408
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: new_inl
static TS *
new_inl(Tokvals t)
{	TS *n;

	if (free_ts)
	{	n = free_ts;
		free_ts = free_ts->nxt;
		memset(n, 0, sizeof(TS));
	} else
		n = (TS *) emalloc(sizeof(TS));
	n->tok = t;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpq $0x0, 0x1053d(%rip)     # 0x16400
je 0x5ef4
movq 0x10534(%rip), %rax     # 0x16400
movq %rax, -0x10(%rbp)
movq 0x10529(%rip), %rax     # 0x16400
movq 0x28(%rax), %rax
movq %rax, 0x1051e(%rip)     # 0x16400
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x40d0
jmp 0x5f02
movl $0x30, %edi
callq 0x4320
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: find_delimiter
static char *
find_delimiter(char *d, char *t)
{	char *p, *q, *r, *s;

zz:	p = strstr(t, d);
	if (!p) return NULL;

	s = t;
yy:	q = strchr(s, '"');

	if (q && q <= p)	/* in string */
	{	/* real string delimiter? */
		if (strncmp(q-1, "'\"'", 3) == 0
		||  strncmp(q-2, "'\\\"'", 4) == 0)
		{	s = q+2;
			goto yy; /* no, try again */
		}
		q++;	/* presumably real string */
xx:		r = strchr(q, '"');	/* find closing quote */
		if (!r) fatal_error("unterminated string");

		if (*(r-1) == '\\') { q++; goto xx; }

		if (r < p)	/* string ends before comment starts */
		{	s = r+1;
			goto yy; /* find another */
		} else	/* yes we're in a string */
		{	t = r;	/* find another delimiter */
			goto zz;
	}	}

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4190
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5f55
movq $0x0, -0x8(%rbp)
jmp 0x604e
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl $0x22, %esi
callq 0x4090
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6046
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x6046
movq -0x28(%rbp), %rdi
addq $-0x1, %rdi
leaq 0xab76(%rip), %rsi      # 0x10b0d
movl $0x3, %edx
callq 0x4050
cmpl $0x0, %eax
je 0x5fc4
movq -0x28(%rbp), %rdi
addq $-0x2, %rdi
leaq 0xab5c(%rip), %rsi      # 0x10b11
movl $0x4, %edx
callq 0x4050
cmpl $0x0, %eax
jne 0x5fd2
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
jmp 0x5f5d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x22, %esi
callq 0x4090
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6003
leaq 0xab18(%rip), %rdi      # 0x10b16
callq 0x42b0
movq -0x30(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x5c, %eax
jne 0x601e
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5fde
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x6039
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x5f5d
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x5f30
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: nested_comment_check
static void
nested_comment_check(char *t, char *r)
{	int c = 0;

	if (!misra_rules) return;

	if (r != NULL)
	{	c = *r;
		*r = '\0';
	}
	if (strstr(t, "/*"))
		m_rule(2, 3, "nested /* comment");

	if (r != NULL)
		*r = c;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, 0xef16(%rip)      # 0x14f94
jne 0x6082
jmp 0x60d8
cmpq $0x0, -0x10(%rbp)
je 0x609a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
leaq 0xaa62(%rip), %rsi      # 0x10b07
callq 0x4190
cmpq $0x0, %rax
je 0x60c6
movl $0x2, %edi
movl $0x3, %esi
leaq 0xaa69(%rip), %rdx      # 0x10b2a
callq 0xca50
cmpq $0x0, -0x10(%rbp)
je 0x60d8
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: lookfor
static void
lookfor(char c)
{
	for ( ; *nowc != c; nowc++)
	{	if (*nowc == '\0')
		{	if (!not_printing[level])
			fprintf(stderr, "%s,%d: unterminated string\n",
				filename, lineno);
			nowc--;
			break;
		}
		if (*nowc == '\\')
			nowc++;
	}
	nowc++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq 0xec6b(%rip), %rax      # 0x14fa0
movsbl (%rax), %eax
movsbl -0x1(%rbp), %ecx
cmpl %ecx, %eax
je 0x63da
movq 0xec55(%rip), %rax      # 0x14fa0
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x63a0
movslq 0xfc5a(%rip), %rcx      # 0x15fb4
leaq 0xfc5f(%rip), %rax      # 0x15fc0
cmpl $0x0, (%rax,%rcx,4)
jne 0x638c
movq 0xdc8a(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq 0xdd78(%rip), %rdx      # 0x140f0
movl 0xec12(%rip), %ecx      # 0x14f90
leaq 0xa7c3(%rip), %rsi      # 0x10b48
movb $0x0, %al
callq 0x4110
movq 0xec0d(%rip), %rax      # 0x14fa0
addq $-0x1, %rax
movq %rax, 0xec02(%rip)      # 0x14fa0
jmp 0x63da
movq 0xebf9(%rip), %rax      # 0x14fa0
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x63c1
movq 0xebea(%rip), %rax      # 0x14fa0
addq $0x1, %rax
movq %rax, 0xebdf(%rip)      # 0x14fa0
jmp 0x63c3
movq 0xebd6(%rip), %rax      # 0x14fa0
addq $0x1, %rax
movq %rax, 0xebcb(%rip)      # 0x14fa0
jmp 0x632e
movq 0xebbf(%rip), %rax      # 0x14fa0
addq $0x1, %rax
movq %rax, 0xebb4(%rip)      # 0x14fa0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: rule_check
static void
rule_check(void)
{
	if (!misra_rules) return;

	if (*nowc == '0' && isdigit(*(nowc+1)))
		m_rule(7, 1, "octal constant or escape sequence");

	if (*nowc != '\\') return;

	switch (*(nowc+1)) {
	case '0': break;
	case '1': case '2':
	case '3': case '4': case '5':
	case '6': case '7': /* not 8 or 9 */
		m_rule(7, 1, "octal constant or escape sequence");
		break;

	case '\"': case '\\': case '\'':
	case 'a': case 'b': case 'f': case 'n':
	case 'r': case 't': case 'v':
	case 'x': case 'X': /* followed by a hexadecimal nr */
		/* these are valid escape sequences */
		break;

	default:
		m_rule(4, 1, "undefined escape sequence");
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0xeb85(%rip)      # 0x14f94
jne 0x6416
jmp 0x64cf
movq 0xeb83(%rip), %rax      # 0x14fa0
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x645f
callq 0x41a0
movq (%rax), %rax
movq 0xeb6c(%rip), %rcx      # 0x14fa0
movsbl 0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x645f
movl $0x7, %edi
movl $0x1, %esi
leaq 0xa70a(%rip), %rdx      # 0x10b64
callq 0xca50
movq 0xeb3a(%rip), %rax      # 0x14fa0
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x6470
jmp 0x64cf
movq 0xeb29(%rip), %rax      # 0x14fa0
movsbl 0x1(%rax), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x8(%rbp)
subl $0x56, %eax
ja 0x64b9
movq -0x8(%rbp), %rax
leaq 0x6d58(%rip), %rcx      # 0xd1ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x64cf
movl $0x7, %edi
movl $0x1, %esi
leaq 0xa6b4(%rip), %rdx      # 0x10b64
callq 0xca50
jmp 0x64cf
jmp 0x64cf
movl $0x4, %edi
movl $0x1, %esi
leaq 0xa6bc(%rip), %rdx      # 0x10b86
callq 0xca50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: digraphs
static void
digraphs(void)
{
	switch (mychar) {
	case '<':
		switch (*nowc) {
		case ':': nowc++; mychar = '['; break;
		case '%': nowc++; mychar = '{'; break;
		default:  break;
		}
		break;
	case ':':
		if (*nowc == '>') { nowc++; mychar = ']'; break; }
		break;
	case '%':
		switch (*nowc) {
		case '>': nowc++; mychar = '}'; break;
		case ':': nowc++; mychar = '#'; break;
		default: break;
		} /* fall thru */
	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsbl 0xfef9(%rip), %eax      # 0x163e4
movl %eax, -0x4(%rbp)
subl $0x25, %eax
je 0x6598
jmp 0x64f9
movl -0x4(%rbp), %eax
subl $0x3a, %eax
je 0x656c
jmp 0x6503
movl -0x4(%rbp), %eax
subl $0x3c, %eax
jne 0x65f0
jmp 0x6511
movq 0xea88(%rip), %rax      # 0x14fa0
movsbl (%rax), %eax
movl %eax, -0x8(%rbp)
subl $0x25, %eax
je 0x654a
jmp 0x6525
movl -0x8(%rbp), %eax
subl $0x3a, %eax
jne 0x6565
jmp 0x652f
movq 0xea6a(%rip), %rax      # 0x14fa0
addq $0x1, %rax
movq %rax, 0xea5f(%rip)      # 0x14fa0
movb $0x5b, 0xfe9c(%rip)     # 0x163e4
jmp 0x6567
movq 0xea4f(%rip), %rax      # 0x14fa0
addq $0x1, %rax
movq %rax, 0xea44(%rip)      # 0x14fa0
movb $0x7b, 0xfe81(%rip)     # 0x163e4
jmp 0x6567
jmp 0x6567
jmp 0x65f2
movq 0xea2d(%rip), %rax      # 0x14fa0
movsbl (%rax), %eax
cmpl $0x3e, %eax
jne 0x6596
movq 0xea1e(%rip), %rax      # 0x14fa0
addq $0x1, %rax
movq %rax, 0xea13(%rip)      # 0x14fa0
movb $0x5d, 0xfe50(%rip)     # 0x163e4
jmp 0x65f2
jmp 0x65f2
movq 0xea01(%rip), %rax      # 0x14fa0
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x3a, %eax
je 0x65d1
jmp 0x65ac
movl -0xc(%rbp), %eax
subl $0x3e, %eax
jne 0x65ec
jmp 0x65b6
movq 0xe9e3(%rip), %rax      # 0x14fa0
addq $0x1, %rax
movq %rax, 0xe9d8(%rip)      # 0x14fa0
movb $0x7d, 0xfe15(%rip)     # 0x163e4
jmp 0x65ee
movq 0xe9c8(%rip), %rax      # 0x14fa0
addq $0x1, %rax
movq %rax, 0xe9bd(%rip)      # 0x14fa0
movb $0x23, 0xfdfa(%rip)     # 0x163e4
jmp 0x65ee
jmp 0x65ee
jmp 0x65f0
jmp 0x65f2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: trigraphs
static void
trigraphs(void)
{
	if (mychar != '?' || *nowc != '?') return;

	switch (*(nowc+1)) {
	case '=':  nowc += 2; mychar = '#'; break;
	case '(':  nowc += 2; mychar = '['; break;
	case ')':  nowc += 2; mychar = ']'; break;
	case '<':  nowc += 2; mychar = '{'; break;
	case '>':  nowc += 2; mychar = '}'; break;
	case '/':  nowc += 2; mychar = '\\'; break;
	case '\'': nowc += 2; mychar = '^'; break;
	case '!':  nowc += 2; mychar = '|'; break;
	case '-':  nowc += 2; mychar = '~'; break;
	default:   return;
	}

	if (misra_rules) m_rule(4, 2, "trigraph");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsbl 0xfdd5(%rip), %eax      # 0x163e4
cmpl $0x3f, %eax
jne 0x6623
movq 0xe985(%rip), %rax      # 0x14fa0
movsbl (%rax), %eax
cmpl $0x3f, %eax
je 0x6628
jmp 0x6779
movq 0xe971(%rip), %rax      # 0x14fa0
movsbl 0x1(%rax), %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x8(%rbp)
subl $0x1d, %eax
ja 0x6758
movq -0x8(%rbp), %rax
leaq 0x6cf8(%rip), %rcx      # 0xd348
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xe940(%rip), %rax      # 0x14fa0
addq $0x2, %rax
movq %rax, 0xe935(%rip)      # 0x14fa0
movb $0x23, 0xfd72(%rip)     # 0x163e4
jmp 0x675a
movq 0xe922(%rip), %rax      # 0x14fa0
addq $0x2, %rax
movq %rax, 0xe917(%rip)      # 0x14fa0
movb $0x5b, 0xfd54(%rip)     # 0x163e4
jmp 0x675a
movq 0xe904(%rip), %rax      # 0x14fa0
addq $0x2, %rax
movq %rax, 0xe8f9(%rip)      # 0x14fa0
movb $0x5d, 0xfd36(%rip)     # 0x163e4
jmp 0x675a
movq 0xe8e6(%rip), %rax      # 0x14fa0
addq $0x2, %rax
movq %rax, 0xe8db(%rip)      # 0x14fa0
movb $0x7b, 0xfd18(%rip)     # 0x163e4
jmp 0x675a
movq 0xe8c8(%rip), %rax      # 0x14fa0
addq $0x2, %rax
movq %rax, 0xe8bd(%rip)      # 0x14fa0
movb $0x7d, 0xfcfa(%rip)     # 0x163e4
jmp 0x675a
movq 0xe8ad(%rip), %rax      # 0x14fa0
addq $0x2, %rax
movq %rax, 0xe8a2(%rip)      # 0x14fa0
movb $0x5c, 0xfcdf(%rip)     # 0x163e4
jmp 0x675a
movq 0xe892(%rip), %rax      # 0x14fa0
addq $0x2, %rax
movq %rax, 0xe887(%rip)      # 0x14fa0
movb $0x5e, 0xfcc4(%rip)     # 0x163e4
jmp 0x675a
movq 0xe877(%rip), %rax      # 0x14fa0
addq $0x2, %rax
movq %rax, 0xe86c(%rip)      # 0x14fa0
movb $0x7c, 0xfca9(%rip)     # 0x163e4
jmp 0x675a
movq 0xe85c(%rip), %rax      # 0x14fa0
addq $0x2, %rax
movq %rax, 0xe851(%rip)      # 0x14fa0
movb $0x7e, 0xfc8e(%rip)     # 0x163e4
jmp 0x675a
jmp 0x6779
cmpl $0x0, 0xe833(%rip)      # 0x14f94
je 0x6779
movl $0x4, %edi
movl $0x2, %esi
leaq 0xa42c(%rip), %rdx      # 0x10ba0
callq 0xca50
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: one_directive
static int
one_directive(TS *d)
{	int i;

	if (!d) return 1;

	switch (d->tok) {
	case VAL:		/* e.g.: # 12 "filename.c" */
		do_lineno(d);
		return 1;
	case NAME:
		for (i = 0; table[i].nm; i++)
			if (strcmp(d->name, table[i].nm) == 0)
			{	if (!not_printing[level]
				||  i >= 8)
					table[i].fct(d->nxt);
				else if (i < 3)
					not_printing[++level] = 3;
				return i+2; /* distinct from 1, 0, -1 */
			}
		if (strcmp(d->name, "include") == 0)
		{	if (misra_rules && !no_includes)
				m_rule(19, 3, "#include needing preprocessing");
			return -1;
		}
		break;
	default:
		break;
	}

	fprintf(stderr, "%s,%d: warning: unrecognized directive '#%s'\n",
		filename, lineno, d->name);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x679f
movl $0x1, -0x4(%rbp)
jmp 0x6920
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x67d2
jmp 0x67af
movl -0x18(%rbp), %eax
subl $0x4, %eax
jne 0x68ea
jmp 0x67bd
movq -0x10(%rbp), %rdi
callq 0x6930
movl $0x1, -0x4(%rbp)
jmp 0x6920
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xe6cc(%rip), %rax      # 0x14eb0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x689e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xe6a8(%rip), %rax      # 0x14eb0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x4100
cmpl $0x0, %eax
jne 0x688e
movslq 0xf791(%rip), %rcx      # 0x15fb4
leaq 0xf796(%rip), %rax      # 0x15fc0
cmpl $0x0, (%rax,%rcx,4)
je 0x6836
cmpl $0x8, -0x14(%rbp)
jl 0x6858
movslq -0x14(%rbp), %rcx
leaq 0xe66f(%rip), %rax      # 0x14eb0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
callq *%rax
jmp 0x6880
cmpl $0x3, -0x14(%rbp)
jge 0x687e
movl 0xf750(%rip), %eax      # 0x15fb4
addl $0x1, %eax
movl %eax, 0xf747(%rip)      # 0x15fb4
movslq %eax, %rcx
leaq 0xf749(%rip), %rax      # 0x15fc0
movl $0x3, (%rax,%rcx,4)
jmp 0x6880
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0x6920
jmp 0x6890
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x67d9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xac76(%rip), %rsi      # 0x11523
callq 0x4100
cmpl $0x0, %eax
jne 0x68e8
cmpl $0x0, 0xe6d6(%rip)      # 0x14f94
je 0x68df
cmpl $0x0, 0xfb11(%rip)      # 0x163d8
jne 0x68df
movl $0x13, %edi
movl $0x3, %esi
leaq 0xa2cf(%rip), %rdx      # 0x10ba9
callq 0xca50
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6920
jmp 0x68ec
jmp 0x68ec
movq 0xd705(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq 0xd7f3(%rip), %rdx      # 0x140f0
movl 0xe68d(%rip), %ecx      # 0x14f90
movq -0x10(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0xa2b6(%rip), %rsi      # 0x10bc8
movb $0x0, %al
callq 0x4110
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: do_lineno
static void
do_lineno(TS *d)
{
	if (d->tok != VAL)
	{
bad:		fprintf(stderr, "%s,%d: warning: malformed directive %s",
			filename, lineno, ibuf);
		return;
	}
	lineno = d->val;

	d = d->nxt;
	if (!d || d->tok != CHAR || d->val != '\"')
		return;	/* no filename */

	d = d->nxt;
	if (!d || d->tok != NAME)
		goto bad;

	filename = d->name;

	d = d->nxt;
	if (!d || d->tok != CHAR || d->val != '\"')
		goto bad;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
je 0x6978
jmp 0x6947
movq 0xd6aa(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq 0xd798(%rip), %rdx      # 0x140f0
movl 0xe632(%rip), %ecx      # 0x14f90
leaq 0xa291(%rip), %rsi      # 0x10bf6
leaq 0x10c14(%rip), %r8      # 0x17580
movb $0x0, %al
callq 0x4110
jmp 0x6a08
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xe60b(%rip)      # 0x14f90
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x69ab
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x69ab
movq -0x8(%rbp), %rax
cmpl $0x22, 0x4(%rax)
je 0x69ad
jmp 0x6a08
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x69c9
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0x69ce
jmp 0x6947
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xd713(%rip)      # 0x140f0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6a03
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6a03
movq -0x8(%rbp), %rax
cmpl $0x22, 0x4(%rax)
je 0x6a08
jmp 0x6947
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: do_ifdef
static void
do_ifdef(TS *s)
{	MD *m;

	if (s->tok != NAME)
		fatal_error("expecting name after #ifdef or #ifndef");
		
	if (level >= 255) 
		fatal_error("ifdefs nested too deep");

	m = is_macro(s->name);
	add_tag(s, m);

	not_printing[++level] = (m == NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0x6c71
leaq 0xa05a(%rip), %rdi      # 0x10cc6
callq 0x42b0
cmpl $0xff, 0xf339(%rip)     # 0x15fb4
jl 0x6c89
leaq 0xa069(%rip), %rdi      # 0x10ced
callq 0x42b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7130
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7190
cmpq $0x0, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movl 0xf2fa(%rip), %eax      # 0x15fb4
addl $0x1, %eax
movl %eax, 0xf2f1(%rip)      # 0x15fb4
movslq %eax, %rcx
leaq 0xf2f3(%rip), %rax      # 0x15fc0
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: do_undef
static void
do_undef(TS *s)
{
	if (s->tok != NAME)
		fatal_error("expect name after #undef");

	if (misra_rules
	&&  BlockDepth > 0)
		m_rule(19, 5, "#undef within block scope");

	if (misra_rules)
		m_rule(19, 6, "#undef");

	rm_def(s->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0x6fb1
leaq 0x9ef8(%rip), %rdi      # 0x10ea4
callq 0x42b0
cmpl $0x0, 0xdfdc(%rip)      # 0x14f94
je 0x6fd9
cmpl $0x0, 0xf44f(%rip)      # 0x16410
jle 0x6fd9
movl $0x13, %edi
movl $0x5, %esi
leaq 0x9ee9(%rip), %rdx      # 0x10ebd
callq 0xca50
cmpl $0x0, 0xdfb4(%rip)      # 0x14f94
je 0x6ff8
movl $0x13, %edi
movl $0x6, %esi
leaq 0x9ec3(%rip), %rdx      # 0x10eb6
callq 0xca50
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5750
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: is_macro
static MD *
is_macro(char *s)
{	MD *m;

	for (m = md; m; m = m->nxt)
		if (strcmp(m->nm, s) == 0)
			return m;

	return (MD *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xf2d5(%rip), %rax      # 0x16418
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x717d
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4100
cmpl $0x0, %eax
jne 0x716d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7185
jmp 0x716f
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7147
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: add_tag
static void
add_tag(TS *ni, MD *m)
{	ML *ml;

	for (ml = ni->ml; ml; ml = ml->nxt)
		if (ml->m == m)
			return;

	if (free_ml)
	{	ml = free_ml;
		free_ml = free_ml->nxt;
		memset(ml, 0, sizeof(ML));
	} else
		ml = (ML *) emalloc(sizeof(ML));
	ml->m = m;
	ml->nxt = ni->ml;
	ni->ml = ml;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x71d2
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x71c2
jmp 0x7240
jmp 0x71c4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x71ac
cmpq $0x0, 0xf22e(%rip)      # 0x16408
je 0x720b
movq 0xf225(%rip), %rax      # 0x16408
movq %rax, -0x18(%rbp)
movq 0xf21a(%rip), %rax      # 0x16408
movq 0x8(%rax), %rax
movq %rax, 0xf20f(%rip)      # 0x16408
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x40d0
jmp 0x7219
movl $0x10, %edi
callq 0x4320
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: newmacro
static void
newmacro(char *s)
{	MD *m;

	m = (MD *) emalloc(sizeof(MD));
	m->nm = emalloc(strlen(s)+1);
	strcpy(m->nm, s);
	m->ln = lineno;
	m->fnm = emalloc(strlen(filename)+1);
	strcpy(m->fnm, filename);
	m->nxt = md;
	md = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x30, %edi
callq 0x4320
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4080
addq $0x1, %rax
movl %eax, %edi
callq 0x4320
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4060
movl 0xdcf2(%rip), %ecx      # 0x14f90
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0xce44(%rip), %rdi      # 0x140f0
callq 0x4080
addq $0x1, %rax
movl %eax, %edi
callq 0x4320
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0xce1a(%rip), %rsi      # 0x140f0
callq 0x4060
movq 0xf136(%rip), %rcx      # 0x16418
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xf123(%rip)      # 0x16418
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: do_params
static TS *
do_params(TS *s)
{
	if (!s) fatal_error("syntax of #define");

	if (s->tok == CHAR
	&&  s->val == ')')	/* empty param list */
		s = s->nxt;
	else
	for ( ; ; s = s->nxt)
	{
		if (s->tok != NAME)
			fatal_error("expected param name");

		ca = add_arg(s->name, ca);
		if (!sfa) sfa = ca;

		s = s->nxt;

		if (!s || s->tok != CHAR)
			fatal_error("bad syntax of #define");

		if (s->val == ')')
		{	s = s->nxt;
			break;
		}

		if (s->val != ',')
			fatal_error("bad syntax of #define");
	}

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x731f
leaq 0x9a65(%rip), %rdi      # 0x10d7f
callq 0x42b0
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x7343
movq -0x8(%rbp), %rax
cmpl $0x29, 0x4(%rax)
jne 0x7343
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x73f8
jmp 0x7345
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0x735a
leaq 0x9a12(%rip), %rdi      # 0x10d67
callq 0x42b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0xf0bf(%rip), %rsi      # 0x16428
callq 0x7960
movq %rax, 0xf0b3(%rip)      # 0x16428
cmpq $0x0, 0xf0a3(%rip)      # 0x16420
jne 0x738d
movq 0xf0a2(%rip), %rax      # 0x16428
movq %rax, 0xf093(%rip)      # 0x16420
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x73a9
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
je 0x73b5
leaq 0x99cb(%rip), %rdi      # 0x10d7b
callq 0x42b0
movq -0x8(%rbp), %rax
cmpl $0x29, 0x4(%rax)
jne 0x73cd
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x73f6
movq -0x8(%rbp), %rax
cmpl $0x2c, 0x4(%rax)
je 0x73e3
leaq 0x999d(%rip), %rdi      # 0x10d7b
callq 0x42b0
jmp 0x73e5
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7345
jmp 0x73f8
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: scan_args
static int
scan_args(char *s)
{	ARGS *an;
	int i;

	for (i = 0, an = ca; an; i++, an = an->nxt)
		if (strcmp(s, an->nm) == 0
		|| (strcmp(s, "__VA_ARGS__") == 0
		&&  strcmp(an->nm, "...") == 0))
			return i;

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq 0xeffe(%rip), %rax      # 0x16428
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7498
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x4100
cmpl $0x0, %eax
je 0x7477
movq -0x10(%rbp), %rdi
leaq 0x993c(%rip), %rsi      # 0x10d91
callq 0x4100
cmpl $0x0, %eax
jne 0x747f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x96cf(%rip), %rsi      # 0x10b3c
callq 0x4100
cmpl $0x0, %eax
jne 0x747f
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x749f
jmp 0x7481
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x742e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: addbody
static void
addbody(Tokvals tok, int v)
{	TS *b;

	b = new_inl(tok);
	b->space = white;
	b->val = v;
	b->nxt = cb;
	if (cb) cb->prv = b;
	cb = b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0x5eb0
movq %rax, -0x10(%rbp)
movl 0xdac8(%rip), %ecx      # 0x14f98
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq 0xef48(%rip), %rcx      # 0x16430
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, 0xef38(%rip)      # 0x16430
je 0x7509
movq -0x10(%rbp), %rcx
movq 0xef2b(%rip), %rax      # 0x16430
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xef1c(%rip)      # 0x16430
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: not_braced
static int
not_braced(TS *s)	/* formal param, not in parentheses */
{
	/* param is
	 * not preceded by #
	 * not preceded or followed by ##
	 */

	if (!s->prv
	||  !s->nxt
	||   s->prv->tok != CHAR
	||  (s->prv->val != '(' && s->prv->val != '#')
	||   s->nxt->tok != CHAR
	||  (s->nxt->val != ')' &&
	    (s->nxt->val != '#'
	 || !s->nxt->nxt
	 || s->nxt->nxt->tok != CHAR
	 || s->nxt->nxt->val != '#')))
		return 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x75ca
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x75ca
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x2, (%rax)
jne 0x75ca
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x28, 0x4(%rax)
je 0x756f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x23, 0x4(%rax)
jne 0x75ca
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x2, (%rax)
jne 0x75ca
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x29, 0x4(%rax)
je 0x75d3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x23, 0x4(%rax)
jne 0x75ca
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x75ca
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
cmpl $0x2, (%rax)
jne 0x75ca
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
cmpl $0x23, 0x4(%rax)
je 0x75d3
movl $0x1, -0x4(%rbp)
jmp 0x75da
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: do_stringarg
static void
do_stringarg(TS *s, int w)
{	int i;

	if (!s)
	{	addbody(CHAR, '#');
		return;
	}
	white = w;
	switch (s->tok) {
	case NAME:
		i = scan_args(s->name);
		addbody(i >= 0 ? ARGSTRING: PLAINSTRING, 0);
		cb->name = s->name;
		cb->val = (i >= 0)? i : 0;
		break;
	case VAL: /* was not a string arg */
		addbody(CHAR, '#');
		white = 0;
		addbody(VAL, s->val);
		break;
	case ECHAR:
		addbody(CHAR, '#');
		white = 0;
		addbody(ECHAR, s->val);
		break;
	case CHAR:
		addbody(CHAR, '#');
		white = s->space;
		addbody(CHAR, s->val);
		break;
	default:
		fatal_error("cannot happen");
		break;
	}
	white = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x760a
movl $0x2, %edi
movl $0x23, %esi
callq 0x74b0
jmp 0x773f
movl -0xc(%rbp), %eax
movl %eax, 0xd985(%rip)      # 0x14f98
movq -0x8(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x7729
movq -0x18(%rbp), %rax
leaq 0x5d9b(%rip), %rcx      # 0xd3d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7410
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x7, %edi
movl $0x6, %eax
cmpl $0x0, %ecx
cmovgel %eax, %edi
xorl %esi, %esi
callq 0x74b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0xedb9(%rip), %rax      # 0x16430
movq %rcx, 0x8(%rax)
cmpl $0x0, -0x10(%rbp)
jl 0x7689
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x7690
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7690
movl -0x1c(%rbp), %ecx
movq 0xed96(%rip), %rax      # 0x16430
movl %ecx, 0x4(%rax)
jmp 0x7735
movl $0x2, %edi
movl $0x23, %esi
callq 0x74b0
movl $0x0, 0xd8dd(%rip)      # 0x14f98
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
movl $0x4, %edi
callq 0x74b0
jmp 0x7735
movl $0x2, %edi
movl $0x23, %esi
callq 0x74b0
movl $0x0, 0xd8b1(%rip)      # 0x14f98
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
movl $0x3, %edi
callq 0x74b0
jmp 0x7735
movl $0x2, %edi
movl $0x23, %esi
callq 0x74b0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, 0xd882(%rip)      # 0x14f98
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
movl $0x2, %edi
callq 0x74b0
jmp 0x7735
leaq 0x9629(%rip), %rdi      # 0x10d59
callq 0x42b0
movl $0x0, 0xd859(%rip)      # 0x14f98
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: add_arg
static ARGS *
add_arg(char *s, ARGS *p)
{	ARGS *a = (ARGS *) emalloc(sizeof(ARGS));

	a->nm = emalloc(strlen(s)+1);
	strcpy(a->nm, s);
	if (p) p->nxt = a;
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x4320
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4080
addq $0x1, %rax
movl %eax, %edi
callq 0x4320
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4060
cmpq $0x0, -0x10(%rbp)
je 0x79bf
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: conflict
static void
conflict(MD *m1, MD *m2)
{	TS *b1, *b2;

	for (b1 = m1->body, b2 = m2->body; b1 && b2; b1 = b1->nxt, b2 = b2->nxt)
	{	if (b1->tok != b2->tok
		|| (b1->name && b2->name && strcmp(b1->name, b2->name) != 0)
		||  b1->val != b2->val)
		{	fprintf(stderr, "%s,%d: warning: macro %s redefined\n",
				filename, lineno, m1->nm);
			fprintf(stderr, "	previous definition: %s,%d\n",
				m1->fnm, m1->ln);
			return;
	}	}

	md = md->nxt;	/* remove new def, same as old */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x7a0f
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x7a1b
jmp 0x7add
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x7a69
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7a59
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7a59
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4100
cmpl $0x0, %eax
jne 0x7a69
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x7abe
movq 0xc588(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq 0xc676(%rip), %rdx      # 0x140f0
movl 0xd510(%rip), %ecx      # 0x14f90
movq -0x8(%rbp), %rax
movq (%rax), %r8
leaq 0x9363(%rip), %rsi      # 0x10df1
movb $0x0, %al
callq 0x4110
movq 0xc55c(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x9360(%rip), %rsi      # 0x10e15
movb $0x0, %al
callq 0x4110
jmp 0x7aef
jmp 0x7ac0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x79f8
movq 0xe934(%rip), %rax      # 0x16418
movq 0x28(%rax), %rax
movq %rax, 0xe929(%rip)      # 0x16418
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: nested
static void
nested(char *s)
{	int i;
	for (i = 0; i < Enesting; i++)
		printf("\t");
	printf("%s", s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0xebe4(%rip), %eax      # 0x17440
jge 0x8877
leaq 0x8fb5(%rip), %rdi      # 0x1181a
movb $0x0, %al
callq 0x40a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8853
movq -0x8(%rbp), %rsi
leaq 0x8398(%rip), %rdi      # 0x10c1a
movb $0x0, %al
callq 0x40a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: cpy_orig
static TS *
cpy_orig(TS *or)
{	TS *nw = (TS *) 0;
	ML *ml;

	if (or != (TS *) 0)
	{	nw = cpy_inl(or, (TS *) 0);
		nw->ml = (ML *) 0;
		for (ml = or->ml; ml; ml = ml->nxt)
			add_tag(nw, ml->m);

		nw->nxt = cpy_orig(or->nxt);
		if (nw->nxt)
			nw->nxt->prv = nw;
	}

	return nw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8932
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x97b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x88fd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x7190
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x88d8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x8890
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x8930
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x8932
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: inherit_tags
static void
inherit_tags(TS *s, TS *tlast, TS *ni)
{	ML *mp;

	for (mp = s->ml; mp; mp = mp->nxt)
		if (s == tlast
		||  throughout(s->nxt, tlast, mp->m))
		{	add_tag(ni, mp->m);
			if (debugging)
			{	nested("");
				printf("inherited tag on %p with %s\t", ni, mp->m->nm);
				tokfull(ni, stdout);
				printf("\n");
		}	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9149
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x90d2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x9fe0
cmpl $0x0, %eax
je 0x9136
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x7190
cmpl $0x0, 0xd2f7(%rip)      # 0x163e0
je 0x9134
leaq 0x8729(%rip), %rdi      # 0x1181b
callq 0x8840
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
leaq 0x81e8(%rip), %rdi      # 0x112f4
movb $0x0, %al
callq 0x40a0
movq -0x18(%rbp), %rdi
movq 0xaeb2(%rip), %rax      # 0x13fd0
movq (%rax), %rsi
callq 0x57e0
leaq 0x7ee9(%rip), %rdi      # 0x11016
movb $0x0, %al
callq 0x40a0
jmp 0x9136
jmp 0x9138
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x90a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: pick_predefined
static TS *
pick_predefined(TS *s, char *str)
{	TS *ni;

	ni = new_inl(NAME);
	ni->name = str;
	ni->space = s->space;

	if (!s->prv)
	{	start = ni;
		ni->prv = start;
	} else
	{	s->prv->nxt = ni;
		ni->prv = s->prv;
	}

	if (s->nxt)
	{	s->nxt->prv = ni;
		ni->nxt = s->nxt;
	}
	return ni;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
callq 0x5eb0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x93ef
movq -0x18(%rbp), %rax
movq %rax, 0xcfea(%rip)      # 0x163c8
movq 0xcfe3(%rip), %rcx      # 0x163c8
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x940f
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x943a
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: show_args
static void
show_args(ARL *sa, int j)
{	TS *wi;
	printf("ARG %d ", j);
	for(wi = sa->al; wi; wi = wi->nxt)
		tokfull(wi, stdout);
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x7a80(%rip), %rdi      # 0x11189
movb $0x0, %al
callq 0x40a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9743
movq -0x18(%rbp), %rdi
movq 0xa8a3(%rip), %rax      # 0x13fd0
movq (%rax), %rsi
callq 0x57e0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x971b
leaq 0x78cc(%rip), %rdi      # 0x11016
movb $0x0, %al
callq 0x40a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: bld_arglst
static ARL *
bld_arglst(TS *s, ARL *al)
{	ARL *a;
	a = (ARL *) emalloc(sizeof(ARL));
	a->al = s;
	if (al) al->nxt = a;
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x4320
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x979c
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: cpy_inl
static TS *
cpy_inl(TS *s, TS *prv)
{	TS *n;
	n = new_inl(s->tok);
	n->val = s->val;
	n->name = s->name;
	n->space = s->space;
	n->ml = s->ml;
	n->prv = prv;
	if (prv) prv->nxt = n;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x5eb0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x982a
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)