LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: register_sizeof
static void register_sizeof(scope_t *scope) {
	arraylist_t *params       = arraylist_init(1);
	arraylist_t *proto_params = arraylist_init(1);
	function_t *function      = function_init(strduplicate("sizeof"), 0, strduplicate("unsigned long int"), 0, params, -1);
	function_t *prototype     = function_init(strduplicate("sizeof"), 1, strduplicate("unsigned long int"), 0, proto_params, -1);
	field_t *param = field_init(strduplicate("expr"), strduplicate("{ANY}"), 0, -1);

	arraylist_add(proto_params, param);
	param = field_init(strduplicate("expr"), strduplicate("{ANY}"), 0, -1);
	arraylist_add(params, param);

	arraylist_add(scope->functions, prototype);
	arraylist_add(scope->functions, function);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
callq 0x8580
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x8580
movq %rax, -0x18(%rbp)
leaq 0xca34(%rip), %rdi      # 0x14843
callq 0xa550
movq %rax, -0x50(%rbp)
leaq 0xca2b(%rip), %rdi      # 0x1484a
callq 0xa550
movq -0x50(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %r8
xorl %ecx, %ecx
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movl %ecx, %esi
callq 0xee00
movq %rax, -0x20(%rbp)
leaq 0xc9fa(%rip), %rdi      # 0x14843
callq 0xa550
movq %rax, -0x48(%rbp)
leaq 0xc9f1(%rip), %rdi      # 0x1484a
callq 0xa550
movq -0x48(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %r8
movl $0x1, %esi
xorl %ecx, %ecx
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0xee00
movq %rax, -0x28(%rbp)
leaq 0xc9d6(%rip), %rdi      # 0x1485c
callq 0xa550
movq %rax, -0x40(%rbp)
leaq 0xc8fd(%rip), %rdi      # 0x14793
callq 0xa550
movq -0x40(%rbp), %rdi
movq %rax, %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x7600
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8730
leaq 0xc996(%rip), %rdi      # 0x1485c
callq 0xa550
movq %rax, -0x38(%rbp)
leaq 0xc8bd(%rip), %rdi      # 0x14793
callq 0xa550
movq -0x38(%rbp), %rdi
movq %rax, %rsi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x7600
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8730
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x8730
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x8730
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: previous_char_is_equal
static char previous_char_is_equal(char *line, int index) {
	char c;

	index--;
	while(is_whitespace(c = line[index]) && index >= 0) { index--; }

	return c == '=';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xd(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xe(%rbp)
je 0x7f75
cmpl $0x0, -0xc(%rbp)
setge %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
testb $0x1, %al
jne 0x7f7e
jmp 0x7f89
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7f48
movsbl -0xd(%rbp), %eax
cmpl $0x3d, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: scope_free
void scope_free(scope_t *scope) {
	node_t * current;

	//Don't free parent !
	
	//Recursively free children
	current = scope->children->head;
	while (current != NULL) {
		scope_free(current->val);
		current->val = NULL;
		current = current->next;
	}
	linkedlist_free(scope->children);

	//Free functions
	for(size_t i = 0 ; i < scope->functions->size; i++) {
		function_free(scope->functions->array[i]);
		scope->functions->array[i] = NULL;
	}
	arraylist_free(scope->functions, 1);

	//Free variables
	field_list_free(scope->variables);

	free(scope);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7fe8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7fa0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x7fbc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc580
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x804c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x100e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7ffd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x1, %esi
callq 0x8a00
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x81d0
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: type_exists
unsigned char type_exists(char *type) {
	static const char *known_types[] = {"char","short","int","unsigned","signed","long","signed","float","double","size_t","void"};
	for(unsigned i = 0 ; i < 11 ; i++)
		if(!strcmp(type, known_types[i]))
			return 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xb, -0x14(%rbp)
jae 0x816a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xff97(%rip), %rax      # 0x180e0
movq (%rax,%rcx,8), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x815d
movb $0x1, -0x1(%rbp)
jmp 0x816e
jmp 0x815f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8133
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: field_free
void field_free(field_t *field) {
	free(field->name);
	if(field->value != NULL) {
		free(field->value);
	}
	free(field->type.name);
	free(field);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x81b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: field_list_free
void field_list_free(arraylist_t *list) {
	field_t *field = NULL;
	for(unsigned int i = 0 ; i < list->size ; i++) {
		field = arraylist_get(list, i);
		field_free(field);
	}
	arraylist_free(list, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x821e
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8890
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8180
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x81eb
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8a00
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: function_list_free
void function_list_free(arraylist_t *list) {
	function_t *function = NULL;
	for(unsigned int i = 0 ; i < list->size ; i++) {
		function = arraylist_get(list, i);
		function_free(function);
	}
	arraylist_free(list, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x827e
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8890
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x100e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x824b
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8a00
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: get_root_scope
scope_t *get_root_scope(scope_t *scope) {
	scope_t *parent = NULL;
	while((parent = scope->parent) != NULL) {
		scope = parent;
	}
	return scope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x82bb
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x82a0
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: get_function_scope
scope_t *get_function_scope(scope_t *scope) {
	scope_t *parent = NULL;
	while((parent = scope->parent) != NULL) {
		if(scope->parent->parent == NULL)
			return scope;
		scope = parent;
	}
	return scope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x8312
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
jne 0x8308
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x831a
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x82e0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: find_function
function_t *find_function(scope_t *scope, char *name, unsigned char allow_prototypes) {
	scope_t *root = get_root_scope(scope);
	function_t *function = NULL;
	for(size_t i = 0 ; i < root->functions->size ; i++) {
		function = arraylist_get(root->functions, i);
		if(!strcmp(name, function->name) && (allow_prototypes || !function->is_prototype))
			return function;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8290
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x83bb
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x8890
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x83ab
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0x83a1
movq -0x30(%rbp), %rax
cmpb $0x0, 0x18(%rax)
jne 0x83ab
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x83c3
jmp 0x83ad
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x8352
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: find_variable
field_t *find_variable(scope_t *scope, char *name) {
	field_t *variable = NULL;

	while(scope != NULL) {
		for(size_t i = 0 ; i < scope->variables->size ; i++) {
			variable = arraylist_get(scope->variables, i);
			if(!strcmp(name, variable->name))
				return variable;
		}
		scope = scope->parent;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x845a
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x844d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x8890
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x843d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8462
jmp 0x843f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x83f7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x83e8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: find_function_prototype
function_t *find_function_prototype(scope_t *root_scope, char *name) {

	arraylist_t *functions = root_scope->functions;
	function_t *prototype  = NULL;

	for(size_t j = 0 ; j < functions->size ; j++) {
		prototype = arraylist_get(functions, j);
		if(prototype->is_prototype && !strcmp(prototype->name, name)) {
			return prototype;
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x84f7
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8890
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x18(%rax), %eax
cmpl $0x0, %eax
je 0x84e7
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x84e7
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x84ff
jmp 0x84e9
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x849c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/scopetree.c
// Function: is_keyword
unsigned char is_keyword(char *name) {
	static const char *keywords[] = {
		"auto", "break", "case", "char", "const", "continue",
		"default", "do", "double", "else", "enum", "extern",
		"float", "for", "goto", "if", "inline", "int", "long",
		"register", "restrict", "return", "short", "signed",
		"static", "struct", "switch", "typedef", "union",
		"unsigned", "void", "volatile", "while",
		NULL
	};
	const char *word   = NULL;
	size_t index = 0;
	while((word = keywords[index++]) != NULL) {
		if(!strcmp(name, word))
			return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
leaq 0xfbfe(%rip), %rax      # 0x18140
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x856a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x8568
movb $0x1, -0x1(%rbp)
jmp 0x856e
jmp 0x852c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/arraylist.c
// Function: arraylist_init
arraylist_t *arraylist_init(unsigned int initial_capacity) {
	arraylist_t *list = malloc(sizeof(arraylist_t));
	
	if(list != NULL) {
		list->size = 0;
		list->capacity = initial_capacity;
		list->array = malloc(list->capacity * sizeof(void*));
		if(list->array == NULL) {
			free(list);
			list = NULL;
		} else {
			arraylist_set_null(list);
		}
	}
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x2110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x85fc
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movl -0x4(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x2110
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x85f1
movq -0x10(%rbp), %rdi
callq 0x2030
movq $0x0, -0x10(%rbp)
jmp 0x85fa
movq -0x10(%rbp), %rdi
callq 0x8610
jmp 0x85fc
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/arraylist.c
// Function: arraylist_copy
arraylist_t *arraylist_copy(arraylist_t *list) {
	arraylist_t *copy = malloc(sizeof(arraylist_t));

	if(copy != NULL) {
		copy->size = list->size; 
		copy->capacity = list->capacity;
		copy->array = malloc(copy->capacity * sizeof(void*));
		if(copy->array == NULL) {
			free(copy);
			copy = NULL;
		} else {
			for(size_t i = 0 ; i < list->capacity ; i++)
				copy->array[i] = list->array[i];
		}
	}
	return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x2110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8723
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x2110
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x86dd
movq -0x10(%rbp), %rdi
callq 0x2030
movq $0x0, -0x10(%rbp)
jmp 0x8721
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x871f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x86e5
jmp 0x8721
jmp 0x8723
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/arraylist.c
// Function: arraylist_remove
void *arraylist_remove(arraylist_t *list, size_t index) {
	void *value = arraylist_get(list, index);
	size_t num_moved;

	if(value == NULL) return NULL;

	num_moved = list->size - index;
	if(num_moved > 0) {
		for(size_t i = 1 ; i <= num_moved ; i++) {
			list->array[index + i - 1] = list->array[index + i];
		}
	}
	list->array[--(list->size)] = NULL;
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8890
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8905
movq $0x0, -0x8(%rbp)
jmp 0x8993
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x8968
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x8966
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
addq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
addq -0x30(%rbp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x8924
jmp 0x8968
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, 0x8(%rdx)
movq $0x0, -0x8(%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/arraylist.c
// Function: arraylist_index_of
size_t arraylist_index_of(arraylist_t *list, void *value) {
	for(size_t i = 0 ; i < list->size ; i++) {
		if(value == list->array[i]) {
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x89f1
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x89e1
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x89f9
jmp 0x89e3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x89b4
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/arraylist.c
// Function: arraylist_free
void arraylist_free(arraylist_t *list, unsigned char free_content) {
	if(free_content) {
		for(size_t i = 0 ; i < list->size ; i++) {
			if(list->array[i] != NULL)
				free(list->array[i]);
		}
	}
	free(list->array);
	free(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
cmpb $0x0, -0x9(%rbp)
je 0x8a66
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x8a64
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x8a54
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
jmp 0x8a56
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8a20
jmp 0x8a66
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_type.c
// Function: parse_type_word
static char parse_type_word(char *line, size_t length, unsigned int *i) {
	char c;
	unsigned int index  = *i;
	int type_word_start =  0;
	int type_word_end   =  0;
	char found          =  0;
	char *word;

	do {

		SKIP_WHITESPACES

		type_word_start = index;
		while((is_alphanumeric(c = line[index]) || c == '*') && index < length) {
			index++;
		}
		type_word_end = index;

		word = strsubstr(line, type_word_start, type_word_end - type_word_start);

		//Remove stars
		word[strlen(word) - strcountuntil(word, '*', 1, 1)] = '\0';
		if(!type_exists(word)) {
			free(word);
			index = type_word_start;
			break;
		} else found = 1;
		free(word);
	} while(c != ';');

	*i = index;
	return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
jmp 0x8ea1
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x8ed0
movl -0x20(%rbp), %eax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x8ed9
jmp 0x8ee4
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8ea1
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movsbl %al, %edi
callq 0xada0
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x8f15
movsbl -0x19(%rbp), %ecx
xorl %eax, %eax
cmpl $0x2a, %ecx
movb %al, -0x3a(%rbp)
jne 0x8f22
movl -0x20(%rbp), %eax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x8f2b
jmp 0x8f36
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8eea
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
subl -0x24(%rbp), %edx
callq 0xa5e0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2090
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
movl $0x2a, %esi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xa6d0
movq -0x50(%rbp), %rcx
movl %eax, %edx
movq -0x48(%rbp), %rax
movl %edx, %edx
subq %rdx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rdi
callq 0x8120
cmpb $0x0, %al
jne 0x8fad
movq -0x38(%rbp), %rdi
callq 0x2030
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x8fc7
movb $0x1, -0x29(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2030
movsbl -0x19(%rbp), %eax
cmpl $0x3b, %eax
jne 0x8e9f
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb -0x29(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_operations.c
// Function: starts_with_return
static unsigned char starts_with_return(char *line, int length) {
	char c;
	int index = 0;

	SKIP_WHITESPACES

	return strstr(line + index, "return") == line + index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xd(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x9cd5
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x9cde
jmp 0x9ce9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9ca6
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
leaq 0xab0f(%rip), %rsi      # 0x1480a
callq 0x2190
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_operations.c
// Function: is_operator_first
static unsigned char is_operator_first(char *line, int length, char *occurrence) {
	int index = 0;
	char c;

	SKIP_WHITESPACES

	return occurrence == line + index; 
}

// 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)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movsbl %al, %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1e(%rbp)
je 0x9d69
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
testb $0x1, %al
jne 0x9d72
jmp 0x9d7d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9d3a
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_operations.c
// Function: parse_declarations
static void parse_declarations(arraylist_t *declarations, scope_t *scope, int line_index, messages_t *messages) {
	field_t *declaration  = NULL;
	type_t declaration_type;

	for(size_t i = 0 ; i < declarations->size ; i++) {
		declaration = arraylist_get(declarations, i);
		if(declaration->value != NULL) {
			//TODO parse inline array ("int test[] = {length, 4};")
			declaration_type = parse_operation(declaration->value, line_index, scope, messages);
			if(!strcmp(declaration_type.name, "NULL")) {
				declaration_type = parse_expression(declaration->value, line_index, scope, messages);
			}
			if(messages->wrong_assignment != NULL && strcmp(declaration_type.name,"NULL") && !type_equals(&declaration->type, &declaration_type)) {
				add_wrong_type_message(messages->wrong_assignment, &declaration->type, &declaration_type);
			}
			free(declaration_type.name);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x9ed8
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x8890
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9ec5
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x8fe0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
leaq 0xaa6c(%rip), %rsi      # 0x148a0
callq 0x20f0
cmpl $0x0, %eax
jne 0x9e6e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x10120
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x9ebc
movq -0x38(%rbp), %rdi
leaq 0xaa1c(%rip), %rsi      # 0x148a0
callq 0x20f0
cmpl $0x0, %eax
je 0x9ebc
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
leaq -0x38(%rbp), %rsi
callq 0x8080
cmpb $0x0, %al
jne 0x9ebc
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
leaq -0x38(%rbp), %rdx
callq 0xa050
movq -0x38(%rbp), %rdi
callq 0x2030
jmp 0x9ec7
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x9dc7
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_operations.c
// Function: find_variable_type_from_line
static type_t find_variable_type_from_line(scope_t *scope, int line) {
	field_t *field = NULL;
	type_t type; //Default return;
	for(size_t i = 0 ; i < scope->variables->size ; i++) {
		field = arraylist_get(scope->variables, i);
		if(field->line == line) {
			return field->type;
		}
	}
	type.name = "NULL";
	return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x9f58
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x8890
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x9f48
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9f73
jmp 0x9f4a
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x9eff
leaq 0xa941(%rip), %rax      # 0x148a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_operations.c
// Function: parse_operand
static type_t parse_operand(char *operand, int line_index, scope_t *scope, messages_t *messages) {

	type_t type = parse_operation(operand, line_index, scope, messages);

	if(!strcmp(type.name, "NULL")) {
		free(type.name);
		type = parse_expression(operand, line_index, scope, messages);
	}

	return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x8fe0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa8d2(%rip), %rsi      # 0x148a0
callq 0x20f0
cmpl $0x0, %eax
jne 0xa00d
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x10120
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_operations.c
// Function: add_wrong_type_message
static void add_wrong_type_message(arraylist_t *messages, type_t *type_left, type_t *type_right) {
	wrong_type_t *assignment              = malloc(sizeof(wrong_type_t));
	assignment->expected_type             = malloc(sizeof(type_t));
	assignment->expected_type->name       = strduplicate(type_left->name);
	assignment->expected_type->is_pointer = type_left->is_pointer;
	assignment->actual_type               = malloc(sizeof(type_t));
	assignment->actual_type->name         = strduplicate(type_right->name);
	assignment->actual_type->is_pointer   = type_right->is_pointer;
	arraylist_add(messages, assignment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x10, %edi
callq 0x2110
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x2110
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xa550
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x20(%rbp), %rax
movq (%rax), %rax
movb %cl, 0x8(%rax)
movl $0x10, %edi
callq 0x2110
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xa550
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movb %cl, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8730
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_operations.c
// Function: get_highest_rank
static int get_highest_rank(char *type1, char *type2) {

	if(!strcmp(type1, "NULL") || !strcmp(type2, "NULL"))
		return -1;

	int rank1 = find_type_rank(type1);
	int rank2 = find_type_rank(type2);
	return rank1 > rank2 ? rank1 : rank2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa745(%rip), %rsi      # 0x148a0
callq 0x20f0
cmpl $0x0, %eax
je 0xa17a
movq -0x18(%rbp), %rdi
leaq 0xa730(%rip), %rsi      # 0x148a0
callq 0x20f0
cmpl $0x0, %eax
jne 0xa183
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa1b7
movq -0x10(%rbp), %rdi
callq 0xa230
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa230
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0xa1ab
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xa1b1
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_operations.c
// Function: is_operator_of_type
static unsigned char is_operator_of_type(const char *operator, const char **type) {
	int i = 0;
	const char *t = NULL;
	while((t = type[i]) != NULL) {
		if(!strcmp(type[i], operator))
			return 1;
		i++;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xa220
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0xa215
movb $0x1, -0x1(%rbp)
jmp 0xa224
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa1df
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_operations.c
// Function: find_type_rank
static int find_type_rank(char *type) {
	int i = 0;
	const char *t = NULL;
	while((t = type_rank[i]) != NULL) {
		if(!strcmp(type_rank[i], type))
			return i;
		i++;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xe0fa(%rip), %rax      # 0x18350
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xa294
movslq -0x14(%rbp), %rcx
leaq 0xe0e1(%rip), %rax      # 0x18350
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0xa289
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa29b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa24b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: strduplicate
char *strduplicate(char *str) {
	char *result = NULL;
	int len;

	if(str == NULL) return NULL;

	len = strlen(str);
	result = malloc((len + 1) * sizeof(char));

	if(result == NULL) return NULL;

	strcpy(result, str);
	result[len] = '\0';

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa575
movq $0x0, -0x8(%rbp)
jmp 0xa5c9
movq -0x10(%rbp), %rdi
callq 0x2090
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2110
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa5a8
movq $0x0, -0x8(%rbp)
jmp 0xa5c9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2060
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: strsubstr
char *strsubstr(char *str , int from, int count) {
	char *result;
	if(str == NULL) return NULL;

	result = malloc((count+1) * sizeof(char));

	if(result == NULL) return NULL;

	strncpy(result, str+from, count);
	result[count] = '\0';
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa603
movq $0x0, -0x8(%rbp)
jmp 0xa656
movl -0x18(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa62a
movq $0x0, -0x8(%rbp)
jmp 0xa656
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
movslq -0x18(%rbp), %rdx
callq 0x2050
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: strcount
unsigned int strcount(char *str, char chr) {

	unsigned int length = strlen(str);
	unsigned int count = 0;

	for(unsigned int i = 0 ; i < length ; i++) {
		if(str[i] == chr)
			count++;
	}
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2090
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0xa6bd
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0xa6b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa6b2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa68c
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: strcountuntil
unsigned int strcountuntil(char *str, char chr, char reverse, char ignore_whitespace) {

	unsigned int length = strlen(str);
	unsigned int count = 0;

	if(!reverse) {
		for(unsigned int i = 0 ; i < length ; i++) {
			if(str[i] == chr || (ignore_whitespace && is_whitespace(str[i])))
				count++;
			else
				break;
		}
	} else {
		for(int i = length - 1 ; i >= 0 ; i--) {
			if(str[i] == chr || (ignore_whitespace && is_whitespace(str[i])))
				count++;
			else
				break;
		}
	}
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
movb %dl, -0x9(%rbp)
movb %cl, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2090
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpb $0x0, -0xa(%rbp)
jne 0xa764
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0xa762
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0xa748
movsbl -0xb(%rbp), %eax
cmpl $0x0, %eax
je 0xa753
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %edi
callq 0xa7d0
movsbl %al, %eax
cmpl $0x0, %eax
je 0xa753
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa755
jmp 0xa762
jmp 0xa757
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa70c
jmp 0xa7c5
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xa7c3
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0xa7a9
movsbl -0xb(%rbp), %eax
cmpl $0x0, %eax
je 0xa7b4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa7d0
movsbl %al, %eax
cmpl $0x0, %eax
je 0xa7b4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa7b6
jmp 0xa7c3
jmp 0xa7b8
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa76d
jmp 0xa7c5
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: strcount_heading_line_breaks
unsigned int strcount_heading_line_breaks(char *str) {

	char *tmp = str_remove_comments(str);
	unsigned int length = strlen(tmp);
	unsigned int count = 0;

	for(unsigned int i = 0 ; i < length ; i++) {
		if(tmp[i] == '\n')
			count++;
		else if(!is_whitespace(tmp[i]))
			break;
	}
	free(tmp);
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa2b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xa8bb
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xa896
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa8ae
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsbl (%rax,%rcx), %edi
callq 0xa7d0
cmpb $0x0, %al
jne 0xa8ac
jmp 0xa8bb
jmp 0xa8ae
jmp 0xa8b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa873
movq -0x10(%rbp), %rdi
callq 0x2030
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: strindexof
int strindexof(char *str, char chr) {

	size_t length = strlen(str);

	for(size_t i = 0 ; i < length ; i++) {
		if(str[i] == chr)
			return (int)i;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xa92e
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xa91e
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0xa935
jmp 0xa920
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa8f7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: strlastindexof
int strlastindexof(char *str, char chr) {

	int length = strlen(str);

	for(unsigned int i = length-1 ; i > 0 ; i--) {
		if(str[i] == chr)
			return i;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0xa995
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xa988
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa99c
jmp 0xa98a
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa967
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: strconcat
char *strconcat(char *str1, char *str2) {
	char *result;
	unsigned int length = 0;

	if(str1 != NULL) length += strlen(str1);
	if(str2 != NULL) length += strlen(str2);

	result = malloc((length + 1) * sizeof(char));

	if(result != NULL) {

		result[0] = '\0';
		result[length - 1] = '\0';

		if(str1 != NULL) strcat(result, str1);
		if(str2 != NULL) strcat(result, str2);

	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa9e3
movq -0x8(%rbp), %rdi
callq 0x2090
movq %rax, %rcx
movl -0x1c(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa9ff
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, %rcx
movl -0x1c(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x2110
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xaa5e
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x8(%rbp)
je 0xaa48
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2150
cmpq $0x0, -0x10(%rbp)
je 0xaa5c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
jmp 0xaa5e
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/stringutils.c
// Function: strjoin
char *strjoin(char **strings, unsigned int count, char *join) {
	char *result;
	unsigned int length = 0;

	if(strings == NULL || join == NULL) return NULL;

	//Calculate length
	for(unsigned int i = 0 ; i < count ; i++)
		if(strings[i] != NULL)
			length += strlen(strings[i]);

	length += (count-1) * strlen(join); //Join characters

	result = malloc((length + 1) * sizeof(char));

	if(result != NULL) {

		result[0] = '\0';
		result[length - 1] = '\0';

		//Concat
		for(unsigned int i = 0 ; i < count ; i++) {
			strcat(result, strings[i]);
			if(i < count - 1)
				strcat(result, join);
		}
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xaa98
cmpq $0x0, -0x20(%rbp)
jne 0xaaa5
movq $0x0, -0x8(%rbp)
jmp 0xab9a
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xaaeb
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0xaade
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x2090
movq %rax, %rcx
movl -0x2c(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x2c(%rbp)
jmp 0xaae0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xaaac
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2090
movq -0x40(%rbp), %rcx
imulq %rax, %rcx
movl -0x2c(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x2110
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xab92
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xab90
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x2150
movl -0x34(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0xab83
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2150
jmp 0xab85
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xab4d
jmp 0xab92
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/stringutils.c
// Function: substr_match
char *substr_match(char *source, match_t match) {
	int length = match.index_end - match.index_start;
	char *substr = malloc((length + 1) * sizeof(char));

	if(substr != NULL) {
		strncpy(substr, source + match.index_start, length);
		substr[length] = '\0';
	}

	return substr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl -0x4(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xac69
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x8(%rbp), %eax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x2050
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)