LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_struct_assignment
static enum result execute_struct_assignment( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct array *arr;
	struct expression *destination = this->source->next;
	struct variable obj = { 0, NULL }, var = { 0, NULL };
	enum result ret = destination->evaluate( destination, vars, &obj );
	if( ret ) {
		ret = is_instance( &obj, ( ( struct structure_statement * ) this )->structure, vars, destination );
		if( ret ) {
			arr = ( struct array * ) obj.string_value;
			ret = this->source->evaluate( this->source, vars, &var );
			if( ret ) {
				arr->number_values[ this->local ] = var.number_value;
				if( arr->string_values ) {
					if( arr->string_values[ this->local ] ) {
						unref_string( arr->string_values[ this->local ] );
					}
					arr->string_values[ this->local ] = var.string_value;
				} else {
					dispose_temporary( &var );
				}
			}
		}
		dispose_temporary( &obj );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, (%rsp)
movq %r15, %rdi
callq *0x18(%r15)
testl %eax, %eax
je 0xa9ce
movq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x41fd
xorl %r15d, %r15d
testl %eax, %eax
je 0xa9de
movq 0x18(%rsp), %r12
movq 0x8(%rbx), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq *0x18(%rdi)
testl %eax, %eax
je 0xa9de
movl %eax, %ebp
movl (%rsp), %eax
movq 0x18(%r12), %rcx
movslq (%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
movq 0x20(%r12), %rax
testq %rax, %rax
je 0xa9d3
movslq (%rbx), %rcx
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0xa9c3
callq 0x38b2
movq 0x20(%r12), %rax
movslq (%rbx), %rcx
movq 0x8(%rsp), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0xa9db
xorl %r15d, %r15d
jmp 0xa9e8
movq %rsp, %rdi
callq 0x3988
movl %ebp, %r15d
leaq 0x10(%rsp), %rdi
callq 0x3988
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_global_assignment
static enum result execute_global_assignment( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable var = { 0 }, *dest = ( ( struct global_assignment_statement * ) this )->destination;
	enum result ret = this->source->evaluate( this->source, vars, &var );
	if( ret ) {
		dispose_temporary( dest );
		dest->number_value = var.number_value;
		dest->string_value = var.string_value;
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %rbx
movq %rax, %rdi
callq *0x18(%rax)
movl %eax, %ebp
testl %eax, %eax
je 0xaa31
movq %rbx, %rdi
callq 0x3988
movl (%rsp), %eax
movl %eax, (%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: write_string_expression
static enum result write_string_expression( struct expression *expr, struct variables *vars, int lf, FILE *output ) {
	struct variable value = { 0, NULL };
	struct string *str;
	enum result ret = expr->evaluate( expr, vars, &value );
	if( ret ) {
		if( value.string_value ) {
			if( value.string_value->type == CUSTOM && ( ( struct custom * ) value.string_value )->type->to_str ) {
				ret = ( ( struct custom * ) value.string_value )->type->to_str( &value, &str, vars, expr );
				dispose_temporary( &value );
				if( ret ) {
					value.string_value = str;
				} else {
					return ret;
				}
			}
			fwrite( value.string_value->string, 1, value.string_value->length, output );
		} else {
#if defined( FLOATING_POINT )
			fprintf( output, "%.16g", value.number_value );
#else
			fprintf( output, "%d", value.number_value );
#endif
		}
		if( lf ) {
			fputc( '\n', output );
		}
		dispose_temporary( &value );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r12
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
callq *0x18(%rdi)
xorl %r14d, %r14d
testl %eax, %eax
je 0xab0b
movl %eax, %r15d
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xaadd
cmpb $0x9, 0x14(%rax)
jne 0xaac8
movq 0x18(%rax), %rcx
movq 0x10(%rcx), %r8
testq %r8, %r8
je 0xaac8
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *%r8
movl %eax, %r15d
movq %rsp, %rdi
callq 0x3988
testl %r15d, %r15d
je 0xab0b
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rdx
pushq $0x1
popq %rsi
movq %rbx, %rcx
callq 0x3210
jmp 0xaaf1
movl (%rsp), %edx
leaq 0x7339(%rip), %rsi      # 0x11e20
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3150
movl %r15d, %r14d
testl %ebp, %ebp
je 0xab03
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x3100
movq %rsp, %rdi
callq 0x3988
movl %r14d, %eax
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: execute_throw_statement
static enum result execute_throw_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable exc = { 0, NULL };
	this->source->evaluate( this->source, vars, &exc );
	dispose_temporary( vars->exception );
	vars->exception->number_value = exc.number_value;
	vars->exception->string_value = exc.string_value;
	return EXCEPTION;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq 0x8(%rdi), %rdi
movq %r14, %rdx
callq *0x18(%rdi)
movq 0x8(%rbx), %rdi
callq 0x3988
movl (%r14), %eax
movq 0x8(%rbx), %rcx
movl %eax, (%rcx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rcx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_exit_statement
static enum result execute_exit_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable exit_code = { 0, NULL };
	char *message = NULL;
	enum result ret = this->source->evaluate( this->source, vars, &exit_code );
	if( ret ) {
		vars->func->env->interrupted = 1;
		if( vars->func->env->worker ) {
			message = "Worker exited.";
		}
		ret = throw_exit( vars, exit_code.number_value, message );
		dispose_temporary( &exit_code );
	}
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
testl %eax, %eax
je 0xabdf
movq 0x18(%rbx), %rax
movq 0x40(%rax), %rax
movb $0x1, 0x18(%rax)
movq 0x3a0(%rax), %rax
testq %rax, %rax
leaq 0x725e(%rip), %rdx      # 0x11e23
cmoveq %rax, %rdx
movq %rsp, %r14
movl (%r14), %esi
movq %rbx, %rdi
callq 0x3b74
movq %r14, %rdi
callq 0x3988
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_if_statement
static enum result execute_if_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct statement *stmt = ( ( struct block_statement * ) this )->if_block;
	struct variable condition = { 0 };
	enum result ret = this->source->evaluate( this->source, vars, &condition );
	if( ret ) {
		if( condition.string_value ) {
			dispose_temporary( &condition );
		} else if( condition.number_value == 0 ) {
			stmt = ( ( struct block_statement * ) this )->else_block;
		}
		while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
			stmt = stmt->next;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x28(%rdi), %r15
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
testl %eax, %eax
je 0xac32
movl %eax, %ebp
cmpq $0x0, 0x8(%rsp)
je 0xac36
movq %rsp, %rdi
callq 0x3988
jmp 0xac41
xorl %ebp, %ebp
jmp 0xac67
cmpl $0x0, (%rsp)
jne 0xac41
movq 0x30(%r12), %r15
pushq $0x1
popq %r12
testq %r15, %r15
je 0xac67
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%r15)
cmpl $0x1, %eax
jne 0xac65
movq 0x20(%r15), %r15
movl %r12d, %ebp
jmp 0xac45
movl %eax, %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: execute_if_local_statement
static enum result execute_if_local_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable *lhs = &vars->locals[ this->local ];
	struct variable *rhs = &vars->locals[ ( ( struct block_statement * ) this )->rhs ];
	struct statement *stmt = ( ( struct block_statement * ) this )->if_block;
	enum result ret = OKAY;
	if( lhs->string_value || rhs->string_value ) {
		return execute_if_statement( this, vars, result );
	}
	switch( ( ( struct block_statement * ) this )->oper ) {
		case '!': if( lhs->number_value == rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		case '(': if( lhs->number_value >  rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		case ')': if( lhs->number_value <  rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		case '<': if( lhs->number_value >= rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		case '=': if( lhs->number_value != rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		case '>': if( lhs->number_value <= rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		default: return execute_if_statement( this, vars, result );
	}
	while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
		stmt = stmt->next;
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rsi), %rax
movslq (%rdi), %rdx
shlq $0x4, %rdx
cmpq $0x0, 0x8(%rax,%rdx)
jne 0xaca6
movslq 0x3c(%rdi), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
cmpq $0x0, 0x8(%rcx)
je 0xacb6
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xabf1
addq %rdx, %rax
movq 0x28(%rdi), %r15
movl 0x38(%rdi), %edx
cmpl $0x3e, %edx
je 0xad06
cmpl $0x28, %edx
je 0xacfe
cmpl $0x29, %edx
je 0xace6
cmpl $0x3c, %edx
je 0xacf6
cmpl $0x3d, %edx
je 0xacee
cmpl $0x21, %edx
jne 0xaca6
movl (%rax), %eax
cmpl (%rcx), %eax
je 0xad0c
jmp 0xad13
movl (%rax), %eax
cmpl (%rcx), %eax
jl 0xad0c
jmp 0xad13
movl (%rax), %eax
cmpl (%rcx), %eax
jne 0xad0c
jmp 0xad13
movl (%rax), %eax
cmpl (%rcx), %eax
jge 0xad0c
jmp 0xad13
movl (%rax), %eax
cmpl (%rcx), %eax
jg 0xad0c
jmp 0xad13
movl (%rax), %eax
cmpl (%rcx), %eax
jg 0xad13
addq $0x30, %rdi
movq (%rdi), %r15
testq %r15, %r15
je 0xad33
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%r15)
cmpl $0x1, %eax
jne 0xad36
addq $0x20, %r15
movq %r15, %rdi
jmp 0xad10
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_if_const_statement
static enum result execute_if_const_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable *lhs = &vars->locals[ this->local ];
	number rhs = ( ( struct block_statement * ) this )->num;
	struct statement *stmt = ( ( struct block_statement * ) this )->if_block;
	enum result ret = OKAY;
	if( lhs->string_value ) {
		if( ( ( struct block_statement * ) this )->oper ) {
			return execute_if_statement( this, vars, result );
		}
	} else {
		switch( ( ( struct block_statement * ) this )->oper ) {
			case  0 : if( lhs->number_value == 0 ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case '!': if( lhs->number_value == rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case '(': if( lhs->number_value >  rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case ')': if( lhs->number_value <  rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case '<': if( lhs->number_value >= rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case '=': if( lhs->number_value != rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case '>': if( lhs->number_value <= rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			default: return execute_if_statement( this, vars, result );
		}
	}
	while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
		stmt = stmt->next;
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rsi), %rax
movslq (%rdi), %rdx
shlq $0x4, %rdx
movq 0x28(%rdi), %r15
cmpq $0x0, 0x8(%rax,%rdx)
movl 0x38(%rdi), %ecx
je 0xad75
testl %ecx, %ecx
je 0xadcd
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xabf1
addq %rdx, %rax
movl 0x40(%rdi), %edx
cmpl $0x3e, %ecx
je 0xadb6
cmpl $0x21, %ecx
je 0xadc2
cmpl $0x28, %ecx
je 0xadbc
cmpl $0x29, %ecx
je 0xada4
cmpl $0x3c, %ecx
je 0xadb0
cmpl $0x3d, %ecx
je 0xadaa
testl %ecx, %ecx
jne 0xad65
cmpl $0x0, (%rax)
jne 0xadcd
jmp 0xadc6
cmpl %edx, (%rax)
jl 0xadc6
jmp 0xadcd
cmpl %edx, (%rax)
jne 0xadc6
jmp 0xadcd
cmpl %edx, (%rax)
jge 0xadc6
jmp 0xadcd
cmpl %edx, (%rax)
jle 0xadc6
jmp 0xadcd
cmpl %edx, (%rax)
jg 0xadc6
jmp 0xadcd
cmpl %edx, (%rax)
jne 0xadcd
addq $0x30, %rdi
movq (%rdi), %r15
testq %r15, %r15
je 0xaded
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%r15)
cmpl $0x1, %eax
jne 0xadf0
addq $0x20, %r15
movq %r15, %rdi
jmp 0xadca
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_while_statement
static enum result execute_while_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct environment *env = vars->func->env;
	struct variable condition = { 0 };
	struct statement *stmt;
	enum result ret;
	while( 1 ) {
		if( this->source->evaluate( this->source, vars, &condition ) ) {
			if( condition.string_value ) {
				dispose_variable( &condition );
			} else if( condition.number_value ) {
				condition.number_value = 0;
			} else {
				return OKAY;
			}
		} else {
			return EXCEPTION;
		}
		stmt = ( ( struct block_statement * ) this )->if_block;
		while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
			stmt = stmt->next;
		}
		if( stmt ) {
			if( ret == RETURN ) {
				return RETURN;
			} else if( ret == BREAK ) {
				return OKAY;
			} else if( ret == EXCEPTION ) {
				return EXCEPTION;
			}
		}
		if( env->interrupted ) {
			return throw_interrupted( vars, this->source );
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rsi), %rax
movq 0x40(%rax), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %r13
movaps %xmm0, (%r13)
leaq 0x28(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x6313(%rip), %r12      # 0x11148
xorl %ebp, %ebp
movq 0x8(%r15), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq *0x18(%rdi)
testl %eax, %eax
je 0xaeb8
cmpq $0x0, 0x8(%rsp)
je 0xae5a
movq %r13, %rdi
callq 0x3896
jmp 0xae64
cmpl $0x0, (%rsp)
je 0xaeb5
andl $0x0, (%rsp)
movq 0x20(%rsp), %r13
movq (%r13), %r13
testq %r13, %r13
je 0xae95
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x10(%r13)
cmpl $0x3, %eax
ja 0xae95
movl %eax, %ecx
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
addq $0x20, %r13
jmp 0xae69
movq 0x18(%rsp), %rax
cmpb $0x0, 0x18(%rax)
movq %rsp, %r13
je 0xae37
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x41a9
jmp 0xaeb8
movl %eax, %ebp
jmp 0xaeb8
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_call_statement
static enum result execute_call_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable var = { 0, NULL };
	enum result ret = this->source->evaluate( this->source, vars, &var );
	if( ret ) {
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
movl %eax, %ebx
testl %eax, %eax
je 0xb291
movq %rsp, %rdi
callq 0x3988
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: parse_catch_block
static struct element* parse_catch_block( struct element *elem,
	struct function *func, struct variables *vars, struct block_statement *try_stmt, char *message ) {
	struct local_variable *local;
	struct statement block = { 0 };
	if( strchr( "Cc", elem->str.string[ 0 ] ) ) {
		elem = elem->next;
		if( elem->str.string[ 0 ] == '(' ) {
			parse_variable_declaration( elem, func, vars, NULL, add_local_variable, message );
			if( message[ 0 ] == 0 ) {
				elem = elem->next;
			}
		}
		if( message[ 0 ] == 0 ) {
			local = get_local_variable( func->variable_decls, elem->str.string, "" );
			if( local ) {
				try_stmt->stmt.local = local->index;
				try_stmt->stmt.execute = execute_try_catch_statement;
			} else {
				sprintf( message, "Undeclared local variable '%.64s' on line %d.", elem->str.string, elem->line );
			}
		}
	} else {
		try_stmt->stmt.execute = execute_try_finally_statement;
	}
	if( message[ 0 ] == 0 ) {
		elem = elem->next;
		if( elem->child ) {
			parse_keywords_indexed( func->env->statements_index, elem->child, func, vars, &block, message );
			try_stmt->else_block = block.next;
		}
		if( message[ 0 ] == 0 ) {
			elem = elem->next;
		}
	}
	return elem;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movaps %xmm0, (%rsp)
movq 0x8(%rdi), %rax
movzbl (%rax), %eax
testl %eax, %eax
je 0xb2dd
cmpl $0x63, %eax
je 0xb2dd
cmpl $0x43, %eax
jne 0xb345
movq 0x20(%rbx), %rbx
movq 0x8(%rbx), %rbp
cmpb $0x28, (%rbp)
jne 0xb319
leaq -0xabc(%rip), %r8       # 0xa836
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
movq %r14, %r9
callq 0x8f8a
cmpb $0x0, (%r14)
jne 0xb391
movq 0x20(%rbx), %rbx
movq 0x8(%rbx), %rbp
jmp 0xb31f
cmpb $0x0, (%r14)
jne 0xb391
movq 0x48(%r13), %rdi
leaq 0x5d2c(%rip), %rdx      # 0x11056
movq %rbp, %rsi
callq 0x5eb5
testq %rax, %rax
je 0xb3a3
movl (%rax), %eax
movl %eax, (%r15)
leaq 0x79(%rip), %rax        # 0xb3bc
jmp 0xb34c
leaq 0x131(%rip), %rax       # 0xb47d
movq %rax, 0x10(%r15)
cmpb $0x0, (%r14)
jne 0xb391
movq 0x20(%rbx), %rbx
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0xb38d
movq 0x40(%r13), %rdi
subq $-0x80, %rdi
movq %rsp, %rbp
movq %r13, %rdx
movq %r12, %rcx
movq %rbp, %r8
movq %r14, %r9
callq 0x69a8
movq 0x20(%rbp), %rax
movq %rax, 0x30(%r15)
cmpb $0x0, (%r14)
jne 0xb391
movq 0x20(%rbx), %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x28(%rbx), %ecx
leaq 0x6abf(%rip), %rsi      # 0x11e6c
movq %r14, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x3200
jmp 0xb350
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_try_catch_statement
static enum result execute_try_catch_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	enum result ret = OKAY;
	int idx = this->local;
	struct variables try_vars;
	struct local_variable *exception_var;
	try_vars.parent = vars->parent;
	try_vars.exception = &vars->locals[ idx ];
	try_vars.locals = vars->locals;
	try_vars.func = vars->func;
	try_vars.line = vars->line;
	ret = execute_statements( ( ( struct block_statement * ) this )->if_block, &try_vars, result );
	if( ret == EXCEPTION ) {
		exception_var = vars->func->variable_decls;
		while( idx-- > 0 )
		{
			exception_var = exception_var->next;
		}
		if( is_exit( try_vars.exception )
		|| ( exception_var->type && !is_instance( try_vars.exception, exception_var->type, NULL, NULL ) ) ) {
			assign_variable( try_vars.exception, vars->exception );
		} else {
			return execute_statements( ( ( struct block_statement * ) this )->else_block, vars, result );
		}
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movslq (%rdi), %r12
movq (%rsi), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x10(%rbx), %rax
movq %r12, %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%rsi)
movl 0x20(%rbx), %eax
movl %eax, 0x20(%rsi)
movq 0x28(%rdi), %rdi
callq 0xb64e
testl %eax, %eax
jne 0xb471
movq 0x18(%rbx), %rax
addq $0x48, %rax
movq (%rax), %rax
testl %r12d, %r12d
jle 0xb426
decl %r12d
addq $0x18, %rax
jmp 0xb415
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xb43a
cmpb $0xa, 0x14(%rcx)
je 0xb466
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0xb450
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x41fd
testl %eax, %eax
je 0xb461
movq 0x30(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xb64e
jmp 0xb471
movq 0x8(%rsp), %rdi
movq 0x8(%rbx), %rsi
callq 0x3996
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_statements
static enum result execute_statements( struct statement *stmt, struct variables *vars, struct variable *result ) {
	enum result ret = OKAY;
	while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
		stmt = stmt->next;
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x1
popq %rbx
testq %r12, %r12
je 0xb683
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%r12)
cmpl $0x1, %eax
jne 0xb681
movq 0x20(%r12), %r12
jmp 0xb662
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_switch_statement
static enum result execute_switch_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	int matched = 0;
	struct expression *case_expr;
	struct variable switch_value = { 0, NULL }, case_value = { 0, NULL };
	struct statement *cases = ( ( struct block_statement * ) this )->if_block;
	struct statement *deflt = ( ( struct block_statement * ) this )->else_block;
	enum result ret = this->source->evaluate( this->source, vars, &switch_value );
	if( ret ) {
		while( cases && ret && !matched ) {
			case_expr = cases->source;
			while( case_expr && ret && !matched ) {
				ret = case_expr->evaluate( case_expr, vars, &case_value );
				if( ret ) {
					matched = compare_variables( &switch_value, &case_value ) == 0;
					dispose_variable( &case_value );
					if( matched ) {
						ret = cases->execute( cases, vars, result );
					}
				}
				case_expr = case_expr->next;
			}
			cases = cases->next;
		}
		if( ret && !matched && deflt ) {
			ret = deflt->execute( deflt, vars, result );
		}
		dispose_temporary( &switch_value );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x30(%rsp)
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq 0x30(%rdi), %rbx
movq %rax, %rdi
callq *0x18(%rax)
testl %eax, %eax
je 0xb7b9
movl %eax, %ebp
movq %rbx, 0x18(%rsp)
xorl %r12d, %r12d
leaq 0x30(%rsp), %r13
testl %r12d, %r12d
jne 0xb784
cmpq $0x0, 0x8(%rsp)
je 0xb784
testl %ebp, %ebp
je 0xb784
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rbx
xorl %r12d, %r12d
testl %r12d, %r12d
jne 0xb771
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xb771
testl %ebp, %ebp
je 0xb771
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq *0x18(%rbx)
xorl %r12d, %r12d
testl %eax, %eax
je 0xb769
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0xb9cc
movl %eax, %r15d
movq %r13, %rdi
callq 0x3896
testl %r15d, %r15d
jne 0xb76b
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
callq *0x10(%rdi)
movl %eax, %ebp
pushq $0x1
popq %r12
jmp 0xb76b
xorl %ebp, %ebp
addq $0x10, %rbx
jmp 0xb70e
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xb6e5
testl %r12d, %r12d
setne %al
testl %ebp, %ebp
sete %cl
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
sete %dl
orb %cl, %dl
orb %al, %dl
jne 0xb7ad
movq %r14, %rsi
movq 0x10(%rsp), %rdx
callq *0x10(%rdi)
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x3988
jmp 0xb7bb
xorl %ebp, %ebp
movl %ebp, %eax
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_case_statement
static struct element* parse_case_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct expression expr = { 0 };
	struct element *next = elem->next;
	struct statement block = { 0 }, *stmt = calloc( 1, sizeof( struct block_statement ) );
	if( stmt ) {
		stmt->dispose = dispose_block_statement;
		prev->next = stmt;
		next = parse_expressions( next, func, vars, '{', &expr, NULL, message );
		stmt->source = expr.next;
		if( message[ 0 ] == 0 ) {
			parse_keywords_indexed( func->env->statements_index, next->child, func, vars, &block, message );
			( ( struct block_statement * ) stmt )->if_block = block.next;
			if( message[ 0 ] == 0 ) {
				stmt->execute = execute_case_statement;
				next = next->next;
			}
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq 0x20(%rdi), %rbx
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x30(%rsp)
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
callq 0x3130
testq %rax, %rax
je 0xb8a0
movq %rax, %r13
leaq -0x7647(%rip), %rax     # 0x41de
movq %rax, 0x18(%r13)
movq %r13, 0x20(%rbp)
movq %r14, (%rsp)
pushq $0x7b
popq %rcx
leaq 0x40(%rsp), %rbp
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %r8
xorl %r9d, %r9d
callq 0x7b36
movq %rax, %rbx
movq 0x10(%rbp), %rax
movq %rax, 0x8(%r13)
cmpb $0x0, (%r14)
jne 0xb8af
movq 0x40(%r12), %rdi
subq $-0x80, %rdi
movq 0x18(%rbx), %rsi
leaq 0x10(%rsp), %rbp
movq %r12, %rdx
movq %r15, %rcx
movq %rbp, %r8
movq %r14, %r9
callq 0x69a8
movq 0x20(%rbp), %rax
movq %rax, 0x28(%r13)
cmpb $0x0, (%r14)
jne 0xb8af
leaq 0xee(%rip), %rax        # 0xb984
movq %rax, 0x10(%r13)
movq 0x20(%rbx), %rbx
jmp 0xb8af
movq 0xc8c9(%rip), %rsi      # 0x18170
movq %r14, %rdi
callq 0x3070
movq %rbx, %rax
addq $0x68, %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_default_statement
static struct element* parse_default_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next;
	struct statement block = { 0 }, *stmt = calloc( 1, sizeof( struct block_statement ) );
	if( stmt ) {
		stmt->dispose = dispose_block_statement;
		prev->next = stmt;
		block.next = NULL;
		parse_keywords_indexed( func->env->statements_index, next->child, func, vars, &block, message );
		( ( struct block_statement * ) stmt )->if_block = block.next;
		if( message[ 0 ] == 0 ) {
			stmt->execute = execute_case_statement;
			next = next->next;
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return elem->next->next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
movq 0x20(%rdi), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x30(%rsp)
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
callq 0x3130
testq %rax, %rax
je 0xb95e
movq %rax, %r13
leaq -0x7733(%rip), %rax     # 0x41de
movq %rax, 0x18(%r13)
movq %r13, 0x20(%rbp)
leaq 0x10(%rsp), %rbp
andq $0x0, 0x20(%rbp)
movq 0x40(%r12), %rdi
subq $-0x80, %rdi
movq 0x18(%r15), %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, %r8
movq %r14, %r9
callq 0x69a8
movq 0x20(%rbp), %rax
movq %rax, 0x28(%r13)
cmpb $0x0, (%r14)
jne 0xb96d
leaq 0x2c(%rip), %rax        # 0xb984
movq %rax, 0x10(%r13)
jmp 0xb96d
movq 0xc80b(%rip), %rsi      # 0x18170
movq %r14, %rdi
callq 0x3070
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rax
addq $0x38, %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: execute_case_statement
static enum result execute_case_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct statement *stmt = ( ( struct block_statement * ) this )->if_block;
	enum result ret = OKAY;
	while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
		stmt = stmt->next;
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
addq $0x28, %r12
pushq $0x1
popq %rbx
movq (%r12), %r12
testq %r12, %r12
je 0xb9be
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%r12)
addq $0x20, %r12
cmpl $0x1, %eax
je 0xb99c
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: compare_variables
static int compare_variables( struct variable *var1, struct variable *var2 ) {
	int result;
	struct string *str1, *str2;
	if( var1->number_value > var2->number_value ) {
		result = 1;
	} else if( var1->number_value < var2->number_value ) {
		result = -1;
	} else if( var1->string_value != var2->string_value ) {
		if( var1->string_value && var2->string_value ) {
			str1 = var1->string_value;
			str2 = var2->string_value;
			if( str1->length > str2->length ) {
				result = memcmp( str1->string, str2->string, sizeof( char ) * str2->length );
			} else {
				result = memcmp( str1->string, str2->string, sizeof( char ) * str1->length );
			}
			if( result == 0 ) {
				result = str1->length - str2->length;
			}
		} else if( var2->string_value ) {
			result = -var2->string_value->length;
		} else {
			result = var1->string_value->length;
		}
	} else {
		result = 0;
	}
	return result;
}

// Assembly:
pushq %rbx
movl (%rsi), %eax
cmpl %eax, (%rdi)
jle 0xb9d7
pushq $0x1
jmp 0xb9db
jge 0xb9e0
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rax
cmpq %rax, %rcx
je 0xba0b
testq %rcx, %rcx
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
je 0xba0f
testq %rax, %rax
je 0xba36
xorl %ebx, %ebx
subl 0x10(%rax), %ebx
jmp 0xb9dc
xorl %ebx, %ebx
jmp 0xb9dc
movl 0x10(%rcx), %edx
movl 0x10(%rax), %r8d
movq 0x8(%rcx), %rdi
movq 0x8(%rax), %rsi
movl %edx, %ebx
subl %r8d, %ebx
cmovll %edx, %r8d
movslq %r8d, %rdx
callq 0x3120
testl %eax, %eax
cmovnel %eax, %ebx
jmp 0xb9dc
movl 0x10(%rcx), %ebx
jmp 0xb9dc
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: execute_save_statement
static enum result execute_save_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	int count;
	char message[ 64 ];
	struct variable str = { 0, NULL }, file = { 0, NULL };
	enum result ret = evaluate_string( this->source, vars, &str );
	if( ret ) {
		ret = evaluate_string( this->source->next, vars, &file );
		if( ret ) {
			count = save_file( file.string_value->string,
				str.string_value->string, str.string_value->length, this->local, message );
			if( count != str.string_value->length ) {
				ret = throw( vars, this->source, 0, message );
			}
			dispose_temporary( &file );
		}
		dispose_temporary( &str );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, (%rsp)
movq 0x8(%rdi), %rdi
callq 0x4284
testl %eax, %eax
je 0xbadb
movq 0x8(%r15), %rax
movq 0x10(%rax), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq 0x4284
testl %eax, %eax
je 0xbadf
movl %eax, %ebx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %r12
movslq 0x10(%rax), %r13
cmpl $0x0, (%r15)
leaq 0x6440(%rip), %rax      # 0x11ee5
leaq 0x6436(%rip), %rsi      # 0x11ee2
cmoveq %rax, %rsi
callq 0x31d0
testq %rax, %rax
je 0xbae3
movq %rax, %rbp
pushq $0x1
popq %rsi
movq %r12, %rdi
movq %r13, %rdx
movq %rax, %rcx
callq 0x3210
movq %rax, %r12
movq %rbp, %rdi
callq 0x30a0
jmp 0xbae7
xorl %ebx, %ebx
jmp 0xbb42
xorl %ebx, %ebx
jmp 0xbb38
pushq $-0x1
popq %r12
cmpl %r13d, %r12d
jge 0xbb10
callq 0x3040
movl (%rax), %edi
callq 0x3220
leaq 0x20(%rsp), %r13
pushq $0x3f
popq %rdx
movq %r13, %rdi
movq %rax, %rsi
callq 0x3050
movb $0x0, 0x3f(%r13)
movq 0x18(%rsp), %rax
cmpl 0x10(%rax), %r12d
je 0xbb30
movq 0x8(%r15), %rsi
xorl %ebx, %ebx
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3bb2
movq %rsp, %rdi
callq 0x3988
leaq 0x10(%rsp), %rdi
callq 0x3988
movl %ebx, %eax
addq $0x68, %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_logical_expression
static enum result evaluate_logical_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	int value;
	struct variable var = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &var );
	if( ret ) {
		value = var.number_value || var.string_value;
		dispose_variable( &var );
		if( this->index == '!' ) {
			value = !value;
		} else {
			while( parameter->next ) {
				parameter = parameter->next;
				if( this->index == '&' ) {
					if( value ) {
						ret = parameter->evaluate( parameter, vars, &var );
						if( ret ) {
							value = var.number_value || var.string_value;
							dispose_variable( &var );
						} else {
							return ret;
						}
					} else {
						break;
					}
				} else {
					if( value ) {
						break;
					} else {
						ret = parameter->evaluate( parameter, vars, &var );
						if( ret ) {
							value = var.number_value || var.string_value;
							dispose_temporary( &var );
						} else {
							return ret;
						}
					}
				}
			}
		}
		result->number_value = value;
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r13
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %r12
movq %r12, %rdi
movq %rsi, 0x18(%rsp)
callq *0x18(%r12)
testl %eax, %eax
je 0xbc95
movl %eax, %r14d
movq %r13, 0x20(%rsp)
movq %rsp, %rdi
cmpl $0x0, (%rdi)
setne %al
cmpq $0x0, 0x8(%rdi)
setne %r13b
orb %al, %r13b
callq 0x3896
cmpl $0x21, 0x4(%r15)
jne 0xbc02
xorb $0x1, %r13b
movzbl %r13b, %eax
andl $0x1, %eax
movq 0x20(%rsp), %rcx
movl %eax, (%rcx)
movl %r14d, %ebx
jmp 0xbc97
movq %rsp, %rbp
xorl %ebx, %ebx
movq 0x10(%r12), %r12
testq %r12, %r12
je 0xbbec
cmpl $0x26, 0x4(%r15)
jne 0xbc57
testb $0x1, %r13b
je 0xbcb0
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq %rbp, %rdx
callq *0x18(%r12)
testl %eax, %eax
je 0xbc97
movl %eax, %r14d
cmpl $0x0, (%rsp)
setne %al
cmpq $0x0, 0x8(%rsp)
setne %r13b
orb %al, %r13b
movq %rbp, %rdi
callq 0x3896
jmp 0xbc07
testb $0x1, %r13b
jne 0xbca8
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq %rbp, %rdx
callq *0x18(%r12)
testl %eax, %eax
je 0xbc95
movl %eax, %r14d
cmpl $0x0, (%rsp)
setne %al
cmpq $0x0, 0x8(%rsp)
setne %r13b
orb %al, %r13b
movq %rbp, %rdi
callq 0x3988
jmp 0xbc07
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r13b
jmp 0xbbec
xorl %r13d, %r13d
jmp 0xbbec
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_ternary_expression
static enum result evaluate_ternary_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable condition = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &condition );
	if( ret ) {
		parameter = parameter->next;
		if( !( condition.number_value || condition.string_value ) ) {
			parameter = parameter->next;
		}
		ret = parameter->evaluate( parameter, vars, result );
		dispose_temporary( &condition );
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %r15
movq %r15, %rdi
callq *0x18(%r15)
testl %eax, %eax
je 0xbd0a
movq 0x10(%r15), %rdi
cmpl $0x0, (%rsp)
jne 0xbcf5
cmpq $0x0, 0x8(%rsp)
jne 0xbcf5
movq 0x10(%rdi), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rdi)
movl %eax, %ebx
movq %rsp, %rdi
callq 0x3988
jmp 0xbd0c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_same_expression
static enum result evaluate_same_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable lhs = { 0, NULL }, rhs = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &lhs );
	if( ret ) {
		parameter = parameter->next;
		ret = parameter->evaluate( parameter, vars, &rhs );
		if( ret ) {
			result->number_value = ( lhs.number_value == rhs.number_value )
				&& ( lhs.string_value == rhs.string_value );
			dispose_temporary( &rhs );
		}
		dispose_temporary( &lhs );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rsp)
movq 0x8(%rdi), %r15
movq %r15, %rdi
callq *0x18(%r15)
testl %eax, %eax
je 0xbd89
movq 0x10(%r15), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq *0x18(%rdi)
movl %eax, %ebp
testl %eax, %eax
je 0xbd7f
movl (%rsp), %eax
leaq 0x10(%rsp), %rdi
cmpl (%rdi), %eax
sete %al
movq 0x8(%rdi), %rcx
cmpq %rcx, 0x8(%rsp)
sete %cl
andb %al, %cl
movzbl %cl, %eax
movl %eax, (%rbx)
callq 0x3988
movq %rsp, %rdi
callq 0x3988
jmp 0xbd8b
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_eq_expression
static enum result evaluate_eq_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable lhs = { 0, NULL }, rhs = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &lhs );
	if( ret ) {
		parameter = parameter->next;
		ret = parameter->evaluate( parameter, vars, &rhs );
		if( ret ) {
			result->number_value = compare_variables( &lhs, &rhs ) == 0;
			dispose_temporary( &rhs );
		}
		dispose_temporary( &lhs );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, (%rsp)
movq 0x8(%rdi), %r15
movq %r15, %rdi
callq *0x18(%r15)
testl %eax, %eax
je 0xbe06
movq 0x10(%r15), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq *0x18(%rdi)
movl %eax, %ebp
testl %eax, %eax
je 0xbdfa
leaq 0x10(%rsp), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xb9cc
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, (%rbx)
movq %r14, %rdi
callq 0x3988
leaq 0x10(%rsp), %rdi
callq 0x3988
jmp 0xbe08
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_cmp_expression
static enum result evaluate_cmp_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable var1 = { 0, NULL }, var2 = { 0, NULL };
	enum result ret = parameter->evaluate( parameter, vars, &var1 );
	if( ret ) {
		parameter = parameter->next;
		ret = parameter->evaluate( parameter, vars, &var2 );
		if( ret ) {
			result->number_value = compare_variables( &var1, &var2 );
			dispose_temporary( &var2 );
		}
		dispose_temporary( &var1 );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, (%rsp)
movq %r15, %rdi
callq *0x18(%r15)
testl %eax, %eax
je 0xc09c
movq 0x10(%r15), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq *0x18(%rdi)
movl %eax, %ebp
testl %eax, %eax
je 0xc090
leaq 0x10(%rsp), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xb9cc
movl %eax, (%rbx)
movq %r14, %rdi
callq 0x3988
leaq 0x10(%rsp), %rdi
callq 0x3988
jmp 0xc09e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_asc_expression
static enum result evaluate_asc_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct string *str;
	int val;
	enum result ret = evaluate_integer( this->parameters, vars, &val );
	if( ret ) {
		str = new_string( 1 );
		if( str ) {
			str->string[ 0 ] = val;
			result->string_value = str;
		} else {
			ret = throw_out_of_memory( vars, this );
		}
	}
	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
movq 0x8(%rdi), %rdi
leaq 0xc(%rsp), %rdx
callq 0x4514
xorl %ebp, %ebp
testl %eax, %eax
je 0xc26e
movl %eax, %r12d
pushq $0x1
popq %rdi
callq 0x3723
testq %rax, %rax
je 0xc263
movb 0xc(%rsp), %cl
movq 0x8(%rax), %rdx
movb %cl, (%rdx)
movq %rax, 0x8(%rbx)
movl %r12d, %ebp
jmp 0xc26e
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c90
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_hex_expression
static enum result evaluate_hex_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	int len, val;
	struct string *str;
	enum result ret = evaluate_integer( this->parameters, vars, &val );
	if( ret ) {
		str = new_string( sizeof( int ) * 2 + 2 );
		if( str ) {
			len = sprintf( str->string, "0x%08X", val );
			if( len > 0 ) {
				str->length = len;
				result->string_value = str;
			} else {
				unref_string( str );
				ret = throw( vars, this, len, "Output error." );
			}
		} else {
			ret = throw_out_of_memory( vars, this );
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0xc(%rsp), %rdx
callq 0x4514
xorl %ebx, %ebx
testl %eax, %eax
je 0xc319
movl %eax, %ebp
pushq $0xa
popq %rdi
callq 0x3723
testq %rax, %rax
je 0xc2ef
movq %rax, %r13
movq %r12, 0x10(%rsp)
movq 0x8(%rax), %rdi
movl 0xc(%rsp), %edx
leaq 0x5d96(%rip), %rsi      # 0x12064
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3200
movl %eax, %r12d
testl %eax, %eax
jle 0xc2fc
movl %r12d, 0x10(%r13)
movq 0x10(%rsp), %rax
movq %r13, 0x8(%rax)
movl %ebp, %ebx
jmp 0xc319
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c90
jmp 0xc319
movq %r13, %rdi
callq 0x38b2
leaq 0x5d60(%rip), %rcx      # 0x1206b
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x3bb2
movl %ebx, %eax
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_int_expression
static enum result evaluate_int_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable str = { 0, NULL };
	enum result ret = this->parameters->evaluate( this->parameters, vars, &str );
	if( ret ) {
		if( str.string_value ) {
			if( str.string_value->type > ELEMENT ) {
				ret = to_num( &str, &str.number_value, vars, this->parameters );
			} else if( !parse_number( str.string_value->string, &str.number_value ) ) {
				ret = throw( vars, this, 0, "Unable to convert string to integer." );
			}
			dispose_temporary( &str );
		}
		if( ret ) {
			result->number_value = ( long_int ) str.number_value;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
xorl %ebp, %ebp
testl %eax, %eax
je 0xc3bc
movl %eax, %r14d
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xc3b4
cmpb $0x2, 0x14(%rax)
jl 0xc380
movq 0x8(%r12), %rcx
movq %rsp, %rdi
movq %rdi, %rsi
movq %r15, %rdx
callq 0x4399
movl %eax, %r14d
jmp 0xc3a7
movq 0x8(%rax), %rdi
movq %rsp, %rsi
callq 0x4b5c
testl %eax, %eax
jne 0xc3a7
leaq 0x5ce2(%rip), %rcx      # 0x12079
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3bb2
movq %rsp, %rdi
callq 0x3988
testl %r14d, %r14d
je 0xc3bc
movl (%rsp), %eax
movl %eax, (%rbx)
movl %r14d, %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: evaluate_num_expression
static enum result evaluate_num_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable str = { 0, NULL };
	enum result ret = this->parameters->evaluate( this->parameters, vars, &str );
	if( ret ) {
		if( str.string_value ) {
			if( str.string_value->type > ELEMENT ) {
				ret = to_num( &str, &str.number_value, vars, this->parameters );
			} else if( !( parse_number( str.string_value->string, &str.number_value ) ) ) {
				ret = throw( vars, this, 0, "Unable to convert string to number." );
			}
			dispose_temporary( &str );
		}
		if( ret ) {
			result->number_value = str.number_value;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
xorl %ebp, %ebp
testl %eax, %eax
je 0xc45d
movl %eax, %r14d
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xc455
cmpb $0x2, 0x14(%rax)
jl 0xc421
movq 0x8(%r12), %rcx
movq %rsp, %rdi
movq %rdi, %rsi
movq %r15, %rdx
callq 0x4399
movl %eax, %r14d
jmp 0xc448
movq 0x8(%rax), %rdi
movq %rsp, %rsi
callq 0x4b5c
testl %eax, %eax
jne 0xc448
leaq 0x5c66(%rip), %rcx      # 0x1209e
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3bb2
movq %rsp, %rdi
callq 0x3988
testl %r14d, %r14d
je 0xc45d
movl (%rsp), %eax
movl %eax, (%rbx)
movl %r14d, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq