LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/ast.c
// Function: call_addarg
void call_addarg(struct call *c, struct expr *e)
{
	c->argc++;
	if (!c->argv) c->argv = malloc(sizeof(struct expr *));
	else c->argv = realloc(c->argv, sizeof(struct expr*)*c->argc);
	c->argv[c->argc-1] = e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x7c1d
movl $0x8, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x7c40
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rsi
shlq $0x3, %rsi
callq 0x20f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/ast.c
// Function: block_init
struct stmt *block_init()
{
	struct block *b = malloc(sizeof(struct block));

	b->scope = NULL;
	b->stmt_list = NULL;
	b->num_stmt = 0;

	return node_init(node_block, b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x20e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rsi
movl $0x9, %edi
callq 0x75d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/ast.c
// Function: binop_init
struct expr *binop_init(enum operator   op, struct expr *lhs,
			struct expr *rhs)
{
	struct binop *b = malloc(sizeof(struct binop));
	b->lhs = lhs, b->rhs = rhs;
	b->op = op;
	return node_init(node_binop, b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rsi
movl $0x6, %edi
callq 0x75d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/ast.c
// Function: unop_init
struct expr *unop_init(enum operator   op, struct expr *term)
{
	struct unop *u = malloc(sizeof(struct unop));
	u->term = term;
	u->op = op;
	return node_init(node_unop, u);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x20e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rsi
movl $0x5, %edi
callq 0x75d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/ast.c
// Function: value_ident
struct expr *value_ident(const char *ident)
{
	union value *v = malloc(sizeof(union value));
	int len = strlen(ident);
	v->ident = malloc(len + 1);
	memcpy(v->ident, ident, len);
	v->ident[len] = 0;
	return node_init(node_ident, v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, %edi
callq 0x20e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2050
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x20d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rsi
movl $0x3, %edi
callq 0x75d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/cdecl.c
// Function: parse_declarator
int parse_declarator(struct parser *p, struct declaration *decl)
{
	struct type *t1 = NULL;
	while (match(p, t_asterisk))
		t1 = types_merge(t1, type_init(type_ptr));
	if (parse_dir_declarator(p, decl)) {
		decl->type = types_merge(decl->type, t1);
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xf, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0x8290
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0xb0a0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xb0e0
movq %rax, -0x20(%rbp)
jmp 0x8258
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7ed0
cmpl $0x0, %eax
je 0x82c7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xb0e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x82ce
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/cdecl.c
// Function: parse_param
struct declaration *parse_param(struct parser *p)
{
	enum type_specifier dtype = type_void;
	if (match(p, t_int))
		dtype = type_int;
	if (match(p, t_char))
		dtype = type_char;
	if (!dtype)
		return NULL;	/*technically wrong, types aren't required by the grammar */
	struct declaration *decl = parse_init_declarator(p, dtype);
	return decl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0x830e
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0x8329
movl $0x2, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x8339
movq $0x0, -0x8(%rbp)
jmp 0x8351
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8360
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/cdecl.c
// Function: parse_init_declarator
struct declaration *parse_init_declarator(struct parser *p,
					  enum type_specifier dtype)
{
	struct declaration *decl;
	decl = malloc(sizeof(struct declaration));
	decl->initializer = NULL;
	decl->ident = NULL;
	decl->type = NULL;
	if (!parse_declarator(p, decl)) {
		free(decl);
		return 0;
	}

	struct type *decldtype = type_init(type_datatype);
	decldtype->info.data_type = dtype;
	decl->type = types_merge(decl->type, decldtype);
	return decl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x18, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8240
cmpl $0x0, %eax
jne 0x83c5
movq -0x20(%rbp), %rdi
callq 0x2030
movq $0x0, -0x8(%rbp)
jmp 0x83fd
xorl %edi, %edi
callq 0xb0a0
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xb0e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/cdecl.c
// Function: parse_declaration
struct stmt *parse_declaration(struct parser *p)
{
	enum type_specifier dtype = type_void;
	if (match(p, t_int))
		dtype = type_int;
	if (match(p, t_char))
		dtype = type_char;
	if (!dtype)
		return NULL;	/*technically wrong, types aren't required by the grammar */
	struct declaration *decl = parse_init_declarator(p, dtype);
	set_type(get_scope(p), decl->ident, decl->type);
	if (match(p, t_semic))
		return node_init(node_decl, decl);
	if (!match(p, t_equal))
		syntax_error(p,
			     "Expected assignment expression after declaration");
	struct expr *e = parse_asn_expr(p);
	if (!e)
		syntax_error(p, "Invalid initializer after declaration");
	decl->initializer = e;
	if (!match(p, t_semic))
		syntax_error(p, "Expected ';' after initializer");
	return node_init(node_decl, decl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0x843e
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0x8459
movl $0x2, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x846c
movq $0x0, -0x8(%rbp)
jmp 0x8551
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8360
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xac40
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0xaea0
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0x84c7
movq -0x20(%rbp), %rsi
movl $0xc, %edi
callq 0x75d0
movq %rax, -0x8(%rbp)
jmp 0x8551
movq -0x10(%rbp), %rdi
movl $0x13, %esi
callq 0xaab0
cmpq $0x0, %rax
jne 0x84eb
movq -0x10(%rbp), %rdi
leaq 0x411a(%rip), %rsi      # 0xc600
callq 0xabb0
movq -0x10(%rbp), %rdi
callq 0x9aa0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x850f
movq -0x10(%rbp), %rdi
leaq 0x4127(%rip), %rsi      # 0xc631
callq 0xabb0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0xaab0
cmpq $0x0, %rax
jne 0x853f
movq -0x10(%rbp), %rdi
leaq 0x411d(%rip), %rsi      # 0xc657
callq 0xabb0
movq -0x20(%rbp), %rsi
movl $0xc, %edi
callq 0x75d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/checker.c
// Function: type_error
void type_error(struct node *parent, struct type *a, struct type *b)
{
	printf("Incompatable types ");
	printf("\"");
	printf("with types \"");
	print_type(a);
	printf("\" and \"");
	print_type(b);
	printf("\" in expression:\n");
	node_debug(parent);
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x3efd(%rip), %rdi      # 0xc6e8
movb $0x0, %al
callq 0x2060
leaq 0x3f16(%rip), %rdi      # 0xc70f
movb $0x0, %al
callq 0x2060
leaq 0x3ef5(%rip), %rdi      # 0xc6fc
movb $0x0, %al
callq 0x2060
movq -0x10(%rbp), %rdi
callq 0xb460
leaq 0x3eeb(%rip), %rdi      # 0xc709
movb $0x0, %al
callq 0x2060
movq -0x18(%rbp), %rdi
callq 0xb460
leaq 0x3edc(%rip), %rdi      # 0xc711
movb $0x0, %al
callq 0x2060
movq -0x8(%rbp), %rdi
callq 0x29f0
leaq 0x3ba3(%rip), %rdi      # 0xc3ef
movb $0x0, %al
callq 0x2060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/checker.c
// Function: rank
int rank(struct type *a)
{
	if (!a) return 0;
	if (!a->type == type_datatype) return 0;
	enum type_specifier dt = a->info.data_type;
	if (dt==type_char) return 1;
	if (dt==type_int) return 2;
	if (dt==type_long) return 3;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8878
movl $0x0, -0x4(%rbp)
jmp 0x88d5
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8898
movl $0x0, -0x4(%rbp)
jmp 0x88d5
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x88b0
movl $0x1, -0x4(%rbp)
jmp 0x88d5
cmpl $0x1, -0x14(%rbp)
jne 0x88bf
movl $0x2, -0x4(%rbp)
jmp 0x88d5
cmpl $0x4, -0x14(%rbp)
jne 0x88ce
movl $0x3, -0x4(%rbp)
jmp 0x88d5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/checker.c
// Function: implicit_cast
int implicit_cast(struct node **a, struct node **b, int favor)
{
	struct type *ta = TYPE(*a), *tb = TYPE(*b);
	/*Integer promotion*/
	int ra = rank(ta), rb = rank(tb);
	if (ra && rb) {
		if ((ra > rb && favor == NEUTRAL) || favor == LHS) {
			if (favor == LHS && rb > ra) {
				printf("Warning: Possible data loss in implicit cast from ");
				print_type(ta);
				printf(" to ");
				print_type(tb);
				printf("\n");
			}

			return explicit_cast(ta, b);
		} else if ((rb > ra && favor == NEUTRAL) || favor == RHS) {
			printf("Integer promotion\n");
			return explicit_cast(tb, a);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8860
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x8860
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x89eb
cmpl $0x0, -0x38(%rbp)
je 0x89eb
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jle 0x8951
cmpl $0x3, -0x1c(%rbp)
je 0x8957
cmpl $0x0, -0x1c(%rbp)
jne 0x89b3
cmpl $0x0, -0x1c(%rbp)
jne 0x89a1
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jle 0x89a1
leaq 0x3db7(%rip), %rdi      # 0xc723
movb $0x0, %al
callq 0x2060
movq -0x28(%rbp), %rdi
callq 0xb460
leaq 0x3dd3(%rip), %rdi      # 0xc756
movb $0x0, %al
callq 0x2060
movq -0x30(%rbp), %rdi
callq 0xb460
leaq 0x3a55(%rip), %rdi      # 0xc3ef
movb $0x0, %al
callq 0x2060
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8a00
movl %eax, -0x4(%rbp)
jmp 0x89f2
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jle 0x89c1
cmpl $0x3, -0x1c(%rbp)
je 0x89c7
cmpl $0x1, -0x1c(%rbp)
jne 0x89e7
leaq 0x3d8d(%rip), %rdi      # 0xc75b
movb $0x0, %al
callq 0x2060
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8a00
movl %eax, -0x4(%rbp)
jmp 0x89f2
jmp 0x89e9
jmp 0x89eb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/checker.c
// Function: explicit_cast
int explicit_cast(struct type *a, struct node **b)
{
	struct node *cast;
	struct type *tb = TYPE(*b);
	int ra = rank(a), rb = rank(tb);
	/*Scalar cast*/
	if (ra && rb) {
		cast = node_init(node_cast, *b);
		TYPE(cast) = type_copy(a);
		*b = cast;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8860
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8860
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x8a86
cmpl $0x0, -0x30(%rbp)
je 0x8a86
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edi
callq 0x75d0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb1f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x8a8d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/lexer.c
// Function: tokenify
struct token **tokenify(char *stream, int *numt)
{
	if (!stream)
		return NULL;
	struct token **tokens = NULL;

	int tlen = 0, numtok = 0, ln = 0;
	char *save = stream, *tok = NULL, *ls = stream;
	enum token_type t;
	while ((t = lex_r(&save, &tlen, &ls, &ln))) {
		tok = malloc(tlen + 1);
		memcpy(tok, save - tlen, tlen);
		tok[tlen] = 0;
		numtok++;
		struct token *token = malloc(sizeof(struct token));
		token->tok = tok, token->type = t;
		token->col = save - ls, token->line = ln;
		if (!tokens)
			tokens = malloc(sizeof(struct token *));
		else
			tokens =
			    realloc(tokens,
				    sizeof(struct token *) * numtok);
		tokens[numtok - 1] = token;
	}
	*numt = numtok;
	return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x93d4
movq $0x0, -0x8(%rbp)
jmp 0x9506
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
callq 0x9510
movl %eax, -0x4c(%rbp)
cmpl $0x0, %eax
je 0x94f5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x20e0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movslq -0x24(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movslq -0x24(%rbp), %rdx
callq 0x20d0
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl $0x18, %edi
callq 0x20e0
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, (%rax)
movl -0x4c(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x2c(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0xc(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x94c6
movl $0x8, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
jmp 0x94db
movq -0x20(%rbp), %rdi
movslq -0x28(%rbp), %rsi
shlq $0x3, %rsi
callq 0x20f0
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdx
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x9409
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_primary
struct expr *parse_primary(struct parser *p)
{
	struct token *t;
	if ((t = match(p, t_ident)))
		return value_ident(t->tok);
	if ((t = match(p, t_numeric)))
		return value_num(t->tok);
	if (match(p, t_lparen)) {
		struct expr *e;
		if ((e = parse_expr(p))) {
			if (!match(p, t_rparen))
				syntax_error(p,
					     "Missing right parentheses");
			return e;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0xaab0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x97c9
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x7e00
movq %rax, -0x8(%rbp)
jmp 0x9852
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xaab0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x97f3
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x7e80
movq %rax, -0x8(%rbp)
jmp 0x9852
movq -0x10(%rbp), %rdi
movl $0x14, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0x984a
movq -0x10(%rbp), %rdi
callq 0x9860
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x9848
movq -0x10(%rbp), %rdi
movl $0x15, %esi
callq 0xaab0
cmpq $0x0, %rax
jne 0x983e
movq -0x10(%rbp), %rdi
leaq 0x305f(%rip), %rsi      # 0xc898
callq 0xabb0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9852
jmp 0x984a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_asn_expr
struct expr *parse_asn_expr(struct parser *p)
{
	struct expr *v;
	struct token *t;
	int s = save(p);
	if ((v = parse_unary(p))) {
		if ((t = match(p, t_equal))) {
			struct expr *rhs;
			if ((rhs = parse_asn_expr(p))) {
				return binop_init(dec_oper(t->tok), v,
						  rhs);
			}
			syntax_error(p,
				     "Missing right hand side in assignment operation");
		}
		node_free(v);
	}
	restore(p, s);
	if ((v = parse_or_expr(p)))
		return v;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9b70
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9b2e
movq -0x10(%rbp), %rdi
movl $0x13, %esi
callq 0xaab0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x9b25
movq -0x10(%rbp), %rdi
callq 0x9aa0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x9b15
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xb6c0
movl %eax, %edi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7d50
movq %rax, -0x8(%rbp)
jmp 0x9b5d
movq -0x10(%rbp), %rdi
leaq 0x2e4e(%rip), %rsi      # 0xc96e
callq 0xabb0
movq -0x18(%rbp), %rdi
callq 0x7660
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xa0e0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9b55
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9b5d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_unary
struct expr *parse_unary(struct parser *p)
{
	struct token *t;
	struct expr *u;
	if ((u = parse_postfix(p)))
		return u;
	/*Ambiguous operators, so specify types manually */
	if ((t = match(p, t_inc)) || (t = match(p, t_dec))) {
		if ((u = parse_unary(p))) {
			return unop_init(t->type ==
					 t_inc ? o_preinc : o_predec, u);
		}
		syntax_error(p, "No unary expression after prefix");
	}
	if ((t = match(p, t_asterisk)) || (t = match(p, t_ampersand))) {
		if ((u = parse_unary(p))) {
			return unop_init(t->type ==
					 t_asterisk ? o_deref : o_ref, u);
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x98a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x9b9c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9c8b
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0xaab0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x9bcc
movq -0x10(%rbp), %rdi
movl $0x23, %esi
callq 0xaab0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9c18
movq -0x10(%rbp), %rdi
callq 0x9b70
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x9c08
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
movl $0x17, %edi
movl $0x15, %eax
cmpl $0x22, %ecx
cmovel %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x7db0
movq %rax, -0x8(%rbp)
jmp 0x9c8b
movq -0x10(%rbp), %rdi
leaq 0x2d1b(%rip), %rsi      # 0xc92e
callq 0xabb0
movq -0x10(%rbp), %rdi
movl $0xf, %esi
callq 0xaab0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x9c48
movq -0x10(%rbp), %rdi
movl $0x11, %esi
callq 0xaab0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9c83
movq -0x10(%rbp), %rdi
callq 0x9b70
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x9c81
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
movl $0x12, %edi
movl $0x13, %eax
cmpl $0xf, %ecx
cmovel %eax, %edi
movq -0x20(%rbp), %rsi
callq 0x7db0
movq %rax, -0x8(%rbp)
jmp 0x9c8b
jmp 0x9c83
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_mul_expr
struct expr *parse_mul_expr(struct parser *p)
{
	struct expr *v = parse_unary(p);
	if (!v)
		return NULL;
	struct token *t;
	while ((t = match(p, t_asterisk)) || (t = match(p, t_rslash))) {
		struct expr *v2 = parse_unary(p);
		if (!v2)
			syntax_error(p, "Unexpected token in expression");
		v = binop_init(dec_oper(t->tok), v, v2);
	}
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9b70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9ccd
movq $0x0, -0x8(%rbp)
jmp 0x9d64
jmp 0x9ccf
movq -0x10(%rbp), %rdi
movl $0xf, %esi
callq 0xaab0
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
jne 0x9d0b
movq -0x10(%rbp), %rdi
movl $0x12, %esi
callq 0xaab0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x9d14
jmp 0x9d5c
movq -0x10(%rbp), %rdi
callq 0x9b70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9d38
movq -0x10(%rbp), %rdi
leaq 0x2c1c(%rip), %rsi      # 0xc94f
callq 0xabb0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xb6c0
movl %eax, %edi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7d50
movq %rax, -0x18(%rbp)
jmp 0x9ccf
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_add_expr
struct expr *parse_add_expr(struct parser *p)
{
	struct expr *v = parse_mul_expr(p);
	if (!v)
		return NULL;
	struct token *t;
	while ((t = match(p, t_plus)) || (t = match(p, t_minus))) {
		struct expr *v2 = parse_mul_expr(p);
		if (!v2)
			syntax_error(p, "Unexpected token in expression");
		v = binop_init(dec_oper(t->tok), v, v2);
	}
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9ca0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9d9d
movq $0x0, -0x8(%rbp)
jmp 0x9e34
jmp 0x9d9f
movq -0x10(%rbp), %rdi
movl $0xd, %esi
callq 0xaab0
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
jne 0x9ddb
movq -0x10(%rbp), %rdi
movl $0xe, %esi
callq 0xaab0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x9de4
jmp 0x9e2c
movq -0x10(%rbp), %rdi
callq 0x9ca0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9e08
movq -0x10(%rbp), %rdi
leaq 0x2b4c(%rip), %rsi      # 0xc94f
callq 0xabb0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xb6c0
movl %eax, %edi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7d50
movq %rax, -0x18(%rbp)
jmp 0x9d9f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_rel_expr
struct expr *parse_rel_expr(struct parser *p)
{
	struct expr *v = parse_add_expr(p);
	if (!v)
		return NULL;
	struct token *t;
	while ((t = match(p, t_gt)) || (t = match(p, t_lt))
	       || (t = match(p, t_lte)) || (t = match(p, t_gte))) {
		struct expr *v2 = parse_add_expr(p);
		if (!v2)
			syntax_error(p, "Unexpected token in expression");
		v = binop_init(dec_oper(t->tok), v, v2);
	}
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9d70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9e6d
movq $0x0, -0x8(%rbp)
jmp 0x9f44
jmp 0x9e6f
movq -0x10(%rbp), %rdi
movl $0x1e, %esi
callq 0xaab0
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
jne 0x9eeb
movq -0x10(%rbp), %rdi
movl $0x1f, %esi
callq 0xaab0
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
jne 0x9eeb
movq -0x10(%rbp), %rdi
movl $0x21, %esi
callq 0xaab0
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
jne 0x9eeb
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0xaab0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x9ef4
jmp 0x9f3c
movq -0x10(%rbp), %rdi
callq 0x9d70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9f18
movq -0x10(%rbp), %rdi
leaq 0x2a3c(%rip), %rsi      # 0xc94f
callq 0xabb0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xb6c0
movl %eax, %edi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7d50
movq %rax, -0x18(%rbp)
jmp 0x9e6f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_eq_expr
struct expr *parse_eq_expr(struct parser *p)
{
	struct expr *v = parse_rel_expr(p);
	if (!v)
		return NULL;
	struct token *t;
	while ((t = match(p, t_eq)) || (t = match(p, t_neq))) {
		struct expr *v2 = parse_rel_expr(p);
		if (!v2)
			syntax_error(p, "Unexpected token in expression");
		v = binop_init(dec_oper(t->tok), v, v2);
	}
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9e40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9f7d
movq $0x0, -0x8(%rbp)
jmp 0xa014
jmp 0x9f7f
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0xaab0
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
jne 0x9fbb
movq -0x10(%rbp), %rdi
movl $0x1d, %esi
callq 0xaab0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x9fc4
jmp 0xa00c
movq -0x10(%rbp), %rdi
callq 0x9e40
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9fe8
movq -0x10(%rbp), %rdi
leaq 0x296c(%rip), %rsi      # 0xc94f
callq 0xabb0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xb6c0
movl %eax, %edi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7d50
movq %rax, -0x18(%rbp)
jmp 0x9f7f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_and_expr
struct expr *parse_and_expr(struct parser *p)
{
	struct expr *v = parse_eq_expr(p);
	if (!v)
		return NULL;
	while (match(p, t_ampersand) && match(p, t_ampersand)) {
		struct expr *v2 = parse_eq_expr(p);
		if (!v2)
			syntax_error(p, "Unexpected token in expression");
		v = binop_init(o_and, v, v2);
	}
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9f50
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa04d
movq $0x0, -0x8(%rbp)
jmp 0xa0d0
jmp 0xa04f
movq -0x10(%rbp), %rdi
movl $0x11, %esi
callq 0xaab0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x21(%rbp)
je 0xa083
movq -0x10(%rbp), %rdi
movl $0x11, %esi
callq 0xaab0
cmpq $0x0, %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xa08c
jmp 0xa0c8
movq -0x10(%rbp), %rdi
callq 0x9f50
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa0b0
movq -0x10(%rbp), %rdi
leaq 0x28a4(%rip), %rsi      # 0xc94f
callq 0xabb0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0xa, %edi
callq 0x7d50
movq %rax, -0x18(%rbp)
jmp 0xa04f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_or_expr
struct expr *parse_or_expr(struct parser *p)
{
	struct expr *v = parse_and_expr(p);
	if (!v)
		return NULL;
	while (match(p, t_vslash) && match(p, t_vslash)) {
		struct expr *v2 = parse_and_expr(p);
		if (!v2)
			syntax_error(p, "Unexpected token in expression");
		v = binop_init(o_or, v, v2);
	}
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa020
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa10d
movq $0x0, -0x8(%rbp)
jmp 0xa190
jmp 0xa10f
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0xaab0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x21(%rbp)
je 0xa143
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0xaab0
cmpq $0x0, %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xa14c
jmp 0xa188
movq -0x10(%rbp), %rdi
callq 0xa020
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa170
movq -0x10(%rbp), %rdi
leaq 0x27e4(%rip), %rsi      # 0xc94f
callq 0xabb0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0xb, %edi
callq 0x7d50
movq %rax, -0x18(%rbp)
jmp 0xa10f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_expr_stmt
struct stmt *parse_expr_stmt(struct parser *p)
{
	struct expr *e;
	if ((e = parse_expr(p))) {
		if (!match(p, t_semic))
			syntax_error(p, "Expected ';' after expression");
		return e;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9860
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa1ed
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0xaab0
cmpq $0x0, %rax
jne 0xa1e3
movq -0x10(%rbp), %rdi
leaq 0x27c0(%rip), %rsi      # 0xc99e
callq 0xabb0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa1f5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_block
struct stmt *parse_block(struct parser *p)
{
	if (match(p, t_lcbrack)) {
		struct stmt *block = block_init();
		push_scope(p);
		struct stmt *s;
		while ((s = parse_stmt(p)) || (s = parse_declaration(p)))
			block_addstmt(block->child, s);
		if (!match(p, t_rcbrack))
			syntax_error(p, "Expected '}'");
		((struct block *) block->child)->scope = pop_scope(p);
		return block;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0xa2cc
movb $0x0, %al
callq 0x7c70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa8e0
movq -0x10(%rbp), %rdi
callq 0xa2e0
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x21(%rbp)
jne 0xa26a
movq -0x10(%rbp), %rdi
callq 0x8410
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xa273
jmp 0xa286
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x7cc0
jmp 0xa238
movq -0x10(%rbp), %rdi
movl $0x19, %esi
callq 0xaab0
cmpq $0x0, %rax
jne 0xa2aa
movq -0x10(%rbp), %rdi
leaq 0x2717(%rip), %rsi      # 0xc9bc
callq 0xabb0
movq -0x10(%rbp), %rdi
callq 0xaa10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa2d4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_stmt
struct stmt *parse_stmt(struct parser *p)
{
	struct stmt *s;
	if ((s = parse_block(p)))
		return s;
	if ((s = parse_expr_stmt(p)))
		return s;
	if ((s = parse_cond(p)))
		return s;
	if ((s = parse_loop(p)))
		return s;
	if ((s = parse_jump(p)))
		return s;
	//if (s=parse_declaration(p)) return s;
	if (match(p, t_semic))
		return node_init(node_empty, NULL);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa200
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa30c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa3b0
movq -0x10(%rbp), %rdi
callq 0xa1a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa32c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa3b0
movq -0x10(%rbp), %rdi
callq 0xa5b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa349
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa3b0
movq -0x10(%rbp), %rdi
callq 0xa3c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa366
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa3b0
movq -0x10(%rbp), %rdi
callq 0xa6e0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa383
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa3b0
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0xa3a8
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x75d0
movq %rax, -0x8(%rbp)
jmp 0xa3b0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_cond
struct stmt *parse_cond(struct parser *p)
{
	struct expr *c;
	struct token *tif;
	if ((tif = match(p, t_if)) && match(p, t_lparen)) {
		if (!(c = parse_expr(p)))
			syntax_error(p, "Expected expression after '('");
		if (match(p, t_rparen)) {
			struct stmt *s, *s2;
			if ((s = parse_stmt(p))) {
				if (match(p, t_else)) {
					if ((s2 = parse_stmt(p)))
						return cond_init(c, s, s2);
				}
				return cond_init(c, s, NULL);
			}
			syntax_error(p, "No valid statement following if");
		}
		syntax_error(p, "Missing right parentheses");
	} else if (tif) {
		syntax_error(p, "Missing left parentheses");
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
callq 0xaab0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xa6b3
movq -0x10(%rbp), %rdi
movl $0x14, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0xa6b3
movq -0x10(%rbp), %rdi
callq 0x9860
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xa613
movq -0x10(%rbp), %rdi
leaq 0x2477(%rip), %rsi      # 0xca85
callq 0xabb0
movq -0x10(%rbp), %rdi
movl $0x15, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0xa6a1
movq -0x10(%rbp), %rdi
callq 0xa2e0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xa691
movq -0x10(%rbp), %rdi
movl $0x1b, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0xa67a
movq -0x10(%rbp), %rdi
callq 0xa2e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xa678
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7ac0
movq %rax, -0x8(%rbp)
jmp 0xa6d4
jmp 0xa67a
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x7ac0
movq %rax, -0x8(%rbp)
jmp 0xa6d4
movq -0x10(%rbp), %rdi
leaq 0x2407(%rip), %rsi      # 0xcaa3
callq 0xabb0
movq -0x10(%rbp), %rdi
leaq 0x21ec(%rip), %rsi      # 0xc898
callq 0xabb0
jmp 0xa6cc
cmpq $0x0, -0x20(%rbp)
je 0xa6ca
movq -0x10(%rbp), %rdi
leaq 0x2304(%rip), %rsi      # 0xc9c9
callq 0xabb0
jmp 0xa6cc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_jump
struct stmt *parse_jump(struct parser *p)
{
	struct token *t;
	if ((t=match(p, t_break)) && match(p, t_semic)) return node_init(node_break, NULL);
	else if (t) syntax_error(p, "Missing semicolon after break");

	if ((t=match(p, t_continue)) && match(p, t_semic)) return node_init(node_continue, NULL);
	else if (t) syntax_error(p, "Missing semicolon after continue");

	struct expr *e;
	if (match(p, t_return)) {
		e = parse_expr(p);
		if (!match(p, t_semic)) syntax_error(p, "Missing semicolon after return");
		return node_init(node_return, e);
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x26, %esi
callq 0xaab0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa72f
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0xa72f
movl $0xd, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x75d0
movq %rax, -0x8(%rbp)
jmp 0xa802
cmpq $0x0, -0x18(%rbp)
je 0xa746
movq -0x10(%rbp), %rdi
leaq 0x2382(%rip), %rsi      # 0xcac3
callq 0xabb0
jmp 0xa748
movq -0x10(%rbp), %rdi
movl $0x27, %esi
callq 0xaab0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa788
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0xa788
movl $0xe, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x75d0
movq %rax, -0x8(%rbp)
jmp 0xa802
cmpq $0x0, -0x18(%rbp)
je 0xa79f
movq -0x10(%rbp), %rdi
leaq 0x2347(%rip), %rsi      # 0xcae1
callq 0xabb0
jmp 0xa7a1
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0xaab0
cmpq $0x0, %rax
je 0xa7fa
movq -0x10(%rbp), %rdi
callq 0x9860
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0xaab0
cmpq $0x0, %rax
jne 0xa7e6
movq -0x10(%rbp), %rdi
leaq 0x2321(%rip), %rsi      # 0xcb02
callq 0xabb0
movq -0x20(%rbp), %rsi
movl $0xf, %edi
callq 0x75d0
movq %rax, -0x8(%rbp)
jmp 0xa802
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_unit
struct node *parse_unit(struct parser *p)
{
	struct node *unit=NULL;
	struct stmt *s;
	while ((s=parse_function(p))) {
		if (!unit) unit = unit_init();
		unit_add(UNIT(unit), s);
	}
	return unit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8560
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa85c
cmpq $0x0, -0x10(%rbp)
jne 0xa849
movb $0x0, %al
callq 0x7980
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x79c0
jmp 0xa824
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/pcommon.c
// Function: parser_init
struct parser *parser_init(struct token **tlist, int num_tokens)
{
	struct parser *p = malloc(sizeof(struct parser));

	p->scope_stk = NULL, p->num_stk = 0;
	push_scope(p);
	p->toks = tlist, p->len = num_tokens;
	p->cur = 0;

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x20, %edi
callq 0x20e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0xa8e0
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/pcommon.c
// Function: push_scope
void push_scope(struct parser *p)
{
	struct symbol_table *top = get_scope(p);
	p->num_stk++;
	if (!p->scope_stk)
		p->scope_stk = malloc(sizeof(struct symbol_table *));
	else
		p->scope_stk =
		    realloc(p->scope_stk,
			    sizeof(struct symbol_table *) * p->num_stk);
	p->scope_stk[p->num_stk - 1] = symbol_table_init(top);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xac40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xa926
movl $0x8, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa948
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x20f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0xac80
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/pcommon.c
// Function: parser_free
void parser_free(struct parser *p)
{
	for (int i = 0; i < p->len; i++) {
		free(p->toks[i]->tok);
		free(p->toks[i]);
	}
	symbol_table_free(pop_scope(p));
	free(p->toks);
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0xa9d7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa993
movq -0x8(%rbp), %rdi
callq 0xaa10
movq %rax, %rdi
callq 0xacf0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/pcommon.c
// Function: pop_scope
struct symbol_table *pop_scope(struct parser *p)
{
	if (!p->num_stk)
		return NULL;
	struct symbol_table *s = p->scope_stk[p->num_stk - 1];
	p->num_stk--;
	if (!p->num_stk) {
		free(p->scope_stk);
		p->scope_stk = NULL;
	} else {
		p->scope_stk =
		    realloc(p->scope_stk,
			    sizeof(struct symbol_table *) * p->num_stk);
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xaa30
movq $0x0, -0x8(%rbp)
jmp 0xaaa6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xaa7c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0xaa9e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x20f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/pcommon.c
// Function: consume
struct token *consume(struct parser *p)
{
	++p->cur;
	if (p->cur > p->len) {
		return NULL;
	}
	return p->toks[p->cur - 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jle 0xab7f
movq $0x0, -0x8(%rbp)
jmp 0xab9c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/pcommon.c
// Function: syntax_error
void syntax_error(struct parser *p, const char *msg)
{
	if (p->cur >= p->len)
		p->cur = p->len - 1;
	struct token *t = p->toks[p->cur];
	fprintf(stderr, "\n(%d,%d): error \"%s\" Near Token %s\n", t->col,
		t->line, msg, t->tok);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jl 0xabe1
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0x53f8(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %rax
movq (%rax), %r9
leaq 0x1efe(%rip), %rsi      # 0xcb21
movb $0x0, %al
callq 0x20b0
movl $0x1, %edi
callq 0x2100
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/symbols.c
// Function: symbol_table_init
struct symbol_table *symbol_table_init(struct symbol_table *parent)
{
	struct symbol_table *table = malloc(sizeof(struct symbol_table));

	table->parent = parent;
	table->syms = NULL, table->num_syms = 0;
	table->fp = parent ? parent->fp : 0;

	return table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x20e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
cmpq $0x0, -0x8(%rbp)
je 0xacd1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xacd9
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xacd9
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/symbols.c
// Function: symbol_table_free
void symbol_table_free(struct symbol_table *scope)
{
	if (!scope)
		return;

	for (int i = 0; i < scope->num_syms; i++) {
		free(scope->syms[i]->identifier);
		free(scope->syms[i]);
	}
	free(scope->syms);
	free(scope);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xad05
jmp 0xad67
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xad51
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xad0c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)