LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_sort.c
// Function: ft_sort
void	ft_sort(int *head, int *tail, int (*cmp)(int, int))
{
	int		*arr;
	int		nbr;
	int		ct;

	if (!cmp)
		cmp = ft_ascending;
	arr = head;
	nbr = (int)(tail - head);
	ct = nbr;
	while (--ct >= 0)
		ft_deep(arr, ct, nbr, cmp);
	while (--nbr >= 1)
	{
		ft_swap(arr + nbr, arr);
		ft_deep(arr, 0, nbr, cmp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
leaq -0x32(%rip), %r14       # 0x29e0
cmovneq %rdx, %r14
movq %rdi, %r15
subq %rdi, %rbx
shrq $0x2, %rbx
testl %ebx, %ebx
jle 0x2a43
leal 0x1(%rbx), %r12d
leal -0x2(%r12), %esi
movq %r15, %rdi
movl %ebx, %edx
movq %r14, %rcx
callq 0x2a87
decl %r12d
cmpl $0x1, %r12d
jg 0x2a28
cmpl $0x2, %ebx
jl 0x2a7e
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
decq %rbx
movl (%r15,%rbx,4), %eax
movl (%r15), %ecx
movl %ecx, (%r15,%rbx,4)
movl %eax, (%r15)
movq %r15, %rdi
xorl %esi, %esi
movl %ebx, %edx
movq %r14, %rcx
callq 0x2a87
leaq -0x1(%rbx), %rax
incq %rbx
cmpq $0x2, %rbx
movq %rax, %rbx
jg 0x2a51
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_sort.c
// Function: ft_deep
static void	ft_deep(int *arr, int index, int nbr, int (*cmp)(int, int))
{
	int	temp_index;

	if (index * 2 + 1 >= nbr)
		return ;
	if (index * 2 + 2 >= nbr)
		temp_index = index * 2 + 1;
	else
	{
		if (cmp(arr[index * 2 + 1], arr[index * 2 + 2]))
			temp_index = index * 2 + 2;
		else
			temp_index = index * 2 + 1;
	}
	if (cmp(arr[temp_index], arr[index]))
		return ;
	ft_swap(arr + index, arr + temp_index);
	ft_deep(arr, temp_index, nbr, cmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
leal 0x1(,%r12,2), %ebx
cmpl %r14d, %ebx
jge 0x2afd
leal (%r12,%r12), %r13d
addl $0x2, %r13d
cmpl %r14d, %r13d
jge 0x2ad3
movl %ebx, %eax
movl (%r15,%rax,4), %edi
movl %r13d, %eax
movl (%r15,%rax,4), %esi
callq *-0x30(%rbp)
testl %eax, %eax
je 0x2ad3
movl %r13d, %ebx
movl %ebx, %r13d
movl (%r15,%r13,4), %edi
movl %r12d, %r12d
movl (%r15,%r12,4), %esi
callq *-0x30(%rbp)
testl %eax, %eax
jne 0x2afd
movl (%r15,%r12,4), %eax
movl (%r15,%r13,4), %ecx
movl %ecx, (%r15,%r12,4)
movl %eax, (%r15,%r13,4)
movl %ebx, %r12d
jmp 0x2aa2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/binary_search.c
// Function: binary_search
int	binary_search(int *arr, int arr_size, int target)
{
	int	lb;
	int	ub;
	int	mid;

	lb = -1;
	ub = arr_size;
	while (ub - lb > 1)
	{
		mid = (ub + lb) / 2;
		if (arr[mid] < target)
			lb = mid;
		else if (arr[mid] > target)
			ub = mid;
		else
			return (mid);
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jle 0x2b47
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
leal (%rsi,%rcx), %r8d
movl %r8d, %eax
shrl $0x1f, %eax
addl %r8d, %eax
sarl %eax
movslq %eax, %r8
cmpl %edx, (%rdi,%r8,4)
jge 0x2b37
movl %eax, %ecx
movl %esi, %eax
jmp 0x2b39
jle 0x2b4c
movl %eax, %r8d
subl %ecx, %r8d
movl %eax, %esi
cmpl $0x1, %r8d
jg 0x2b19
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_sqrt.c
// Function: ft_sqrt
int	ft_sqrt(int n)
{
	long long	lb;
	long long	ub;
	long long	mid;

	if (n <= 1LL)
		return (n);
	lb = 0LL;
	ub = (long long)n;
	while (ub - lb > 1LL)
	{
		mid = (lb + ub) / 2LL;
		if (mid * mid <= (long long)n)
			lb = mid;
		else
			ub = mid;
	}
	return ((int)lb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
cmpl $0x2, %edi
jl 0x2b94
movslq %eax, %rcx
xorl %eax, %eax
movq %rcx, %rdx
leaq (%rdx,%rax), %rdi
movq %rdi, %rsi
shrq $0x3f, %rsi
addq %rdi, %rsi
sarq %rsi
movq %rsi, %rdi
imulq %rsi, %rdi
cmpq %rcx, %rdi
jg 0x2b85
movq %rsi, %rax
jmp 0x2b88
movq %rsi, %rdx
movq %rdx, %rsi
subq %rax, %rsi
cmpq $0x1, %rsi
jg 0x2b63
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/ch6/track_memory.c
// Function: alloc
void *alloc(void *ud,
            void *ptr,
            size_t osize,
            size_t nsize) {
  bytes_alloced += nsize - (ptr ? osize : 0);
  if (nsize) return realloc(ptr, nsize);
  free(ptr);
  return NULL;
}

// Assembly:
movq %rsi, %rdi
testq %rsi, %rsi
cmoveq %rsi, %rdx
movq %rcx, %rax
subq %rdx, %rax
addq %rax, 0x28ab5(%rip)     # 0x2d2c8
testq %rcx, %rcx
je 0x4820
movq %rcx, %rsi
jmp 0x43d0
pushq %rbp
movq %rsp, %rbp
callq 0x4050
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/src/jpeg.c
// Function: init
extern image_type_t *init(void)
{
	static image_type_t jpeg;
	jpeg.type = "JPEG";
	jpeg.is_type = is_jpeg;
	jpeg.read = read_jpeg;
	jpeg.write = write_jpeg;
	jpeg.info = info_jpeg;
	jpeg.free = free_jpeg;
	return &jpeg;
}

// Assembly:
leaq 0x3bbd(%rip), %rax      # 0x5000
movq %rax, 0x5c8e(%rip)      # 0x70d8
leaq 0x5c87(%rip), %rax      # 0x70d8
leaq 0x40(%rip), %rcx        # 0x1498
movq %rcx, 0x5c81(%rip)      # 0x70e0
leaq 0x92(%rip), %rcx        # 0x14f8
movq %rcx, 0x5c7b(%rip)      # 0x70e8
leaq 0x22b(%rip), %rcx       # 0x169f
movq %rcx, 0x5c75(%rip)      # 0x70f0
leaq 0x39d(%rip), %rcx       # 0x181f
movq %rcx, 0x5c6f(%rip)      # 0x70f8
leaq 0x3cd(%rip), %rcx       # 0x185d
movq %rcx, 0x5c69(%rip)      # 0x7100
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/src/jpeg.c
// Function: is_jpeg
static bool is_jpeg(char *file_name)
{
	FILE *fp = fopen(file_name, "rb");
	if (!fp)
		return false;

	uint8_t header[3];
	fread(header, 1, sizeof header, fp);
	fclose(fp);

	return !memcmp(header, jpeg_header, sizeof header);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x3b62(%rip), %rsi      # 0x5005
callq 0x10f0
testq %rax, %rax
je 0x14ee
movq %rax, %rbx
leaq 0x5(%rsp), %r14
movl $0x1, %esi
movl $0x3, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x1060
movq %rbx, %rdi
callq 0x1070
movzwl (%r14), %eax
xorl $0xd8ff, %eax           # imm = 0xD8FF
movzbl 0x2(%r14), %ecx
xorl $0xff, %ecx
orw %ax, %cx
sete %al
jmp 0x14f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/src/jpeg.c
// Function: write_jpeg
static int write_jpeg(image_info_t image_info, void (*progress_update)(uint64_t, uint64_t))
{
	errno = EXIT_SUCCESS;

	FILE *fp = fopen(image_info.file, "wb");
	if (!fp)
		return errno;

	jpeg_message_t msg = { image_info.width, NULL };
	msg.data = malloc(msg.size); // total capacity

	/* retrieve the image data */
	jpeg_image_t *image = image_info.extra;

	/* copy message from image_info.buffer to message.data */
	for (uint64_t x = 0, i = 0; x < image_info.width * image_info.bpp; x += image_info.bpp, i++)
	{
		msg.data[i]  = (image_info.buffer[0][x + 0] & 0x07) << 5;
		msg.data[i] |= (image_info.buffer[0][x + 1] & 0x03) << 3;
		msg.data[i] |= (image_info.buffer[0][x + 2] & 0x07);
		if (progress_update)
			progress_update(x, image_info.width);
	}
	free(image_info.buffer[0]);
	free(image_info.buffer);

	/* get actual message length from data */
	memcpy(&msg.size, msg.data, sizeof msg.size);
	msg.size = ntohll(msg.size);

	/* write the message to the image */
	jpeg_encode_data(fp, &msg, image);

	free(msg.data);
	for (uint64_t i = 0; i < image->height; i++)
		free(image->rgb[i]);
	free(image->rgb);
	free(image);

	fclose(fp);

	return errno;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r12
callq 0x1050
movq %rax, %rbx
movl $0x0, (%rax)
movq 0x70(%rsp), %rdi
leaq 0x393e(%rip), %rsi      # 0x5008
callq 0x10f0
testq %rax, %rax
je 0x180e
movq %rax, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
leaq 0x70(%rsp), %rbx
movq 0x30(%rbx), %r13
movq %r13, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq %r13, %rdi
callq 0x1110
movq %rax, 0x10(%rsp)
movq 0x48(%rbx), %r15
movzwl 0x38(%rbx), %eax
movq %r13, 0x28(%rsp)
movq %rax, 0x30(%rsp)
imulq %rax, %r13
testq %r13, %r13
je 0x1781
leaq 0x70(%rsp), %rax
movq 0x40(%rax), %r14
xorl %ebx, %ebx
xorl %ebp, %ebp
movq (%r14), %rax
movb (%rax,%rbp), %al
shlb $0x5, %al
movq 0x10(%rsp), %rcx
movb %al, (%rcx,%rbx)
movq (%r14), %rax
movb 0x1(%rax,%rbp), %al
shlb $0x3, %al
andb $0x18, %al
movq 0x10(%rsp), %rcx
orb %al, (%rcx,%rbx)
movq (%r14), %rax
movb 0x2(%rax,%rbp), %al
andb $0x7, %al
movq 0x10(%rsp), %rcx
orb %al, (%rcx,%rbx)
testq %r12, %r12
je 0x1774
movq %rbp, %rdi
movq 0x28(%rsp), %rsi
callq *%r12
addq 0x30(%rsp), %rbp
incq %rbx
cmpq %r13, %rbp
jb 0x172e
leaq 0x70(%rsp), %rax
movq 0x40(%rax), %r12
movq (%r12), %rdi
callq 0x1040
movq %r12, %rdi
callq 0x1040
leaq 0x8(%rsp), %r12
movq 0x8(%r12), %rax
movq (%rax), %rax
bswapq %rax
movq %rax, (%r12)
movq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1120
movq 0x8(%r12), %rdi
callq 0x1040
cmpl $0x0, 0xc(%r15)
je 0x17ed
xorl %ebx, %ebx
movq (%r15), %rax
movq (%rax,%rbx,8), %rdi
callq 0x1040
incq %rbx
movl 0xc(%r15), %eax
cmpq %rax, %rbx
jb 0x17d5
movq (%r15), %rdi
callq 0x1040
movq %r15, %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1070
movq 0x20(%rsp), %rax
movl (%rax), %eax
jmp 0x1810
movl (%rbx), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/src/jpeg.c
// Function: info_jpeg
extern uint64_t info_jpeg(image_info_t *image_info)
#endif
{
	data_info_t extra = { NULL, 0, true, false };
	image_info->extra = &extra;
	read_jpeg(image_info, NULL);
	return HIDE_CAPACITY;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x37fa(%rip), %rax      # 0x5028
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups 0x37dc(%rip), %xmm0     # 0x5018
movaps %xmm0, (%rcx)
movq %rcx, 0x48(%rdi)
xorl %esi, %esi
callq 0x14f8
movq 0x28(%rbx), %rax
imulq 0x30(%rbx), %rax
addq $-0x8, %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/src/jpeg.c
// Function: free_jpeg
extern void free_jpeg(image_info_t image_info)
#endif
{
	free(image_info.buffer[0]);
	free(image_info.buffer);
	jpeg_image_t *image = image_info.extra;
	for (uint64_t i = 0; i < image->height; i++)
		free(image->rgb[i]);
	free(image->rgb);
	free(image);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x60(%rsp), %rbx
movq (%rbx), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1040
movq 0x68(%rsp), %rbx
cmpl $0x0, 0xc(%rbx)
je 0x189b
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1040
incq %r14
movl 0xc(%rbx), %eax
cmpq %rax, %r14
jb 0x1884
movq (%rbx), %rdi
callq 0x1040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
nop
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/src/jpeg-load.c
// Function: BuildHuffmanTable
static void BuildHuffmanTable(const uint8_t *bits, stHuffmanTable *HT)
{
	// Takes two array of bits, and build the huffman table for size, and code
	for (int j = 1; j <= 16; j++)
		HT->m_length[j] = bits[j];

	// Work out the total number of codes
	int numBlocks = 0;
	for (int i = 1; i <= 16; i++)
		numBlocks += HT->m_length[i];
	HT->m_numBlocks = numBlocks;

	// Fill in the data our our blocks, so we know how many bits each
	// one is
	for (int i = 1, c = 0; i <= 16; i++)
		for (int j = 0; j < HT->m_length[i]; j++, c++)
			HT->m_blocks[c].length = i;

	GenHuffCodes(HT->m_numBlocks, HT->m_blocks, HT->m_hufVal);
}

// Assembly:
xorl %eax, %eax
movb 0x1(%rdi,%rax), %cl
movb %cl, 0x1(%rsi,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x2239
xorl %ecx, %ecx
xorl %eax, %eax
movzbl 0x1(%rsi,%rcx), %edx
addl %edx, %eax
incq %rcx
cmpq $0x10, %rcx
jne 0x224e
movl %eax, 0x114(%rsi)
leaq 0x11c(%rsi), %rcx
xorl %edx, %edx
movl $0x1, %edi
cmpb $0x0, (%rsi,%rdi)
je 0x229d
movslq %edx, %r8
leaq (%r8,%r8,2), %r8
leaq (%rcx,%r8,4), %r9
xorl %r8d, %r8d
movl %edi, (%r9)
incl %r8d
movzbl (%rsi,%rdi), %r10d
addq $0xc, %r9
cmpl %r10d, %r8d
jb 0x2286
addl %r8d, %edx
incq %rdi
cmpq $0x11, %rdi
jne 0x2272
testl %eax, %eax
je 0x22f4
leaq 0x118(%rsi), %rcx
movl %eax, %eax
xorl %edx, %edx
movl $0x1, %r8d
xorl %edi, %edi
leaq (%rdx,%rdx,2), %r9
movl 0x4(%rcx,%r9,4), %r10d
movl %r10d, %r11d
subl %r8d, %r11d
jle 0x22d8
addl %edi, %edi
decl %r11d
jne 0x22ce
movl %r10d, %r8d
leaq (%rcx,%r9,4), %r9
movw %di, 0x8(%r9)
movzbl 0x11(%rsi,%rdx), %r10d
movl %r10d, (%r9)
incq %rdx
incl %edi
cmpq %rax, %rdx
jne 0x22bd
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/src/jpeg-save.c
// Function: writebits
static void writebits(bitstring bs)
{
	// bit position in the bitstring we read, should be<=15 and >=0
	for (int posval = bs.length - 1; posval >= 0; )
	{
		if (bs.value & mask[posval])
			bytenew |= mask[bytepos];
		posval--;
		bytepos--;
		if (bytepos < 0)
		{
			if (bytenew == 0xFF)
			{
				writebyte(0xFF);
				writebyte(0);
			}
			else
				writebyte(bytenew);
			bytepos = 7;
			bytenew = 0;
		}
	}
}

// Assembly:
testb %dil, %dil
je 0x3b7f
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
shrl $0x10, %ebx
movzbl %dil, %r14d
incq %r14
leaq 0x19ef(%rip), %r15      # 0x5500
movzwl -0x4(%r15,%r14,2), %eax
testl %eax, %ebx
je 0x3b2d
movsbq 0x358f(%rip), %rax      # 0x70b2
movb (%r15,%rax,2), %al
orb %al, 0x3637(%rip)       # 0x7164
decb 0x357f(%rip)            # 0x70b2
jns 0x3b71
movzbl 0x3628(%rip), %edi      # 0x7164
cmpl $0xff, %edi
jne 0x3b57
movq 0x360d(%rip), %rsi      # 0x7158
movl $0xff, %edi
callq 0x10b0
xorl %edi, %edi
movq 0x35fa(%rip), %rsi      # 0x7158
callq 0x10b0
movb $0x7, 0x3548(%rip)      # 0x70b2
movb $0x0, 0x35f3(%rip)      # 0x7164
decq %r14
cmpq $0x1, %r14
jg 0x3b11
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/ArvoreSintaticaAbstrata.c
// Function: getStringTipo
char* getStringTipo (Tipo *t) {

    Tipo *aux = t;
    char *strbase = strFormatoTipo(t->tipo_base);
    char *arrayde = "array de ";
    char *str;
    int arrayCounts = 0;

    if(t == NULL) {
      printf("TIPO NULL");
      return NULL;
    }
    while (aux->de != NULL) {
      arrayCounts++;
      aux = aux->de;
    }

    str = (char*)malloc((strlen(arrayde)*arrayCounts + strlen(strbase) + 1) * sizeof(char));
    if (str == NULL){printf("falta de memoria"); exit(1);}
    str[0] = '\0';
    while(arrayCounts) {
      strcat(str,arrayde);
      arrayCounts--;
    }
    strcat(str,strbase);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x4(%rdi), %eax
cmpq $0x3, %rax
ja 0x3428
leaq 0x3c89(%rip), %rcx      # 0x70a8
movslq (%rcx,%rax,4), %rbx
addq %rcx, %rbx
jmp 0x342f
leaq 0x3d0e(%rip), %rbx      # 0x713d
testq %rdi, %rdi
je 0x34a9
movl $0x1, %r15d
movl $0x8, %r14d
movq 0x8(%rdi), %rdi
decl %r15d
addq $-0x9, %r14
testq %rdi, %rdi
jne 0x3440
movq %rbx, %rdi
callq 0x10b0
subq %r14, %rax
movq %rax, %rdi
callq 0x1160
testq %rax, %rax
je 0x34c2
movq %rax, %r14
movb $0x0, (%rax)
testl %r15d, %r15d
je 0x3496
movabsq $0x6564207961727261, %r12 # imm = 0x6564207961727261
movq %r14, %rdi
callq 0x10b0
movq %r12, (%r14,%rax)
movw $0x20, 0x8(%r14,%rax)
incl %r15d
jne 0x347d
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11a0
leaq 0x3c4e(%rip), %rdi      # 0x70fe
xorl %eax, %eax
callq 0x10c0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c3f(%rip), %rdi      # 0x7108
xorl %eax, %eax
callq 0x10c0
movl $0x1, %edi
callq 0x11c0
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/ArvoreSintaticaAbstrata.c
// Function: print_tree
void print_tree (Programa *p) {
  int nivel = 0;
  if (p != NULL){
    printf("Nivel\t No\n");
    printf("%d\t [Programa]\n",nivel);
    print_defs(p->defs,nivel+1);
  }
  else
    printf("[Programa vazio]\n");
}

// Assembly:
testq %rdi, %rdi
je 0x3658
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x4004(%rip), %rdi      # 0x7502
callq 0x1070
leaq 0x3c0f(%rip), %rdi      # 0x7119
xorl %esi, %esi
xorl %eax, %eax
callq 0x10c0
movq (%rbx), %r14
testq %r14, %r14
je 0x3649
movl $0x1, %r15d
leaq 0x3c1c(%rip), %r13      # 0x7148
leaq 0x3c86(%rip), %rbx      # 0x71b9
movq %r13, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x10c0
movl (%r14), %eax
testl %eax, %eax
je 0x358a
cmpl $0x1, %eax
jne 0x3639
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x3639
movq %r15, -0x30(%rbp)
incl %r15d
movq 0x8(%r12), %rdi
callq 0x3404
cmpl $0x0, 0x14(%r12)
movq (%r12), %rdx
je 0x3621
leaq 0x3bf7(%rip), %rdi      # 0x717c
jmp 0x3628
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x3639
movq %r15, -0x30(%rbp)
leal 0x1(%r15), %r13d
movq (%rax), %rdi
movq 0x10(%rax), %r12
movq %rax, %r15
callq 0x3404
movq %r15, -0x38(%rbp)
movq 0x8(%r15), %rdx
leaq 0x3be1(%rip), %rdi      # 0x719e
movl %r13d, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x10c0
testq %r12, %r12
je 0x3603
movl $0x1, %r15d
movq (%r12), %rdi
callq 0x3404
movq 0x8(%r12), %rcx
movq %rbx, %rdi
movl %r13d, %esi
movl %r15d, %edx
movq %rax, %r8
xorl %eax, %eax
callq 0x10c0
movq 0x18(%r12), %r12
incl %r15d
testq %r12, %r12
jne 0x35d5
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %r15
leal 0x2(%r15), %esi
callq 0x3664
leaq 0x3b29(%rip), %r13      # 0x7148
jmp 0x3639
leaq 0x3b31(%rip), %rdi      # 0x7159
movl %r15d, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x10c0
movq -0x30(%rbp), %r15
incl %r15d
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x3533
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3e92(%rip), %rdi      # 0x74f1
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/ArvoreSintaticaAbstrata.c
// Function: print_bloco
static void print_bloco (Bloco *b, int nivel) {
    DefVarL *aux = b->declVars;
    CMDL *auxcmd = b->cmds;
    int nivelaux = nivel;

    if (b == NULL) return;
    printf ("%d\t [Bloco]\n",nivel);
    while (aux != NULL){
      nivelaux++;
      printf("%d\t [Def Var] %s : %s\n",nivelaux,aux->v->id,getStringTipo(aux->v->tipo));
      aux = aux->prox;
    }
    nivelaux = nivel;
    while (auxcmd != NULL) {
      nivelaux++;
      print_cmd(auxcmd->c,nivelaux);
      auxcmd = auxcmd->prox;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq (%rdi), %r15
movq 0x8(%rdi), %r13
leaq 0x3b53(%rip), %rdi      # 0x71d5
xorl %eax, %eax
callq 0x10c0
testq %r15, %r15
je 0x36c4
leal 0x1(%rbx), %r14d
movq (%r15), %rax
movq (%rax), %r12
movq 0x8(%rax), %rdi
callq 0x3404
leaq 0x3b3a(%rip), %rdi      # 0x71e2
movl %r14d, %esi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x10c0
movq 0x8(%r15), %r15
incl %r14d
testq %r15, %r15
jne 0x3692
testq %r13, %r13
je 0x381c
incl %ebx
leaq 0x3982(%rip), %r15      # 0x7058
movq (%r13), %r12
testq %r12, %r12
je 0x380d
movl (%r12), %eax
cmpq $0x9, %rax
ja 0x37e0
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
leaq 0x3af8(%rip), %rdi      # 0x71f9
movl %ebx, %esi
xorl %eax, %eax
callq 0x10c0
movq 0x8(%r12), %rdi
leal 0x1(%rbx), %r14d
movl %r14d, %esi
callq 0x382b
movq 0x10(%r12), %rdi
movl %r14d, %esi
jmp 0x37c7
leaq 0x3b71(%rip), %rdi      # 0x72a0
jmp 0x37d5
leaq 0x3b54(%rip), %rdi      # 0x728f
jmp 0x37b6
leaq 0x3add(%rip), %rdi      # 0x7221
jmp 0x378b
leaq 0x3ae2(%rip), %rdi      # 0x722f
movl %ebx, %esi
xorl %eax, %eax
callq 0x10c0
movq 0x8(%r12), %rdi
leal 0x1(%rbx), %r14d
movl %r14d, %esi
callq 0x38e1
movq 0x10(%r12), %rdi
movl %r14d, %esi
callq 0x3664
movq 0x18(%r12), %rdi
jmp 0x37aa
leaq 0x3ae9(%rip), %rdi      # 0x726b
jmp 0x37b6
leaq 0x3a85(%rip), %rdi      # 0x7210
movl %ebx, %esi
xorl %eax, %eax
callq 0x10c0
movq 0x8(%r12), %rdi
leal 0x1(%rbx), %r14d
movl %r14d, %esi
callq 0x38e1
movq 0x10(%r12), %rdi
movl %r14d, %esi
jmp 0x3808
leaq 0x3a8c(%rip), %rdi      # 0x7242
movl %ebx, %esi
xorl %eax, %eax
callq 0x10c0
movq 0x8(%r12), %rdi
leal 0x1(%rbx), %esi
callq 0x38e1
jmp 0x380d
leaq 0x3a7f(%rip), %rdi      # 0x7254
movl %ebx, %esi
xorl %eax, %eax
callq 0x10c0
jmp 0x380d
leaq 0x3ac9(%rip), %rdi      # 0x72b0
xorl %eax, %eax
callq 0x10c0
jmp 0x380d
leaq 0x3a87(%rip), %rdi      # 0x727e
movl %ebx, %esi
xorl %eax, %eax
callq 0x10c0
movq 0x8(%r12), %rdi
leal 0x1(%rbx), %esi
callq 0x3664
movq 0x8(%r13), %r13
incl %ebx
testq %r13, %r13
jne 0x36d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/ArvoreSintaticaAbstrata.c
// Function: print_variavel
static void print_variavel(Var* v, int nivel) {
  if (v == NULL) return;


  if (v->tag == vVar) {
    printf("%d\t [Variavel %s] %s : %s\n",nivel,getStringEscopo(v->u.vvar.escopo),v->u.vvar.id,getStringTipo(v->tipo));
  }
  else if (v->tag == vAcesso) {
    printf("%d\t [Exp Acesso : %s]\n",nivel, getStringTipo(v->tipo));
    print_exp(v->u.vacesso.expvar,nivel+1);
    print_exp(v->u.vacesso.expindex,nivel+1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3864
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x386f
testl %eax, %eax
jne 0x3864
movl 0x18(%r14), %eax
cmpq $0x2, %rax
ja 0x38aa
leaq 0x385d(%rip), %rcx      # 0x70b8
movslq (%rcx,%rax,4), %r15
addq %rcx, %r15
jmp 0x38b1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdi
callq 0x3404
leaq 0x3a5b(%rip), %rdi      # 0x72da
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10c0
movq 0x10(%r14), %rdi
incl %ebx
movl %ebx, %esi
callq 0x38e1
movq 0x18(%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x38e1
leaq 0x3a58(%rip), %r15      # 0x7309
movq 0x8(%r14), %rdi
movq 0x10(%r14), %r14
callq 0x3404
leaq 0x39fa(%rip), %rdi      # 0x72bf
movl %ebx, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/TabelaSimbolos.c
// Function: tipa_arvore
void tipa_arvore(Programa *p) {

    Definicao *auxdef;
    Simbolo *s = NULL;
    int nivelEscopo = 0;

    if (p == NULL) return;

    //todas variaveis globais e declaracoes de funcoes
    auxdef = p->defs;
    while (auxdef != NULL) {
        if (auxdef->tag == DVar) {
          s = cria_no_var(s,auxdef->u.v ,nivelEscopo);
        }
        if (auxdef->tag == DFunc) {
          s = cria_no_func(s,auxdef->u.f,nivelEscopo);
        }
        auxdef = auxdef->prox;
      }
      //print_simbolos(s);
    auxdef = p->defs;
    while (auxdef != NULL) {
        if (auxdef->tag == DFunc) {
          //s = cria_no_func(s,auxdef->u.f,nivelEscopo);
          s = cria_no_param(s,auxdef->u.f->params,nivelEscopo+1);

          s = tipa_bloco(s,auxdef->u.f->bloco,nivelEscopo+1);
        }
        auxdef = auxdef->prox;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3c4f
movq %rdi, -0x30(%rbp)
movq (%rdi), %r12
xorl %edi, %edi
testq %r12, %r12
je 0x3c03
cmpl $0x1, (%r12)
jne 0x3b7f
movq 0x8(%r12), %rsi
xorl %edx, %edx
callq 0x3c82
movq %rax, %rdi
cmpl $0x0, (%r12)
jne 0x3bf9
movq 0x8(%r12), %r13
movq %rdi, %r14
testq %rdi, %rdi
je 0x3be2
movq %r14, %rbx
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x3bbd
testl %eax, %eax
jne 0x3bd9
movq 0x8(%rbx), %rax
movq (%rax), %rdi
movq 0x8(%r13), %r15
movq %r15, %rsi
callq 0x1100
testl %eax, %eax
jne 0x3bd9
jmp 0x3c5e
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x8(%r13), %r15
movq %r15, %rsi
callq 0x1100
testl %eax, %eax
je 0x3c67
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x3b96
movq %r14, %rdi
xorl %esi, %esi
callq 0x3fe5
movq %rax, %rdi
movl $0x1, (%rax)
movq %r13, 0x8(%rax)
movq 0x10(%r12), %r12
jmp 0x3b60
movq -0x30(%rbp), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x3c4f
cmpl $0x0, (%r14)
jne 0x3c49
movq 0x8(%r14), %rax
movq 0x10(%rax), %rbx
movl $0x1, %esi
callq 0x3fe5
movl $0x2, (%rax)
movq %rbx, 0x8(%rax)
movq 0x8(%r14), %rcx
movq 0x18(%rcx), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x3d6f
movq %rax, %rdi
movq 0x10(%r14), %r14
jmp 0x3c0a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x393f(%rip), %rdi      # 0x75a4
jmp 0x3c6e
leaq 0x396c(%rip), %rdi      # 0x75da
movq %r15, %rsi
xorl %eax, %eax
callq 0x10c0
movl $0x1, %edi
callq 0x11c0
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/TabelaSimbolos.c
// Function: cria_no_var
static Simbolo* cria_no_var(Simbolo *s, DefVar *v, int nivelEscopo) {
    Simbolo *aux,*nv;

    aux = s;
    while(aux != NULL && aux->escopo == nivelEscopo) {
      if (aux->tag == SVar) {
          if (strcmp(aux->u.v->id, v->id) == 0) {
            printf("[Erro] Redefinicao da variavel %s\n",v->id);
            exit(1);
          }
      }
      else if (aux->tag == SParams) {
        ParametroL *p = aux->u.p;
        while(p != NULL) {
          if(strcmp(p->id, v->id) == 0) {
            printf("[Erro] Redefinicao da variavel \"%s\"\n",v->id);
            exit(1);
          }
          p = p->prox;
        }
      }
      else if (aux->tag == SFunc) {
        if (strcmp(aux->u.f->id, v->id) == 0) {
          printf("[Erro] Redefinicao de \"%s\" para um simbolo diferente\n",v->id);
          exit(1);
        }
      }
      aux = aux->ant;
    }

    nv = cria_no_final(s,nivelEscopo);
    nv->tag = SVar;
    nv->u.v = v;
    return nv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
testq %rdi, %rdi
je 0x3d1d
movq -0x30(%rbp), %r13
cmpl %r14d, 0x10(%r13)
jne 0x3d1d
movl (%r13), %eax
cmpl $0x2, %eax
je 0x3cef
cmpl $0x1, %eax
je 0x3cd6
testl %eax, %eax
jne 0x3d14
movq 0x8(%r13), %rax
movq (%rax), %rdi
movq (%rbx), %r12
movq %r12, %rsi
callq 0x1100
testl %eax, %eax
jne 0x3d14
jmp 0x3d5d
movq 0x8(%r13), %rax
movq 0x8(%rax), %rdi
movq (%rbx), %r12
movq %r12, %rsi
callq 0x1100
testl %eax, %eax
jne 0x3d14
jmp 0x3d66
movq 0x8(%r13), %r15
testq %r15, %r15
je 0x3d14
movq (%rbx), %r12
movq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x1100
testl %eax, %eax
je 0x3d42
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x3cfb
movq 0x20(%r13), %r13
testq %r13, %r13
jne 0x3ca3
movq -0x30(%rbp), %rdi
movl %r14d, %esi
callq 0x3fe5
movl $0x0, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3836(%rip), %rdi      # 0x757f
movq %r12, %rsi
xorl %eax, %eax
callq 0x10c0
movl $0x1, %edi
callq 0x11c0
leaq 0x37f8(%rip), %rdi      # 0x755c
jmp 0x3d49
leaq 0x3837(%rip), %rdi      # 0x75a4
jmp 0x3d49
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/TabelaSimbolos.c
// Function: cria_no_final
static Simbolo* cria_no_final (Simbolo *s, int nivelEscopo) {
    Simbolo *nv = (Simbolo*)malloc(sizeof(Simbolo));
    if(nv == NULL) {
      printf("sem memoria costura\n");
      exit(1);
    }

    nv->escopo = nivelEscopo;
    nv->prox = NULL;
    if (s == NULL){
        nv->prim = nv;
        nv->ant = NULL;
    }
    else {
      nv->prim = s->prim;
      nv->ant = s;
      s->prox = nv;
    }
    return nv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0x30, %edi
callq 0x1160
testq %rax, %rax
je 0x4035
movl %r14d, 0x10(%rax)
movq $0x0, 0x28(%rax)
testq %rbx, %rbx
je 0x4024
movq 0x18(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %rax, 0x28(%rbx)
jmp 0x4030
movq %rax, 0x18(%rax)
movq $0x0, 0x20(%rax)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x37d1(%rip), %rdi      # 0x780d
callq 0x1070
movl $0x1, %edi
callq 0x11c0
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/TabelaSimbolos.c
// Function: tipa_variavel
static void tipa_variavel(Simbolo *s, Var *v, int nivelEscopo) {
    ParametroL *p;
    while (s != NULL){
      if (s->tag == SVar) {
        if(strcmp(s->u.v->id,v->u.vvar.id) == 0) {
          v->u.vvar.d.def = s->u.v;
          v->tipo = s->u.v->tipo;
          v->u.vvar.escopo = v->u.vvar.d.def->escopo;
          if(v->tipo->tipo_base == bVoid) {
            printf("[Erro] %s nao pode ser declarada com tipo void\n",v->u.vvar.id);
            exit(1);
          }
          return;
        }
      }
      else if (s->tag == SParams) {
        p = s->u.p;
        while (p != NULL) {
          if (strcmp(p->id,v->u.vvar.id) == 0){
            v->u.vvar.escopo = EscopoFunc;
            v->u.vvar.d.defp = p;
            v->tipo = p->tipo;
            if(v->tipo->tipo_base == bVoid) {
              printf("[Erro] %s nao pode ser declarada com tipo void\n",v->u.vvar.id);
              exit(1);
            }
            return;
          }
          p = p->prox;
        }
      } /* fim else if */
      s = s->ant;
    }
    printf("[Erro] variavel %s nao declarada\n",v->u.vvar.id);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x45cb
movq %rdi, %r14
movl (%r14), %eax
cmpl $0x2, %eax
je 0x459a
testl %eax, %eax
jne 0x45c2
movq 0x8(%r14), %r12
movq (%r12), %rdi
movq 0x10(%rbx), %r15
movq %r15, %rsi
callq 0x1100
testl %eax, %eax
jne 0x45c2
jmp 0x4609
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x45c2
movq 0x10(%rbx), %r15
movq 0x8(%r12), %rdi
movq %r15, %rsi
callq 0x1100
testl %eax, %eax
je 0x45e7
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x45a7
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x4574
movq 0x10(%rbx), %rsi
leaq 0x30b4(%rip), %rdi      # 0x768a
xorl %eax, %eax
callq 0x10c0
movl $0x1, %edi
callq 0x11c0
movl $0x2, 0x18(%rbx)
movq %r12, 0x20(%rbx)
movq (%r12), %rax
movq %rax, 0x8(%rbx)
cmpl $0x0, 0x4(%rax)
je 0x4623
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r12, 0x20(%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
movl 0x14(%r12), %ecx
movl %ecx, 0x18(%rbx)
jmp 0x45fa
leaq 0x3030(%rip), %rdi      # 0x765a
movq %r15, %rsi
jmp 0x45d6
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/TabelaSimbolos.c
// Function: cmp_tipo_base
static int cmp_tipo_base(Tipo *t1, Tipo *t2) {
  if(t1->tipo_base == bChar && t2->tipo_base == bInt) return 0; //equivalencia de char e int
  if(t1->tipo_base == bInt && t2->tipo_base == bChar) return 0; //equivalencia de char e int
    if(t1->tipo_base < t2->tipo_base)
      return -1;
    else if (t1->tipo_base > t2->tipo_base)
      return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x4(%rdi), %ecx
cmpl $0x2, %ecx
je 0x464b
cmpl $0x1, %ecx
jne 0x4655
cmpl $0x2, 0x4(%rsi)
je 0x4651
cmpl $0x2, %ecx
jne 0x4655
cmpl $0x1, 0x4(%rsi)
jne 0x4655
xorl %eax, %eax
jmp 0x4665
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x4(%rsi), %ecx
jb 0x4665
seta %al
movzbl %al, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/TabelaSimbolos.c
// Function: promove_tipo
static Exp* promove_tipo(Exp *e, Base_TAG tipo_base) {

    Exp * expas = NULL;
    Tipo *nvtipo = NULL;

    nvtipo = (Tipo*)malloc(sizeof(Tipo));
    if (nvtipo == NULL) {printf("memoria insuficiente\n");exit(1);}

    nvtipo->tag = base;
    nvtipo->tipo_base = tipo_base;
    nvtipo->de = NULL;

    expas = (Exp*)malloc(sizeof(Exp));
    if (expas == NULL) {printf("memoria insuficiente\n");exit(1);}
    expas->tag = EXP_AS;
    expas->tipo = nvtipo;
    expas->u.expnewas.exp = e;
    expas->u.expnewas.tipo = nvtipo;

    return expas;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movl $0x10, %edi
callq 0x1160
testq %rax, %rax
je 0x46c7
movq %rax, %r14
movl $0x0, (%rax)
movl %r15d, 0x4(%rax)
movq $0x0, 0x8(%rax)
movl $0x28, %edi
callq 0x1160
testq %rax, %rax
je 0x46c7
movl $0x9, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3153(%rip), %rdi      # 0x7821
callq 0x1070
movl $0x1, %edi
callq 0x11c0
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/TabelaSimbolos.c
// Function: cmp_tipo_array
static int cmp_tipo_array(Tipo *t1, Tipo *t2){

  if (t1->tag != array || t2->tag != array) return -1;
  if (cmp_tipo_base(t1,t2) == 0) {
    Tipo *aux1,*aux2;
    aux1 = t1->de;
    aux2 = t2->de;
    while (aux1 != NULL && aux2 != NULL) {
      aux1 = aux1->de;
      aux2 = aux2->de;
    }
    if (aux1 != NULL || aux2 != NULL)
      return -1;
    else
      return 0;
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $0x1, (%rdi)
jne 0x472a
movq %rsi, %rbx
cmpl $0x1, (%rsi)
jne 0x472a
movq %rdi, %r14
movq %rbx, %rsi
callq 0x462f
testl %eax, %eax
jne 0x472a
jmp 0x4710
testq %rbx, %rbx
je 0x471d
movq 0x8(%rbx), %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x470b
xorl %r15d, %r15d
orq %rbx, %r14
setne %r15b
negl %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/TabelaSimbolos.c
// Function: tipa_expacesso
static void tipa_expacesso(Simbolo *s,Exp *e, int nivelEscopo) {

  tipa_expressao(s,e->u.expvar->u.vacesso.expvar,nivelEscopo);
  tipa_expressao(s,e->u.expvar->u.vacesso.expindex,nivelEscopo);

  if (verifica_tipo(e->u.expvar->u.vacesso.expindex->tipo,bInt)) {
    Tipo *nvtipo = NULL;

    nvtipo = (Tipo*) malloc(sizeof(Tipo));
    if (nvtipo == NULL) {printf("memoria insuficiente");exit(1);}
    nvtipo->tag = base;
    nvtipo->tipo_base = e->u.expvar->u.vacesso.expvar->tipo->tipo_base;
    nvtipo->de = NULL;
    e->tipo = nvtipo;
  }
  else {
    printf("[Erro Tipo] Esperado index tipo int encontrando %s\n",getStringTipo (e->u.expvar->u.vacesso.expindex->tipo));
    exit(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rsi
callq 0x408b
movq 0x10(%rbx), %rax
movq 0x18(%rax), %rsi
movq %r14, %rdi
callq 0x408b
movq 0x10(%rbx), %r14
movq 0x18(%r14), %rax
movq 0x8(%rax), %rdi
cmpl $0x1, (%rdi)
je 0x47ad
cmpl $0x2, 0x4(%rdi)
jne 0x47ad
movl $0x10, %edi
callq 0x1160
testq %rax, %rax
je 0x47c5
movl $0x0, (%rax)
movq 0x10(%r14), %rcx
movq 0x8(%rcx), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3404
leaq 0x2f67(%rip), %rdi      # 0x7720
movq %rax, %rsi
xorl %eax, %eax
callq 0x10c0
jmp 0x47d3
leaq 0x3055(%rip), %rdi      # 0x7821
xorl %eax, %eax
callq 0x10c0
movl $0x1, %edi
callq 0x11c0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/thiagok00[P]INF1715-Compilers/GeraCodigo.c
// Function: tipo_string
char *tipo_string(Tipo *tipo) {

  char *str;
  char *strbase;
  char aststr[200] = "";

  str = (char*) malloc(sizeof(char)*200);
  if (str == NULL) {printf("Falta de memoria\n");exit(1);}
  str[0] ='\0';

  strbase = tipo_base_string(tipo->tipo_base);
  while(tipo->de != NULL){
    sprintf(aststr,"%s*",aststr);
    tipo = tipo->de;
  }
  sprintf(str,"%s%s",strbase,aststr);

  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
leaq -0xf0(%rbp), %rdi
movl $0xc8, %edx
xorl %esi, %esi
callq 0x10e0
movl $0xc8, %edi
callq 0x1160
testq %rax, %rax
je 0x48d9
movq %rax, %rbx
movb $0x0, (%rax)
movl 0x4(%r14), %r13d
cmpq $0x0, 0x8(%r14)
je 0x4887
addq $0x8, %r14
leaq 0x30ab(%rip), %r15      # 0x790d
leaq -0xf0(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x11b0
movq (%r14), %rax
leaq 0x8(%rax), %r14
cmpq $0x0, 0x8(%rax)
jne 0x4869
cmpl $0x1, %r13d
leaq 0x3072(%rip), %rax      # 0x7904
leaq 0x3067(%rip), %rcx      # 0x7900
cmoveq %rax, %rcx
cmpl $0x3, %r13d
leaq 0x305f(%rip), %rdx      # 0x7907
cmovneq %rcx, %rdx
leaq 0x305e(%rip), %rsi      # 0x7911
leaq -0xf0(%rbp), %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11b0
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37be(%rip), %rdi      # 0x809e
callq 0x1070
movl $0x1, %edi
callq 0x11c0
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/echo.c
// Function: parse_args
struct echo_args *parse_args(struct echo_args *args, int argc, char **argv){
    args->count = 0;
    if(argv[1][0] == '-'){    
        for(int i = 1; i < argc; i++){
            if(!strcmp(argv[i], "-n")){
                args->nonewline = true;
                args->count += 1;
            }
            else if(!strcmp(argv[i], "-e")){
                args->backslash = true;
                args->count += 1;
            }
            else if(!strcmp(argv[i], "-E")){
                args->backslash = false;
                args->count += 1;
            }
        }
    }
    return args;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x0, 0x4(%rdi)
movq 0x8(%rdx), %rax
cmpb $0x2d, (%rax)
setne %al
cmpl $0x2, %esi
setl %cl
orb %al, %cl
jne 0x11ff
movq %rdx, %rbx
movl %esi, %r12d
movl $0x1, %r15d
movq (%rbx,%r15,8), %r13
movq %r13, %rdi
leaq 0xe52(%rip), %rsi       # 0x2004
callq 0x1060
testl %eax, %eax
je 0x11e8
movq %r13, %rdi
leaq 0xe42(%rip), %rsi       # 0x2007
callq 0x1060
testl %eax, %eax
je 0x11ee
movq %r13, %rdi
leaq 0xe32(%rip), %rsi       # 0x200a
callq 0x1060
testl %eax, %eax
jne 0x11f7
movb $0x0, 0x1(%r14)
jmp 0x11f3
movb $0x1, (%r14)
jmp 0x11f3
movb $0x1, 0x1(%r14)
incl 0x4(%r14)
incq %r15
cmpq %r15, %r12
jne 0x11a4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/echo.c
// Function: main
int main(int argc, char **argv){
    struct echo_args *args = calloc(1, sizeof(struct echo_args));
    args = parse_args(args, argc, argv);
    if(argc == 1){
        putchar('\n');
        return 0;
    }
    for(int i = args->count + 1; i < argc; i++){
        printf("%s", argv[i]);
        if(i < argc - 1){
            putchar(' ');
        }
    }
    if(args->nonewline == false){
        putchar('\n');
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %edi
movl $0x8, %esi
callq 0x1050
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x116c
cmpl $0x1, %r14d
je 0x12a1
movq %r15, -0x30(%rbp)
movslq 0x4(%r15), %r13
leal 0x1(%r13), %eax
cmpl %r14d, %eax
jge 0x1298
leal -0x1(%r14), %eax
incq %r13
movslq %eax, %r15
negl %r14d
leaq 0xd9d(%rip), %r12       # 0x200d
movq (%rbx,%r13,8), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x1040
cmpq %r15, %r13
jge 0x128d
movl $0x20, %edi
callq 0x1030
incq %r13
movl %r14d, %eax
addl %r13d, %eax
jne 0x1270
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x12ab
movl $0xa, %edi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/src/bareitem.c
// Function: SH_BareItem__destroy
void
SH_BareItem__destroy(SH_BareItem *obj, sh_bool_t recursive, int* err) {
	__cascade(err,);
	if (recursive) {
		switch (obj->type) {
		case SH_NULL:
			free(obj);
			__clear(err);
			return;

		case SH_INTEGER:
			do_destroy(SH_Integer, obj);
			__clear(err);
			return;

		case SH_DECIMAL:
			do_destroy(SH_Decimal, obj);
			__clear(err);
			return;

		case SH_STRING:
			do_destroy(SH_String, obj);
			__clear(err);
			return;

		case SH_TOKEN:
			do_destroy(SH_Token, obj);
			__clear(err);
			return;

		case SH_BYTESEQUENCE:
			do_destroy(SH_ByteSequence, obj);
			__clear(err);
			return;

		case SH_BOOLEAN:
			do_destroy(SH_Boolean, obj);
			__clear(err);
			return;

		case SH_INNERLIST:
			/*do_destroy(SH_InnerList, recursive, obj);*/
			SH_InnerList__destroy((SH_InnerList*)(obj->ptr), recursive, 0);
			free(obj);
			__clear(err);
			return;

		/*default: fall out */
		}

		free(obj);
		__raise(err, SH_E_ITEM_WRONG_TYPE);
	} else {
		free(obj);
		__clear(err);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x1465
cmpl $0x0, (%rbx)
jne 0x151f
testb %sil, %sil
je 0x1487
movl (%r14), %eax
cmpq $0x7, %rax
ja 0x1525
leaq 0xb82(%rip), %rcx       # 0x2000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0x1040
testq %rbx, %rbx
je 0x151f
xorl %r15d, %r15d
jmp 0x151c
movq 0x8(%r14), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x10f0
jmp 0x150f
movq 0x8(%r14), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x1050
jmp 0x150f
movq 0x8(%r14), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x1110
jmp 0x150f
movq 0x8(%r14), %rdi
movzbl %sil, %esi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x1060
jmp 0x150f
movq 0x8(%r14), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x1100
jmp 0x150f
movq 0x8(%r14), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x10a0
jmp 0x150f
movq 0x8(%r14), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x10b0
movq %r14, %rdi
callq 0x1040
testq %rbx, %rbx
je 0x151f
movl %r15d, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1040
movl $0x100001, %r15d        # imm = 0x100001
jmp 0x1517
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/src/bareitem.c
// Function: SH_BareItem__to_s
sh_char_t*
SH_BareItem__to_s(SH_BareItem* obj, int* err) {
	sh_char_t* str;

	__cascade(err, (sh_char_t*)0);
	switch (obj->type) {
	case SH_NULL:
		str = (sh_char_t*)malloc(sizeof(sh_char_t));
		if ((sh_char_t*)0 == str) {
			__raise(err, SH_E_MALLOC_ERROR);
			return (sh_char_t*)0;
		}
		*str = SH_CHAR_C(0);
		return str;

	case SH_INTEGER:
		return SH_Integer__to_s((SH_Integer*)(obj->ptr), err);

	case SH_DECIMAL:
		return SH_Decimal__to_s((SH_Decimal*)(obj->ptr), err);

	case SH_STRING:
		return SH_String__to_s((SH_String*)(obj->ptr), err);

	case SH_TOKEN:
		return SH_Token__to_s((SH_Token*)(obj->ptr), err);

	case SH_BYTESEQUENCE:
		return SH_ByteSequence__to_s((SH_ByteSequence*)(obj->ptr), err);

	case SH_BOOLEAN:
		return SH_Boolean__to_s((SH_Boolean*)(obj->ptr), err);

	case SH_INNERLIST:
		return SH_InnerList__to_s((SH_InnerList*)(obj->ptr), err);

	/*default: fall out */
	}

	__raise(err, SH_E_ITEM_WRONG_TYPE);
	return (sh_char_t*)0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1695
cmpl $0x0, (%rbx)
je 0x1695
xorl %eax, %eax
popq %rbx
retq
movl (%rdi), %eax
cmpq $0x7, %rax
ja 0x171c
leaq 0x97c(%rip), %rcx       # 0x2020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, %edi
callq 0x10c0
testq %rax, %rax
je 0x1730
movb $0x0, (%rax)
jmp 0x1693
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x10e0
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1070
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x10d0
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1090
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1030
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1080
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1120
testq %rbx, %rbx
je 0x1691
movl $0x100001, (%rbx)       # imm = 0x100001
jmp 0x1691
testq %rbx, %rbx
je 0x1691
movl $0x80000001, (%rbx)     # imm = 0x80000001
jmp 0x1691
// File: /workspace/github_c_makefile_star2_O1/carlitosmarin[P]Sistema-Ficheros-SOII/verificacion.c
// Function: mostrarRegistro
void mostrarRegistro(struct registro *reg) {
	char fec[20];
	memset(fec,0,20);
	struct tm *ts;
	time_t t = reg->fecha;
	ts = localtime(&t);
	strftime(fec, sizeof(fec), "%Y/%m/%d %H:%M:%S", ts);
	printf("\t� Fecha: %s\n", fec);
	printf("\t� Numero escritura: %d\n", reg->nEscritura);
	printf("\t� Posicion: %d\n", reg->posicion);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movl $0x0, 0x10(%r14)
movl (%rdi), %eax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x1030
leaq 0x16af(%rip), %rdx      # 0x552a
movl $0x14, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0x1150
leaq 0x16aa(%rip), %rdi      # 0x553c
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
movl 0x8(%rbx), %esi
leaq 0x16a4(%rip), %rdi      # 0x554a
xorl %eax, %eax
callq 0x10a0
movl 0xc(%rbx), %esi
leaq 0x16ac(%rip), %rdi      # 0x5563
xorl %eax, %eax
callq 0x10a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/carlitosmarin[P]Sistema-Ficheros-SOII/verificacion.c
// Function: mostrarInfo
void mostrarInfo(struct informacion *info) {
	printf("PID: %d\n", info->proceso);
	printf("Registros validados: %d\n", info->nEscrituras);
	puts("Primera Escritura:");
	mostrarRegistro(&info->PrimeraEscritura);
	puts("Ultima Escritura:");
	mostrarRegistro(&info->UltimaEscritura);
	puts("Mayor Posicion:");
	mostrarRegistro(&info->MayorPosicion);
	puts("Menor Posicion:");
	mostrarRegistro(&info->MenorPosicion);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %esi
leaq 0x16a1(%rip), %rdi      # 0x5574
xorl %eax, %eax
callq 0x10a0
movl 0x4(%rbx), %esi
leaq 0x1699(%rip), %rdi      # 0x557d
xorl %eax, %eax
callq 0x10a0
leaq 0x16a4(%rip), %rdi      # 0x5596
callq 0x1060
leaq 0x8(%rbx), %rdi
callq 0x3e47
leaq 0x16a2(%rip), %rdi      # 0x55a9
callq 0x1060
leaq 0x18(%rbx), %rdi
callq 0x3e47
leaq 0x169f(%rip), %rdi      # 0x55bb
callq 0x1060
leaq 0x38(%rbx), %rdi
callq 0x3e47
leaq 0x169a(%rip), %rdi      # 0x55cb
callq 0x1060
addq $0x28, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x3e47
// File: /workspace/github_c_makefile_star2_O1/Arlu[P]RDMA-Hello-World/server.c
// Function: chat
void chat()
{
    struct RemoteMR remote_mr;

    // Get Hello World via send and receive request:
    post_recv(BUFFER_SIZE);
    wait_completions(RECV_WRID);

    printf(ib_res.buf);

    // Get remote address and rkey:
    post_recv(sizeof(struct RemoteMR));
    wait_completions(RECV_WRID);
    memcpy(&remote_mr, ib_res.buf, sizeof(struct RemoteMR));

    // Get Hello World via RDMA Read:
    post_recv(1); // Wait to the client for read ready:
    wait_completions(RECV_WRID);
    post_send_read(remote_mr, BUFFER_SIZE);
    wait_completions(READ_WRID);

    printf(ib_res.buf);

    // Send remote address and rkey:
    remote_mr.remote_addr = (uint64_t)ib_res.buf;
    remote_mr.rkey = ib_res.mr->rkey;
    memcpy(ib_res.buf, &remote_mr, sizeof(struct RemoteMR));
    post_send(sizeof(struct RemoteMR));
    wait_completions(SEND_WRID);

    // Wait to the client for Send Hello World via RDMA Write:
    post_recv(1);
    wait_completions(RECV_WRID);

    printf(ib_res.buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x400, %edi            # imm = 0x400
callq 0x1c94
movl $0x1, %edi
callq 0x1e95
leaq 0x2d66(%rip), %r15      # 0x4178
movq 0x60(%r15), %rdi
xorl %eax, %eax
callq 0x10b0
movl $0x10, %edi
callq 0x1c94
movl $0x1, %edi
callq 0x1e95
movq 0x60(%r15), %rax
movq (%rax), %rbx
movl 0x8(%rax), %r14d
movl 0xc(%rax), %r12d
movl $0x1, %edi
callq 0x1c94
movl $0x1, %edi
callq 0x1e95
movq %rbx, %rdi
movl %r14d, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x1d7f
movl $0x4, %edi
callq 0x1e95
movq 0x60(%r15), %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x10(%r15), %rax
movq 0x60(%r15), %rcx
movl 0x28(%rax), %eax
movq %rcx, (%rcx)
movl %eax, 0x8(%rcx)
movl %r12d, 0xc(%rcx)
movl $0x10, %edi
callq 0x1cf0
movl $0x2, %edi
callq 0x1e95
movl $0x1, %edi
callq 0x1c94
movl $0x1, %edi
callq 0x1e95
movq 0x60(%r15), %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O1/Arlu[P]RDMA-Hello-World/server.c
// Function: main
int main(int argc, char *argv[])
{
    server_name = NULL;

    if (setup_ib())
    {
        perror("Failed to setup IB.");
    }

    chat();

    close_ib_connection();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2c84(%rip), %rax      # 0x4158
movq $0x0, (%rax)
xorl %eax, %eax
callq 0x1867
testl %eax, %eax
jne 0x14f6
callq 0x13ec
xorl %eax, %eax
callq 0x1c24
xorl %eax, %eax
popq %rbp
retq
leaq 0xb07(%rip), %rdi       # 0x2004
callq 0x11d0
jmp 0x14e6