LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/live.c
// Function: use
void use(struct bb *blk, struct ir_stmt *s)
{
	if (s->arg1 && s->arg1->type == oper_reg)
		intarr_add(&blk->use, &blk->nuse, s->arg1->val.virt_reg);
	if (s->arg2 && s->arg2->type == oper_reg)
		intarr_add(&blk->use, &blk->nuse, s->arg2->val.virt_reg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3c18
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
jne 0x3c18
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x8(%rbp), %rsi
addq $0x58, %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %edx
callq 0x3b40
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3c50
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, (%rax)
jne 0x3c50
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x8(%rbp), %rsi
addq $0x58, %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %edx
callq 0x3b40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/match.c
// Function: find_stmt_match
struct ir_stmt *find_stmt_match(struct pattern_state *state)
{
	if (!state->entry) return NULL;
	int offset = 0, ns = 0;
	struct ir_stmt *iter=NULL, *a=state->entry;

	for (int i = 0; i < state->num_patts; i++) {
		ns = state->plist[i].num_stmt;
		iter = a;
		if (offset + ns > state->num_spatts) {
			break;
		}
		int nm;
		/*first check if the statement types are right*/
		for (nm = 0; nm < ns && iter; nm++, iter=iter->next) {
			if (!match_pattern(state->splist+nm+offset, ns-nm, iter)) {
				break;
			}
		}
		if (nm == ns) {
			a = state->callback(a, state->plist[i].value);
		}

		offset += ns;
	}
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4743
movq $0x0, -0x8(%rbp)
jmp 0x4874
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x486c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jle 0x47af
jmp 0x486c
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x31(%rbp)
jge 0x47ce
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x47d7
jmp 0x4824
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0x30(%rbp), %rax
imulq $0x14, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rax
imulq $0x14, %rax, %rax
addq %rax, %rdi
movl -0x18(%rbp), %esi
subl -0x30(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x4880
cmpl $0x0, %eax
jne 0x480b
jmp 0x4824
jmp 0x480d
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x47b6
movl -0x30(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x4855
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x476b
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/match.c
// Function: match_pattern
int match_pattern(struct stmt_pattern *spat, int max, struct ir_stmt *st)
{
	if (st->type != (*spat).st_type) return 0;

	struct ir_stmt *src = NULL, *dst = NULL;
	struct ir_stmt *cur = st;
	int it = 0;
	while (cur && it < max) {
		if (it > 1 && !src) break;
		if ((spat[it].flags&SRC)) src = cur;
		if ((spat[it].flags&DST)) dst = cur;
		it++;
		cur = cur->next;
	}
	if (!src || !dst) src=st, dst=st;
	struct stmt_pattern pat = *spat;

	if ((pat.flags&LBL)) return dst->label == src->label;

	if (!match_operand(dst, src->result, 	pat.result)) return 0;
	if (!match_operand(dst, src->arg1, 	pat.arg1)) return 0;
	if (!match_operand(dst, src->arg2, 	pat.arg2)) return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x48ae
movl $0x0, -0x4(%rbp)
jmp 0x4a23
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x51(%rbp)
je 0x48e5
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x48ee
jmp 0x4959
cmpl $0x1, -0x3c(%rbp)
jle 0x48fd
cmpq $0x0, -0x28(%rbp)
jne 0x48fd
jmp 0x4959
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x491e
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x493f
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x48cd
cmpq $0x0, -0x28(%rbp)
je 0x4967
cmpq $0x0, -0x30(%rbp)
jne 0x4977
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x40(%rbp)
movl -0x50(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x49b6
movq -0x30(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x30(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x4a23
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x48(%rbp), %edx
callq 0x4a30
cmpl $0x0, %eax
jne 0x49d8
movl $0x0, -0x4(%rbp)
jmp 0x4a23
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x44(%rbp), %edx
callq 0x4a30
cmpl $0x0, %eax
jne 0x49fa
movl $0x0, -0x4(%rbp)
jmp 0x4a23
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x40(%rbp), %edx
callq 0x4a30
cmpl $0x0, %eax
jne 0x4a1c
movl $0x0, -0x4(%rbp)
jmp 0x4a23
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/match.c
// Function: match_operand
int match_operand(struct ir_stmt *st, struct ir_operand *a, enum oper_pattern pat)
{
	if (!a) return 1;
	if (pat == opat_ignore) return 1;
	if (pat == opat_imm && a->type == oper_cnum) return 1;
	if (pat == opat_reg && a->type == oper_reg) return 1;
	if (pat == opat_mem && a->type == oper_sym) return 1;

	if (pat == opat_result) return compare_operands(a, st->result);
	if (pat == opat_arg1) return compare_operands(a, st->arg1);
	if (pat == opat_arg2) return compare_operands(a, st->arg2);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4a56
movl $0x1, -0x4(%rbp)
jmp 0x4b0e
cmpl $0x0, -0x1c(%rbp)
jne 0x4a68
movl $0x1, -0x4(%rbp)
jmp 0x4b0e
cmpl $0x1, -0x1c(%rbp)
jne 0x4a83
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x4a83
movl $0x1, -0x4(%rbp)
jmp 0x4b0e
cmpl $0x2, -0x1c(%rbp)
jne 0x4a9b
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4a9b
movl $0x1, -0x4(%rbp)
jmp 0x4b0e
cmpl $0x3, -0x1c(%rbp)
jne 0x4ab3
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x4ab3
movl $0x1, -0x4(%rbp)
jmp 0x4b0e
cmpl $0x4, -0x1c(%rbp)
jne 0x4acf
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4b20
movl %eax, -0x4(%rbp)
jmp 0x4b0e
cmpl $0x5, -0x1c(%rbp)
jne 0x4aeb
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4b20
movl %eax, -0x4(%rbp)
jmp 0x4b0e
cmpl $0x6, -0x1c(%rbp)
jne 0x4b07
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x4b20
movl %eax, -0x4(%rbp)
jmp 0x4b0e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/match.c
// Function: compare_operands
int compare_operands(struct ir_operand *a, struct ir_operand *b)
{
	if (!b || !a) return 0;
	if (a->type != b->type) return 0;
	enum oper_type t = a->type;
	if (t==oper_reg&&a->val.virt_reg==b->val.virt_reg) return 1;
	if (t==oper_cnum&&a->val.constant==b->val.constant) return 1;
	if (t==oper_sym&&a->val.sym&&b->val.sym&&!strcmp(a->val.sym->identifier,b->val.sym->identifier)) return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4b3e
cmpq $0x0, -0x10(%rbp)
jne 0x4b4a
movl $0x0, -0x4(%rbp)
jmp 0x4bfb
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4b64
movl $0x0, -0x4(%rbp)
jmp 0x4bfb
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x4b8c
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x4b8c
movl $0x1, -0x4(%rbp)
jmp 0x4bfb
cmpl $0x2, -0x1c(%rbp)
jne 0x4bad
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x4bad
movl $0x1, -0x4(%rbp)
jmp 0x4bfb
cmpl $0x1, -0x1c(%rbp)
jne 0x4bf4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4bf4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4bf4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x20a0
cmpl $0x0, %eax
jne 0x4bf4
movl $0x1, -0x4(%rbp)
jmp 0x4bfb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/peep.c
// Function: reduce_store_load
struct ir_stmt * reduce_store_load(struct ir_stmt *a)
{
	/*Use the value of the previous store instead of load again*/
	struct ir_stmt *ld = a->next;
	if (!ld) return a;
	/*Change the load to a move, with the previous stores operand as the value*/
	ld->type = stmt_move;
	ir_operand_free(ld->arg1);
	ld->arg1 = copy(a->arg2);
	/*Now all occurances of ld->result can be replaced with ld->arg1 */
	struct ir_stmt *cur = ld->next;
	while (cur) {
		if (compare_operands(ld->result, cur->result)) {
			ir_operand_free(cur->result);
			cur->result = copy(ld->arg1);
		}
		if (compare_operands(ld->result, cur->arg1)) {
			ir_operand_free(cur->arg1);
			cur->arg1 = copy(ld->arg1);
		}
		if (compare_operands(ld->result, cur->arg2)) {
			ir_operand_free(cur->arg2);
			cur->arg2 = copy(ld->arg1);
		}

		cur = cur->next;
	}
	unlink(ld);
	struct ir_stmt *n = ld->next;
	ir_stmt_free(ld);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4f4c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50bb
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7150
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6f30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5060
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4b20
cmpl $0x0, %eax
je 0x4fd1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7150
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f30
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4b20
cmpl $0x0, %eax
je 0x5010
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7150
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f30
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x4b20
cmpl $0x0, %eax
je 0x504f
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7150
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f30
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4f87
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x507f
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x509e
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7180
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/peep.c
// Function: reduce_label
struct ir_stmt *reduce_label(struct ir_stmt *a)
{
	/*If there is 2 labels, remove the 2nd and replace all occurances with the first*/
	struct ir_stmt *l2 = a->next;
	if (!l2) return a;
	int sl = l2->label;
	unlink(l2);

	ir_stmt_free(l2);
	struct ir_stmt *cur = a;
	/*loop forward and replace*/
	while (cur) {
		if (cur->label == sl) cur->label = a->label;
		cur = cur->next;
	}
	/*loop backwards and replace*/
	cur = a;
	while (cur) {
		if (cur->label == sl) cur->label = a->label;
		cur = cur->prev;
	}
	return a->prev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x50fc
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x51c7
movq -0x18(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x5125
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x5144
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdi
callq 0x7180
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5184
movq -0x28(%rbp), %rax
movl 0x30(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x5176
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5155
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x51bb
movq -0x28(%rbp), %rax
movl 0x30(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x51ad
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x518c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/ralloc.c
// Function: vertex_init
struct vertex *vertex_init()
{
	struct vertex *v = malloc(sizeof(struct vertex));

	v->siblings = NULL, v->num_siblings = 0;
	v->color = -1, v->ocolor = -1;
	v->removed = 0;

	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x20e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/ralloc.c
// Function: vertex_add_edge
void vertex_add_edge(struct vertex *v, struct vertex *v2)
{
	v->num_siblings++;
	if (!v->siblings) v->siblings = malloc(sizeof(struct vertex));
	else v->siblings = realloc(v->siblings, sizeof(struct vertex) * v->num_siblings);
	v->siblings[v->num_siblings-1] = v2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x536f
movl $0x20, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5393
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rsi
shlq $0x5, %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 0x18(%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/ralloc.c
// Function: degree
int degree(struct vertex *v)
{
	int deg = 0;
	for (int i = 0; i < v->num_siblings; i++)
		deg += !v->siblings[i]->removed;
	return deg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x5451
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x8(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5416
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/ralloc.c
// Function: push
void push(struct vstk *stk, struct vertex *v)
{
	stk->num_vertices++;
	if (!stk->vertices) stk->vertices = malloc(sizeof(struct vertex*));
	else stk->vertices = realloc(stk->vertices, sizeof(struct vertex*)*stk->num_vertices);
	stk->vertices[stk->num_vertices-1] = v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -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 0x549d
movl $0x8, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x54bf
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), %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/ralloc.c
// Function: pop
struct vertex *pop(struct vstk *stk)
{
	if (!stk->num_vertices) return NULL;
	struct vertex *v = stk->vertices[stk->num_vertices-1];
	stk->num_vertices--;
	if (!stk->num_vertices) {
		free(stk->vertices);
		stk->vertices = NULL;
	} else {
		stk->vertices = realloc(stk->vertices, stk->num_vertices*sizeof(struct vertex*));
	}
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x5510
movq $0x0, -0x8(%rbp)
jmp 0x5586
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 0x555c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x557e
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/ralloc.c
// Function: fill_stack
void fill_stack(struct vertex **graph, int num, struct vstk *stk, int k)
{
	if (!k) return;
	for (int i = 0; i < num; i++) {
		if (graph[i]->removed) continue;
		if (degree(graph[i]) < k) {
			graph[i]->removed = 1;
			push(stk, graph[i]);
			fill_stack(graph, num, stk, k);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x55b1
jmp 0x5634
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5634
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x8(%rax)
je 0x55d4
jmp 0x5629
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5400
cmpl -0x1c(%rbp), %eax
jge 0x5627
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5460
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5590
jmp 0x5634
jmp 0x5629
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x55b8
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/tac.c
// Function: map_stmt
enum stmt_type map_stmt(enum operator op)
{
	switch (op) {
#define STMT(a, b, c) case b: return STMT_STR(a);
		STMT_OPER_TABLE
#undef STMT
		default: break;
	}
	return stmt_invalid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x18, %rax
ja 0x58d2
movq -0x10(%rbp), %rax
leaq 0x6af1(%rip), %rcx      # 0xc324
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xa, -0x4(%rbp)
jmp 0x58db
movl $0xb, -0x4(%rbp)
jmp 0x58db
movl $0xc, -0x4(%rbp)
jmp 0x58db
movl $0xd, -0x4(%rbp)
jmp 0x58db
movl $0xe, -0x4(%rbp)
jmp 0x58db
movl $0xf, -0x4(%rbp)
jmp 0x58db
movl $0x10, -0x4(%rbp)
jmp 0x58db
movl $0x11, -0x4(%rbp)
jmp 0x58db
movl $0x12, -0x4(%rbp)
jmp 0x58db
movl $0x13, -0x4(%rbp)
jmp 0x58db
movl $0x14, -0x4(%rbp)
jmp 0x58db
movl $0x15, -0x4(%rbp)
jmp 0x58db
movl $0x16, -0x4(%rbp)
jmp 0x58db
movl $0x17, -0x4(%rbp)
jmp 0x58db
movl $0x18, -0x4(%rbp)
jmp 0x58db
movl $0x19, -0x4(%rbp)
jmp 0x58db
jmp 0x58d4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/tac.c
// Function: block_emit
void block_emit(struct generator *context, struct block *b)
{
	struct node *p = context->parent;
	context->scope = b->scope;
	for (int i = 0; i < b->num_stmt; i++) {
		generate_from_node(b->stmt_list[i], context, IGNORE);
		/*Merge it into the block*/
		TLIST(p)=merge(TLIST(p), TLIST(b->stmt_list[i]));
		FLIST(p)=merge(FLIST(p), FLIST(b->stmt_list[i]));
	}
	context->scope = b->scope->parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5d9c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
movl $0x3, %edx
callq 0x5920
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x6d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x6d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5cf3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/tac.c
// Function: decl_emit
void decl_emit(struct generator *context, struct declaration *decl)
{
	struct ir_stmt *stmt = ir_stmt_init();
	stmt->type = stmt_alloc;
	alloc_type(context->scope, decl->ident);
	struct symbol *s = get_symbol(context->scope, decl->ident);
	stmt->arg1 = from_sym(s);
	if (decl->initializer) {
		emit(context, stmt);
		stmt = ir_stmt_init();
		stmt->type = stmt_store;
		stmt->arg2 = generate_from_node(decl->initializer, context, VALUE);
		stmt->arg1 = from_sym(s);
	}
	emit(context, stmt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x70d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x5, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xafb0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xad70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6e70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6083
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6c40
callq 0x70d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x12, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
movl $0x2, %edx
callq 0x5920
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
callq 0x6e70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6c40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
callq 0x70d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x62c8
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x62c8
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62c6
movq -0x8(%rbp), %rax
movl (%rax), %edi
movl %edi, %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
callq 0x6ee0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x62c8
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x6342
callq 0x70d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x7, (%rax)
movslq -0x2c(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
movl $0x2, %edx
callq 0x5920
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6c40
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x62d4
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0x5920
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6c40
cmpl $0x3, -0x14(%rbp)
je 0x6393
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f30
movq %rax, -0x40(%rbp)
jmp 0x639b
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x639b
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xad70
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x63f0
movq -0x28(%rbp), %rdi
callq 0x6e70
movq %rax, -0x8(%rbp)
jmp 0x64dd
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
je 0x647b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
cmpl $0x2, 0x18(%rax)
jne 0x647b
callq 0x70d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x13, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl %edi, %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
callq 0x6ee0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0x6e70
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6c40
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f30
movq %rax, -0x8(%rbp)
jmp 0x64dd
callq 0x70d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x11, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl %edi, %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
callq 0x6ee0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0x6e70
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6c40
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x20e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x4, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x70d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6c40
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6bd8
jmp 0x6c33
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6bec
jmp 0x6c33
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x6c1f
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x30(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6bf3
movq -0x18(%rbp), %rdi
callq 0x71d0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6fc0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x6c7e
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x6caa
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x20e0
movq %rax, -0x10(%rbp)
movl $0x8, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x70d0
movq %rax, -0x18(%rbp)
cmpl $0x1, -0x10(%rbp)
jne 0x6d3d
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
jmp 0x6d47
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6c40
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6d9b
cmpq $0x0, -0x18(%rbp)
je 0x6d9b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e61
cmpq $0x0, -0x18(%rbp)
jne 0x6db6
cmpq $0x0, -0x10(%rbp)
je 0x6db6
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e61
cmpq $0x0, -0x10(%rbp)
jne 0x6dd1
cmpq $0x0, -0x18(%rbp)
jne 0x6dd1
movq $0x0, -0x8(%rbp)
jmp 0x6e61
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
addl 0x8(%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x20(%rbp), %rsi
shlq $0x3, %rsi
callq 0x20f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6e50
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
subl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6e1a
movq -0x18(%rbp), %rdi
callq 0x71d0
movq -0x10(%rbp), %rax
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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6e9b
leaq 0x5553(%rip), %rdi      # 0xc3dd
movb $0x0, %al
callq 0x2060
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2100
movl $0x10, %edi
callq 0x20e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x20e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x6f5f
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x6ee0
movq %rax, -0x10(%rbp)
jmp 0x6f99
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x6f7b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6e70
movq %rax, -0x10(%rbp)
jmp 0x6f97
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6f95
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x64f0
movq %rax, -0x10(%rbp)
jmp 0x6f97
jmp 0x6f99
cmpq $0x0, -0x10(%rbp)
je 0x6fae
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6ff8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x6ff8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x704c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7021
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x7021
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x704a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x7048
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x7048
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x704a
jmp 0x704c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7073
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7073
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x709a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x709a
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x70c1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x70c1
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x4(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x38, %edi
callq 0x20e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7195
jmp 0x71c5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7150
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7150
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7150
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x20e0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x20, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x20e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rsi
movl $0xb, %edi
callq 0x75d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rsi
movl $0x8, %edi
callq 0x75d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x18, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rsi
movl $0x7, %edi
callq 0x75d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)