LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: check_element_depth
static int check_element_depth( struct element *elem, int max_depth ) {
	max_depth--;
	while( elem ) {
		if( elem->child && ( max_depth < 0 || !check_element_depth( elem->child, max_depth ) ) ) {
			return 0;
		}
		elem = elem->next;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7261
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %ebp
xorl %r15d, %r15d
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x7258
testl %ebx, %ebx
jle 0x7267
movl %ebp, %esi
callq 0x7229
testl %eax, %eax
je 0x7267
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x7240
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: new_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
testq %rdi, %rdi
je 0x72dd
movq %rsi, %r14
movq %rdi, %rbx
callq 0x30c0
movq %rax, %r12
testq %r14, %r14
je 0x72a9
movq 0x30(%r14), %rcx
movl %r12d, %eax
testq %rcx, %rcx
je 0x72a9
movl 0x10(%rcx), %eax
addl %r12d, %eax
incl %eax
movslq %eax, %rsi
addq $0x69, %rsi
movl $0x1, %edi
callq 0x3130
testq %rax, %rax
je 0x7316
movq %rax, %r15
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, 0x8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x7e86
jmp 0x7304
movl $0x1, %edi
movl $0x68, %esi
callq 0x3130
testq %rax, %rax
je 0x7316
movq %rax, %r15
leaq 0xb5d8(%rip), %rax      # 0x128d3
movq %rax, 0x8(%r15)
movl $0xa, %eax
movl %eax, 0x10(%r15)
movq $0x1, (%r15)
movb $0x6, 0x14(%r15)
jmp 0x7319
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_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 0x73c7
movq %rdi, %rbx
movq %rsp, %r15
movq $0x0, 0x20(%r15)
movq 0x40(%rdi), %rdi
subq $-0x80, %rdi
movq %rbx, %rdx
movq %r15, %r8
movq %r14, %r9
callq 0x6e94
movq %rax, %rcx
movq 0x20(%r15), %rax
movq %rax, 0x58(%rbx)
xorl %eax, %eax
cmpb $0x0, (%r14)
jne 0x73d0
movl $0x1, %eax
testq %rcx, %rcx
je 0x73d0
leaq -0x308d(%rip), %rdx     # 0x430b
cmpq %rdx, 0x10(%rcx)
jne 0x73d0
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x73d0
leaq 0x2c(%rip), %rsi        # 0x73da
cmpq %rsi, 0x18(%rdx)
jne 0x73d0
cmpq %rbx, 0x20(%rdx)
jne 0x73d0
leaq 0x193(%rip), %rdx       # 0x7554
movq %rdx, 0x10(%rcx)
jmp 0x73d0
xorl %eax, %eax
cmpb $0x0, (%r14)
sete %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r13
movq %rax, -0x48(%rbp)
movl 0x20(%rax), %r15d
movl %r13d, %eax
shll $0x4, %eax
movslq %eax, %rdx
movq %rsp, %rdi
subq %rdx, %rdi
movq %rdi, %rsp
xorl %ebx, %ebx
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
callq 0x30f0
testq %r13, %r13
jle 0x7618
movq %r13, -0x38(%rbp)
movq %r13, %rbx
movq -0x30(%rbp), %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq *0x18(%r12)
testl %eax, %eax
je 0x760d
movq 0x10(%r12), %r12
addq $0x10, %r13
decq %rbx
jne 0x75b3
movq -0x38(%rbp), %r13
testl %r13d, %r13d
jle 0x7616
movq %r13, %rax
shlq $0x4, %rax
movq %rax, -0x50(%rbp)
xorl %r12d, %r12d
movq -0x30(%rbp), %rbx
leaq (%rbx,%r12), %rdi
movq 0x10(%r14), %rsi
addq %r12, %rsi
callq 0x3a65
addq $0x10, %r12
cmpq %r12, -0x50(%rbp)
jne 0x75ee
movl %r13d, %ebx
jmp 0x7618
xorl %r14d, %r14d
movq -0x38(%rbp), %r13
jmp 0x767c
xorl %ebx, %ebx
cmpl %r15d, %ebx
jge 0x7657
movl %ebx, %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 0x764e
callq 0x394d
movq $0x0, (%rbx,%r12)
addq $0x10, %r12
decq %r15
jne 0x762b
movq -0x48(%rbp), %rax
movq 0x40(%rax), %rax
cmpb $0x0, 0x18(%rax)
je 0x7676
movq %r14, %rdi
movq -0x40(%rbp), %rsi
callq 0x4320
xorl %r14d, %r14d
jmp 0x767c
movl $0x5, %r14d
movq -0x30(%rbp), %r15
testl %r13d, %r13d
jle 0x76a3
shlq $0x4, %r13
xorl %ebx, %ebx
movq 0x8(%r15,%rbx), %rdi
testq %rdi, %rdi
je 0x769a
callq 0x394d
addq $0x10, %rbx
cmpq %rbx, %r13
jne 0x768b
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_O3/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 0x77be
testq %rax, %rax
je 0x7781
movq %rax, %r15
leaq 0xae2b(%rip), %rdi      # 0x12512
xorl %esi, %esi
callq 0x7275
testq %rax, %rax
je 0x7779
movq %rax, %r12
movq %r13, 0x28(%rax)
incq (%r13)
movq %r14, 0x40(%rax)
leaq 0x11a73(%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 0x7850
movq 0x280(%r14,%rbp,8), %r15
testq %r15, %r15
je 0x7764
cmpb $0x0, (%rbx)
jne 0x7764
movq (%r15), %r13
cmpb $0x6, 0x14(%r13)
jne 0x775e
cmpq $0x0, 0x38(%r13)
je 0x775e
movq %r13, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x7328
movq $0x0, 0x38(%r13)
movq 0x8(%r15), %r15
jmp 0x772e
incq %rbp
cmpq $0x20, %rbp
jne 0x7726
movq %r12, %rdi
callq 0x394d
movq (%rsp), %r15
movq %r15, %rdi
callq 0x394d
cmpb $0x0, 0x18(%r14)
je 0x77a7
movabsq $0x2e646574707572, %rax # imm = 0x2E646574707572
movq %rax, 0x5(%rbx)
movabsq $0x7075727265746e49, %rax # imm = 0x7075727265746E49
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x77af
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_O3/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 0x8a8c
testl %eax, %eax
jle 0x7820
movl %eax, %eax
movsbl -0x1(%r14,%rax), %edx
testl %edx, %edx
je 0x7843
movl 0x30(%rsp), %ecx
leaq 0xb1f4(%rip), %rsi      # 0x12a05
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3200
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
testl %eax, %eax
sets %cl
movq 0x20(%rsp), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x7848
movq %rax, %rdi
callq 0x394d
xorl %eax, %eax
jmp 0x7848
movq 0x20(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x78de
movq %r9, %rbx
movq %r8, %r13
movq %rsi, %rbp
movq %rdi, %r14
cmpb $0x0, (%rbx)
jne 0x78de
testq %r14, %r14
je 0x78a4
movq 0x8(%rbp), %r15
movq %r14, %r12
movq (%r12), %rsi
movq %r15, %rdi
callq 0x65ba
testl %eax, %eax
jne 0x78a7
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x788a
xorl %r12d, %r12d
movq %r12, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r13, %r8
movq %rbx, %r9
callq 0x6f94
movq %rax, %rbp
movq %r13, %rax
testq %r13, %r13
je 0x78d6
movq 0x20(%rax), %r13
testq %r13, %r13
jne 0x78c5
movq %rax, %r13
testq %rbp, %rbp
jne 0x7879
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_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 0x7960
movq %rax, %r12
xorps %xmm0, %xmm0
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 0x797b
movl %eax, %ebx
movq %r12, %rdi
callq 0x394d
movl %ebx, %eax
jmp 0x7971
movq 0x11809(%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_O3/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 $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x381a
testq %rax, %rax
js 0x7a3e
movq %rax, %rbp
cmpq $0x7ffffffe, %rax       # imm = 0x7FFFFFFE
ja 0x7a19
leaq 0x1(%rbp), %rdi
callq 0x31b0
testq %rax, %rax
je 0x7a25
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %rbp, %rcx
movq %rbx, %r8
callq 0x381a
testq %rax, %rax
js 0x7a36
movb $0x0, (%r13,%rax)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x76b5
movl %eax, %r15d
movq %r13, %rdi
callq 0x3030
movl $0x1, %ebp
testl %r15d, %r15d
jne 0x7aab
jmp 0x7a3e
movups 0xb200(%rip), %xmm0     # 0x12c20
movups %xmm0, (%rbx)
jmp 0x7a3e
movq 0x11744(%rip), %rsi     # 0x19170
movq %rbx, %rdi
callq 0x3070
jmp 0x7a3e
movq %r13, %rdi
callq 0x3030
leaq 0xb1eb(%rip), %rsi      # 0x12c30
movl $0xf, %edx
movq %rbx, %rdi
callq 0x3060
movl $0x0, %ebp
testl %eax, %eax
je 0x7aab
movq %rsp, %r15
movl $0x7f, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3050
movb $0x0, 0x7f(%r15)
leaq 0xb1c6(%rip), %rsi      # 0x12c40
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3200
testl %eax, %eax
jns 0x7aab
movups 0xb1c5(%rip), %xmm0     # 0x12c5c
movups %xmm0, (%rbx)
movw $0x20, 0x10(%rbx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x31f0
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: 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 0x7b70
movq %rsi, %rbx
movq %rsp, %r14
movq (%r12), %r13
movb 0x14(%r13), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x7b62
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%r13), %rdi
movq 0x38(%r13), %r15
movq %rdi, 0x18(%rsp)
testq %rdi, %rdi
je 0x7b62
testq %r15, %r15
je 0x7b55
movq %rbx, 0x8(%rsp)
leaq 0x18(%r13), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *0x18(%r15)
movl %eax, %ebp
movq %r15, %rdi
callq 0x3af9
xorl %r15d, %r15d
movq %r15, 0x38(%r13)
movq 0x18(%rsp), %rdi
callq 0x394d
movq %r15, 0x30(%r13)
testl %ebp, %ebp
jne 0x7b62
jmp 0x7b76
callq 0x394d
movq $0x0, 0x30(%r13)
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x7ae3
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_O3/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 0x7c2a
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x1, %edi
movl $0x20, %esi
callq 0x3130
testq %rax, %rax
je 0x7c19
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq (%rax), %rdx
movb (%rdx), %sil
testb %sil, %sil
je 0x7bf4
incq %rdx
xorl %ecx, %ecx
movzbl %sil, %esi
xorl %esi, %ecx
movb (%rdx), %sil
incq %rdx
testb %sil, %sil
jne 0x7bde
andl $0x1f, %ecx
jmp 0x7bf6
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 0x7ba8
jmp 0x7c2a
movq 0x11550(%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_O3/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 0x7d7b
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, (%rsp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x3130
testq %rax, %rax
je 0x7d69
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 0x7cac
leaq 0x1(%rbp), %rdx
xorl %eax, %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x7c99
andl $0x1f, %eax
jmp 0x7cae
xorl %eax, %eax
movq 0x180(%r15,%rax,8), %rcx
movq %rcx, 0x18(%r13)
movq %r13, 0x180(%r15,%rax,8)
cmpb $0x24, (%rbp)
jne 0x7d56
cmpb $0x61, 0x1(%rbp)
jl 0x7d56
incq %rbp
movq %rbp, %rdi
callq 0x30c0
leaq 0x21(%rax), %rsi
movl $0x1, %edi
callq 0x3130
testq %rax, %rax
je 0x7d69
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 0x7d40
movq %r14, %rdx
addq $0x21, %rdx
xorl %eax, %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x7d2d
andl $0x1f, %eax
jmp 0x7d42
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 0x7c5c
jmp 0x7d7b
movq 0x11400(%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_O3/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 0x1144b(%rip), %rdi     # 0x19200
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7b88
testl %eax, %eax
je 0x7df1
leaq 0x11775(%rip), %rdi     # 0x19540
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7c38
testl %eax, %eax
je 0x7df1
leaq 0x11f9f(%rip), %rdi     # 0x19d80
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3f91
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movq $0x0, 0x20(%rdi)
leaq -0xa52(%rip), %rax      # 0x73da
movq %rax, 0x18(%rdi)
movl 0x18(%rsi), %eax
movl %eax, (%rdi)
movq %rsi, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7e79
movl %eax, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x7e71
callq 0x394d
incq %r15
cmpq %r15, %r14
jne 0x7e5f
movl $0x0, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7eba
movq 0x30(%rdi), %rax
movl %r15d, %ebp
testq %rax, %rax
je 0x7ebd
movl 0x10(%rax), %r13d
leal (%r15,%r13), %ebp
incl %ebp
jmp 0x7ebd
movl %r15d, %ebp
testq %rbx, %rbx
je 0x7f01
testl %r13d, %r13d
je 0x7eea
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 0x7eec
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_O3/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 0x7f50
movq %r15, (%rax)
incq (%r15)
movq $0x0, 0x8(%rax)
cmpq $0x0, (%r14)
je 0x7f4a
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_O3/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 0x8056
pushq %rbp
pushq %rbx
xorl %eax, %eax
movl $0x1, %r8d
movl $0x9, %ecx
movq %rdi, %r9
movzbl (%r9), %r9d
cmpl $0x5c, %r9d
je 0x7f85
testl %r9d, %r9d
jne 0x7fee
jmp 0x8047
movslq %r8d, %r11
movzbl (%rdi,%r11), %ebx
testl %ebx, %ebx
je 0x7fee
leaq 0x1(%r11), %r10
movl %ebx, %r9d
andb $-0x8, %r9b
cmpb $0x30, %r9b
jne 0x7ffe
movl %ebx, %r9d
addb $-0x30, %r9b
movb (%rdi,%r10), %bl
movl %ebx, %ebp
andb $-0x8, %bpl
cmpb $0x30, %bpl
jne 0x8024
shlb $0x3, %r9b
addb %r9b, %bl
movl %ebx, %r9d
addb $-0x30, %r9b
movb 0x2(%rdi,%r11), %r10b
movl %r10d, %ebx
andb $-0x8, %bl
cmpb $0x30, %bl
jne 0x801d
shlb $0x3, %r9b
addl $0x3, %r8d
addb %r9b, %r10b
addb $-0x30, %r10b
movl %r10d, %r9d
movl %r8d, %r10d
jmp 0x8024
cmpb %dl, %r9b
jne 0x7ff8
movl %eax, %r11d
jmp 0x8036
leal 0x1(%rax), %r11d
jmp 0x802b
cmpl $0x6e, %ebx
je 0x800d
cmpl $0x72, %ebx
jne 0x8012
movb $0xd, %r9b
jmp 0x8024
movb $0xa, %r9b
jmp 0x8024
cmpl $0x74, %ebx
cmovel %ecx, %ebx
movl %ebx, %r9d
jmp 0x8024
addq $0x2, %r11
movl %r11d, %r10d
leal 0x1(%rax), %r11d
movl %r10d, %r8d
testq %rsi, %rsi
je 0x8036
cltq
movb %r9b, (%rsi,%rax)
movslq %r8d, %r9
incl %r8d
addq %rdi, %r9
movl %r11d, %eax
jmp 0x7f71
testq %rsi, %rsi
popq %rbx
popq %rbp
je 0x8055
movslq %eax, %rcx
movb $0x0, (%rsi,%rcx)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x3130
movq %rax, %rbx
testq %rax, %rax
je 0x8092
movl %ebp, (%rbx)
movq %r15, 0x20(%rbx)
leaq -0x45e7(%rip), %rax     # 0x3aa5
movq %rax, 0x18(%rbx)
jmp 0x80a1
movq 0x110d7(%rip), %rsi     # 0x19170
movq %r14, %rdi
callq 0x3070
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: 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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8131
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r12d, %r12d
movl 0x10(%r14), %edi
callq 0x3690
testq %rax, %rax
je 0x8124
movq %rax, %r15
movl 0x28(%r14), %eax
movl %eax, 0x28(%r15)
testq %r12, %r12
je 0x80e7
movq %r15, 0x20(%r12)
testq %rbx, %rbx
cmoveq %r15, %rbx
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
movslq 0x10(%r15), %rdx
callq 0x3180
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x8116
callq 0x80af
movq %rax, 0x18(%r15)
testq %rax, %rax
je 0x8124
movq 0x20(%r14), %r14
movq %r15, %r12
testq %r14, %r14
jne 0x80c4
jmp 0x8133
testq %rbx, %rbx
je 0x8133
movq %rbx, %rdi
callq 0x394d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_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
xorl %ebx, %ebx
testq %rdi, %rdi
movq %r9, 0x10(%rsp)
je 0x821d
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpb %cl, (%rax)
je 0x8220
movq %r8, %r15
movq %rdx, %r12
movq %rsi, %r13
movq 0x50(%rsp), %rbp
movb (%rbp), %al
xorl %ebx, %ebx
movl %ecx, 0xc(%rsp)
testb %al, %al
jne 0x8220
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbp, %r8
callq 0x4f62
incl %ebx
testq %rax, %rax
je 0x821d
movq %rax, %r14
movq 0x10(%r15), %r15
movb (%rbp), %al
movq 0x8(%r14), %rcx
movb (%rcx), %cl
testb %al, %al
jne 0x820f
cmpb $0x2c, %cl
jne 0x820f
movl 0x28(%r14), %edx
movq 0x20(%r14), %r14
testq %r14, %r14
je 0x81d8
movq 0x8(%r14), %rax
cmpb $0x2c, (%rax)
jne 0x81eb
movq %rbp, %rdi
leaq 0xa3d8(%rip), %rsi      # 0x125ba
xorl %eax, %eax
callq 0x3200
jmp 0x8208
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbp, %r8
callq 0x4f62
movq %rax, %r14
movq 0x10(%r15), %r15
incl %ebx
testq %r14, %r14
jne 0x81b0
jmp 0x821d
movl 0xc(%rsp), %edx
cmpb %dl, %cl
jne 0x8186
jmp 0x8220
xorl %r14d, %r14d
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x822c
movl %ebx, (%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_O3/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 0x82f9
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x82d1
cmpb $0x6, 0x14(%rax)
jne 0x82d1
movl (%r14), %ecx
movl %ecx, 0x10(%rsp)
movq %rax, 0x30(%rsp)
movl 0x4(%r14), %edx
cmpl %edx, 0x1c(%rax)
jne 0x8309
movq 0x10(%r12), %rax
leaq 0x10(%rsp), %rdi
movq %rax, 0x8(%rdi)
movq %rbx, %rsi
movq %r15, %rdx
callq 0x73da
movl %eax, %ebx
jmp 0x82e8
movl (%rsp), %edx
leaq 0xa40c(%rip), %rcx      # 0x126e7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c96
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x82fb
callq 0x394d
jmp 0x82fb
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xa3ab(%rip), %rcx      # 0x126bb
jmp 0x82db
// File: /workspace/github_c_makefile_star2_O3/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 0x8339
leaq 0x1(%r14), %rcx
xorl %ebp, %ebp
orb %al, %bpl
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x8328
notb %bpl
jmp 0x833c
movb $-0x1, %bpl
movsbl (%rbx), %esi
testb %bpl, %sil
jne 0x8356
testb %sil, %sil
je 0x835b
movq %r14, %rdi
callq 0x30d0
testq %rax, %rax
jne 0x835b
incq %rbx
jmp 0x833c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x839e
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 0x839c
incl %ebp
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x837c
jmp 0x839e
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: 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 0x854e
movq %r8, %r13
movq %rsi, %r12
movq %rdi, %rbp
movq %rbx, (%rsp)
movq 0x20(%rdi), %rdi
movq %rdx, %rsi
callq 0x8363
testl %eax, %eax
js 0x8569
movl %eax, %ebx
movl $0x1, %edi
movl $0x30, %esi
callq 0x3130
testq %rax, %rax
je 0x8584
movq %rax, 0x10(%r13)
movq %rbp, 0x20(%rax)
movl %ebx, 0x4(%rax)
movl 0x28(%r15), %ecx
movl %ecx, (%rax)
movq %r12, 0x8(%rax)
leaq 0x264(%rip), %rcx       # 0x87ac
movq %rcx, 0x18(%rax)
jmp 0x8593
movq 0x8(%r15), %rdx
movl 0x28(%r15), %ecx
leaq 0xa275(%rip), %rsi      # 0x127d2
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x8597
movq 0x8(%r15), %rdx
movl 0x28(%r15), %ecx
leaq 0xa225(%rip), %rsi      # 0x1279d
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x8593
movq 0x10be5(%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_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
movq 0x20(%r14), %r13
callq *0x18(%rdi)
xorl %r15d, %r15d
testl %eax, %eax
je 0x883f
movq %rbx, 0x8(%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x43a6
movl %eax, %ebp
movq 0x8(%rbx), %rdi
testl %eax, %eax
je 0x8832
movq 0x18(%rdi), %rcx
movslq 0x4(%r14), %rax
movl (%rcx,%rax,4), %ecx
movq 0x8(%rsp), %rdx
movl %ecx, (%rdx)
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x8837
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x8837
movq %rax, 0x8(%rdx)
incq (%rax)
jmp 0x8837
testq %rdi, %rdi
je 0x883f
callq 0x394d
movl %ebp, %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_O3/martincameron[P]towntalk/towntalk.c
// Function: get_decl_indexed
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:
movb (%rsi), %r8b
xorl %eax, %eax
testb %r8b, %r8b
je 0x8874
leaq 0x1(%rsi), %r9
movzbl %r8b, %r8d
xorl %r8d, %eax
movb (%r9), %r8b
incq %r9
testb %r8b, %r8b
jne 0x885f
andl $0x1f, %eax
movq 0x280(%rdi,%rax,8), %rdi
jmp 0x887e
// File: /workspace/github_c_makefile_star2_O3/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 0x88c2
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movslq %edx, %r13
movq (%r12), %r14
cmpl %ebp, 0x10(%r14)
jne 0x88b8
movq 0x8(%r14), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3060
testl %eax, %eax
je 0x88d7
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x889b
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 0x88c5
movsbl 0x14(%r14), %eax
cmpl %ebx, %eax
jne 0x88c2
jmp 0x88c5
// File: /workspace/github_c_makefile_star2_O3/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 0x891c
movq 0x8(%r13), %rdx
movl 0x18(%r13), %ecx
leaq 0xa02a(%rip), %rsi      # 0x12937
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x898a
movq %rdx, %rbx
movq %rsi, %r12
movl 0x28(%rsi), %esi
movq 0x40(%r13), %rdx
movq %r12, %rdi
movq %r14, %rcx
callq 0x8997
testl %eax, %eax
je 0x8987
movslq 0x10(%r12), %rdi
addq $0x21, %rdi
callq 0x31b0
testq %rax, %rax
je 0x8978
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 0x898a
movq 0x107f1(%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_O3/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, %r8d
movq 0x8(%rdi), %r14
movb (%r14), %al
testb %al, %al
je 0x89cf
leaq 0x1(%r14), %rcx
xorl %ebx, %ebx
movzbl %al, %eax
xorl %eax, %ebx
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x89bc
andl $0x1f, %ebx
jmp 0x89d1
xorl %ebx, %ebx
cmpl $0x40, 0x10(%rdi)
jle 0x89ee
leaq 0x9f92(%rip), %rsi      # 0x12970
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rdx
movl %r8d, %ecx
jmp 0x8a70
movl %r8d, 0x4(%rsp)
leaq 0x10786(%rip), %r13     # 0x19180
movq (%r13), %rsi
movq %r14, %rdi
callq 0x65ba
testl %eax, %eax
jne 0x8a5d
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x89fa
movl %ebx, %r13d
movq 0x80(%r12,%r13,8), %rbp
testq %rbp, %rbp
je 0x8a39
movq (%rbp), %rsi
movq %r14, %rdi
callq 0x65ba
testl %eax, %eax
jne 0x8a5d
movq 0x18(%rbp), %rbp
jmp 0x8a1e
movq 0x180(%r12,%r13,8), %r12
testq %r12, %r12
je 0x8a88
movq (%r12), %rdi
movq %r14, %rsi
callq 0x3140
testl %eax, %eax
je 0x8a5d
movq 0x18(%r12), %r12
jmp 0x8a41
leaq 0x9f2d(%rip), %rsi      # 0x12991
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rdx
movl 0x4(%rsp), %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
incl %ebx
jmp 0x8a77
// File: /workspace/github_c_makefile_star2_O3/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 0x8e1a
leaq (%rdi,%rbx), %rax
incl %ebx
movslq %ebx, %r10
movzbl (%rdi,%r10), %r9d
incq %r10
cmpl $0x5c, %r9d
je 0x8deb
movl %r10d, %ebx
cmpl $0x22, %r9d
jne 0x8df2
jmp 0x8dfe
addl $0x2, %ebx
movb (%rdi,%r10), %r9b
testb $0x60, %r9b
jne 0x8dcf
cmpb $0x22, %r9b
jne 0x8e23
testq %rdx, %rdx
je 0x8e3b
movl %ebx, %ecx
subl %esi, %ecx
movslq %ecx, %rcx
movq %rdx, %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0x3180
jmp 0x8e3b
leaq 0x9c80(%rip), %rsi      # 0x12aa1
jmp 0x8e2a
leaq 0x9c5b(%rip), %rsi      # 0x12a85
movq %r8, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x3200
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
movl %ebx, %eax
popq %rbx
retq