LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: call_emit
struct ir_operand *call_emit(struct generator *context, struct call *c, int result)
{
	struct ir_stmt *s = ir_stmt_init();
	struct type *ct = TYPE(context->parent);
	/*If function has return type, then store result in register*/
	if (ct && ct->type == type_datatype) {
		if (ct->info.data_type != type_void) {
			s->result = from_reg(context->reg_cnt++);
		}
	}
	for (int i = c->argc-1; i >= 0; i--) {
		struct ir_stmt *p = ir_stmt_init();
		p->type = stmt_param;
		p->arg1 = from_cnum(i);
		p->arg2 = generate_from_node(c->argv[i], context, VALUE);
		emit(context, p);
	}
	s->type = stmt_call;
	s->arg1 = generate_from_node(c->func, context, ADDRESS);
	emit(context, s);
	return result != IGNORE ? copy(s->result) : NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x4(%rsp)
movq %rsi, %r12
movq %rdi, %r14
movl $0x38, %edi
callq 0x2100
movq %rax, %rcx
movl $0x0, (%rax)
addq $0x8, %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rcx)
movups %xmm0, 0x18(%rcx)
movq $0x0, 0x28(%rcx)
movq %rcx, 0x10(%rsp)
movl $0xffffffff, 0x30(%rcx) # imm = 0xFFFFFFFF
movq 0x20(%r14), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x4960
cmpl $0x0, 0x18(%rax)
jne 0x4960
cmpl $0x0, (%rax)
je 0x4960
movl (%r14), %ebx
leal 0x1(%rbx), %eax
movl %eax, (%r14)
movl $0x10, %edi
callq 0x2100
movq $0x0, (%rax)
movl %ebx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movslq (%r12), %rbp
testq %rbp, %rbp
jle 0x4a11
leaq 0x18(%r14), %rbx
decq %rbp
movabsq $0x400000002, %r15      # imm = 0x400000002
movl $0x38, %edi
callq 0x2100
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq $0x0, 0x28(%rax)
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movl $0x7, (%rax)
movl $0x10, %edi
callq 0x2100
movq %r15, (%rax)
movq %rbp, 0x8(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r12), %rax
movq (%rax,%rbp,8), %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x4161
movq %rax, 0x18(%r13)
movq %r13, %rdi
callq 0x545c
cmpq $0x0, 0x10(%r14)
je 0x49f6
movq (%rbx), %rax
movq %r13, 0x28(%rax)
movq %rax, 0x20(%r13)
jmp 0x49fa
movq %r13, 0x10(%r14)
movq %r13, (%rbx)
leaq -0x1(%rbp), %rax
incq %rbp
cmpq $0x1, %rbp
movq %rax, %rbp
jg 0x497e
movq 0x10(%rsp), %rbx
movl $0x2, (%rbx)
movq 0x8(%r12), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x4161
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x545c
cmpq $0x0, 0x10(%r14)
je 0x4a53
movq 0x18(%r14), %rax
addq $0x18, %r14
movq %rbx, 0x28(%rax)
movq %rax, 0x20(%rbx)
jmp 0x4a5b
movq %rbx, 0x10(%r14)
addq $0x18, %r14
movq %rbx, (%r14)
cmpl $0x3, 0x4(%rsp)
jne 0x4a76
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x53ee
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: ident_emit
struct ir_operand *ident_emit(struct generator *context, char *ident, int result)
{
	//if (result == IGNORE) return NULL;
	struct symbol *s = get_symbol(context->scope, ident);
	if (result == ADDRESS) return from_sym(s);
	/*Arrays are converted to pointers to the first member of the array*/
	if (TYPE(context->parent) && TYPE(context->parent)->type == type_array) {
		struct ir_stmt *stmt = ir_stmt_init();
		stmt->type = stmt_addr;
		stmt->result = from_reg(context->reg_cnt++);
		stmt->arg1 = from_sym(s);
		emit(context, stmt);
		return copy(stmt->result);
	}
	/*If the value is asked for then emit a load instruction with the symbol address*/
	struct ir_stmt *stmt = ir_stmt_init();
	stmt->type = stmt_load;
	stmt->result = from_reg(context->reg_cnt++);
	stmt->arg1 = from_sym(s);
	emit(context, stmt);
	return copy(stmt->result);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x7dfe
movq %rax, %r14
cmpl $0x1, %ebp
jne 0x4ac8
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x539a
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x4b0c
cmpl $0x2, 0x18(%rax)
jne 0x4b0c
movl $0x38, %edi
callq 0x2100
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
xorl %r12d, %r12d
movq %r12, 0x28(%rax)
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movl $0x13, (%rax)
jmp 0x4b38
movl $0x38, %edi
callq 0x2100
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
xorl %r12d, %r12d
movq %r12, 0x28(%rax)
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movl $0x11, (%rax)
movl (%rbx), %r13d
leal 0x1(%r13), %eax
movl %eax, (%rbx)
movl $0x10, %edi
callq 0x2100
movq %r12, (%rax)
movl %r13d, 0x8(%rax)
movq %rax, 0x8(%r15)
movq %r14, %rdi
callq 0x539a
movq %rax, 0x10(%r15)
movq %r15, %rdi
callq 0x545c
cmpq %r12, 0x10(%rbx)
je 0x4b82
movq 0x18(%rbx), %rax
addq $0x18, %rbx
movq %r15, 0x28(%rax)
movq %rax, 0x20(%r15)
jmp 0x4b8a
movq %r15, 0x10(%rbx)
addq $0x18, %rbx
movq %r15, (%rbx)
movq 0x8(%r15), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x53ee
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: from_cnum
struct ir_operand *from_cnum(long cnum)
{
	struct ir_operand *oper = malloc(sizeof(struct ir_operand));
	oper->size = INT_TYPE_SIZE;//Default constant size is integer
	oper->type = oper_cnum;
	oper->val.constant = cnum;
	return oper;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10, %edi
callq 0x2100
movabsq $0x400000002, %rcx      # imm = 0x400000002
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: emit_label
struct ir_stmt *emit_label(struct generator *context, int label)
{
	struct ir_stmt *stmt = ir_stmt_init();
	stmt->type = stmt_label;
	stmt->label = label;
	emit(context, stmt);
	return stmt;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0x38, %edi
callq 0x2100
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq $0x0, 0x28(%rax)
movl $0x1, (%rax)
movl %ebp, 0x30(%rax)
movq %rax, %rdi
callq 0x545c
cmpq $0x0, 0x10(%rbx)
je 0x51a4
movq 0x18(%rbx), %rax
addq $0x18, %rbx
movq %r14, 0x28(%rax)
movq %rax, 0x20(%r14)
jmp 0x51ac
movq %r14, 0x10(%rbx)
addq $0x18, %rbx
movq %r14, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: backpatch
void backpatch(struct ir_list **rlist, int label)
{
	if (!rlist) return;
	struct ir_list *list = *rlist;
	if (!list) return;
	for (int i = 0; i < list->num_stmt; i++)
		list->list[i]->label = label;
	free_list(list);
	*rlist = NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x5206
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x51ff
movslq 0x8(%r14), %rax
testq %rax, %rax
jle 0x51e8
movq (%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rdi
movl %esi, 0x30(%rdi)
incq %rdx
cmpq %rdx, %rax
jne 0x51d9
movq (%r14), %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2030
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: emit
void emit(struct generator *context, struct ir_stmt *stmt)
{
	eval_size(stmt);
	if (!context->head) {
		context->head = stmt;
		context->cur = stmt;
	} else {
		context->cur->next = stmt;
		stmt->prev = context->cur;
		context->cur = stmt;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x545c
cmpq $0x0, 0x10(%r14)
je 0x5232
movq 0x18(%r14), %rax
addq $0x18, %r14
movq %rbx, 0x28(%rax)
movq %rax, 0x20(%rbx)
jmp 0x523a
movq %rbx, 0x10(%r14)
addq $0x18, %r14
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: make_list
struct ir_list *make_list(struct ir_stmt *n)
{
	struct ir_list *list = malloc(sizeof(struct ir_list));
	list->list = malloc(sizeof(struct ir_stmt*));
	list->list[0] = n;
	list->num_stmt = 1;
	return list;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x2100
movq %rax, %r14
movl $0x8, %edi
callq 0x2100
movq %rax, (%r14)
movq %rbx, (%rax)
movl $0x1, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: emit_jump
struct ir_stmt *emit_jump(struct generator *context, int label, int conditional)
{
	struct ir_stmt *stmt = ir_stmt_init();
	if (conditional == CONDITIONAL)
		stmt->type = stmt_cgoto;
	else
		stmt->type = stmt_ugoto;
	stmt->label = label;
	emit(context, stmt);
	return stmt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl $0x38, %edi
callq 0x2100
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq $0x0, 0x28(%rax)
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
addl $0x3, %eax
movl %eax, (%r14)
movl %r15d, 0x30(%r14)
movq %r14, %rdi
callq 0x545c
cmpq $0x0, 0x10(%rbx)
je 0x52de
movq 0x18(%rbx), %rax
addq $0x18, %rbx
movq %r14, 0x28(%rax)
movq %rax, 0x20(%r14)
jmp 0x52e6
movq %r14, 0x10(%rbx)
addq $0x18, %rbx
movq %r14, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: merge
struct ir_list *merge(struct ir_list *list1, struct ir_list *list2)
{
	if (!list1 && list2) return list2;
	if (!list2 && list1) return list1;
	if (!list1 && !list2) return NULL;

	int os = list1->num_stmt;
	int ns = list1->num_stmt + list2->num_stmt;
	list1->num_stmt = ns;
	list1->list = realloc(list1->list, sizeof(struct ir_stmt*)*ns);
	for (int i = os; i < ns; i++) {
		list1->list[i] = list2->list[i-os];
	}
	free_list(list2);
	return list1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
je 0x5318
movq %r14, %rbx
jmp 0x538d
movq %rdi, %rbx
testq %r14, %r14
sete %al
testq %rdi, %rdi
setne %cl
testb %al, %cl
jne 0x538d
movq %rbx, %rax
orq %r14, %rax
je 0x538b
movslq 0x8(%rbx), %r15
movslq 0x8(%r14), %r13
leaq (%r15,%r13), %r12
movl %r12d, 0x8(%rbx)
movq (%rbx), %rdi
movq %r12, %rsi
shlq $0x3, %rsi
callq 0x2110
movq %rax, (%rbx)
testq %r13, %r13
jle 0x5379
movslq %r12d, %rax
xorl %ecx, %ecx
movq (%r14), %rdx
movq (%rdx,%rcx), %rdx
movq (%rbx), %rsi
movq %rdx, (%rsi,%r15,8)
incq %r15
addq $0x8, %rcx
cmpq %rax, %r15
jl 0x535f
movq (%r14), %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2030
jmp 0x538d
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: from_sym
struct ir_operand *from_sym(struct symbol *s)
{
	if (!s) {
		printf("Unresolved symbol!\n");
		exit (-1);
	}
	struct ir_operand *oper = malloc(sizeof(struct ir_operand));
	oper->size = s->size;
	oper->type = oper_sym;
	oper->val.sym = s;
	return oper;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x53bf
movq %rdi, %rbx
movl $0x10, %edi
callq 0x2100
movl 0x8(%rbx), %ecx
movl %ecx, 0x4(%rax)
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
leaq 0x4063(%rip), %rdi      # 0x9429
callq 0x2060
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: from_reg
struct ir_operand *from_reg(int reg)
{
	struct ir_operand *oper = malloc(sizeof(struct ir_operand));
	oper->size = 0;
	oper->type = oper_reg;
	oper->val.virt_reg = reg;
	return oper;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl $0x10, %edi
callq 0x2100
movq $0x0, (%rax)
movl %ebx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: copy
struct ir_operand *copy(struct ir_operand *oper)
{
	struct ir_operand *cpy = NULL;
	if (oper->type == oper_reg)
		cpy = from_reg(oper->val.virt_reg);
	else if (oper->type == oper_sym)
		cpy = from_sym(oper->val.sym);
	else if (oper->type == oper_cnum)
		cpy = from_cnum(oper->val.constant);
	if (cpy) cpy->size = oper->size;
	return cpy;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x5429
cmpl $0x1, %eax
je 0x541e
testl %eax, %eax
jne 0x544a
movl 0x8(%rbx), %ebp
movl $0x10, %edi
callq 0x2100
movq $0x0, (%rax)
movl %ebp, 0x8(%rax)
jmp 0x544c
movq 0x8(%rbx), %rdi
callq 0x539a
jmp 0x544c
movq 0x8(%rbx), %r14
movl $0x10, %edi
callq 0x2100
movabsq $0x400000002, %rcx      # imm = 0x400000002
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
jmp 0x544c
xorl %eax, %eax
testq %rax, %rax
je 0x5457
movl 0x4(%rbx), %ecx
movl %ecx, 0x4(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: eval_size
void eval_size(struct ir_stmt *stmt)
{
	int dfsize = 0;
	if (stmt->result && stmt->result->size) dfsize = stmt->result->size;
	else if (stmt->arg1 && stmt->arg1->size) dfsize = stmt->arg1->size;
	else if (stmt->arg2 && stmt->arg2->size) dfsize = stmt->arg2->size;

	if (stmt->result && !stmt->result->size)
		stmt->result->size = dfsize;
	if (stmt->arg1 && !stmt->arg1->size)
		stmt->arg1->size = dfsize;
	if (stmt->arg2 && !stmt->arg2->size)
		stmt->arg2->size = dfsize;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x546c
movl 0x4(%rcx), %eax
testl %eax, %eax
jne 0x548c
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x547c
movl 0x4(%rax), %eax
testl %eax, %eax
jne 0x548c
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x548a
movl 0x4(%rax), %eax
jmp 0x548c
xorl %eax, %eax
testq %rcx, %rcx
je 0x549a
cmpl $0x0, 0x4(%rcx)
jne 0x549a
movl %eax, 0x4(%rcx)
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x54ac
cmpl $0x0, 0x4(%rcx)
jne 0x54ac
movl %eax, 0x4(%rcx)
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x54bb
cmpl $0x0, 0x4(%rcx)
je 0x54bc
retq
movl %eax, 0x4(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: ir_stmt_init
struct ir_stmt *ir_stmt_init()
{
	struct ir_stmt *stmt = malloc(sizeof(struct ir_stmt));
	stmt->type=stmt_invalid;
	stmt->result = NULL, stmt->arg1 = NULL, stmt->arg2 = NULL;
	stmt->prev = NULL, stmt->next = NULL;
	stmt->label = -1;
	return stmt;
}

// Assembly:
pushq %rax
movl $0x38, %edi
callq 0x2100
movl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq $0x0, 0x28(%rax)
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/tac.c
// Function: ir_stmt_free
void ir_stmt_free(struct ir_stmt *stmt)
{
	if (!stmt) return;
	ir_operand_free(stmt->result);
	ir_operand_free(stmt->arg1);
	ir_operand_free(stmt->arg2);
	free(stmt);
}

// Assembly:
testq %rdi, %rdi
je 0x5533
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x550e
callq 0x2030
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x551c
callq 0x2030
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x552a
callq 0x2030
movq %rbx, %rdi
popq %rbx
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/frontend/ast.c
// Function: node_init
struct node *node_init(int type, void *term)
{
	struct node *n = malloc(sizeof(struct node));

	n->type = type;
	n->child = term;

	n->inf = malloc(sizeof(struct node_info));
	n->inf->type = NULL;
	n->inf->truelist = NULL, n->inf->falselist = NULL;
	n->inf->virt_reg = 0;

	return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl $0x18, %edi
callq 0x2100
movq %rax, %r14
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
movl $0x20, %edi
callq 0x2100
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/frontend/ast.c
// Function: unit_add
void unit_add(struct unit *u, struct stmt *edecl)
{
	u->num_decls++;
	if (!u->edecls) u->edecls = malloc(sizeof(struct stmt*));
	else u->edecls = realloc(u->edecls, sizeof(struct stmt*)*u->num_decls);
	u->edecls[u->num_decls-1] = edecl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rdi), %rsi
incq %rsi
movl %esi, 0x8(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5a36
shlq $0x3, %rsi
callq 0x2110
jmp 0x5a40
movl $0x8, %edi
callq 0x2100
movq %rax, (%r14)
movslq 0x8(%r14), %rcx
movq %rbx, -0x8(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/frontend/ast.c
// Function: loop_init
struct stmt *loop_init(struct expr *init, struct expr *cond,
		       struct expr *iter, struct stmt *body)
{
	struct loop *l = malloc(sizeof(struct loop));
	l->init = init, l->condition = cond, l->iter = iter;
	l->body = body;
	return node_init(node_loop, l);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x2100
movq %rax, %r13
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movl $0x18, %edi
callq 0x2100
movq %rax, %rbx
movl $0xb, (%rax)
movq %r13, 0x8(%rax)
movl $0x20, %edi
callq 0x2100
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/frontend/ast.c
// Function: func_init
struct stmt *func_init(char *ident, struct type *ftype, struct stmt *body)
{
	struct func *f = malloc(sizeof(struct func));
	f->ident = ident;
	f->ftype = ftype;
	f->body = body;
	return node_init(node_func, f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x2100
movq %rax, %r12
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movl $0x18, %edi
callq 0x2100
movq %rax, %rbx
movl $0x8, (%rax)
movq %r12, 0x8(%rax)
movl $0x20, %edi
callq 0x2100
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/frontend/ast.c
// Function: call_init
struct expr *call_init(struct expr *func, struct expr **args, int argc)
{
	struct call *c = malloc(sizeof(struct call));

	c->func = func;
	c->argv = args;
	c->argc = argc;

	return node_init(node_call, c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x2100
movq %rax, %r12
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movl %ebx, (%rax)
movl $0x18, %edi
callq 0x2100
movq %rax, %rbx
movl $0x7, (%rax)
movq %r12, 0x8(%rax)
movl $0x20, %edi
callq 0x2100
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rdi), %rsi
incq %rsi
movl %esi, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x5c1a
shlq $0x3, %rsi
callq 0x2110
jmp 0x5c24
movl $0x8, %edi
callq 0x2100
movq %rax, 0x10(%r14)
movslq (%r14), %rcx
movq %rbx, -0x8(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl $0x18, %edi
callq 0x2100
movq %rax, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movl $0x18, %edi
callq 0x2100
movq %rax, %r14
movl $0x9, (%rax)
movq %rbx, 0x8(%rax)
movl $0x20, %edi
callq 0x2100
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/frontend/ast.c
// Function: block_addstmt
void block_addstmt(struct block *b, struct stmt *s)
{
	b->num_stmt++;
	if (!b->stmt_list)
		b->stmt_list = malloc(sizeof(struct stmt *));
	else
		b->stmt_list =
		    realloc(b->stmt_list,
			    sizeof(struct stmt *) * b->num_stmt);
	b->stmt_list[b->num_stmt - 1] = s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rdi), %rsi
incq %rsi
movl %esi, 0x8(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5cba
shlq $0x3, %rsi
callq 0x2110
jmp 0x5cc4
movl $0x8, %edi
callq 0x2100
movq %rax, (%r14)
movslq 0x8(%r14), %rcx
movq %rbx, -0x8(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movl $0x18, %edi
callq 0x2100
movq %rax, %r15
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movl %ebp, 0x10(%rax)
movl $0x18, %edi
callq 0x2100
movq %rax, %rbx
movl $0x6, (%rax)
movq %r15, 0x8(%rax)
movl $0x20, %edi
callq 0x2100
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl $0x10, %edi
callq 0x2100
movq %rax, %r14
movq %rbx, (%rax)
movl %ebp, 0x8(%rax)
movl $0x18, %edi
callq 0x2100
movq %rax, %rbx
movl $0x5, (%rax)
movq %r14, 0x8(%rax)
movl $0x20, %edi
callq 0x2100
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %edi
callq 0x2100
movq %rax, %r14
movq %rbx, %rdi
callq 0x2070
movq %rax, %r15
incl %eax
movslq %eax, %rdi
callq 0x2100
movq %rax, %r12
movq %rax, (%r14)
movslq %r15d, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x20f0
movb $0x0, (%r12,%r15)
movl $0x18, %edi
callq 0x2100
movq %rax, %rbx
movl $0x3, (%rax)
movq %r14, 0x8(%rax)
movl $0x20, %edi
callq 0x2100
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl $0xf, %esi
callq 0x7cb0
xorl %r14d, %r14d
xorl %r12d, %r12d
testq %rax, %rax
je 0x6147
movl $0x1, %edi
callq 0x7f9c
movq %r12, %rdi
movq %rax, %rsi
callq 0x7fb6
movq %rax, %r12
movq %r15, %rdi
movl $0xf, %esi
callq 0x7cb0
jmp 0x611b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5e74
testl %eax, %eax
je 0x616c
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x7fb6
movq %rax, 0x8(%rbx)
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x4, %esi
callq 0x7cb0
xorl %ebp, %ebp
testq %rax, %rax
setne %bpl
movq %rbx, %rdi
movl $0x5, %esi
callq 0x7cb0
testq %rax, %rax
movl $0x2, %esi
cmovel %ebp, %esi
testl %esi, %esi
je 0x61be
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x61c7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x18, %edi
callq 0x2100
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x60fd
testl %eax, %eax
je 0x6215
xorl %edi, %edi
callq 0x7f9c
movl %ebp, (%rax)
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x7fb6
movq %rax, 0x8(%rbx)
jmp 0x621f
movq %rbx, %rdi
callq 0x2030
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x4, %esi
callq 0x7cb0
xorl %ebp, %ebp
testq %rax, %rax
setne %bpl
movq %rbx, %rdi
movl $0x5, %esi
callq 0x7cb0
testq %rax, %rax
movl $0x2, %esi
cmovel %ebp, %esi
testl %esi, %esi
je 0x6314
movq %rbx, %rdi
callq 0x61c7
movq %rax, %r14
movq %rbx, %rdi
callq 0x7d5d
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x7e98
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x62fd
movq %rbx, %rdi
movl $0x13, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x62b9
leaq 0x338b(%rip), %rsi      # 0x963c
movq %rbx, %rdi
callq 0x7d15
movq %rbx, %rdi
callq 0x7196
movq %rax, %r15
testq %rax, %rax
jne 0x62d8
leaq 0x339d(%rip), %rsi      # 0x966d
movq %rbx, %rdi
callq 0x7d15
movq %r15, 0x10(%r14)
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x62fd
leaq 0x339e(%rip), %rsi      # 0x9693
movq %rbx, %rdi
callq 0x7d15
movl $0xc, %edi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x57a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x327b(%rip), %rdi      # 0x9724
xorl %eax, %eax
callq 0x2080
movl $0x22, %edi
callq 0x2040
leaq 0x3277(%rip), %rdi      # 0x9738
xorl %eax, %eax
callq 0x2080
movq %r15, %rdi
callq 0x81ed
leaq 0x326e(%rip), %rdi      # 0x9745
xorl %eax, %eax
callq 0x2080
movq %r14, %rdi
callq 0x81ed
leaq 0x331c(%rip), %rdi      # 0x9809
callq 0x2060
movq %rbx, %rdi
callq 0x26d1
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x6516
cmpl $0x0, 0x18(%rdi)
je 0x6517
retq
movl (%rdi), %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0x6516
movl %ecx, %eax
leaq 0x336b(%rip), %rcx      # 0x9894
movl (%rcx,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq (%rax), %r15
movq (%rsi), %rax
movq 0x10(%rax), %rax
movq (%rax), %rbx
xorl %eax, %eax
testq %r15, %r15
je 0x6587
xorl %ecx, %ecx
cmpl $0x0, 0x18(%r15)
movl $0x0, %esi
jne 0x658b
movl (%r15), %esi
movb $0x1, %cl
cmpl $0x4, %esi
je 0x6680
cmpl $0x2, %esi
je 0x666c
cmpl $0x1, %esi
jne 0x6587
movl $0x2, %esi
jmp 0x658b
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edi, %edi
testq %rbx, %rbx
je 0x65a1
cmpl $0x0, 0x18(%rbx)
movl $0x0, %eax
je 0x662c
andb %dil, %cl
cmpb $0x1, %cl
jne 0x65d2
cmpl %eax, %esi
seta %cl
cmpl $0x3, %edx
sete %dil
testl %edx, %edx
je 0x65e0
andb %cl, %dil
jne 0x65e0
cmpl %esi, %eax
seta %al
cmpl $0x3, %edx
sete %cl
cmpl $0x1, %edx
je 0x664a
andb %al, %cl
jne 0x664a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl %esi, %eax
setbe %al
testl %edx, %edx
setne %cl
orb %al, %cl
jne 0x6624
leaq 0x3158(%rip), %rdi      # 0x974d
xorl %eax, %eax
callq 0x2080
movq %r15, %rdi
callq 0x81ed
leaq 0x3175(%rip), %rdi      # 0x9780
xorl %eax, %eax
callq 0x2080
movq %rbx, %rdi
callq 0x81ed
movl $0xa, %edi
callq 0x2040
movq %r15, %rdi
movq %r14, %rsi
jmp 0x665c
movl (%rbx), %eax
movb $0x1, %dil
cmpl $0x4, %eax
je 0x668a
cmpl $0x2, %eax
je 0x6676
cmpl $0x1, %eax
jne 0x6694
movl $0x2, %eax
jmp 0x65a1
leaq 0x31c9(%rip), %rdi      # 0x981a
callq 0x2060
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x669d
movl $0x1, %esi
jmp 0x658b
movl $0x1, %eax
jmp 0x65a1
movl $0x3, %esi
jmp 0x658b
movl $0x3, %eax
jmp 0x65a1
xorl %edi, %edi
xorl %eax, %eax
jmp 0x65a1
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq 0x10(%rsi), %rax
movq (%rax), %rdx
testq %rdi, %rdi
je 0x66ce
cmpl $0x0, 0x18(%r14)
jne 0x66ce
movl (%r14), %ecx
cmpl $0x4, %ecx
ja 0x66ce
movb $0x16, %al
shrb %cl, %al
jmp 0x66d0
xorl %eax, %eax
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x66ea
cmpl $0x0, 0x18(%rdx)
jne 0x66ea
movl (%rdx), %ecx
cmpl $0x4, %ecx
ja 0x66ea
movb $0x16, %dl
shrb %cl, %dl
jmp 0x66ec
xorl %edx, %edx
andb %dl, %al
testb $0x1, %al
je 0x6716
movl $0x1, %ebp
movl $0x1, %edi
callq 0x57a0
movq %rax, %r15
movq %r14, %rdi
callq 0x8040
movq 0x10(%r15), %rcx
movq %rax, (%rcx)
movq %r15, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x6e00
movq %rsi, %r14
leaq 0x4(%rsp), %rsi
movl %ebx, (%rsi)
movq %rsp, %rcx
movl %ebx, (%rcx)
leaq 0x10(%rsp), %rax
movq %rdi, (%rax)
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
movq %rax, %rdi
callq 0x6e1d
testl %eax, %eax
je 0x6e05
movl %eax, %r15d
movq %r14, 0x18(%rsp)
movl $0x8, %r14d
xorl %ebx, %ebx
xorl %r13d, %r13d
movq %r13, 0x20(%rsp)
movslq 0x4(%rsp), %r12
leaq 0x1(%r12), %rdi
callq 0x2100
movq %rax, %rbp
movq 0x10(%rsp), %r13
movq %r13, %rsi
subq %r12, %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x20f0
movb $0x0, (%rbp,%r12)
movl $0x18, %edi
callq 0x2100
movq %rax, %r12
movq %rbp, (%rax)
movl %r15d, 0x14(%rax)
subl 0x8(%rsp), %r13d
movl %r13d, 0x8(%rax)
movq 0x20(%rsp), %rdi
movl (%rsp), %eax
movl %eax, 0xc(%r12)
testq %rdi, %rdi
je 0x6dbf
movq %r14, %rsi
callq 0x2110
jmp 0x6dc9
movl $0x8, %edi
callq 0x2100
movq %rax, %r13
movq %r12, (%rax,%rbx,8)
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rsp, %rcx
callq 0x6e1d
movl %eax, %r15d
addq $0x8, %r14
incq %rbx
testl %eax, %eax
jne 0x6d53
movq 0x18(%rsp), %r14
jmp 0x6e08
xorl %r13d, %r13d
jmp 0x6e0b
xorl %r13d, %r13d
movl %ebx, (%r14)
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/frontend/lexer.c
// Function: lex_r
enum token_type lex_r(char **saveptr, int *tlen, char **ls, int *ln)
{
	char *str = *saveptr;
	while (isspace(*str))
		*ln += *str == '\n' ? (*ls = str, 1) : 0, str++;

	enum token_type t = t_none;
	int len = 0;
	size_t ntoken_pairs =
	    (size_t) ((sizeof(token_pairs) / sizeof(struct token_pair)));
	/*Match against static tokens */
	for (unsigned int i = 0; i < ntoken_pairs; i++) {
		if (!strncmp
		    (str, token_pairs[i].match, token_pairs[i].len)) {
			len = token_pairs[i].len;
			t = token_pairs[i].type;
			break;
		}
	}
	/*Check for ident, string, numeric, etc */
	if (t == t_none) {
		if (isdigit(*str)) {
			t = t_numeric;
			while (str[len] && isdigit(str[len]))
				len++;
		} else if (isalpha(*str) || *str == '_') {
			t = t_ident;
			while (str[len]
			       && (isalpha(str[len]) || str[len] == '_'))
				len++;
		}
	}

	*saveptr = str + len;
	*tlen = len;
	return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq (%rdi), %r15
callq 0x2130
movq (%rax), %rbp
movsbq (%r15), %rbx
movzwl (%rbp,%rbx,2), %r14d
btl $0xd, %r14d
jae 0x6e89
movl (%r12), %ecx
xorl %edx, %edx
cmpb $0xa, %bl
jne 0x6e6b
movq %r15, (%r13)
movl $0x1, %edx
addl %edx, %ecx
movl %ecx, (%r12)
movq (%rax), %rbp
movsbq 0x1(%r15), %rbx
incq %r15
movzwl (%rbp,%rbx,2), %r14d
btl $0xd, %r14d
jb 0x6e5b
movl $0x10, %r13d
leaq 0x6c2a(%rip), %rax      # 0xdac0
movq -0x8(%r13,%rax), %rsi
movl (%r13,%rax), %r12d
movslq %r12d, %rdx
movq %r15, %rdi
callq 0x2050
testl %eax, %eax
je 0x6ec3
addq $0x18, %r13
cmpq $0x340, %r13            # imm = 0x340
jne 0x6e8f
xorl %eax, %eax
xorl %r12d, %r12d
jmp 0x6ecf
leaq 0x6bf6(%rip), %rax      # 0xdac0
movl -0x10(%r13,%rax), %eax
testl %eax, %eax
je 0x6ef7
movslq %r12d, %rcx
addq %rcx, %r15
movq 0x8(%rsp), %rdx
movq %r15, (%rdx)
movq 0x10(%rsp), %rdx
movl %ecx, (%rdx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl %r14w, %ecx
btl $0xb, %ecx
jb 0x6f4a
cmpb $0x5f, %bl
je 0x6f10
xorl %eax, %eax
andl $0x400, %ecx            # imm = 0x400
je 0x6ed3
movslq %r12d, %rcx
movb (%r15,%rcx), %dl
movl $0xc, %eax
testb %dl, %dl
je 0x6ed3
addq %r15, %rcx
incq %rcx
cmpb $0x5f, %dl
je 0x6f3c
movsbq %dl, %rdx
movzwl (%rbp,%rdx,2), %edx
andl $0x400, %edx            # imm = 0x400
je 0x6ed3
incl %r12d
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x6f26
jmp 0x6ed3
movslq %r12d, %rcx
movb (%r15,%rcx), %dl
movl $0x1, %eax
testb %dl, %dl
je 0x6ed3
addq %r15, %rcx
incq %rcx
movsbq %dl, %rdx
testb $0x8, 0x1(%rbp,%rdx,2)
je 0x6ed3
incl %r12d
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x6f64
jmp 0x6ed3
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xc, %esi
callq 0x7cb0
testq %rax, %rax
je 0x6fa9
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5d8e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7cb0
testq %rax, %rax
je 0x6fca
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5e15
movq %rbx, %rdi
movl $0x14, %esi
callq 0x7cb0
testq %rax, %rax
je 0x700f
movq %rbx, %rdi
callq 0x7196
testq %rax, %rax
je 0x700f
movq %rax, %r14
movq %rbx, %rdi
movl $0x15, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x7012
leaq 0x28d9(%rip), %rsi      # 0x98de
movq %rbx, %rdi
callq 0x7d15
jmp 0x7012
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_postfix
struct expr *parse_postfix(struct parser *p)
{
	struct token *t;
	struct expr *e;
	if (!(e = parse_primary(p)))
		return NULL;
	while ((t = match(p, t_inc)) || (t = match(p, t_dec))
	       || (t = match(p, t_lbrack)) || (t = match(p, t_lparen))) {
		if (t->type == t_lbrack) {
			struct expr *sub;
			if (!(sub = parse_expr(p)))
				syntax_error(p,
					     "Invalid array subscript expression");
			if (!match(p, t_rbrack))
				syntax_error(p,
					     "Missing right bracket in subscript expression");
			e = binop_init(o_add, e, sub);
			e = unop_init(o_deref, e);
		} else if (t->type == t_lparen) {
			struct expr *call = call_init(e, NULL, 0);
			struct expr *arg;
			while ((arg=parse_asn_expr(p))) {
				call_addarg(CALL(call), arg);
				if (!match(p, t_comma)) break;
			}
			if (!match(p, t_rparen))
				syntax_error(p, "Missing right parentheses in function call");
			e = call;
		} else {
			e = unop_init(t->type ==
				      t_inc ? o_postinc : o_postdec, e);
		}
	}

	return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6f84
testq %rax, %rax
je 0x7181
movq %rax, %r14
leaq 0x2901(%rip), %r15      # 0x9949
leaq 0x28a9(%rip), %r12      # 0x98f8
leaq 0x28c5(%rip), %r13      # 0x991b
movq %rbx, %rdi
movl $0x22, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x70a2
movq %rbx, %rdi
movl $0x23, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x70a2
movq %rbx, %rdi
movl $0x16, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x70a2
movq %rbx, %rdi
movl $0x14, %esi
callq 0x7cb0
testq %rax, %rax
je 0x7184
movl 0x14(%rax), %eax
cmpl $0x14, %eax
je 0x7102
cmpl $0x16, %eax
jne 0x7162
movq %rbx, %rdi
callq 0x7196
movq %rax, %rbp
testq %rax, %rax
jne 0x70ce
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7d15
movq %rbx, %rdi
movl $0x17, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x70eb
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7d15
xorl %edi, %edi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x5cd8
movl $0x13, %edi
movq %rax, %rsi
jmp 0x7174
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5b8f
movq %rax, %r14
movq %rbx, %rdi
callq 0x7196
testq %rax, %rax
je 0x713c
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0x5bf4
movq %rbx, %rdi
movl $0x29, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x7111
movq %rbx, %rdi
movl $0x15, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x7056
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d15
jmp 0x7056
xorl %ecx, %ecx
cmpl $0x22, %eax
setne %cl
leal 0x14(,%rcx,2), %edi
movq %r14, %rsi
callq 0x5d3b
movq %rax, %r14
jmp 0x7056
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %ebp
callq 0x7226
testq %rax, %rax
je 0x7213
movq %rax, %r14
movq %rbx, %rdi
movl $0x13, %esi
callq 0x7cb0
testq %rax, %rax
je 0x720b
movq %rax, %r12
movq %rbx, %rdi
callq 0x7196
movq %rax, %r15
testq %rax, %rax
je 0x71ee
movq (%r12), %rdi
callq 0x8384
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5cd8
jmp 0x71fd
leaq 0x27bf(%rip), %rsi      # 0x99b4
movq %rbx, %rdi
callq 0x7d15
testq %r15, %r15
je 0x720b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x57dc
movl %ebp, 0x18(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x75e2
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7022
testq %rax, %rax
je 0x723f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movl $0x22, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x7263
movq %rbx, %rdi
movl $0x23, %esi
callq 0x7cb0
testq %rax, %rax
je 0x7295
movq %rax, %r14
movq %rbx, %rdi
callq 0x7226
testq %rax, %rax
je 0x7286
xorl %ecx, %ecx
cmpl $0x22, 0x14(%r14)
setne %cl
leal 0x15(,%rcx,2), %edi
jmp 0x72d7
leaq 0x26e7(%rip), %rsi      # 0x9974
movq %rbx, %rdi
callq 0x7d15
movq %rbx, %rdi
movl $0xf, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x72b9
movq %rbx, %rdi
movl $0x11, %esi
callq 0x7cb0
testq %rax, %rax
je 0x72e6
movq %rax, %r14
movq %rbx, %rdi
callq 0x7226
testq %rax, %rax
je 0x72e6
xorl %edi, %edi
cmpl $0xf, 0x14(%r14)
sete %dil
orl $0x12, %edi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5d3b
xorl %eax, %eax
jmp 0x7237
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x7226
testq %rax, %rax
je 0x736a
movq %rax, %r14
leaq 0x2688(%rip), %r15      # 0x9995
movq %rbx, %rdi
movl $0xf, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x7331
movq %rbx, %rdi
movl $0x12, %esi
callq 0x7cb0
testq %rax, %rax
je 0x736d
movq %rax, %r12
movq %rbx, %rdi
callq 0x7226
movq %rax, %r13
testq %rax, %rax
jne 0x734f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d15
movq (%r12), %rdi
callq 0x8384
movl %eax, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5cd8
movq %rax, %r14
jmp 0x730d
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x72ed
testq %rax, %rax
je 0x73f7
movq %rax, %r14
leaq 0x25fb(%rip), %r15      # 0x9995
movq %rbx, %rdi
movl $0xd, %esi
callq 0x7cb0
testq %rax, %rax
jne 0x73be
movq %rbx, %rdi
movl $0xe, %esi
callq 0x7cb0
testq %rax, %rax
je 0x73fa
movq %rax, %r12
movq %rbx, %rdi
callq 0x72ed
movq %rax, %r13
testq %rax, %rax
jne 0x73dc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d15
movq (%r12), %rdi
callq 0x8384
movl %eax, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5cd8
movq %rax, %r14
jmp 0x739a
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq