LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: check_name
static void
check_name(char *s)
{	int i;

	if (strcmp(s, "include") == 0)
		m_rule(19, 9, "macro argument matches directive name");
	for (i = 0; table[i].nm != NULL; i++)
		if (strcmp(s, table[i].nm) == 0)
		m_rule(19, 9, "macro argument matches directive name");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7ccc(%rip), %rsi      # 0x11523
callq 0x4100
cmpl $0x0, %eax
jne 0x9877
movl $0x13, %edi
movl $0x9, %esi
leaq 0x78f1(%rip), %rdx      # 0x11163
callq 0xca50
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0xb627(%rip), %rax      # 0x14eb0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x98dc
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0xb60b(%rip), %rax      # 0x14eb0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x4100
cmpl $0x0, %eax
jne 0x98cf
movl $0x13, %edi
movl $0x9, %esi
leaq 0x7899(%rip), %rdx      # 0x11163
callq 0xca50
jmp 0x98d1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x987e
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: hunt_param
static ARL *
hunt_param(MD *m, TS *b)
{	ARL  *ap;	/* actual */
	ARGS *fp;	/* formal */
	int i = 0, j = 0;
	int n = b->val;	/* nr of param in formal param list */
#ifdef DEBUG
	TS *x; printf("\n");
#endif
	for (ap = saa; ap; ap = ap->nxt)
	{	i++;	/* count actual params */
#ifdef DEBUG
		printf("actual %d ", i);
		for (x = ap->al; x; x = x->nxt)
			printf("%s ", x->name);
		if (i==n) printf("<<--%s", b->name);
			printf("\n");
#endif
	}

	for (fp = m->arg; fp; fp = fp->nxt)
	{	j++;	/* count formal params */
#ifdef DEBUG
		printf("formal %d %s\n", j, fp->nm);
#endif
	}

	if (strcmp(b->name, "__VA_ARGS__") == 0)
		n = j-1;	/* last formal */

	for (i = 0, ap = saa; ap; i++, ap = ap->nxt)
		if (i == n) break;	/* nth param in actual param list */

	if (!ap) fatal_error("did not find param");

	return ap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq 0xdb29(%rip), %rax      # 0x17448
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9941
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9923
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x996b
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x994d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7417(%rip), %rsi      # 0x10d91
callq 0x4100
cmpl $0x0, %eax
jne 0x998d
movl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movq 0xdaad(%rip), %rax      # 0x17448
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x99c9
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x99b0
jmp 0x99c9
jmp 0x99b2
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x999f
cmpq $0x0, -0x18(%rbp)
jne 0x99dc
leaq 0x781b(%rip), %rdi      # 0x111f2
callq 0x42b0
movq -0x18(%rbp), %rax
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: add_inl
static void
add_inl(Tokvals tt, int v, char *nm, int sp, int reuse)
{	TS *ni;

	ni = new_inl(tt);
	ni->val = v;

	if (reuse)
		ni->name  = nm;
	else
	{	ni->name = emalloc(strlen(nm)+1);
		strcpy(ni->name, nm);
	}
	ni->space = sp;

	if (lst) lst->nxt = ni;
	ni->prv = lst;
	if (!frst) frst = ni;
	lst = ni;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0x4(%rbp), %edi
callq 0x5eb0
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
cmpl $0x0, -0x18(%rbp)
je 0x9a33
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x9a63
movq -0x10(%rbp), %rdi
callq 0x4080
addq $0x1, %rax
movl %eax, %edi
callq 0x4320
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4060
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
cmpq $0x0, 0xd9e3(%rip)      # 0x17458
je 0x9a86
movq -0x20(%rbp), %rcx
movq 0xd9d6(%rip), %rax      # 0x17458
movq %rcx, 0x28(%rax)
movq 0xd9cb(%rip), %rcx      # 0x17458
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0xd9c3(%rip)      # 0x17460
jne 0x9aaa
movq -0x20(%rbp), %rax
movq %rax, 0xd9b6(%rip)      # 0x17460
movq -0x20(%rbp), %rax
movq %rax, 0xd9a3(%rip)      # 0x17458
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: stringify
static char *
stringify(TS *s, TS *f)
{	static char m[128];
	static char p[128];
	char *q;
	int i = 0;

	if (!s) return "";

	p[0] = m[1] = '\0';

	if (s)
	switch (s->tok) {
	case NAME:
		for (q = s->name; *q != '\0'; q++)
		{	if (*q == '\\'
			||  *q == '"')
				strcat(p, "\\");
			m[0] = *q;
			strcat(p, m);
		}
		break;

	case VAL:
		sprintf(p, "%d", s->val);
		break;

	case CHAR:
		if (s->val != '"')
		{	sprintf(p, "%c", s->val);  
			break;
		}
		/* else fall thru */
	case ECHAR:
		sprintf(p, "\\%c", s->val);
		break;

	default: break;
	}

	if (s != f)	/* not for first arg */
	for (i = 0; i < s->space; i++)
		m[i] = ' ';

	m[i] = '\0';
	strcat(m, p);

	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9aee
leaq 0x7d36(%rip), %rax      # 0x1181b
movq %rax, -0x8(%rbp)
jmp 0x9c74
movb $0x0, 0xd97c(%rip)      # 0x17471
movb $0x0, 0xd9f4(%rip)      # 0x174f0
cmpq $0x0, -0x10(%rbp)
je 0x9c0e
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0x9c0a
movq -0x30(%rbp), %rax
leaq 0x38df(%rip), %rcx      # 0xd408
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9ba2
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x9b62
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x9b75
leaq 0xd987(%rip), %rdi      # 0x174f0
leaq 0x6f24(%rip), %rsi      # 0x10a94
callq 0x4160
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, 0xd8ef(%rip)       # 0x17470
leaq 0xd968(%rip), %rdi      # 0x174f0
leaq 0xd8e1(%rip), %rsi      # 0x17470
callq 0x4160
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x9b3e
jmp 0x9c0c
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0xd93e(%rip), %rdi      # 0x174f0
leaq 0x6ed8(%rip), %rsi      # 0x10a91
movb $0x0, %al
callq 0x4170
jmp 0x9c0c
movq -0x10(%rbp), %rax
cmpl $0x22, 0x4(%rax)
je 0x9bea
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0xd916(%rip), %rdi      # 0x174f0
leaq 0x7625(%rip), %rsi      # 0x11206
movb $0x0, %al
callq 0x4170
jmp 0x9c0c
jmp 0x9bec
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0xd8f6(%rip), %rdi      # 0x174f0
leaq 0x7604(%rip), %rsi      # 0x11205
movb $0x0, %al
callq 0x4170
jmp 0x9c0c
jmp 0x9c0c
jmp 0x9c0e
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x9c47
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x9c45
movslq -0x24(%rbp), %rcx
leaq 0xd83a(%rip), %rax      # 0x17470
movb $0x20, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9c1f
jmp 0x9c47
movslq -0x24(%rbp), %rcx
leaq 0xd81e(%rip), %rax      # 0x17470
movb $0x0, (%rax,%rcx)
leaq 0xd813(%rip), %rdi      # 0x17470
leaq 0xd88c(%rip), %rsi      # 0x174f0
callq 0x4160
leaq 0xd800(%rip), %rax      # 0x17470
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: string_size
static int
string_size(TS *s)
{	int cnt, v;

	if (!s) return 0;

	cnt = s->space+1;
	switch (s->tok) {
	case NAME:	cnt = strlen(s->name);
			break;
	case VAL:	for (v = s->val; v >= 10; v /= 10)
				cnt++;
			break;
	case ECHAR:	cnt++; /* fall thru */
	default:	break;
	}

	return cnt+string_size(s->nxt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9f3f
movl $0x0, -0x4(%rbp)
jmp 0x9fd4
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
incl %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x9f6f
jmp 0x9f5b
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x9fac
jmp 0x9f65
movl -0x1c(%rbp), %eax
subl $0x4, %eax
je 0x9f81
jmp 0x9fb5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4080
movl %eax, -0x14(%rbp)
jmp 0x9fb7
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0xa, -0x18(%rbp)
jl 0x9faa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
jmp 0x9f8b
jmp 0x9fb7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9fb7
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x9f20
movl %eax, %ecx
movl -0x20(%rbp), %eax
addl %ecx, %eax
movl %eax, -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: throughout
static int
throughout(TS *s, TS *tlast, MD *m)
{	ML *mp;

	if (!s || s == tlast) return 1;

	for (mp = s->ml; mp; mp = mp->nxt)
		if (mp->m == m)
			break;

	if (!mp) return 0;

	return throughout(s->nxt, tlast, m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa005
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xa00e
movl $0x1, -0x4(%rbp)
jmp 0xa068
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa040
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0xa030
jmp 0xa040
jmp 0xa032
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xa01a
cmpq $0x0, -0x28(%rbp)
jne 0xa050
movl $0x0, -0x4(%rbp)
jmp 0xa068
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9fe0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: do_elif_post
static void
do_elif_post(void)
{
	if (not_printing[level] == 1)		/* all earlier if-exprs were False */
		not_printing[level] = !eval_expr(start);
	else if (not_printing[level] != 3)	/* 0 or 2 at least one earlier if-expr was True */
		not_printing[level] = 2; /* prevent next elifs to misinterpret state */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0xbeb9(%rip), %rcx      # 0x15fb4
leaq 0xbebe(%rip), %rax      # 0x15fc0
cmpl $0x1, (%rax,%rcx,4)
jne 0xa134
movq 0xc2b9(%rip), %rdi      # 0x163c8
callq 0xb120
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edx
movslq 0xbe8c(%rip), %rcx      # 0x15fb4
leaq 0xbe91(%rip), %rax      # 0x15fc0
movl %edx, (%rax,%rcx,4)
jmp 0xa15f
movslq 0xbe79(%rip), %rcx      # 0x15fb4
leaq 0xbe7e(%rip), %rax      # 0x15fc0
cmpl $0x3, (%rax,%rcx,4)
je 0xa15d
movslq 0xbe65(%rip), %rcx      # 0x15fb4
leaq 0xbe6a(%rip), %rax      # 0x15fc0
movl $0x2, (%rax,%rcx,4)
jmp 0xa15f
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: add_sysdir
void
add_sysdir(char *s)
{	ARGS *inc;

	if (!s || strlen(s) < 2) return;

	for (inc = sysdirs; inc; inc = inc->nxt)
		if (strcmp(s, inc->nm) == 0)
			return;

	inc = (ARGS *) emalloc(sizeof(ARGS));
	inc->nm = (char *) emalloc(strlen(s)+1);
	strcpy(inc->nm, s);
	inc->nxt = sysdirs;
	sysdirs = inc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa192
movq -0x8(%rbp), %rdi
callq 0x4080
cmpq $0x2, %rax
jae 0xa197
jmp 0xa226
movq 0xd3d2(%rip), %rax      # 0x17570
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa1d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x4100
cmpl $0x0, %eax
jne 0xa1c0
jmp 0xa226
jmp 0xa1c2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa1a2
movl $0x10, %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
movq 0xd35d(%rip), %rcx      # 0x17570
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xd34a(%rip)      # 0x17570
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: need_more
void
need_more(void)
{
	if (fgets(ibuf, MAXIN, mfd) == NULL)
		fatal_error("gh_cpp: unexpected eof");
	delta++;
	trimline(ibuf);
	/* should check if the line ends in a \\ */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xe305(%rip), %rdx      # 0x18580
leaq 0xd2fe(%rip), %rdi      # 0x17580
movl $0x1000, %esi           # imm = 0x1000
callq 0x40f0
cmpq $0x0, %rax
jne 0xa29e
leaq 0x7091(%rip), %rdi      # 0x1132a
callq 0x42b0
movl 0xe2e4(%rip), %eax      # 0x18588
addl $0x1, %eax
movl %eax, 0xe2db(%rip)      # 0x18588
leaq 0xd2cc(%rip), %rdi      # 0x17580
callq 0xa2c0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: trimline
static int
trimline(char *b)
{	int len;

	len = strlen(b);
	if (len >= MAXIN) fatal_error("input line too long");

	while (len > 1
	&& (b[len-2] == ' '
	||  b[len-2] == '\t'))
	{	b[len-2] = '\n';
		b[len-1] = '\0';
		len--;
	}

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4080
movl %eax, -0xc(%rbp)
cmpl $0x1000, -0xc(%rbp)     # imm = 0x1000
jl 0xa2ed
leaq 0x7162(%rip), %rdi      # 0x1144a
callq 0x42b0
jmp 0xa2ef
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0xd(%rbp)
jle 0xa335
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xe(%rbp)
je 0xa32f
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0xa33e
jmp 0xa36b
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movb $0xa, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa2ef
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: search_sys
static int
search_sys(ARGS *n, char *f)
{	char *s;
	FILE *nfd;

	if (!n) return 0;

	if (search_sys(n->nxt, f))
		return 1;

	s = (char *) emalloc(strlen(f)+strlen(n->nm)+1+1);
	sprintf(s, "%s/%s", n->nm, f);

	if (misra_rules)
	{	if (strcmp(s, "malloc.h") == 0)
			m_rule(20, 4, "<malloc.h>");
		else if (strcmp(s, "signal.h") == 0)
			m_rule(20, 8, "<signal.h>");
		else if (strcmp(s, "stdio.h") == 0)
			m_rule(20, 9, "<stdio.h>");
		else if (strcmp(s, "time.h") == 0)
			m_rule(20, 12, "<time.h>");
	}

	if ((nfd = fopen(s, "r")) == NULL)
	{	free(s);
		return 0;
	}
	if (verbose>1) printf("/**** #include: %s ****/\n", s);

	fclose(nfd);
	do_file(filename, lineno, s);
	free(s);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xaaf3
movl $0x0, -0x4(%rbp)
jmp 0xacb4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xaad0
cmpl $0x0, %eax
je 0xab15
movl $0x1, -0x4(%rbp)
jmp 0xacb4
movq -0x18(%rbp), %rdi
callq 0x4080
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4080
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
addq $0x1, %rax
movl %eax, %edi
callq 0x4320
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
leaq 0x6814(%rip), %rsi      # 0x11375
movb $0x0, %al
callq 0x4170
leaq 0xa425(%rip), %rax      # 0x14f94
cmpl $0x0, (%rax)
je 0xac35
movq -0x20(%rbp), %rdi
leaq 0x68db(%rip), %rsi      # 0x1145e
callq 0x4100
cmpl $0x0, %eax
jne 0xaba8
movl $0x14, %edi
movl $0x4, %esi
leaq 0x68c9(%rip), %rdx      # 0x11467
callq 0xca50
jmp 0xac33
movq -0x20(%rbp), %rdi
leaq 0x68bf(%rip), %rsi      # 0x11472
callq 0x4100
cmpl $0x0, %eax
jne 0xabd5
movl $0x14, %edi
movl $0x8, %esi
leaq 0x68ad(%rip), %rdx      # 0x1147b
callq 0xca50
jmp 0xac31
movq -0x20(%rbp), %rdi
leaq 0x68a6(%rip), %rsi      # 0x11486
callq 0x4100
cmpl $0x0, %eax
jne 0xac02
movl $0x14, %edi
movl $0x9, %esi
leaq 0x6893(%rip), %rdx      # 0x1148e
callq 0xca50
jmp 0xac2f
movq -0x20(%rbp), %rdi
leaq 0x688b(%rip), %rsi      # 0x11498
callq 0x4100
cmpl $0x0, %eax
jne 0xac2d
movl $0x14, %edi
movl $0xc, %esi
leaq 0x6877(%rip), %rdx      # 0x1149f
callq 0xca50
jmp 0xac2f
jmp 0xac31
jmp 0xac33
jmp 0xac35
movq -0x20(%rbp), %rdi
leaq 0x3a38(%rip), %rsi      # 0xe678
callq 0x4140
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xac61
movq -0x20(%rbp), %rdi
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0xacb4
leaq 0xb348(%rip), %rax      # 0x15fb0
cmpl $0x1, (%rax)
jle 0xac7f
movq -0x20(%rbp), %rsi
leaq 0x6703(%rip), %rdi      # 0x1137b
movb $0x0, %al
callq 0x40a0
movq -0x28(%rbp), %rdi
callq 0x4070
leaq 0x9461(%rip), %rax      # 0x140f0
movq (%rax), %rdi
leaq 0xa2f7(%rip), %rax      # 0x14f90
movl (%rax), %esi
movq -0x20(%rbp), %rdx
callq 0xa720
movq -0x20(%rbp), %rdi
callq 0x4030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: push_stacker
static void
push_stacker(char *s)
{	ARGS *n;

	for (n = stacker; n; n = n->nxt)
		if (strcmp(s, n->nm) == 0)
		{	if (verbose>1)
			{	for (n = stacker; n; n = n->nxt)
					fprintf(stderr, "--");
			}
			if (misra_rules)
				m_rule(19, 15, "include file processed twice");
			fprintf(stderr, "warning: circular #include \"%s\" -- nesting depth %d\n",
				s, stack_depth);
			if (stack_depth > 1024)
				fatal_error("max nesting depth exceeded; circular #include");
			break;
		}

	if (verbose>1)
	{	for (n = stacker; n; n = n->nxt)
			fprintf(stderr, "  ");
		fprintf(stderr, "%s\n", s);
	}
	n = (ARGS *) emalloc(sizeof(ARGS));
	n->nm = (char *) emalloc(strlen(s)+1);
	strcpy(n->nm, s);
	n->nxt = stacker;
	stacker = n;
	stack_depth++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xd8bd(%rip), %rax      # 0x18590
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xadb2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x4100
cmpl $0x0, %eax
jne 0xad9f
leaq 0xb2ae(%rip), %rax      # 0x15fb0
cmpl $0x1, (%rax)
jle 0xad41
movq 0xd882(%rip), %rax      # 0x18590
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xad3f
movq 0x92d8(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x677e(%rip), %rsi      # 0x114a8
movb $0x0, %al
callq 0x4110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xad12
jmp 0xad41
leaq 0xa24c(%rip), %rax      # 0x14f94
cmpl $0x0, (%rax)
je 0xad63
movl $0x13, %edi
movl $0xf, %esi
leaq 0x674d(%rip), %rdx      # 0x114ab
callq 0xca50
movq 0x928e(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl 0xd815(%rip), %ecx      # 0x1858c
leaq 0x674a(%rip), %rsi      # 0x114c8
movb $0x0, %al
callq 0x4110
cmpl $0x400, 0xd7fd(%rip)    # imm = 0x400
jle 0xad9d
leaq 0x6765(%rip), %rdi      # 0x114fd
callq 0x42b0
jmp 0xadb2
jmp 0xada1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xacd7
leaq 0xb1f7(%rip), %rax      # 0x15fb0
cmpl $0x1, (%rax)
jle 0xae12
movq 0xd7cb(%rip), %rax      # 0x18590
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xadf6
movq 0x9221(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x6c0f(%rip), %rsi      # 0x119f0
movb $0x0, %al
callq 0x4110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xadc9
movq 0x91fb(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x6192(%rip), %rsi      # 0x10f9d
movb $0x0, %al
callq 0x4110
movl $0x10, %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
movq 0xd73b(%rip), %rcx      # 0x18590
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xd728(%rip)      # 0x18590
movl 0xd71e(%rip), %eax      # 0x1858c
addl $0x1, %eax
movl %eax, 0xd715(%rip)      # 0x1858c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: pop_stacker
static void
pop_stacker(char *s)
{
	if (!stacker || strcmp(stacker->nm, s) != 0)
		fatal_error("internal error stack");
	stacker = stacker->nxt;
	stack_depth--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0xd6fc(%rip)      # 0x18590
je 0xaeae
movq 0xd6f3(%rip), %rax      # 0x18590
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4100
cmpl $0x0, %eax
je 0xaeba
leaq 0x6676(%rip), %rdi      # 0x1152b
callq 0x42b0
movq 0xd6cf(%rip), %rax      # 0x18590
movq 0x8(%rax), %rax
movq %rax, 0xd6c4(%rip)      # 0x18590
movl 0xd6ba(%rip), %eax      # 0x1858c
addl $-0x1, %eax
movl %eax, 0xd6b1(%rip)      # 0x1858c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: hexa
int
hexa(char *s)
{	int x = 0;
	int cnt = 0;

	for ( ; *s != '\'' && *s != '\0'; s++)
	{	cnt++;
		x = 16*x + *s;
		switch (*s) {
		case '0': case '1': case '2':
		case '3': case '4': case '5':
		case '6': case '7': case '8':
		case '9':
			x -= '0';
			break;
		case 'a': case 'b': case 'c':
		case 'd': case 'e': case 'f':
			x -= 'a' + 10;
			break;
		case 'A': case 'B': case 'C':
		case 'D': case 'E': case 'F':
			x -= 'A' + 10;
			break;
		default:
			fatal_error("bad hexadecimal char constant");
	}	}
	if (cnt == 0)
		fprintf(stderr, "%s,%d: warning, \\x with no hex digits\n",
			filename, lineno);


	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x27, %ecx
movb %al, -0x11(%rbp)
je 0xaf2b
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xaf37
jmp 0xafbf
movl -0x10(%rbp), %eax
incl %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x18(%rbp)
addl $-0x30, %eax
subl $0xa, %eax
jb 0xaf7f
jmp 0xaf65
movl -0x18(%rbp), %eax
addl $-0x41, %eax
subl $0x6, %eax
jb 0xaf95
jmp 0xaf72
movl -0x18(%rbp), %eax
addl $-0x61, %eax
subl $0x6, %eax
jb 0xaf8a
jmp 0xafa0
movl -0xc(%rbp), %eax
subl $0x30, %eax
movl %eax, -0xc(%rbp)
jmp 0xafac
movl -0xc(%rbp), %eax
subl $0x6b, %eax
movl %eax, -0xc(%rbp)
jmp 0xafac
movl -0xc(%rbp), %eax
subl $0x4b, %eax
movl %eax, -0xc(%rbp)
jmp 0xafac
leaq 0x66a1(%rip), %rdi      # 0x11648
callq 0x42b0
jmp 0xafae
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xaf0a
cmpl $0x0, -0x10(%rbp)
jne 0xaff0
movq 0x902c(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x911a(%rip), %rax      # 0x140f0
movq (%rax), %rdx
leaq 0x9fb0(%rip), %rax      # 0x14f90
movl (%rax), %ecx
leaq 0x667d(%rip), %rsi      # 0x11666
movb $0x0, %al
callq 0x4110
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: octal
int
octal(char *s)
{	int x = 0;
	int cnt = 0;

	for ( ; *s != '\'' && *s != '\0'; s++)
	{	if (++cnt > 3)
		{	x = (x << 8) + *s;
			continue;	/* octal sequence has only 3 significant digits */
		}
		x = 8*x + *s;
		switch (*s) {
		case '0': case '1': case '2':
		case '3': case '4': case '5':
		case '6': case '7': 
			x -= '0';
			break;
		default:
			fprintf(stderr, "saw character '%c'\n", *s);
			fatal_error("bad octal char constant");
	}	}

	if (cnt > 3)
		fprintf(stderr, "%s,%d: warning, multi-byte character constant\n",
			filename, lineno);

	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x27, %ecx
movb %al, -0x11(%rbp)
je 0xb03b
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xb047
jmp 0xb0d7
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x3, %eax
jle 0xb069
movl -0xc(%rbp), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0xb0c6
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %edx
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,8), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
subl $0x7, %eax
ja 0xb099
jmp 0xb08e
movl -0xc(%rbp), %eax
subl $0x30, %eax
movl %eax, -0xc(%rbp)
jmp 0xb0c4
movq 0x8f58(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movsbl (%rax), %edx
leaq 0x65dc(%rip), %rsi      # 0x1168d
movb $0x0, %al
callq 0x4110
leaq 0x65e2(%rip), %rdi      # 0x116a1
callq 0x42b0
jmp 0xb0c6
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xb01a
cmpl $0x3, -0x10(%rbp)
jle 0xb108
movq 0x8f14(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x9002(%rip), %rax      # 0x140f0
movq (%rax), %rdx
leaq 0x9e98(%rip), %rax      # 0x14f90
movl (%rax), %ecx
leaq 0x65b8(%rip), %rsi      # 0x116b9
movb $0x0, %al
callq 0x4110
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: eval_expr
int
eval_expr(TS *p)
{	int v;

	if (!p
	||  !p->nxt
	||   p->tok != CHAR
	||   p->val != '#'
	||  !(p->nxt->tok == NAME)
	|| (strcmp(p->nxt->name, "if") != 0
	&&  strcmp(p->nxt->name, "elif") != 0))
		fatal_error("cannot happen, eval_expr");

	strcpy(err_s, "");

	pp = p->nxt;
	lat = nxt_token();
	push_expr(4);

	if (verbose>1) dump_stack("stack:");

	if (lat != DONE) syntax_error("bad expression");

	v = interpret();	/* evaluate expression on stack */
	assert(valptr == 0);
	if (verbose>1) printf("eval result: %d\n", v);
	return v?1:0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb198
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xb198
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xb198
movq -0x8(%rbp), %rax
cmpl $0x23, 0x4(%rax)
jne 0xb198
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x1, (%rax)
jne 0xb198
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x5d8e(%rip), %rsi      # 0x10eff
callq 0x4100
cmpl $0x0, %eax
je 0xb1a4
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x5aaa(%rip), %rsi      # 0x10c38
callq 0x4100
cmpl $0x0, %eax
je 0xb1a4
leaq 0x6549(%rip), %rdi      # 0x116e8
callq 0x42b0
leaq 0xd3f5(%rip), %rdi      # 0x185a0
leaq 0x6669(%rip), %rsi      # 0x1181b
callq 0x4060
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, 0xd7da(%rip)      # 0x189a0
callq 0xb270
movl %eax, 0xd7d7(%rip)      # 0x189a8
movl $0x4, %edi
callq 0xb2f0
leaq 0xadce(%rip), %rax      # 0x15fb0
cmpl $0x1, (%rax)
jle 0xb1f3
leaq 0x6513(%rip), %rdi      # 0x11701
callq 0xb800
cmpl $0x0, 0xd7ae(%rip)      # 0x189a8
je 0xb208
leaq 0x6505(%rip), %rdi      # 0x11708
callq 0xb8c0
callq 0xb970
movl %eax, -0xc(%rbp)
cmpl $0x0, 0xd795(%rip)      # 0x189ac
jne 0xb21b
jmp 0xb23a
leaq 0x64f5(%rip), %rdi      # 0x11717
leaq 0x64fa(%rip), %rsi      # 0x11723
movl $0x1bb, %edx            # imm = 0x1BB
leaq 0x64f8(%rip), %rcx      # 0x1172d
callq 0x40c0
leaq 0xad6f(%rip), %rax      # 0x15fb0
cmpl $0x1, (%rax)
jle 0xb257
movl -0xc(%rbp), %esi
leaq 0x64f1(%rip), %rdi      # 0x11741
movb $0x0, %al
callq 0x40a0
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: nxt_token
static Tokvals
nxt_token(void)
{
	if (!pp || !pp->nxt) return DONE;

	pp = pp->nxt;
	mychar = myval = pp->val;
	myname = pp->name;

	return pp->tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0xd724(%rip)      # 0x189a0
je 0xb28c
movq 0xd71b(%rip), %rax      # 0x189a0
cmpq $0x0, 0x28(%rax)
jne 0xb295
movl $0x0, -0x4(%rbp)
jmp 0xb2e6
movq 0xd704(%rip), %rax      # 0x189a0
movq 0x28(%rax), %rax
movq %rax, 0xd6f9(%rip)      # 0x189a0
movq 0xd6f2(%rip), %rax      # 0x189a0
movl 0x4(%rax), %eax
leaq 0xb140(%rip), %rcx      # 0x163f8
movl %eax, (%rcx)
movb %al, %cl
leaq 0xb121(%rip), %rax      # 0x163e4
movb %cl, (%rax)
movq 0xd6d4(%rip), %rax      # 0x189a0
movq 0x8(%rax), %rcx
leaq 0xb111(%rip), %rax      # 0x163e8
movq %rcx, (%rax)
movq 0xd6bf(%rip), %rax      # 0x189a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: dump_stack
static void
dump_stack(char *s)	/* verbose/debugging mode only */
{	int i;

	printf("=== ");
	printf("%s:\n", s);
	for (i = 0; i < valptr; i++)
	{	printf("%2d:	", i);
		tokname(valstack[i].tok, stdout);
		printf("[%d]", valstack[i].val);
		printf("\n");
	}
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x5ff9(%rip), %rdi      # 0x1180c
movb $0x0, %al
callq 0x40a0
movq -0x8(%rbp), %rsi
leaq 0x5fec(%rip), %rdi      # 0x11811
movb $0x0, %al
callq 0x40a0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0xd170(%rip), %eax      # 0x189ac
jge 0xb8a2
movl -0xc(%rbp), %esi
leaq 0x5fce(%rip), %rdi      # 0x11816
movb $0x0, %al
callq 0x40a0
movslq -0xc(%rbp), %rcx
leaq 0xd156(%rip), %rax      # 0x189b0
movl 0x4(%rax,%rcx,8), %edi
movq 0x876b(%rip), %rax      # 0x13fd0
movq (%rax), %rsi
callq 0x4370
movslq -0xc(%rbp), %rcx
leaq 0xd138(%rip), %rax      # 0x189b0
movl (%rax,%rcx,8), %esi
leaq 0x5f9a(%rip), %rdi      # 0x1181c
movb $0x0, %al
callq 0x40a0
leaq 0x5786(%rip), %rdi      # 0x11016
movb $0x0, %al
callq 0x40a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb833
leaq 0x576d(%rip), %rdi      # 0x11016
movb $0x0, %al
callq 0x40a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: syntax_error
static void
syntax_error(char *s)
{
	fprintf(stderr, "%s,%d: expr: syntax error at '%s' (%s)\n",
		filename, lineno, ibuf, s);
	fprintf(stderr, "unexpected '");
	tokname(lat, stderr);
	fprintf(stderr, "'\n");

	show_line(0, stderr);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x8725(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x8813(%rip), %rax      # 0x140f0
movq (%rax), %rdx
leaq 0x96a9(%rip), %rax      # 0x14f90
movl (%rax), %ecx
movq -0x8(%rbp), %r9
leaq 0x5f2d(%rip), %rsi      # 0x11821
leaq 0xbc85(%rip), %r8       # 0x17580
movb $0x0, %al
callq 0x4110
movq 0x86ef(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x5f36(%rip), %rsi      # 0x11849
movb $0x0, %al
callq 0x4110
movl 0xd088(%rip), %edi      # 0x189a8
movq 0x86d1(%rip), %rax      # 0x13ff8
movq (%rax), %rsi
callq 0x4370
movq 0x86c2(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x5175(%rip), %rsi      # 0x10ab5
movb $0x0, %al
callq 0x4110
movq 0x86aa(%rip), %rax      # 0x13ff8
movq (%rax), %rsi
xorl %edi, %edi
callq 0x4750
movl $0x1, %edi
callq 0x4180
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: emit
static void
emit(Tokvals n, int v)
{
	assert(n != CHAR);
	valstack[valptr].tok = n;
	valstack[valptr].val = v;
	if (++valptr >= MAXSTACK)
		syntax_error("formula too long");

	if (verbose>1) dump_stack("emit");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x2, -0x4(%rbp)
je 0xc106
jmp 0xc125
leaq 0x568f(%rip), %rdi      # 0x1179c
leaq 0x560f(%rip), %rsi      # 0x11723
movl $0x46, %edx
leaq 0x56be(%rip), %rcx      # 0x117de
callq 0x40c0
movl -0x4(%rbp), %edx
movslq 0xc87d(%rip), %rcx      # 0x189ac
leaq 0xc87a(%rip), %rax      # 0x189b0
movl %edx, 0x4(%rax,%rcx,8)
movl -0x8(%rbp), %edx
movslq 0xc868(%rip), %rcx      # 0x189ac
leaq 0xc865(%rip), %rax      # 0x189b0
movl %edx, (%rax,%rcx,8)
movl 0xc858(%rip), %eax      # 0x189ac
addl $0x1, %eax
movl %eax, 0xc84f(%rip)      # 0x189ac
cmpl $0x100, %eax            # imm = 0x100
jl 0xc170
leaq 0x568b(%rip), %rdi      # 0x117f6
callq 0xb8c0
leaq 0x9e39(%rip), %rax      # 0x15fb0
cmpl $0x1, (%rax)
jle 0xc188
leaq 0x5684(%rip), %rdi      # 0x11807
callq 0xb800
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: do_division
static void
do_division(void)
{	int v, w;

	w = interpret();
	if (w == 0)
	{	strcpy(err_s, "divide by zero");
		if (!sh_err)	/* unless in a boolean subexpression */
			fatal_error("division by zero");
		v = interpret();
		emit(VAL, 0);
	} else
	{	v = interpret();
		emit(VAL, (v / w));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb970
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0xc1e4
leaq 0xc3f3(%rip), %rdi      # 0x185a0
leaq 0x56f8(%rip), %rsi      # 0x118ac
callq 0x4060
cmpl $0x0, 0xcff0(%rip)      # 0x191b0
jne 0xc1ce
leaq 0x56f2(%rip), %rdi      # 0x118bb
callq 0x42b0
callq 0xb970
movl %eax, -0x4(%rbp)
movl $0x4, %edi
xorl %esi, %esi
callq 0xc0f0
jmp 0xc1ff
callq 0xb970
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, %esi
movl $0x4, %edi
callq 0xc0f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: do_bool
static int
do_bool(int op)
{	int v, w;

	sh_err++;
	w = interpret();
	sh_err--;
	v = interpret();

	if ((op == LAND && v == 0)
	||  (op == LOR  && v != 0))
		strcpy(err_s, "");
	else if (sh_err == 0
	     &&  strlen(err_s) > 0)
		fatal_error(err_s);

	return (op == LOR) ? (v || w) : (v && w);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl 0xcf8f(%rip), %eax      # 0x191b0
addl $0x1, %eax
movl %eax, 0xcf86(%rip)      # 0x191b0
callq 0xb970
movl %eax, -0xc(%rbp)
movl 0xcf78(%rip), %eax      # 0x191b0
addl $-0x1, %eax
movl %eax, 0xcf6f(%rip)      # 0x191b0
callq 0xb970
movl %eax, -0x8(%rbp)
cmpl $0x1b, -0x4(%rbp)
jne 0xc255
cmpl $0x0, -0x8(%rbp)
je 0xc261
cmpl $0x1a, -0x4(%rbp)
jne 0xc276
cmpl $0x0, -0x8(%rbp)
je 0xc276
leaq 0xc338(%rip), %rdi      # 0x185a0
leaq 0x55ac(%rip), %rsi      # 0x1181b
callq 0x4060
jmp 0xc29f
cmpl $0x0, 0xcf33(%rip)      # 0x191b0
jne 0xc29d
leaq 0xc31a(%rip), %rdi      # 0x185a0
callq 0x4080
cmpq $0x0, %rax
jbe 0xc29d
leaq 0xc308(%rip), %rdi      # 0x185a0
callq 0x42b0
jmp 0xc29f
cmpl $0x1a, -0x4(%rbp)
jne 0xc2c7
movb $0x1, %al
cmpl $0x0, -0x8(%rbp)
movb %al, -0xd(%rbp)
jne 0xc2ba
cmpl $0x0, -0xc(%rbp)
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0xc2e7
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x15(%rbp)
je 0xc2dc
cmpl $0x0, -0xc(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: do_shift
static int
do_shift(int op)
{	int v, w;

	sh_err++;
	w = interpret();
	v = interpret();
	sh_err--;

	if (w <= 0)
		strcpy(err_s, "shift by non-positive number");
	else if (w >= sizeof(long)*8)
		strcpy(err_s, "shift in preprocessor directive causes integer overflow");

	if (sh_err == 0
	&&  strlen(err_s) > 0)
	{	fprintf(stderr, "%s,%d: warning, %s\n",
			filename, lineno, err_s);
	}

	return (op == LS) ? (v << w) : (v >> w);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0xceaf(%rip), %eax      # 0x191b0
addl $0x1, %eax
movl %eax, 0xcea6(%rip)      # 0x191b0
callq 0xb970
movl %eax, -0xc(%rbp)
callq 0xb970
movl %eax, -0x8(%rbp)
movl 0xce90(%rip), %eax      # 0x191b0
addl $-0x1, %eax
movl %eax, 0xce87(%rip)      # 0x191b0
cmpl $0x0, -0xc(%rbp)
jg 0xc344
leaq 0xc26a(%rip), %rdi      # 0x185a0
leaq 0x558f(%rip), %rsi      # 0x118cc
callq 0x4060
jmp 0xc363
movslq -0xc(%rbp), %rax
cmpq $0x40, %rax
jb 0xc361
leaq 0xc24b(%rip), %rdi      # 0x185a0
leaq 0x558d(%rip), %rsi      # 0x118e9
callq 0x4060
jmp 0xc363
cmpl $0x0, 0xce46(%rip)      # 0x191b0
jne 0xc3b0
leaq 0xc22d(%rip), %rdi      # 0x185a0
callq 0x4080
cmpq $0x0, %rax
jbe 0xc3b0
movq 0x7c73(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x7d61(%rip), %rax      # 0x140f0
movq (%rax), %rdx
leaq 0x8bf7(%rip), %rax      # 0x14f90
movl (%rax), %ecx
leaq 0x557f(%rip), %rsi      # 0x11921
leaq 0xc1f7(%rip), %r8       # 0x185a0
movb $0x0, %al
callq 0x4110
cmpl $0x1c, -0x4(%rbp)
jne 0xc3c3
movl -0x8(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x10(%rbp)
jmp 0xc3ce
movl -0x8(%rbp), %eax
movl -0xc(%rbp), %ecx
sarl %cl, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: do_colon
static void
do_colon(void)
{	int v, w, x;
	char err_t[1024];
	char err_f[1024];
	char err_o[1024];

	strcpy(err_o, err_s);

	sh_err++;
	v = interpret();	/* the else value */
	strcpy(err_f, err_s);	/* remember any error conditions */

	assert(valstack[--valptr].tok == QUEST);

	w = interpret();	/* the then value */
	strcpy(err_t, err_s);	/* remember any error conditions */
	sh_err--;

	x = interpret();	/* the condition */

	if (x)
	{	if (strlen(err_t) > 0)
		{	if (sh_err == 0)
				fatal_error(err_t);
			else
				strcpy(err_o, err_t);
		}
	} else
	{	if (strlen(err_f) > 0)
		{	if (sh_err == 0)
				fatal_error(err_f);
			else
				strcpy(err_o, err_f);
	}	}

	strcpy(err_s, err_o);
	emit(VAL, x?w:v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc20, %rsp            # imm = 0xC20
leaq -0xc10(%rbp), %rdi
leaq 0xc1a7(%rip), %rsi      # 0x185a0
callq 0x4060
movl 0xcdac(%rip), %eax      # 0x191b0
addl $0x1, %eax
movl %eax, 0xcda3(%rip)      # 0x191b0
callq 0xb970
movl %eax, -0x4(%rbp)
leaq -0x810(%rbp), %rdi
leaq 0xc17d(%rip), %rsi      # 0x185a0
callq 0x4060
movl 0xc57e(%rip), %eax      # 0x189ac
addl $-0x1, %eax
movl %eax, 0xc575(%rip)      # 0x189ac
movslq %eax, %rcx
leaq 0xc56f(%rip), %rax      # 0x189b0
cmpl $0x1e, 0x4(%rax,%rcx,8)
jne 0xc44a
jmp 0xc469
leaq 0x54e4(%rip), %rdi      # 0x11935
leaq 0x52cb(%rip), %rsi      # 0x11723
movl $0x161, %edx            # imm = 0x161
leaq 0x54f1(%rip), %rcx      # 0x11955
callq 0x40c0
callq 0xb970
movl %eax, -0x8(%rbp)
leaq -0x410(%rbp), %rdi
leaq 0xc121(%rip), %rsi      # 0x185a0
callq 0x4060
movl 0xcd26(%rip), %eax      # 0x191b0
addl $-0x1, %eax
movl %eax, 0xcd1d(%rip)      # 0x191b0
callq 0xb970
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xc4e1
leaq -0x410(%rbp), %rdi
callq 0x4080
cmpq $0x0, %rax
jbe 0xc4df
cmpl $0x0, 0xccf6(%rip)      # 0x191b0
jne 0xc4ca
leaq -0x410(%rbp), %rdi
callq 0x42b0
jmp 0xc4dd
leaq -0xc10(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x4060
jmp 0xc4df
jmp 0xc521
leaq -0x810(%rbp), %rdi
callq 0x4080
cmpq $0x0, %rax
jbe 0xc51f
cmpl $0x0, 0xccb6(%rip)      # 0x191b0
jne 0xc50a
leaq -0x810(%rbp), %rdi
callq 0x42b0
jmp 0xc51d
leaq -0xc10(%rbp), %rdi
leaq -0x810(%rbp), %rsi
callq 0x4060
jmp 0xc51f
jmp 0xc521
leaq -0xc10(%rbp), %rsi
leaq 0xc071(%rip), %rdi      # 0x185a0
callq 0x4060
cmpl $0x0, -0xc(%rbp)
je 0xc545
movl -0x8(%rbp), %eax
movl %eax, -0xc14(%rbp)
jmp 0xc54e
movl -0x4(%rbp), %eax
movl %eax, -0xc14(%rbp)
movl -0xc14(%rbp), %esi
movl $0x4, %edi
callq 0xc0f0
addq $0xc20, %rsp            # imm = 0xC20
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp4.c
// Function: mark_macro
static int
mark_macro(TS *s, int from, int len)
{	ML *m;

	for (m = s->ml; m; m = m->nxt)
		add_mark(from - s->space, len + s->space, m->m);

	return from+len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc823
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
subl 0x10(%rax), %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
addl 0x10(%rax), %esi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0xc960
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc7ee
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp4.c
// Function: show_mark
static void
show_mark(FILE *fd, POS *p)
{	int i;

	if (!p) return;
	show_mark(fd, p->nxt);
	p->nxt = free_mark;
	free_mark = p;

	if (verbose) fprintf(fd, "      ");

	for (i = 0; i < p->from; i++)
		fprintf(fd, " ");
	for (i = 0; i < p->len; i++)
		fprintf(fd, "-");

	if (p->m)
		fprintf(fd, " [%s,%d: %s]",
			p->m->fnm, p->m->ln, p->m->nm);
	else
		fprintf(fd, " [undefined]");

	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc84c
jmp 0xc959
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xc830
movq 0xc95c(%rip), %rcx      # 0x191c0
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xc949(%rip)      # 0x191c0
leaq 0x9732(%rip), %rax      # 0x15fb0
cmpl $0x0, (%rax)
je 0xc895
movq -0x8(%rbp), %rdi
leaq 0x515e(%rip), %rsi      # 0x119ec
movb $0x0, %al
callq 0x4110
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xc8c4
movq -0x8(%rbp), %rdi
leaq 0x513f(%rip), %rsi      # 0x119f1
movb $0x0, %al
callq 0x4110
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc89c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xc8f4
movq -0x8(%rbp), %rdi
leaq 0x4bc7(%rip), %rsi      # 0x114a9
movb $0x0, %al
callq 0x4110
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc8cb
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc935
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %r8
leaq 0x50c7(%rip), %rsi      # 0x119f3
movb $0x0, %al
callq 0x4110
jmp 0xc947
movq -0x8(%rbp), %rdi
leaq 0x50c0(%rip), %rsi      # 0x11a00
movb $0x0, %al
callq 0x4110
movq -0x8(%rbp), %rdi
leaq 0x46c4(%rip), %rsi      # 0x11016
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_cpp4.c
// Function: add_mark
static void
add_mark(int from, int len, MD *m)
{	POS *p;

	for (p = markings; p; p = p->nxt)
		if (p->m == m
		&&  p->from + p->len == from)
		{	p->len += len;
			return;
		}

	if (free_mark)
	{	p = free_mark;
		free_mark = free_mark->nxt;
		memset(p, 0, sizeof(POS));
	} else
		p = (POS *) emalloc(sizeof(POS));

	p->from = from;
	p->len  = len;
	p->m = m;
	p->nxt = markings;
	markings = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq 0xc83f(%rip), %rax      # 0x191b8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc9c6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xc9b6
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
addl 0x4(%rcx), %eax
cmpl -0x4(%rbp), %eax
jne 0xc9b6
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
jmp 0xca46
jmp 0xc9b8
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc97d
cmpq $0x0, 0xc7f2(%rip)      # 0x191c0
je 0xc9ff
movq 0xc7e9(%rip), %rax      # 0x191c0
movq %rax, -0x18(%rbp)
movq 0xc7de(%rip), %rax      # 0x191c0
movq 0x10(%rax), %rax
movq %rax, 0xc7d3(%rip)      # 0x191c0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x40d0
jmp 0xca0d
movl $0x18, %edi
callq 0x4320
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0xc785(%rip), %rcx      # 0x191b8
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0xc772(%rip)      # 0x191b8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)