LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/setsig.c
// Function: main
int main(int argc, char *argv[])
{
	char filename[100];
	int memfd;
	void *mapped_base;

	strcpy(filename,"/mnt/");
	strcat(filename,argv[1]);
	strcat(filename,".bin");

	memfd = open("/dev/mem", O_RDWR | O_SYNC);
	if (memfd == -1) {
		printf("Can't open /dev/mem.\n");
		exit(0);
	}

	// Map one page of memory into user space such that the device is in that page, but it may not
	// be at the start of the page

	mapped_base = mmap( (void *) MEM0_BASE_ADDRESS, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, memfd, FIFO_BASE_ADDRESS);
	if (mapped_base == (void *) -1) {
		printf("Can't map the memory to user space.\n");
		exit(0);
	}
	
	/* ----------- INSERT CODE BELOW THIS LINE ------------ */

	set_sig_tx(filename, mapped_base);

	/* ----------- INSERT CODE ABOVE THIS LINE ------------ */
	if (munmap(mapped_base, MAP_SIZE) == -1) {
		printf("Can't unmap memory from user space.\n");
		exit(0);
	}
	close(memfd);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x80(%rbp), %rdi
leaq 0x1d90(%rip), %rsi      # 0x3004
callq 0x1050
leaq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1110
leaq -0x80(%rbp), %rdi
leaq 0x1d75(%rip), %rsi      # 0x300a
callq 0x1110
leaq 0x1d6e(%rip), %rdi      # 0x300f
movl $0x101002, %esi         # imm = 0x101002
movb $0x0, %al
callq 0x10f0
movl %eax, -0x84(%rbp)
cmpl $-0x1, -0x84(%rbp)
jne 0x12d1
leaq 0x1d55(%rip), %rdi      # 0x3018
movb $0x0, %al
callq 0x10a0
xorl %edi, %edi
callq 0x1130
movl -0x84(%rbp), %r8d
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x400000, %esi         # imm = 0x400000
movl $0x3, %edx
movl $0x11, %ecx
movl $0x60000000, %r9d       # imm = 0x60000000
callq 0x1080
movq %rax, -0x90(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x90(%rbp)
jne 0x1323
leaq 0x1d19(%rip), %rdi      # 0x302e
movb $0x0, %al
callq 0x10a0
xorl %edi, %edi
callq 0x1130
leaq -0x80(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x14e0
movq -0x90(%rbp), %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x10e0
cmpl $-0x1, %eax
jne 0x135e
leaq 0x1d03(%rip), %rdi      # 0x3053
movb $0x0, %al
callq 0x10a0
xorl %edi, %edi
callq 0x1130
movl -0x84(%rbp), %edi
callq 0x10c0
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/form9.c
// Function: StrNCaseCmp
int StrNCaseCmp(const char *a, const char *b, unsigned int n)
{
   unsigned int i,l,m;

   l = strlen(a);
   m = strlen(b);

   for (i=0 ; i < n && i <= l && i <= m ; ++i)
   {
      if (toupper(a[i]) < toupper(b[i])) return -1;
      if (toupper(a[i]) > toupper(b[i])) return  1;
   }
   return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1040
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1040
movl %eax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %ecx
xorl %eax, %eax
cmpl 0x1c(%rsp), %ecx
movb %al, 0xf(%rsp)
jae 0x1265
movl 0x18(%rsp), %ecx
xorl %eax, %eax
cmpl 0x14(%rsp), %ecx
movb %al, 0xf(%rsp)
ja 0x1265
movl 0x18(%rsp), %eax
cmpl 0x10(%rsp), %eax
setbe %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1272
jmp 0x12fc
movq 0x28(%rsp), %rax
movl 0x18(%rsp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x1030
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x1030
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x12ae
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x1304
movq 0x28(%rsp), %rax
movl 0x18(%rsp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x1030
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x1030
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jle 0x12ea
movl $0x1, 0x34(%rsp)
jmp 0x1304
jmp 0x12ec
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1236
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/form9.c
// Function: IsEquate
int IsEquate(void)
{
   char *e;
   char *p;
   e = strchr(Line,'=');
   if (e)
   {
      p = strchr(Line,';');
      if (p && p < e) return -1; // '=' after comment character
      p = strchr(Line,'*');
      if (p && p < e) return -1; // ignore * = syntax for PC setting
      return e-Line;
   }
   return -1; // no equate character found
}

// Assembly:
subq $0x18, %rsp
leaq 0x6195(%rip), %rdi      # 0x74b0
movl $0x3d, %esi
callq 0x1050
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x13a9
leaq 0x6177(%rip), %rdi      # 0x74b0
movl $0x3b, %esi
callq 0x1050
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x1363
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x1363
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x13b1
leaq 0x6146(%rip), %rdi      # 0x74b0
movl $0x2a, %esi
callq 0x1050
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x1394
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x1394
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x13b1
movq 0x8(%rsp), %rax
leaq 0x6110(%rip), %rcx      # 0x74b0
subq %rcx, %rax
movl %eax, 0x14(%rsp)
jmp 0x13b1
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/form9.c
// Function: Usage
void Usage(void)
{
   fprintf(stderr,"Usage: form9 [options] <in >out\n");
   fprintf(stderr,"Options:\n");
   fprintf(stderr,"   -l print mnemonics in lower case\n");
   fprintf(stderr,"   -u print mnemonics in upper case\n");
   fprintf(stderr,"   -o print pseudos   in lower case\n");
   fprintf(stderr,"   -p print pseudos   in upper case\n");
   fprintf(stderr,"   -m col   mnemonic/pseudo  column ( 8)\n");
   fprintf(stderr,"   -a col   argument/operand column (16)\n");
   fprintf(stderr,"   -e col   equate column           (16)\n");
   fprintf(stderr,"   -c col  code line comment column (32)\n");
   exit(1);
}

// Assembly:
pushq %rax
movq 0x3820(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x18c9(%rip), %rsi      # 0x30ab
movb $0x0, %al
callq 0x10a0
movq 0x3808(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x18d2(%rip), %rsi      # 0x30cc
movb $0x0, %al
callq 0x10a0
movq 0x37f0(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x18c4(%rip), %rsi      # 0x30d6
movb $0x0, %al
callq 0x10a0
movq 0x37d8(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x18d1(%rip), %rsi      # 0x30fb
movb $0x0, %al
callq 0x10a0
movq 0x37c0(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x18de(%rip), %rsi      # 0x3120
movb $0x0, %al
callq 0x10a0
movq 0x37a8(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x18eb(%rip), %rsi      # 0x3145
movb $0x0, %al
callq 0x10a0
movq 0x3790(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x18f8(%rip), %rsi      # 0x316a
movb $0x0, %al
callq 0x10a0
movq 0x3778(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x190a(%rip), %rsi      # 0x3194
movb $0x0, %al
callq 0x10a0
movq 0x3760(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x191c(%rip), %rsi      # 0x31be
movb $0x0, %al
callq 0x10a0
movq 0x3748(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x192e(%rip), %rsi      # 0x31e8
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x10f0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/form9.c
// Function: MoveLine
int MoveLine(int i, int col)
{
   int l;
   if (col >= 0)
   {
      l = strlen(Line)-i+1;
      if (col > i)
      {
         memmove(Line+col,Line+i,l);
         memset(Line+i,' ',col-i);
         return col; // moved to this column
      }
      while (col < i)
      {
         if (i > 0 && Line[i-1] != ' ') break;
         if (i > 1 && Line[i-2] != ' ') break;
         --i;
         memmove(Line+i,Line+i+1,l);
      }
      return i; // moved to this column
   }
   return i;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x1a02
leaq 0x5bc2(%rip), %rdi      # 0x74b0
callq 0x1040
movslq 0x10(%rsp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jle 0x1966
movslq 0xc(%rsp), %rax
leaq 0x5b97(%rip), %rdi      # 0x74b0
addq %rax, %rdi
movslq 0x10(%rsp), %rax
leaq 0x5b88(%rip), %rsi      # 0x74b0
addq %rax, %rsi
movslq 0x8(%rsp), %rdx
callq 0x10d0
movslq 0x10(%rsp), %rax
leaq 0x5b6f(%rip), %rdi      # 0x74b0
addq %rax, %rdi
movl 0xc(%rsp), %eax
subl 0x10(%rsp), %eax
movslq %eax, %rdx
movl $0x20, %esi
callq 0x1070
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x1a0a
jmp 0x1968
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x19f8
cmpl $0x0, 0x10(%rsp)
jle 0x1999
movl 0x10(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x5b22(%rip), %rax      # 0x74b0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x1999
jmp 0x19f8
cmpl $0x1, 0x10(%rsp)
jle 0x19bc
movl 0x10(%rsp), %eax
subl $0x2, %eax
movslq %eax, %rcx
leaq 0x5aff(%rip), %rax      # 0x74b0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x19bc
jmp 0x19f8
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movslq 0x10(%rsp), %rax
leaq 0x5add(%rip), %rdi      # 0x74b0
addq %rax, %rdi
movslq 0x10(%rsp), %rax
leaq 0x5ace(%rip), %rsi      # 0x74b0
addq %rax, %rsi
addq $0x1, %rsi
movslq 0x8(%rsp), %rdx
callq 0x10d0
jmp 0x1968
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x1a0a
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/form9.c
// Function: MoveOperand
void MoveOperand(int i)
{
   int l;
   if (ocol >= 0)
   {
      while (Line[i] == ' ') ++i;
      l = strlen(Line)-i+1;
      if (ocol > i)
      {
         memmove(Line+ocol,Line+i,l);
         memset(Line+i,' ',ocol-i);
      }
      while (ocol < i)
      {
         if (Line[i-1] != ' ') break;
         if (i > 1 && Line[i-2] != ' ') break;
         --i;
         memmove(Line+i,Line+i+1,l);
      }
   }
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
cmpl $0x0, 0x3668(%rip)      # 0x5094
jl 0x1b56
jmp 0x1a34
movslq 0x4(%rsp), %rcx
leaq 0x5a70(%rip), %rax      # 0x74b0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x1a56
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1a34
leaq 0x5a53(%rip), %rdi      # 0x74b0
callq 0x1040
movslq 0x4(%rsp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, (%rsp)
movl 0x361d(%rip), %eax      # 0x5094
cmpl 0x4(%rsp), %eax
jle 0x1acc
movslq 0x3610(%rip), %rax      # 0x5094
leaq 0x5a25(%rip), %rdi      # 0x74b0
addq %rax, %rdi
movslq 0x4(%rsp), %rax
leaq 0x5a16(%rip), %rsi      # 0x74b0
addq %rax, %rsi
movslq (%rsp), %rdx
callq 0x10d0
movslq 0x4(%rsp), %rax
leaq 0x59fe(%rip), %rdi      # 0x74b0
addq %rax, %rdi
movl 0x35d9(%rip), %eax      # 0x5094
subl 0x4(%rsp), %eax
movslq %eax, %rdx
movl $0x20, %esi
callq 0x1070
jmp 0x1ace
movl 0x35c0(%rip), %eax      # 0x5094
cmpl 0x4(%rsp), %eax
jge 0x1b54
movl 0x4(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x59c5(%rip), %rax      # 0x74b0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x1af6
jmp 0x1b54
cmpl $0x1, 0x4(%rsp)
jle 0x1b19
movl 0x4(%rsp), %eax
subl $0x2, %eax
movslq %eax, %rcx
leaq 0x59a2(%rip), %rax      # 0x74b0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x1b19
jmp 0x1b54
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
movslq 0x4(%rsp), %rax
leaq 0x5980(%rip), %rdi      # 0x74b0
addq %rax, %rdi
movslq 0x4(%rsp), %rax
leaq 0x5971(%rip), %rsi      # 0x74b0
addq %rax, %rsi
addq $0x1, %rsi
movslq (%rsp), %rdx
callq 0x10d0
jmp 0x1ace
jmp 0x1b56
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/form9.c
// Function: MoveComment
void MoveComment(int i)
{
   char *p;
   int j;

   p = strchr(Line+i,';');
   if (!p) p = strchr(Line+i,'*');
   if (p)
   {
      j = p - Line;
      if (p[1] != ' ') MoveLine(j+1,j+2);
      MoveLine(j,ccol);
   }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movslq 0x14(%rsp), %rax
leaq 0x593c(%rip), %rdi      # 0x74b0
addq %rax, %rdi
movl $0x3b, %esi
callq 0x1050
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1bac
movslq 0x14(%rsp), %rax
leaq 0x5916(%rip), %rdi      # 0x74b0
addq %rax, %rdi
movl $0x2a, %esi
callq 0x1050
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1bf7
movq 0x8(%rsp), %rax
leaq 0x58f0(%rip), %rcx      # 0x74b0
subq %rcx, %rax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x20, %eax
je 0x1be8
movl 0x4(%rsp), %edi
addl $0x1, %edi
movl 0x4(%rsp), %esi
addl $0x2, %esi
callq 0x18d0
movl 0x4(%rsp), %edi
movl 0x34aa(%rip), %esi      # 0x509c
callq 0x18d0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/fileloader.c
// Function: free_buffer
void free_buffer(arraylist_t *buffer) {
    line_t *line = NULL;

    if(!buffer) return;

    for(size_t i = 0; i < buffer->size; i++) {
        line = get_line(buffer, i);
        free(line->line);
        free(line->source);
        free(line);
    }
    arraylist_free(buffer, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2d1d
jmp 0x2d81
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2d76
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x2cb0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2d25
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8a00
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/test.c
// Function: test
void test() {

	test_variable_parsing();
	test_function_parsing();
	test_scope_parsing();
	test_rule_max_line_numbers();
	test_rule_max_file_line_numbers();
	test_rule_no_prototype();
	test_function_call_parsing();
	test_parse_expression();
	test_parsing_operations();
	test_rule_no_multi_declaration();
	test_rule_parsing();

	printf("------------------------------%s\n", FORMAT_RESET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2df0
callq 0x3250
callq 0x35b0
callq 0x3f80
callq 0x4030
callq 0x4140
callq 0x4380
callq 0x4700
callq 0x4f40
callq 0x5990
callq 0x5b70
leaq 0x1025f(%rip), %rdi     # 0x13031
leaq 0x1024c(%rip), %rsi     # 0x13025
movb $0x0, %al
callq 0x20b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/test.c
// Function: test_variable_declaration_parsing
static void test_variable_declaration_parsing(char *line) {
	arraylist_t *list = NULL;

	printf("%sInput: %s\"%s\"%s\n", COLOR_BLUE, COLOR_YELLOW, line, FORMAT_RESET);
	list = get_variables_from_declaration(0, line);
	if(list != NULL) {
		printf("%sOutput: %s\n", COLOR_BLUE, FORMAT_RESET);
		print_variables(list, 0);
		field_list_free(list);
	} else
		printf("%sOutput: %sNULL%s\n", COLOR_BLUE, COLOR_RED, FORMAT_RESET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rcx
leaq 0x103b7(%rip), %rdi     # 0x13426
leaq 0x103c3(%rip), %rsi     # 0x13439
leaq 0xffa2(%rip), %rdx      # 0x1301f
leaq 0xffa1(%rip), %r8       # 0x13025
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0xb980
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x30d3
leaq 0x10397(%rip), %rdi     # 0x1343f
leaq 0x1038a(%rip), %rsi     # 0x13439
leaq 0xff6f(%rip), %rdx      # 0x13025
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3100
movq -0x10(%rbp), %rdi
callq 0x81d0
jmp 0x30f6
leaq 0x10373(%rip), %rdi     # 0x1344d
leaq 0x10358(%rip), %rsi     # 0x13439
leaq 0xff31(%rip), %rdx      # 0x13019
leaq 0xff36(%rip), %rcx      # 0x13025
movb $0x0, %al
callq 0x20b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/test.c
// Function: print_variables
static void print_variables(arraylist_t *variables, unsigned int tabs) {
	field_t *variable = NULL;
	if(variables != NULL) {
		for(unsigned int i = 0 ; i < variables->size ; i++) {
			variable = arraylist_get(variables, i);

			for(unsigned int j = 0 ; j < tabs ; j++)
				printf("\t");

			printf(" %s%2d:  %sName:       %s%s\n",
				COLOR_MAGENTA, i,
				COLOR_CYAN, FORMAT_RESET, variable->name);

			for(unsigned int j = 0 ; j < tabs ; j++)
				printf("\t");
			printf("      %sType:       %s%s\n", COLOR_CYAN, FORMAT_RESET, variable->type.name);

			for(unsigned int j = 0 ; j < tabs ; j++)
				printf("\t");
			printf("      %sIs pointer: %s%d\n", COLOR_CYAN, FORMAT_RESET, variable->type.is_pointer);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3249
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3247
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x8890
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x3174
leaq 0x102ff(%rip), %rdi     # 0x13461
movb $0x0, %al
callq 0x20b0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3153
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movq (%rax), %r9
leaq 0x102de(%rip), %rdi     # 0x13463
leaq 0x102f4(%rip), %rsi     # 0x13480
leaq 0x102f3(%rip), %rcx     # 0x13486
leaq 0xfe8b(%rip), %r8       # 0x13025
movb $0x0, %al
callq 0x20b0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x31c9
leaq 0x102aa(%rip), %rdi     # 0x13461
movb $0x0, %al
callq 0x20b0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x31a8
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x102b4(%rip), %rdi     # 0x1348c
leaq 0x102a7(%rip), %rsi     # 0x13486
leaq 0xfe3f(%rip), %rdx      # 0x13025
movb $0x0, %al
callq 0x20b0
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x3215
leaq 0x1025e(%rip), %rdi     # 0x13461
movb $0x0, %al
callq 0x20b0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x31f4
movq -0x18(%rbp), %rax
movsbl 0x18(%rax), %ecx
leaq 0x10282(%rip), %rdi     # 0x134a6
leaq 0x1025b(%rip), %rsi     # 0x13486
leaq 0xfdf3(%rip), %rdx      # 0x13025
movb $0x0, %al
callq 0x20b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3129
jmp 0x3249
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/test.c
// Function: test_function_parsing
static void test_function_parsing() {
	printf("------------------------------%s\n", FORMAT_RESET);

	printf("%sTESTING PARSE FUNCTIONS%s\n", COLOR_GREEN_BOLD, FORMAT_RESET);

	test_function_declaration_parsing("void test();");
	test_function_declaration_parsing("void test2(int, int);");
	test_function_declaration_parsing("void test3(int i, int* j);");
	test_function_declaration_parsing("void test4(int i , unsigned int *ptr) {");
	test_function_declaration_parsing("void *test_ptr() {");
	test_function_declaration_parsing("void* *test_ptr2() {");
	test_function_declaration_parsing("void * test_ptr3() {");
	test_function_declaration_parsing("void[15] array() {");
	test_function_declaration_parsing("void test2(int) {");
	test_function_declaration_parsing("void test2(int array[15]) {");
	test_function_declaration_parsing("void test2(int* array[15]) {");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xfdd6(%rip), %rdi      # 0x13031
leaq 0xfdc3(%rip), %rsi      # 0x13025
movb $0x0, %al
callq 0x20b0
leaq 0x10250(%rip), %rdi     # 0x134c0
leaq 0xfe04(%rip), %rsi      # 0x1307b
leaq 0xfda7(%rip), %rdx      # 0x13025
movb $0x0, %al
callq 0x20b0
leaq 0x10251(%rip), %rdi     # 0x134dd
callq 0x3310
leaq 0x10252(%rip), %rdi     # 0x134ea
callq 0x3310
leaq 0x1025c(%rip), %rdi     # 0x13500
callq 0x3310
leaq 0x1026b(%rip), %rdi     # 0x1351b
callq 0x3310
leaq 0x10287(%rip), %rdi     # 0x13543
callq 0x3310
leaq 0x1028e(%rip), %rdi     # 0x13556
callq 0x3310
leaq 0x10297(%rip), %rdi     # 0x1356b
callq 0x3310
leaq 0x102a0(%rip), %rdi     # 0x13580
callq 0x3310
leaq 0x102a7(%rip), %rdi     # 0x13593
callq 0x3310
leaq 0x102ad(%rip), %rdi     # 0x135a5
callq 0x3310
leaq 0x102bd(%rip), %rdi     # 0x135c1
callq 0x3310
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/test.c
// Function: test_function_declaration_parsing
static void test_function_declaration_parsing(char *line) {
	function_t *function = get_function_from_declaration(0, line);

	printf("%sInput: %s\"%s\"%s\n", COLOR_BLUE, COLOR_YELLOW, line, FORMAT_RESET);
	if(function != NULL) {
		printf("%sOutput: %s\n", COLOR_BLUE, FORMAT_RESET);
		print_function(function, 0);
		function_free(function);
	} else
		printf("%sOutput: %sNULL%s\n", COLOR_BLUE, COLOR_RED, FORMAT_RESET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0xee90
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
leaq 0x100f0(%rip), %rdi     # 0x13426
leaq 0x100fc(%rip), %rsi     # 0x13439
leaq 0xfcdb(%rip), %rdx      # 0x1301f
leaq 0xfcda(%rip), %r8       # 0x13025
movb $0x0, %al
callq 0x20b0
cmpq $0x0, -0x10(%rbp)
je 0x338b
leaq 0x100df(%rip), %rdi     # 0x1343f
leaq 0x100d2(%rip), %rsi     # 0x13439
leaq 0xfcb7(%rip), %rdx      # 0x13025
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x33c0
movq -0x10(%rbp), %rdi
callq 0x100e0
jmp 0x33ae
leaq 0x100bb(%rip), %rdi     # 0x1344d
leaq 0x100a0(%rip), %rsi     # 0x13439
leaq 0xfc79(%rip), %rdx      # 0x13019
leaq 0xfc7e(%rip), %rcx      # 0x13025
movb $0x0, %al
callq 0x20b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/test.c
// Function: print_functions
static void print_functions(arraylist_t *functions, unsigned int tabs) {
	function_t *function = NULL;
	if(functions != NULL) {
		for(unsigned int i = 0 ; i < functions->size ; i++) {
			function = arraylist_get(functions, i);
			print_function(function, tabs);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3f6d
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3f6b
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x8890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x33c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f35
jmp 0x3f6d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/test.c
// Function: test_rule_max_line_numbers
static void test_rule_max_line_numbers(){
	printf("------------------------------%s\n", FORMAT_RESET);

	printf("%sTESTING RULE: max-line-numbers%s\n", COLOR_GREEN_BOLD, FORMAT_RESET);

	arraylist_t *file = arraylist_init(ARRAYLIST_DEFAULT_CAPACITY);
	arraylist_add(file, strduplicate("static int glob = 89;"));

	check_max_line_length(file, 5, "fictive_file.c");
	check_max_line_length(file, 50, "fictive_file.c");

	arraylist_free(file, 1);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xf0a2(%rip), %rdi      # 0x13031
leaq 0xf08f(%rip), %rsi      # 0x13025
movb $0x0, %al
callq 0x20b0
leaq 0xf934(%rip), %rdi      # 0x138d8
leaq 0xf0d0(%rip), %rsi      # 0x1307b
leaq 0xf073(%rip), %rdx      # 0x13025
movb $0x0, %al
callq 0x20b0
movl $0xa, %edi
callq 0x8580
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xf6b4(%rip), %rdi      # 0x1368a
callq 0xa550
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x8730
movq -0x8(%rbp), %rdi
movl $0x5, %esi
leaq 0xf905(%rip), %rdx      # 0x138fc
callq 0xd8b0
movq -0x8(%rbp), %rdi
movl $0x32, %esi
leaq 0xf8f0(%rip), %rdx      # 0x138fc
callq 0xd8b0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8a00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/test.c
// Function: test_rule_max_file_line_numbers
static void test_rule_max_file_line_numbers(){
	printf("------------------------------%s\n", FORMAT_RESET);

	printf("%sTESTING RULE: max-file-line-numbers%s\n", COLOR_GREEN_BOLD, FORMAT_RESET);

	arraylist_t *file = arraylist_init(ARRAYLIST_DEFAULT_CAPACITY);
	arraylist_add(file, strduplicate("static int glob = 89;"));
	arraylist_add(file, strduplicate("static int glob = 89;"));
	arraylist_add(file, strduplicate("static int glob = 89;"));
	arraylist_add(file, strduplicate("static int glob = 89;"));

	max_file_line_numbers(file, 2, "fictive_file.c");
	max_file_line_numbers(file, 50, "fictive_file.c");

	arraylist_free(file, 1);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xeff2(%rip), %rdi      # 0x13031
leaq 0xefdf(%rip), %rsi      # 0x13025
movb $0x0, %al
callq 0x20b0
leaq 0xf8b7(%rip), %rdi      # 0x1390b
leaq 0xf020(%rip), %rsi      # 0x1307b
leaq 0xefc3(%rip), %rdx      # 0x13025
movb $0x0, %al
callq 0x20b0
movl $0xa, %edi
callq 0x8580
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xf604(%rip), %rdi      # 0x1368a
callq 0xa550
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x8730
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xf5e4(%rip), %rdi      # 0x1368a
callq 0xa550
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x8730
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xf5c4(%rip), %rdi      # 0x1368a
callq 0xa550
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x8730
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xf5a4(%rip), %rdi      # 0x1368a
callq 0xa550
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x8730
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0xf7f5(%rip), %rdx      # 0x138fc
callq 0xcaa0
movq -0x8(%rbp), %rdi
movl $0x32, %esi
leaq 0xf7e0(%rip), %rdx      # 0x138fc
callq 0xcaa0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8a00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/display.c
// Function: print_message
void print_message(char *file, int line_index, char *line, const char *message, const char *type, const char *color) {
	if(line == NULL)
		printf("%s[%s]%s At %s%s:%d%s: %s\n", color, type, FORMAT_RESET, COLOR_CYAN_BOLD, file, line_index, FORMAT_RESET, message);
	else
		printf("%s[%s]%s At %s%s:%d%s: %s\n  %s\n", color, type, FORMAT_RESET, COLOR_CYAN_BOLD, file, line_index, FORMAT_RESET, message, line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x68fa
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %r9
movl -0x14(%rbp), %r11d
movq -0x28(%rbp), %rax
leaq 0xde32(%rip), %rdi      # 0x14704
leaq 0xc74c(%rip), %r10      # 0x13025
leaq 0xcfa8(%rip), %r8       # 0x13888
movq %r10, %rcx
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x20b0
jmp 0x6942
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %r9
movl -0x14(%rbp), %ebx
movq -0x28(%rbp), %r10
movq -0x20(%rbp), %rax
leaq 0xde07(%rip), %rdi      # 0x1471f
leaq 0xc706(%rip), %r11      # 0x13025
leaq 0xcf62(%rip), %r8       # 0x13888
movq %r11, %rcx
movl %ebx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x20b0
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: exclude_conf_file
void exclude_conf_file(arraylist_t *conf, char *name){
    if(strlen(name) <= 0) return;

    rule_t *e;

    e = malloc(sizeof(rule_t));
    e->name = malloc(sizeof(char) * 1048);

    strcpy(e->name, "conf_inc_");
    strcat(e->name, name);

    e->enable = 1;
    e->value = 0;
    arraylist_add(conf, e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
cmpq $0x0, %rax
ja 0x6c21
jmp 0x6c89
movl $0x10, %edi
callq 0x2110
movq %rax, -0x18(%rbp)
movl $0x418, %edi            # imm = 0x418
callq 0x2110
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0xdaf7(%rip), %rsi      # 0x14748
callq 0x2060
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8730
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: find_rule_index
int find_rule_index(arraylist_t *conf, char *name){
    if(strlen(name) <= 0) return -2;

    for(size_t i = 0; i < conf->size; i++){
        if(strcmp(name, ((rule_t*)(conf->array[i]))->name) == 0){
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2090
cmpq $0x0, %rax
ja 0x6cb8
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x6d0e
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x6d07
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x6cf7
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x6d0e
jmp 0x6cf9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6cc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: exclude_file
void exclude_file(FILE *src, arraylist_t *conf){
    if(src == NULL) return;
    char *line;
    int found;
    char *tmp;
    char *get;
    rule_t *e;

    line = malloc(sizeof(char) * 1048);
    tmp = malloc(sizeof(char) * 1048);

    get = fgets(line, 1048, src);
    if(get == NULL) { //Unexpected EOF reached
        free(line);
        free(tmp);
        return;
    }

    while(!is_whitespace(line[0]) && line[0] != '#'){
        strcpy(tmp, "exfile_");
        if(line[1] == ' '){
            strcat(tmp, line+2);
        }else{
            strcat(tmp, line+1);
        }
        strformat(tmp, 1048);

        found = find_rule_index(conf, tmp);
        if(found == -1 ){
            e = malloc(sizeof(rule_t));
            e->name = malloc(sizeof(char) * 1048);
            strcpy(e->name, tmp);
            e->value = 0;
            e->enable = 0;
            arraylist_add(conf, e);
        }
        get = fgets(line, 1048, src);
        if(get == NULL) break;
    }
    free(line);
    free(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x706c
jmp 0x71e2
movl $0x418, %edi            # imm = 0x418
callq 0x2110
movq %rax, -0x18(%rbp)
movl $0x418, %edi            # imm = 0x418
callq 0x2110
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x418, %esi            # imm = 0x418
callq 0x20e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x70bc
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x28(%rbp), %rdi
callq 0x2030
jmp 0x71e2
jmp 0x70be
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0xa7d0
movb %al, %cl
xorl %eax, %eax
cmpb $0x0, %cl
movb %al, -0x39(%rbp)
jne 0x70e6
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x70f2
jmp 0x71d0
movq -0x28(%rbp), %rdi
leaq 0xd676(%rip), %rsi      # 0x14773
callq 0x2060
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x20, %eax
jne 0x7122
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
callq 0x2150
jmp 0x7133
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x2150
movq -0x28(%rbp), %rdi
movl $0x418, %esi            # imm = 0x418
callq 0xabb0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6c90
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x71ac
movl $0x10, %edi
callq 0x2110
movq %rax, -0x38(%rbp)
movl $0x418, %edi            # imm = 0x418
callq 0x2110
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2060
movq -0x38(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x8730
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x418, %esi            # imm = 0x418
callq 0x20e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x71cb
jmp 0x71d0
jmp 0x70be
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x28(%rbp), %rdi
callq 0x2030
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: recursive_activation
void recursive_activation(FILE *src, arraylist_t *conf){
    if(src == NULL) return;

    char *line;
    char *get; //fgets return
    int found;
    int enable;
    enable = 0;
    rule_t *e;

    line = malloc(sizeof(char) * 1048);

    get = fgets(line, 1048, src);
    if(get == NULL) { //Unexpected EOF reached
        free(line);
        return;
    }
    if(!is_whitespace(line[0]) && line[0] != '#'){

        found = find_rule_index(conf, "recursive");

        if(strstr(line, "true")){
            enable = 1;
        }
        if(strstr(line, "false")){
            enable = 0;
        }

        if(found >= 0){
            ((rule_t*)(conf->array[found]))->enable= enable;
        }else if(found == -1){
            e = malloc(sizeof(rule_t));

            e->name = malloc(sizeof(char) * 1048);

            strcpy(e->name, "recursive");
            e->value = 0;
            e->enable = enable;
            arraylist_add(conf, e);
        }
    }
    free(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x720c
jmp 0x7344
movl $0x0, -0x28(%rbp)
movl $0x418, %edi            # imm = 0x418
callq 0x2110
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x418, %esi            # imm = 0x418
callq 0x20e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x724c
movq -0x18(%rbp), %rdi
callq 0x2030
jmp 0x7344
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0xa7d0
cmpb $0x0, %al
jne 0x733b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x733b
movq -0x10(%rbp), %rdi
leaq 0xd4ee(%rip), %rsi      # 0x14769
callq 0x6c90
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd4ed(%rip), %rsi      # 0x1477b
callq 0x2190
cmpq $0x0, %rax
je 0x72a0
movl $0x1, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd4d5(%rip), %rsi      # 0x14780
callq 0x2190
cmpq $0x0, %rax
je 0x72bd
movl $0x0, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x72da
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x8(%rax)
jmp 0x7339
cmpl $-0x1, -0x24(%rbp)
jne 0x7337
movl $0x10, %edi
callq 0x2110
movq %rax, -0x30(%rbp)
movl $0x418, %edi            # imm = 0x418
callq 0x2110
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0xd459(%rip), %rsi      # 0x14769
callq 0x2060
movq -0x30(%rbp), %rax
movl $0x0, 0xc(%rax)
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8730
jmp 0x7339
jmp 0x733b
movq -0x18(%rbp), %rdi
callq 0x2030
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: is_recursive
int is_recursive(arraylist_t *conf) {
    if (conf == NULL) return -1;
    int index = find_rule_index(conf, "recursive");
    if (index >= 0) return ((rule_t *) (arraylist_get(conf, (unsigned int) index)))->enable;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x736c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x73a2
movq -0x10(%rbp), %rdi
leaq 0xd3f2(%rip), %rsi      # 0x14769
callq 0x6c90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x739b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8890
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x73a2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: get_rule
rule_t *get_rule(arraylist_t *conf, char *name){
    if(conf == NULL || strlen(name) <= 0) return NULL;
    int index = find_rule_index(conf, name);
    if(index >= 0) return ((rule_t*)(arraylist_get(conf, (unsigned int)index)));
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x73d6
movq -0x18(%rbp), %rdi
callq 0x2090
cmpq $0x0, %rax
ja 0x73e0
movq $0x0, -0x8(%rbp)
jmp 0x7412
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6c90
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x740a
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x8890
movq %rax, -0x8(%rbp)
jmp 0x7412
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: exclude_filepath
void exclude_filepath(arraylist_t *conf, char *filepath){
    if(strlen(filepath) <= 0) return;

    rule_t *e;

    e = malloc(sizeof(rule_t));
    e->name = malloc(sizeof(char) * 1048);

    strcpy(e->name, "incfilepath_");
    strcat(e->name, filepath);

    e->enable = 1;
    e->value = 0;
    arraylist_add(conf, e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
cmpq $0x0, %rax
ja 0x7441
jmp 0x74a9
movl $0x10, %edi
callq 0x2110
movq %rax, -0x18(%rbp)
movl $0x418, %edi            # imm = 0x418
callq 0x2110
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0xd315(%rip), %rsi      # 0x14786
callq 0x2060
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8730
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: is_excluded
int is_excluded(arraylist_t *conf, char *path) {
    char *name;
    name = malloc(sizeof(char) * 1048);

    strcpy(name, "exfile_");
    strcat(name, path);
    if(get_rule(conf, name) == NULL) {
        free(name);
        return 0;
    } else {
        free(name);
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x418, %edi            # imm = 0x418
callq 0x2110
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xd29a(%rip), %rsi      # 0x14773
callq 0x2060
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2150
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x73b0
cmpq $0x0, %rax
jne 0x7510
movq -0x20(%rbp), %rdi
callq 0x2030
movl $0x0, -0x4(%rbp)
jmp 0x7520
movq -0x20(%rbp), %rdi
callq 0x2030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: free_conf
void free_conf(arraylist_t *conf) {
    if(!conf) return;
    for(size_t i = 0; i < conf->size; i++){
        free(((rule_t*)(arraylist_get(conf,i)))->name);
        free(conf->array[i]);
    }
    arraylist_free(conf, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7545
jmp 0x759d
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x7592
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8890
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x754d
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8a00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: field_init
field_t *field_init(char *name, char *type, char type_is_pointer, int line_index) {
	field_t *field = malloc(sizeof(field_t));

	if(field != NULL) {
		field->name            = name;
		field->type.name       = type;
		field->type.is_pointer = type_is_pointer;
		field->type.is_literal = 0;
		field->line            = line_index;
		field->is_param        = 0;
		field->value           = NULL;
	}
	return field;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x28, %edi
callq 0x2110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7674
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x18(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x19(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x24(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: scope_init
scope_t *scope_init(scope_t *parent) {
	scope_t *scope = malloc(sizeof(scope_t));

	if(scope != NULL) {
		scope->parent    = parent;
		scope->children  = linkedlist_init();
		scope->variables = arraylist_init(10);
		scope->functions = arraylist_init(10);
		scope->from_line = -1;
		scope->to_line   = -1;
		scope->from_char = -1;
		scope->to_char   = -1;
	}

	return scope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x30, %edi
callq 0x2110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7714
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, %al
callq 0xc150
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0xa, %edi
callq 0x8580
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0xa, %edi
callq 0x8580
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x24(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: is_in_child_scope
scope_t *is_in_child_scope(scope_t *scope, int line) {
	scope_t *child;
	node_t * current = scope->children->head;
	if(current != NULL) {
		do {
			child = (scope_t*) current->val;
			if(line >= child->from_line && line <= child->to_line)
				return child;
		} while ((current = current->next) != NULL);
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7787
jmp 0x7744
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jl 0x7771
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jg 0x7771
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x778f
jmp 0x7773
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x7744
jmp 0x7787
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: parse_scope_content
static void parse_scope_content(arraylist_t *file, scope_t *scope) {
	char *line;
	arraylist_t *variables;

	for(int i = scope->from_line ; i <= scope->to_line ; i++) {
		if(is_in_child_scope(scope, i)) continue; //Ignore lines inside child scopes
		line = (char*) arraylist_get(file, i);
		variables = get_variables_from_declaration(i,line);
		if(variables != NULL) {
			arraylist_add_all(scope->variables, variables);
			arraylist_free(variables, 0);
			variables = NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jg 0x7cd3
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x7720
cmpq $0x0, %rax
je 0x7c7a
jmp 0x7cc8
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x8890
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xb980
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7cc6
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x8830
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x8a00
movq $0x0, -0x20(%rbp)
jmp 0x7cc8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7c5a
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: parse_scope_functions
static void parse_scope_functions(arraylist_t *file, scope_t *scope) {
	char *line;
	function_t *function;

	for(int i = scope->from_line ; i < scope->to_line ; i++) {
		line = (char*) arraylist_get(file, i);
		function = get_function_from_declaration(i, line);
		if(function != NULL) {
			arraylist_add(scope->functions, function);
			function = NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x7d54
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x8890
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xee90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7d47
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x8730
movq $0x0, -0x20(%rbp)
jmp 0x7d49
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7cfa
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: find_function_from_line
static function_t *find_function_from_line(arraylist_t *list, int line) {
	function_t *function = NULL;
	for(size_t i = 0 ; i < list->size ; i++) {
		function = arraylist_get(list, i);
		if(function->line == line)
			return function;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x7dc4
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x7db4
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7dcc
jmp 0x7db6
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7d7f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)