LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_or_expr
struct expr *parse_or_expr(struct parser *p)
{
	struct expr *v = parse_and_expr(p);
	if (!v)
		return NULL;
	while (match(p, t_vslash) && match(p, t_vslash)) {
		struct expr *v2 = parse_and_expr(p);
		if (!v2)
			syntax_error(p, "Unexpected token in expression");
		v = binop_init(o_or, v, v2);
	}
	return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x74ef
testq %rax, %rax
je 0x760a
movq %rax, %rbx
movq %r14, %rdi
movl $0x10, %esi
callq 0x7c4e
testq %rax, %rax
je 0x760c
leaq 0x23bb(%rip), %r15      # 0x9971
movq %r14, %rdi
movl $0x10, %esi
callq 0x7c4e
testq %rax, %rax
je 0x760c
movq %r14, %rdi
callq 0x74ef
movq %rax, %r12
testq %rax, %rax
jne 0x75e3
movq %r14, %rdi
movq %r15, %rsi
callq 0x7ca4
movl $0xb, %edi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x5cb2
movq %rax, %rbx
movq %r14, %rdi
movl $0x10, %esi
callq 0x7c4e
testq %rax, %rax
jne 0x75b6
jmp 0x760c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_expr_stmt
struct stmt *parse_expr_stmt(struct parser *p)
{
	struct expr *e;
	if ((e = parse_expr(p))) {
		if (!match(p, t_semic))
			syntax_error(p, "Expected ';' after expression");
		return e;
	}
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x7142
movq %rax, %rbx
testq %rax, %rax
je 0x7650
movq %r14, %rdi
movl $0x2a, %esi
callq 0x7c4e
testq %rax, %rax
jne 0x7650
leaq 0x2378(%rip), %rsi      # 0x99c0
movq %r14, %rdi
callq 0x7ca4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_block
struct stmt *parse_block(struct parser *p)
{
	if (match(p, t_lcbrack)) {
		struct stmt *block = block_init();
		push_scope(p);
		struct stmt *s;
		while ((s = parse_stmt(p)) || (s = parse_declaration(p)))
			block_addstmt(block->child, s);
		if (!match(p, t_rcbrack))
			syntax_error(p, "Expected '}'");
		((struct block *) block->child)->scope = pop_scope(p);
		return block;
	}
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %esi
callq 0x7c4e
testq %rax, %rax
je 0x76de
xorl %eax, %eax
callq 0x5c0d
movq %rax, %r14
movq %rbx, %rdi
callq 0x7b37
movq %rbx, %rdi
callq 0x76ec
testq %rax, %rax
jne 0x769d
movq %rbx, %rdi
callq 0x61f6
testq %rax, %rax
je 0x76ab
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0x5c68
jmp 0x7683
movq %rbx, %rdi
movl $0x19, %esi
callq 0x7c4e
testq %rax, %rax
jne 0x76cc
leaq 0x231a(%rip), %rsi      # 0x99de
movq %rbx, %rdi
callq 0x7ca4
movq %rbx, %rdi
callq 0x7c07
movq 0x8(%r14), %rcx
movq %rax, 0x10(%rcx)
jmp 0x76e1
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_stmt
struct stmt *parse_stmt(struct parser *p)
{
	struct stmt *s;
	if ((s = parse_block(p)))
		return s;
	if ((s = parse_expr_stmt(p)))
		return s;
	if ((s = parse_cond(p)))
		return s;
	if ((s = parse_loop(p)))
		return s;
	if ((s = parse_jump(p)))
		return s;
	//if (s=parse_declaration(p)) return s;
	if (match(p, t_semic))
		return node_init(node_empty, NULL);

