LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 -0x816(%rip), %rcx      # 0x407b
cmpq %rcx, %rax
je 0x48b2
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
je 0x492f
movq 0x18(%rsp), %r13
jmp 0x48c4
movq 0x10(%r15), %rax
movslq 0x4(%r12), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %r13
testq %r13, %r13
je 0x4917
cmpb $0x2, 0x14(%r13)
jne 0x4917
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x4514
testl %eax, %eax
je 0x4945
movslq 0xc(%rsp), %rdx
cmpl 0x40(%r13), %edx
jae 0x4933
movl %eax, %ebp
movq 0x18(%r13), %rax
movl (%rax,%rdx,4), %eax
movl %eax, (%rbx)
movq 0x20(%r13), %rax
testq %rax, %rax
je 0x4947
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je 0x4947
movq %rax, 0x8(%rbx)
incq (%rax)
jmp 0x4947
leaq 0xc90c(%rip), %rcx      # 0x1122a
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3bb2
jmp 0x4947
xorl %ebp, %ebp
jmp 0x4951
leaq 0xc8d5(%rip), %rcx      # 0x1120f
movq %r15, %rdi
movq %r14, %rsi
callq 0x3bb2
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
callq 0x3988
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_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_number
int parse_number( char *str, number *result ) {
	char *end;
	number value;
#if defined( FLOATING_POINT )
	if( str[ 0 ] != '0' || str[ 1 ] == '.' ) {
		errno = 0;
		value = strtod( str, &end );
		if( !( *end || errno ) ) {
			*result = value;
			return 1;
		}
	}
#endif
	errno = 0;
	value = strtoul( str, &end, 0 );
	if( !( *end || errno ) ) {
		*result = value;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3040
movq %rax, %r14
andl $0x0, (%rax)
leaq 0x8(%rsp), %r12
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x31e0
movq (%r12), %rcx
cmpb $0x0, (%rcx)
jne 0x4ba1
cmpl $0x0, (%r14)
jne 0x4ba1
movl %eax, (%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 -0xb5f(%rip), %rax      # 0x407b
cmpq %rax, 0x18(%r12)
je 0x4c06
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x4284
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x4c1d
movl %eax, %ebp
cmpl $0x1, %eax
je 0x4c4f
jmp 0x4c7f
movq 0x10(%rbx), %rax
movslq 0x4(%r12), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %r13
testq %r13, %r13
je 0x4c4f
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %rbx, %rsi
callq 0x4514
xorl %ebp, %ebp
testl %eax, %eax
je 0x4c75
movslq 0xc(%rsp), %rdx
cmpl 0x10(%r13), %edx
jae 0x4c63
movq 0x8(%r13), %rcx
movsbl (%rcx,%rdx), %ecx
movl %ecx, (%r14)
movl %eax, %ebp
jmp 0x4c75
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4284
movl %eax, %ebp
jmp 0x4c7f
leaq 0xc61d(%rip), %rcx      # 0x11287
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3bb2
leaq 0x10(%rsp), %rdi
callq 0x3988
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_O2/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 0x4284
testl %eax, %eax
je 0x4d3d
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x4514
xorl %ebp, %ebp
testl %eax, %eax
je 0x4d53
movl 0xc(%rsp), %edx
testl %edx, %edx
js 0x4d41
movl %eax, %r12d
leal (,%rdx,4), %ecx
movq 0x18(%rsp), %rax
movl 0x10(%rax), %esi
addl $-0x3, %esi
cmpl %esi, %ecx
jge 0x4d41
movq 0x8(%rax), %rdi
movl %edx, %esi
callq 0x4cb6
movl %eax, (%rbx)
movl %r12d, %ebp
jmp 0x4d53
xorl %ebp, %ebp
jmp 0x4d5d
leaq 0xc53f(%rip), %rcx      # 0x11287
movq %r15, %rdi
movq %r14, %rsi
callq 0x3bb2
leaq 0x10(%rsp), %rdi
callq 0x3988
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x3130
testq %rax, %rax
je 0x5d88
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 0x5d70
cmpb %al, -0x1(%r12,%rcx)
jne 0x5d70
movsbl %al, %edx
movq %rsp, %rsi
movq %r12, %rdi
callq 0x793e
cmpl $0x1, %eax
jne 0x5d70
movsbl (%rsp), %eax
movl %eax, 0x28(%r15)
movl %eax, 0x4(%r15)
leaq -0x239f(%rip), %rax     # 0x39cb
movq %rax, 0x18(%r15)
jmp 0x5d97
leaq 0xb830(%rip), %rsi      # 0x115a7
movq %r14, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3200
jmp 0x5d97
movq 0x123e1(%rip), %rsi     # 0x18170
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_O2/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)
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x3130
testq %rax, %rax
je 0x5e7a
movq %rax, %r12
movq %rax, 0x10(%rbp)
movl 0x28(%r15), %edx
movl %edx, (%rax)
movq %r13, 0x20(%rax)
testq %rbx, %rbx
je 0x5e67
movq 0x8(%rbx), %rax
cmpb $0x28, (%rax)
jne 0x5e67
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 0x7b36
movq 0x10(%r13), %rax
movq %rax, 0x8(%r12)
cmpb $0x0, (%r14)
jne 0x5e89
movl 0xc(%rsp), %eax
movq 0x20(%r12), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x5e9b
leaq 0x106a(%rip), %rax      # 0x6ec6
movq %rax, 0x18(%r12)
movq 0x20(%rbx), %rbx
jmp 0x5e89
leaq 0xb813(%rip), %rsi      # 0x11681
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x5e89
movq 0x122ef(%rip), %rsi     # 0x18170
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 0xb7a5(%rip), %rsi      # 0x1164e
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x5e89
// File: /workspace/github_c_makefile_star2_O2/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 0x7cc2
movq %rax, %r15
subq %r14, %r15
testq %rbx, %rbx
je 0x5f02
movq 0x8(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3060
testl %eax, %eax
jne 0x5efc
movq %r12, %rdi
callq 0x30c0
cmpq %r15, %rax
je 0x5f02
movq 0x18(%rbx), %rbx
jmp 0x5ed4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: hash_code
static int hash_code( char *str, char terminator ) {
	char chr = str[ 0 ];
	int idx = 1, hash = 0;
	while( chr != terminator && chr ) {
		hash = hash ^ chr;
		chr = str[ idx++ ];
	}
	return hash & 0x1F;
}

// Assembly:
xorl %eax, %eax
movb (%rdi), %cl
cmpb %sil, %cl
je 0x5f57
testb %cl, %cl
je 0x5f57
movzbl %cl, %ecx
xorl %ecx, %eax
incq %rdi
jmp 0x5f42
andl $0x1f, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x78, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
testq %rcx, %rcx
je 0x5f8b
movq %rcx, %rsi
callq 0x7cc2
movq %rax, %r14
subq %rbx, %r14
jmp 0x5f93
callq 0x30c0
movq %rax, %r14
movq 0x28(%r15), %rax
cmpb $0x8, 0x14(%rax)
jne 0x5fa3
movq 0x18(%rax), %rbp
jmp 0x5fa5
xorl %ebp, %ebp
movq 0x40(%r15), %r15
movq %r14, %rax
shlq $0x20, %rax
movq %rax, 0x18(%rsp)
movslq %r14d, %rax
movq %rax, 0x20(%rsp)
movb (%rbx,%rax), %al
movb %al, 0xb(%rsp)
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5f40
movl %eax, %eax
movq %r15, 0x28(%rsp)
movq 0x280(%r15,%rax,8), %rdi
movq %rbx, 0x10(%rsp)
movq %rbx, %rsi
movl %r14d, %edx
movl 0xc(%rsp), %ecx
callq 0x81fe
leaq 0x30(%rsp), %r12
testq %rax, %rax
jne 0x6080
testq %rbp, %rbp
je 0x6080
movq (%rbp), %rax
movslq 0x10(%rax), %rbx
leaq 0x1(%rbx), %r15
leal (%r15,%r14), %r13d
cmpl $0x40, %r13d
jg 0x6075
movq 0x8(%rax), %rsi
movq %r12, %rdi
callq 0x3070
movb $0x5f, 0x30(%rsp,%rbx)
leaq (%rsp,%r15), %rdi
addq $0x30, %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x3050
movslq %r13d, %rax
movb $0x0, 0x30(%rsp,%rax)
movq %r12, %rdi
xorl %esi, %esi
callq 0x5f40
movl %eax, %eax
movq 0x28(%rsp), %rcx
movq 0x280(%rcx,%rax,8), %rdi
movq %r12, %rsi
movl %r13d, %edx
movl 0xc(%rsp), %ecx
callq 0x81fe
jmp 0x6077
xorl %eax, %eax
movq 0x8(%rbp), %rbp
jmp 0x5ff7
movb 0xb(%rsp), %dil
testb %dil, %dil
je 0x60be
testq %rax, %rax
je 0x60be
cmpb $0x6, 0x14(%rax)
jne 0x60be
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq 0x18(%rsp), %rsi
addq %rcx, %rsi
sarq $0x20, %rsi
xorb $0x21, %dil
xorl %ecx, %ecx
movq 0x10(%rsp), %rdx
orb (%rdx,%rsi), %dil
cmovneq %rcx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x3130
testq %rax, %rax
je 0x6168
movq %rax, %rbp
movq %rax, 0x20(%r14)
leaq 0x8(%rsp), %r14
andq $0x0, 0x10(%r14)
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x4d6c
movq %rax, %r15
movq 0x10(%r14), %r14
movq %r14, 0x8(%rbp)
testq %r14, %r14
je 0x6185
movq 0x8(%r15), %rax
movzbl (%rax), %eax
cmpl $0x2c, %eax
je 0x6147
cmpl $0x3b, %eax
jne 0x614b
jmp 0x6179
movq 0x20(%r15), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x4d6c
movq %rax, %r15
movq 0x10(%r14), %r14
jmp 0x612f
movq 0x12001(%rip), %rsi     # 0x18170
movq %rbx, %rdi
callq 0x3070
jmp 0x6185
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_O2/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 0x61b3
xorl %eax, %eax
jmp 0x61d2
movb (%rbx), %cl
pushq $0x1
popq %rax
cmpb %cl, %bpl
je 0x61d2
cmpb $0x61, %bpl
setge %dl
addb $-0x20, %bpl
cmpb %cl, %bpl
sete %cl
testb %cl, %dl
je 0x61af
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x698b
movb (%rdx), %cl
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x19, %cl
ja 0x698b
pushq $0x1
popq %rcx
movl %ecx, %ebx
cmpl %eax, %ecx
jge 0x6987
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 0x6983
xorl %ebx, %ebx
movl %eax, %ecx
jmp 0x6946
incl %ecx
jmp 0x6946
testl %ebx, %ebx
jne 0x69a4
movl 0x28(%rdi), %ecx
leaq 0xb01b(%rip), %rax      # 0x119b0
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_O2/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 %r8, %rbp
movq %rcx, %r12
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r13
movq %r8, 0x8(%rsp)
movb (%rbx), %al
testq %r14, %r14
je 0x6a29
testb %al, %al
jne 0x6a2d
movq 0x8(%r14), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x5f40
movl %eax, %eax
movq (%r13,%rax,8), %rsi
movq %r15, %rdi
callq 0x6af7
movq %rax, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rcx
movq %rbp, %r8
movq %rbx, %r9
callq 0x6a6b
movq %rax, %r14
movq %rbp, %rax
testq %rbp, %rbp
je 0x6a24
movq 0x20(%rax), %rbp
testq %rbp, %rbp
jne 0x6a13
movq %rax, %rbp
jmp 0x69cf
testb %al, %al
je 0x6a3f
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6a2d
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdd44
// File: /workspace/github_c_makefile_star2_O2/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 0x6acd
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 0x61d9
cmpb $0x0, (%r14)
jne 0x6ae5
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 0xae0f(%rip), %rsi      # 0x118ea
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: check_element_depth
static int check_element_depth( struct element *elem, int max_depth ) {
	max_depth--;
	while( elem ) {
		if( elem->child && ( max_depth < 0 || !check_element_depth( elem->child, max_depth ) ) ) {
			return 0;
		}
		elem = elem->next;
	}
	return 1;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x6db4
movq %rbx, %rdi
callq 0x30c0
movq %rax, %r15
testq %r14, %r14
je 0x6dab
movq 0x30(%r14), %rcx
movl %r15d, %eax
testq %rcx, %rcx
je 0x6dab
movl 0x10(%rcx), %eax
addl %r15d, %eax
incl %eax
movslq %eax, %rsi
addq $0x69, %rsi
jmp 0x6db7
pushq $0x68
popq %rsi
pushq $0x1
popq %rdi
callq 0x3130
movq %rax, %r12
testq %rax, %rax
je 0x6e0a
movq %r12, %rcx
addq $0x68, %rcx
movq %rcx, 0x8(%r12)
testq %rbx, %rbx
je 0x6de8
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x787e
jmp 0x6df7
leaq 0xab24(%rip), %rax      # 0x11913
movq %rax, 0x8(%r12)
pushq $0xa
popq %rax
movl %eax, 0x10(%r12)
movq $0x1, (%r12)
movb $0x6, 0x14(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_function_body
int parse_function_body( struct function *func, struct variables *vars, char *message ) {
	struct statement prev = { 0 }, *stmt = NULL;
	struct element *next = func->body->child;
	struct expression *source;
	if( next ) {
		prev.next = NULL;
		stmt = parse_keywords_indexed( func->env->statements_index, next, func, vars, &prev, message );
		func->statements = prev.next;
	}
	if( message[ 0 ] == 0 ) {
		if( stmt && stmt->execute == execute_return_statement ) {
			source = stmt->source;
			if( source && source->evaluate == evaluate_call_expression
			&& ( ( struct function_expression * ) source )->function == func ) {
				stmt->execute = execute_tail_call_statement;
			}
		}
		return 1;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x38(%rdi), %rax
movq 0x18(%rax), %rsi
testq %rsi, %rsi
je 0x6eb3
movq %rdi, %rbx
movq %rsp, %r15
andq $0x0, 0x20(%r15)
movq 0x40(%rdi), %rdi
subq $-0x80, %rdi
movq %rbx, %rdx
movq %r15, %r8
movq %r14, %r9
callq 0x69a8
movq %rax, %rcx
movq 0x20(%r15), %rax
movq %rax, 0x58(%rbx)
xorl %eax, %eax
cmpb $0x0, (%r14)
jne 0x6ebc
pushq $0x1
popq %rax
testq %rcx, %rcx
je 0x6ebc
leaq -0x2cf0(%rip), %rdx     # 0x4194
cmpq %rdx, 0x10(%rcx)
jne 0x6ebc
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x6ebc
leaq 0x2c(%rip), %rsi        # 0x6ec6
cmpq %rsi, 0x18(%rdx)
jne 0x6ebc
cmpq %rbx, 0x20(%rdx)
jne 0x6ebc
leaq 0x17a(%rip), %rdx       # 0x7027
movq %rdx, 0x10(%rcx)
jmp 0x6ebc
xorl %eax, %eax
cmpb $0x0, (%r14)
sete %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_tail_call_statement
static enum result execute_tail_call_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	enum result ret = OKAY;
	struct expression *source = this->source, *parameter = source->parameters;
	struct function *func = ( ( struct function_expression * ) source )->function;
	int num_params = func->num_parameters, num_locals = func->num_variables;
	int idx = 0, size = sizeof( struct variable ) * num_params;
	struct variable *locals = alloca( size );
	memset( locals, 0, size );
	while( idx < num_params ) {
		ret = parameter->evaluate( parameter, vars, &locals[ idx++ ] );
		if( ret ) {
			parameter = parameter->next;
		} else {
			break;
		}
	}
	if( ret ) {
		idx = 0;
		while( idx < num_params ) {
			assign_variable( &locals[ idx ], &vars->locals[ idx ] );
			idx++;
		}
		while( idx < num_locals ) {
			dispose_variable( &vars->locals[ idx++ ] );
		}
		if( func->env->interrupted ) {
			ret = throw_interrupted( vars, source );
		} else {
			ret = AGAIN;
		}
	}
	idx = 0;
	while( idx < num_params ) {
		dispose_temporary( &locals[ idx++ ] );
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x30(%rbp)
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r14
movq %rax, -0x38(%rbp)
movq 0x20(%rax), %rax
movl 0x1c(%rax), %r15d
movq %rax, -0x40(%rbp)
movslq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movl %r15d, %eax
shll $0x4, %eax
movslq %eax, %rdx
movq %rsp, %rbx
subq %rdx, %rbx
movq %rbx, %rsp
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x30f0
testl %r15d, %r15d
cmovgl %r15d, %r12d
movq %rbx, %r13
movq %r12, %r15
subq $0x1, %r15
jb 0x70aa
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %r13, %rdx
callq *0x18(%r14)
testl %eax, %eax
je 0x710b
movq 0x10(%r14), %r14
addq $0x10, %r13
jmp 0x7088
movq %r12, %r14
shlq $0x4, %r14
xorl %r15d, %r15d
movq -0x30(%rbp), %r13
cmpq %r15, %r14
je 0x70d3
leaq (%rbx,%r15), %rdi
movq 0x10(%r13), %rsi
addq %r15, %rsi
callq 0x3996
addq $0x10, %r15
jmp 0x70b8
movq %r12, %r15
cmpq -0x48(%rbp), %r15
jge 0x70f1
incq %r15
movq 0x10(%r13), %rdi
addq %r14, %rdi
callq 0x3896
addq $0x10, %r14
jmp 0x70d6
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rax
cmpb $0x0, 0x18(%rax)
je 0x7110
movq %r13, %rdi
movq -0x38(%rbp), %rsi
callq 0x41a9
xorl %r14d, %r14d
jmp 0x7122
pushq $0x5
popq %r14
jmp 0x7122
movq %rbx, %rdi
callq 0x3988
addq $0x10, %rbx
subq $0x1, %r12
jae 0x7116
movl %r14d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_tt_program
int parse_tt_program( char *program, struct string *file, struct environment *env, char *message ) {
	int idx;
	struct string_list *list;
	struct function *init, *func;
	struct element *elem = parse_element( program, env->element_depth, message );
	if( elem ) {
		/* Create empty function for global evaluation. */
		init = new_function( "[Init]", NULL );
		if( init ) {
			init->file = file;
			file->reference_count++;
			init->env = env;
			/* Populate execution environment. */
			parse_keywords( declarations, elem, init, NULL, NULL, message );
			/* Parse function bodies. */
			for( idx = 0; idx < 32; idx++ ) {
				list = env->decls_index[ idx ];
				while( list && message[ 0 ] == 0 ) {
					if( list->str->type == FUNCTION ) {
						func = ( struct function * ) list->str;
						if( func->body ) {
							parse_function_body( func, NULL, message );
							func->body = NULL;
						}
					}
					list = list->next;
				}
			}
			unref_string( &init->str );
		}
		unref_string( &elem->str );
	}
	if( env->interrupted ) {
		strcpy( message, "Interrupted." );
	}
	return message[ 0 ] == 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movl 0x8(%rdx), %esi
movq %rcx, %rdx
callq 0x7253
testq %rax, %rax
je 0x7216
movq %rax, %r15
leaq 0xa3e3(%rip), %rdi      # 0x11552
xorl %esi, %esi
callq 0x6d74
testq %rax, %rax
je 0x720e
movq %r13, 0x28(%rax)
incq (%r13)
movq %r14, 0x40(%rax)
leaq 0x10fee(%rip), %rdi     # 0x18180
xorl %ebp, %ebp
movq %r15, 0x10(%rsp)
movq %r15, %rsi
movq %rax, 0x8(%rsp)
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x72d9
leaq 0x280(%r14), %r15
cmpq $0x20, %rbp
je 0x71ff
leaq (%r15,%rbp,8), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x71fa
cmpb $0x0, (%rbx)
jne 0x71fa
movq (%r12), %r13
cmpb $0x6, 0x14(%r13)
jne 0x71f4
cmpq $0x0, 0x38(%r13)
je 0x71f4
movq %r13, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x6e19
andq $0x0, 0x38(%r13)
addq $0x8, %r12
jmp 0x71c2
incq %rbp
jmp 0x71b8
movq 0x8(%rsp), %rdi
callq 0x38b2
movq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x38b2
cmpb $0x0, 0x18(%r14)
je 0x723c
movabsq $0x2e646574707572, %rax # imm = 0x2E646574707572
movq %rax, 0x5(%rbx)
movabsq $0x7075727265746e49, %rax # imm = 0x7075727265746E49
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x7244
xorl %eax, %eax
cmpb $0x0, (%rbx)
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_element
static struct element* parse_element( char *buffer, int max_depth, char *message ) {
	int idx;
	struct element elem;
	elem.line = 1;
	elem.str.string = NULL;
	elem.str.type = ELEMENT;
	elem.child = elem.next = NULL;
	idx = parse_child_element( buffer, 0, &elem, max_depth, message );
	if( idx > 0 ) {
		if( buffer[ idx - 1 ] != 0 ) {
			sprintf( message, "Unexpected closing bracket '%c' on line %d.", buffer[ idx - 1 ], elem.line );
			idx = -4;
		}
	}
	if( idx < 0 && elem.child ) {
		unref_string( &elem.child->str );
		elem.child = NULL;
	}
	return elem.child;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, %ecx
leaq 0x8(%rsp), %rdx
movl $0x1, 0x28(%rdx)
andq $0x0, 0x8(%rdx)
movq %rdi, %r14
movb $0x1, 0x14(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdx)
xorl %esi, %esi
movq %rbx, %r8
callq 0x83bb
testl %eax, %eax
jle 0x72b0
movl %eax, %ecx
movsbl -0x1(%r14,%rcx), %edx
testl %edx, %edx
je 0x72b0
movl 0x30(%rsp), %ecx
leaq 0xa7a2(%rip), %rsi      # 0x11a45
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3200
pushq $-0x4
popq %rax
testl %eax, %eax
sets %cl
movq 0x20(%rsp), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x72d1
movq %rax, %rdi
callq 0x38b2
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_keywords
static void parse_keywords( struct keyword *keywords, 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, keywords ), elem, func, vars, stmt, message );
		while( stmt && stmt->next ) {
			stmt = stmt->next;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r12
testq %rbp, %rbp
je 0x733c
cmpb $0x0, (%rbx)
jne 0x733c
movq 0x8(%rbp), %rdi
movq %r12, %rsi
callq 0x6af7
movq %rax, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %r13, %r8
movq %rbx, %r9
callq 0x6a6b
movq %rax, %rbp
movq %r13, %rax
testq %r13, %r13
je 0x7337
movq 0x20(%rax), %r13
testq %r13, %r13
jne 0x7326
movq %rax, %r13
jmp 0x72f6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_tt_file
int parse_tt_file( char *file_name, struct environment *env, char *message ) {
	int success = 0;
	struct string *path = ( struct string * ) new_source( strlen( file_name ) );
	if( path ) {
		strcpy( path->string, file_name );
		success = include_tt_file( path, env, message );
		unref_string( path );
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return success;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x30c0
movl %eax, %edi
callq 0x36ed
testq %rax, %rax
je 0x7398
movq %rax, %r15
movq 0x8(%rax), %rdi
movq %r12, %rsi
callq 0x3070
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x73b5
movl %eax, %ebx
movq %r15, %rdi
callq 0x38b2
movl %ebx, %eax
jmp 0x73a9
movq 0x10dd1(%rip), %rsi     # 0x18170
movq %rbx, %rdi
callq 0x3070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: include_tt_file
static int include_tt_file( struct string *path, struct environment *env, char *message ) {
	long file_length, success = 0;
	char *program_buffer, *file_name = path->string, error[ 128 ] = "";
	/* Load program file into string.*/
	file_length = load_file( file_name, NULL, 0, 0, message );
	if( file_length >= 0 ) {
		if( file_length < MAX_INTEGER ) {
			/* printf( "Parsing '%s'. Length %ld\n", file_name, file_length ); */
			program_buffer = malloc( file_length + 1 );
			if( program_buffer ) {
				file_length = load_file( file_name, program_buffer, 0, file_length, message );
				if( file_length >= 0 ) {
					program_buffer[ file_length ] = 0;
					/* Parse program structure.*/
					success = parse_tt_program( program_buffer, path, env, message );
				}
				free( program_buffer );
			} else {
				strcpy( message, OUT_OF_MEMORY );
			}
		} else {
			strcpy( message, "File too large." );
		}
	}
	if( !success && strncmp( message, "Unable to parse", 15 ) ) {
		strncpy( error, message, 127 );
		error[ 127 ] = 0;
		if( sprintf( message, "Unable to parse '%.96s'.\n%s", file_name, error ) < 0 ) {
			strcpy( message, "Unable to parse. " );
			strcat( message, error );
		}
	}
	return success;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r13
movq 0x8(%rdi), %r15
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x3788
testq %rax, %rax
js 0x7480
movq %rax, %r12
cmpq $0x7ffffffe, %rax       # imm = 0x7FFFFFFE
ja 0x745b
movq %rbp, 0x8(%rsp)
leaq 0x1(%r12), %rdi
callq 0x31b0
testq %rax, %rax
je 0x7467
movq %rax, %rbp
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r12, %rcx
movq %rbx, %r8
callq 0x3788
testq %rax, %rax
js 0x7478
movb $0x0, (%rbp,%rax)
movq %rbp, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x713a
movl %eax, %r12d
movq %rbp, %rdi
callq 0x3030
testl %r12d, %r12d
je 0x7480
pushq $0x1
popq %r14
jmp 0x74ea
movups 0xa7fe(%rip), %xmm0     # 0x11c60
movups %xmm0, (%rbx)
jmp 0x7480
movq 0x10d02(%rip), %rsi     # 0x18170
movq %rbx, %rdi
callq 0x3070
jmp 0x7480
movq %rbp, %rdi
callq 0x3030
leaq 0xa7e9(%rip), %rsi      # 0x11c70
pushq $0xf
popq %rdx
movq %rbx, %rdi
callq 0x3060
testl %eax, %eax
je 0x74ea
leaq 0x10(%rsp), %r12
pushq $0x7f
popq %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3050
movb $0x0, 0x7f(%r12)
leaq 0xa7ca(%rip), %rsi      # 0x11c80
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3200
testl %eax, %eax
jns 0x74ea
movups 0xa7c8(%rip), %xmm0     # 0x11c9c
movups %xmm0, (%rbx)
movw $0x20, 0x10(%rbx)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x31f0
movl %r14d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: initialize_globals
int initialize_globals( struct environment *env, struct variable *exception ) {
	struct string *str;
	struct string_list *list = env->globals;
	while( list ) {
		str = list->str;
		if( str->type == GLOBAL || str->type == CONST ) {
			if( initialize_global( ( struct global_variable * ) str, exception ) == EXCEPTION ) {
				return 0;
			}
		}
		list = list->next;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x380, %r15            # imm = 0x380
movq %rsp, %r12
movq (%r15), %r15
testq %r15, %r15
je 0x75a4
movq (%r15), %rbx
movb 0x14(%rbx), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x759b
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
andq $0x0, 0x20(%rsp)
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %r13
movq %rdi, 0x18(%rsp)
testq %rdi, %rdi
je 0x759b
testq %r13, %r13
je 0x7591
movq %r14, 0x8(%rsp)
leaq 0x18(%rbx), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq *0x18(%r13)
movl %eax, %ebp
movq %r13, %rdi
callq 0x3a26
andq $0x0, 0x38(%rbx)
movq 0x18(%rsp), %rdi
callq 0x38b2
andq $0x0, 0x30(%rbx)
testl %ebp, %ebp
jne 0x759b
jmp 0x75b6
callq 0x38b2
andq $0x0, 0x30(%rbx)
addq $0x8, %r15
jmp 0x751d
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x75a7
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: add_statements
int add_statements( struct keyword *statements, struct environment *env, char *message ) {
	int idx;
	struct keyword *statement;
	while( statements->name ) {
		statement = calloc( 1, sizeof( struct keyword ) );
		if( statement ) {
			memcpy( statement, statements, sizeof( struct keyword ) );
			idx = hash_code( statement->name, 0 );
			statement->next = env->statements_index[ idx ];
			env->statements_index[ idx ] = statement;
		} else {
			strcpy( message, OUT_OF_MEMORY );
			return 0;
		}
		statements++;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r12
pushq $0x1
popq %rbx
pushq $0x1
popq %r13
pushq $0x20
popq %rbp
cmpq $0x0, (%r12)
je 0x763d
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3130
testq %rax, %rax
je 0x762b
movq %rax, %r14
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq (%rax), %rdi
xorl %esi, %esi
callq 0x5f40
movl %eax, %eax
movq 0x80(%r15,%rax,8), %rcx
movq %rcx, 0x18(%r14)
movq %r14, 0x80(%r15,%rax,8)
addq $0x20, %r12
jmp 0x75d9
movq 0x10b3e(%rip), %rsi     # 0x18170
movq (%rsp), %rdi
callq 0x3070
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: add_operators
int add_operators( struct operator *operators, struct environment *env, char *message ) {
	int idx;
	struct operator *oper;
	while( operators->name ) {
		oper = new_operator( NULL, operators );
		if( oper ) {
			idx = hash_code( oper->name, 0 );
			oper->next = env->operators_index[ idx ];
			env->operators_index[ idx ] = oper;
			if( oper->name[ 0 ] == '$' && oper->name[ 1 ] > 96 ) {
				/* Add synonym. */
				oper = new_operator( &oper->name[ 1 ], oper );
				if( oper ) {
					oper->name[ 0 ] -= 32;
					idx = hash_code( oper->name, 0 );
					oper->next = env->operators_index[ idx ];
					env->operators_index[ idx ] = oper;
				} else {
					strcpy( message, OUT_OF_MEMORY );
					return 0;
				}
			}
		} else {
			strcpy( message, OUT_OF_MEMORY );
			return 0;
		}
		operators++;
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x1
popq %rbx
cmpq $0x0, (%r12)
je 0x7703
xorl %edi, %edi
movq %r12, %rsi
callq 0x770f
testq %rax, %rax
je 0x76f2
movq %rax, %r13
movq (%rax), %rdi
xorl %esi, %esi
callq 0x5f40
movl %eax, %eax
movq 0x180(%r15,%rax,8), %rcx
movq %rcx, 0x18(%r13)
movq %r13, 0x180(%r15,%rax,8)
movq (%r13), %rdi
cmpb $0x24, (%rdi)
jne 0x76e9
cmpb $0x61, 0x1(%rdi)
jl 0x76e9
incq %rdi
movq %r13, %rsi
callq 0x770f
testq %rax, %rax
je 0x76f2
movq %rax, %r13
movq (%rax), %rax
addb $-0x20, (%rax)
movq (%r13), %rdi
xorl %esi, %esi
callq 0x5f40
movl %eax, %eax
movq 0x180(%r15,%rax,8), %rcx
movq %rcx, 0x18(%r13)
movq %r13, 0x180(%r15,%rax,8)
addq $0x20, %r12
jmp 0x7663
movq 0x10a77(%rip), %rsi     # 0x18170
movq %r14, %rdi
callq 0x3070
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: new_operator
static struct operator* new_operator( char *name, struct operator *src ) {
	struct operator *oper;
	size_t size = sizeof( struct operator );
	if( name ) {
		size += sizeof( char ) * ( strlen( name ) + 1 );
	}
	oper = calloc( 1, size );
	if( oper ) {
		if( src ) {
			memcpy( oper, src, sizeof( struct operator ) );
		}
		if( name ) {
			oper->name = ( char * ) &oper[ 1 ];
			strcpy( oper->name, name );
		}
	}
	return oper;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x7730
movq %rbx, %rdi
callq 0x30c0
movq %rax, %rsi
addq $0x21, %rsi
jmp 0x7733
pushq $0x20
popq %rsi
pushq $0x1
popq %rdi
callq 0x3130
movq %rax, %r15
testq %rax, %rax
je 0x7771
testq %r14, %r14
je 0x775a
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
testq %rbx, %rbx
je 0x7771
movq %r15, %rdi
addq $0x20, %rdi
movq %rdi, (%r15)
movq %rbx, %rsi
callq 0x3070
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: initialize_environment
int initialize_environment( struct environment *env, size_t max_stack, char *message ) {
	memset( env, 0, sizeof( struct environment ) );
	env->element_depth = max_stack >> 10;
	return add_statements( statements, env, message )
		&& add_operators( operators, env, message )
		&& add_constants( constants, env, message );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x3a8, %edx            # imm = 0x3A8
xorl %esi, %esi
callq 0x30f0
shrq $0xa, %r15
movl %r15d, 0x8(%r14)
leaq 0x10a5d(%rip), %rdi     # 0x18200
movq %r14, %rsi
movq %rbx, %rdx
callq 0x75ba
testl %eax, %eax
je 0x77df
leaq 0x10d87(%rip), %rdi     # 0x18540
movq %r14, %rsi
movq %rbx, %rdx
callq 0x764e
testl %eax, %eax
je 0x77df
leaq 0x115b1(%rip), %rdi     # 0x18d80
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3e6c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: initialize_entry_point
void initialize_entry_point( struct function_expression *expr, struct function *func ) {
	func->env->stack_limit = ( size_t ) &expr - ( func->env->element_depth << 9 );
	memset( expr, 0, sizeof( struct function_expression ) );
	expr->expr.evaluate = evaluate_call_expression;
	expr->expr.line = func->line;
	expr->function = func;
}

// Assembly:
movq 0x40(%rsi), %rax
movl 0x8(%rax), %ecx
shll $0x9, %ecx
movslq %ecx, %rcx
negq %rcx
addq %rsp, %rcx
addq $-0x8, %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
andq $0x0, 0x20(%rdi)
leaq -0x951(%rip), %rax      # 0x6ec6
movq %rax, 0x18(%rdi)
movl 0x18(%rsi), %eax
movl %eax, (%rdi)
movq %rsi, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: truncate_array
static void truncate_array( struct array *arr ) {
	struct string *str;
	int idx = 0, len = arr->length;
	if( arr->string_values ) {
		while( idx < len ) {
			str = arr->string_values[ idx++ ];
			if( str ) {
				unref_string( str );
			}
		}
	}
	arr->length = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x785e
movl 0x40(%rbx), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x785e
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x7859
callq 0x38b2
incq %r15
jmp 0x7842
andl $0x0, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: dispose_local_variables
static void dispose_local_variables( struct local_variable *local ) {
	struct local_variable *next;
	while( local ) {
		next = local->next;
		free( local );
		local = next;
	}
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x787c
movq 0x18(%rdi), %rbx
callq 0x3030
movq %rbx, %rdi
jmp 0x7869
popq %rbx
retq