LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_call_expression
static struct element* parse_call_expression( struct element *elem,
	struct function *func, struct variables *vars, struct function *decl, struct expression *prev, char *message ) {
	int num_params;
	struct element *next = elem->next;
	struct expression param = { 0 }, *expr = calloc( 1, sizeof( struct function_expression ) );
	if( expr ) {
		prev->next = expr;
		expr->line = elem->line;
		( ( struct function_expression * ) expr )->function = decl;
		if( next && next->str.string[ 0 ] == '(' ) {
			parse_expressions( next->child, func, vars, 0, &param, &num_params, message );
			expr->parameters = param.next;
			if( message[ 0 ] == 0 ) {
				if( num_params == ( ( struct function_expression * ) expr )->function->num_parameters ) {
					expr->evaluate = evaluate_call_expression;
					next = next->next;
				} else {
					sprintf( message, "Wrong number of arguments to '%.64s()' on line %d.", elem->str.string, next->line );
				}
			}
		} else {
			sprintf( message, "Expected '(' after function name on line %d.", elem->line );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x30f0
movl $0x1, %edi
movl $0x28, %esi
callq 0x3120
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x6e9a
movq -0x68(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x68(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x40(%rbp)
je 0x6e7f
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x6e7f
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rax
xorl %ecx, %ecx
leaq -0x60(%rbp), %r8
leaq -0x34(%rbp), %r9
movq %rax, (%rsp)
callq 0xac40
movq -0x50(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6e7d
movl -0x34(%rbp), %eax
movq -0x68(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x6e5a
movq -0x68(%rbp), %rax
leaq 0x29c8(%rip), %rcx      # 0x9810
movq %rcx, 0x18(%rax)
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x6e7b
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x40(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x14c61(%rip), %rsi     # 0x1bad5
movb $0x0, %al
callq 0x31f0
jmp 0x6e7d
jmp 0x6e98
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x14c77(%rip), %rsi     # 0x1bb08
movb $0x0, %al
callq 0x31f0
jmp 0x6eaa
movq -0x30(%rbp), %rdi
movq 0x1a2bb(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_refcall_expression
static struct element* parse_refcall_expression( struct element *elem,
	struct function *func, struct variables *vars, struct expression *prev, char *message ) {
	int count;
	struct element *next = elem->next;
	struct expression param = { 0 }, *expr = calloc( 1, sizeof( struct expression ) );
	if( expr ) {
		prev->next = expr;
		expr->line = elem->line;
		if( next && next->str.string[ 0 ] == '(' ) {
			parse_expressions( next->child, func, vars, 0, &param, &count, message );
			expr->parameters = param.next;
			if( message[ 0 ] == 0 ) {
				if( count > 0 ) {
					expr->index = count - 1;
					expr->evaluate = evaluate_refcall_expression;
					next = next->next;
				} else {
					sprintf( message, "Expected expression after '(' on line %d.", next->line );
				}
			}
		} else {
			sprintf( message, "Expected '(' after ':' on line %d.", elem->line );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x30f0
movl $0x1, %edi
movl $0x20, %esi
callq 0x3120
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x6ff5
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x6fda
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x6fda
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
leaq -0x58(%rbp), %r8
leaq -0x2c(%rbp), %r9
movq %rax, (%rsp)
callq 0xac40
movq -0x48(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6fd8
cmpl $0x0, -0x2c(%rbp)
jle 0x6fbd
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x60(%rbp), %rax
leaq 0x3e55(%rip), %rcx      # 0xae00
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x6fd6
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x14b66(%rip), %rsi     # 0x1bb35
movb $0x0, %al
callq 0x31f0
jmp 0x6fd8
jmp 0x6ff3
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x14b73(%rip), %rsi     # 0x1bb5f
movb $0x0, %al
callq 0x31f0
jmp 0x7005
movq -0x28(%rbp), %rdi
movq 0x1a160(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: get_local_variable
static struct local_variable* get_local_variable( struct local_variable *locals, char *name, char *terminators ) {
	size_t len = field_end( name, terminators ) - name;
	while( locals && ( strncmp( locals->name, name, len ) || strlen( locals->name ) != len ) ) {
		locals = locals->next;
	}
	return locals;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaf10
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x21(%rbp)
je 0x7536
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3060
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
jne 0x7530
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x30c0
cmpq -0x20(%rbp), %rax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x753f
jmp 0x754d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x74ec
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: hash_code
static int hash_code( char *str, char terminator ) {
	char chr = str[ 0 ];
	int idx = 1, hash = 0;
	while( chr != terminator && chr ) {
		hash = hash ^ chr;
		chr = str[ idx++ ];
	}
	return hash & 0x1F;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0xa(%rbp)
movl $0x1, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movsbl -0xa(%rbp), %ecx
movsbl -0x9(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
je 0x79a3
movsbl -0xa(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x79ac
jmp 0x79d2
movl -0x14(%rbp), %eax
movsbl -0xa(%rbp), %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0xa(%rbp)
jmp 0x7985
movl -0x14(%rbp), %eax
andl $0x1f, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_expr_list_statement
struct element* parse_expr_list_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev,
	enum result ( *execute )( struct statement *this, struct variables *vars, struct variable *result ),
	char *message ) {
	struct expression head, *expr;
	struct element *next = elem->next;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		prev->next = stmt;
		head.next = NULL;
		next = parse_expression( next, func, vars, &head, message );
		expr = stmt->source = head.next;
		while( expr && next->str.string[ 0 ] != ';' ) {
			if( next->str.string[ 0 ] == ',' ) {
				next = next->next;
			}
			next = parse_expression( next, func, vars, expr, message );
			expr = expr->next;
		}
		if( expr ) {
			stmt->execute = execute;
			next = next->next;
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x60(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x3120
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x838c
movq -0x68(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq $0x0, -0x40(%rbp)
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %r8
leaq -0x50(%rbp), %rcx
callq 0x60c0
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq %rax, -0x58(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x58(%rbp)
movb %al, -0x69(%rbp)
je 0x831b
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
setne %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x8324
jmp 0x836b
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x8340
movq -0x60(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x60c0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x82fb
cmpq $0x0, -0x58(%rbp)
je 0x838a
movq -0x28(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x60(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x839c
movq -0x30(%rbp), %rdi
movq 0x18dc9(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: is_keyword
int is_keyword( char *name, char *key ) {
	int chr = key[ 0 ];
	if( strcmp( &name[ 1 ], &key[ 1 ] ) == 0 ) {
		if( chr == name[ 0 ] || ( chr > 96 && chr - 32 == name[ 0 ] ) ) {
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x3130
cmpl $0x0, %eax
jne 0x8414
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x8409
cmpl $0x60, -0x1c(%rbp)
jle 0x8412
movl -0x1c(%rbp), %eax
subl $0x20, %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x8412
movl $0x1, -0x4(%rbp)
jmp 0x841b
jmp 0x8414
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: validate_name
static int validate_name( struct element *elem, char *message ) {
	int chr = elem->str.string[ 0 ], idx = 1, len = elem->str.length;
	int result = len < 65 && ( ( chr >= 'A' && chr <= 'Z') || ( chr >= 'a' && chr <= 'z' ) );
	if( result ) {
		/* First character must be alphabetical.*/
		while( idx < len ) {
			chr = elem->str.string[ idx++ ];
			if( !( chr == '_' || ( chr >= '0' && chr <= '9' )
			|| ( chr >= 'A' && chr <= 'Z' ) || ( chr >= 'a' && chr <= 'z' ) ) ) {
				/* Subsequent characters must be alphanumerical, or underscore. */
				result = 0;
				idx = len;
			}
		}
	}
	if( !result ) {
		sprintf( message, "Invalid name '%.64s' on line %d.", elem->str.string, elem->line );
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x41, -0x1c(%rbp)
movb %al, -0x21(%rbp)
jge 0x8fac
cmpl $0x41, -0x14(%rbp)
jl 0x8f8b
movb $0x1, %al
cmpl $0x5a, -0x14(%rbp)
movb %al, -0x22(%rbp)
jle 0x8fa6
xorl %eax, %eax
cmpl $0x61, -0x14(%rbp)
movb %al, -0x23(%rbp)
jl 0x8fa0
cmpl $0x7a, -0x14(%rbp)
setle %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x901f
jmp 0x8fbf
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x901d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x5f, -0x14(%rbp)
je 0x901b
cmpl $0x30, -0x14(%rbp)
jl 0x8ff6
cmpl $0x39, -0x14(%rbp)
jle 0x901b
cmpl $0x41, -0x14(%rbp)
jl 0x9002
cmpl $0x5a, -0x14(%rbp)
jle 0x901b
cmpl $0x61, -0x14(%rbp)
jl 0x900e
cmpl $0x7a, -0x14(%rbp)
jle 0x901b
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x8fbf
jmp 0x901f
cmpl $0x0, -0x20(%rbp)
jne 0x9046
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x12dfe(%rip), %rsi     # 0x1be3d
movb $0x0, %al
callq 0x31f0
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_keywords_indexed
struct statement* parse_keywords_indexed( struct keyword **index, struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct statement *stmt = prev;
	while( elem && message[ 0 ] == 0 ) {
		elem = parse_keyword( get_keyword( elem->str.string, index[ hash_code( elem->str.string, 0 ) ] ), elem, func, vars, stmt, message );
		while( stmt && stmt->next ) {
			stmt = stmt->next;
		}
	}
#if defined( OPTIMIZER )
	if( message[ 0 ] == 0 && prev->next ) {
		stmt = optimize_statements( func, prev, message );
	}
#endif
	return stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x39(%rbp)
je 0x9094
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x90a0
jmp 0x9130
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x7960
movq -0x50(%rbp), %rdi
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x9220
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x9170
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x51(%rbp)
je 0x9114
movq -0x38(%rbp), %rax
cmpq $0x0, 0x20(%rax)
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x911d
jmp 0x912b
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x90f9
jmp 0x9078
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x915c
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x915c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x144e0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_keyword
static struct element* parse_keyword( struct keyword *key, struct element *elem,
	struct function *func, struct variables *vars, struct statement *stmt, char *message ) {
	if( key ) {
		validate_syntax( key->syntax, elem->next, elem, func->env, message );
		if( message[ 0 ] == 0 ) { 
			elem = key->parse( elem, func, vars, stmt, message );
		}
	} else {
		sprintf( message, "Unrecognized keyword '%.64s' on line %d.", elem->str.string, elem->line );
	}
	return elem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x91ec
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x30(%rbp), %r8
callq 0x8430
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x91ea
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%rax
movq %rax, -0x10(%rbp)
jmp 0x920d
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x12b71(%rip), %rsi     # 0x1bd77
movb $0x0, %al
callq 0x31f0
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x948c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x947e
cmpl $0x0, -0x14(%rbp)
jl 0x9475
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x9430
cmpl $0x0, %eax
jne 0x947e
movl $0x0, -0x4(%rbp)
jmp 0x9493
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9448
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x94e4
movq -0x8(%rbp), %rdi
callq 0x30c0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0xa730
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rsi
shlq $0x0, %rsi
addq $0x68, %rsi
movl $0x1, %edi
callq 0x3120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x956c
movq -0x20(%rbp), %rcx
addq $0x68, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x953f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0xa730
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x9559
movq -0x20(%rbp), %rax
leaq 0x12856(%rip), %rcx     # 0x1bda0
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0xa, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x1, (%rax)
movq -0x20(%rbp), %rax
movb $0x6, 0x14(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x30f0
movq $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x9783
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x80, %rdi
movq -0x58(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r9
leaq -0x48(%rbp), %r8
callq 0x9050
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x97f3
cmpq $0x0, -0x50(%rbp)
je 0x97ea
movq -0x50(%rbp), %rax
leaq -0x4981(%rip), %rcx     # 0x4e20
cmpq %rcx, 0x10(%rax)
jne 0x97ea
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x97e8
movq -0x60(%rbp), %rax
leaq 0x4b(%rip), %rcx        # 0x9810
cmpq %rcx, 0x18(%rax)
jne 0x97e8
movq -0x60(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x97e8
movq -0x50(%rbp), %rax
leaq 0x23c(%rip), %rcx       # 0x9a20
movq %rcx, 0x10(%rax)
jmp 0x97ea
movl $0x1, -0x4(%rbp)
jmp 0x97fa
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
movb $0x1, -0x3c(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %r8
xorl %esi, %esi
leaq -0x50(%rbp), %rdx
callq 0xba90
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x9e1a
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x9e18
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edx
movl -0x28(%rbp), %ecx
leaq 0x120c8(%rip), %rsi     # 0x1bed2
movb $0x0, %al
callq 0x31f0
movl $0xfffffffc, -0x1c(%rbp) # imm = 0xFFFFFFFC
jmp 0x9e1a
cmpl $0x0, -0x1c(%rbp)
jge 0x9e38
cmpq $0x0, -0x38(%rbp)
je 0x9e38
movq -0x38(%rbp), %rdi
callq 0x3c20
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x39(%rbp)
je 0x9e94
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x9e9d
jmp 0x9f05
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x9220
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x9170
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x3a(%rbp)
je 0x9ee9
movq -0x38(%rbp), %rax
cmpq $0x0, 0x20(%rax)
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x9ef2
jmp 0x9f00
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x9ece
jmp 0x9e78
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30c0
movl %eax, %edi
callq 0x3930
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9f76
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3070
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9f90
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3c20
jmp 0x9f86
movq -0x18(%rbp), %rdi
movq 0x171df(%rip), %rsi     # 0x21160
callq 0x3070
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0xc0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x30f0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x3a80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0xa094
cmpq $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
jge 0xa082
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
callq 0x31a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa070
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x3a80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0xa065
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x9be0
cltq
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3030
jmp 0xa080
movq -0x18(%rbp), %rdi
movq 0x170e5(%rip), %rsi     # 0x21160
callq 0x3070
jmp 0xa092
movq -0x18(%rbp), %rdi
leaq 0x12063(%rip), %rsi     # 0x1c0f0
callq 0x3070
jmp 0xa094
cmpq $0x0, -0x28(%rbp)
jne 0xa112
movq -0x18(%rbp), %rdi
leaq 0x1205a(%rip), %rsi     # 0x1c100
movl $0xf, %edx
callq 0x3060
cmpl $0x0, %eax
je 0xa112
leaq -0xc0(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x7f, %edx
callq 0x3050
movb $0x0, -0x41(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
leaq 0x1202c(%rip), %rsi     # 0x1c110
movb $0x0, %al
callq 0x31f0
cmpl $0x0, %eax
jge 0xa110
movq -0x18(%rbp), %rdi
leaq 0x12031(%rip), %rsi     # 0x1c12c
callq 0x3070
movq -0x18(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x31e0
jmp 0xa112
movq -0x28(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x380(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa196
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl 0x14(%rax), %eax
cmpl $0x4, %eax
je 0xa16b
movq -0x20(%rbp), %rax
movsbl 0x14(%rax), %eax
cmpl $0x5, %eax
jne 0xa188
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa1b0
cmpl $0x0, %eax
jne 0xa186
movl $0x0, -0x4(%rbp)
jmp 0xa19d
jmp 0xa188
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xa13f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: initialize_global
static enum result initialize_global( struct global_variable *global, struct variable *exception ) {
	enum result ret = OKAY;
	struct variables vars = { 0 };
	struct expression *init = global->initializer;
	vars.func = global->init_function;
	if( vars.func ) {
		if( init ) {
			vars.exception = exception;
			ret = init->evaluate( init, &vars, &global->value );
			dispose_expressions( init );
			global->initializer = NULL;
		}
		unref_string( &vars.func->str );
		global->init_function = NULL;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa24c
cmpq $0x0, -0x48(%rbp)
je 0xa237
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0x18, %rdx
leaq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x14(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3e60
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x28(%rbp), %rdi
callq 0x3c20
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movl -0x14(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: add_statements
int add_statements( struct keyword *statements, struct environment *env, char *message ) {
	int idx;
	struct keyword *statement;
	while( statements->name ) {
		statement = calloc( 1, sizeof( struct keyword ) );
		if( statement ) {
			memcpy( statement, statements, sizeof( struct keyword ) );
			idx = hash_code( statement->name, 0 );
			statement->next = env->statements_index[ idx ];
			env->statements_index[ idx ] = statement;
		} else {
			strcpy( message, OUT_OF_MEMORY );
			return 0;
		}
		statements++;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa32b
movl $0x1, %edi
movl $0x20, %esi
callq 0x3120
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa301
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x7960
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x80(%rax,%rcx,8), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, 0x80(%rax,%rcx,8)
jmp 0xa31a
movq -0x20(%rbp), %rdi
movq 0x16e54(%rip), %rsi     # 0x21160
callq 0x3070
movl $0x0, -0x4(%rbp)
jmp 0xa332
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
jmp 0xa274
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa496
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xa4b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa46c
movq -0x30(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x7960
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x180(%rax,%rcx,8), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, 0x180(%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x24, %eax
jne 0xa46a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x60, %eax
jle 0xa46a
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq $0x1, %rdi
movq -0x30(%rbp), %rsi
callq 0xa4b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa44f
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
subl $0x20, %ecx
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x7960
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x180(%rax,%rcx,8), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, 0x180(%rax,%rcx,8)
jmp 0xa468
movq -0x20(%rbp), %rdi
movq 0x16d06(%rip), %rsi     # 0x21160
callq 0x3070
movl $0x0, -0x4(%rbp)
jmp 0xa49d
jmp 0xa46a
jmp 0xa485
movq -0x20(%rbp), %rdi
movq 0x16ce9(%rip), %rsi     # 0x21160
callq 0x3070
movl $0x0, -0x4(%rbp)
jmp 0xa49d
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
jmp 0xa354
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_operator
static struct operator* new_operator( char *name, struct operator *src ) {
	struct operator *oper;
	size_t size = sizeof( struct operator );
	if( name ) {
		size += sizeof( char ) * ( strlen( name ) + 1 );
	}
	oper = calloc( 1, size );
	if( oper ) {
		if( src ) {
			memcpy( oper, src, sizeof( struct operator ) );
		}
		if( name ) {
			oper->name = ( char * ) &oper[ 1 ];
			strcpy( oper->name, name );
		}
	}
	return oper;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x20, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa4e8
movq -0x8(%rbp), %rdi
callq 0x30c0
addq $0x1, %rax
shlq $0x0, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x3120
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa556
cmpq $0x0, -0x10(%rbp)
je 0xa52e
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x8(%rbp)
je 0xa554
movq -0x18(%rbp), %rcx
addq $0x20, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3070
jmp 0xa556
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x3a8, %edx            # imm = 0x3A8
callq 0x30f0
movq -0x10(%rbp), %rax
shrq $0xa, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x16c4c(%rip), %rdi     # 0x211f0
callq 0xa260
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0xa5f2
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x16f6c(%rip), %rdi     # 0x21530
callq 0xa340
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0xa5f2
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1778c(%rip), %rdi     # 0x21d70
callq 0x48b0
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x8(%rax), %eax
shll $0x9, %eax
cltq
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
leaq -0xe3d(%rip), %rcx      # 0x9810
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xa6d4
jmp 0xa69a
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xa6d2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa6d0
movq -0x10(%rbp), %rdi
callq 0x3c20
jmp 0xa69a
jmp 0xa6d4
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: dispose_local_variables
static void dispose_local_variables( struct local_variable *local ) {
	struct local_variable *next;
	while( local ) {
		next = local->next;
		free( local );
		local = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa722
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa6fc
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa780
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xa780
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa7e0
cmpl $0x0, -0x24(%rbp)
je 0xa7bc
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rsi
movslq -0x24(%rbp), %rdx
callq 0x3050
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movb $0x5f, (%rax,%rcx)
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x3050
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4850
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa84d
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa837
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0xa842
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x3120
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xaada
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
leaq -0x6d24(%rip), %rcx     # 0x3db0
movq %rcx, 0x18(%rax)
jmp 0xaaea
movq -0x20(%rbp), %rdi
movq 0x1667b(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)