	return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x765b
testq %rax, %rax
jne 0x772e
movq %rbx, %rdi
callq 0x761b
testq %rax, %rax
jne 0x772e
movq %rbx, %rdi
callq 0x78ee
testq %rax, %rax
jne 0x772e
movq %rbx, %rdi
callq 0x7750
testq %rax, %rax
jne 0x772e
movq %rbx, %rdi
callq 0x79c7
testq %rax, %rax
je 0x7730
popq %rbx
retq
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x7c4e
testq %rax, %rax
je 0x774c
xorl %edi, %edi
xorl %esi, %esi
popq %rbx
jmp 0x5764
xorl %eax, %eax
jmp 0x772e
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_loop
struct stmt *parse_loop(struct parser *p)
{
	struct token *t;
	struct expr *init, *cond, *iter;
	struct stmt *body;
	if ((t = match(p, t_while))) {
		if (!match(p, t_lparen))
			syntax_error(p, "Missing left parentheses");
		if (!(cond = parse_expr(p)))
			syntax_error(p, "No valid expression");
		if (!match(p, t_rparen))
			syntax_error(p, "Missing right parentheses");
		if (!(body = parse_stmt(p)))
			syntax_error(p,
				     "Missing statement after while expression");
		return loop_init(NULL, cond, NULL, body);
	}
	if ((t = match(p, t_for))) {
		if (!match(p, t_lparen))
			syntax_error(p, "Missing left parentheses");
		init = parse_declaration(p);
		if (!init)
			syntax_error(p,
				     "No valid initializer statement in for loop");
		cond = parse_expr(p);
		if (!match(p, t_semic))
			syntax_error(p,
				     "No valid condition statement in for loop");
		iter = parse_expr(p);
		if (!match(p, t_rparen))
			syntax_error(p, "Missing right parentheses");
		if (!(body = parse_stmt(p)))
			syntax_error(p, "Missing statement");
		return loop_init(init, cond, iter, body);
	}

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x24, %esi
callq 0x7c4e
movq %rbx, %rdi
testq %rax, %rax
je 0x77fe
movl $0x14, %esi
callq 0x7c4e
testq %rax, %rax
jne 0x7790
leaq 0x2263(%rip), %rsi      # 0x99eb
movq %rbx, %rdi
callq 0x7ca4
movq %rbx, %rdi
callq 0x7142
movq %rax, %r14
testq %rax, %rax
jne 0x77af
leaq 0x225d(%rip), %rsi      # 0x9a04
movq %rbx, %rdi
callq 0x7ca4
movq %rbx, %rdi
movl $0x15, %esi
callq 0x7c4e
testq %rax, %rax
jne 0x77d0
leaq 0x20f2(%rip), %rsi      # 0x98ba
movq %rbx, %rdi
callq 0x7ca4
movq %rbx, %rdi
callq 0x76ec
movq %rax, %r15
testq %rax, %rax
jne 0x77ef
leaq 0x2231(%rip), %rsi      # 0x9a18
movq %rbx, %rdi
callq 0x7ca4
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
jmp 0x78d4
movl $0x25, %esi
callq 0x7c4e
testq %rax, %rax
je 0x78e2
movq %rbx, %rdi
movl $0x14, %esi
callq 0x7c4e
testq %rax, %rax
jne 0x7832
leaq 0x21c1(%rip), %rsi      # 0x99eb
movq %rbx, %rdi
callq 0x7ca4
movq %rbx, %rdi
callq 0x61f6
movq %rax, %r14
testq %rax, %rax
jne 0x7851
leaq 0x21f8(%rip), %rsi      # 0x9a41
movq %rbx, %rdi
callq 0x7ca4
movq %rbx, %rdi
callq 0x7142
movq %rax, %r15
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x7c4e
testq %rax, %rax
jne 0x787d
leaq 0x21f7(%rip), %rsi      # 0x9a6c
movq %rbx, %rdi
callq 0x7ca4
movq %rbx, %rdi
callq 0x7142
movq %rax, %r12
movq %rbx, %rdi
movl $0x15, %esi
callq 0x7c4e
testq %rax, %rax
jne 0x78a9
leaq 0x2019(%rip), %rsi      # 0x98ba
movq %rbx, %rdi
callq 0x7ca4
movq %rbx, %rdi
callq 0x76ec
movq %rax, %r13
testq %rax, %rax
jne 0x78c8
leaq 0x21d5(%rip), %rsi      # 0x9a95
movq %rbx, %rdi
callq 0x7ca4
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5a24
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_cond
struct stmt *parse_cond(struct parser *p)
{
	struct expr *c;
	struct token *tif;
	if ((tif = match(p, t_if)) && match(p, t_lparen)) {
		if (!(c = parse_expr(p)))
			syntax_error(p, "Expected expression after '('");
		if (match(p, t_rparen)) {
			struct stmt *s, *s2;
			if ((s = parse_stmt(p))) {
				if (match(p, t_else)) {
					if ((s2 = parse_stmt(p)))
						return cond_init(c, s, s2);
				}
				return cond_init(c, s, NULL);
			}
			syntax_error(p, "No valid statement following if");
		}
		syntax_error(p, "Missing right parentheses");
	} else if (tif) {
		syntax_error(p, "Missing left parentheses");
	}

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1a, %esi
callq 0x7c4e
testq %rax, %rax
je 0x79bf
movq %rbx, %rdi
movl $0x14, %esi
callq 0x7c4e
testq %rax, %rax
je 0x7986
movq %rbx, %rdi
callq 0x7142
movq %rax, %r14
testq %rax, %rax
jne 0x793a
leaq 0x2175(%rip), %rsi      # 0x9aa7
movq %rbx, %rdi
callq 0x7ca4
movq %rbx, %rdi
movl $0x15, %esi
callq 0x7c4e
testq %rax, %rax
je 0x79b0
movq %rbx, %rdi
callq 0x76ec
testq %rax, %rax
je 0x79a1
movq %rax, %r15
movq %rbx, %rdi
movl $0x1b, %esi
callq 0x7c4e
testq %rax, %rax
je 0x798f
movq %rbx, %rdi
callq 0x76ec
testq %rax, %rax
je 0x798f
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
jmp 0x7997
leaq 0x205e(%rip), %rsi      # 0x99eb
jmp 0x79b7
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x5a91
leaq 0x211d(%rip), %rsi      # 0x9ac5
movq %rbx, %rdi
callq 0x7ca4
leaq 0x1f03(%rip), %rsi      # 0x98ba
movq %rbx, %rdi
callq 0x7ca4
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_jump
struct stmt *parse_jump(struct parser *p)
{
	struct token *t;
	if ((t=match(p, t_break)) && match(p, t_semic)) return node_init(node_break, NULL);
	else if (t) syntax_error(p, "Missing semicolon after break");

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x26, %esi
callq 0x7c4e
testq %rax, %rax
je 0x7a05
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x7c4e
testq %rax, %rax
je 0x79f6
movl $0xd, %edi
jmp 0x7a2e
leaq 0x20e8(%rip), %rsi      # 0x9ae5
movq %rbx, %rdi
callq 0x7ca4
movq %rbx, %rdi
movl $0x27, %esi
callq 0x7c4e
testq %rax, %rax
je 0x7a41
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x7c4e
testq %rax, %rax
je 0x7a32
movl $0xe, %edi
xorl %esi, %esi
jmp 0x7a87
leaq 0x20ca(%rip), %rsi      # 0x9b03
movq %rbx, %rdi
callq 0x7ca4
movq %rbx, %rdi
movl $0x28, %esi
callq 0x7c4e
testq %rax, %rax
je 0x7a93
movq %rbx, %rdi
callq 0x7142
movq %rax, %r14
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x7c4e
testq %rax, %rax
jne 0x7a7f
leaq 0x20ad(%rip), %rsi      # 0x9b24
movq %rbx, %rdi
callq 0x7ca4
movl $0xf, %edi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5764
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/parser.c
// Function: parse_unit
struct node *parse_unit(struct parser *p)
{
	struct node *unit=NULL;
	struct stmt *s;
	while ((s=parse_function(p))) {
		if (!unit) unit = unit_init();
		unit_add(UNIT(unit), s);
	}
	return unit;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x62f0
testq %rax, %rax
je 0x7ae2
movq %rax, %r14
xorl %r15d, %r15d
testq %r15, %r15
jne 0x7ac4
xorl %eax, %eax
callq 0x5981
movq %rax, %r15
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x59da
movq %rbx, %rdi
callq 0x62f0
movq %rax, %r14
testq %rax, %rax
jne 0x7ab5
jmp 0x7ae5
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/pcommon.c
// Function: push_scope
void push_scope(struct parser *p)
{
	struct symbol_table *top = get_scope(p);
	p->num_stk++;
	if (!p->scope_stk)
		p->scope_stk = malloc(sizeof(struct symbol_table *));
	else
		p->scope_stk =
		    realloc(p->scope_stk,
			    sizeof(struct symbol_table *) * p->num_stk);
	p->scope_stk[p->num_stk - 1] = symbol_table_init(top);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x8(%rdi), %rax
movq (%rdi), %rdi
testq %rax, %rax
je 0x7b5f
movq -0x8(%rdi,%rax,8), %r14
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rbx)
leaq 0x8(,%rax,8), %rsi
jmp 0x7b73
movl $0x1, 0x8(%rbx)
testq %rdi, %rdi
je 0x7b97
movl $0x8, %esi
xorl %r14d, %r14d
callq 0x2110
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x7d04
movq (%rbx), %rcx
movslq 0x8(%rbx), %rdx
movq %rax, -0x8(%rcx,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x2100
xorl %r14d, %r14d
jmp 0x7b78
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/pcommon.c
// Function: parser_free
void parser_free(struct parser *p)
{
	for (int i = 0; i < p->len; i++) {
		free(p->toks[i]->tok);
		free(p->toks[i]);
	}
	symbol_table_free(pop_scope(p));
	free(p->toks);
	free(p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x1c(%rdi)
jle 0x7bdf
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax), %rdi
callq 0x2030
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2030
incq %r14
movslq 0x1c(%rbx), %rax
cmpq %rax, %r14
jl 0x7bb6
movq %rbx, %rdi
callq 0x7c07
movq %rax, %rdi
callq 0x7d36
movq 0x10(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/pcommon.c
// Function: pop_scope
struct symbol_table *pop_scope(struct parser *p)
{
	if (!p->num_stk)
		return NULL;
	struct symbol_table *s = p->scope_stk[p->num_stk - 1];
	p->num_stk--;
	if (!p->num_stk) {
		free(p->scope_stk);
		p->scope_stk = NULL;
	} else {
		p->scope_stk =
		    realloc(p->scope_stk,
			    sizeof(struct symbol_table *) * p->num_stk);
	}
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x8(%rdi), %rax
testq %rax, %rax
je 0x7c35
movq %rdi, %r14
movq (%rdi), %rdi
movq -0x8(%rdi,%rax,8), %rbx
decl %eax
movl %eax, 0x8(%r14)
je 0x7c39
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x2110
jmp 0x7c40
xorl %ebx, %ebx
jmp 0x7c43
callq 0x2030
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/pcommon.c
// Function: syntax_error
void syntax_error(struct parser *p, const char *msg)
{
	if (p->cur >= p->len)
		p->cur = p->len - 1;
	struct token *t = p->toks[p->cur];
	fprintf(stderr, "\n(%d,%d): error \"%s\" Near Token %s\n", t->col,
		t->line, msg, t->tok);
	exit(1);
}

// Assembly:
movq %rsi, %r8
movl 0x18(%rdi), %eax
movl 0x1c(%rdi), %ecx
cmpl %ecx, %eax
jl 0x7cb8
decl %ecx
movl %ecx, 0x18(%rdi)
movl %ecx, %eax
pushq %rax
movq 0x10(%rdi), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq 0x632e(%rip), %rcx      # 0xdff8
movq (%rcx), %rdi
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
movq (%rax), %r9
leaq 0x1e66(%rip), %rsi      # 0x9b43
xorl %eax, %eax
callq 0x20d0
movl $0x1, %edi
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/symbols.c
// Function: symbol_table_init
struct symbol_table *symbol_table_init(struct symbol_table *parent)
{
	struct symbol_table *table = malloc(sizeof(struct symbol_table));

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

	return table;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x2100
movq %rbx, 0x18(%rax)
movq $0x0, 0x10(%rax)
movl $0x0, 0x8(%rax)
testq %rbx, %rbx
je 0x7d2f
movq (%rbx), %rcx
jmp 0x7d31
xorl %ecx, %ecx
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/symbols.c
// Function: symbol_table_free
void symbol_table_free(struct symbol_table *scope)
{
	if (!scope)
		return;

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

// Assembly:
testq %rdi, %rdi
je 0x7d8d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x7d75
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2030
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x7d4b
movq 0x10(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/symbols.c
// Function: get_symbol
struct symbol *get_symbol(struct symbol_table *scope, const char *ident)
{
	struct symbol_table *p = scope;
	struct symbol *sym = NULL;
	while (p && !sym) {
		for (int i = 0; i < p->num_syms; i++) {
			if (!strcmp(p->syms[i]->identifier, ident)) {
				sym = p->syms[i];
				break;
			}
		}
		p = p->parent;
	}

	return sym;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7dd9
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%r14), %r12
testq %r12, %r12
jle 0x7dd0
movq 0x10(%r14), %r13
xorl %ebp, %ebp
movq (%r13,%rbp,8), %r15
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x20c0
testl %eax, %eax
je 0x7ddc
incq %rbp
cmpq %rbp, %r12
jne 0x7db3
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x7da4
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/symbols.c
// Function: set_type
void set_type(struct symbol_table *scope, char *ident, struct type *type)
{
	scope->num_syms++;
	if (!scope->syms)
		scope->syms = malloc(sizeof(struct symbol *));
	else
		scope->syms =
		    realloc(scope->syms,
			    sizeof(struct symbol *) * scope->num_syms);
	struct symbol *s = malloc(sizeof(struct symbol));

	s->offset = 0;
	int len = strlen(ident);
	s->identifier = malloc(len+1);
	memcpy(s->identifier, ident, len);
	s->identifier[len] = 0;
     	s->type = type;
	s->size = resolve_size(type);
	scope->syms[scope->num_syms - 1] = s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x8(%rdi), %rsi
incq %rsi
movl %esi, 0x8(%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x7e40
shlq $0x3, %rsi
callq 0x2110
jmp 0x7e4a
movl $0x8, %edi
callq 0x2100
movq %rax, 0x10(%rbx)
movl $0x20, %edi
callq 0x2100
movq %rax, %r12
movq $0x0, (%rax)
movq %r15, %rdi
callq 0x2070
movq %rax, %r13
incl %eax
movslq %eax, %rdi
callq 0x2100
movq %rax, %rbp
movq %rax, 0x10(%r12)
movslq %r13d, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x20f0
movb $0x0, (%rbp,%r13)
movq %r14, 0x18(%r12)
movq %r14, %rdi
callq 0x80f0
cltq
movq %rax, 0x8(%r12)
movq 0x10(%rbx), %rax
movslq 0x8(%rbx), %rcx
movq %r12, -0x8(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/symbols.c
// Function: alloc_type
unsigned alloc_type(struct symbol_table *scope, char *ident)
{
	struct symbol *sym = get_symbol(scope, ident);
	if (!sym) return 0;
	/*If parent's frame pointer is greater than the current frame pointer, update it*/
	if (scope->parent && scope->parent->fp > scope->fp)
		scope->fp = scope->parent->fp;
	/*For now, default to integer*/
	scope->fp += sym->size;
	sym->offset = scope->fp;
	return sym->offset;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x7d8e
testq %rax, %rax
je 0x7ef9
movq %rax, %rcx
movq (%rbx), %rax
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0x7eed
movq (%rdx), %rdx
cmpq %rax, %rdx
cmovaq %rdx, %rax
addq 0x8(%rcx), %rax
movq %rax, (%rbx)
movq %rax, (%rcx)
jmp 0x7efb
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/types.c
// Function: types_merge
struct type *types_merge(struct type *t1, struct type *t2)
{
	struct type *t3 = t1 ? t1 : t2;
	if (t1) {
		while (t1->next)
			t1 = t1->next;
		t1->next = t2;
	}
	return t3;
}

// Assembly:
testq %rdi, %rdi
je 0x7f4a
movq %rdi, %rax
movq %rdi, %rdx
movq %rdx, %rcx
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
jne 0x7f39
movq %rsi, 0x20(%rcx)
retq
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/types.c
// Function: type_free
void type_free(struct type *head)
{
	if (!head)
		return;
	type_free(head->next);
	if (head->type == type_fcn) {
		for (int i = 0; i < head->info.fcn.paramc; i++) {
			free(head->info.fcn.paramv[i]);
			type_free(head->info.fcn.paramt[i]);
		}
		free(head->info.fcn.paramv);
		free(head->info.fcn.paramt);
	}
	free(head);
}

// Assembly:
testq %rdi, %rdi
je 0x7fb7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x7f4e
cmpl $0x3, 0x18(%rbx)
jne 0x7fa8
cmpl $0x0, (%rbx)
jle 0x7f96
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2030
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x7f4e
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x7f71
movq 0x8(%rbx), %rdi
callq 0x2030
movq 0x10(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/types.c
// Function: type_copy
struct type *type_copy(struct type *top)
{
	if (!top) return NULL;
	struct type *cpy = type_init(top->type);
	memcpy(&cpy->info, &top->info, sizeof(top->info));
	if (top->type == type_fcn) {
		struct func_type fcn = top->info.fcn;
		char **paramv  = malloc(sizeof(char*)*fcn.paramc);
		struct type **paramt = malloc(sizeof(struct type*)*fcn.paramc);
		for (int i = 0; i < fcn.paramc; i++) {
			int slen = strlen(fcn.paramv[i]);
			char *np = malloc(slen+1);
			memcpy(np, fcn.paramv[i], slen);
			np[slen] = 0;
			paramv[i] = np;
			paramt[i] = type_copy(fcn.paramt[i]);
		}
		cpy->info.fcn.paramv = paramv;
		cpy->info.fcn.paramt = paramt;
	}
	if (top->next) cpy->next = type_copy(top->next);
	return cpy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x80db
movq %rdi, %r15
movl 0x18(%rdi), %ebx
movl $0x28, %edi
callq 0x2100
movq %rax, %r14
movl %ebx, 0x18(%rax)
movq $0x0, 0x20(%rax)
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r15), %rax
movq %rax, 0x10(%r14)
cmpl $0x3, %ebx
jne 0x80c7
movq %r14, 0x10(%rsp)
movslq (%r15), %rbx
movq 0x8(%r15), %r13
movq %r15, 0x8(%rsp)
movq 0x10(%r15), %r15
leaq (,%rbx,8), %r12
movq %r12, %rdi
callq 0x2100
movq %rax, %rbp
movq %r12, %rdi
callq 0x2100
testq %rbx, %rbx
jle 0x80b5
xorl %r14d, %r14d
movq %r15, 0x20(%rsp)
movq %rbp, 0x18(%rsp)
movq %rax, (%rsp)
movq %r13, %r12
movq (%r13,%r14,8), %r13
movq %r13, %rdi
callq 0x2070
movq %rax, %rbp
incl %eax
movslq %eax, %rdi
callq 0x2100
movq %rbx, %r15
movq %rax, %rbx
movslq %ebp, %rbp
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %r13
movq %rbp, %rdx
callq 0x20f0
movb $0x0, (%rbx,%rbp)
movq 0x18(%rsp), %rbp
movq %rbx, (%rbp,%r14,8)
movq %r15, %rbx
movq 0x20(%rsp), %r15
movq (%r15,%r14,8), %rdi
callq 0x7fb8
movq (%rsp), %rcx
movq %rax, (%rcx,%r14,8)
movq (%rsp), %rax
incq %r14
cmpq %r14, %rbx
jne 0x804b
movq 0x10(%rsp), %r14
movq %rbp, 0x8(%r14)
movq %rax, 0x10(%r14)
movq 0x8(%rsp), %r15
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x80de
callq 0x7fb8
movq %rax, 0x20(%r14)
jmp 0x80de
xorl %r14d, %r14d
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/types.c
// Function: resolve_size
int resolve_size(struct type *type)
{
	struct type *head = type;
	int m = 1;
	while (head) {
		if (head->type == type_ptr) return PTR_SIZE*m;
		if (head->type == type_datatype) {
			switch (head->info.data_type) {
				case type_int: return INT_TYPE_SIZE*m;
				case type_char: return CHAR_TYPE_SIZE*m;
				default: break;
			}
		}
		if (head->type == type_array) m = m * head->info.elem;
		head = head->next;
	}
	/*Default to integer*/
	printf("Error resolving size of type: ");
	print_type(type);
	printf("\n");
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rdi, %rdi
je 0x812a
movl $0x1, %ebx
movq %r14, %rax
movl 0x18(%rax), %ecx
testl %ecx, %ecx
je 0x8115
cmpl $0x2, %ecx
jne 0x811c
imull (%rax), %ebx
jmp 0x8121
movl (%rax), %ecx
cmpl $0x2, %ecx
je 0x8151
cmpl $0x1, %ecx
je 0x814e
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x8104
leaq 0x1a84(%rip), %rdi      # 0x9bb5
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2080
movq %r14, %rdi
callq 0x815b
movl $0xa, %edi
callq 0x2040
jmp 0x8151
shll $0x2, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/types.c
// Function: print_type
void print_type(struct type *head)
{
	if (!head)
		return;
	switch (head->type) {
	case type_datatype:
		printf("%s", data_type_str[head->info.data_type]);
		print_type(head->next);
		break;
	case type_ptr:
		printf("ptr(");
		print_type(head->next);
		printf(")");
		break;
	case type_array:
		printf("arr(");
		print_type(head->next);
		printf(", %d)", head->info.elem);
		break;
	case type_fcn:
		printf("fcn( ");
		for (int i = 0; i < head->info.fcn.paramc; i++) {
			printf("%s: ", head->info.fcn.paramv[i]);
			print_type(head->info.fcn.paramt[i]);
			if ((i + 1) < head->info.fcn.paramc)
				printf(", ");
		}
		printf(") -> ");
		print_type(head->next);
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x822a
movq %rdi, %rbx
leaq 0x19ef(%rip), %r14      # 0x9b68
leaq 0x1049(%rip), %r12      # 0x91c9
leaq 0x1004(%rip), %r13      # 0x918b
leaq 0x1a5c(%rip), %rbp      # 0x9bea
movl 0x18(%rbx), %eax
cmpq $0x3, %rax
ja 0x822a
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movl (%rbx), %eax
leaq 0x6403(%rip), %rcx      # 0xe5b0
movq (%rcx,%rax,8), %rsi
leaq 0xfc5(%rip), %rdi       # 0x917d
xorl %eax, %eax
callq 0x2080
jmp 0x821d
leaq 0x1a1c(%rip), %rdi      # 0x9be4
xorl %eax, %eax
callq 0x2080
cmpl $0x0, (%rbx)
jle 0x8213
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2080
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x815b
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x820e
movq %r13, %rdi
xorl %eax, %eax
callq 0x2080
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x81d7
movq %rbp, %rdi
xorl %eax, %eax
callq 0x2080
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x818e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1994(%rip), %rdi      # 0x9bd4
xorl %eax, %eax
callq 0x2080
movq 0x20(%rbx), %rdi
callq 0x815b
movl $0x29, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
leaq 0x196a(%rip), %rdi      # 0x9bd9
xorl %eax, %eax
callq 0x2080
movq 0x20(%rbx), %rdi
callq 0x815b
movl (%rbx), %esi
leaq 0x1956(%rip), %rdi      # 0x9bde
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2080
// File: /workspace/github_c_makefile_star2_O3/Mithreindeir[P]ewcc/src/frontend/types.c
// Function: cmp_types
int cmp_types(struct type *a, struct type *b)
{
	if (!a || !b)
		return 0;
	if (a->next && b->next)
		return cmp_types(a->next, b->next);
	if ((!a->next && b->next) || (b->next && !a->next))
		return 0;
	if (a->type != b->type)
		return 0;
	if (a->type == type_datatype
	    && a->info.data_type != b->info.data_type)
		return 0;
	return 1;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x82c8
movq %rsi, %rcx
testq %rsi, %rsi
je 0x82c8
movq %rdi, %rdx
movq 0x20(%rdi), %rdi
movq 0x20(%rcx), %rsi
testq %rdi, %rdi
je 0x82c3
testq %rsi, %rsi
jne 0x829f
jmp 0x82c9
testq %rsi, %rsi
je 0x82c9
retq
movl 0x18(%rdx), %esi
cmpl 0x18(%rcx), %esi
jne 0x82c8
testl %esi, %esi
jne 0x82db
movl (%rdx), %edx
cmpl (%rcx), %edx
jne 0x82c8
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/main.c
// Function: main
int		main(int ac, char **av)
{
  t_list	list;
  t_anthill	anthill;
  t_ant		*ants;

  if (ac != 1 || av[1] != NULL)
    return (my_printf("USAGE:\n\t ./lem_in < map\n"));
  init(&anthill, &list);
  if (recup_info(&list, &anthill) == ERROR ||
      anthill.entry == NULL || anthill.exit == NULL)
    {
      printf_info(&list, &anthill);
      return (ERROR);
    }
  anthill.entry->ants = anthill.ants;
  check_graph(&anthill);
  if (anthill.entry->mark == FALSE)
    {
      printf_info(&list, &anthill);
      return (ERROR);
    }
  printf_info(&list, &anthill);
  if (!(ants = get_ants(anthill.entry->ants, &anthill)))
    return (1);
  move_ants(ants, &anthill);
  return (0);
}

// Assembly:
cmpl $0x1, %edi
jne 0x11c2
cmpq $0x0, 0x8(%rsi)
je 0x11d0
leaq 0x1e3b(%rip), %rdi      # 0x3004
xorl %eax, %eax
jmp 0x26b4
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movups %xmm0, 0x8(%rsi)
movq $0x0, 0x18(%rsi)
leaq 0x20(%rsp), %rdi
movl $0x0, (%rdi)
movups %xmm0, 0x8(%rdi)
callq 0x21d0
cmpl $0x1, %eax
je 0x1283
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x1283
cmpq $0x0, 0x10(%rsp)
je 0x1283
movq %rsp, %rbx
movl (%rbx), %ecx
movl %ecx, (%rax)
movq %rbx, %rdi
callq 0x2145
movq 0x8(%rbx), %rax
movl 0xc(%rax), %ebp
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x1ad0
movl $0x1, %ebx
testl %ebp, %ebp
je 0x12a9
movq 0x8(%rsp), %r15
movslq (%r15), %r14
testq %r14, %r14
setle %bpl
shlq $0x4, %r14
movq %r14, %rdi
callq 0x1090
testq %rax, %rax
sete %cl
orb %bpl, %cl
jne 0x1297
xorl %ecx, %ecx
movq %r15, (%rax,%rcx)
movq $0x0, 0x8(%rax,%rcx)
addq $0x10, %rcx
cmpq %rcx, %r14
jne 0x126b
jmp 0x129c
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x1ad0
movl $0x1, %ebx
jmp 0x12a9
testq %rax, %rax
je 0x12a9
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1dbc
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/tools2.c
// Function: free_tab
void	free_tab(char **tab)
{
  int	i;

  i = 0;
  if (tab != NULL)
    {
      while (tab[i])
	free(tab[i++]);
      free(tab);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x12f0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x12e1
leaq 0x8(%rbx), %r14
callq 0x1030
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x12d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/tools.c
// Function: my_putstr_error
int	my_putstr_error(const char *str)
{
  int	i;

  i = -1;
  while (str[++i])
    write(2, &str[i], i);
  return (ERROR);
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x1327
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
leaq (%rbx,%r14), %rsi
movl $0x2, %edi
movq %r14, %rdx
callq 0x1040
cmpb $0x0, 0x1(%rbx,%r14)
leaq 0x1(%r14), %r14
jne 0x1303
addq $0x8, %rsp
popq %rbx
popq %r14
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/tools.c
// Function: my_strcmp
int     my_strcmp(const char *s1, const char *s2)
{
  int   character;

  if (!s1 || !s2)
    return ((s1) ? 1 : (s2) ? -1 : 0);
  character = 0;
  while (s1[character] == s2[character] && s1[character] && s2[character])
    character = character + 1;
  if (s1[character] > s2[character])
    return (1);
  else if (s1[character] < s2[character])
    return (-1);
  else
    return (0);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x1366
xorl %eax, %eax
movb (%rdi,%rax), %cl
movb (%rsi,%rax), %dl
testb %dl, %dl
je 0x1354
testb %cl, %cl
je 0x1354
incq %rax
cmpb %dl, %cl
je 0x133f
movl $0x1, %eax
cmpb %dl, %cl
jg 0x1365
setl %al
movzbl %al, %eax
negl %eax
retq
xorl %ecx, %ecx
negq %rsi
sbbl %ecx, %ecx
testq %rdi, %rdi
movl $0x1, %eax
cmovel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/tools.c
// Function: my_strdup
char    *my_strdup(const char *src)
{
  char  *dest;
  int   i;
  int   n;

  i = 0;
  n = my_strlen(src);
  if ((dest = malloc(sizeof(char) * (n + 1))) == NULL)
    return (NULL);
  while (i < n)
    {
      dest[i] = src[i];
      ++i;
    }
  dest[i] = '\0';
  return (dest);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x24a4
movl %eax, %r15d
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x1090
movq %rax, %rbx
testq %rax, %rax
je 0x13bd
testl %r15d, %r15d
jle 0x13b5
movl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1080
jmp 0x13b8
xorl %r15d, %r15d
movb $0x0, (%rbx,%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/tools.c
// Function: my_compare
int     my_compare(char *s1, char *s2, int i)
{
  int	nb;

  nb = 0;
  while (i > 0 && s1[nb] != '\0' && s2[nb] != '\0')
    {
      if (s1[nb] != s2[nb])
	return (1);
      nb++;
      i--;
    }
  if (i == 0)
    return (0);
  if (my_strlen(s1) != my_strlen(s2))
    return (1);
  return (0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %edx, %edx
jle 0x13f3
movl %edx, %eax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
testb %dl, %dl
je 0x13f5
movb (%rbx,%rcx), %sil
testb %sil, %sil
je 0x13f5
cmpb %sil, %dl
jne 0x1413
incq %rcx
cmpq %rcx, %rax
jne 0x13d4
jmp 0x140f
je 0x140f
callq 0x24a4
movl %eax, %ebp
movq %rbx, %rdi
callq 0x24a4
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %ebp
setne %al
jmp 0x1418
xorl %eax, %eax
jmp 0x1418
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/get_next_line.c
// Function: get_next_line
char		*get_next_line(const int fd)
{
  int		i;
  char		read_c;
  char		*str;
  int		check;

  i = 0;
  read_c = 0;
  if ((check = read_char(fd, &read_c)) == -1)
    return (NULL);
  if ((str = malloc(sizeof(char) * (READ_SIZE + 1))) == NULL)
    return (NULL);
  my_memset(str, 0, READ_SIZE + 1 * sizeof(char));
  while (read_c != '\n')
    {
      str[i++] = read_c;
      if (read_char(fd, &read_c) < 0)
	break;
      if (i > (READ_SIZE + 1))
	if ((str = my_realloc(str, (i + (READ_SIZE + 1) * sizeof(*str)))) == NULL)
	  return (NULL);
    }
  if (str[i])
    str[i] = '\0';
  return (str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x7(%rsp), %rsi
movb $0x0, (%rsi)
callq 0x1562
cmpl $-0x1, %eax
je 0x1536
movl $0x1, %edi
movl $0x1001, %esi           # imm = 0x1001
callq 0x1070
testq %rax, %rax
je 0x1536
movq %rax, %r14
movb 0x7(%rsp), %al
cmpb $0xa, %al
jne 0x148f
movq %r14, %r12
jmp 0x1539
leaq 0x7(%rsp), %r15
xorl %ebp, %ebp
leaq 0x1(%rbp), %r13
movb %al, (%r14,%rbp)
movl %ebx, %edi
movq %r15, %rsi
callq 0x1562
testl %eax, %eax
js 0x154b
cmpq $0x1001, %rbp           # imm = 0x1001
jb 0x1522
movq %r14, %rdi
callq 0x24a4
cltq
leaq (%rax,%rbp), %rdi
addq $0x1002, %rdi           # imm = 0x1002
callq 0x1090
testq %rax, %rax
je 0x1536
movq %rax, %r12
addq $0x1002, %rbp           # imm = 0x1002
movq %r14, %rdi
callq 0x24a4
movslq %eax, %rdx
addq %rbp, %rdx
je 0x14fc
movq %r12, %rdi
xorl %esi, %esi
callq 0x1050
movb (%r14), %al
testb %al, %al
je 0x1515
xorl %ecx, %ecx
movb %al, (%r12,%rcx)
movb 0x1(%r14,%rcx), %al
incq %rcx
testb %al, %al
jne 0x1505
movq %r14, %rdi
callq 0x1030
movq %r12, %r14
jmp 0x1525
movq %r14, %r12
movb 0x7(%rsp), %al
movq %r13, %rbp
cmpb $0xa, %al
jne 0x1496
jmp 0x154e
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %r12
movslq %r13d, %rax
cmpb $0x0, (%r12,%rax)
je 0x1539
movslq %r13d, %rax
movb $0x0, (%r12,%rax)
jmp 0x1539
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/get_next_line.c
// Function: read_char
static int	read_char(const int fd, char *read_c)
{
  static char	buffer[READ_SIZE];
  static int	bytes_reads = 0;
  static int	y = 0;

  if (bytes_reads == 0)
    {
      if ((bytes_reads = read(fd, buffer, READ_SIZE)) <= 0)
	return (-1);
      y = 0;
    }
  *read_c = buffer[y];
  y = y + 1;
  bytes_reads = bytes_reads - 1;
  return (0);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl 0x4b04(%rip), %eax      # 0x6070
testl %eax, %eax
je 0x1578
movl 0x4afe(%rip), %ecx      # 0x6074
jmp 0x1595
leaq 0x3af1(%rip), %rsi      # 0x5070
movl $0x1000, %edx           # imm = 0x1000
callq 0x1060
movl %eax, 0x4ae1(%rip)      # 0x6070
xorl %ecx, %ecx
testl %eax, %eax
jle 0x15b8
movslq %ecx, %rcx
leaq 0x3ad1(%rip), %rdx      # 0x5070
movb (%rcx,%rdx), %dl
movb %dl, (%rbx)
incl %ecx
movl %ecx, 0x4ac8(%rip)      # 0x6074
decl %eax
movl %eax, 0x4abc(%rip)      # 0x6070
xorl %eax, %eax
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x15b6
nop
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/clear_file.c
// Function: epur_str
void    epur_str(char *str)
{
  int   i;
  int   j;

  i = 0;
  j = 0;
  while (str[i] != '\0')
    {
      if (str[i] != ' ' && str[i] != '\t')
        {
          str[j++] = str[i];
          if (str[i + 1] != '\0' && (str[i + 1] == ' ' || str[i + 1] == '\t'))
            str[j++] = ' ';
        }
      i++;
    }
  if (j != 0 && (str[j - 1] == ' ' || str[j - 1] == '\t'))
    str[j - 1] = '\0';
  str[j] = '\0';
}

// Assembly:
leaq 0x1(%rdi), %rax
xorl %ecx, %ecx
movzbl -0x1(%rax), %esi
cmpl $0x9, %esi
je 0x15f6
cmpl $0x20, %esi
je 0x15f6
testl %esi, %esi
je 0x15ff
movslq %ecx, %rdx
movb %sil, (%rdi,%rdx)
incq %rdx
movzbl (%rax), %esi
cmpl $0x20, %esi
je 0x15ef
cmpl $0x9, %esi
jne 0x15f8
addl $0x2, %ecx
movb $0x20, (%rdi,%rdx)
movl %ecx, %edx
incq %rax
movl %edx, %ecx
jmp 0x15c6
testl %ecx, %ecx
je 0x161c
movslq %ecx, %rax
movzbl -0x1(%rdi,%rax), %ecx
cmpl $0x20, %ecx
je 0x1615
cmpl $0x9, %ecx
jne 0x161e
movb $0x0, -0x1(%rdi,%rax)
jmp 0x161e
xorl %eax, %eax
movb $0x0, (%rdi,%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/parse.c
// Function: parse_info
int              parse_info(t_list *list, t_anthill *anthill)
{
  t_line	*element;

  element = list->first;
  if (check_number(element->line) == ERROR)
    return (ERROR);
  list->first->bool = TRUE;
  anthill->ants = my_getnbr(element->line);
  if (get_info(anthill, element, 0, 0) == ERROR ||
      anthill->entry == NULL || anthill->exit == NULL)
    return (ERROR);
  return (create_link(list, anthill));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x8(%rdi), %r14
movq (%r14), %rdi
callq 0x1970
cmpl $0x1, %eax
jne 0x1661
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x8(%rax)
movq (%r14), %rdi
callq 0x215c
movq 0x18(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
leaq 0x1981(%rip), %r15      # 0x301d
xorl %ebx, %ebx
movq (%r14), %rdi
movq %r15, %rsi
callq 0x132d
testl %eax, %eax
je 0x1770
movq (%r14), %rdi
leaq 0x196a(%rip), %rsi      # 0x3025
callq 0x132d
testl %eax, %eax
je 0x1791
movq (%r14), %rdi
movl $0x20, %esi
callq 0x22a4
testq %rax, %rax
je 0x164d
movq %rax, %r13
movq %rax, %rdi
callq 0x141f
cmpl $0x3, %eax
jne 0x1766
movl $0x30, %edi
callq 0x1090
testq %rax, %rax
je 0x164d
movq %rax, %rbp
movq (%r13), %rdi
callq 0x1379
movq %rax, 0x10(%rbp)
testq %rax, %rax
je 0x164d
movq %r13, %rdi
movq 0x18(%rsp), %rsi
movq %rbp, %rdx
callq 0x1a11
cmpl $0x1, %eax
je 0x164d
movl $0x0, 0xc(%rbp)
cmpl $0x1, %ebx
jne 0x174a
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x175b
cmpl $0x1, %r12d
jne 0x175e
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x175e
movq %rbp, (%rax)
movl $0x1, 0x8(%r14)
movq %r13, %rdi
callq 0x12b8
jmp 0x17b1
cmpl $0x2, %r12d
jl 0x1785
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x164d
testl %ebx, %ebx
jg 0x164d
incl %ebx
jmp 0x17b1
cmpl $0x2, %ebx
jl 0x17a5
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x164d
testl %r12d, %r12d
jg 0x164d
incl %r12d
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x169e
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x164d
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x164d
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17fc
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/create_edge.c
// Function: create_link
int		create_link(t_list *list, t_anthill *anthill)
{
  t_line        *element;
  char          **tab;
  char          *temp;

  element = list->first;
  while (element)
    {
      if (!(tab = my_str_to_wordtab(element->line, EDGE_CHAR)))
        return (ERROR);
      if (count_tab(tab) == 2)
        {
          if (create_edge(tab, anthill, 0, 0) == ERROR)
            return (ERROR);
          temp = tab[0];
          tab[0] = tab[1];
          tab[1] = temp;
          if (create_edge(tab, anthill, 0, 0) == ERROR)
            return (ERROR);
          element->bool = TRUE;
        }
      free_tab(tab);
      element = element->next;
    }
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x187e
movq %rsi, %rbx
movl $0x1, %ebp
movq (%r15), %rdi
movl $0x2d, %esi
callq 0x22a4
testq %rax, %rax
je 0x1880
movq %rax, %r14
movq %rax, %rdi
callq 0x141f
cmpl $0x2, %eax
jne 0x186d
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x188d
testl %eax, %eax
jne 0x1880
movdqu (%r14), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, (%r14)
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x188d
testl %eax, %eax
jne 0x1880
movl $0x1, 0x8(%r15)
movq %r14, %rdi
callq 0x12b8
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x1814
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/create_edge.c
// Function: create_edge
static int	create_edge(char **tab, t_anthill *anthill,
			    int found_first, int found_second)
{
  t_room        *room;
  t_room        *to_link;
  t_edge        *edge;
  t_edge        *edge_link;

  room = anthill->first;
  to_link = anthill->first;
  while (room && to_link && (found_first == 0 || found_second == 0))
    {
      if (my_strcmp(room->name, tab[0]) == 0)
        found_first = 1;
      else
        room = room->next;
      if (my_strcmp(to_link->name, tab[1]) == 0)
        found_second = 1;
      else
        to_link = to_link->next;
    }
  if (found_first == 0 || found_second == 0 ||
      !(edge = malloc(sizeof(*edge)))
      || !(edge_link = malloc(sizeof(*edge_link))))
    return (ERROR);
  linking(room, to_link, edge, edge_link);
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %ebx
testq %rsi, %rsi
je 0x195c
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq %rsi, %r12
xorl %r13d, %r13d
testl %ebp, %ebp
sete %al
testl %r13d, %r13d
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x190a
movq 0x10(%r12), %rdi
movq (%r15), %rsi
callq 0x132d
testl %eax, %eax
je 0x18de
movq 0x28(%r12), %r12
jmp 0x18e3
movl $0x1, %ebp
movq 0x10(%r14), %rdi
movq 0x8(%r15), %rsi
callq 0x132d
testl %eax, %eax
je 0x18fa
movq 0x28(%r14), %r14
jmp 0x1900
movl $0x1, %r13d
testq %r12, %r12
je 0x190a
testq %r14, %r14
jne 0x18b4
testl %ebp, %ebp
sete %al
testl %r13d, %r13d
sete %cl
orb %al, %cl
jne 0x195c
movl $0x10, %edi
callq 0x1090
testq %rax, %rax
je 0x195c
movq %rax, %r15
movl $0x10, %edi
callq 0x1090
testq %rax, %rax
je 0x195c
movq %r12, (%rax)
movq 0x20(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x20(%r14)
movq %r14, (%r15)
movq 0x20(%r12), %rax
movq %rax, 0x8(%r15)
movq %r15, 0x20(%r12)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/check_info.c
// Function: check_twice
int             check_twice(t_anthill *anthill,
			    const char *name,
			    const int x, const int y)
{
  t_room	*room;

  room = anthill->first;
  while (room)
    {
      if ((my_strcmp(room->name, name) == 0 ||
           (x == room->x && y == room->y)))
        return (ERROR);
      room = room->next;
    }
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %r15
testq %r15, %r15
je 0x19d6
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x132d
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x19d8
cmpl %ebp, 0x18(%r15)
jne 0x19cd
cmpl %ebx, 0x1c(%r15)
je 0x19d8
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0x19aa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/check_info.c
// Function: setup_room
int     setup_room(char **tab, t_anthill *anthill,
		   t_room *room)
{
  room->ants = 0;
  room->mark = FALSE;
  room->distance = -1;
  if ((check_pos(tab[1]) == ERROR) ||
      (check_pos(tab[2]) == ERROR))
    return (ERROR);
  room->x = my_getnbr(tab[1]);
  room->y = my_getnbr(tab[2]);
  if (check_twice(anthill, room->name,
		  room->x, room->y) == ERROR)
    return (0);
  room->next = anthill->first;
  anthill->first = room;
  room->edges = NULL;
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x0, (%rdx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x8(%rdx)
movq 0x8(%rdi), %rdi
movb (%rdi), %cl
testb %cl, %cl
je 0x1a58
leaq 0x1(%rdi), %rax
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
setb %dl
cmpb $0x2d, %cl
sete %cl
orb %dl, %cl
je 0x1ac4
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x1a3c
movq 0x10(%r15), %rax
movb (%rax), %cl
testb %cl, %cl
je 0x1a81
incq %rax
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
setb %dl
cmpb $0x2d, %cl
sete %cl
orb %dl, %cl
je 0x1ac4
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x1a65
callq 0x215c
movl %eax, 0x18(%rbx)
movq 0x10(%r15), %rdi
callq 0x215c
movl %eax, 0x1c(%rbx)
movq 0x10(%rbx), %rsi
movl 0x18(%rbx), %edx
movq %r14, %rdi
movl %eax, %ecx
callq 0x1993
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x1ac9
movq 0x18(%r14), %rcx
movq %rcx, 0x28(%rbx)
movq %rbx, 0x18(%r14)
movq $0x0, 0x20(%rbx)
jmp 0x1ac9
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/print_info.c
// Function: printf_info
void	printf_info(t_list *list, t_anthill *anthill)
{
  my_printf("#number_of_ants\n");
  my_printf("%i\n", anthill->ants);
  my_printf("#rooms\n");
  print_rooms(anthill->first, anthill);
  my_printf("#tunnels\n");
  print_tunnels(list);
  my_printf("#moves\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x154a(%rip), %rdi      # 0x302b
xorl %eax, %eax
callq 0x26b4
movl (%r14), %esi
leaq 0x157a(%rip), %rdi      # 0x306c
xorl %eax, %eax
callq 0x26b4
leaq 0x153c(%rip), %rdi      # 0x303c
xorl %eax, %eax
callq 0x26b4
movq 0x18(%r14), %rdi
movq %r14, %rsi
callq 0x1b96
leaq 0x152a(%rip), %rdi      # 0x3044
xorl %eax, %eax
callq 0x26b4
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x1b81
leaq 0x153f(%rip), %rbx      # 0x3070
movq (%r14), %rsi
movq %rsi, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
movzbl (%rdx), %edi
cmpl $0x2d, %edi
je 0x1b49
testl %edi, %edi
jne 0x1b4b
jmp 0x1b5e
incl %ecx
xorl %r8d, %r8d
cmpb $0x20, %dil
sete %r8b
addl %r8d, %eax
incq %rdx
jmp 0x1b3b
cmpl $0x1, %ecx
jne 0x1b78
testl %eax, %eax
jne 0x1b78
cmpl $0x1, 0x8(%r14)
jne 0x1b78
movq %rbx, %rdi
xorl %eax, %eax
callq 0x26b4
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x1b31
leaq 0x14c6(%rip), %rdi      # 0x304e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26b4
// File: /workspace/github_c_makefile_star2_O3/Vatoth[P]CPE_2016_Lemin/src/print_info.c
// Function: print_rooms
static void	print_rooms(t_room *room, t_anthill *anthill)
{
  if (room && anthill)
    {
      if (room->next)
	print_rooms(room->next, anthill);
      if (room == anthill->entry)
	my_printf("##start\n");
      else if (room == anthill->exit)
	my_printf("##end\n");
      my_printf("%s %i %i\n", room->name, room->x, room->y);
    }
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x1bd6
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1bc1
movq %r14, %rsi
callq 0x1b96
cmpq %rbx, 0x8(%r14)
je 0x1bd7
cmpq %rbx, 0x10(%r14)
jne 0x1be5
leaq 0x148b(%rip), %rdi      # 0x305f
jmp 0x1bde
retq
leaq 0x1478(%rip), %rdi      # 0x3056
xorl %eax, %eax
callq 0x26b4
movq 0x10(%rbx), %rsi
movl 0x18(%rbx), %edx
movl 0x1c(%rbx), %ecx
leaq 0x1470(%rip), %rdi      # 0x3066
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26b4