LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: validate_decl
static int validate_decl( struct string *decl, int line, struct environment *env, char *message ) {
	int hash = validate_local( decl, line, env, message );
	if( hash && get_decl( env->decls_index[ hash - 1 ], decl->string, decl->length, 0 ) ) {
		sprintf( message, "Name '%.64s' already declared on line %d.", decl->string, line );
	}
	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xb990
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x4842
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x280(%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
xorl %ecx, %ecx
callq 0xb7d0
cmpq $0x0, %rax
je 0x4842
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movl -0xc(%rbp), %ecx
leaq 0x1766d(%rip), %rsi     # 0x1bea8
movb $0x0, %al
callq 0x31f0
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_string_list
static struct string_list* new_string_list( struct string *value, struct string_list *next ) {
	struct string_list *list = malloc( sizeof( struct string_list ) );
	if( list ) {
		list->str = value;
		value->reference_count++;
		list->next = next;
	}
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x31a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x489a
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: add_constants
int add_constants( struct constant *constants, struct environment *env, char *message ) {
	struct global_variable *global;
	while( constants->name && message[ 0 ] == 0 ) {
		global = new_global_variable( constants->name, NULL, NULL, NULL, message );
		if( global ) {
			if( add_global( global, 0, env, message ) ) {
				global->str.type = CONST;
				global->value.number_value = constants->number_value;
				if( constants->string_value ) {
					global->value.string_value = new_string_literal( constants->string_value );
					if( global->value.string_value == NULL ) {
						strcpy( message, OUT_OF_MEMORY );
					}
				}
			}
			unref_string( &global->str );
		}
		constants++;
	}
	return message[ 0 ] == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x48e3
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x48ef
jmp 0x499f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x49c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x498e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %esi, %esi
callq 0x4ae0
cmpq $0x0, %rax
je 0x4985
movq -0x20(%rbp), %rax
movb $0x5, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4983
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4b60
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x4981
movq -0x18(%rbp), %rdi
movq 0x1c7e4(%rip), %rsi     # 0x21160
callq 0x3070
jmp 0x4983
jmp 0x4985
movq -0x20(%rbp), %rdi
callq 0x3c20
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0x48c4
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_global_variable
static struct global_variable* new_global_variable( char *name,
	struct structure *type, struct function *init_function, struct expression *initializer, char *message ) {
	int nlen = strlen( name );
	int qlen = qualify_name( init_function, name, nlen, NULL );
	struct global_variable *global = malloc( sizeof( struct global_variable ) + sizeof( char ) * ( qlen + 1 ) );
	if( global ) {
		global->str.reference_count = 1;
		global->str.string = ( char * ) &global[ 1 ];
		qualify_name( init_function, name, nlen, global->str.string );
		global->str.length = qlen;
		global->str.type = GLOBAL;
		global->value.number_value = 0;
		global->value.string_value = NULL;
		global->type = type;
		global->init_function = init_function;
		if( init_function ) {
			init_function->str.reference_count++;
		}
		global->initializer = initializer;
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return global;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30c0
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x2c(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0xa730
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
addq $0x40, %rdi
callq 0x31a0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4abb
movq -0x38(%rbp), %rax
movq $0x1, (%rax)
movq -0x38(%rbp), %rcx
addq $0x40, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0xa730
movl -0x30(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rax
movb $0x4, 0x14(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x4aad
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x4acb
movq -0x28(%rbp), %rdi
movq 0x1c69a(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x380, %rdi            # imm = 0x380
movq -0x18(%rbp), %rsi
addq $0x388, %rsi            # imm = 0x388
movq -0x8(%rbp), %rdx
callq 0xa7f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4b3b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4720
movq %rax, -0x28(%rbp)
jmp 0x4b4b
movq -0x20(%rbp), %rdi
movq 0x1c61a(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x22, %edx
callq 0xa860
movl %eax, %edi
callq 0x39b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4baf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x22, %edx
callq 0xa860
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4c24
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x1, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4c85
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
leaq 0x169c3(%rip), %rcx     # 0x1b63e
callq 0x4330
movl %eax, -0x4(%rbp)
jmp 0x4c9f
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, (%rax)
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4d89
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: execute_local_assignment
enum result execute_local_assignment( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable var = { 0 }, *dest = &vars->locals[ this->local ];
	enum result ret = this->source->evaluate( this->source, vars, &var );
	if( ret ) {
		dispose_temporary( dest );
		dest->number_value = var.number_value;
		dest->string_value = var.string_value;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x4e13
movq -0x30(%rbp), %rdi
callq 0x3ce0
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x3a0(%rax)
je 0x4ead
movq -0x10(%rbp), %rdi
xorl %esi, %esi
leaq 0x167a9(%rip), %rdx     # 0x1b64c
callq 0x42b0
movl %eax, -0x4(%rbp)
jmp 0x4ec6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
leaq 0x1678e(%rip), %rcx     # 0x1b64c
callq 0x4330
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4f90
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x14(%rax), %eax
cmpl $0x2, %eax
jne 0x4f90
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
je 0x4f8e
movq -0x18(%rbp), %rax
cmpq -0xb8(%rbp), %rax
jne 0x4f7a
movl $0x1, -0x4(%rbp)
jmp 0x4fda
movq -0xb8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0xb8(%rbp)
jmp 0x4f5a
jmp 0x4f90
cmpq $0x0, -0x20(%rbp)
je 0x4fd3
leaq -0xb0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x166ac(%rip), %rsi     # 0x1b659
movb $0x0, %al
callq 0x31f0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq -0xb0(%rbp), %rcx
callq 0x4330
movl %eax, -0x4(%rbp)
jmp 0x4fda
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x5047
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5047
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
leaq 0x16636(%rip), %rcx     # 0x1b675
callq 0x4330
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x50e7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x50ac
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x14(%rax), %eax
cmpl $0x1, %eax
jne 0x50aa
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x50ed
jmp 0x50c5
cmpl $0x0, -0x24(%rbp)
je 0x50c3
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x50c3
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x50ed
jmp 0x50c5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
leaq 0x165ad(%rip), %rcx     # 0x1b683
callq 0x4330
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3be0
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x519e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x14(%rax), %eax
cmpl $0x9, %eax
jne 0x516e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x516e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x2c(%rbp), %rsi
callq *%rax
movl %eax, -0x30(%rbp)
jmp 0x5187
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
leaq 0x164bf(%rip), %rcx     # 0x1b63e
callq 0x4330
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x5196
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x51b1
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5249
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x14(%rax), %eax
cmpl $0x9, %eax
jne 0x522e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x522e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x525c
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
leaq 0x163ff(%rip), %rcx     # 0x1b63e
callq 0x4330
movl %eax, -0x4(%rbp)
jmp 0x525c
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x530d
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x52cf
movq -0x38(%rbp), %rdi
callq 0x3c20
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x38(%rbp)
je 0x5304
movq -0x38(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5334
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x51c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
leaq -0x15df(%rip), %rcx     # 0x3d80
cmpq %rcx, 0x18(%rax)
jne 0x537e
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5452
movq -0x10(%rbp), %rax
leaq -0x7c9(%rip), %rcx      # 0x4bc0
cmpq %rcx, 0x18(%rax)
jne 0x53e7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x53d2
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x51c0
movl %eax, -0x4(%rbp)
jmp 0x5452
movq -0x40(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5452
jmp 0x53e9
movl $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x544c
cmpq $0x0, -0x30(%rbp)
je 0x5441
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x51c0
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3ce0
jmp 0x544a
movl -0x38(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x544c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
leaq -0x16ff(%rip), %rcx     # 0x3d80
cmpq %rcx, 0x18(%rax)
jne 0x549e
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5572
movq -0x10(%rbp), %rax
leaq -0x8e9(%rip), %rcx      # 0x4bc0
cmpq %rcx, 0x18(%rax)
jne 0x5507
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x54f2
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x5100
movl %eax, -0x4(%rbp)
jmp 0x5572
movq -0x40(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5572
jmp 0x5509
movl $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x556c
cmpq $0x0, -0x30(%rbp)
je 0x5561
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x5100
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3ce0
jmp 0x556a
movl -0x38(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x556c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0xb4(%rbp)
cmpl $0x0, -0xb4(%rbp)
je 0x5672
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5580
cmpl $0x0, %eax
je 0x5631
movl -0xb4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x567b
leaq -0xb0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x16013(%rip), %rsi     # 0x1b659
movb $0x0, %al
callq 0x31f0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0xb0(%rbp), %rcx
xorl %edx, %edx
callq 0x4330
movl %eax, -0xb4(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3be0
movl -0xb4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5908
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
leaq 0x15d40(%rip), %rcx     # 0x1b63e
callq 0x4330
movl %eax, -0x4(%rbp)
jmp 0x591a
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x3040
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x31d0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5de5
callq 0x3040
cmpl $0x0, (%rax)
jne 0x5de5
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5dec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movl $0x1, -0x34(%rbp)
movq -0x20(%rbp), %rax
leaq -0x1282(%rip), %rcx     # 0x4bc0
cmpq %rcx, 0x18(%rax)
jne 0x5e69
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x5e85
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4ff0
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x5ef5
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5460
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x5eea
movl -0x38(%rbp), %eax
movq -0x40(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x5ece
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x5ee8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x38(%rbp), %edx
leaq 0x1582b(%rip), %rcx     # 0x1b70b
callq 0x4330
movl %eax, -0x34(%rbp)
jmp 0x5eea
leaq -0x30(%rbp), %rdi
callq 0x3ce0
jmp 0x5f11
cmpl $0x1, -0x34(%rbp)
jne 0x5f0f
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4ff0
movl %eax, -0x34(%rbp)
jmp 0x5f11
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4ff0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x60b1
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x5460
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x60a8
cmpl $0x0, -0x34(%rbp)
jl 0x608c
movl -0x34(%rbp), %eax
shll $0x2, %eax
movq -0x28(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jge 0x608c
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x34(%rbp), %esi
callq 0x5f80
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x60a6
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x34(%rbp), %edx
leaq 0x1566d(%rip), %rcx     # 0x1b70b
callq 0x4330
movl %eax, -0x38(%rbp)
jmp 0x60a8
leaq -0x30(%rbp), %rdi
callq 0x3ce0
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_number_literal_expression
static struct element* parse_number_literal_expression( struct element *elem, struct expression *prev, char *message ) {
	struct value_expression *expr = calloc( 1, sizeof( struct value_expression ) );
	if( expr ) {
		prev->next = &expr->expr;
		expr->expr.line = elem->line;
		if( parse_number( elem->str.string, &expr->num ) ) {
			expr->expr.index = ( long_int ) expr->num;
			expr->expr.evaluate = evaluate_number_literal_expression;
		} else {
			sprintf( message, "Invalid number literal '%.64s' on line %d.", elem->str.string, elem->line );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return elem->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x3120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6693
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x28, %rsi
callq 0x5d90
cmpl $0x0, %eax
je 0x6670
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
leaq -0x28ea(%rip), %rcx     # 0x3d80
movq %rcx, 0x18(%rax)
jmp 0x6691
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x15356(%rip), %rsi     # 0x1b9e0
movb $0x0, %al
callq 0x31f0
jmp 0x66a3
movq -0x18(%rbp), %rdi
movq 0x1aac2(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_string_literal_expression
static struct element* parse_string_literal_expression( struct element *elem,
	struct expression *prev, char *message ) {
	struct string *value = new_string_literal( elem->str.string );
	if( value ) {
		prev->next = new_string_literal_expression( 0, value, elem->line, message );
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return elem->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4b60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x670f
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x18(%rbp), %rcx
xorl %edi, %edi
callq 0xaa70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x671f
movq -0x18(%rbp), %rdi
movq 0x1aa46(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_element_literal_expression
static struct element* parse_element_literal_expression( struct element *elem,
	struct environment *env, struct expression *prev, char *message ) {
	struct element *child, *next = elem->next;
	if( next && next->str.string[ 0 ] == '{' ) {
		child = next->child;
		if( child ) {
			if( env->worker ) {
				child = copy_element( child );
				if( child == NULL ) {
					strcpy( message, OUT_OF_MEMORY );
				}
			} else {
				child->str.reference_count++;
			}
			if( child ) {
				prev->next = new_string_literal_expression( 0, &child->str, elem->line, message );
			}
		} else {
			prev->next = calloc( 1, sizeof( struct value_expression ) );
			if( prev->next ) {
				prev->next->line = elem->line;
				prev->next->evaluate = evaluate_number_literal_expression;
			} else {
				strcpy( message, OUT_OF_MEMORY );
			}
		}
		next = next->next;
	} else {
		sprintf( message, "Expected '{' after '$' on line %d.", elem->line );
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x685d
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x685d
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x67f2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x3a0(%rax)
je 0x67ba
movq -0x28(%rbp), %rdi
callq 0xab00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x67b8
movq -0x20(%rbp), %rdi
movq 0x1a9ad(%rip), %rsi     # 0x21160
callq 0x3070
jmp 0x67c8
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x67f0
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x20(%rbp), %rcx
xorl %edi, %edi
callq 0xaa70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x684f
movl $0x1, %edi
movl $0x30, %esi
callq 0x3120
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x683d
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
leaq -0x2ab7(%rip), %rcx     # 0x3d80
movq %rcx, 0x18(%rax)
jmp 0x684d
movq -0x20(%rbp), %rdi
movq 0x1a918(%rip), %rsi     # 0x21160
callq 0x3070
jmp 0x684f
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x6876
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x1519c(%rip), %rsi     # 0x1ba0b
movb $0x0, %al
callq 0x31f0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x3120
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6b4f
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x38(%rbp)
jle 0x6b2c
cmpl $0x7, -0x38(%rbp)
jge 0x6b2c
movq -0x28(%rbp), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x31(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6b2c
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movsbl -0x31(%rbp), %edx
callq 0xa860
cmpl $0x1, %eax
jne 0x6b2c
movsbl -0x30(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
movsbl -0x30(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
leaq -0x2da6(%rip), %rcx     # 0x3d80
movq %rcx, 0x18(%rax)
jmp 0x6b4d
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x14ee8(%rip), %rsi     # 0x1ba2e
movb $0x0, %al
callq 0x31f0
jmp 0x6b5f
movq -0x18(%rbp), %rdi
movq 0x1a606(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_index_expression
static struct element* parse_index_expression( struct element *elem,
	struct function *func, struct variables *vars, struct expression *prev, char *message ) {
	int num_params;
	struct expression param = { 0 }, *expr = calloc( 1, sizeof( struct expression ) );
	if( expr ) {
		prev->next = expr;
		expr->line = elem->line;
		parse_expressions( elem->child, func, vars, 0, &param, &num_params, message );
		expr->parameters = param.next;
		if( message[ 0 ] == 0 ) {
			if( num_params == 2 ) {
				expr->evaluate = evaluate_index_expression;
			} else {
				sprintf( message, "Invalid index expression on line %d.", elem->line );
			}
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return elem->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x30f0
movl $0x1, %edi
movl $0x20, %esi
callq 0x3120
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x6c46
movq -0x58(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x58(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
leaq -0x50(%rbp), %r8
leaq -0x2c(%rbp), %r9
movq %rax, (%rsp)
callq 0xac40
movq -0x40(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6c44
cmpl $0x2, -0x2c(%rbp)
jne 0x6c29
movq -0x58(%rbp), %rax
leaq -0x1273(%rip), %rcx     # 0x59b0
movq %rcx, 0x18(%rax)
jmp 0x6c42
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x14e21(%rip), %rsi     # 0x1ba5c
movb $0x0, %al
callq 0x31f0
jmp 0x6c44
jmp 0x6c56
movq -0x28(%rbp), %rdi
movq 0x1a50f(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_func_ref_expression
static struct element* parse_func_ref_expression( struct element *elem,
	struct function *func, struct expression *prev, char *message ) {
	char *name = &elem->str.string[ 1 ];
	struct function_expression *expr = calloc( 1, sizeof( struct function_expression ) );
	if( expr ) {
		prev->next = &expr->expr;
		expr->expr.line = elem->line;
		expr->function = ( struct function * ) find_decl( func, name, FUNCTION, NULL );
		if( expr->function ) {
			expr->expr.evaluate = evaluate_func_ref_expression;
		} else {
			sprintf( message, "Function '%.64s' not declared on line %d.", name, elem->line );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return elem->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x3120
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6d27
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x6, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x7b80
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6d08
movq -0x30(%rbp), %rax
leaq 0x40be(%rip), %rcx      # 0xadc0
movq %rcx, 0x18(%rax)
jmp 0x6d25
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x14d8d(%rip), %rsi     # 0x1baab
movb $0x0, %al
callq 0x31f0
jmp 0x6d37
movq -0x20(%rbp), %rdi
movq 0x1a42e(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)