LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x25(%rbp)
je 0xada9
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xadb2
jmp 0xae1b
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xae0a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x20a0
cmpl $0x0, %eax
jne 0xadfd
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0xae0a
jmp 0xadff
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xadb9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xad90
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/symbols.c
// Function: get_type
struct type *get_type(struct symbol_table *scope, const char *ident)
{
	if (!scope)
		return NULL;
	struct symbol *sym = get_symbol(scope, ident);
	return sym ? sym->type : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xae51
movq $0x0, -0x8(%rbp)
jmp 0xae87
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xad70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xae77
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xae7f
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0xae7f
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/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xaee3
movl $0x8, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xaf07
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x20f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x20, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2050
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x20d0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0xb380
movslq %eax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xad70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xafe1
movl $0x0, -0x4(%rbp)
jmp 0xb03c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xb012
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0xb012
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/types.c
// Function: type_init
struct type *type_init(enum info_type node_type)
{
	struct type *t = malloc(sizeof(struct type));
	t->type = node_type;
	t->next = NULL;
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x28, %edi
callq 0x20e0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb0fd
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xb105
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb13b
jmp 0xb116
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb12f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xb116
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb168
jmp 0xb1e9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xb150
movq -0x8(%rbp), %rax
cmpl $0x3, 0x18(%rax)
jne 0xb1e0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xb1c6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xb150
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb186
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb210
movq $0x0, -0x8(%rbp)
jmp 0xb368
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
callq 0xb0a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x18(%rax)
jne 0xb33d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movslq -0x30(%rbp), %rdi
shlq $0x3, %rdi
callq 0x20e0
movq %rax, -0x38(%rbp)
movslq -0x30(%rbp), %rdi
shlq $0x3, %rdi
callq 0x20e0
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0xb325
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2050
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x20e0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movslq -0x48(%rbp), %rdx
callq 0x20d0
movq -0x50(%rbp), %rax
movslq -0x48(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x50(%rbp), %rdx
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xb1f0
movq %rax, %rdx
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xb290
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb360
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xb1f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb420
movq -0x18(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0xb3ba
movl -0x1c(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0xb44c
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xb3f8
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x1, %eax
je 0xb3de
jmp 0xb3d4
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0xb3e9
jmp 0xb3f4
movl -0x1c(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0xb44c
movl -0x1c(%rbp), %eax
shll $0x0, %eax
movl %eax, -0x4(%rbp)
jmp 0xb44c
jmp 0xb3f6
jmp 0xb3f8
movq -0x18(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jne 0xb40f
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
imull (%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xb39b
leaq 0x1770(%rip), %rdi      # 0xcb97
movb $0x0, %al
callq 0x2060
movq -0x10(%rbp), %rdi
callq 0xb460
leaq 0xfb1(%rip), %rdi       # 0xc3ef
movb $0x0, %al
callq 0x2060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb478
jmp 0xb5cd
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0xb5cd
movq -0x18(%rbp), %rax
leaq 0x16b0(%rip), %rcx      # 0xcb48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x50f0(%rip), %rax      # 0x105a0
movq (%rax,%rcx,8), %rsi
leaq 0xcf3(%rip), %rdi       # 0xc1ae
movb $0x0, %al
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xb460
jmp 0xb5cd
leaq 0x16db(%rip), %rdi      # 0xcbb6
movb $0x0, %al
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xb460
leaq 0xb56(%rip), %rdi       # 0xc04c
movb $0x0, %al
callq 0x2060
jmp 0xb5cd
leaq 0x16b2(%rip), %rdi      # 0xcbbb
movb $0x0, %al
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xb460
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x1696(%rip), %rdi      # 0xcbc0
movb $0x0, %al
callq 0x2060
jmp 0xb5cd
leaq 0x1689(%rip), %rdi      # 0xcbc6
movb $0x0, %al
callq 0x2060
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xb5b2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xcac(%rip), %rdi       # 0xc219
movb $0x0, %al
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xb460
movl -0xc(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xb5a5
leaq 0xc20(%rip), %rdi       # 0xc1be
movb $0x0, %al
callq 0x2060
jmp 0xb5a7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb54b
leaq 0x1613(%rip), %rdi      # 0xcbcc
movb $0x0, %al
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xb460
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb5fe
cmpq $0x0, -0x18(%rbp)
jne 0xb60a
movl $0x0, -0x4(%rbp)
jmp 0xb6b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb63a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb63a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0xb5e0
movl %eax, -0x4(%rbp)
jmp 0xb6b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xb650
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xb666
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb66f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xb66f
movl $0x0, -0x4(%rbp)
jmp 0xb6b0
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0xb688
movl $0x0, -0x4(%rbp)
jmp 0xb6b0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xb6a9
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0xb6a9
movl $0x0, -0x4(%rbp)
jmp 0xb6b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/frontend/types.c
// Function: dec_oper
enum operator  dec_oper(char *str)
{
	for (int i = 0; i < NUM_OPERATORS; i++) {
		if (!strcmp(str, operator_str[i])) {
			return i;
		}
	}
	return o_invalid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x1f, -0x14(%rbp)
jge 0xb70b
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x4db8(%rip), %rax      # 0x104a0
movq (%rax,%rcx,8), %rsi
callq 0x20a0
cmpl $0x0, %eax
jne 0xb6fe
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb712
jmp 0xb700
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb6d3
movl $0x1c, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/counter_example_2_pthread/code02.c
// Function: f
void* f()
{
    for(int n = 0; n < 1000; ++n) {
        atomic_fetch_add_explicit(&acnt, 1, memory_order_relaxed); // atomic
        ++cnt; // undefined behavior, in practice some updates missed
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x3e8, -0x4(%rbp)      # imm = 0x3E8
jge 0x11a3
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
lock
xaddl %eax, 0x2ebe(%rip)      # 0x4044
movl %eax, -0xc(%rbp)
movl 0x2eb9(%rip), %eax      # 0x4048
addl $0x1, %eax
movl %eax, 0x2eb0(%rip)      # 0x4048
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x116b
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/counter_example_2_pthread/code02.c
// Function: main
int main(void)
{
    pthread_t thr[10];
    for(int n = 0; n < 10; ++n)
        pthread_create(&thr[n], NULL, f, NULL);
    for(int n = 0; n < 10; ++n)
        pthread_join(thr[n], NULL);
 
    printf("The atomic counter is %u\n", acnt);
    printf("The non-atomic counter is %u\n", cnt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x64(%rbp)
cmpl $0xa, -0x64(%rbp)
jge 0x11f9
movslq -0x64(%rbp), %rax
leaq -0x60(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x86(%rip), %rdx       # 0x1160
movq %rcx, %rsi
callq 0x1040
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x11c6
movl $0x0, -0x68(%rbp)
cmpl $0xa, -0x68(%rbp)
jge 0x1223
movslq -0x68(%rbp), %rax
movq -0x60(%rbp,%rax,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x1200
movl 0x2e1b(%rip), %esi      # 0x4044
leaq 0xdd4(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl 0x2e0b(%rip), %esi      # 0x4048
leaq 0xdda(%rip), %rdi       # 0x201e
movb $0x0, %al
callq 0x1030
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Vatoth[P]CPE_2016_Lemin/src/main.c
// Function: init
void	init(t_anthill *anthill, t_list *list)
{
  anthill->first = NULL;
  anthill->exit = NULL;
  anthill->entry = NULL;
  list->first = NULL;
  list->last = NULL;
  list->len = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x11f7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x120d
leaq 0x2e06(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x3920
movl %eax, -0x4(%rbp)
jmp 0x12c5
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1170
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2fb0
cmpl $0x1, %eax
je 0x123a
cmpq $0x0, -0x40(%rbp)
je 0x123a
cmpq $0x0, -0x38(%rbp)
jne 0x1250
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2280
movl $0x1, -0x4(%rbp)
jmp 0x12c5
movl -0x48(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
leaq -0x48(%rbp), %rdi
callq 0x2e40
movq -0x40(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x1282
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2280
movl $0x1, -0x4(%rbp)
jmp 0x12c5
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2280
movq -0x40(%rbp), %rax
movl (%rax), %edi
leaq -0x48(%rbp), %rsi
callq 0x12d0
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
jne 0x12b1
movl $0x1, -0x4(%rbp)
jmp 0x12c5
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x27c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Vatoth[P]CPE_2016_Lemin/src/main.c
// Function: get_ants
static t_ant    *get_ants(int nb, t_anthill *anthill)
{
  t_ant         *ants;
  int           i;

  if (!(ants = malloc(sizeof(*ants) * nb)))
    return (NULL);
  i = 0;
  while (i < nb)
    {
      ants[i].now = anthill->entry;
      ants[i].next = NULL;
      i += 1;
    }
  return (ants);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x4, %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1300
movq $0x0, -0x8(%rbp)
jmp 0x1353
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x134b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1307
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13b1
jmp 0x137c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x13a8
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
jmp 0x137c
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1404
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rdx
movl $0x2, %edi
callq 0x1040
jmp 0x13d3
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x142a
cmpq $0x0, -0x18(%rbp)
jne 0x145b
cmpq $0x0, -0x10(%rbp)
je 0x143b
movl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1450
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1513
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movsbl (%rax,%rdx), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jne 0x14ae
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x14ae
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x14b7
jmp 0x14c2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1462
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x14e7
movl $0x1, -0x4(%rbp)
jmp 0x1513
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x150c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1513
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3470
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1565
movq $0x0, -0x8(%rbp)
jmp 0x15a4
jmp 0x1567
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x1590
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1567
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x21(%rbp)
jle 0x1600
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x1600
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1609
jmp 0x1642
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x162e
movl $0x1, -0x4(%rbp)
jmp 0x167f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15ca
cmpl $0x0, -0x1c(%rbp)
jne 0x1651
movl $0x0, -0x4(%rbp)
jmp 0x167f
movq -0x10(%rbp), %rdi
callq 0x3470
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3470
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
je 0x1678
movl $0x1, -0x4(%rbp)
jmp 0x167f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Vatoth[P]CPE_2016_Lemin/src/tools.c
// Function: count_tab
int	count_tab(char **tab)
{
  int	i;

  i = 0;
  while (tab[i])
    i++;
  return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x16b9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x169f
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Vatoth[P]CPE_2016_Lemin/src/get_next_line.c
// Function: my_memset
void    *my_memset(void *str, const int c, size_t n)
{
  char  *d;

  d = str;
  while (n > 0)
    {
      *d++ = c;
      n--;
    }
  return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x1702
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x16d7
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl -0xc(%rbp), %edi
leaq -0x11(%rbp), %rsi
callq 0x1810
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
jne 0x1747
movq $0x0, -0x8(%rbp)
jmp 0x1803
movl $0x1001, %edi           # imm = 0x1001
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1768
movq $0x0, -0x8(%rbp)
jmp 0x1803
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x1001, %edx           # imm = 0x1001
callq 0x16c0
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
je 0x17e1
movb -0x11(%rbp), %dl
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %edi
leaq -0x11(%rbp), %rsi
callq 0x1810
cmpl $0x0, %eax
jge 0x17ac
jmp 0x17e1
cmpl $0x1001, -0x10(%rbp)    # imm = 0x1001
jle 0x17df
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rsi
addq $0x1001, %rsi           # imm = 0x1001
callq 0x18a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x17dd
movq $0x0, -0x8(%rbp)
jmp 0x1803
jmp 0x17df
jmp 0x1778
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x17fb
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x583a(%rip)      # 0x7060
jne 0x185a
movl -0x8(%rbp), %edi
leaq 0x482e(%rip), %rsi      # 0x6060
movl $0x1000, %edx           # imm = 0x1000
callq 0x1050
movl %eax, 0x581e(%rip)      # 0x7060
cmpl $0x0, %eax
jg 0x1850
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1896
movl $0x0, 0x580a(%rip)      # 0x7064
movslq 0x5803(%rip), %rcx      # 0x7064
leaq 0x47f8(%rip), %rax      # 0x6060
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl 0x57ed(%rip), %eax      # 0x7064
addl $0x1, %eax
movl %eax, 0x57e4(%rip)      # 0x7064
movl 0x57da(%rip), %eax      # 0x7060
subl $0x1, %eax
movl %eax, 0x57d1(%rip)      # 0x7060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Vatoth[P]CPE_2016_Lemin/src/get_next_line.c
// Function: my_realloc
static char	*my_realloc(char *str, const size_t size)
{
  char		*my_str;
  int		i;

  i = 0;
  if ((my_str = malloc((size + my_strlen(str)) * sizeof(char))) == NULL)
    return (NULL);
  my_str = my_memset(my_str, 0, size + my_strlen(str));
  while (str[i])
    {
      my_str[i] = str[i];
      i++;
    }
  free(str);
  return (my_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3470
movq -0x30(%rbp), %rdi
cltq
addq %rax, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x18ee
movq $0x0, -0x8(%rbp)
jmp 0x195f
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3470
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rdi
cltq
addq %rax, %rdx
xorl %esi, %esi
callq 0x16c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x194e
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x191f
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1a49
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x1a3b
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0x1a3b
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1a39
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x1a23
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x1a39
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
movslq %ecx, %rcx
movb $0x20, (%rax,%rcx)
jmp 0x1a3b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1986
cmpl $0x0, -0x10(%rbp)
je 0x1a8c
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x1a7b
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x1a8c
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2010
cmpl $0x1, %eax
jne 0x1ad6
movl $0x1, -0x4(%rbp)
jmp 0x1b3e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2e80
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x1b50
cmpl $0x1, %eax
je 0x1b25
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1b25
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1b2e
movl $0x1, -0x4(%rbp)
jmp 0x1b3e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Vatoth[P]CPE_2016_Lemin/src/parse.c
// Function: get_info
static int              get_info(t_anthill *anthill, t_line *element,
				 int check_start, int check_exit)
{
  while (element)
    {
      if (my_strcmp(element->line, START_COMMENT) == 0)
        {
          if ((check_exit >= 2 && anthill->exit == NULL) || check_start > 0)
            return (ERROR);
          check_start++;
          element = element->next;
        }
      else if (my_strcmp(element->line, END_COMMENT) == 0)
        {
          if ((check_start >= 2 && anthill->entry == NULL) || check_exit > 0)
            return (ERROR);
          check_exit++;
          element = element->next;
        }
      else
        {
          if (parser(element, anthill, check_start, check_exit) == ERROR)
            return (ERROR);
          element = element->next;
        }
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c46
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x249e(%rip), %rsi      # 0x401d
callq 0x1410
cmpl $0x0, %eax
jne 0x1bc3
cmpl $0x2, -0x20(%rbp)
jl 0x1b9a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1ba0
cmpl $0x0, -0x1c(%rbp)
jle 0x1bac
movl $0x1, -0x4(%rbp)
jmp 0x1c4d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1c41
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x2454(%rip), %rsi      # 0x4025
callq 0x1410
cmpl $0x0, %eax
jne 0x1c12
cmpl $0x2, -0x1c(%rbp)
jl 0x1bec
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1bf2
cmpl $0x0, -0x20(%rbp)
jle 0x1bfb
movl $0x1, -0x4(%rbp)
jmp 0x1c4d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1c3f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x1c60
cmpl $0x1, %eax
jne 0x1c33
movl $0x1, -0x4(%rbp)
jmp 0x1c4d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1c41
jmp 0x1b66
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Vatoth[P]CPE_2016_Lemin/src/parse.c
// Function: parser
static int              parser(t_line *element, t_anthill *anthill,
			       const int check_start, const int check_exit)
{
  char                  **tab;
  t_room                *room;

  if (!(tab = my_str_to_wordtab(element->line, SEPARATOR_CHAR)))
    return (ERROR);
  if (count_tab(tab) == 3)
    {
      if (!(room = malloc(sizeof(*room))) ||
          !(room->name = my_strdup(tab[0]))
          || (setup_room(tab, anthill, room) == ERROR))
        return (ERROR);
      room->mark = FALSE;
      if (check_start == 1 && anthill->entry == NULL)
        anthill->entry = room;
      else if (check_exit == 1 && anthill->exit == NULL)
        anthill->exit = room;
      element->bool = TRUE;
    }
  free_tab(tab);
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x3100
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1c9d
movl $0x1, -0x4(%rbp)
jmp 0x1d60
movq -0x28(%rbp), %rdi
callq 0x1690
cmpl $0x3, %eax
jne 0x1d50
movl $0x30, %edi
callq 0x1060
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1cf3
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x1520
movq -0x30(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x1cf3
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2180
cmpl $0x1, %eax
jne 0x1cfc
movl $0x1, -0x4(%rbp)
jmp 0x1d60
movq -0x30(%rbp), %rax
movl $0x0, 0xc(%rax)
cmpl $0x1, -0x1c(%rbp)
jne 0x1d26
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1d26
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1d45
cmpl $0x1, -0x20(%rbp)
jne 0x1d43
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1d43
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1d45
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0x1360
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1e55
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl $0x2d, %esi
callq 0x3100
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1dbe
movl $0x1, -0x4(%rbp)
jmp 0x1e5c
movq -0x28(%rbp), %rdi
callq 0x1690
cmpl $0x2, %eax
jne 0x1e3b
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x1e70
cmpl $0x1, %eax
jne 0x1deb
movl $0x1, -0x4(%rbp)
jmp 0x1e5c
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x1e70
cmpl $0x1, %eax
jne 0x1e30
movl $0x1, -0x4(%rbp)
jmp 0x1e5c
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0x1360
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1d8c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x41(%rbp)
je 0x1ed1
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x41(%rbp)
je 0x1ed1
movb $0x1, %al
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x42(%rbp)
je 0x1ecb
cmpl $0x0, -0x20(%rbp)
sete %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1eda
jmp 0x1f3c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1410
cmpl $0x0, %eax
jne 0x1efc
movl $0x1, -0x1c(%rbp)
jmp 0x1f08
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1410
cmpl $0x0, %eax
jne 0x1f2b
movl $0x1, -0x20(%rbp)
jmp 0x1f37
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1e9e
cmpl $0x0, -0x1c(%rbp)
je 0x1f70
cmpl $0x0, -0x20(%rbp)
je 0x1f70
movl $0x10, %edi
callq 0x1060
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1f70
movl $0x10, %edi
callq 0x1060
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x1f79
movl $0x1, -0x4(%rbp)
jmp 0x1f95
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x1fa0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop