LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_element
enum result evaluate_element( struct expression *expr, struct variables *vars, struct variable *result, int allow_null ) {
	enum result ret = expr->evaluate( expr, vars, result );
	if( ret ) {
		if( result->string_value ) {
			if( result->string_value->type == ELEMENT ) {
				return ret;
			}
		} else if( allow_null && !result->number_value ) {
			return ret;
		}
		ret = throw( vars, expr, 0, "Not an element." );
		dispose_variable( result );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq *0x18(%rdi)
testl %eax, %eax
je 0x44d7
movl %eax, %ebp
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x44db
cmpb $0x1, 0x14(%rax)
jne 0x44e5
jmp 0x4517
xorl %ebp, %ebp
jmp 0x4517
testl %r12d, %r12d
je 0x44e5
cmpl $0x0, (%rbx)
je 0x4517
leaq 0xdccb(%rip), %rcx      # 0x121b7
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3cc3
movl $0x0, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4517
callq 0x3979
movq $0x0, 0x8(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: to_int
enum result to_int( struct variable *var, int *result, struct variables *vars, struct expression *source ) {
	number value;
	enum result ret;
	if( var->string_value ) {
		if( var->string_value->type == CUSTOM && ( ( struct custom * ) var->string_value )->type->to_num ) {
			ret = ( ( struct custom * ) var->string_value )->type->to_num( var, &value, vars, source );
		} else {
			ret = throw( vars, source, 0, "Not a number." );
		}
		if( ret ) {
			*result = ( long_int ) value;
		}
		return ret;
	}
	*result = ( long_int ) var->number_value;
	return OKAY;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4573
cmpb $0x9, 0x14(%rax)
jne 0x454f
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x454f
leaq 0x4(%rsp), %rsi
callq *%rax
movl %eax, %ebp
jmp 0x4568
leaq 0xdc1c(%rip), %rax      # 0x12172
xorl %ebp, %ebp
movq %rdx, %rdi
movq %rcx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3cc3
testl %ebp, %ebp
je 0x457c
leaq 0x4(%rsp), %rdi
jmp 0x4578
movl $0x1, %ebp
movl (%rdi), %eax
movl %eax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: to_num
enum result to_num( struct variable *var, number *result, struct variables *vars, struct expression *source ) {
	if( var->string_value ) {
		if( var->string_value->type == CUSTOM && ( ( struct custom * ) var->string_value )->type->to_num ) {
			return ( ( struct custom * ) var->string_value )->type->to_num( var, result, vars, source );
		} else {
			return throw( vars, source, 0, "Not a number." );
		}
	}
	*result = var->number_value;
	return OKAY;
}

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x45c0
cmpb $0x9, 0x14(%rax)
jne 0x45a5
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x45a5
popq %rbx
jmpq *%rax
leaq 0xdbc6(%rip), %rax      # 0x12172
xorl %ebx, %ebx
movq %rdx, %rdi
movq %rcx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3cc3
jmp 0x45c9
movl (%rdi), %eax
movl %eax, (%rsi)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: assign_array_variable
enum result assign_array_variable( struct variable *src, struct array *arr, int idx, struct variables *vars, struct expression *source ) {
	struct string *str;
	if( arr->string_values ) {
		arr->number_values[ idx ] = src->number_value;
		str = arr->string_values[ idx ];
		if( str ) {
			unref_string( str );
		}
		str = src->string_value;
		arr->string_values[ idx ] = str;
		if( str ) {
			str->reference_count++;
		}
		return OKAY;
	}
	return to_num( src, &arr->number_values[ idx ], vars, source );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x461c
movl (%r14), %ecx
movq 0x18(%rbx), %rsi
movslq %edx, %r15
movl %ecx, (%rsi,%r15,4)
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x45fd
callq 0x3979
movq 0x8(%r14), %rax
movq 0x20(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
testq %rax, %rax
je 0x4611
incq (%rax)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movslq %edx, %rsi
shlq $0x2, %rsi
addq 0x18(%rbx), %rsi
movq %r14, %rdi
movq %rcx, %rdx
movq %r8, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x4585
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_number
enum result evaluate_number( struct expression *expr, struct variables *vars, number *result ) {
	enum result ret;
	struct variable var, *local;
	if( expr->evaluate == evaluate_number_literal_expression ) {
		*result = ( ( struct value_expression * ) expr )->num;
		return OKAY;
	} else if( expr->evaluate == evaluate_local ) {
		local = &vars->locals[ expr->index ];
		if( local->string_value ) {
			return to_num( local, result, vars, expr );
		}
		*result = local->number_value;
		return OKAY;
	}
	var.number_value = 0;
	var.string_value = NULL;
	ret = expr->evaluate( expr, vars, &var );
	if( ret ) {
		if( var.string_value ) {
			ret = to_num( &var, result, vars, expr );
			dispose_temporary( &var );
		} else {
			*result = var.number_value;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
leaq -0xb8d(%rip), %rcx      # 0x3aca
cmpq %rcx, %rax
je 0x46b7
movq %rsi, %r15
leaq -0x459(%rip), %rcx      # 0x420d
cmpq %rcx, %rax
je 0x46c4
movq %rsp, %rdx
movl $0x0, (%rdx)
movq $0x0, 0x8(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
je 0x46f6
cmpq $0x0, 0x8(%rsp)
je 0x46fa
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4585
movl %eax, %ebp
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x4701
callq 0x3979
jmp 0x4701
movl 0x28(%r14), %eax
movl %eax, (%rbx)
movl $0x1, %ebp
jmp 0x4701
movq 0x10(%r15), %rax
movslq 0x4(%r14), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
cmpq $0x0, 0x8(%rax,%rcx)
je 0x4710
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4585
xorl %ebp, %ebp
jmp 0x4701
movl %eax, %ebp
movl (%rsp), %eax
movl %eax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl (%rdi), %eax
jmp 0x46bb
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_integer
enum result evaluate_integer( struct expression *expr, struct variables *vars, int *result ) {
	enum result ret;
	struct variable var, *local;
	if( expr->evaluate == evaluate_number_literal_expression ) {
		*result = expr->index;
		return OKAY;
	} else if( expr->evaluate == evaluate_local ) {
		local = &vars->locals[ expr->index ];
		if( local->string_value ) {
			return to_int( local, result, vars, expr );
		}
		*result = ( long_int ) local->number_value;
		return OKAY;
	}
	var.number_value = 0;
	var.string_value = NULL;
	ret = expr->evaluate( expr, vars, &var );
	if( ret ) {
		if( var.string_value ) {
			ret = to_int( &var, result, vars, expr );
			dispose_temporary( &var );
		} else {
			*result = ( long_int ) var.number_value;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
leaq -0xc67(%rip), %rcx      # 0x3aca
cmpq %rcx, %rax
je 0x4791
movq %rsi, %r15
leaq -0x533(%rip), %rcx      # 0x420d
cmpq %rcx, %rax
je 0x479e
movq %rsp, %rdx
movl $0x0, (%rdx)
movq $0x0, 0x8(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
je 0x47d0
cmpq $0x0, 0x8(%rsp)
je 0x47d4
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4522
movl %eax, %ebp
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x47db
callq 0x3979
jmp 0x47db
movl 0x4(%r14), %eax
movl %eax, (%rbx)
movl $0x1, %ebp
jmp 0x47db
movq 0x10(%r15), %rax
movslq 0x4(%r14), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
cmpq $0x0, 0x8(%rax,%rcx)
je 0x47ea
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4522
xorl %ebp, %ebp
jmp 0x47db
movl %eax, %ebp
movl (%rsp), %eax
movl %eax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl (%rdi), %eax
jmp 0x4795
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_custom
enum result evaluate_custom( struct expression *expr, struct custom_type *type, struct variables *vars, struct variable *result ) {
	char msg[ 128 ];
	enum result ret = expr->evaluate( expr, vars, result );
	if( ret ) {
		if( is_custom_instance( result->string_value, type ) ) {
			return ret;
		}
		sprintf( msg, "Not an instance of '%.64s'.", type->name );
		ret = throw( vars, expr, 0, msg );
		dispose_variable( result );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rsi
movq %rcx, %rdx
callq *0x18(%rdi)
testl %eax, %eax
je 0x488c
movl %eax, %ebp
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x4844
cmpb $0x9, 0x14(%rax)
jne 0x4844
cmpq %r12, 0x18(%rax)
je 0x488e
movq (%r12), %rdx
leaq 0xd93e(%rip), %rsi      # 0x1218d
xorl %ebp, %ebp
movq %rsp, %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x3200
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x3cc3
movl $0x0, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x488e
callq 0x3979
movq $0x0, 0x8(%rbx)
jmp 0x488e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: execute_increment_statement
enum result execute_increment_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable *local = &vars->locals[ this->local ];
	if( local->string_value ) {
		return throw( vars, this->source, 0, "Not a number." );
	}
	local->number_value++;
	return OKAY;
}

// Assembly:
pushq %rbx
movq 0x10(%rsi), %rax
movslq (%rdi), %rcx
shlq $0x4, %rcx
cmpq $0x0, 0x8(%rax,%rcx)
je 0x4a52
movq 0x8(%rdi), %rax
leaq 0xd731(%rip), %rcx      # 0x12172
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3cc3
jmp 0x4a5c
addq %rcx, %rax
incl (%rax)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_index_expression
enum result evaluate_index_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	int idx;
	struct array *arr;
	enum result ret = OKAY;
	struct expression *parameter = this->parameters;
	struct variable src = { 0, NULL };
	if( parameter->evaluate == evaluate_local ) {
		arr = ( struct array * ) vars->locals[ parameter->index ].string_value;
	} else {
		ret = parameter->evaluate( parameter, vars, &src );
		arr = ( struct array * ) src.string_value;
	}
	if( ret ) {
		if( arr && arr->str.type == ARRAY ) {
			ret = evaluate_integer( parameter->next, vars, &idx );
			if( ret ) {
				if( ( unsigned int ) idx < ( unsigned int ) arr->length ) {
					result->number_value = arr->number_values[ idx ];
					if( arr->string_values && arr->string_values[ idx ] ) {
						result->string_value = arr->string_values[ idx ];
						result->string_value->reference_count++;
					}
				} else {
					ret = throw( vars, this, idx, "Array index out of bounds." );
				}
			}
		} else {
			ret = throw( vars, this, 0, "Not an array." );
		}
		dispose_temporary( &src );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x18(%r12), %rax
leaq -0x8c0(%rip), %rcx      # 0x420d
cmpq %rcx, %rax
je 0x4aed
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *%rax
movq 0x8(%r13), %r13
testl %eax, %eax
sete %al
jmp 0x4b01
movq 0x10(%r15), %rax
movslq 0x4(%r12), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %r13
xorl %eax, %eax
xorl %ebp, %ebp
testb %al, %al
jne 0x4b99
testq %r13, %r13
je 0x4b5e
cmpb $0x2, 0x14(%r13)
jne 0x4b5e
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x4714
testl %eax, %eax
je 0x4b88
movslq 0xc(%rsp), %rdx
cmpl 0x40(%r13), %edx
jae 0x4b76
movl %eax, %ebp
movq 0x18(%r13), %rax
movl (%rax,%rdx,4), %eax
movl %eax, (%rbx)
movq 0x20(%r13), %rax
testq %rax, %rax
je 0x4b8a
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je 0x4b8a
movq %rax, 0x8(%rbx)
incq (%rax)
jmp 0x4b8a
leaq 0xd67d(%rip), %rcx      # 0x121e2
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3cc3
jmp 0x4b8a
leaq 0xd64a(%rip), %rcx      # 0x121c7
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cc3
xorl %ebp, %ebp
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4b99
callq 0x3979
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_number
int parse_number( char *str, number *result ) {
	char *end;
	number value;
#if defined( FLOATING_POINT )
	if( str[ 0 ] != '0' || str[ 1 ] == '.' ) {
		errno = 0;
		value = strtod( str, &end );
		if( !( *end || errno ) ) {
			*result = value;
			return 1;
		}
	}
#endif
	errno = 0;
	value = strtoul( str, &end, 0 );
	if( !( *end || errno ) ) {
		*result = value;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3040
movq %rax, %r14
movl $0x0, (%rax)
leaq 0x8(%rsp), %r12
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x31e0
movq (%r12), %rcx
cmpb $0x0, (%rcx)
jne 0x4dc7
cmpl $0x0, (%r14)
jne 0x4dc7
movl %eax, (%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_chr_expression
enum result evaluate_chr_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable src = { 0, NULL };
	enum result ret = OKAY;
	int idx;
	struct string *str;
	if( parameter->evaluate == evaluate_local ) {
		str = vars->locals[ parameter->index ].string_value;
	} else {
		ret = evaluate_string( parameter, vars, &src );
		str = src.string_value;
	}
	if( str ) {
		ret = evaluate_integer( parameter->next, vars, &idx );
		if( ret ) {
			if( ( unsigned int ) idx < ( unsigned int ) str->length ) {
				result->number_value = ( signed char ) str->string[ idx ];
			} else {
				ret = throw( vars, this, idx, "String index out of bounds." );
			}
		}
		dispose_temporary( &src );
	} else if( ret == OKAY ) {
		ret = evaluate_string( parameter, vars, &src );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
leaq -0xbf3(%rip), %rax      # 0x420d
cmpq %rax, 0x18(%r12)
je 0x4e20
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x445f
movl %eax, %ebp
leaq 0x18(%rsp), %rax
jmp 0x4e39
movq 0x10(%rbx), %rax
movslq 0x4(%r12), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x8, %rax
movl $0x1, %ebp
movq (%rax), %r13
testq %r13, %r13
je 0x4e73
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %rbx, %rsi
callq 0x4714
xorl %ebp, %ebp
testl %eax, %eax
je 0x4e9e
movslq 0xc(%rsp), %rdx
cmpl 0x10(%r13), %edx
jae 0x4e8c
movq 0x8(%r13), %rcx
movsbl (%rcx,%rdx), %ecx
movl %ecx, (%r14)
movl %eax, %ebp
jmp 0x4e9e
cmpl $0x1, %ebp
jne 0x4ead
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x445f
movl %eax, %ebp
jmp 0x4ead
leaq 0xd3ac(%rip), %rcx      # 0x1223f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3cc3
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4ead
callq 0x3979
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_unpack_expression
enum result evaluate_unpack_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable str = { 0, NULL };
	int idx;
	enum result ret = evaluate_string( parameter, vars, &str );
	if( ret ) {
		ret = evaluate_integer( parameter->next, vars, &idx );
		if( ret ) {
			if( idx >= 0 && idx * 4 < str.string_value->length - 3 ) {
				result->number_value = unpack( str.string_value->string, idx );
			} else {
				ret = throw( vars, this, idx, "String index out of bounds." );
			}
		}
		dispose_temporary( &str );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq %r12, %rdi
callq 0x445f
testl %eax, %eax
je 0x4f67
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x4714
xorl %ebp, %ebp
testl %eax, %eax
je 0x4f7d
movl 0xc(%rsp), %edx
testl %edx, %edx
js 0x4f6b
leal (,%rdx,4), %ecx
movq 0x18(%rsp), %rsi
movl 0x10(%rsi), %edi
addl $-0x3, %edi
cmpl %edi, %ecx
jge 0x4f6b
movq 0x8(%rsi), %rdx
movl %ecx, %ecx
movl (%rdx,%rcx), %ecx
bswapl %ecx
movl %ecx, (%rbx)
movl %eax, %ebp
jmp 0x4f7d
xorl %ebp, %ebp
jmp 0x4f8c
leaq 0xd2cd(%rip), %rcx      # 0x1223f
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cc3
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4f8c
callq 0x3979
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_character_literal_expression
static struct element* parse_character_literal_expression( struct element *elem, struct expression *prev, char *message ) {
	struct value_expression *expr = calloc( 1, sizeof( struct value_expression ) );
	char *str = elem->str.string, out[ 8 ], quote = str[ 0 ];
	int len = elem->str.length;
	if( expr ) {
		prev->next = &expr->expr;
		expr->expr.line = elem->line;
		if( len > 0 && len < 7 && str[ len - 1 ] == quote && unquote_string( str, out, quote ) == 1 ) {
			expr->num = out[ 0 ];
			expr->expr.index = out[ 0 ];
			expr->expr.evaluate = evaluate_number_literal_expression;
		} else {
			sprintf( message, "Invalid character literal '%.64s' on line %d.", elem->str.string, elem->line );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return elem->next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movl $0x1, %edi
movl $0x30, %esi
callq 0x3130
testq %rax, %rax
je 0x579e
movq %rax, %r15
movq 0x8(%rbx), %r12
movb (%r12), %al
movl 0x10(%rbx), %ecx
movq %r15, 0x10(%r13)
movl 0x28(%rbx), %ebp
movl %ebp, (%r15)
leal -0x1(%rcx), %edx
cmpl $0x5, %edx
ja 0x5786
cmpb %al, -0x1(%r12,%rcx)
jne 0x5786
movsbl %al, %edx
movq %rsp, %rsi
movq %r12, %rdi
callq 0x80dc
cmpl $0x1, %eax
jne 0x5786
movsbl (%rsp), %eax
movl %eax, 0x28(%r15)
movl %eax, 0x4(%r15)
leaq -0x1cb6(%rip), %rax     # 0x3aca
movq %rax, 0x18(%r15)
jmp 0x57ad
leaq 0xcdd5(%rip), %rsi      # 0x12562
movq %r14, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3200
jmp 0x57ad
movq 0x139cb(%rip), %rsi     # 0x19170
movq %r14, %rdi
callq 0x3070
movq 0x20(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_call_expression
static struct element* parse_call_expression( struct element *elem,
	struct function *func, struct variables *vars, struct function *decl, struct expression *prev, char *message ) {
	int num_params;
	struct element *next = elem->next;
	struct expression param = { 0 }, *expr = calloc( 1, sizeof( struct function_expression ) );
	if( expr ) {
		prev->next = expr;
		expr->line = elem->line;
		( ( struct function_expression * ) expr )->function = decl;
		if( next && next->str.string[ 0 ] == '(' ) {
			parse_expressions( next->child, func, vars, 0, &param, &num_params, message );
			expr->parameters = param.next;
			if( message[ 0 ] == 0 ) {
				if( num_params == ( ( struct function_expression * ) expr )->function->num_parameters ) {
					expr->evaluate = evaluate_call_expression;
					next = next->next;
				} else {
					sprintf( message, "Wrong number of arguments to '%.64s()' on line %d.", elem->str.string, next->line );
				}
			}
		} else {
			sprintf( message, "Expected '(' after function name on line %d.", elem->line );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r14
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq 0x20(%rdi), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x3130
testq %rax, %rax
je 0x5894
movq %rax, %r12
movq %rax, 0x10(%rbp)
movl 0x28(%r15), %edx
movl %edx, (%rax)
movq %r13, 0x20(%rax)
testq %rbx, %rbx
je 0x5881
movq 0x8(%rbx), %rax
cmpb $0x28, (%rax)
jne 0x5881
movq 0x18(%rbx), %rdi
movq %r14, (%rsp)
leaq 0x20(%rsp), %r13
leaq 0xc(%rsp), %r9
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
xorl %ecx, %ecx
movq %r13, %r8
callq 0x8314
movq 0x10(%r13), %rax
movq %rax, 0x8(%r12)
cmpb $0x0, (%r14)
jne 0x58a3
movl 0xc(%rsp), %eax
movq 0x20(%r12), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x58b5
leaq 0x1ca3(%rip), %rax      # 0x7519
movq %rax, 0x18(%r12)
movq 0x20(%rbx), %rbx
jmp 0x58a3
leaq 0xcdb4(%rip), %rsi      # 0x1263c
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x58a3
movq 0x138d5(%rip), %rsi     # 0x19170
movq %r14, %rdi
callq 0x3070
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %rdx
movl 0x28(%rbx), %ecx
leaq 0xcd46(%rip), %rsi      # 0x12609
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x58a3
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_refcall_expression
static struct element* parse_refcall_expression( struct element *elem,
	struct function *func, struct variables *vars, struct expression *prev, char *message ) {
	int count;
	struct element *next = elem->next;
	struct expression param = { 0 }, *expr = calloc( 1, sizeof( struct expression ) );
	if( expr ) {
		prev->next = expr;
		expr->line = elem->line;
		if( next && next->str.string[ 0 ] == '(' ) {
			parse_expressions( next->child, func, vars, 0, &param, &count, message );
			expr->parameters = param.next;
			if( message[ 0 ] == 0 ) {
				if( count > 0 ) {
					expr->index = count - 1;
					expr->evaluate = evaluate_refcall_expression;
					next = next->next;
				} else {
					sprintf( message, "Expected expression after '(' on line %d.", next->line );
				}
			}
		} else {
			sprintf( message, "Expected '(' after ':' on line %d.", elem->line );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, 0x18(%rsp)
movq %rsi, %r13
movq %rdi, %r12
movq 0x20(%rdi), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x3130
testq %rax, %rax
je 0x5998
movq %rax, %r15
movq %rax, 0x10(%rbp)
movl 0x28(%r12), %edx
movl %edx, (%rax)
testq %rbx, %rbx
je 0x5985
movq 0x8(%rbx), %rax
cmpb $0x28, (%rax)
jne 0x5985
movq 0x18(%rbx), %rdi
movq %r14, (%rsp)
leaq 0x20(%rsp), %r12
leaq 0x14(%rsp), %r9
movq %r13, %rsi
movq 0x18(%rsp), %rdx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x8314
movq 0x10(%r12), %rax
movq %rax, 0x8(%r15)
cmpb $0x0, (%r14)
jne 0x59a7
movl 0x14(%rsp), %eax
testl %eax, %eax
jle 0x59b9
decl %eax
movl %eax, 0x4(%r15)
leaq 0x2a9c(%rip), %rax      # 0x8417
movq %rax, 0x18(%r15)
movq 0x20(%rbx), %rbx
jmp 0x59a7
leaq 0xcd07(%rip), %rsi      # 0x12693
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x59a7
movq 0x137d1(%rip), %rsi     # 0x19170
movq %r14, %rdi
callq 0x3070
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x28(%rbx), %edx
leaq 0xcca6(%rip), %rsi      # 0x12669
jmp 0x598c
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: get_local_variable
static struct local_variable* get_local_variable( struct local_variable *locals, char *name, char *terminators ) {
	size_t len = field_end( name, terminators ) - name;
	while( locals && ( strncmp( locals->name, name, len ) || strlen( locals->name ) != len ) ) {
		locals = locals->next;
	}
	return locals;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x84da
testq %rbx, %rbx
je 0x5d43
movq %rax, %r15
subq %r14, %r15
movq 0x8(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3060
testl %eax, %eax
jne 0x5d3a
movq %r12, %rdi
callq 0x30c0
cmpq %r15, %rax
je 0x5d43
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x5d17
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_local_expression
static struct element* parse_local_expression( struct element *elem,
	struct function *func, struct variables *vars, struct local_variable *local, struct expression *prev, char *message ) {
	struct element *next = elem->next;
	char *field = &elem->str.string[ strlen( local->name ) ];
	struct expression *expr = calloc( 1, sizeof( struct expression ) );
	if( expr ) {
		prev->next = expr;
		expr->line = elem->line;
		expr->index = local->index;
		expr->evaluate = evaluate_local;
		if( field[ 0 ] == '.' ) {
			next = parse_member_expression( local->type, expr, &field[ 1 ], elem, func, vars, prev, message );
		} else if( field[ 0 ] == ':' ) {
			next = parse_member_call_expression( local->type, expr, &field[ 1 ], elem, func, vars, prev, message );
		} else if( !strcmp( field, "++" ) ) {
			expr->evaluate = evaluate_local_post_inc;
		} else if( !strcmp( field, "--" ) ) {
			expr->evaluate = evaluate_local_post_dec;
		} else if( field[ 0 ] ) {
			sprintf( message, "Invalid local variable expression '%.64s' on line %d.", elem->str.string, elem->line );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, 0x20(%rsp)
movq %rcx, %r15
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq 0x20(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rcx), %rdi
callq 0x30c0
movq %rax, %rbp
movl $0x1, %edi
movl $0x20, %esi
callq 0x3130
testq %rax, %rax
je 0x5e0b
movq %rax, %r13
movq %rbx, (%rsp)
addq %r12, %rbp
movq 0x20(%rsp), %rdx
movq %rax, 0x10(%rdx)
movl 0x28(%r14), %ecx
movl %ecx, (%rax)
movl (%r15), %eax
movl %eax, 0x4(%r13)
leaq -0x1bbf(%rip), %rax     # 0x420d
movq %rax, 0x18(%r13)
movzbl (%rbp), %ebx
cmpl $0x3a, %ebx
movq %rdx, %rax
je 0x5e1f
cmpl $0x2e, %ebx
jne 0x5e48
movq 0x10(%r15), %rdi
incq %rbp
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movq %rax, %r8
movq (%rsp), %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x86a9
movq 0x1335e(%rip), %rsi     # 0x19170
movq %rbx, %rdi
callq 0x3070
jmp 0x5ea3
movq 0x10(%r15), %rdi
incq %rbp
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
pushq (%rsp)
pushq %rax
callq 0x8773
addq $0x38, %rsp
jmp 0x5eac
movl %ecx, %r15d
leaq 0xc910(%rip), %rsi      # 0x12762
movq %rbp, %rdi
callq 0x3140
testl %eax, %eax
je 0x5e8f
leaq 0xc900(%rip), %rsi      # 0x12765
movq %rbp, %rdi
callq 0x3140
testl %eax, %eax
je 0x5e98
testb %bl, %bl
je 0x5ea3
leaq 0xc8ec(%rip), %rsi      # 0x12768
movq (%rsp), %rdi
movq %r12, %rdx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x3200
jmp 0x5ea3
leaq -0x1c61(%rip), %rax     # 0x4235
jmp 0x5e9f
leaq -0x1c25(%rip), %rax     # 0x427a
movq %rax, 0x18(%r13)
movq 0x18(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_capture_expression
static struct element* parse_capture_expression( struct element *elem,
	struct function *func, struct variables *vars, struct local_variable *local, struct expression *prev, char *message ) {
	struct element *next = elem->next;
	struct variable *captured = &vars->locals[ local->index ];
	char *field = &elem->str.string[ strlen( local->name ) ];
	struct expression *expr = calloc( 1, sizeof( struct value_expression ) );
	if( expr ) {
		prev->next = expr;
		expr->line = elem->line;
		expr->index = ( long_int ) captured->number_value;
		( ( struct value_expression * ) expr )->num = captured->number_value;
		if( captured->string_value ) {
			captured->string_value->reference_count++;
			( ( struct value_expression * ) expr )->str = captured->string_value;
			expr->evaluate = evaluate_string_literal_expression;
		} else {
			expr->evaluate = evaluate_number_literal_expression;
		}
		if( field[ 0 ] == '.' ) {
			next = parse_member_expression( local->type, expr, &field[ 1 ], elem, func, vars, prev, message );
		} else if( field[ 0 ] == ':' ) {
			next = parse_member_call_expression( local->type, expr, &field[ 1 ], elem, func, vars, prev, message );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, (%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
movq 0x8(%rdi), %r12
movq 0x20(%rdi), %rax
movq %rax, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rdx), %r14
movslq (%rcx), %r13
movq 0x8(%rcx), %rdi
callq 0x30c0
movq %rax, %rbp
movl $0x1, %edi
movl $0x30, %esi
callq 0x3130
testq %rax, %rax
je 0x5f50
movq (%rsp), %r10
addq %rbp, %r12
shlq $0x4, %r13
movq 0x20(%rsp), %r11
movq %rax, 0x10(%r11)
movl 0x28(%r15), %ecx
movl %ecx, (%rax)
movl (%r14,%r13), %ecx
movl %ecx, 0x4(%rax)
movl %ecx, 0x28(%rax)
movq 0x8(%r14,%r13), %rcx
testq %rcx, %rcx
je 0x5f62
incq (%rcx)
movq %rcx, 0x20(%rax)
leaq -0x2479(%rip), %rcx     # 0x3ad5
jmp 0x5f69
movq 0x13219(%rip), %rsi     # 0x19170
movq (%rsp), %rdi
callq 0x3070
jmp 0x5fa5
leaq -0x249f(%rip), %rcx     # 0x3aca
movq %rcx, 0x18(%rax)
movzbl (%r12), %ecx
cmpl $0x3a, %ecx
je 0x5fb0
cmpl $0x2e, %ecx
jne 0x5fa5
movq 0x10(%rbx), %rdi
incq %r12
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r11, %r8
movq %r10, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x86a9
movq 0x18(%rsp), %rax
addq $0x28, %rsp
jmp 0x5fd7
movq 0x10(%rbx), %rdi
incq %r12
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
pushq %r10
pushq %r11
callq 0x8773
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_operator_expression
static struct element* parse_operator_expression( struct element *elem, struct operator *oper,
	struct function *func, struct variables *vars, struct expression *prev, char *message ) {
	int count;
	struct element *next = elem->next;
	struct expression param = { 0 }, *expr = calloc( 1, sizeof( struct expression ) );
	if( expr ) {
		prev->next = expr;
		expr->line = elem->line;
		expr->index = oper->oper;
		expr->evaluate = oper->evaluate;
		if( oper->num_operands != 0 ) {
			if( next && next->str.string[ 0 ] == '(' ) {
				parse_expressions( next->child, func, vars, 0, &param, &count, message );
				expr->parameters = param.next;
				if( message[ 0 ] == 0 ) {
					if( count == oper->num_operands || ( oper->num_operands < 0 && count >= -oper->num_operands ) ) {
						next = next->next;
					} else {
						sprintf( message, "Wrong number of arguments to '%.64s()' on line %d.", oper->name, next->line );
					}
				}
			} else {
				sprintf( message, "Expected '(' after '%.64s' on line %d.", oper->name, elem->line );
			}
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r14
movq %r8, %r12
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r13
movq 0x20(%rdi), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x3130
testq %rax, %rax
je 0x60c6
movq %rax, %rbp
movq %rax, 0x10(%r12)
movl 0x28(%r13), %ecx
movl %ecx, (%rax)
movsbl 0x8(%r15), %eax
movl %eax, 0x4(%rbp)
movq 0x10(%r15), %rax
movq %rax, 0x18(%rbp)
cmpl $0x0, 0xc(%r15)
je 0x60eb
testq %rbx, %rbx
je 0x60d7
movq 0x8(%rbx), %rax
cmpb $0x28, (%rax)
jne 0x60d7
movq 0x18(%rbx), %rdi
movq %r14, (%rsp)
leaq 0x20(%rsp), %r12
leaq 0xc(%rsp), %r9
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x8314
movq 0x10(%r12), %rax
movq %rax, 0x8(%rbp)
cmpb $0x0, (%r14)
jne 0x60eb
movl 0xc(%rsp), %eax
movl 0xc(%r15), %ecx
cmpl %ecx, %eax
je 0x60fd
testl %ecx, %ecx
setns %dl
negl %ecx
cmpl %ecx, %eax
setl %al
orb %dl, %al
je 0x60fd
movq (%r15), %rdx
movl 0x28(%rbx), %ecx
leaq 0xc545(%rip), %rsi      # 0x12609
jmp 0x60e1
movq 0x130a3(%rip), %rsi     # 0x19170
movq %r14, %rdi
callq 0x3070
jmp 0x60eb
movq (%r15), %rdx
leaq 0xc267(%rip), %rsi      # 0x12348
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rbx), %rbx
jmp 0x60eb
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: find_decl
static struct string* find_decl( struct function *func, char *name, enum reference_type type, char *terminators ) {
	char qname[ 65 ];
	struct string *str;
	struct string_list *imports = NULL;
	int qlen, flen = terminators ? field_end( name, terminators ) - name : strlen( name );
	if( func->file->type == SOURCE ) {
		imports = ( ( struct source * ) func->file )->imports;
	}
	str = get_decl( func->env->decls_index[ hash_code( name, name[ flen ] ) ], name, flen, type );
	while( str == NULL && imports ) {
		qlen = imports->str->length;
		if( qlen + 1 + flen < 65 ) {
			strcpy( qname, imports->str->string );
			qname[ qlen++ ] = '_';
			strncpy( &qname[ qlen ], name, flen );
			qlen += flen;
			qname[ qlen ] = 0;
			str = get_decl( func->env->decls_index[ hash_code( qname, 0 ) ], qname, qlen, type );
		}
		imports = imports->next;
	}
	if( name[ flen ] && str && str->type == FUNCTION && ( name[ flen + 1 ] || name[ flen ] != '!' ) ) {
		str = NULL;
	}
	return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, 0x4(%rsp)
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rdi
testq %rcx, %rcx
je 0x6133
movq %rcx, %rsi
callq 0x84da
movq %rax, %r14
subq %rbx, %r14
jmp 0x613b
callq 0x30c0
movq %rax, %r14
movq 0x28(%r12), %rax
cmpb $0x8, 0x14(%rax)
jne 0x614c
movq 0x18(%rax), %r15
jmp 0x614f
xorl %r15d, %r15d
movq 0x40(%r12), %rax
movq %rax, 0x10(%rsp)
movslq %r14d, %rax
movq %rax, 0x18(%rsp)
movb (%rbx,%rax), %bpl
movb (%rbx), %cl
cmpb %bpl, %cl
sete %dl
testb %cl, %cl
sete %sil
xorl %eax, %eax
orb %dl, %sil
jne 0x6196
leaq 0x1(%rbx), %rdx
movl %eax, %esi
movzbl %cl, %eax
xorl %esi, %eax
movb (%rdx), %cl
cmpb %bpl, %cl
je 0x6193
incq %rdx
testb %cl, %cl
jne 0x617e
andl $0x1f, %eax
movq 0x10(%rsp), %rcx
movq 0x280(%rcx,%rax,8), %rdi
movq %rbx, 0x8(%rsp)
movq %rbx, %rsi
movl %r14d, %edx
movl 0x4(%rsp), %ecx
callq 0x8a37
testq %rax, %rax
jne 0x6260
testq %r15, %r15
je 0x6260
movq (%r15), %rax
movslq 0x10(%rax), %rbx
leaq 0x1(%rbx), %r12
leal (%r12,%r14), %r13d
cmpl $0x40, %r13d
jg 0x6250
movq 0x8(%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3070
movb $0x5f, 0x20(%rsp,%rbx)
leaq (%rsp,%r12), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x3050
movslq %r13d, %rax
movb $0x0, 0x20(%rsp,%rax)
movb 0x20(%rsp), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x6230
leaq 0x21(%rsp), %rdx
movzbl %cl, %ecx
xorl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x621f
andl $0x1f, %eax
movq 0x10(%rsp), %rcx
movq 0x280(%rcx,%rax,8), %rdi
leaq 0x20(%rsp), %rsi
movl %r13d, %edx
movl 0x4(%rsp), %ecx
callq 0x8a37
jmp 0x6252
xorl %eax, %eax
testq %rax, %rax
jne 0x6260
movq 0x8(%r15), %r15
jmp 0x61c0
testb %bpl, %bpl
je 0x6298
testq %rax, %rax
movq 0x8(%rsp), %rsi
je 0x6298
cmpb $0x6, 0x14(%rax)
jne 0x6298
shlq $0x20, %r14
movabsq $0x100000000, %rcx      # imm = 0x100000000
addq %r14, %rcx
sarq $0x20, %rcx
xorb $0x21, %bpl
xorl %edx, %edx
orb (%rsi,%rcx), %bpl
cmovneq %rdx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_expr_list_statement
struct element* parse_expr_list_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev,
	enum result ( *execute )( struct statement *this, struct variables *vars, struct variable *result ),
	char *message ) {
	struct expression head, *expr;
	struct element *next = elem->next;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		prev->next = stmt;
		head.next = NULL;
		next = parse_expression( next, func, vars, &head, message );
		expr = stmt->source = head.next;
		while( expr && next->str.string[ 0 ] != ';' ) {
			if( next->str.string[ 0 ] == ',' ) {
				next = next->next;
			}
			next = parse_expression( next, func, vars, expr, message );
			expr = expr->next;
		}
		if( expr ) {
			stmt->execute = execute;
			next = next->next;
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, (%rsp)
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq 0x20(%rdi), %r15
movl $0x1, %edi
movl $0x28, %esi
callq 0x3130
testq %rax, %rax
je 0x6680
movq %rax, %rbp
movq %rax, 0x20(%r14)
leaq 0x8(%rsp), %r14
movq $0x0, 0x10(%r14)
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x4f9b
movq %rax, %r15
movq 0x10(%r14), %r14
movq %r14, 0x8(%rbp)
testq %r14, %r14
je 0x669d
movq 0x8(%r15), %rax
movzbl (%rax), %eax
cmpl $0x2c, %eax
je 0x665f
cmpl $0x3b, %eax
jne 0x6663
jmp 0x6691
movq 0x20(%r15), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x4f9b
movq %rax, %r15
movq 0x10(%r14), %r14
jmp 0x6647
movq 0x12ae9(%rip), %rsi     # 0x19170
movq %rbx, %rdi
callq 0x3070
jmp 0x669d
movq (%rsp), %rax
movq %rax, 0x10(%rbp)
movq 0x20(%r15), %r15
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: is_keyword
int is_keyword( char *name, char *key ) {
	int chr = key[ 0 ];
	if( strcmp( &name[ 1 ], &key[ 1 ] ) == 0 ) {
		if( chr == name[ 0 ] || ( chr > 96 && chr - 32 == name[ 0 ] ) ) {
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rsi), %bpl
incq %rdi
incq %rsi
callq 0x3140
testl %eax, %eax
je 0x66cb
xorl %eax, %eax
jmp 0x66ec
movb (%rbx), %cl
movl $0x1, %eax
cmpb %cl, %bpl
je 0x66ec
cmpb $0x61, %bpl
setge %dl
addb $-0x20, %bpl
cmpb %cl, %bpl
sete %cl
testb %cl, %dl
je 0x66c7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: validate_name
static int validate_name( struct element *elem, char *message ) {
	int chr = elem->str.string[ 0 ], idx = 1, len = elem->str.length;
	int result = len < 65 && ( ( chr >= 'A' && chr <= 'Z') || ( chr >= 'a' && chr <= 'z' ) );
	if( result ) {
		/* First character must be alphabetical.*/
		while( idx < len ) {
			chr = elem->str.string[ idx++ ];
			if( !( chr == '_' || ( chr >= '0' && chr <= '9' )
			|| ( chr >= 'A' && chr <= 'Z' ) || ( chr >= 'a' && chr <= 'z' ) ) ) {
				/* Subsequent characters must be alphanumerical, or underscore. */
				result = 0;
				idx = len;
			}
		}
	}
	if( !result ) {
		sprintf( message, "Invalid name '%.64s' on line %d.", elem->str.string, elem->line );
	}
	return result;
}

// Assembly:
movq 0x8(%rdi), %rdx
movl 0x10(%rdi), %eax
cmpl $0x40, %eax
jg 0x6f6a
movb (%rdx), %cl
leal -0x41(%rcx), %r9d
movb $0x1, %r8b
cmpb $0x1a, %r9b
jb 0x6f6d
addb $-0x61, %cl
cmpb $0x1a, %cl
setb %r8b
jmp 0x6f6d
xorl %r8d, %r8d
pushq %rbx
movzbl %r8b, %ebx
movl %ebx, %ecx
xorb $0x1, %cl
cmpl $0x2, %eax
setl %r8b
orb %cl, %r8b
jne 0x6fc7
movl $0x1, %ecx
movl %ecx, %r8d
movb (%rdx,%r8), %r8b
cmpb $0x5f, %r8b
sete %r9b
leal -0x30(%r8), %r10d
cmpb $0xa, %r10b
setb %r10b
andb $-0x21, %r8b
addb $-0x41, %r8b
cmpb $0x1a, %r8b
setb %r8b
orb %r9b, %r10b
orb %r8b, %r10b
jne 0x6fc1
xorl %ebx, %ebx
movl %eax, %ecx
jmp 0x6fc3
incl %ecx
cmpl %eax, %ecx
jl 0x6f88
testl %ebx, %ebx
jne 0x6fe2
movl 0x28(%rdi), %ecx
leaq 0xb99c(%rip), %rax      # 0x12971
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x3200
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_keywords_indexed
struct statement* parse_keywords_indexed( struct keyword **index, struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct statement *stmt = prev;
	while( elem && message[ 0 ] == 0 ) {
		elem = parse_keyword( get_keyword( elem->str.string, index[ hash_code( elem->str.string, 0 ) ] ), elem, func, vars, stmt, message );
		while( stmt && stmt->next ) {
			stmt = stmt->next;
		}
	}
#if defined( OPTIMIZER )
	if( message[ 0 ] == 0 && prev->next ) {
		stmt = optimize_statements( func, prev, message );
	}
#endif
	return stmt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %r8, (%rsp)
movq %r8, %rax
testq %rsi, %rsi
je 0x70ab
movq %rsi, %rbp
movq %rdi, %r13
movq (%rsp), %r14
cmpb $0x0, (%rbx)
jne 0x70a8
movq 0x8(%rbp), %r15
movb (%r15), %cl
testb %cl, %cl
je 0x7048
leaq 0x1(%r15), %rdx
xorl %eax, %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x7035
andl $0x1f, %eax
jmp 0x704a
xorl %eax, %eax
movq (%r13,%rax,8), %r12
testq %r12, %r12
je 0x706b
movq (%r12), %rsi
movq %r15, %rdi
callq 0x66af
testl %eax, %eax
jne 0x706b
movq 0x18(%r12), %r12
jmp 0x704f
movq %r12, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x70e9
movq %rax, %rbp
movq %r14, %rax
testq %r14, %r14
je 0x709a
movq 0x20(%rax), %r14
testq %r14, %r14
jne 0x7089
movq %rax, %r14
testq %rbp, %rbp
jne 0x701b
jmp 0x70ab
movq %r14, %rax
cmpb $0x0, (%rbx)
je 0x70bf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rcx
cmpq $0x0, 0x20(%rcx)
je 0x70b0
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeed0
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_keyword
static struct element* parse_keyword( struct keyword *key, struct element *elem,
	struct function *func, struct variables *vars, struct statement *stmt, char *message ) {
	if( key ) {
		validate_syntax( key->syntax, elem->next, elem, func->env, message );
		if( message[ 0 ] == 0 ) { 
			elem = key->parse( elem, func, vars, stmt, message );
		}
	} else {
		sprintf( message, "Unrecognized keyword '%.64s' on line %d.", elem->str.string, elem->line );
	}
	return elem;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %rsi, %rbx
testq %rdi, %rdi
je 0x714b
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbp
movq 0x8(%rdi), %rdi
movq 0x20(%rbx), %rsi
movq 0x40(%rdx), %rcx
movq %rbx, %rdx
movq %r14, %r8
callq 0x66f3
cmpb $0x0, (%r14)
jne 0x7163
movq 0x10(%rbp), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x8(%rbx), %rdx
movl 0x28(%rbx), %ecx
leaq 0xb752(%rip), %rsi      # 0x128ab
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: check_element_depth
static int check_element_depth( struct element *elem, int max_depth ) {
	max_depth--;
	while( elem ) {
		if( elem->child && ( max_depth < 0 || !check_element_depth( elem->child, max_depth ) ) ) {
			return 0;
		}
		elem = elem->next;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x739f
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %ebp
xorl %r15d, %r15d
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x7396
testl %ebx, %ebx
jle 0x73a5
movl %ebp, %esi
callq 0x7367
testl %eax, %eax
je 0x73a5
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x737e
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: new_function
static struct function* new_function( char *name, struct function *parent ) {
	int nlen, qlen = 0;
	struct function *func;
	if( name ) {
		nlen = strlen( name );
		qlen = qualify_name( parent, name, nlen, NULL ) + 1;
	}
	func = calloc( 1, sizeof( struct function ) + sizeof( char ) * qlen );
	if( func ) {
		func->str.string = ( char * ) &func[ 1 ];
		if( name ) {
			func->str.length = qualify_name( parent, name, nlen, func->str.string );
		} else {
			func->str.string = "[Function]";
			func->str.length = 10;
		}
		func->str.reference_count = 1;
		func->str.type = FUNCTION;
	}
	return func;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x73f3
movq %rbx, %rdi
callq 0x30c0
movq %rax, %r15
testq %r14, %r14
je 0x73ea
movq 0x30(%r14), %rcx
movl %r15d, %eax
testq %rcx, %rcx
je 0x73ea
movl 0x10(%rcx), %eax
addl %r15d, %eax
incl %eax
movslq %eax, %rsi
addq $0x69, %rsi
jmp 0x73f8
movl $0x68, %esi
movl $0x1, %edi
callq 0x3130
movq %rax, %r12
testq %rax, %rax
je 0x744f
movq %r12, %rcx
addq $0x68, %rcx
movq %rcx, 0x8(%r12)
testq %rbx, %rbx
je 0x742b
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x800c
jmp 0x743c
leaq 0xb4a2(%rip), %rax      # 0x128d4
movq %rax, 0x8(%r12)
movl $0xa, %eax
movl %eax, 0x10(%r12)
movq $0x1, (%r12)
movb $0x6, 0x14(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq