LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %rcx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x20(%rsp)
movq 0x38(%rdi), %rax
movq 0x18(%rax), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x74c3
movq %rsp, %r12
movq $0x0, 0x20(%r12)
movq 0x40(%r14), %rdi
subq $-0x80, %rdi
movq %r14, %rdx
movq %r12, %r8
movq %r15, %r9
callq 0x6fe6
movq 0x20(%r12), %rcx
movq %rcx, 0x58(%r14)
jmp 0x74c5
xorl %eax, %eax
cmpb $0x0, (%r15)
je 0x74d9
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x1, %ebx
testq %rax, %rax
je 0x74cb
leaq -0x31ae(%rip), %rcx     # 0x433c
cmpq %rcx, 0x10(%rax)
jne 0x74cb
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x74cb
leaq 0x19(%rip), %rdx        # 0x7519
cmpq %rdx, 0x18(%rcx)
jne 0x74cb
cmpq %r14, 0x20(%rcx)
jne 0x74cb
leaq 0x18b(%rip), %rcx       # 0x769e
movq %rcx, 0x10(%rax)
jmp 0x74cb
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r12
movq %rax, -0x40(%rbp)
movq 0x20(%rax), %rax
movslq 0x1c(%rax), %rbx
movq %rax, -0x48(%rbp)
movl 0x20(%rax), %r15d
movl %ebx, %eax
shll $0x4, %eax
movslq %eax, %rdx
movq %rsp, %rdi
subq %rdx, %rdi
movq %rdi, %rsp
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
callq 0x30f0
movq %rbx, -0x38(%rbp)
testq %rbx, %rbx
jle 0x771f
movq -0x38(%rbp), %rbx
movq -0x30(%rbp), %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq *0x18(%r12)
testl %eax, %eax
je 0x77b9
movq 0x10(%r12), %r12
addq $0x10, %r13
decq %rbx
jne 0x76fb
movq -0x38(%rbp), %r13
testl %r13d, %r13d
movl $0x0, %eax
jle 0x775b
movq %r13, %rbx
shlq $0x4, %rbx
xorl %r12d, %r12d
movq -0x30(%rbp), %r13
leaq (%r12,%r13), %rdi
movq 0x10(%r14), %rsi
addq %r12, %rsi
callq 0x3a95
addq $0x10, %r12
cmpq %r12, %rbx
jne 0x773b
movq -0x38(%rbp), %r13
movl %r13d, %eax
cmpl %r15d, %eax
jge 0x779a
movl %eax, %r12d
subq %r12, %r15
shlq $0x4, %r12
orq $0x8, %r12
movq 0x10(%r14), %rbx
movl $0x0, -0x8(%rbx,%r12)
movq (%rbx,%r12), %rdi
testq %rdi, %rdi
je 0x7791
callq 0x3979
movq $0x0, (%rbx,%r12)
addq $0x10, %r12
decq %r15
jne 0x776e
movq -0x48(%rbp), %rax
movq 0x40(%rax), %rax
cmpb $0x0, 0x18(%rax)
je 0x77c2
movq %r14, %rdi
movq -0x40(%rbp), %rsi
callq 0x4351
xorl %r14d, %r14d
jmp 0x77c8
xorl %r14d, %r14d
movq -0x38(%rbp), %r13
jmp 0x77c8
movl $0x5, %r14d
movq -0x30(%rbp), %r15
testl %r13d, %r13d
jle 0x77ef
shlq $0x4, %r13
xorl %ebx, %ebx
movq 0x8(%r15,%rbx), %rdi
testq %rdi, %rdi
je 0x77e6
callq 0x3979
addq $0x10, %rbx
cmpq %rbx, %r13
jne 0x77d7
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_O1/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
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movl 0x8(%rdx), %esi
movq %rcx, %rdx
callq 0x7906
testq %rax, %rax
je 0x78cd
movq %rax, %r15
leaq 0xacda(%rip), %rdi      # 0x1250d
xorl %esi, %esi
callq 0x73b3
testq %rax, %rax
je 0x78c5
movq %rax, %r12
movq %r13, 0x28(%rax)
incq (%r13)
movq %r14, 0x40(%rax)
leaq 0x11927(%rip), %rdi     # 0x19180
xorl %ebp, %ebp
movq %r15, (%rsp)
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x799a
movq 0x280(%r14,%rbp,8), %r15
testq %r15, %r15
je 0x78b0
cmpb $0x0, (%rbx)
jne 0x78b0
movq (%r15), %r13
cmpb $0x6, 0x14(%r13)
jne 0x78aa
cmpq $0x0, 0x38(%r13)
je 0x78aa
movq %r13, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x745e
movq $0x0, 0x38(%r13)
movq 0x8(%r15), %r15
jmp 0x787a
incq %rbp
cmpq $0x20, %rbp
jne 0x7872
movq %r12, %rdi
callq 0x3979
movq (%rsp), %r15
movq %r15, %rdi
callq 0x3979
cmpb $0x0, 0x18(%r14)
je 0x78ef
movabsq $0x2e646574707572, %rax # imm = 0x2E646574707572
movq %rax, 0x5(%rbx)
movabsq $0x7075727265746e49, %rax # imm = 0x7075727265746E49
movq %rax, (%rbx)
xorl %eax, %eax
cmpb $0x0, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_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
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
movl $0x1, 0x28(%rdx)
movq $0x0, 0x8(%rdx)
movb $0x1, 0x14(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdx)
xorl %esi, %esi
movq %rbx, %r8
callq 0x8c3a
testl %eax, %eax
jle 0x7968
movl %eax, %ecx
movsbl -0x1(%r14,%rcx), %edx
testl %edx, %edx
je 0x7968
movl 0x30(%rsp), %ecx
leaq 0xb0ad(%rip), %rsi      # 0x12a06
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3200
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
testl %eax, %eax
sets %al
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x798d
callq 0x3979
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
testq %rsi, %rsi
je 0x7a28
movq %r9, %rbx
movq %r8, %r13
movq %rsi, %rbp
movq %rdi, %r14
cmpb $0x0, (%rbx)
jne 0x7a28
movq %r14, %r12
testq %r14, %r14
je 0x79f1
movq 0x8(%rbp), %r15
movq %r14, %r12
movq (%r12), %rsi
movq %r15, %rdi
callq 0x66af
testl %eax, %eax
jne 0x79f1
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x79d7
movq %r12, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r13, %r8
movq %rbx, %r9
callq 0x70e9
movq %rax, %rbp
movq %r13, %rax
testq %r13, %r13
je 0x7a20
movq 0x20(%rax), %r13
testq %r13, %r13
jne 0x7a0f
movq %rax, %r13
testq %rbp, %rbp
jne 0x79c3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_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 %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x30c0
movq %rax, %r13
movslq %r13d, %rdi
addq $0x21, %rdi
callq 0x31b0
testq %rax, %rax
je 0x7aad
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq %rax, %rdi
addq $0x20, %rdi
movq %rdi, 0x8(%rax)
movq $0x1, (%rax)
movl %r13d, 0x10(%rax)
movb $0x8, 0x14(%rax)
movq %r15, %rsi
callq 0x3070
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7ac8
movl %eax, %ebx
movq %r12, %rdi
callq 0x3979
movl %ebx, %eax
jmp 0x7abe
movq 0x116bc(%rip), %rsi     # 0x19170
movq %rbx, %rdi
callq 0x3070
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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), %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x383d
testq %rax, %rax
js 0x7bb1
movq %rax, %r12
cmpq $0x7ffffffe, %rax       # imm = 0x7FFFFFFE
jg 0x7b93
movq %rbp, 0x8(%rsp)
leaq 0x1(%r12), %rdi
callq 0x31b0
testq %rax, %rax
je 0x7b9f
movq %rax, %rbp
xorl %r15d, %r15d
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r12, %rcx
movq %rbx, %r8
callq 0x383d
testq %rax, %rax
js 0x7b89
movb $0x0, (%rbp,%rax)
movq %rbp, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x7801
movl %eax, %r15d
movq %rbp, %rdi
callq 0x3030
jmp 0x7bb1
movups 0xb08a(%rip), %xmm0     # 0x12c24
movups %xmm0, (%rbx)
jmp 0x7bae
movq 0x115ca(%rip), %rsi     # 0x19170
movq %rbx, %rdi
callq 0x3070
xorl %r15d, %r15d
testq %r15, %r15
je 0x7bcb
movl %r15d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb062(%rip), %rsi      # 0x12c34
movl $0xf, %edx
movq %rbx, %rdi
callq 0x3060
testl %eax, %eax
je 0x7bb6
leaq 0x10(%rsp), %r12
movl $0x7f, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3050
movb $0x0, 0x7f(%r12)
leaq 0xb03f(%rip), %rsi      # 0x12c44
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3200
testl %eax, %eax
jns 0x7bb6
movups 0xb040(%rip), %xmm0     # 0x12c60
movups %xmm0, (%rbx)
movw $0x20, 0x10(%rbx)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x31f0
jmp 0x7bb6
// File: /workspace/github_c_makefile_star2_O1/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 0x380(%rdi), %r12
testq %r12, %r12
je 0x7cf1
movq %rsi, %rbx
movq %rsp, %r14
movq (%r12), %r13
movb 0x14(%r13), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x7ce3
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%r13), %rax
movq 0x38(%r13), %r15
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x7ce3
testq %r15, %r15
je 0x7cd1
movq %rbx, 0x8(%rsp)
leaq 0x18(%r13), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *0x18(%r15)
movl %eax, %ebp
movq %r15, %rdi
callq 0x3b29
xorl %r15d, %r15d
movq %r15, 0x38(%r13)
movq 0x18(%rsp), %rdi
callq 0x3979
movq %r15, 0x30(%r13)
testl %ebp, %ebp
jne 0x7ce3
jmp 0x7cf7
movq 0x18(%rsp), %rdi
callq 0x3979
movq $0x0, 0x30(%r13)
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x7c5f
movl $0x1, %r15d
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: 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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %ebx
cmpq $0x0, (%rdi)
je 0x7dab
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x1, %edi
movl $0x20, %esi
callq 0x3130
testq %rax, %rax
je 0x7d9a
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq (%rax), %rdx
movb (%rdx), %sil
testb %sil, %sil
je 0x7d75
incq %rdx
xorl %ecx, %ecx
movzbl %sil, %esi
xorl %esi, %ecx
movb (%rdx), %sil
incq %rdx
testb %sil, %sil
jne 0x7d5f
andl $0x1f, %ecx
jmp 0x7d77
xorl %ecx, %ecx
movq 0x80(%r15,%rcx,8), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x80(%r15,%rcx,8)
cmpq $0x0, 0x20(%r12)
leaq 0x20(%r12), %r12
jne 0x7d29
jmp 0x7dab
movq 0x113cf(%rip), %rsi     # 0x19170
movq %r14, %rdi
callq 0x3070
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %ebx
cmpq $0x0, (%rdi)
je 0x7efc
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, (%rsp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x3130
testq %rax, %rax
je 0x7eea
movq %rax, %r13
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq (%rax), %rbp
movb (%rbp), %cl
testb %cl, %cl
je 0x7e2d
leaq 0x1(%rbp), %rdx
xorl %eax, %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x7e1a
andl $0x1f, %eax
jmp 0x7e2f
xorl %eax, %eax
movq 0x180(%r15,%rax,8), %rcx
movq %rcx, 0x18(%r13)
movq %r13, 0x180(%r15,%rax,8)
cmpb $0x24, (%rbp)
jne 0x7ed7
cmpb $0x61, 0x1(%rbp)
jl 0x7ed7
incq %rbp
movq %rbp, %rdi
callq 0x30c0
leaq 0x21(%rax), %rsi
movl $0x1, %edi
callq 0x3130
testq %rax, %rax
je 0x7eea
movq %rax, %r14
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
leaq 0x20(%rax), %rdi
movq %rdi, (%rax)
movq %rbp, %rsi
callq 0x3070
movb 0x20(%r14), %cl
addb $-0x20, %cl
movb %cl, 0x20(%r14)
je 0x7ec1
movq %r14, %rdx
addq $0x21, %rdx
xorl %eax, %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x7eae
andl $0x1f, %eax
jmp 0x7ec3
xorl %eax, %eax
movq 0x180(%r15,%rax,8), %rcx
movq %rcx, 0x18(%r14)
movq %r14, 0x180(%r15,%rax,8)
cmpq $0x0, 0x20(%r12)
leaq 0x20(%r12), %r12
jne 0x7ddd
jmp 0x7efc
movq 0x1127f(%rip), %rsi     # 0x19170
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_O1/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 0x112ca(%rip), %rdi     # 0x19200
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7d09
testl %eax, %eax
je 0x7f72
leaq 0x115f4(%rip), %rdi     # 0x19540
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7db9
testl %eax, %eax
je 0x7f72
leaq 0x11e1e(%rip), %rdi     # 0x19d80
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3fbb
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, -0x8(%rsp)
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)
movq $0x0, 0x20(%rdi)
leaq -0xa99(%rip), %rax      # 0x7519
movq %rax, 0x18(%rdi)
movl 0x18(%rsi), %eax
movl %eax, (%rdi)
movq %rsi, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl 0x40(%rdi), %eax
cmpq $0x0, 0x20(%rdi)
setne %cl
testl %eax, %eax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x7fff
movl %eax, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x7ff7
callq 0x3979
incq %r15
cmpq %r15, %r14
jne 0x7fe5
movl $0x0, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: qualify_name
static int qualify_name( struct function *func, char *name, int len, char *output ) {
	int llen = 0, qlen = len;
	if( func && func->library ) {
		llen = func->library->length;
		qlen = llen + 1 + len;
	}
	if( output ) {
		if( llen ) {
			strncpy( output, func->library->string, llen );
			output[ llen++ ] = '_';
		}
		strncpy( &output[ llen ], name, len );
		output[ qlen ] = 0;
	}
	return qlen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, %r14
xorl %r13d, %r13d
testq %rdi, %rdi
je 0x8040
movq 0x30(%rdi), %rax
movl %r15d, %ebp
testq %rax, %rax
je 0x8043
movl 0x10(%rax), %r13d
leal (%r15,%r13), %ebp
incl %ebp
jmp 0x8043
movl %r15d, %ebp
testq %rbx, %rbx
je 0x8087
testl %r13d, %r13d
je 0x8070
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rsi
movslq %r13d, %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3050
incl %r13d
movb $0x5f, (%rbx,%r12)
movslq %r13d, %rdi
jmp 0x8072
xorl %edi, %edi
addq %rbx, %rdi
movslq %r15d, %rdx
movq %r14, %rsi
callq 0x3050
movslq %ebp, %rax
movb $0x0, (%rbx,%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: append_string_list
static struct string_list* append_string_list( struct string_list **head, struct string_list **tail, struct string *value ) {
	struct string_list *list = new_string_list( value, NULL );
	if( list ) {
		if( *head ) {
			( *tail )->next = list;
		} else {
			*head = list;
		}
		*tail = list;
	}
	return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x31b0
testq %rax, %rax
je 0x80d6
movq %r15, (%rax)
incq (%r15)
movq $0x0, 0x8(%rax)
cmpq $0x0, (%r14)
je 0x80d0
movq (%rbx), %r14
addq $0x8, %r14
movq %rax, (%r14)
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: unquote_string
static int unquote_string( char *string, char *output, char quote ) {
	int chr, offset = 0, length = 0;
	if( string ) {
		chr = string[ offset++ ];
		while( chr ) {
			if( chr == '\\' && string[ offset ] ) {
				chr = string[ offset++ ];
				if( chr >= '0' && chr <= '7' ) {
					chr = chr - '0';
					if( string[ offset ] >= '0' && string[ offset ] <= '7' ) {
						chr = ( chr << 3 ) | ( string[ offset++ ] - '0' );
						if( string[ offset ] >= '0' && string[ offset ] <= '7' ) {
							chr = ( chr << 3 ) | ( string[ offset++ ] - '0' );
						}
					}
				} else if( chr == 'n' ) {
					chr = '\n';
				} else if( chr == 'r' ) {
					chr = '\r';
				} else if( chr == 't' ) {
					chr = '\t';
				}
				if( output ) {
					output[ length++ ] = chr;
				} else {
					length++;
				}
			} else if( chr != quote ) {
				if( output ) {
					output[ length++ ] = chr;
				} else {
					length++;
				}
			}
			chr = string[ offset++ ];
		}
		if( output ) {
			output[ length ] = 0;
		}
	}
	return length;
}

// Assembly:
testq %rdi, %rdi
je 0x81f2
pushq %rbp
pushq %rbx
xorl %eax, %eax
movl $0x1, %r10d
movl $0x9, %ecx
movq %rdi, %r11
movzbl (%r11), %r9d
cmpl $0x5c, %r9d
je 0x810b
testl %r9d, %r9d
jne 0x816b
jmp 0x81e3
movslq %r10d, %r11
movsbl (%rdi,%r11), %r8d
testl %r8d, %r8d
je 0x816b
leaq 0x1(%r11), %r9
movl %r8d, %ebx
andb $-0x8, %bl
cmpb $0x30, %bl
jne 0x8189
addl $-0x30, %r8d
movb (%rdi,%r9), %bl
movl %ebx, %ebp
andb $-0x8, %bpl
cmpb $0x30, %bpl
jne 0x81ba
addb $-0x30, %bl
movzbl %bl, %r9d
leal (%r9,%r8,8), %r8d
movb 0x2(%rdi,%r11), %r9b
movl %r9d, %ebx
andb $-0x8, %bl
cmpb $0x30, %bl
jne 0x81b3
addl $0x3, %r10d
addb $-0x30, %r9b
movzbl %r9b, %r9d
leal (%r9,%r8,8), %r8d
movl %r10d, %r9d
jmp 0x81ba
cmpb %dl, %r9b
jne 0x8175
movl %r10d, %r9d
jmp 0x81cc
leal 0x1(%rax), %r8d
testq %rsi, %rsi
je 0x8184
cltq
movb %r9b, (%rsi,%rax)
movl %r10d, %r9d
jmp 0x81cf
cmpb $0x6e, %r8b
je 0x81a1
movzbl %r8b, %r10d
cmpl $0x72, %r10d
jne 0x81a9
movl $0xd, %r8d
jmp 0x81ba
movl $0xa, %r8d
jmp 0x81ba
cmpb $0x74, %r8b
cmovel %ecx, %r8d
jmp 0x81ba
addq $0x2, %r11
movl %r11d, %r9d
testq %rsi, %rsi
je 0x81ca
movslq %eax, %r10
incl %eax
movb %r8b, (%rsi,%r10)
jmp 0x81cc
incl %eax
movl %eax, %r8d
movslq %r9d, %r11
incl %r9d
addq %rdi, %r11
movl %r9d, %r10d
movl %r8d, %eax
jmp 0x80f7
testq %rsi, %rsi
popq %rbx
popq %rbp
je 0x81f1
movslq %eax, %rcx
movb $0x0, (%rsi,%rcx)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: new_string_literal_expression
static struct expression* new_string_literal_expression( number number_value,
	struct string *string_value, int line, char *message ) {
	struct expression *expr = calloc( 1, sizeof( struct value_expression ) );
	if( expr ) {
		expr->line = line;
		expr->index = ( long_int ) number_value;
		( ( struct value_expression * ) expr )->num = number_value;
		( ( struct value_expression * ) expr )->str = string_value;
		expr->evaluate = evaluate_string_literal_expression;
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return expr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movl $0x1, %edi
movl $0x30, %esi
callq 0x3130
movq %rax, %rbx
testq %rax, %rax
je 0x8236
movl %ebp, (%rbx)
xorl %eax, %eax
movl %eax, 0x4(%rbx)
movl %eax, 0x28(%rbx)
movq %r14, 0x20(%rbx)
leaq -0x475b(%rip), %rax     # 0x3ad5
movq %rax, 0x18(%rbx)
jmp 0x8245
movq 0x10f33(%rip), %rsi     # 0x19170
movq %r15, %rdi
callq 0x3070
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: copy_element
static struct element* copy_element( struct element *source ) {
	struct element *elem = NULL, *prev = NULL, *head = NULL;
	while( source ) {
		elem = new_element( source->str.length );
		if( elem ) {
			elem->line = source->line;
			if( prev ) {
				prev->next = elem;
			}
			prev = elem;
			if( head == NULL ) {
				head = elem;
			}
			memcpy( elem->str.string, source->str.string, sizeof( char ) * elem->str.length );
			if( source->child ) {
				elem->child = copy_element( source->child );
				if( elem->child ) {
					source = source->next;
				} else {
					source = elem = NULL;
				}
			} else {
				source = source->next;
			}
		} else {
			source = NULL;
		}
	}
	if( elem == NULL && head ) {
		unref_string( &head->str );
		head = NULL;
	}
	return head;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x82e9
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
movl 0x10(%r14), %edi
callq 0x36a0
movb $0x1, %bpl
testq %rax, %rax
je 0x82ce
movq %rax, %rbx
movq %rax, %r15
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
testq %r13, %r13
je 0x8297
movq %r15, 0x20(%r13)
testq %r12, %r12
cmovneq %r12, %rbx
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
movslq 0x10(%r15), %rdx
callq 0x3180
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x82c6
callq 0x8253
movq %rax, 0x18(%r15)
testq %rax, %rax
je 0x82d9
movq 0x20(%r14), %r14
xorl %ebp, %ebp
jmp 0x82dc
xorl %r14d, %r14d
movq %r13, %r15
movq %r12, %rbx
jmp 0x82dc
xorl %r14d, %r14d
movq %rbx, %r12
movq %r15, %r13
testq %r14, %r14
jne 0x8270
jmp 0x82ee
movb $0x1, %bpl
xorl %ebx, %ebx
testb %bpl, %bpl
je 0x8302
testq %rbx, %rbx
je 0x8302
movq %rbx, %rdi
callq 0x3979
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_expressions
static struct element* parse_expressions( struct element *elem, struct function *func,
	struct variables *vars, char terminator, struct expression *prev, int *num_exprs, char *message ) {
	int line, count = 0;
	while( elem && elem->str.string[ 0 ] != terminator && message[ 0 ] == 0 ) {
		elem = parse_expression( elem, func, vars, prev, message );
		prev = prev->next;
		count++;
		while( elem && message[ 0 ] == 0 && elem->str.string[ 0 ] == ',' ) {
			line = elem->line;
			elem = elem->next;
			if( elem && elem->str.string[ 0 ] != ',' ) {
				elem = parse_expression( elem, func, vars, prev, message );
				prev = prev->next;
				count++;
			} else {
				sprintf( message, "Expected expression after ',' on line %d.", line );
			}
		}
	}
	if( num_exprs ) {
		*num_exprs = count;
	}
	return elem;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq %rdi, %r14
testq %rdi, %rdi
je 0x83e6
movq %r8, %r15
movq %rdx, %r12
movq %rsi, %r13
movq 0x50(%rsp), %rbx
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movl 0xc(%rsp), %ecx
cmpb %cl, (%rax)
je 0x83e8
cmpb $0x0, (%rbx)
jne 0x83e8
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x4f9b
movq %rax, %r14
movq 0x10(%r15), %r15
incl %ebp
testq %rax, %rax
je 0x83db
cmpb $0x0, (%rbx)
jne 0x83db
movq 0x8(%r14), %rax
cmpb $0x2c, (%rax)
jne 0x83db
movl 0x28(%r14), %edx
movq 0x20(%r14), %r14
testq %r14, %r14
je 0x83a6
movq 0x8(%r14), %rax
cmpb $0x2c, (%rax)
jne 0x83b9
movq %rbx, %rdi
leaq 0xa205(%rip), %rsi      # 0x125b5
xorl %eax, %eax
callq 0x3200
jmp 0x83d6
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x4f9b
movq %rax, %r14
movq 0x10(%r15), %r15
incl %ebp
testq %r14, %r14
jne 0x8382
testq %r14, %r14
jne 0x8347
jmp 0x83e8
xorl %ebp, %ebp
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x83f4
movl %ebp, (%rax)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_refcall_expression
static enum result evaluate_refcall_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct function_expression expr = { 0 };
	struct variable func = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &func );
	if( ret ) {
		if( func.string_value && func.string_value->type == FUNCTION ) {
			expr.expr.line = this->line;
			expr.function = ( struct function * ) func.string_value;
			if( expr.function->num_parameters == this->index ) {
				expr.expr.parameters = parameter->next;
				ret = evaluate_call_expression( &expr.expr, vars, result );
			} else {
				ret = throw( vars, this, this->index, "Incorrect number of parameters to function." );
			}
		} else {
			ret = throw( vars, this, func.number_value, "Not a function reference." );
		}
		dispose_temporary( &func );
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %r12
movq %r12, %rdi
callq *0x18(%r12)
testl %eax, %eax
je 0x84c1
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x8499
cmpb $0x6, 0x14(%rax)
jne 0x8499
movl (%r14), %ecx
movl %ecx, 0x10(%rsp)
movq %rax, 0x30(%rsp)
movl 0x4(%r14), %edx
cmpl %edx, 0x1c(%rax)
jne 0x84d1
movq 0x10(%r12), %rax
leaq 0x10(%rsp), %rdi
movq %rax, 0x8(%rdi)
movq %rbx, %rsi
movq %r15, %rdx
callq 0x7519
movl %eax, %ebx
jmp 0x84b0
movl (%rsp), %edx
leaq 0xa23f(%rip), %rcx      # 0x126e2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3cc3
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x84c3
callq 0x3979
jmp 0x84c3
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xa1de(%rip), %rcx      # 0x126b6
jmp 0x84a3
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: field_end
static char* field_end( char *str, char *terminators ) {
	char mask = 0, *end = terminators;
	while( *end ) {
		mask |= *end++;
	}
	end = str;
	mask = ~mask;
	while( *end & mask || ( *end && !strchr( terminators, *end ) ) ) {
		end++;
	}
	return end;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %al
testb %al, %al
je 0x8501
leaq 0x1(%r14), %rcx
xorl %ebp, %ebp
orb %al, %bpl
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x84f0
notb %bpl
jmp 0x8504
movb $-0x1, %bpl
movsbl (%rbx), %esi
testb %bpl, %sil
jne 0x851e
testb %sil, %sil
je 0x8523
movq %r14, %rdi
callq 0x30d0
testq %rax, %rax
jne 0x8523
incq %rbx
jmp 0x8504
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: get_string_list_index
static int get_string_list_index( struct string_list *list, char *value ) {
	int idx = 0;
	while( list && strcmp( list->str->string, value ) ) {
		idx++;
		list = list->next;
	}
	if( list == NULL ) {
		idx = -1;
	}
	return idx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x8566
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x3140
testl %eax, %eax
je 0x8564
incl %ebp
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x8544
jmp 0x8566
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_member_expression
static struct element* parse_member_expression( struct structure *struc, struct expression *this,
	char *memb, struct element *elem, struct function *func, struct variables *vars, struct expression *prev, char *message ) {
	struct element *next = elem->next;
	struct expression *expr;
	int idx;
	if( struc ) {
		idx = get_string_list_index( struc->fields, memb );
		if( idx >= 0 ) {
			expr = calloc( 1, sizeof( struct value_expression ) );
			if( expr ) {
				prev->next = expr;
				( ( struct value_expression * ) expr )->str = &struc->str;
				expr->index = idx;
				expr->line = elem->line;
				expr->parameters = this;
				expr->evaluate = evaluate_member_expression;
			} else {
				strcpy( message, OUT_OF_MEMORY );
			}
		} else {
			sprintf( message, "Field not declared in expression '%.64s' on line %d.", elem->str.string, elem->line );
		}
	} else {
		sprintf( message, "Expression '%.64s' has no associated structure on line %d.", elem->str.string, elem->line );
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %rcx, %r15
movq 0x20(%rcx), %rbx
testq %rdi, %rdi
je 0x8718
movq %r8, %r13
movq %rsi, %r12
movq %rdi, %rbp
movq %rbx, (%rsp)
movq 0x20(%rdi), %rdi
movq %rdx, %rsi
callq 0x852b
testl %eax, %eax
js 0x8733
movl %eax, %ebx
movl $0x1, %edi
movl $0x30, %esi
callq 0x3130
testq %rax, %rax
je 0x874e
movq %rax, 0x10(%r13)
movq %rbp, 0x20(%rax)
movl %ebx, 0x4(%rax)
movl 0x28(%r15), %ecx
movl %ecx, (%rax)
movq %r12, 0x8(%rax)
leaq 0x263(%rip), %rcx       # 0x8975
movq %rcx, 0x18(%rax)
jmp 0x875d
movq 0x8(%r15), %rdx
movl 0x28(%r15), %ecx
leaq 0xa0ac(%rip), %rsi      # 0x127d3
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x8761
movq 0x8(%r15), %rdx
movl 0x28(%r15), %ecx
leaq 0xa05c(%rip), %rsi      # 0x1279e
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x875d
movq 0x10a1b(%rip), %rsi     # 0x19170
movq %r14, %rdi
callq 0x3070
movq (%rsp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_member_expression
static enum result evaluate_member_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct array *arr;
	struct variable obj = { 0, NULL };
	struct expression *parameter = this->parameters;
	struct structure *struc = ( struct structure * ) ( ( struct value_expression * ) this )->str;
	enum result ret = parameter->evaluate( parameter, vars, &obj );
	if( ret ) {
		ret = is_instance( &obj, struc, vars, this );
		if( ret ) {
			arr = ( struct array * ) obj.string_value;
			result->number_value = arr->number_values[ this->index ];
			if( arr->string_values && arr->string_values[ this->index ] ) {
				result->string_value = arr->string_values[ this->index ];
				result->string_value->reference_count++;
			}
		}
		dispose_temporary( &obj );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
movq 0x20(%r14), %r12
callq *0x18(%rdi)
testl %eax, %eax
je 0x89f5
movq %rsp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x43d7
movl %eax, %ebp
testl %eax, %eax
je 0x89e4
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rdx
movslq 0x4(%r14), %rax
movl (%rdx,%rax,4), %edx
movl %edx, (%rbx)
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x89e4
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x89e4
movq %rax, 0x8(%rbx)
incq (%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x89f7
callq 0x3979
jmp 0x89f7
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: get_decl
static struct string* get_decl( struct string_list *list, char *name, int len, enum reference_type type ) {
	while( list && ( list->str->length != len || strncmp( list->str->string, name, len ) ) ) {
		list = list->next;
	}
	if( list && ( !type || ( enum reference_type ) list->str->type == type ) ) {
		return list->str;
	}
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8a7b
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movslq %edx, %r13
movq (%r12), %r14
cmpl %ebp, 0x10(%r14)
jne 0x8a71
movq 0x8(%r14), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3060
testl %eax, %eax
je 0x8a90
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x8a54
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebx, %ebx
je 0x8a7e
movsbl 0x14(%r14), %eax
cmpl %ebx, %eax
jne 0x8a7b
jmp 0x8a7e
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: new_local_variable
static struct local_variable* new_local_variable( struct function *func, struct element *name, struct structure *type, char *message ) {
	struct local_variable *local = NULL;
	if( func->num_variables >= 128 ) {
		sprintf( message, "Too many local variables in function '%.64s' on line %d.", func->str.string, func->line );
	} else if( validate_local( &name->str, name->line, func->env, message ) ) {
		local = malloc( sizeof( struct local_variable ) + sizeof( char ) * ( name->str.length + 1 ) );
		if( local ) {
			local->index = func->num_variables;
			local->name = ( char * ) &local[ 1 ];
			strcpy( local->name, name->str.string );
			local->type = type;
			local->next = NULL;
		} else {
			strcpy( message, OUT_OF_MEMORY );
		}
	}
	return local;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdi, %r13
cmpl $0x80, 0x20(%rdi)
jl 0x8ad5
movq 0x8(%r13), %rdx
movl 0x18(%r13), %ecx
leaq 0x9e72(%rip), %rsi      # 0x12938
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x8b43
movq %rdx, %rbx
movq %rsi, %r12
movl 0x28(%rsi), %esi
movq 0x40(%r13), %rdx
movq %r12, %rdi
movq %r14, %rcx
callq 0x8b50
testl %eax, %eax
je 0x8b40
movslq 0x10(%r12), %rdi
addq $0x21, %rdi
callq 0x31b0
testq %rax, %rax
je 0x8b31
movq %rax, %r15
movl 0x20(%r13), %eax
movl %eax, (%r15)
movq %r15, %rdi
addq $0x20, %rdi
movq %rdi, 0x8(%r15)
movq 0x8(%r12), %rsi
callq 0x3070
movq %rbx, 0x10(%r15)
movq $0x0, 0x18(%r15)
jmp 0x8b43
movq 0x10638(%rip), %rsi     # 0x19170
movq %r14, %rdi
callq 0x3070
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: validate_local
static int validate_local( struct string *decl, int line, struct environment *env, char *message ) {
	int hash = hash_code( decl->string, 0 );
	if( decl->length > 64 ) {
		sprintf( message, "Invalid name '%.64s' on line %d.", decl->string, line );
	} else if( get_keyword( decl->string, declarations )
	|| get_keyword( decl->string, env->statements_index[ hash ] )
	|| get_operator( decl->string, env->operators_index[ hash ] ) ) {
		sprintf( message, "Name '%.64s' already defined on line %d.", decl->string, line );
	} else {
		return hash + 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq 0x8(%rdi), %r14
movb (%r14), %al
testb %al, %al
je 0x8b87
leaq 0x1(%r14), %rcx
xorl %ebx, %ebx
movzbl %al, %eax
xorl %eax, %ebx
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x8b74
andl $0x1f, %ebx
jmp 0x8b89
xorl %ebx, %ebx
cmpl $0x40, 0x10(%rdi)
jle 0x8b98
leaq 0x9ddb(%rip), %rsi      # 0x12971
jmp 0x8bc3
leaq 0x105e1(%rip), %r13     # 0x19180
movq (%r13), %rsi
movq %r14, %rdi
callq 0x66af
testl %eax, %eax
jne 0x8bbc
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x8b9f
testl %eax, %eax
je 0x8be5
leaq 0x9dcf(%rip), %rsi      # 0x12992
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3200
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %eax
movq %rax, (%rsp)
movq 0x80(%r12,%rax,8), %r13
testq %r13, %r13
je 0x8c0e
movq (%r13), %rsi
movq %r14, %rdi
callq 0x66af
testl %eax, %eax
jne 0x8bbc
movq 0x18(%r13), %r13
jmp 0x8bf3
movq (%rsp), %rax
movq 0x180(%r12,%rax,8), %r12
testq %r12, %r12
je 0x8c36
movq (%r12), %rdi
movq %r14, %rsi
callq 0x3140
testl %eax, %eax
je 0x8bbc
movq 0x18(%r12), %r12
jmp 0x8c1a
incl %ebx
jmp 0x8bd4
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_string
static int parse_string( char *input, int idx, char *output, int line, char *message ) {
	int offset = idx;
	char chr = input[ idx++ ];
	if( chr == '"' ) {
		while( ( chr & 0x7F ) >= 32 ) {
			chr = input[ idx++ ];
			if( chr == '\\' ) {
				chr = input[ idx++ ];
			} else if( chr == '"' ) {
				break;
			}
		}
		if( chr == '"' ) {
			if( output ) {
				memcpy( output, &input[ offset ], sizeof( char ) * ( idx - offset ) );
			}
		} else {
			sprintf( message, "Unclosed string on line %d.", line );
			idx = -3;
		}
	} else {
		sprintf( message, "Expected '\"' on line %d.", line );
		idx = -3;
	}
	return idx;
}

// Assembly:
pushq %rbx
movslq %esi, %rbx
cmpb $0x22, (%rdi,%rbx)
jne 0x8fc8
leaq (%rdi,%rbx), %rax
incl %ebx
movslq %ebx, %r10
movzbl (%rdi,%r10), %r9d
incq %r10
cmpl $0x5c, %r9d
je 0x8f99
movl %r10d, %ebx
cmpl $0x22, %r9d
jne 0x8fa0
jmp 0x8fa6
addl $0x2, %ebx
movb (%rdi,%r10), %r9b
testb $0x60, %r9b
jne 0x8f7d
cmpb $0x22, %r9b
jne 0x8fd1
testq %rdx, %rdx
je 0x8fe9
movl %ebx, %ecx
subl %esi, %ecx
movslq %ecx, %rcx
movq %rdx, %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0x3180
jmp 0x8fe9
leaq 0x9ad3(%rip), %rsi      # 0x12aa2
jmp 0x8fd8
leaq 0x9aae(%rip), %rsi      # 0x12a86
movq %r8, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x3200
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: parse_import
static struct element* parse_import( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next, *name = next;
	struct string *library = get_decl_indexed( func, name->str.string, name->str.length, LIBRARY );
	if( library ) {
		next = next->next->next->next->next;
	} else {
		next = parse_include( next->next, func, vars, prev, message );
		library = get_decl_indexed( func, name->str.string, name->str.length, LIBRARY );
	}
	if( message[ 0 ] == 0 ) {
		if( library ) {
			import_library( library, func->file, message );
		} else {
			sprintf( message, "Library '%.32s' not found in file %.64s on line %d.\n", name->str.string, name->next->next->str.string, elem->line );
		}
	}
	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %r13
movq 0x8(%r13), %rsi
movl 0x10(%r13), %edx
movq %r15, %rdi
movl $0x7, %ecx
callq 0x8a06
movq 0x20(%r13), %rdi
testq %rax, %rax
je 0x902f
movq 0x20(%rdi), %rcx
movq 0x20(%rcx), %rcx
movq 0x20(%rcx), %r12
jmp 0x9052
movq %r15, %rsi
movq %rbx, %r8
callq 0x909f
movq %rax, %r12
movq 0x8(%r13), %rsi
movl 0x10(%r13), %edx
movq %r15, %rdi
movl $0x7, %ecx
callq 0x8a06
cmpb $0x0, (%rbx)
jne 0x9092
testq %rax, %rax
je 0x906d
movq 0x28(%r15), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x942f
jmp 0x9092
movq 0x8(%r13), %rdx
movq 0x20(%r13), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rcx
movl 0x28(%r14), %r8d
leaq 0x9a5a(%rip), %rsi      # 0x12ae2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3200
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq