LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x78b2
movq 0x30(%rdi), %rax
movl %r15d, %ebp
testq %rax, %rax
je 0x78b5
movl 0x10(%rax), %r13d
leal (%r15,%r13), %ebp
incl %ebp
jmp 0x78b5
movl %r15d, %ebp
testq %rbx, %rbx
je 0x78f9
testl %r13d, %r13d
je 0x78e2
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 0x78e4
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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
xorl %esi, %esi
callq 0x3e43
testq %rax, %rax
je 0x7936
cmpq $0x0, (%r14)
je 0x7930
movq (%rbx), %r14
addq $0x8, %r14
movq %rax, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7a37
pushq %rbp
pushq %r14
pushq %rbx
xorl %eax, %eax
movl $0x1, %r9d
movl $0x9, %ecx
movq %rdi, %r8
movzbl (%r8), %r10d
movslq %eax, %r8
cmpl $0x5c, %r10d
je 0x7972
testl %r10d, %r10d
jne 0x79dd
jmp 0x7a28
movslq %r9d, %rbx
movzbl (%rdi,%rbx), %ebp
testl %ebp, %ebp
je 0x79dd
leaq 0x1(%rbx), %r11
movl %ebp, %r10d
andb $-0x8, %r10b
cmpb $0x30, %r10b
jne 0x79e6
movl %ebp, %r10d
addb $-0x30, %r10b
movb (%rdi,%r11), %bpl
movl %ebp, %r14d
andb $-0x8, %r14b
cmpb $0x30, %r14b
jne 0x7a0c
shlb $0x3, %r10b
addb %r10b, %bpl
movl %ebp, %r10d
addb $-0x30, %r10b
movb 0x2(%rdi,%rbx), %r11b
movl %r11d, %ebp
andb $-0x8, %bpl
cmpb $0x30, %bpl
jne 0x7a05
shlb $0x3, %r10b
addl $0x3, %r9d
addb %r10b, %r11b
addb $-0x30, %r11b
movl %r11d, %r10d
movl %r9d, %r11d
jmp 0x7a0c
cmpb %dl, %r10b
je 0x7a1a
incl %eax
jmp 0x7a11
cmpl $0x6e, %ebp
je 0x79f5
cmpl $0x72, %ebp
jne 0x79fa
movb $0xd, %r10b
jmp 0x7a0c
movb $0xa, %r10b
jmp 0x7a0c
cmpl $0x74, %ebp
cmovel %ecx, %ebp
movl %ebp, %r10d
jmp 0x7a0c
addq $0x2, %rbx
movl %ebx, %r11d
incl %eax
movl %r11d, %r9d
testq %rsi, %rsi
je 0x7a1a
movb %r10b, (%rsi,%r8)
movslq %r9d, %r8
incl %r9d
addq %rdi, %r8
jmp 0x795b
testq %rsi, %rsi
popq %rbx
popq %r14
popq %rbp
je 0x7a36
movb $0x0, (%rsi,%r8)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x3130
movq %rax, %rbx
testq %rax, %rax
je 0x7a6f
movl %ebp, (%rbx)
movq %r15, 0x20(%rbx)
leaq -0x4095(%rip), %rax     # 0x39d4
movq %rax, 0x18(%rbx)
jmp 0x7a7e
movq 0x106fa(%rip), %rsi     # 0x18170
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_O2/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
movb $0x1, %cl
xorl %r12d, %r12d
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x7b10
movq %rdi, %r15
movl 0x10(%rdi), %edi
callq 0x3638
movb $0x1, %cl
movl $0x0, %edi
testq %rax, %rax
je 0x7a9b
movq %rax, %r14
movl 0x28(%r15), %eax
movl %eax, 0x28(%r14)
testq %r12, %r12
je 0x7acc
movq %r14, 0x20(%r12)
testq %rbx, %rbx
cmoveq %r14, %rbx
movq 0x8(%r14), %rdi
movq 0x8(%r15), %rsi
movslq 0x10(%r14), %rdx
callq 0x3180
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x7b05
callq 0x7a8c
movq %rax, 0x18(%r14)
movb $0x1, %cl
movl $0x0, %edi
movq %r14, %r12
testq %rax, %rax
je 0x7a9b
movq 0x20(%r15), %rdi
xorl %ecx, %ecx
movq %r14, %r12
jmp 0x7a9b
testq %rbx, %rbx
setne %al
andb %al, %cl
cmpb $0x1, %cl
jne 0x7b27
movq %rbx, %rdi
callq 0x38b2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_expressions
static struct element* parse_expressions( struct element *elem, struct function *func,
	struct variables *vars, char terminator, struct expression *prev, int *num_exprs, char *message ) {
	int line, count = 0;
	while( elem && elem->str.string[ 0 ] != terminator && message[ 0 ] == 0 ) {
		elem = parse_expression( elem, func, vars, prev, message );
		prev = prev->next;
		count++;
		while( elem && message[ 0 ] == 0 && elem->str.string[ 0 ] == ',' ) {
			line = elem->line;
			elem = elem->next;
			if( elem && elem->str.string[ 0 ] != ',' ) {
				elem = parse_expression( elem, func, vars, prev, message );
				prev = prev->next;
				count++;
			} else {
				sprintf( message, "Expected expression after ',' on line %d.", line );
			}
		}
	}
	if( num_exprs ) {
		*num_exprs = count;
	}
	return elem;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r14
movl %ecx, 0x4(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbp
movq 0x50(%rsp), %r13
leaq 0x9a93(%rip), %rbx      # 0x115fa
xorl %r15d, %r15d
testq %rbp, %rbp
je 0x7bdb
movq 0x8(%rbp), %rax
movl 0x4(%rsp), %ecx
cmpb %cl, (%rax)
je 0x7bdb
cmpb $0x0, (%r13)
jne 0x7bdb
movq %rbp, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rcx
movq %r13, %r8
callq 0x4d6c
movq %rax, %rbp
incl %r15d
movq 0x10(%r14), %r14
testq %rbp, %rbp
je 0x7b6a
cmpb $0x0, (%r13)
jne 0x7b6a
movq 0x8(%rbp), %rax
cmpb $0x2c, (%rax)
jne 0x7b6a
movl 0x28(%rbp), %edx
movq 0x20(%rbp), %rbp
testq %rbp, %rbp
je 0x7bcc
movq 0x8(%rbp), %rax
cmpb $0x2c, (%rax)
jne 0x7b82
movq %r13, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3200
jmp 0x7ba2
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x7be8
movl %r15d, (%rax)
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: 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)
andq $0x0, 0x30(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %r12
movq %r12, %rdi
callq *0x18(%r12)
testl %eax, %eax
je 0x7ca9
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x7c88
cmpb $0x6, 0x14(%rax)
jne 0x7c88
movl (%r14), %ecx
movl %ecx, 0x10(%rsp)
movq %rax, 0x30(%rsp)
movl 0x4(%r14), %edx
cmpl %edx, 0x1c(%rax)
jne 0x7cb9
movq 0x10(%r12), %rax
leaq 0x10(%rsp), %rdi
movq %rax, 0x8(%rdi)
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6ec6
movl %eax, %ebx
jmp 0x7c9f
movl (%rsp), %edx
leaq 0x9a95(%rip), %rcx      # 0x11727
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bb2
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x3988
jmp 0x7cab
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x9a3b(%rip), %rcx      # 0x116fb
jmp 0x7c92
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ebp, %ebp
movq %rsi, %rax
movb (%rax), %cl
testb %cl, %cl
je 0x7cdf
incq %rax
orb %cl, %bpl
jmp 0x7cd1
notb %bpl
movsbl (%rbx), %esi
testb %bpl, %sil
jne 0x7cfc
testb %sil, %sil
je 0x7d01
movq %r14, %rdi
callq 0x30d0
testq %rax, %rax
jne 0x7d01
incq %rbx
jmp 0x7ce2
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
pushq $-0x1
popq %rbx
testq %r15, %r15
je 0x7d3d
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x3140
testl %eax, %eax
je 0x7d3b
incl %ebp
movq 0x8(%r15), %r15
jmp 0x7d1b
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_thiscall_expression
static enum result evaluate_thiscall_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	int idx, count;
	struct array *arr;
	struct variable obj = { 0 };
	struct string *function = NULL;
	struct function_expression call_expr = { 0 };
	struct value_expression obj_expr = { 0 };
	struct structure *struc = ( struct structure * ) ( ( struct value_expression * ) this )->str;
	enum result ret = this->parameters->evaluate( this->parameters, vars, &obj );
	if( ret ) {
		ret = is_instance( &obj, struc, vars, this );
		if( ret ) {
			arr = ( struct array * ) obj.string_value;
			idx = this->index >> 8;
			count = this->index & 0xFF;
			if( arr->string_values ) {
				function = arr->string_values[ idx ];
			}
			if( function && function->type == FUNCTION ) {
				obj_expr.str = obj.string_value;
				obj_expr.expr.evaluate = evaluate_string_literal_expression;
				obj_expr.expr.next = this->parameters->next;
				call_expr.expr.line = this->line;
				call_expr.function = ( struct function * ) function;
				call_expr.expr.parameters = &obj_expr.expr;
				if( call_expr.function->num_parameters == count ) {
					function->reference_count++;
					ret = evaluate_call_expression( &call_expr.expr, vars, result );
					function->reference_count--;
				} else {
					ret = throw( vars, this, count, "Incorrect number of parameters to function." );
				}
			} else {
				ret = throw( vars, this, arr->number_values[ idx ], "Not a function reference." );
			}
		}
		dispose_temporary( &obj );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x30(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq 0x8(%rdi), %rdi
movq 0x20(%r14), %r12
callq *0x18(%rdi)
testl %eax, %eax
je 0x7e37
movq %rsp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x41fd
xorl %ebp, %ebp
testl %eax, %eax
je 0x7e54
movq 0x8(%rsp), %rax
movl 0x4(%r14), %ecx
movl %ecx, %edx
sarl $0x8, %edx
movq 0x20(%rax), %rsi
movslq %edx, %rdx
testq %rsi, %rsi
je 0x7e3b
movq (%rsi,%rdx,8), %r12
testq %r12, %r12
je 0x7e3b
cmpb $0x6, 0x14(%r12)
jne 0x7e3b
movzbl %cl, %edx
leaq 0x40(%rsp), %rcx
movq %rax, 0x20(%rcx)
leaq -0x441f(%rip), %rax     # 0x39d4
movq %rax, 0x18(%rcx)
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rcx)
movl (%r14), %eax
movl %eax, 0x10(%rsp)
movq %r12, 0x30(%rsp)
movq %rcx, 0x18(%rsp)
cmpl %edx, 0x1c(%r12)
jne 0x7e6b
incq (%r12)
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6ec6
movl %eax, %ebp
decq (%r12)
jmp 0x7e54
xorl %ebp, %ebp
jmp 0x7e5c
movq 0x18(%rax), %rax
movl (%rax,%rdx,4), %edx
leaq 0x98de(%rip), %rcx      # 0x11727
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bb2
movq %rsp, %rdi
callq 0x3988
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9889(%rip), %rcx      # 0x116fb
jmp 0x7e49
// File: /workspace/github_c_makefile_star2_O2/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 0x7edf
movq %r8, %r13
movq %rsi, %r12
movq %rdi, %rbp
movq %rbx, (%rsp)
movq 0x20(%rdi), %rdi
movq %rdx, %rsi
callq 0x7d09
testl %eax, %eax
js 0x7efa
movl %eax, %ebx
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x3130
testq %rax, %rax
je 0x7f15
movq %rax, 0x10(%r13)
movq %rbp, 0x20(%rax)
movl %ebx, 0x4(%rax)
movl 0x28(%r15), %ecx
movl %ecx, (%rax)
movq %r12, 0x8(%rax)
leaq 0x262(%rip), %rcx       # 0x813b
movq %rcx, 0x18(%rax)
jmp 0x7f24
movq 0x8(%r15), %rdx
movl 0x28(%r15), %ecx
leaq 0x9924(%rip), %rsi      # 0x11812
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x7f28
movq 0x8(%r15), %rdx
movl 0x28(%r15), %ecx
leaq 0x98d4(%rip), %rsi      # 0x117dd
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x7f24
movq 0x10254(%rip), %rsi     # 0x18170
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_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_member_expression
static enum result evaluate_member_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct array *arr;
	struct variable obj = { 0, NULL };
	struct expression *parameter = this->parameters;
	struct structure *struc = ( struct structure * ) ( ( struct value_expression * ) this )->str;
	enum result ret = parameter->evaluate( parameter, vars, &obj );
	if( ret ) {
		ret = is_instance( &obj, struc, vars, this );
		if( ret ) {
			arr = ( struct array * ) obj.string_value;
			result->number_value = arr->number_values[ this->index ];
			if( arr->string_values && arr->string_values[ this->index ] ) {
				result->string_value = arr->string_values[ this->index ];
				result->string_value->reference_count++;
			}
		}
		dispose_temporary( &obj );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
movq 0x20(%r14), %r12
callq *0x18(%rdi)
testl %eax, %eax
je 0x81b4
movq %rsp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x41fd
movl %eax, %ebp
testl %eax, %eax
je 0x81aa
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rdx
movslq 0x4(%r14), %rax
movl (%rdx,%rax,4), %edx
movl %edx, (%rbx)
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x81aa
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x81aa
movq %rax, 0x8(%rbx)
incq (%rax)
movq %rsp, %rdi
callq 0x3988
jmp 0x81b6
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movslq %edx, %r13
testq %r12, %r12
je 0x824c
movq (%r12), %r14
cmpl %ebp, 0x10(%r14)
jne 0x8238
movq 0x8(%r14), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3060
testl %eax, %eax
je 0x823f
movq 0x8(%r12), %r12
jmp 0x8216
testl %ebx, %ebx
je 0x824f
movsbl 0x14(%r14), %eax
cmpl %ebx, %eax
je 0x824f
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: 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 0x8297
movq 0x8(%r13), %rdx
movl 0x18(%r13), %ecx
leaq 0x96ef(%rip), %rsi      # 0x11977
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x8302
movq %rdx, %rbx
movq %rsi, %r12
movl 0x28(%rsi), %esi
movq 0x40(%r13), %rdx
movq %r12, %rdi
movq %r14, %rcx
callq 0x830f
testl %eax, %eax
je 0x82ff
movslq 0x10(%r12), %rdi
addq $0x21, %rdi
callq 0x31b0
testq %rax, %rax
je 0x82f0
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)
andq $0x0, 0x18(%r15)
jmp 0x8302
movq 0xfe79(%rip), %rsi      # 0x18170
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_O2/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, %ebx
movq %rdi, %rbp
movq 0x8(%rdi), %r14
xorl %r13d, %r13d
movq %r14, %rdi
xorl %esi, %esi
callq 0x5f40
cmpl $0x41, 0x10(%rbp)
jl 0x8345
leaq 0x966d(%rip), %rsi      # 0x119b0
jmp 0x8392
movl %eax, %ebp
leaq 0xfe32(%rip), %rsi      # 0x18180
movq %r14, %rdi
callq 0x6af7
testq %rax, %rax
jne 0x8388
movl %ebp, %r13d
movq 0x80(%r12,%r13,8), %rsi
movq %r14, %rdi
callq 0x6af7
testq %rax, %rax
jne 0x8388
movq 0x180(%r12,%r13,8), %rsi
movq %r14, %rdi
callq 0x5f11
testq %rax, %rax
je 0x83b3
leaq 0x9642(%rip), %rsi      # 0x119d1
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x3200
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %r13d
incl %r13d
jmp 0x83a1
// File: /workspace/github_c_makefile_star2_O2/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 0x8718
leaq (%rdi,%rbx), %rax
incl %ebx
movb $0x22, %r9b
testb $0x60, %r9b
je 0x8721
movslq %ebx, %r10
movzbl (%rdi,%r10), %r9d
incq %r10
cmpl $0x5c, %r9d
je 0x870f
movl %r10d, %ebx
cmpl $0x22, %r9d
jne 0x86ed
jmp 0x873f
addl $0x2, %ebx
movb (%rdi,%r10), %r9b
jmp 0x86ed
leaq 0x93c2(%rip), %rsi      # 0x11ae1
jmp 0x872e
cmpb $0x22, %r9b
je 0x8742
leaq 0x9397(%rip), %rsi      # 0x11ac5
movq %r8, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x3200
pushq $-0x3
popq %rbx
jmp 0x875c
movl %r10d, %ebx
testq %rdx, %rdx
je 0x875c
movl %ebx, %ecx
subl %esi, %ecx
movslq %ecx, %rcx
movq %rdx, %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0x3180
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_import
static struct element* parse_import( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next, *name = next;
	struct string *library = get_decl_indexed( func, name->str.string, name->str.length, LIBRARY );
	if( library ) {
		next = next->next->next->next->next;
	} else {
		next = parse_include( next->next, func, vars, prev, message );
		library = get_decl_indexed( func, name->str.string, name->str.length, LIBRARY );
	}
	if( message[ 0 ] == 0 ) {
		if( library ) {
			import_library( library, func->file, message );
		} else {
			sprintf( message, "Library '%.32s' not found in file %.64s on line %d.\n", name->str.string, name->next->next->str.string, elem->line );
		}
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %rbp
movq 0x8(%rbp), %r12
movl 0x10(%rbp), %edx
pushq $0x7
popq %rcx
movq %rsi, %rdi
movq %r12, %rsi
callq 0x81c5
movq 0x20(%rbp), %rdi
testq %rax, %rax
je 0x87a4
movq 0x20(%rdi), %rcx
movq 0x20(%rcx), %rcx
movq 0x20(%rcx), %r13
jmp 0x87c7
movq %r15, %rsi
movq %rbx, %r8
callq 0x8818
movq %rax, %r13
movq 0x8(%rbp), %r12
movl 0x10(%rbp), %edx
pushq $0x7
popq %rcx
movq %r15, %rdi
movq %r12, %rsi
callq 0x81c5
cmpb $0x0, (%rbx)
jne 0x8806
testq %rax, %rax
je 0x87e2
movq 0x28(%r15), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x8b4c
jmp 0x8806
movq 0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rcx
movl 0x28(%r14), %r8d
leaq 0x9328(%rip), %rsi      # 0x11b21
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x3200
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_library_declaration
static struct element* parse_library_declaration( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct function *init;
	struct element *next = elem->next;
	struct string *library = get_decl_indexed( func, next->str.string, next->str.length, LIBRARY );
	if( library ) {
		library->reference_count++;
	} else {
		library = new_string_value( next->str.string );
		if( library ) {
			library->type = LIBRARY;
			add_decl( library, next->line, func->env, message );
		} else {
			strcpy( message, OUT_OF_MEMORY );
		}
	}
	if( message[ 0 ] == 0 && import_library( library, func->file, message ) ) {
		init = new_function( "[Init]", NULL );
		if( init ) {
			init->file = func->file;
			init->file->reference_count++;
			init->library = library;
			library->reference_count++;
			init->env = func->env;
			next = next->next;
			parse_keywords( library_decls, next->child, init, NULL, NULL, message );
			next = next->next;
			unref_string( &init->str );
		} else {
			strcpy( message, OUT_OF_MEMORY );
		}
		unref_string( library );
	}
	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rsi, %r12
movq 0x20(%rdi), %rbx
movq 0x8(%rbx), %r13
movl 0x10(%rbx), %edx
pushq $0x7
popq %rcx
movq %rsi, %rdi
movq %r13, %rsi
callq 0x81c5
testq %rax, %rax
je 0x89d4
movq %rax, %r15
incq (%rax)
jmp 0x8a0f
movq %r13, %rdi
callq 0x3756
testq %rax, %rax
je 0x89fd
movq %rax, %r15
movb $0x7, 0x14(%rax)
movl 0x28(%rbx), %esi
movq 0x40(%r12), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x3d9a
jmp 0x8a0f
movq 0xf76c(%rip), %rsi      # 0x18170
movq %r14, %rdi
callq 0x3070
xorl %r15d, %r15d
cmpb $0x0, (%r14)
jne 0x8aa3
movq 0x28(%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x8b4c
testl %eax, %eax
je 0x8aa3
leaq 0x8b1e(%rip), %rdi      # 0x11552
xorl %esi, %esi
callq 0x6d74
testq %rax, %rax
je 0x8a8c
movq %rax, %r13
movq 0x28(%r12), %rax
movq %rax, 0x28(%r13)
incq (%rax)
movq %r15, 0x30(%r13)
incq (%r15)
movq 0x40(%r12), %rax
movq %rax, 0x40(%r13)
movq 0x20(%rbx), %rbx
movq 0x18(%rbx), %rsi
leaq 0x10362(%rip), %rdi     # 0x18dd0
movq %r13, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x72d9
movq 0x20(%rbx), %rbx
movq %r13, %rdi
callq 0x38b2
jmp 0x8a9b
movq 0xf6dd(%rip), %rsi      # 0x18170
movq %r14, %rdi
callq 0x3070
movq %r15, %rdi
callq 0x38b2
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_program_declaration
static struct element* parse_program_declaration( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct environment *env = func->env;
	struct element *next = elem->next;
	struct function *prog = new_function( next->str.string, NULL );
	if( prog ) {
		prog->line = elem->line;
		prog->file = func->file;
		prog->file->reference_count++;
		if( func->library ) {
			prog->library = func->library;
			prog->library->reference_count++;
		}
		prog->body = next->next;
		prog->env = env;
		if( add_decl( &prog->str, next->line, env, message ) ) {
			env->entry_point = prog;
			next = next->next->next;
		}
		unref_string( &prog->str );
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x40(%rsi), %r14
movq 0x20(%rdi), %rbx
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x6d74
testq %rax, %rax
je 0x8b3a
movq %rax, %r15
movl 0x28(%rbp), %eax
movl %eax, 0x18(%r15)
movq 0x28(%r13), %rax
movq %rax, 0x28(%r15)
incq (%rax)
movq 0x30(%r13), %rax
testq %rax, %rax
je 0x8b01
movq %rax, 0x30(%r15)
incq (%rax)
movq 0x20(%rbx), %rax
movq %rax, 0x38(%r15)
movq %r14, 0x40(%r15)
movl 0x28(%rbx), %esi
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x3d9a
testq %rax, %rax
je 0x8b32
movq %r15, 0x398(%r14)
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rbx
movq %r15, %rdi
callq 0x38b2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: import_library
static int import_library( struct string *library, struct string *source, char *message ) {
	struct string_list *imports;
	if( source->type == SOURCE ) {
		imports = ( ( struct source * ) source )->imports;
		while( imports ) {
			if( imports->str == library ) {
				return 1;
			}
			imports = imports->next;
		}
		imports = new_string_list( library, ( ( struct source * ) source )->imports );
		if( imports ) {
			( ( struct source * ) source )->imports = imports;
		} else {
			strcpy( message, OUT_OF_MEMORY );
			return 0;
		}
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
pushq $0x1
popq %rbx
cmpb $0x8, 0x14(%rsi)
jne 0x8b9d
movq %rdx, %r14
movq %rsi, %r15
addq $0x18, %r15
movq %r15, %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x8b7a
leaq 0x8(%rcx), %rax
cmpq %rdi, (%rcx)
jne 0x8b67
jmp 0x8b9d
movq (%r15), %rsi
callq 0x3e43
testq %rax, %rax
je 0x8b8c
movq %rax, (%r15)
jmp 0x8b9d
movq 0xf5dd(%rip), %rsi      # 0x18170
movq %r14, %rdi
callq 0x3070
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: str_idx
static int str_idx( char *str, char *chars, int idx ) {
	char *chr, *end;
	if( idx < 0 ) {
		chr = end = field_end( str, chars );
		while( *end ) {
			chr = end;
			end = field_end( end + 1, chars );
		}
	} else {
		chr = field_end( str + idx, chars );
	}
	if( *chr ) {
		return chr - str;
	}
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
js 0x8bd6
movl %edx, %edi
addq %rbx, %rdi
movq %r14, %rsi
callq 0x7cc2
movl %eax, %edx
subl %ebx, %edx
xorl %ecx, %ecx
cmpb $0x1, (%rax)
sbbl %ecx, %ecx
orl %edx, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7cc2
movq %rax, %r15
cmpb $0x0, (%r15)
je 0x8bc1
leaq 0x1(%r15), %rdi
movq %r14, %rsi
callq 0x7cc2
movq %rax, %rcx
movq %r15, %rax
movq %rcx, %r15
jmp 0x8be4
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_function_declaration
static struct element* parse_function_declaration( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next;
	struct function *decl = parse_function( next->next, next->str.string, func, message );
	if( decl ) {
		if( add_decl( &decl->str, next->line, func->env, message ) ) {
			next = next->next->next->next;
		}
		unref_string( &decl->str );
	}
	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rsi, %r12
movq 0x20(%rdi), %rbx
movq 0x8(%rbx), %rsi
movq 0x20(%rbx), %rdi
movq %r12, %rdx
movq %r8, %rcx
callq 0x6b26
testq %rax, %rax
je 0x8c5a
movq %rax, %r14
movl 0x28(%rbx), %esi
movq 0x40(%r12), %rdx
movq %rax, %rdi
movq %r15, %rcx
callq 0x3d9a
testq %rax, %rax
je 0x8c52
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rbx
movq %r14, %rdi
callq 0x38b2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: add_global_constant
static int add_global_constant( struct element *elem,
	struct function *func, struct structure *type, struct expression *initializer,
	struct statement *prev, char *message ) {
	struct global_variable *global = new_global_variable( elem->str.string, type, func, initializer, message );
	if( global ) {
		if( add_global( global, elem->line, func->env, message ) ) {
			global->str.type = CONST;
		}
		unref_string( &global->str );
	}
	return message[ 0 ] == 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
movq %r15, %rdx
movq %r9, %r8
callq 0x3f11
testq %rax, %rax
je 0x920d
movq %rax, %r14
movl 0x28(%r12), %esi
movq 0x40(%r15), %rdx
movq %rax, %rdi
movq %rbx, %rcx
callq 0x3fda
testq %rax, %rax
je 0x9205
movb $0x5, 0x14(%r14)
movq %r14, %rdi
callq 0x38b2
xorl %eax, %eax
cmpb $0x0, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: expr_set_line
static void expr_set_line( struct expression *expr, int line ) {
	while( expr ) {
		expr->line = line;
		expr_set_line( expr->parameters, line );
		expr = expr->next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testq %r14, %r14
je 0x9561
movl %ebx, (%r14)
movq 0x8(%r14), %rdi
movl %ebx, %esi
callq 0x953f
movq 0x10(%r14), %r14
jmp 0x9548
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: add_global_variable
static int add_global_variable( struct element *elem,
	struct function *func, struct structure *type, struct expression *initializer,
	struct statement *prev, char *message ) {
	struct global_variable *global = new_global_variable( elem->str.string, type, func, initializer, message );
	if( global ) {
		add_global( global, elem->line, func->env, message );
		unref_string( &global->str );
	}
	return message[ 0 ] == 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %r9, %r8
callq 0x3f11
testq %rax, %rax
je 0x95b0
movq %rax, %r15
movl 0x28(%r12), %esi
movq 0x40(%r14), %rdx
movq %rax, %rdi
movq %rbx, %rcx
callq 0x3fda
movq %r15, %rdi
callq 0x38b2
xorl %eax, %eax
cmpb $0x0, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_break_statement
static struct element* parse_break_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		stmt->execute = execute_break_statement;
		prev->next = stmt;
		next = next->next;
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r15
movq %rcx, %r14
movq 0x20(%rdi), %rbx
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x3130
testq %rax, %rax
je 0x9eca
leaq 0xd2d(%rip), %rcx       # 0xabe9
movq %rcx, 0x10(%rax)
movq %rax, 0x20(%r14)
movq 0x20(%rbx), %rbx
jmp 0x9ed9
movq 0xe29f(%rip), %rsi      # 0x18170
movq %r15, %rdi
callq 0x3070
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_continue_statement
static struct element* parse_continue_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		stmt->execute = execute_continue_statement;
		prev->next = stmt;
		next = next->next;
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r15
movq %rcx, %r14
movq 0x20(%rdi), %rbx
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x3130
testq %rax, %rax
je 0x9f16
leaq 0xce5(%rip), %rcx       # 0xabed
movq %rcx, 0x10(%rax)
movq %rax, 0x20(%r14)
movq 0x20(%rbx), %rbx
jmp 0x9f25
movq 0xe253(%rip), %rsi      # 0x18170
movq %r15, %rdi
callq 0x3070
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_until_statement
static struct element* parse_until_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = parse_while_statement( elem, func, vars, prev, message );
	if( message[ 0 ] == 0 ) {
		prev->next->execute = execute_until_statement;
	}
	return next;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
callq 0xa1c1
cmpb $0x0, (%r14)
jne 0xa37d
movq 0x20(%rbx), %rcx
leaq 0xe37(%rip), %rdx       # 0xb1b0
movq %rdx, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_try_statement
static struct element* parse_try_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct statement try_block = { 0 };
	struct block_statement *try_stmt = calloc( 1, sizeof( struct block_statement ) );
	if( try_stmt ) {
		try_stmt->stmt.dispose = dispose_block_statement;
		prev->next = &try_stmt->stmt;
		elem = elem->next;
		if( elem->child ) {
			parse_keywords_indexed( func->env->statements_index, elem->child, func, vars, &try_block, message );
			try_stmt->if_block = try_block.next;
		}
		if( message[ 0 ] == 0 ) {
			elem = parse_catch_block( elem->next, func, vars, try_stmt, message );
			while( message[ 0 ] == 0 && elem
			&& ( is_keyword( elem->str.string, "catch" ) || is_keyword( elem->str.string, "finally" ) ) ) {
				try_stmt = calloc( 1, sizeof( struct block_statement ) );
				if( try_stmt ) {
					try_stmt->stmt.dispose = dispose_block_statement;
					try_stmt->if_block = prev->next;
					prev->next = &try_stmt->stmt;
					elem = parse_catch_block( elem, func, vars, try_stmt, message );
				} else {
					strcpy( message, OUT_OF_MEMORY );
				}
			}
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return elem;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x40(%rsp)
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
callq 0x3130
testq %rax, %rax
je 0xa4f4
movq %rax, %r15
leaq -0x6204(%rip), %rax     # 0x41de
movq %rax, 0x18(%r15)
movq %r15, 0x20(%r13)
movq 0x20(%r14), %r14
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0xa420
movq 0x40(%r12), %rdi
subq $-0x80, %rdi
leaq 0x20(%rsp), %r8
movq %r12, %rdx
movq %rbp, %rcx
movq %rbx, %r9
callq 0x69a8
leaq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%r15)
cmpb $0x0, (%rbx)
jne 0xa503
movq %r13, 0x18(%rsp)
movq 0x20(%r14), %rdi
movq %r12, 0x8(%rsp)
movq %r12, %rsi
movq %rbp, 0x10(%rsp)
movq %rbp, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0xb299
movq %rax, %r14
leaq 0x6fbe(%rip), %rbp      # 0x11415
pushq $0x1
popq %r12
pushq $0x48
popq %r15
cmpb $0x0, (%rbx)
jne 0xa503
testq %r14, %r14
je 0xa503
movq 0x8(%r14), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x6197
testl %eax, %eax
jne 0xa497
movq %r13, %rdi
leaq 0x6f8d(%rip), %rsi      # 0x1141b
callq 0x6197
testl %eax, %eax
je 0xa503
movq %r12, %rdi
movq %r15, %rsi
callq 0x3130
testq %rax, %rax
jne 0xa4b8
movq 0xdcc2(%rip), %rsi      # 0x18170
movq %rbx, %rdi
callq 0x3070
jmp 0xa45f
leaq -0x62e1(%rip), %rcx     # 0x41de
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rdx
movq 0x20(%rdx), %rcx
movq %rcx, 0x28(%rax)
movq %rax, 0x20(%rdx)
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
movq %rbx, %r8
callq 0xb299
movq %rax, %r14
jmp 0xa45f
movq 0xdc75(%rip), %rsi      # 0x18170
movq %rbx, %rdi
callq 0x3070
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_increment_statement
static struct element* parse_increment_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct local_variable *local;
	struct element *next = elem->next;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		prev->next = stmt;
		local = get_local_variable( func->variable_decls, next->str.string, "" );
		if( local ) {
			stmt->source = calloc( 1, sizeof( struct expression ) );
			if( stmt->source ) {
				stmt->local = local->index;
				stmt->source->line = next->line;
				stmt->execute = execute_increment_statement;
				next = next->next->next;
			} else {
				strcpy( message, OUT_OF_MEMORY );
			}
		} else {
			sprintf( message, "Undeclared local variable '%.64s' on line %d.", next->str.string, next->line );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rsi, %r12
movq 0x20(%rdi), %rbx
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x3130
testq %rax, %rax
je 0xa710
movq %rax, %r15
movq %rax, 0x20(%r13)
movq 0x48(%r12), %rdi
movq 0x8(%rbx), %r12
leaq 0x698b(%rip), %rdx      # 0x11056
movq %r12, %rsi
callq 0x5eb5
testq %rax, %rax
je 0xa721
movq %rax, %r13
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x3130
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0xa710
movl (%r13), %ecx
movl %ecx, (%r15)
movl 0x28(%rbx), %ecx
movl %ecx, (%rax)
leaq -0x5f18(%rip), %rax     # 0x47ea
movq %rax, 0x10(%r15)
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rbx
jmp 0xa738
movq 0xda59(%rip), %rsi      # 0x18170
movq %r14, %rdi
callq 0x3070
jmp 0xa738
movl 0x28(%rbx), %ecx
leaq 0x7741(%rip), %rsi      # 0x11e6c
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x3200
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_append_statement
static struct element* parse_append_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = parse_save_statement( elem, func, vars, prev, message );
	if( prev->next && message[ 0 ] == 0 ) {
		prev->next->local = 1;
	}
	return next;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
callq 0xa7fc
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0xa82e
cmpb $0x0, (%rbx)
jne 0xa82e
movl $0x1, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: add_local_variable
static int add_local_variable( struct element *elem,
	struct function *func, struct structure *type, struct expression *initializer,
	struct statement *prev, char *message ) {
	struct statement *stmt;
	struct local_variable *param = new_local_variable( func, elem, type, message );
	if( param ) {
		/*printf("Local variable '%s'\n", elem->str.string);*/
		if( get_local_variable( func->variable_decls, elem->str.string, "" ) == NULL ) {
			func->num_variables = func->num_variables + 1;
			if( func->variable_decls ) {
				func->variable_decls_tail->next = param;
			} else {
				func->variable_decls = param;
			}
			func->variable_decls_tail = param;
			if( initializer ) {
				stmt = calloc( 1, sizeof( struct statement ) );
				if( stmt ) {
					prev->next = stmt;
					stmt->source = initializer;
					stmt->local = func->num_variables - 1;
					stmt->execute = execute_local_assignment;
				} else {
					strcpy( message, OUT_OF_MEMORY );
				}
			}
		} else {
			dispose_local_variables( param );
			sprintf( message, "Local variable '%.64s' already declared on line %d.", elem->str.string, elem->line );
		}
	}
	return message[ 0 ] == 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, (%rsp)
movq %rsi, %r12
movq %rdi, %rbp
movq %rsi, %rdi
movq %rbp, %rsi
movq %r9, %rcx
callq 0x8261
testq %rax, %rax
je 0xa8a4
movq %rax, %r13
movq 0x48(%r12), %r15
movq 0x8(%rbp), %rsi
leaq 0x67df(%rip), %rdx      # 0x11056
movq %r15, %rdi
callq 0x5eb5
testq %rax, %rax
je 0xa8bb
movq %r13, %rdi
callq 0x7868
movq 0x8(%rbp), %rdx
movl 0x28(%rbp), %ecx
leaq 0x7496(%rip), %rsi      # 0x11d30
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3200
xorl %eax, %eax
cmpb $0x0, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x20(%r12), %ebp
leal 0x1(%rbp), %eax
movl %eax, 0x20(%r12)
testq %r15, %r15
je 0xa8d8
movq 0x50(%r12), %rax
addq $0x18, %rax
jmp 0xa8dd
leaq 0x48(%r12), %rax
movq %r13, (%rax)
movq %r13, 0x50(%r12)
cmpq $0x0, (%rsp)
je 0xa8a4
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x3130
testq %rax, %rax
je 0xa917
movq %rax, 0x20(%r14)
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movl %ebp, (%rax)
leaq -0x67cd(%rip), %rcx     # 0x4144
movq %rcx, 0x10(%rax)
jmp 0xa8a4
movq 0xd852(%rip), %rsi      # 0x18170
movq %rbx, %rdi
callq 0x3070
jmp 0xa8a4