LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: trim_heading_whitespaces
char *trim_heading_whitespaces(char *line) {
	size_t index = 0;
	size_t length = strlen(line);
	char *trimmed = line;

	while(is_whitespace(*trimmed) && index < length) {
		trimmed++;
		index++;
	}

	return trimmed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2090
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0xacd0
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xacd9
jmp 0xacf3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xaca9
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: trim
char *trim(char *line) {
	char *trimmed = strduplicate(trim_heading_whitespaces(line));
	size_t index  = 0;
	size_t length = strlen(trimmed);

	index = length - 1;
	while(is_whitespace(trimmed[index]) && index < length) {
		index--;
	}

	trimmed[index + 1] = '\0';

	return trimmed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xac80
movq %rax, %rdi
callq 0xa550
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0xad6e
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xad77
jmp 0xad85
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xad42
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, 0x1(%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: check_quotes
unsigned char check_quotes(char *line, char *occurrence, int length) {
	unsigned char found_before = 0;

	//Find quote before
	for(int i = occurrence - line ; i >= 0 ; i--) {
		if(line[i] == '"') {
			found_before = 1;
			break;
		}
	}

	if(!found_before) return 0;

	//Find quote after
	for(int i = occurrence - line ; i < length ; i++) {
		if(line[i] == '"') {
			return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xaeab
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
jne 0xae9e
movb $0x1, -0x1d(%rbp)
jmp 0xaeab
jmp 0xaea0
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xae81
cmpb $0x0, -0x1d(%rbp)
jne 0xaeb7
movb $0x0, -0x1(%rbp)
jmp 0xaef5
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xaef1
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
jne 0xaee4
movb $0x1, -0x1(%rbp)
jmp 0xaef5
jmp 0xaee6
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xaec5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: check_parenthesis
unsigned char check_parenthesis(char *line, char *occurrence, int length) {
	unsigned char found_before = 0;
	int  level                 = -1; 

	//Find parenthesis before
	for(int i = occurrence - line ; i >= 0 ; i--) {
		if(line[i] == ')' && !check_quotes(line, line + i, length)) {
			level--;
		}
		if(line[i] == '(' && !check_quotes(line, line + i, length)) {
			level++;
			if(level == 0) {
				found_before = 1;
				break;
			}
		}
	}

	if(!found_before) return 0;
	level = 1;

	//Find parenthesis after
	for(int i = occurrence - line ; i < length ; i++) {
		if(line[i] == '(' && !check_quotes(line, line + i, length)) {
			level++;
		} 
		if(line[i] == ')' && !check_quotes(line, line + i, length)) {
			level--;
			if(level == 0)
				return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0xafbe
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x29, %eax
jne 0xaf6b
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x28(%rbp), %rax
addq %rax, %rsi
movl -0x1c(%rbp), %edx
callq 0xae60
cmpb $0x0, %al
jne 0xaf6b
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
jne 0xafae
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x28(%rbp), %rax
addq %rax, %rsi
movl -0x1c(%rbp), %edx
callq 0xae60
cmpb $0x0, %al
jne 0xafae
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xafac
movb $0x1, -0x1d(%rbp)
jmp 0xafbe
jmp 0xafae
jmp 0xafb0
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xaf2c
cmpb $0x0, -0x1d(%rbp)
jne 0xafcd
movb $0x0, -0x1(%rbp)
jmp 0xb07a
movl $0x1, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb076
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
jne 0xb023
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
movl -0x1c(%rbp), %edx
callq 0xae60
cmpb $0x0, %al
jne 0xb023
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x29, %eax
jne 0xb066
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
movl -0x1c(%rbp), %edx
callq 0xae60
cmpb $0x0, %al
jne 0xb066
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xb064
movb $0x1, -0x1(%rbp)
jmp 0xb07a
jmp 0xb066
jmp 0xb068
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xafe2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: generate_char_sequence
char *generate_char_sequence(char c, unsigned int count) {
	char *seq = malloc((count + 1)*sizeof(char));
	for(unsigned int i = 0 ; i < count ; i++) {
		seq[i] = c;
	}
	seq[count] = '\0';
	return seq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x2110
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0xb2bf
movb -0x1(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb29f
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_variables.c
// Function: parse_variable_array
static unsigned int parse_variable_array(char *line, size_t length, unsigned int *i) {
	unsigned int index = *i;
	unsigned int array_count = 0;
	char c;

	//Is array?
	do {
		if(index < length && line[index] == '[') {
			index++;
			array_count++;

			//Any character until closing bracket
			while((c = line[index]) != ']' && index < length) {
				index++;
			}
			index++;

			SKIP_WHITESPACES
		} else break;
	} while(index < length);

	*i = index;
	return array_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpq -0x10(%rbp), %rax
jae 0xb720
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x5b, %eax
jne 0xb720
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x5d, %ecx
movb %al, -0x22(%rbp)
je 0xb6be
movl -0x1c(%rbp), %eax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0xb6c7
jmp 0xb6d2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb697
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x23(%rbp)
je 0xb70a
movl -0x1c(%rbp), %eax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
testb $0x1, %al
jne 0xb713
jmp 0xb71e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb6db
jmp 0xb722
jmp 0xb731
jmp 0xb724
movl -0x1c(%rbp), %eax
cmpq -0x10(%rbp), %rax
jb 0xb664
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_variables.c
// Function: skip_switch_case
static int skip_switch_case(char *line, int index, int length) {

	char c;

	SKIP_WHITESPACES

	if(strstr(line + index, "case") == line + index || strstr(line + index, "default") == line + index) {
		index += c == 'c' ? 4 : 7;

		SKIP_WHITESPACES

		while((c = line[index]) != ':' && index < length) {
			index++;
		}

		if(c != ':') return -1;

		return index + 1;
	}

	return -1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
je 0xbd01
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0xbd0a
jmp 0xbd15
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbcd2
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
leaq 0x8a92(%rip), %rsi      # 0x147b9
callq 0x2190
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0xbd67
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
leaq 0x8a7f(%rip), %rsi      # 0x147cd
callq 0x2190
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0xbe1e
movsbl -0x19(%rbp), %edx
movl $0x7, %eax
movl $0x4, %ecx
cmpl $0x63, %edx
cmovel %ecx, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1b(%rbp)
je 0xbdb0
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
testb $0x1, %al
jne 0xbdb9
jmp 0xbdc4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbd81
jmp 0xbdc6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x3a, %ecx
movb %al, -0x1c(%rbp)
je 0xbded
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
movb %al, -0x1c(%rbp)
movb -0x1c(%rbp), %al
testb $0x1, %al
jne 0xbdf6
jmp 0xbe01
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbdc6
movsbl -0x19(%rbp), %eax
cmpl $0x3a, %eax
je 0xbe13
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbe25
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xbe25
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_variables.c
// Function: match_for_loop
static match_t *match_for_loop(char *line) {
	match_t *match = NULL;
	unsigned int index = 0;
	size_t length = strlen(line);
	char c;

	SKIP_WHITESPACES

	if(strstr(line + index, "for") == line + index) {

		index += 3; // Skip "for"

		SKIP_WHITESPACES

		if(c != '(') return NULL; //Syntax error

		index++;
		SKIP_WHITESPACES

		match = match_init();
		if(match == NULL) return NULL;

		match->index_start = index;
		match->index_end = strindexof(line + index , ';') + index + 1;

		if(match->index_start > match->index_end) {
			free(match);
			match = NULL;
		}
	}

	return match;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
je 0xbe87
movl -0x1c(%rbp), %eax
cmpq -0x28(%rbp), %rax
setb %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0xbe90
jmp 0xbe9b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbe58
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
leaq 0x717e(%rip), %rsi      # 0x1302a
callq 0x2190
movq -0x10(%rbp), %rcx
movl -0x1c(%rbp), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0xbfdc
movl -0x1c(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2b(%rbp)
je 0xbefc
movl -0x1c(%rbp), %eax
cmpq -0x28(%rbp), %rax
setb %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
testb $0x1, %al
jne 0xbf05
jmp 0xbf10
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbecd
movsbl -0x29(%rbp), %eax
cmpl $0x28, %eax
je 0xbf26
movq $0x0, -0x8(%rbp)
jmp 0xbfe4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2c(%rbp)
je 0xbf5e
movl -0x1c(%rbp), %eax
cmpq -0x28(%rbp), %rax
setb %al
movb %al, -0x2c(%rbp)
movb -0x2c(%rbp), %al
testb $0x1, %al
jne 0xbf67
jmp 0xbf72
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbf2f
movb $0x0, %al
callq 0xae40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbf8e
movq $0x0, -0x8(%rbp)
jmp 0xbfe4
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movl $0x3b, %esi
callq 0xa8d0
movl %eax, %ecx
addl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jbe 0xbfda
movq -0x18(%rbp), %rdi
callq 0x2030
movq $0x0, -0x18(%rbp)
jmp 0xbfdc
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_variables.c
// Function: get_variable_from_declaration
static field_t *get_variable_from_declaration(int line_index, char *type, int star_count_type, char *declaration, unsigned int *names_index) {

	field_t *variable = NULL;
	match_t *match = NULL;
	unsigned int star_count, sub_index, tmp_index;
	char *tmp;
	char *name;
	char *value = NULL;
	unsigned int array_count = 0;

	tmp_index = *names_index;
	match = parse_variable_name(declaration, names_index, &array_count, &value);

	if(match != NULL) {
		tmp = substr_match(declaration + tmp_index, *match);
		free(match);

		star_count = strcount(tmp, '*');
		sub_index  = strcountuntil(tmp, '*', 0, 1);

		//Remove stars
		name = strsubstr(tmp, sub_index, strlen(tmp) - star_count);
		free(tmp);

		if(name != NULL) {
			if(is_keyword(name)) {
				free(name);
			} else {
				variable = field_init(name, strduplicate(type), star_count + array_count + star_count_type, line_index);
				variable->value = value;
			}
		}
	}

	return variable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0xb2e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xc13c
movq -0x20(%rbp), %rdi
movl -0x44(%rbp), %eax
addq %rax, %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
callq 0xac10
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2030
movq -0x50(%rbp), %rdi
movl $0x2a, %esi
callq 0xa660
movl %eax, -0x3c(%rbp)
movq -0x50(%rbp), %rdi
movl $0x2a, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xa6d0
movl %eax, -0x40(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2090
movq -0x70(%rbp), %rdi
movl -0x68(%rbp), %esi
movl -0x3c(%rbp), %ecx
subq %rcx, %rax
movl %eax, %edx
callq 0xa5e0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2030
cmpq $0x0, -0x58(%rbp)
je 0xc13a
movq -0x58(%rbp), %rdi
callq 0x8510
cmpb $0x0, %al
je 0xc0fc
movq -0x58(%rbp), %rdi
callq 0x2030
jmp 0xc138
movq -0x58(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa550
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movl -0x3c(%rbp), %eax
addl -0x64(%rbp), %eax
addl -0x14(%rbp), %eax
movl -0x4(%rbp), %ecx
movsbl %al, %edx
callq 0x7600
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xc13a
jmp 0xc13c
movq -0x30(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/linkedlist.c
// Function: linkedlist_init
linkedlist_t *linkedlist_init() {
	linkedlist_t *list = malloc(sizeof(linkedlist_t));
	if(list == NULL) return NULL;
	list->length = 0;
	list->head = NULL;
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x2110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc177
movq $0x0, -0x8(%rbp)
jmp 0xc195
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/linkedlist.c
// Function: linkedlist_add
void linkedlist_add(linkedlist_t *list, void *value) {
	node_t * node = linkedlist_create_node(value, NULL);
	if(list->length) {
		node_t *last = linkedlist_get_node(list, list->length-1);
		last->next = linkedlist_create_node(value,NULL);
	} else {
		list->head = node;
	}
	list->length++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc220
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0xc1fa
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
subl $0x1, %esi
callq 0xc280
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc220
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xc206
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/linkedlist.c
// Function: linkedlist_create_node
node_t * linkedlist_create_node(void *value, node_t *next) {
	node_t * node = NULL;
	node = malloc(sizeof(node_t));
	if(node == NULL) {
		exit(1);
	}
	node->val = value;
	node->next = next;
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x10, %edi
callq 0x2110
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc257
movl $0x1, %edi
callq 0x2170
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/linkedlist.c
// Function: linkedlist_get_node
node_t * linkedlist_get_node(linkedlist_t *list, int index) {
	if(index >= list->length || index < 0) return NULL;
	node_t * current = list->head;
	for(int i = 1; i <= index && current != NULL ; i++) {
		current = current->next;
	}
	return current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xc29c
cmpl $0x0, -0x14(%rbp)
jge 0xc2a6
movq $0x0, -0x8(%rbp)
jmp 0xc2f9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x25(%rbp)
jg 0xc2d1
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xc2da
jmp 0xc2f1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc2b9
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/linkedlist.c
// Function: linkedlist_remove_index
void linkedlist_remove_index(linkedlist_t *list, int index) {

	if(list->length == 0) return;

	if(!index) {
		linkedlist_pop(list);
		return;
	}

	node_t * current = list->head;
	node_t * temp_node = NULL;
	for(int i = 1; i < index && current != NULL ; i++) {
		current = current->next;
	}

	temp_node = current->next;
	current->next = temp_node->next;
	if(temp_node->val != NULL)
		free(temp_node->val);
	free(temp_node);

	list->length--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xc31d
jmp 0xc3ca
cmpl $0x0, -0xc(%rbp)
jne 0xc331
movq -0x8(%rbp), %rdi
callq 0xc3d0
jmp 0xc3ca
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x25(%rbp)
jge 0xc364
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xc36d
jmp 0xc384
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc34c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc3b6
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/linkedlist.c
// Function: linkedlist_pop
void linkedlist_pop(linkedlist_t *list) {
	if(!list->length) return;
	node_t * next_node = NULL;
	node_t ** head = &list->head;

	next_node = (*head)->next;
	if((*head)->val != NULL)
		free((*head)->val);
	free(*head);
	*head = next_node;
	list->length--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xc3e7
jmp 0xc448
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0xc426
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/linkedlist.c
// Function: linkedlist_insert
void linkedlist_insert(linkedlist_t *list, int index, void *value) {
	if(index == list->length) {
		linkedlist_add(list,value);
	} else if(!index) {
		linkedlist_push(list,value);
	} else {
		node_t * previous = linkedlist_get_node(list, index-1);
		previous->next = linkedlist_create_node(value,previous->next);

		list->length++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xc4cd
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc1a0
jmp 0xc51e
cmpl $0x0, -0xc(%rbp)
jne 0xc4e2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc530
jmp 0xc51c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
callq 0xc280
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xc220
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xc51e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/linkedlist.c
// Function: linkedlist_push
void linkedlist_push(linkedlist_t *list, void *value) {
	node_t ** head = &list->head;
	node_t * newNode = linkedlist_create_node(value,*head);
	*head = newNode;
	list->length++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xc220
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/linkedlist.c
// Function: linkedlist_free
void linkedlist_free(linkedlist_t *list) {
	if(list == NULL) return;
	node_t * current;
	while ((current = list->head) != NULL) {
		list->head = list->head->next;
		if(current->val != NULL)
			free (current->val);
		free (current);
	}
	free(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xc595
jmp 0xc5e7
jmp 0xc597
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xc5de
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc5d3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0x2030
jmp 0xc597
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/no_trailing_spaces.c
// Function: no_trailing_spaces
int no_trailing_spaces(arraylist_t *file, char *filename) {
	if(!file) return -1;
	unsigned int counter = 0;
	for(size_t i = 0 ; i < file->size ; i++){
		counter += no_trailing_spaces_check(arraylist_get(file, i), i, filename);
	}
	return counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc610
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc666
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xc660
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8890
movq %rax, %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
movq -0x18(%rbp), %rdx
callq 0xc670
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xc61f
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/no_trailing_spaces.c
// Function: no_trailing_spaces_check
static int no_trailing_spaces_check(char *line, int line_index, char *filename) {
	int index;
	char *trimmed = NULL;
	index = strlastindexof(line, '\n');
	if((index >= 1 && line[index-1] == ' ') || (index >= 2 && line[index - 1] == '\r' && line[index - 2] == ' ')) {
		trimmed = trim(line);
		print_warning(filename, line_index + 1, trimmed, "Trailing space(s) before EOL");
		free(trimmed);
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0xa940
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jl 0xc6b8
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0xc6ea
cmpl $0x2, -0x24(%rbp)
jl 0xc723
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0xc723
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0xc723
movq -0x10(%rbp), %rdi
callq 0xad00
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movq -0x30(%rbp), %rdx
leaq 0x8241(%rip), %rcx      # 0x1494d
callq 0x6850
movq -0x30(%rbp), %rdi
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0xc72a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/array_bracket_eol.c
// Function: array_bracket_eol
unsigned int array_bracket_eol(arraylist_t *file, arraylist_t *real_file) {
	unsigned int counter = 0;

	for(unsigned int i = 0; i < file->size; i++) {
		counter += array_bracket_eol_check(get_line(file, i), real_file);
	}
	return counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xc794
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2cb0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xc7a0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc75e
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/array_bracket_eol.c
// Function: check_do
static unsigned int check_do(char *line, int index_bracket){
	if(index_bracket == -1){
		return -1;
	}
	for(int i = index_bracket - 1; i > 0; i--){
		if(line[i] == 'o' && line[i-1] == 'd'){
			return i;
		}else if(!is_whitespace(line[i])){
			return -1;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0xca1e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca90
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0xca89
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x6f, %eax
jne 0xca5c
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x64, %eax
jne 0xca5c
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xca90
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa7d0
cmpb $0x0, %al
jne 0xca7a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca90
jmp 0xca7c
jmp 0xca7e
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xca27
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
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/rules/max_file_line_numbers.c
// Function: max_file_line_numbers
unsigned int max_file_line_numbers(arraylist_t *file, unsigned int n, char *filename){

  if(file->size > n){
    char size_string[12];
    char n_string[12];
    sprintf(size_string, "%ld", file->size);
    sprintf(n_string, "%d", n);

    char *tmp0 = strconcat("Too many lines, actual: ", size_string);
    char *tmp1 = strconcat(tmp0, ", max: ");
    free(tmp0);
    tmp0 = strconcat(tmp1, n_string);

    print_warning(filename, n, NULL, tmp0);

    free(tmp1);
    free(tmp0);
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jbe 0xcb67
leaq -0x2c(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x7eab(%rip), %rsi      # 0x14985
movb $0x0, %al
callq 0x2160
leaq -0x38(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x7e9a(%rip), %rsi      # 0x14989
movb $0x0, %al
callq 0x2160
leaq -0x2c(%rbp), %rsi
leaq 0x7e8b(%rip), %rdi      # 0x1498c
callq 0xa9b0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
leaq 0x7e90(%rip), %rsi      # 0x149a5
callq 0xa9b0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2030
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa9b0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x40(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x6850
movq -0x48(%rbp), %rdi
callq 0x2030
movq -0x40(%rbp), %rdi
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0xcb6e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/no_multi_declaration.c
// Function: list_contains
static unsigned char list_contains(arraylist_t *list, int value) {
	for(size_t i = 0 ; i < list->size ; i++) {
		if(*(int*)arraylist_get(list, i) == value)
			return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xce1f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8890
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xce0f
movb $0x1, -0x1(%rbp)
jmp 0xce23
jmp 0xce11
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xcde7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/indent.c
// Function: is_expression
int is_expression(char *line, char *tmp){
    size_t index = 0;
    size_t length;
    char c;

    length = strlen(line);

    while (is_whitespace(c = line[index]) && index < length) { index++; };
    if(!strcmp(tmp, line+index)) return 1;
    return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
je 0xd2e6
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setb %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0xd2ef
jmp 0xd2fd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd2b5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0xd31c
movl $0x1, -0x4(%rbp)
jmp 0xd323
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/indent.c
// Function: check_expression
void check_expression(char *line, const char *expr, int *adding, int *special){
    char *tmp = NULL;
    size_t tmp_length;
    size_t index;
    char c;

    tmp = strstr(line, expr);
    index = strlen(expr);
    if(tmp) {
        if(!is_expression(line, tmp)) return;
        tmp_length = strlen(tmp);
        while (is_whitespace(c = tmp[index]) && index < tmp_length) { index++; };
        if (*adding == 0 && tmp[index] == '(') {
            (*adding) += 1;
            (*special) = 1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2190
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xd416
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xd290
cmpl $0x0, %eax
jne 0xd390
jmp 0xd416
movq -0x28(%rbp), %rdi
callq 0x2090
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
je 0xd3ce
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
setb %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0xd3d7
jmp 0xd3e5
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xd39d
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xd414
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
jne 0xd414
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
jmp 0xd416
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/comma_spacing.c
// Function: comma_spacing
unsigned int comma_spacing(arraylist_t *buffer, arraylist_t *real_file){
    char *line = NULL;
    size_t length;
    unsigned int counter = 0;
    line_t *e;
    char *display = NULL;
    unsigned int breaks = 0;

    for(size_t i = 0; i < buffer->size; i++){
        e = get_line(buffer, i);
        line = str_remove_comments(e->line);
        length = strlen(line);
        for(size_t j = 0; j < length; j++){
            if(line[j] == ',' && !check_quotes(line, line+j, (int)length) && line[j+1] != ' '){
                counter++;
                breaks = strcount_heading_line_breaks(e->line) + (e->start_real_line == 0 ? 1 : 0);
                display = trim(arraylist_get(real_file, e->start_real_line + breaks - 1));
                print_warning(e->source, e->start_real_line + breaks, display, "No space after a comma");
                free(display);
            }
        }
        free(line);
    }
    return counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xd5a0
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
movl %eax, %esi
callq 0x2cb0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0xa2b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2090
movq %rax, -0x20(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xd586
movq -0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
jne 0xd573
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x50(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %edx
callq 0xae60
cmpb $0x0, %al
jne 0xd573
movq -0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0x20, %eax
je 0xd573
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0xa840
movq -0x30(%rbp), %rcx
movl 0x10(%rcx), %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovel %edx, %ecx
addl %ecx, %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
addl -0x3c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x8890
movq %rax, %rdi
callq 0xad00
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rax
movl 0x10(%rax), %esi
addl -0x3c(%rbp), %esi
movq -0x38(%rbp), %rdx
leaq 0x7478(%rip), %rcx      # 0x149dd
callq 0x6850
movq -0x38(%rbp), %rdi
callq 0x2030
jmp 0xd575
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0xd4a0
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xd456
movl -0x24(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/no_prototype.c
// Function: check_params
static char check_params(function_t *function, function_t *prototype) {
	if(function->params->size != prototype->params->size) return 0;
	for(size_t i = 0 ; i < function->params->size ; i++) {
		if(!type_equals(&((field_t*)arraylist_get(function->params, i))->type, &((field_t*)arraylist_get(prototype->params, i))->type))
			return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x8(%rcx), %rax
je 0xd830
movb $0x0, -0x1(%rbp)
jmp 0xd8a2
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0xd89e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x8890
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x8890
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rsi
callq 0x8080
cmpb $0x0, %al
jne 0xd88e
movb $0x0, -0x1(%rbp)
jmp 0xd8a2
jmp 0xd890
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd838
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/max_line_numbers.c
// Function: check_max_line_length
unsigned int check_max_line_length(arraylist_t *file, unsigned int n, char *filename){
	unsigned int counter = 0;

	for(unsigned int i = 0; i < file->size; i++){
		counter += line_length_check(arraylist_get(file, i), n, i, filename);
	}
	return counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xd90f
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x8890
movq %rax, %rdi
movl -0xc(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0xd920
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd8d1
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/max_line_numbers.c
// Function: line_length_check
static unsigned int line_length_check(char *line, unsigned int n, unsigned int line_index, char *filename) {
	char *tmp0 = NULL;
	char *tmp1 = NULL;
	char *display = NULL;
	char length_str[20];
	char max_str[12];
	size_t length = strlen(line);

	if(length >= 1 && line[length - 1] == '\n')
		length--;

	if(length > n){
		sprintf(length_str, "%ld", length);
		sprintf(max_str, "%d", n);
		tmp0 = strconcat("Too many characters, actual: ", length_str);
		tmp1 = strconcat(tmp0, ", max: ");
		free(tmp0);
		tmp0 = strconcat(tmp1, max_str);
		free(tmp1);
		display = trim(line);
		print_warning(filename, line_index + 1, display, tmp0);
		free(tmp0);
		free(display);
		return 1;
	} else {
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0x68(%rbp)
cmpq $0x1, -0x68(%rbp)
jb 0xd983
movq -0x10(%rbp), %rax
movq -0x68(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xd983
movq -0x68(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jbe 0xda48
leaq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x6fe3(%rip), %rsi      # 0x14985
movb $0x0, %al
callq 0x2160
leaq -0x5c(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x6fd2(%rip), %rsi      # 0x14989
movb $0x0, %al
callq 0x2160
leaq -0x50(%rbp), %rsi
leaq 0x7054(%rip), %rdi      # 0x14a1d
callq 0xa9b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x6fc8(%rip), %rsi      # 0x149a5
callq 0xa9b0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x30(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0xa9b0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0xad00
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6850
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x38(%rbp), %rdi
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0xda4f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/parsing.c
// Function: fill_functions_list
static void fill_functions_list(scope_t *root_scope, arraylist_t *functions) {
	function_t *function = NULL;
	for(size_t i = 0 ; i < root_scope->functions->size ; i++) {
		function = arraylist_get(root_scope->functions, i);
		if(!(function->is_prototype) && strcmp(function->name, "sizeof")) {
			arraylist_add(functions, function);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0xe9e6
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x8890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x18(%rax)
jne 0xe9d6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5e84(%rip), %rsi      # 0x14843
callq 0x20f0
cmpl $0x0, %eax
je 0xe9d6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8730
jmp 0xe9d8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xe980
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/parsing.c
// Function: fill_variables_list
static void fill_variables_list(scope_t *scope, arraylist_t *variables) {
	node_t  *current = scope->children->head;
	field_t *field   = NULL;

	for(size_t i = 0 ; i < scope->variables->size ; i++) {
		field = arraylist_get(scope->variables, i);
		arraylist_add(variables, field);
	}

	if(current != NULL) {
		do {
			fill_variables_list((scope_t*)current->val, variables);
		} while ((current = current->next) != NULL);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0xea62
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x8890
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8730
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xea20
cmpq $0x0, -0x18(%rbp)
je 0xea8f
jmp 0xea6b
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe9f0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xea6b
jmp 0xea8f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)