LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/src/test_host.c
// Function: main
int
main(int argc VL_UNUSED, char ** argv VL_UNUSED)
{
  char * string = vl_configuration_to_string_copy() ;
  assert (string) ;
  VL_PRINTF(string) ;
  vl_free(string) ;
  return 0 ;
}

// Assembly:
pushq %rbx
callq 0x1040
movq %rax, %rbx
callq 0x1030
movq %rax, %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq *%rcx
movq %rbx, %rdi
callq 0x1050
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: fatal_error
void
fatal_error(char *s)
{
	fprintf(stderr, "%s,%d: error: %s\n", filename, lineno, s);
	fprintf(stderr, "line: %s\n", ibuf);

	if (misra_rules > 1) show_violations();
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %r8
movq 0xd54c(%rip), %rbx      # 0x11ff8
movq (%rbx), %rdi
movq 0xd65a(%rip), %rdx      # 0x12110
movl 0xe3d4(%rip), %ecx      # 0x12e90
leaq 0x6762(%rip), %rsi      # 0xb225
xorl %eax, %eax
callq 0x4150
movq (%rbx), %rdi
leaq 0xa72f(%rip), %rsi      # 0xf203
leaq 0x109a5(%rip), %rdx     # 0x15480
xorl %eax, %eax
callq 0x4150
cmpl $0x2, 0xe3ab(%rip)      # 0x12e94
jl 0x4af0
callq 0xa380
movl $0x1, %edi
callq 0x41c0
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: emalloc
char *
emalloc(int n)
{	char *ptr;
#ifdef PC
	int m = n%sizeof(unsigned long);
	if (m != 0) n += sizeof(unsigned long)-m;
#endif
	ptr = (char *) malloc(n);
	if (!ptr) fatal_error("out of memory");
	memset(ptr, 0, n);
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x4160
testq %rax, %rax
je 0x4b23
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4100
leaq 0x670d(%rip), %rdi      # 0xb237
callq 0x4a9c
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: skipwhite
void
skipwhite(void)
{
	white = 0;
	while (*nowc == ' ' || *nowc == '\t')
	{	if (*nowc == ' ')
			white++;
		else
			white += 8-((nowc - lbuf + white)%8);
		nowc++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0xe1ae(%rip)      # 0x12e98
movq 0xe1af(%rip), %rax      # 0x12ea0
leaq 0x1(%rax), %rcx
leaq 0xe1b4(%rip), %rdx      # 0x12eb0
subq %rdx, %rax
xorl %edx, %edx
movzbl -0x1(%rcx), %esi
cmpl $0x9, %esi
je 0x4d13
cmpl $0x20, %esi
jne 0x4d42
incl %edx
jmp 0x4d2d
movslq %edx, %rdx
leaq (%rax,%rdx), %rsi
leal 0x7(%rsi), %edi
testq %rsi, %rsi
cmovnsl %esi, %edi
andl $-0x8, %edi
subl %esi, %edi
addl %edi, %edx
addl $0x8, %edx
movl %edx, 0xe165(%rip)      # 0x12e98
movq %rcx, 0xe166(%rip)      # 0x12ea0
incq %rcx
incq %rax
jmp 0x4d01
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: show_line
void
show_line(int d, FILE *fd)
{
	if (verbose)
		fprintf(fd, "[%d:%d] ", level, not_printing[level]);
	if (numbered)
		fprintf(fd, "%s,%d: ", filename, lineno);
	if (verbose || explanations
	|| (!d && !not_printing[level]))	/* not a directive */
	{	prep_line(start);
		fprintf(fd, "%s", lbuf);
	}
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0x0, 0xf158(%rip)      # 0x13eb0
je 0x4d7c
movslq 0xf153(%rip), %rdx      # 0x13eb4
leaq 0xf158(%rip), %rax      # 0x13ec0
movl (%rax,%rdx,4), %ecx
leaq 0x6585(%rip), %rsi      # 0xb2f7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4150
cmpl $0x0, 0xf53d(%rip)      # 0x142c0
je 0x4da3
movq 0xd384(%rip), %rdx      # 0x12110
movl 0xe0fe(%rip), %ecx      # 0x12e90
leaq 0x6567(%rip), %rsi      # 0xb300
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4150
cmpl $0x0, 0xf106(%rip)      # 0x13eb0
jne 0x4dce
testb $0x1, 0xf511(%rip)      # 0x142c4
jne 0x4dce
testl %r14d, %r14d
jne 0x4de9
movslq 0xf0f3(%rip), %rax      # 0x13eb4
leaq 0xf0f8(%rip), %rcx      # 0x13ec0
cmpl $0x0, (%rcx,%rax,4)
jne 0x4de9
movq 0xf4f3(%rip), %rdi      # 0x142c8
callq 0x4dfa
leaq 0xe0cf(%rip), %rdi      # 0x12eb0
movq %rbx, %rsi
callq 0x40f0
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x4120
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: prep_line
static void
prep_line(TS *from)
{	char tmp[1024];
	TS *n;
	int i;
	static int saw_else_last;

	strcpy(lbuf, "");
	for (n = from; n; n = n->nxt)
	{	for (i = n->space; i > 0; i--)
			strcat(lbuf, " ");

		switch (n->tok) {
		case NAME:
			strcat(lbuf, n->name);
			saw_else_last = (strcmp(n->name, "else") == 0);
			break;
		case VAL:
			sprintf(tmp, "%d", n->val);
			strcat(lbuf, tmp);
			saw_else_last = 0;
			break;
		case ECHAR:
			strcat(lbuf, "\\");
			saw_else_last = 0;
			/* fall thru */
		case CHAR:
			sprintf(tmp, "%c", n->val);
			strcat(lbuf, tmp);

			if (saw_else_last && n->val == ';')
			fprintf(stderr, "%s,%d: 'else' is followed by ';'\n",
				filename, lineno);
			saw_else_last = 0;
			break;
		case TPASTE:
			strcat(lbuf, "##");
			break;
		default:
			fprintf(stderr, "saw: ");
			tokfull(n, stderr);
			fprintf(stderr, "\n");
			fatal_error("unknown token");
	}	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movb $0x0, 0xe09b(%rip)      # 0x12eb0
testq %rdi, %rdi
je 0x4f3b
movq %rdi, %rbx
leaq 0xe088(%rip), %r14      # 0x12eb0
leaq 0x6259(%rip), %r15      # 0xb088
leaq -0x430(%rbp), %r12
movl 0x10(%rbx), %r13d
testl %r13d, %r13d
jle 0x4e5a
incl %r13d
movq %r14, %rdi
callq 0x40a0
movw $0x20, (%rax,%r14)
decl %r13d
cmpl $0x1, %r13d
jg 0x4e42
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0x4e9b
movslq (%r15,%rcx,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x41a0
movq 0x8(%rbx), %rdi
leaq 0x9e7e(%rip), %rsi      # 0xed02
callq 0x4140
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, 0xf466(%rip)      # 0x142fc
jmp 0x4f2e
cmpl $0x20, %eax
jne 0x4f4d
movq %r14, %rdi
callq 0x40a0
movw $0x2323, (%rax,%r14)    # imm = 0x2323
movb $0x0, 0x2(%rax,%r14)
jmp 0x4f2e
movq %r14, %rdi
callq 0x40a0
movw $0x5c, (%rax,%r14)
movl $0x0, 0xf428(%rip)      # 0x142fc
movb 0x4(%rbx), %al
movb %al, -0x430(%rbp)
movb $0x0, -0x42f(%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x41a0
cmpl $0x0, 0xf406(%rip)      # 0x142fc
je 0x4f24
cmpl $0x3b, 0x4(%rbx)
jne 0x4f24
callq 0x4210
jmp 0x4f24
movl 0x4(%rbx), %edx
movq %r12, %rdi
leaq 0x9996(%rip), %rsi      # 0xe8a8
xorl %eax, %eax
callq 0x41b0
movq %r14, %rdi
movq %r12, %rsi
callq 0x41a0
movl $0x0, 0xf3ce(%rip)      # 0x142fc
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x4e36
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x423a
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: release_all
static void
release_all(TS *s)
{
	if (!s) return;
	release_all(s->nxt);
	release_ml(s->ml);
	s->nxt = free_ts;
	free_ts = s;
}

// Assembly:
testq %rdi, %rdi
je 0x5547
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x550f
movq 0x18(%rbx), %rdi
callq 0x6139
movq 0xedca(%rip), %rax      # 0x14300
movq %rax, 0x28(%rbx)
movq %rbx, 0xedbf(%rip)      # 0x14300
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0xc445(%rip), %rsi      # 0x12200
testq %rsi, %rsi
je 0x5df2
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xc43a(%rip), %r14      # 0x12208
leaq 0xf6ab(%rip), %rbx      # 0x15480
movq %rbx, %rdi
callq 0x4070
callq 0x4f55
movq (%r14), %rsi
addq $0x8, %r14
testq %rsi, %rsi
jne 0x5dd5
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4afa
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4070
movq %r14, %rdi
movl $0x3d, %esi
callq 0x40b0
testq %rax, %rax
je 0x6009
movq %rax, %rbx
movq %rax, %r15
movb $0x0, (%rbx)
movq %r14, %rdi
callq 0x6b37
incq %rbx
movb $0x3d, (%r15)
movl $0x0, 0xcebc(%rip)      # 0x12e98
callq 0x41f0
movq (%rax), %rax
movsbq 0x1(%r15), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x6013
movl $0x1, %edi
xorl %esi, %esi
callq 0x6c37
movq 0xe32d(%rip), %rax      # 0x14330
movq %rbx, 0x8(%rax)
jmp 0x6027
movq %r14, %rdi
callq 0x6b37
jmp 0x6027
movq %rbx, %rdi
callq 0x4190
movl $0x4, %edi
movl %eax, %esi
callq 0x6c37
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6ca3
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xe2d1(%rip), %r14      # 0x14318
testq %r14, %r14
je 0x6097
movq %rdi, %rbx
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x4140
testl %eax, %eax
je 0x607b
movq %r14, %r15
movq 0x28(%r14), %r14
testq %r14, %r14
je 0x6097
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x4140
testl %eax, %eax
jne 0x605e
jmp 0x607e
xorl %r15d, %r15d
leaq 0x28(%r15), %rax
testq %r15, %r15
movq 0x28(%r14), %rcx
leaq 0xe288(%rip), %rdx      # 0x14318
cmovneq %rax, %rdx
movq %rcx, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edi
callq 0x4b2f
movl (%r14), %eax
decl %eax
cmpl $0x3, %eax
ja 0x611c
leaq 0x5039(%rip), %rcx      # 0xb100
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rdx
leaq 0x8809(%rip), %rsi      # 0xe8e4
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4150
movl 0x4(%r14), %edx
leaq 0x87fe(%rip), %rsi      # 0xe8f2
jmp 0x610e
movl 0x4(%r14), %edx
leaq 0x87f9(%rip), %rsi      # 0xe8fa
jmp 0x610e
movl 0x4(%r14), %edx
leaq 0x87dd(%rip), %rsi      # 0xe8eb
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x4150
leaq 0x87de(%rip), %rdi      # 0xe901
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x41d0
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x6168
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6139
movq 0xe1b1(%rip), %rax      # 0x14308
movq %rax, 0x8(%rbx)
movq %rbx, 0xe1a6(%rip)      # 0x14308
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x41e0
testq %rax, %rax
je 0x624d
movq %rax, %r15
leaq 0x8787(%rip), %r12      # 0xe922
leaq 0x8784(%rip), %r13      # 0xe926
movq %rbx, -0x30(%rbp)
movq %r14, %rdi
movl $0x22, %esi
callq 0x40b0
testq %rax, %rax
je 0x6248
movq %rax, %rbx
cmpq %r15, %rax
ja 0x6248
leaq -0x1(%rbx), %rdi
movl $0x3, %edx
movq %r12, %rsi
callq 0x4060
testl %eax, %eax
je 0x6220
leaq -0x2(%rbx), %rdi
movl $0x4, %edx
movq %r13, %rsi
callq 0x4060
testl %eax, %eax
je 0x6220
incq %rbx
movq %rbx, %rdi
movl $0x22, %esi
callq 0x40b0
testq %rax, %rax
je 0x625e
movq %rax, %r14
incq %rbx
cmpb $0x5c, -0x1(%rax)
je 0x61f5
cmpq %r15, %r14
jae 0x6229
incq %r14
movq %r14, %rbx
jmp 0x6224
addq $0x2, %rbx
movq %rbx, %rdi
jmp 0x61a9
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x41e0
movq %rax, %r15
testq %rax, %rax
movl $0x0, %eax
jne 0x61a6
jmp 0x624f
movq %r15, %rax
jmp 0x624f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x86c6(%rip), %rdi      # 0xe92b
callq 0x4a9c
// File: /workspace/github_c_makefile_star2_O1/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
movq 0xcc2b(%rip), %rax      # 0x12ea0
movb (%rax), %cl
cmpb %dil, %cl
je 0x62c2
cmpb $0x5c, %cl
je 0x628a
movzbl %cl, %ecx
testl %ecx, %ecx
jne 0x6294
jmp 0x62a7
incq %rax
movq %rax, 0xcc0c(%rip)      # 0x12ea0
leaq 0x1(%rax), %rdx
movq %rdx, 0xcc01(%rip)      # 0x12ea0
movb 0x1(%rax), %cl
movq %rdx, %rax
jmp 0x6277
movslq 0xdc06(%rip), %rax      # 0x13eb4
leaq 0xdc0b(%rip), %rcx      # 0x13ec0
cmpl $0x0, (%rcx,%rax,4)
je 0x62cb
decq 0xcbde(%rip)            # 0x12ea0
incq 0xcbd7(%rip)            # 0x12ea0
popq %rbp
retq
callq 0x43cf
jmp 0x62bb
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x4, (%rdi)
jne 0x6322
movl 0x4(%rdi), %eax
movl %eax, 0xcbb0(%rip)      # 0x12e90
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x6321
cmpl $0x2, (%rax)
jne 0x6321
cmpl $0x22, 0x4(%rax)
jne 0x6321
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x6322
cmpl $0x1, (%rax)
jne 0x6322
movq 0x8(%rax), %rcx
movq %rcx, 0xbe03(%rip)      # 0x12110
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x6322
cmpl $0x2, (%rax)
jne 0x6322
cmpl $0x22, 0x4(%rax)
jne 0x6322
retq
pushq %rbp
movq %rsp, %rbp
callq 0x43f9
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
cmpl $0x1, (%rdi)
jne 0x656a
cmpl $0xff, 0xd98f(%rip)     # 0x13eb4
jge 0x6576
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6aa1
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6ad9
xorl %eax, %eax
testq %r14, %r14
sete %al
movslq 0xd964(%rip), %rcx      # 0x13eb4
leaq 0x1(%rcx), %rdx
movl %edx, 0xd95a(%rip)      # 0x13eb4
leaq 0xd95f(%rip), %rdx      # 0x13ec0
movl %eax, 0x4(%rdx,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x856a(%rip), %rdi      # 0xeadb
callq 0x4a9c
leaq 0x8585(%rip), %rdi      # 0xeb02
callq 0x4a9c
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
cmpl $0x1, (%rdi)
jne 0x6a11
movq %rdi, %rbx
cmpl $0x0, 0xc4d2(%rip)      # 0x12e94
je 0x69e3
cmpl $0x0, 0xd945(%rip)      # 0x14310
jle 0x69e3
leaq 0x82fe(%rip), %rdx      # 0xecd2
movl $0x13, %edi
movl $0x5, %esi
callq 0xa250
cmpl $0x0, 0xc4aa(%rip)      # 0x12e94
je 0x6a02
leaq 0x82d8(%rip), %rdx      # 0xeccb
movl $0x13, %edi
movl $0x6, %esi
callq 0xa250
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6036
leaq 0x82a1(%rip), %rdi      # 0xecb9
callq 0x4a9c
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: do_else
static void
do_else(TS *unused)
{
	if (level <= 0) fatal_error("unmatched #else");

	if (not_printing[level] < 2)
		not_printing[level] = 1 - not_printing[level];
	/* if it's 3 it remains unchanged */
}

// Assembly:
cmpl $0x0, 0xd46a(%rip)      # 0x13eb4
jle 0x6a6d
movslq 0xd461(%rip), %rax      # 0x13eb4
leaq 0xd466(%rip), %rcx      # 0x13ec0
movl (%rcx,%rax,4), %edx
cmpl $0x1, %edx
jg 0x6a6c
movl $0x1, %esi
subl %edx, %esi
movl %esi, (%rcx,%rax,4)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x827f(%rip), %rdi      # 0xecf7
callq 0x4a9c
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq 0xd869(%rip), %rbx      # 0x14318
testq %rbx, %rbx
je 0x6acf
movq %rdi, %r14
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4140
testl %eax, %eax
je 0x6ad1
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x6ab7
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x6afa
cmpq %r14, (%rax)
je 0x6b32
movq 0x8(%rax), %rax
jmp 0x6aea
movq 0xd807(%rip), %rax      # 0x14308
testq %rax, %rax
je 0x6b19
movq 0x8(%rax), %rcx
movq %rcx, 0xd7f7(%rip)      # 0x14308
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
jmp 0x6b23
movl $0x10, %edi
callq 0x4afa
movq %r14, (%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x30, %edi
callq 0x4afa
movq %rax, %rbx
movq %r14, %rdi
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4afa
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x4070
movl 0xc31e(%rip), %eax      # 0x12e90
movl %eax, 0x8(%rbx)
movq 0xb594(%rip), %rdi      # 0x12110
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4afa
movq %rax, 0x10(%rbx)
movq 0xb57c(%rip), %rsi      # 0x12110
movq %rax, %rdi
callq 0x4070
movq 0xd775(%rip), %rax      # 0x14318
movq %rax, 0x28(%rbx)
movq %rbx, 0xd76a(%rip)      # 0x14318
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xd760(%rip), %r12      # 0x14328
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %r12, %r12
je 0x6c28
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x7fc8(%rip), %r15      # 0xeba6
movq (%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x4140
testl %eax, %eax
je 0x6c26
movq %r14, %rdi
movq %r15, %rsi
callq 0x4140
testl %eax, %eax
jne 0x6c13
movq %r13, %rdi
leaq 0x7d47(%rip), %rsi      # 0xe951
callq 0x4140
testl %eax, %eax
je 0x6c26
incl %ebx
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x6bde
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6c28
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
movq 0xd6b6(%rip), %rax      # 0x14300
testq %rax, %rax
je 0x6c6a
movq 0x28(%rax), %rcx
movq %rcx, 0xd6a6(%rip)      # 0x14300
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x6c74
movl $0x30, %edi
callq 0x4afa
movl %r14d, (%rax)
movl 0xc21b(%rip), %ecx      # 0x12e98
movl %ecx, 0x10(%rax)
movl %ebx, 0x4(%rax)
movq 0xd6a6(%rip), %rcx      # 0x14330
movq %rcx, 0x28(%rax)
testq %rcx, %rcx
je 0x6c97
movq %rax, 0x20(%rcx)
movq %rax, 0xd692(%rip)      # 0x14330
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xd3eb(%rip)      # 0x15340
jle 0x7f70
xorl %r14d, %r14d
movl $0x9, %edi
callq 0x4040
incl %r14d
cmpl 0xd3d2(%rip), %r14d     # 0x15340
jl 0x7f5a
leaq 0x6ab8(%rip), %rdi      # 0xea2f
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x40c0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7fdb
movq %rdi, %r14
xorl %esi, %esi
callq 0x82c5
movq %rax, %rbx
movq $0x0, 0x18(%rax)
movq 0x18(%r14), %r15
testq %r15, %r15
je 0x7fc3
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x6ad9
movq 0x8(%r15), %r15
jmp 0x7fad
movq 0x28(%r14), %rdi
callq 0x7f85
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x7fdd
movq %rbx, 0x20(%rax)
jmp 0x7fdd
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %r15d
movq 0xc021(%rip), %rax      # 0x14300
testq %rax, %rax
je 0x82ff
movq 0x28(%rax), %rcx
movq %rcx, 0xc011(%rip)      # 0x14300
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x8309
movl $0x30, %edi
callq 0x4afa
movl %r15d, (%rax)
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movl 0x10(%r14), %ecx
movl %ecx, 0x10(%rax)
movq 0x18(%r14), %rcx
movq %rcx, 0x18(%rax)
movq %rbx, 0x20(%rax)
testq %rbx, %rbx
je 0x8337
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl 0x4(%rsi), %ebx
leaq 0xcff5(%rip), %rax      # 0x15348
movq (%rax), %rcx
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
jne 0x8353
movq 0x18(%rdi), %rax
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x8377
movq 0x8(%rax), %rax
incl %r14d
jmp 0x8369
movq 0x8(%rsi), %rdi
leaq 0x6824(%rip), %rsi      # 0xeba6
callq 0x4140
testl %eax, %eax
cmovel %r14d, %ebx
movq 0xcfb4(%rip), %rax      # 0x15348
testq %rax, %rax
sete %cl
je 0x83b8
testl %ebx, %ebx
je 0x83b8
decl %ebx
movq 0x10(%rax), %rax
subl $0x1, %ebx
setb %dl
testq %rax, %rax
sete %cl
je 0x83b8
testb %dl, %dl
je 0x83a2
testb %cl, %cl
jne 0x83c1
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6c32(%rip), %rdi      # 0xeffa
callq 0x4a9c
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movq %rdx, %r15
movl %esi, %r13d
movl %edi, %r14d
movq 0xbf12(%rip), %rbx      # 0x14300
testq %rbx, %rbx
je 0x840e
movq 0x28(%rbx), %rax
movq %rax, 0xbf02(%rip)      # 0x14300
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x841f
movl $0x30, %edi
movl %ecx, %ebx
callq 0x4afa
movl %ebx, %ecx
movq %rax, %rbx
movl %r14d, (%rbx)
movl %r13d, 0x4(%rbx)
testl %r12d, %r12d
je 0x8431
movq %r15, 0x8(%rbx)
jmp 0x8456
movq %r15, %rdi
movl %ecx, %r14d
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4afa
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x4070
movl %r14d, %ecx
movl %ecx, 0x10(%rbx)
movq 0xcef8(%rip), %rax      # 0x15358
testq %rax, %rax
je 0x8469
movq %rbx, 0x28(%rax)
movq %rax, 0x20(%rbx)
cmpq $0x0, 0xceeb(%rip)      # 0x15360
jne 0x847e
movq %rbx, 0xcee2(%rip)      # 0x15360
movq %rbx, 0xced3(%rip)      # 0x15358
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]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:
testq %rdi, %rdi
je 0x852c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movb %al, 0xceb8(%rip)       # 0x15371
movb %al, 0xcf31(%rip)       # 0x153f0
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x8567
leaq 0x2c5d(%rip), %rcx      # 0xb130
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %r13
leaq 0xcf09(%rip), %r15      # 0x153f0
leaq 0xce82(%rip), %r12      # 0x15370
movzbl (%r13), %eax
cmpl $0x22, %eax
je 0x8503
cmpl $0x5c, %eax
je 0x8503
testl %eax, %eax
jne 0x8512
jmp 0x8567
movq %r15, %rdi
callq 0x40a0
movw $0x5c, (%rax,%r15)
movb (%r13), %al
movb %al, 0xce54(%rip)       # 0x15370
movq %r15, %rdi
movq %r12, %rsi
callq 0x41a0
incq %r13
jmp 0x84ee
leaq 0x7065(%rip), %rax      # 0xf598
retq
movl 0x4(%rbx), %eax
cmpl $0x22, %eax
jne 0x85b4
movl 0x4(%rbx), %edx
leaq 0xceaa(%rip), %rdi      # 0x153f0
leaq 0x6ac0(%rip), %rsi      # 0xf00d
jmp 0x8560
movl 0x4(%rbx), %edx
leaq 0xce97(%rip), %rdi      # 0x153f0
leaq 0x6348(%rip), %rsi      # 0xe8a8
xorl %eax, %eax
callq 0x41b0
cmpq %r14, %rbx
je 0x858d
cmpl $0x0, 0x10(%rbx)
jle 0x858d
xorl %eax, %eax
leaq 0xcdf5(%rip), %rcx      # 0x15370
movb $0x20, (%rax,%rcx)
incq %rax
movslq 0x10(%rbx), %rdx
cmpq %rdx, %rax
jl 0x857b
jmp 0x858f
xorl %eax, %eax
leaq 0xcdda(%rip), %rdi      # 0x15370
movb $0x0, (%rax,%rdi)
leaq 0xce4f(%rip), %rsi      # 0x153f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41a0
movb %al, 0xce36(%rip)       # 0x153f0
movb $0x0, 0xce30(%rip)      # 0x153f1
jmp 0x8567
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movl $0xcccccccd, %r15d      # imm = 0xCCCCCCCD
testq %r14, %r14
je 0x862c
movl (%r14), %edx
movl 0x10(%r14), %ecx
leal 0x1(%rcx), %eax
cmpl $0x4, %edx
je 0x8608
cmpl $0x3, %edx
je 0x8601
cmpl $0x1, %edx
jne 0x8624
movq 0x8(%r14), %rdi
callq 0x40a0
jmp 0x8624
addl $0x2, %ecx
movl %ecx, %eax
jmp 0x8624
movl 0x4(%r14), %ecx
cmpl $0xa, %ecx
jl 0x8624
incl %eax
movl %ecx, %edx
imulq %r15, %rdx
shrq $0x23, %rdx
cmpl $0x63, %ecx
movl %edx, %ecx
ja 0x8611
movq 0x28(%r14), %r14
addl %eax, %ebx
jmp 0x85d8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %eax
testq %rdi, %rdi
je 0x8668
cmpq %rsi, %rdi
je 0x8668
movq 0x18(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x8668
cmpq %rdx, (%rcx)
je 0x8662
movq 0x8(%rcx), %rcx
jmp 0x8652
movq 0x28(%rdi), %rdi
jmp 0x863d
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x8734
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x40a0
cmpq $0x2, %rax
jb 0x8730
movq 0xcd97(%rip), %r14      # 0x15470
testq %r14, %r14
je 0x86f3
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
je 0x8730
movq 0x8(%r14), %r14
jmp 0x86d9
movl $0x10, %edi
callq 0x4afa
movq %rax, %r14
movq %rbx, %rdi
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4afa
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4070
movq 0xcd4b(%rip), %rax      # 0x15470
movq %rax, 0x8(%r14)
movq %r14, 0xcd40(%rip)      # 0x15470
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdd19(%rip), %rdx      # 0x16480
leaq 0xcd12(%rip), %rdi      # 0x15480
movl $0x1000, %esi           # imm = 0x1000
callq 0x4130
testq %rax, %rax
jne 0x8789
leaq 0x69ba(%rip), %rdi      # 0xf13e
callq 0x4a9c
incl 0xdcf9(%rip)            # 0x16488
popq %rbp
jmp 0x8792
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
leaq 0xcce0(%rip), %r14      # 0x15480
movq %r14, %rdi
callq 0x40a0
movq %rax, %rbx
cmpl $0x1000, %ebx           # imm = 0x1000
jl 0x87bf
leaq 0x6aa4(%rip), %rdi      # 0xf25e
callq 0x4a9c
cmpl $0x2, %ebx
jl 0x87f4
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movzbl -0x2(%rbx,%r14), %eax
cmpl $0x20, %eax
je 0x87da
cmpl $0x9, %eax
jne 0x87f4
movw $0xa, -0x2(%rbx,%r14)
leaq -0x1(%rbx), %rax
cmpq $0x2, %rbx
movq %rax, %rbx
jg 0x87ca
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x8f69
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rdi
callq 0x8e8c
movl $0x1, %r14d
testl %eax, %eax
jne 0x9012
movq %r15, %rdi
callq 0x40a0
movq %rax, %rbx
movq (%r12), %rdi
callq 0x40a0
leal (%rax,%rbx), %edi
addl $0x2, %edi
callq 0x4afa
movq %rax, %rbx
movq (%r12), %rdx
leaq 0x629f(%rip), %rsi      # 0xf189
xorl %r14d, %r14d
movq %rax, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x41b0
leaq 0x9f93(%rip), %rax      # 0x12e94
cmpl $0x0, (%rax)
je 0x8fad
leaq 0x6361(%rip), %rsi      # 0xf272
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
je 0x8f71
leaq 0x6362(%rip), %rsi      # 0xf286
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
je 0x8f84
leaq 0x6363(%rip), %rsi      # 0xf29a
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
je 0x8f97
leaq 0x6362(%rip), %rsi      # 0xf2ac
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
jne 0x8fad
leaq 0x6356(%rip), %rdx      # 0xf2b3
movl $0x14, %edi
movl $0xc, %esi
jmp 0x8fa8
xorl %r14d, %r14d
jmp 0x9012
leaq 0x6303(%rip), %rdx      # 0xf27b
movl $0x14, %edi
movl $0x4, %esi
jmp 0x8fa8
leaq 0x6304(%rip), %rdx      # 0xf28f
movl $0x14, %edi
movl $0x8, %esi
jmp 0x8fa8
leaq 0x6304(%rip), %rdx      # 0xf2a2
movl $0x14, %edi
movl $0x9, %esi
callq 0xa250
leaq 0x34c0(%rip), %rsi      # 0xc474
movq %rbx, %rdi
callq 0x4180
testq %rax, %rax
je 0x900a
movq %rax, %r15
leaq 0xaee5(%rip), %rax      # 0x13eb0
cmpl $0x2, (%rax)
jl 0x8fe1
leaq 0x61b8(%rip), %rdi      # 0xf18f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x40c0
movq %r15, %rdi
callq 0x4090
leaq 0x9120(%rip), %rax      # 0x12110
movq (%rax), %rdi
leaq 0x9e96(%rip), %rax      # 0x12e90
movl (%rax), %esi
movq %rbx, %rdx
callq 0x8a81
movl $0x1, %r14d
movq %rbx, %rdi
callq 0x4030
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x63c9(%rip), %r15      # 0xf404
movl $0x3ff, %r13d           # imm = 0x3FF
movl $0x7e0000, %ecx         # imm = 0x7E0000
movabsq $0x7e000000000000, %rdx # imm = 0x7E000000000000
xorl %ebx, %ebx
movzbl (%r14,%r12), %eax
testl %eax, %eax
je 0x90b0
cmpl $0x27, %eax
je 0x90b0
movsbl %al, %eax
shll $0x4, %ebx
addl %eax, %ebx
movzbl %al, %eax
addl $-0x30, %eax
cmpl $0x36, %eax
ja 0x9097
btq %rax, %r13
jb 0x908a
btq %rax, %rcx
jb 0x908f
btq %rax, %rdx
jae 0x9097
addl $-0x6b, %ebx
jmp 0x9092
addl $-0x30, %ebx
jmp 0x9092
addl $-0x4b, %ebx
incq %r12
jmp 0x9052
movq %r15, %rdi
callq 0x4a9c
movabsq $0x7e000000000000, %rdx # imm = 0x7E000000000000
movl $0x7e0000, %ecx         # imm = 0x7E0000
jmp 0x9092
testl %r12d, %r12d
je 0x90c6
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x478b
jmp 0x90b5
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r15d, %r15d
xorl %ebx, %ebx
movzbl (%r14,%r15), %eax
testl %eax, %eax
je 0x9117
cmpl $0x27, %eax
je 0x9117
movsbl %al, %edi
cmpl $0x3, %r15d
jb 0x90fd
shll $0x8, %ebx
addl %edi, %ebx
jmp 0x910b
leal (%rdi,%rbx,8), %ebx
movl %edi, %eax
andb $-0x8, %al
cmpb $0x30, %al
jne 0x9110
addl $-0x30, %ebx
incq %r15
jmp 0x90df
callq 0x47eb
jmp 0x910b
cmpl $0x4, %r15d
jae 0x912a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x47bb
jmp 0x911d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x9183
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x9183
cmpl $0x2, (%rbx)
jne 0x9183
cmpl $0x23, 0x4(%rbx)
jne 0x9183
cmpl $0x1, (%rax)
jne 0x9183
movq 0x8(%rax), %r14
leaq 0x5bb0(%rip), %rsi      # 0xed14
movq %r14, %rdi
callq 0x4140
testl %eax, %eax
je 0x918f
leaq 0x58d6(%rip), %rsi      # 0xea4d
movq %r14, %rdi
callq 0x4140
testl %eax, %eax
je 0x918f
leaq 0x631a(%rip), %rdi      # 0xf4a4
callq 0x4a9c
movb $0x0, 0xd30a(%rip)      # 0x164a0
movq 0x28(%rbx), %rax
movq %rax, 0xd6ff(%rip)      # 0x168a0
xorl %ecx, %ecx
testq %rax, %rax
je 0x91dd
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x91dd
movq %rax, 0xd6e8(%rip)      # 0x168a0
movl 0x4(%rax), %ecx
leaq 0xb136(%rip), %rdx      # 0x142f8
movl %ecx, (%rdx)
leaq 0xb119(%rip), %rdx      # 0x142e4
movb %cl, (%rdx)
movq 0x8(%rax), %rcx
leaq 0xb110(%rip), %rdx      # 0x142e8
movq %rcx, (%rdx)
movl (%rax), %ecx
movl %ecx, 0xd6c5(%rip)      # 0x168a8
movl $0x4, %edi
callq 0x926c
leaq 0xacbc(%rip), %r14      # 0x13eb0
cmpl $0x2, (%r14)
jl 0x9206
leaq 0x62bc(%rip), %rdi      # 0xf4bd
callq 0x95ad
cmpl $0x0, 0xd69b(%rip)      # 0x168a8
jne 0x9241
callq 0x96ee
cmpl $0x0, 0xd691(%rip)      # 0x168ac
jne 0x924d
movl %eax, %ebx
cmpl $0x2, (%r14)
jl 0x9235
leaq 0x62d1(%rip), %rdi      # 0xf4fd
movl %ebx, %esi
xorl %eax, %eax
callq 0x40c0
xorl %eax, %eax
testl %ebx, %ebx
setne %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x627c(%rip), %rdi      # 0xf4c4
callq 0x965f
leaq 0x627f(%rip), %rdi      # 0xf4d3
leaq 0x6284(%rip), %rsi      # 0xf4df
leaq 0x6287(%rip), %rcx      # 0xf4e9
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x40e0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5fc4(%rip), %rdi      # 0xf589
xorl %eax, %eax
callq 0x40c0
leaq 0x5fbb(%rip), %rdi      # 0xf58e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x40c0
cmpl $0x0, 0xd2c8(%rip)      # 0x168ac
jle 0x9647
leaq 0x5fa6(%rip), %rbx      # 0xf593
leaq 0xd2bc(%rip), %r12      # 0x168b0
movq 0x89d5(%rip), %r13      # 0x11fd0
leaq 0x5f97(%rip), %r14      # 0xf599
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x40c0
movl 0x4(%r12,%r15,8), %edi
movq (%r13), %rsi
callq 0x4b2f
movl (%r12,%r15,8), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x40c0
movl $0xa, %edi
callq 0x4040
incq %r15
movslq 0xd26a(%rip), %rax      # 0x168ac
cmpq %rax, %r15
jl 0x9605
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %r9
movq 0x8989(%rip), %rbx      # 0x11ff8
movq (%rbx), %rdi
leaq 0x8a97(%rip), %rax      # 0x12110
movq (%rax), %rdx
leaq 0x980d(%rip), %rax      # 0x12e90
movl (%rax), %ecx
leaq 0x5f12(%rip), %rsi      # 0xf59e
leaq 0xbded(%rip), %r8       # 0x15480
xorl %eax, %eax
callq 0x4150
movq (%rbx), %rcx
leaq 0x5f22(%rip), %rdi      # 0xf5c6
movl $0xc, %esi
movl $0x1, %edx
callq 0x41d0
movl 0xd1ef(%rip), %edi      # 0x168a8
movq (%rbx), %rsi
callq 0x4b2f
movq (%rbx), %rcx
leaq 0x51ff(%rip), %rdi      # 0xe8ca
movl $0x2, %esi
movl $0x1, %edx
callq 0x41d0
movq (%rbx), %rsi
xorl %edi, %edi
callq 0x4d44
movl $0x1, %edi
callq 0x41c0
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x2, %edi
je 0x9cbb
movslq 0xcc2b(%rip), %rax      # 0x168ac
leal 0x1(%rax), %ecx
leaq 0xcc25(%rip), %rdx      # 0x168b0
movl %edi, 0x4(%rdx,%rax,8)
movl %esi, (%rdx,%rax,8)
movl %ecx, 0xcc14(%rip)      # 0x168ac
cmpq $0xff, %rax
jge 0x9cda
leaq 0xa209(%rip), %rax      # 0x13eb0
cmpl $0x2, (%rax)
jl 0x9cb9
leaq 0x58d1(%rip), %rdi      # 0xf584
popq %rbp
jmp 0x95ad
popq %rbp
retq
leaq 0x586c(%rip), %rdi      # 0xf52e
leaq 0x5816(%rip), %rsi      # 0xf4df
leaq 0x588b(%rip), %rcx      # 0xf55b
movl $0x46, %edx
callq 0x40e0
leaq 0x5892(%rip), %rdi      # 0xf573
callq 0x965f
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
incl 0xd3b7(%rip)            # 0x170b0
callq 0x96ee
movl %eax, %ebx
decl 0xd3aa(%rip)            # 0x170b0
callq 0x96ee
movl %eax, %r15d
movl %r14d, %eax
xorl $0x1b, %eax
orl %r15d, %eax
je 0x9d2d
cmpl $0x1a, %r14d
sete %al
testl %r15d, %r15d
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x9d5d
movb $0x0, 0xc76c(%rip)      # 0x164a0
cmpl $0x1a, %r14d
jne 0x9d42
orl %ebx, %r15d
setne %al
jmp 0x9d4f
testl %ebx, %ebx
setne %cl
testl %r15d, %r15d
setne %al
andb %cl, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0xd34c(%rip)      # 0x170b0
jne 0x9d34
cmpb $0x0, 0xc733(%rip)      # 0x164a0
je 0x9d34
leaq 0xc72a(%rip), %rdi      # 0x164a0
callq 0x4a9c
jmp 0x9d34