LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: add_global
static struct string_list* add_global( struct global_variable *global, int line, struct environment *env, char *message ) {
	struct string_list *list = append_string_list( &env->globals, &env->globals_tail, &global->str );
	if( list ) {
		list = add_decl( &global->str, line, env, message );
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x380(%rdx), %rdi
leaq 0x388(%rdx), %rsi
movq %r15, %rdx
callq 0x7f12
testq %rax, %rax
je 0x4156
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3edc
movq 0x15013(%rip), %rsi     # 0x19170
movq %rbx, %rdi
callq 0x3070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: new_string_literal
static struct string* new_string_literal( char *source ) {
	struct string *str = new_string( unquote_string( source, NULL, '"' ) );
	if( str ) {
		str->length = unquote_string( source, str->string, '"' );
	}
	return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
movl $0x22, %edx
callq 0x7f56
movslq %eax, %r15
leaq 0x19(%r15), %rdi
callq 0x31b0
movq %rax, %r14
testq %rax, %rax
je 0x41d3
movq $0x0, 0x10(%r14)
movq %r14, %rax
addq $0x18, %rax
movq %rax, 0x8(%r14)
movb $0x0, 0x18(%r14,%r15)
movq $0x1, (%r14)
movl %r15d, 0x10(%r14)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movl $0x22, %edx
callq 0x7f56
movl %eax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_local
enum result evaluate_local( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable *var = &vars->locals[ this->index ];
	result->number_value = var->number_value;
	if( var->string_value ) {
		result->string_value = var->string_value;
		result->string_value->reference_count++;
	}
	return OKAY;
}

// Assembly:
movq 0x10(%rsi), %rax
movslq 0x4(%rdi), %rcx
shlq $0x4, %rcx
movl (%rax,%rcx), %esi
movl %esi, (%rdx)
movq 0x8(%rax,%rcx), %rax
testq %rax, %rax
je 0x41fe
movq %rax, 0x8(%rdx)
incq (%rax)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_local_post_inc
enum result evaluate_local_post_inc( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable *var = &vars->locals[ this->index ];
	if( var->string_value ) {
		return throw( vars, this, 0, "Not a number." );
	} else {
		result->number_value = var->number_value++;
	}
	return OKAY;
}

// Assembly:
pushq %rbx
movq %rdi, %rax
movq 0x10(%rsi), %rcx
movslq 0x4(%rdi), %rdi
shlq $0x4, %rdi
cmpq $0x0, 0x8(%rcx,%rdi)
je 0x4234
leaq 0xdf57(%rip), %rcx      # 0x1217a
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3c96
jmp 0x4245
addq %rdi, %rcx
movl (%rcx), %eax
leal 0x1(%rax), %esi
movl %esi, (%rcx)
movl %eax, (%rdx)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_global
enum result evaluate_global( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable *var = &( ( struct global_variable * ) ( ( struct value_expression * ) this )->str )->value;
	result->number_value = var->number_value;
	if( var->string_value ) {
		result->string_value = var->string_value;
		result->string_value->reference_count++;
	}
	return OKAY;
}

// Assembly:
movq 0x20(%rdi), %rax
movl 0x18(%rax), %ecx
movl %ecx, (%rdx)
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x42a7
movq %rax, 0x8(%rdx)
incq (%rax)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: throw_interrupted
enum result throw_interrupted( struct variables *vars, struct expression *source ) {
	if( vars->func->env->worker ) {
		return throw_exit( vars, 0, "Interrupted." );
	} else {
		return throw( vars, source, 0, "Interrupted.");
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x3a0(%rax)
je 0x436f
movq 0x8(%rdi), %rbx
leaq 0x20(%rax), %r14
movq $0x2, 0x20(%rax)
movb $0xa, 0x34(%rax)
leaq 0xde37(%rip), %rcx      # 0x12188
movq %rcx, 0x28(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4363
callq 0x394d
movl $0x0, (%rbx)
movq %r14, 0x8(%rbx)
jmp 0x437d
leaq 0xde12(%rip), %rcx      # 0x12188
xorl %edx, %edx
callq 0x3c96
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: is_instance
enum result is_instance( struct variable *var, struct structure *type, struct variables *vars, struct expression *source ) {
	char msg[ 128 ];
	struct structure *struc;
	if( var->string_value && var->string_value->type == ARRAY ) {
		struc = ( ( struct array * ) var->string_value )->structure;
		while( struc ) {
			if( type == struc ) {
				return OKAY;
			}
			struc = struc->super;
		}
	}
	if( vars ) {
		sprintf( msg, "Not an instance of '%.64s'.", type->str.string );
		return throw( vars, source, var->number_value, msg );
	}
	return EXCEPTION;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x43e1
cmpb $0x2, 0x14(%rax)
jne 0x43e1
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x43e1
cmpq %rsi, %rax
je 0x4417
movq 0x30(%rax), %rax
jmp 0x43d1
testq %r14, %r14
je 0x4413
movq 0x8(%rsi), %rdx
leaq 0xdda4(%rip), %rsi      # 0x12195
xorl %ebp, %ebp
movq %rsp, %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x3200
movl (%r15), %edx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rcx
callq 0x3c96
jmp 0x441c
xorl %ebp, %ebp
jmp 0x441c
movl $0x1, %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_string
enum result evaluate_string( struct expression *expr, struct variables *vars, struct variable *result ) {
	enum result ret = expr->evaluate( expr, vars, result );
	if( ret && result->string_value == NULL ) {
		ret = throw( vars, expr, 0, "Not a string." );
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
callq *0x18(%rdi)
testl %eax, %eax
je 0x4468
movl %eax, %ebx
cmpq $0x0, 0x8(%r12)
jne 0x446a
leaq 0xdd5a(%rip), %rcx      # 0x121b1
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3c96
jmp 0x446a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x44a6
movl %eax, %ebp
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x44aa
cmpb $0x1, 0x14(%rax)
jne 0x44b4
jmp 0x44e6
xorl %ebp, %ebp
jmp 0x44e6
testl %r12d, %r12d
je 0x44b4
cmpl $0x0, (%rbx)
je 0x44e6
leaq 0xdd04(%rip), %rcx      # 0x121bf
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3c96
movl $0x0, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x44e6
callq 0x394d
movq $0x0, 0x8(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4543
cmpb $0x9, 0x14(%rax)
jne 0x4528
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x4528
leaq 0x4(%rsp), %rsi
callq *%rax
testl %eax, %eax
je 0x4555
movl %eax, %ebp
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
jmp 0x454c
leaq 0xdc4b(%rip), %rax      # 0x1217a
xorl %ebp, %ebp
movq %rdx, %rdi
movq %rcx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3c96
jmp 0x454c
movl (%rdi), %eax
movl %eax, (%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x454c
// File: /workspace/github_c_makefile_star2_O3/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 0x4594
cmpb $0x9, 0x14(%rax)
jne 0x4579
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x4579
popq %rbx
jmpq *%rax
leaq 0xdbfa(%rip), %rax      # 0x1217a
xorl %ebx, %ebx
movq %rdx, %rdi
movq %rcx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3c96
jmp 0x459d
movl (%rdi), %eax
movl %eax, (%rsi)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x45ef
movl (%rbx), %ecx
movq 0x18(%r14), %rsi
movslq %edx, %r15
movl %ecx, (%rsi,%r15,4)
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x45d4
callq 0x394d
movq 0x20(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, (%rax,%r15,8)
testq %rcx, %rcx
je 0x45e4
incq (%rcx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movslq %edx, %rsi
shlq $0x2, %rsi
addq 0x18(%r14), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
movq %r8, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x4559
// File: /workspace/github_c_makefile_star2_O3/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 -0xb90(%rip), %rcx      # 0x3a9a
cmpq %rcx, %rax
je 0x468a
movq %rsi, %r15
leaq -0x45d(%rip), %rcx      # 0x41dc
cmpq %rcx, %rax
je 0x4697
movq %rsp, %rdx
movl $0x0, (%rdx)
movq $0x0, 0x8(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
je 0x46c9
cmpq $0x0, 0x8(%rsp)
je 0x46cd
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4559
movl %eax, %ebp
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x46d4
callq 0x394d
jmp 0x46d4
movl 0x28(%r14), %eax
movl %eax, (%rbx)
movl $0x1, %ebp
jmp 0x46d4
movq 0x10(%r15), %rax
movslq 0x4(%r14), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
cmpq $0x0, 0x8(%rax,%rcx)
je 0x46e3
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4559
xorl %ebp, %ebp
jmp 0x46d4
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 0x468e
// File: /workspace/github_c_makefile_star2_O3/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 -0xc6a(%rip), %rcx      # 0x3a9a
cmpq %rcx, %rax
je 0x4764
movq %rsi, %r15
leaq -0x537(%rip), %rcx      # 0x41dc
cmpq %rcx, %rax
je 0x4771
movq %rsp, %rdx
movl $0x0, (%rdx)
movq $0x0, 0x8(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
je 0x47a3
cmpq $0x0, 0x8(%rsp)
je 0x47a7
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x44f1
movl %eax, %ebp
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x47ae
callq 0x394d
jmp 0x47ae
movl 0x4(%r14), %eax
movl %eax, (%rbx)
movl $0x1, %ebp
jmp 0x47ae
movq 0x10(%r15), %rax
movslq 0x4(%r14), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
cmpq $0x0, 0x8(%rax,%rcx)
je 0x47bd
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x44f1
xorl %ebp, %ebp
jmp 0x47ae
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 0x4768
// File: /workspace/github_c_makefile_star2_O3/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 0x485f
movl %eax, %ebp
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x4817
cmpb $0x9, 0x14(%rax)
jne 0x4817
cmpq %r12, 0x18(%rax)
je 0x4861
movq (%r12), %rdx
leaq 0xd973(%rip), %rsi      # 0x12195
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 0x3c96
movl $0x0, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4861
callq 0x394d
movq $0x0, 0x8(%rbx)
jmp 0x4861
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_O3/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 0x4a1c
movq 0x8(%rdi), %rax
leaq 0xd76f(%rip), %rcx      # 0x1217a
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3c96
jmp 0x4a26
addq %rcx, %rax
incl (%rax)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 -0x8bb(%rip), %rcx      # 0x41dc
cmpq %rcx, %rax
je 0x4ab8
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
je 0x4b35
movq 0x18(%rsp), %r13
jmp 0x4aca
movq 0x10(%r15), %rax
movslq 0x4(%r12), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %r13
testq %r13, %r13
je 0x4b1d
cmpb $0x2, 0x14(%r13)
jne 0x4b1d
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x46e7
testl %eax, %eax
je 0x4b4b
movslq 0xc(%rsp), %rdx
cmpl 0x40(%r13), %edx
jae 0x4b39
movl %eax, %ebp
movq 0x18(%r13), %rax
movl (%rax,%rdx,4), %eax
movl %eax, (%rbx)
movq 0x20(%r13), %rax
testq %rax, %rax
je 0x4b4d
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je 0x4b4d
movq %rax, 0x8(%rbx)
incq (%rax)
jmp 0x4b4d
leaq 0xd6c6(%rip), %rcx      # 0x121ea
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3c96
jmp 0x4b4d
xorl %ebp, %ebp
jmp 0x4b5c
leaq 0xd68f(%rip), %rcx      # 0x121cf
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c96
xorl %ebp, %ebp
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4b5c
callq 0x394d
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_O3/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 -0xbee(%rip), %rax      # 0x41dc
cmpq %rax, 0x18(%r12)
je 0x4df6
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x442e
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x4e0d
movl %eax, %ebp
cmpl $0x1, %eax
je 0x4e3f
jmp 0x4e74
movq 0x10(%rbx), %rax
movslq 0x4(%r12), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %r13
testq %r13, %r13
je 0x4e3f
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %rbx, %rsi
callq 0x46e7
xorl %ebp, %ebp
testl %eax, %eax
je 0x4e65
movslq 0xc(%rsp), %rdx
cmpl 0x10(%r13), %edx
jae 0x4e53
movq 0x8(%r13), %rcx
movsbl (%rcx,%rdx), %ecx
movl %ecx, (%r14)
movl %eax, %ebp
jmp 0x4e65
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x442e
movl %eax, %ebp
jmp 0x4e74
leaq 0xd3ed(%rip), %rcx      # 0x12247
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c96
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4e74
callq 0x394d
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_O3/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 0x442e
testl %eax, %eax
je 0x4f2e
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x46e7
xorl %ebp, %ebp
testl %eax, %eax
je 0x4f44
movl 0xc(%rsp), %edx
testl %edx, %edx
js 0x4f32
leal (,%rdx,4), %ecx
movq 0x18(%rsp), %rsi
movl 0x10(%rsi), %edi
addl $-0x3, %edi
cmpl %edi, %ecx
jge 0x4f32
movq 0x8(%rsi), %rdx
movl %ecx, %ecx
movl (%rdx,%rcx), %ecx
bswapl %ecx
movl %ecx, (%rbx)
movl %eax, %ebp
jmp 0x4f44
xorl %ebp, %ebp
jmp 0x4f53
leaq 0xd30e(%rip), %rcx      # 0x12247
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c96
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4f53
callq 0x394d
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5b6b
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 0x5b53
cmpb %al, -0x1(%r12,%rcx)
jne 0x5b53
movsbl %al, %edx
movq %rsp, %rsi
movq %r12, %rdi
callq 0x7f56
cmpl $0x1, %eax
jne 0x5b53
movsbl (%rsp), %eax
movl %eax, 0x28(%r15)
movl %eax, 0x4(%r15)
leaq -0x20b3(%rip), %rax     # 0x3a9a
movq %rax, 0x18(%r15)
jmp 0x5b7a
leaq 0xca0d(%rip), %rsi      # 0x12567
movq %r14, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3200
jmp 0x5b7a
movq 0x135fe(%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_O3/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 0x5c61
movq %rax, %r12
movq %rax, 0x10(%rbp)
movl 0x28(%r15), %edx
movl %edx, (%rax)
movq %r13, 0x20(%rax)
testq %rbx, %rbx
je 0x5c4e
movq 0x8(%rbx), %rax
cmpb $0x28, (%rax)
jne 0x5c4e
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 0x8142
movq 0x10(%r13), %rax
movq %rax, 0x8(%r12)
cmpb $0x0, (%r14)
jne 0x5c70
movl 0xc(%rsp), %eax
movq 0x20(%r12), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x5c82
leaq 0x1797(%rip), %rax      # 0x73da
movq %rax, 0x18(%r12)
movq 0x20(%rbx), %rbx
jmp 0x5c70
leaq 0xc9ec(%rip), %rsi      # 0x12641
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x5c70
movq 0x13508(%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 0xc97e(%rip), %rsi      # 0x1260e
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x5c70
// File: /workspace/github_c_makefile_star2_O3/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 0x5d65
movq %rax, %r15
movq %rax, 0x10(%rbp)
movl 0x28(%r12), %edx
movl %edx, (%rax)
testq %rbx, %rbx
je 0x5d52
movq 0x8(%rbx), %rax
cmpb $0x28, (%rax)
jne 0x5d52
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 0x8142
movq 0x10(%r12), %rax
movq %rax, 0x8(%r15)
cmpb $0x0, (%r14)
jne 0x5d74
movl 0x14(%rsp), %eax
testl %eax, %eax
jle 0x5d86
decl %eax
movl %eax, 0x4(%r15)
leaq 0x2507(%rip), %rax      # 0x824f
movq %rax, 0x18(%r15)
movq 0x20(%rbx), %rbx
jmp 0x5d74
leaq 0xc93f(%rip), %rsi      # 0x12698
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x5d74
movq 0x13404(%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 0xc8de(%rip), %rsi      # 0x1266e
jmp 0x5d59
// File: /workspace/github_c_makefile_star2_O3/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 0x8312
testq %rbx, %rbx
je 0x5de2
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 0x5dd9
movq %r12, %rdi
callq 0x30c0
cmpq %r15, %rax
je 0x5de4
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x5db6
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5e8c
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 0x5e9e
incq (%rcx)
movq %rcx, 0x20(%rax)
leaq -0x23e5(%rip), %rcx     # 0x3aa5
jmp 0x5ea5
movq 0x132dd(%rip), %rsi     # 0x19170
movq (%rsp), %rdi
callq 0x3070
jmp 0x5ee1
leaq -0x240b(%rip), %rcx     # 0x3a9a
movq %rcx, 0x18(%rax)
movzbl (%r12), %ecx
cmpl $0x3a, %ecx
je 0x5eec
cmpl $0x2e, %ecx
jne 0x5ee1
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 0x84df
movq 0x18(%rsp), %rax
addq $0x28, %rsp
jmp 0x5f13
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 0x85a9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6002
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 0x6027
testq %rbx, %rbx
je 0x6013
movq 0x8(%rbx), %rax
cmpb $0x28, (%rax)
jne 0x6013
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 0x8142
movq 0x10(%r12), %rax
movq %rax, 0x8(%rbp)
cmpb $0x0, (%r14)
jne 0x6027
movl 0xc(%rsp), %eax
movl 0xc(%r15), %ecx
cmpl %ecx, %eax
je 0x6039
testl %ecx, %ecx
setns %dl
negl %ecx
cmpl %ecx, %eax
setl %al
orb %dl, %al
je 0x6039
movq (%r15), %rdx
movl 0x28(%rbx), %ecx
leaq 0xc60e(%rip), %rsi      # 0x1260e
jmp 0x601d
movq 0x13167(%rip), %rsi     # 0x19170
movq %r14, %rdi
callq 0x3070
jmp 0x6027
movq (%r15), %rdx
leaq 0xc333(%rip), %rsi      # 0x12350
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 0x6027
// File: /workspace/github_c_makefile_star2_O3/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 0x606f
movq %rcx, %rsi
callq 0x8312
movq %rax, %r14
subq %rbx, %r14
jmp 0x6077
callq 0x30c0
movq %rax, %r14
movq 0x28(%r12), %rax
cmpb $0x8, 0x14(%rax)
jne 0x6088
movq 0x18(%rax), %r15
jmp 0x608b
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 0x60d2
leaq 0x1(%rbx), %rdx
movl %eax, %esi
movzbl %cl, %eax
xorl %esi, %eax
movb (%rdx), %cl
cmpb %bpl, %cl
je 0x60cf
incq %rdx
testb %cl, %cl
jne 0x60ba
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 0x887e
testq %rax, %rax
jne 0x619c
testq %r15, %r15
je 0x619c
movq (%r15), %rax
movslq 0x10(%rax), %rbx
leaq 0x1(%rbx), %r12
leal (%r12,%r14), %r13d
cmpl $0x40, %r13d
jg 0x618c
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 0x616c
leaq 0x21(%rsp), %rdx
movzbl %cl, %ecx
xorl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x615b
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 0x887e
jmp 0x618e
xorl %eax, %eax
testq %rax, %rax
jne 0x619c
movq 0x8(%r15), %r15
jmp 0x60fc
testb %bpl, %bpl
je 0x61d4
testq %rax, %rax
movq 0x8(%rsp), %rsi
je 0x61d4
cmpb $0x6, 0x14(%rax)
jne 0x61d4
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_O3/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 0x658b
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 0x4f62
movq %rax, %r15
movq 0x10(%r14), %r14
movq %r14, 0x8(%rbp)
testq %r14, %r14
je 0x65a8
movq 0x8(%r15), %rax
movzbl (%rax), %eax
cmpl $0x2c, %eax
je 0x656a
cmpl $0x3b, %eax
jne 0x656e
jmp 0x659c
movq 0x20(%r15), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x4f62
movq %rax, %r15
movq 0x10(%r14), %r14
jmp 0x6552
movq 0x12bde(%rip), %rsi     # 0x19170
movq %rbx, %rdi
callq 0x3070
jmp 0x65a8
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_O3/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 0x65d6
xorl %eax, %eax
jmp 0x65f7
movb (%rbx), %cl
movl $0x1, %eax
cmpb %cl, %bpl
je 0x65f7
cmpb $0x61, %bpl
setge %dl
addb $-0x20, %bpl
cmpb %cl, %bpl
sete %cl
testb %cl, %dl
je 0x65d2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
movq 0x8(%rdi), %rdx
movl 0x10(%rdi), %eax
cmpl $0x40, %eax
jg 0x6e77
movb (%rdx), %cl
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x19, %cl
ja 0x6e77
movl $0x1, %ebx
cmpl $0x2, %eax
jl 0x6e90
movl $0x1, %r8d
movl $0x1, %ecx
movl %r8d, %ebx
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 0x6e69
xorl %r8d, %r8d
movl %eax, %ecx
jmp 0x6e6e
incl %ecx
movl %ebx, %r8d
cmpl %eax, %ecx
jl 0x6e2c
testl %r8d, %r8d
jne 0x6e90
movl 0x28(%rdi), %ecx
leaq 0xbaef(%rip), %rax      # 0x12970
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x3200
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6f57
movq %rsi, %rbp
movq %rdi, %r13
movq (%rsp), %r14
cmpb $0x0, (%rbx)
jne 0x6f82
movq 0x8(%rbp), %r15
movb (%r15), %cl
testb %cl, %cl
je 0x6ef6
leaq 0x1(%r15), %rdx
xorl %eax, %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x6ee3
andl $0x1f, %eax
jmp 0x6ef8
xorl %eax, %eax
movq (%r13,%rax,8), %r12
testq %r12, %r12
je 0x6f19
movq (%r12), %rsi
movq %r15, %rdi
callq 0x65ba
testl %eax, %eax
jne 0x6f1c
movq 0x18(%r12), %r12
jmp 0x6efd
xorl %r12d, %r12d
movq %r12, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x6f94
movq %rax, %rbp
movq %r14, %rax
testq %r14, %r14
je 0x6f4b
movq 0x20(%rax), %r14
testq %r14, %r14
jne 0x6f3a
movq %rax, %r14
testq %rbp, %rbp
jne 0x6ec9
cmpb $0x0, (%rbx)
jne 0x6f85
movq (%rsp), %rsi
cmpq $0x0, 0x20(%rsi)
je 0x6f85
movq 0x8(%rsp), %rdi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeb54
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6ff6
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 0x65fe
cmpb $0x0, (%r14)
jne 0x700e
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 0xb8a6(%rip), %rsi      # 0x128aa
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