LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: copy_element
static struct element* copy_element( struct element *source ) {
	struct element *elem = NULL, *prev = NULL, *head = NULL;
	while( source ) {
		elem = new_element( source->str.length );
		if( elem ) {
			elem->line = source->line;
			if( prev ) {
				prev->next = elem;
			}
			prev = elem;
			if( head == NULL ) {
				head = elem;
			}
			memcpy( elem->str.string, source->str.string, sizeof( char ) * elem->str.length );
			if( source->child ) {
				elem->child = copy_element( source->child );
				if( elem->child ) {
					source = source->next;
				} else {
					source = elem = NULL;
				}
			} else {
				source = source->next;
			}
		} else {
			source = NULL;
		}
	}
	if( elem == NULL && head ) {
		unref_string( &head->str );
		head = NULL;
	}
	return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xac0c
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x3780
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xabff
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xab6b
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xab82
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rdx
shlq $0x0, %rdx
callq 0x3170
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xabf1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xab00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xabdf
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xabef
movq $0x0, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0xabfd
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xac07
movq $0x0, -0x8(%rbp)
jmp 0xab24
cmpq $0x0, -0x10(%rbp)
jne 0xac2b
cmpq $0x0, -0x20(%rbp)
je 0xac2b
movq -0x20(%rbp), %rdi
callq 0x3c20
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_expressions
static struct element* parse_expressions( struct element *elem, struct function *func,
	struct variables *vars, char terminator, struct expression *prev, int *num_exprs, char *message ) {
	int line, count = 0;
	while( elem && elem->str.string[ 0 ] != terminator && message[ 0 ] == 0 ) {
		elem = parse_expression( elem, func, vars, prev, message );
		prev = prev->next;
		count++;
		while( elem && message[ 0 ] == 0 && elem->str.string[ 0 ] == ',' ) {
			line = elem->line;
			elem = elem->next;
			if( elem && elem->str.string[ 0 ] != ',' ) {
				elem = parse_expression( elem, func, vars, prev, message );
				prev = prev->next;
				count++;
			} else {
				sprintf( message, "Expected expression after ',' on line %d.", line );
			}
		}
	}
	if( num_exprs ) {
		*num_exprs = count;
	}
	return elem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq 0x10(%rbp), %rcx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x39(%rbp)
je 0xaca0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %ecx
movsbl -0x19(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x39(%rbp)
je 0xaca0
movq 0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xacac
jmp 0xad98
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x60c0
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x3a(%rbp)
je 0xad0f
movq 0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
jne 0xad0f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
sete %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0xad18
jmp 0xad93
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xad79
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0xad79
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x60c0
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xad8e
movq 0x10(%rbp), %rdi
movl -0x34(%rbp), %edx
leaq 0x10cfa(%rip), %rsi     # 0x1ba81
movb $0x0, %al
callq 0x31f0
jmp 0xacde
jmp 0xac6c
cmpq $0x0, -0x30(%rbp)
je 0xada8
movl -0x38(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: evaluate_refcall_expression
static enum result evaluate_refcall_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct function_expression expr = { 0 };
	struct variable func = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &func );
	if( ret ) {
		if( func.string_value && func.string_value->type == FUNCTION ) {
			expr.expr.line = this->line;
			expr.function = ( struct function * ) func.string_value;
			if( expr.function->num_parameters == this->index ) {
				expr.expr.parameters = parameter->next;
				ret = evaluate_call_expression( &expr.expr, vars, result );
			} else {
				ret = throw( vars, this, this->index, "Incorrect number of parameters to function." );
			}
		} else {
			ret = throw( vars, this, func.number_value, "Not a function reference." );
		}
		dispose_temporary( &func );
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x30f0
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq *%rax
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0xaefd
cmpq $0x0, -0x48(%rbp)
je 0xaeda
movq -0x48(%rbp), %rax
movsbl 0x14(%rax), %eax
cmpl $0x6, %eax
jne 0xaeda
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0xaeba
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9810
movl %eax, -0x5c(%rbp)
jmp 0xaed8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0x10cb2(%rip), %rcx     # 0x1bb82
callq 0x4330
movl %eax, -0x5c(%rbp)
jmp 0xaef4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x50(%rbp), %edx
leaq 0x10cc2(%rip), %rcx     # 0x1bbae
callq 0x4330
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3ce0
movl -0x5c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: field_end
static char* field_end( char *str, char *terminators ) {
	char mask = 0, *end = terminators;
	while( *end ) {
		mask |= *end++;
	}
	end = str;
	mask = ~mask;
	while( *end & mask || ( *end && !strchr( terminators, *end ) ) ) {
		end++;
	}
	return end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0xaf52
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %ecx
movsbl -0x11(%rbp), %eax
orl %ecx, %eax
movb %al, -0x11(%rbp)
jmp 0xaf2c
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x11(%rbp), %eax
xorl $-0x1, %eax
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movsbl -0x11(%rbp), %eax
andl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jne 0xafae
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
je 0xafa8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movsbl (%rax), %esi
callq 0x30d0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xafb7
jmp 0xafc5
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xaf64
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: get_string_list_index
static int get_string_list_index( struct string_list *list, char *value ) {
	int idx = 0;
	while( list && strcmp( list->str->string, value ) ) {
		idx++;
		list = list->next;
	}
	if( list == NULL ) {
		idx = -1;
	}
	return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x15(%rbp)
je 0xb010
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3130
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xb019
jmp 0xb030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xafe7
cmpq $0x0, -0x8(%rbp)
jne 0xb03e
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_member_expression
static struct element* parse_member_expression( struct structure *struc, struct expression *this,
	char *memb, struct element *elem, struct function *func, struct variables *vars, struct expression *prev, char *message ) {
	struct element *next = elem->next;
	struct expression *expr;
	int idx;
	if( struc ) {
		idx = get_string_list_index( struc->fields, memb );
		if( idx >= 0 ) {
			expr = calloc( 1, sizeof( struct value_expression ) );
			if( expr ) {
				prev->next = expr;
				( ( struct value_expression * ) expr )->str = &struc->str;
				expr->index = idx;
				expr->line = elem->line;
				expr->parameters = this;
				expr->evaluate = evaluate_member_expression;
			} else {
				strcpy( message, OUT_OF_MEMORY );
			}
		} else {
			sprintf( message, "Field not declared in expression '%.64s' on line %d.", elem->str.string, elem->line );
		}
	} else {
		sprintf( message, "Expression '%.64s' has no associated structure on line %d.", elem->str.string, elem->line );
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb354
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xafd0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jl 0xb331
movl $0x1, %edi
movl $0x30, %esi
callq 0x3120
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xb31f
movq -0x40(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x44(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
leaq 0x347(%rip), %rcx       # 0xb660
movq %rcx, 0x18(%rax)
jmp 0xb32f
movq 0x18(%rbp), %rdi
movq 0x15e36(%rip), %rsi     # 0x21160
callq 0x3070
jmp 0xb352
movq 0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x1091f(%rip), %rsi     # 0x1bc6a
movb $0x0, %al
callq 0x31f0
jmp 0xb375
movq 0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x10931(%rip), %rsi     # 0x1bc9f
movb $0x0, %al
callq 0x31f0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: evaluate_member_expression
static enum result evaluate_member_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct array *arr;
	struct variable obj = { 0, NULL };
	struct expression *parameter = this->parameters;
	struct structure *struc = ( struct structure * ) ( ( struct value_expression * ) this )->str;
	enum result ret = parameter->evaluate( parameter, vars, &obj );
	if( ret ) {
		ret = is_instance( &obj, struc, vars, this );
		if( ret ) {
			arr = ( struct array * ) obj.string_value;
			result->number_value = arr->number_values[ this->index ];
			if( arr->string_values && arr->string_values[ this->index ] ) {
				result->string_value = arr->string_values[ this->index ];
				result->string_value->reference_count++;
			}
		}
		dispose_temporary( &obj );
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xb759
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
leaq -0x30(%rbp), %rdi
callq 0x4f10
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xb750
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb74e
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xb74e
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xb750
leaq -0x30(%rbp), %rdi
callq 0x3ce0
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: get_decl
static struct string* get_decl( struct string_list *list, char *name, int len, enum reference_type type ) {
	while( list && ( list->str->length != len || strncmp( list->str->string, name, len ) ) ) {
		list = list->next;
	}
	if( list && ( !type || ( enum reference_type ) list->str->type == type ) ) {
		return list->str;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0xb82d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
movb $0x1, %al
cmpl -0x1c(%rbp), %ecx
movb %al, -0x22(%rbp)
jne 0xb827
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x3060
cmpl $0x0, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xb836
jmp 0xb844
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xb7e6
cmpq $0x0, -0x10(%rbp)
je 0xb86e
cmpl $0x0, -0x20(%rbp)
je 0xb861
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x14(%rax), %eax
cmpl -0x20(%rbp), %eax
jne 0xb86e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xb876
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_local_variable
static struct local_variable* new_local_variable( struct function *func, struct element *name, struct structure *type, char *message ) {
	struct local_variable *local = NULL;
	if( func->num_variables >= 128 ) {
		sprintf( message, "Too many local variables in function '%.64s' on line %d.", func->str.string, func->line );
	} else if( validate_local( &name->str, name->line, func->env, message ) ) {
		local = malloc( sizeof( struct local_variable ) + sizeof( char ) * ( name->str.length + 1 ) );
		if( local ) {
			local->index = func->num_variables;
			local->name = ( char * ) &local[ 1 ];
			strcpy( local->name, name->str.string );
			local->type = type;
			local->next = NULL;
		} else {
			strcpy( message, OUT_OF_MEMORY );
		}
	}
	return local;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x80, 0x20(%rax)
jl 0xb8d3
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
leaq 0x1053d(%rip), %rsi     # 0x1be04
movb $0x0, %al
callq 0x31f0
jmp 0xb97d
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0xb990
cmpl $0x0, %eax
je 0xb97b
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
addq $0x20, %rdi
callq 0x31a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xb969
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rcx
addq $0x20, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3070
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0xb979
movq -0x20(%rbp), %rdi
movq 0x157ec(%rip), %rsi     # 0x21160
callq 0x3070
jmp 0xb97b
jmp 0xb97d
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: validate_local
static int validate_local( struct string *decl, int line, struct environment *env, char *message ) {
	int hash = hash_code( decl->string, 0 );
	if( decl->length > 64 ) {
		sprintf( message, "Invalid name '%.64s' on line %d.", decl->string, line );
	} else if( get_keyword( decl->string, declarations )
	|| get_keyword( decl->string, env->statements_index[ hash ] )
	|| get_operator( decl->string, env->operators_index[ hash ] ) ) {
		sprintf( message, "Name '%.64s' already defined on line %d.", decl->string, line );
	} else {
		return hash + 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 %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x7960
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x40, 0x10(%rax)
jle 0xb9e5
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl -0x14(%rbp), %ecx
leaq 0x10464(%rip), %rsi     # 0x1be3d
movb $0x0, %al
callq 0x31f0
jmp 0xba71
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1577c(%rip), %rsi     # 0x21170
callq 0x9220
cmpq $0x0, %rax
jne 0xba45
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x80(%rax,%rcx,8), %rsi
callq 0x9220
cmpq $0x0, %rax
jne 0xba45
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x180(%rax,%rcx,8), %rsi
callq 0x7900
cmpq $0x0, %rax
je 0xba64
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl -0x14(%rbp), %ecx
leaq 0x10403(%rip), %rsi     # 0x1be5e
movb $0x0, %al
callq 0x31f0
jmp 0xba6f
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xba78
jmp 0xba71
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_string
static int parse_string( char *input, int idx, char *output, int line, char *message ) {
	int offset = idx;
	char chr = input[ idx++ ];
	if( chr == '"' ) {
		while( ( chr & 0x7F ) >= 32 ) {
			chr = input[ idx++ ];
			if( chr == '\\' ) {
				chr = input[ idx++ ];
			} else if( chr == '"' ) {
				break;
			}
		}
		if( chr == '"' ) {
			if( output ) {
				memcpy( output, &input[ offset ], sizeof( char ) * ( idx - offset ) );
			}
		} else {
			sprintf( message, "Unclosed string on line %d.", line );
			idx = -3;
		}
	} else {
		sprintf( message, "Expected '\"' on line %d.", line );
		idx = -3;
	}
	return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x2d(%rbp)
movsbl -0x2d(%rbp), %eax
cmpl $0x22, %eax
jne 0xbfae
jmp 0xbf07
movsbl -0x2d(%rbp), %eax
andl $0x7f, %eax
cmpl $0x20, %eax
jl 0xbf5d
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x2d(%rbp)
movsbl -0x2d(%rbp), %eax
cmpl $0x5c, %eax
jne 0xbf4e
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x2d(%rbp)
jmp 0xbf5b
movsbl -0x2d(%rbp), %eax
cmpl $0x22, %eax
jne 0xbf59
jmp 0xbf5d
jmp 0xbf5b
jmp 0xbf07
movsbl -0x2d(%rbp), %eax
cmpl $0x22, %eax
jne 0xbf90
cmpq $0x0, -0x18(%rbp)
je 0xbf8e
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
movl -0xc(%rbp), %eax
subl -0x2c(%rbp), %eax
movslq %eax, %rdx
shlq $0x0, %rdx
callq 0x3170
jmp 0xbfac
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0xffb4(%rip), %rsi      # 0x1bf52
movb $0x0, %al
callq 0x31f0
movl $0xfffffffd, -0xc(%rbp) # imm = 0xFFFFFFFD
jmp 0xbfca
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0xffb2(%rip), %rsi      # 0x1bf6e
movb $0x0, %al
callq 0x31f0
movl $0xfffffffd, -0xc(%rbp) # imm = 0xFFFFFFFD
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_import
static struct element* parse_import( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next, *name = next;
	struct string *library = get_decl_indexed( func, name->str.string, name->str.length, LIBRARY );
	if( library ) {
		next = next->next->next->next->next;
	} else {
		next = parse_include( next->next, func, vars, prev, message );
		library = get_decl_indexed( func, name->str.string, name->str.length, LIBRARY );
	}
	if( message[ 0 ] == 0 ) {
		if( library ) {
			import_library( library, func->file, message );
		} else {
			sprintf( message, "Library '%.32s' not found in file %.64s on line %d.\n", name->str.string, name->next->next->str.string, elem->line );
		}
	}
	return next;
}

// 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 %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x38(%rbp), %rax
movl 0x10(%rax), %edx
movl $0x7, %ecx
callq 0xb770
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xc052
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xc094
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xc100
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x38(%rbp), %rax
movl 0x10(%rax), %edx
movl $0x7, %ecx
callq 0xb770
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xc0f2
cmpq $0x0, -0x40(%rbp)
je 0xc0be
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0xc610
jmp 0xc0f0
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %r8d
leaq 0xfec5(%rip), %rsi      # 0x1bfae
movb $0x0, %al
callq 0x31f0
jmp 0xc0f2
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_program_declaration
static struct element* parse_program_declaration( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct environment *env = func->env;
	struct element *next = elem->next;
	struct function *prog = new_function( next->str.string, NULL );
	if( prog ) {
		prog->line = elem->line;
		prog->file = func->file;
		prog->file->reference_count++;
		if( func->library ) {
			prog->library = func->library;
			prog->library->reference_count++;
		}
		prog->body = next->next;
		prog->env = env;
		if( add_decl( &prog->str, next->line, env, message ) ) {
			env->entry_point = prog;
			next = next->next->next;
		}
		unref_string( &prog->str );
	}
	return next;
}

// 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 %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x94a0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xc603
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xc5a1
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x4720
cmpq $0x0, %rax
je 0xc5fa
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x398(%rax)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3c20
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: import_library
static int import_library( struct string *library, struct string *source, char *message ) {
	struct string_list *imports;
	if( source->type == SOURCE ) {
		imports = ( ( struct source * ) source )->imports;
		while( imports ) {
			if( imports->str == library ) {
				return 1;
			}
			imports = imports->next;
		}
		imports = new_string_list( library, ( ( struct source * ) source )->imports );
		if( imports ) {
			( ( struct source * ) source )->imports = imports;
		} else {
			strcpy( message, OUT_OF_MEMORY );
			return 0;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x14(%rax), %eax
cmpl $0x8, %eax
jne 0xc6ad
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc668
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xc65a
movl $0x1, -0x4(%rbp)
jmp 0xc6b4
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc63d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x4850
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc692
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xc6ab
movq -0x20(%rbp), %rdi
movq 0x14ac3(%rip), %rsi     # 0x21160
callq 0x3070
movl $0x0, -0x4(%rbp)
jmp 0xc6b4
jmp 0xc6ad
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: str_idx
static int str_idx( char *str, char *chars, int idx ) {
	char *chr, *end;
	if( idx < 0 ) {
		chr = end = field_end( str, chars );
		while( *end ) {
			chr = end;
			end = field_end( end + 1, chars );
		}
	} else {
		chr = field_end( str + idx, chars );
	}
	if( *chr ) {
		return chr - str;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xc718
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaf10
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0xc716
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
callq 0xaf10
movq %rax, -0x30(%rbp)
jmp 0xc6ee
jmp 0xc730
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xaf10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0xc749
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0xc750
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_function_declaration
static struct element* parse_function_declaration( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next;
	struct function *decl = parse_function( next->next, next->str.string, func, message );
	if( decl ) {
		if( add_decl( &decl->str, next->line, func->env, message ) ) {
			next = next->next->next->next;
		}
		unref_string( &decl->str );
	}
	return next;
}

// 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 %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x9280
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xc7ef
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0x4720
cmpq $0x0, %rax
je 0xc7e6
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3c20
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: add_structure_field
static int add_structure_field( struct structure *struc, struct element *elem, char *message ) {
	struct string *field;
	if( validate_name( elem, message ) ) {
		if( struc->fields && get_string_list_index( struc->fields, elem->str.string ) >= 0 ) {
			sprintf( message, "Field '%.64s' already defined on line %d.", elem->str.string, elem->line );
		} else {
			field = new_string_value( elem->str.string );
			if( field ) {
				if( append_string_list( &struc->fields, &struc->fields_tail, field ) ) {
					struc->length++;
				} else {
					strcpy( message, OUT_OF_MEMORY );
				}
				unref_string( field );
			} else {
				strcpy( message, OUT_OF_MEMORY );
			}
		}
	}
	return message[ 0 ] == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8f40
cmpl $0x0, %eax
je 0xcd47
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xccd2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xafd0
cmpl $0x0, %eax
jl 0xccd2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0xf3bf(%rip), %rsi      # 0x1c088
movb $0x0, %al
callq 0x31f0
jmp 0xcd45
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3a30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcd33
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
movq -0x20(%rbp), %rdx
callq 0xa7f0
cmpq $0x0, %rax
je 0xcd18
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0xcd28
movq -0x18(%rbp), %rdi
movq 0x1443d(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x20(%rbp), %rdi
callq 0x3c20
jmp 0xcd43
movq -0x18(%rbp), %rdi
movq 0x14422(%rip), %rsi     # 0x21160
callq 0x3070
jmp 0xcd45
jmp 0xcd47
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: add_global_constant
static int add_global_constant( struct element *elem,
	struct function *func, struct structure *type, struct expression *initializer,
	struct statement *prev, char *message ) {
	struct global_variable *global = new_global_variable( elem->str.string, type, func, initializer, message );
	if( global ) {
		if( add_global( global, elem->line, func->env, message ) ) {
			global->str.type = CONST;
		}
		unref_string( &global->str );
	}
	return message[ 0 ] == 0;
}

// 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x49c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xd10b
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x30(%rbp), %rcx
callq 0x4ae0
cmpq $0x0, %rax
je 0xd102
movq -0x38(%rbp), %rax
movb $0x5, 0x14(%rax)
movq -0x38(%rbp), %rdi
callq 0x3c20
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: expr_set_line
static void expr_set_line( struct expression *expr, int line ) {
	while( expr ) {
		expr->line = line;
		expr_set_line( expr->parameters, line );
		expr = expr->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd4fd
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xd4c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xd4cf
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_buffer
static struct array* new_buffer( int length ) {
	struct array *arr = calloc( 1, sizeof( struct array ) + sizeof( number ) * length );
	if( arr ) {
		arr->number_values = ( number * ) &arr[ 1 ];
		arr->str.string = "[Buffer]";
		arr->str.length = 8;
		arr->str.reference_count = 1;
		arr->str.type = ARRAY;
		arr->length = length;
	}
	return arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
shlq $0x2, %rsi
addq $0x48, %rsi
movl $0x1, %edi
callq 0x3120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd583
movq -0x10(%rbp), %rcx
addq $0x48, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0xeb90(%rip), %rcx      # 0x1c0e7
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x8, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x1, (%rax)
movq -0x10(%rbp), %rax
movb $0x2, 0x14(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: add_global_variable
static int add_global_variable( struct element *elem,
	struct function *func, struct structure *type, struct expression *initializer,
	struct statement *prev, char *message ) {
	struct global_variable *global = new_global_variable( elem->str.string, type, func, initializer, message );
	if( global ) {
		add_global( global, elem->line, func->env, message );
		unref_string( &global->str );
	}
	return message[ 0 ] == 0;
}

// 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x49c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xd5fd
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x30(%rbp), %rcx
callq 0x4ae0
movq -0x38(%rbp), %rdi
callq 0x3c20
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_break_statement
static struct element* parse_break_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		stmt->execute = execute_break_statement;
		prev->next = stmt;
		next = next->next;
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// 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 %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x3120
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xdaab
movq -0x38(%rbp), %rax
leaq 0x1e83(%rip), %rcx      # 0xf910
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xdabb
movq -0x28(%rbp), %rdi
movq 0x136aa(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_continue_statement
static struct element* parse_continue_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		stmt->execute = execute_continue_statement;
		prev->next = stmt;
		next = next->next;
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// 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 %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x3120
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xdb3b
movq -0x38(%rbp), %rax
leaq 0x1e13(%rip), %rcx      # 0xf930
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xdb4b
movq -0x28(%rbp), %rdi
movq 0x1361a(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_until_statement
static struct element* parse_until_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = parse_while_statement( elem, func, vars, prev, message );
	if( message[ 0 ] == 0 ) {
		prev->next->execute = execute_until_statement;
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xdf30
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xe208
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
leaq 0x218c(%rip), %rcx      # 0x10390
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_increment_statement
static struct element* parse_increment_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct local_variable *local;
	struct element *next = elem->next;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		prev->next = stmt;
		local = get_local_variable( func->variable_decls, next->str.string, "" );
		if( local ) {
			stmt->source = calloc( 1, sizeof( struct expression ) );
			if( stmt->source ) {
				stmt->local = local->index;
				stmt->source->line = next->line;
				stmt->execute = execute_increment_statement;
				next = next->next->next;
			} else {
				strcpy( message, OUT_OF_MEMORY );
			}
		} else {
			sprintf( message, "Undeclared local variable '%.64s' on line %d.", next->str.string, next->line );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// 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 %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x3120
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xe7d1
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xc92d(%rip), %rdx      # 0x1b056
callq 0x74c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xe7ae
movl $0x1, %edi
movl $0x20, %esi
callq 0x3120
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe79c
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
leaq -0x8ed6(%rip), %rcx     # 0x58b0
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xe7ac
movq -0x28(%rbp), %rdi
movq 0x129b9(%rip), %rsi     # 0x21160
callq 0x3070
jmp 0xe7cf
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x38(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0xdb34(%rip), %rsi      # 0x1c2fc
movb $0x0, %al
callq 0x31f0
jmp 0xe7e1
movq -0x28(%rbp), %rdi
movq 0x12984(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_append_statement
static struct element* parse_append_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = parse_save_statement( elem, func, vars, prev, message );
	if( prev->next && message[ 0 ] == 0 ) {
		prev->next->local = 1;
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xe920
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xe9ce
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xe9ce
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl $0x1, (%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)