LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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)
movq $0x0, 0x30(%rsp)
movl $0x1, %edi
movl $0x48, %esi
callq 0x3130
testq %rax, %rax
je 0xc443
movq %rax, %r13
leaq -0x800e(%rip), %rax     # 0x43b8
movq %rax, 0x18(%r13)
movq %r13, 0x20(%rbp)
movq %r14, (%rsp)
leaq 0x40(%rsp), %rbp
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x7b, %ecx
movq %rbp, %r8
xorl %r9d, %r9d
callq 0x8314
movq %rax, %rbx
movq 0x10(%rbp), %rax
movq %rax, 0x8(%r13)
cmpb $0x0, (%r14)
jne 0xc452
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 0x6fe6
movq 0x20(%rbp), %rax
movq %rax, 0x28(%r13)
cmpb $0x0, (%r14)
jne 0xc452
leaq 0xfa(%rip), %rax        # 0xc533
movq %rax, 0x10(%r13)
movq 0x20(%rbx), %rbx
jmp 0xc452
movq 0xcd26(%rip), %rsi      # 0x19170
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_O1/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, %r13
movq %rdi, %rbx
movq 0x20(%rdi), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x1, %edi
movl $0x48, %esi
callq 0x3130
testq %rax, %rax
je 0xc50d
movq %rax, %r12
leaq -0x8103(%rip), %rax     # 0x43b8
movq %rax, 0x18(%r12)
movq %r12, 0x20(%rbp)
leaq 0x10(%rsp), %rbp
movq $0x0, 0x20(%rbp)
movq 0x40(%r13), %rdi
subq $-0x80, %rdi
movq 0x18(%r15), %rsi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, %r8
movq %r14, %r9
callq 0x6fe6
movq 0x20(%rbp), %rax
movq %rax, 0x28(%r12)
cmpb $0x0, (%r14)
jne 0xc51c
leaq 0x2d(%rip), %rax        # 0xc533
movq %rax, 0x10(%r12)
jmp 0xc51c
movq 0xcc5c(%rip), %rsi      # 0x19170
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_O1/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 0x28(%rdi), %r12
movl $0x1, %ebx
testq %r12, %r12
je 0xc570
movq %rdx, %r14
movq %rsi, %r15
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%r12)
cmpl $0x1, %eax
jne 0xc56e
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0xc54f
jmp 0xc570
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: 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
movl $0x1, %ebx
cmpl %eax, (%rdi)
jg 0xc5ea
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jl 0xc5ea
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rax
cmpq %rax, %rcx
je 0xc5bc
testq %rcx, %rcx
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
je 0xc5c0
testq %rax, %rax
je 0xc5e7
xorl %ebx, %ebx
subl 0x10(%rax), %ebx
jmp 0xc5ea
xorl %ebx, %ebx
jmp 0xc5ea
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 0xc5ea
movl 0x10(%rcx), %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x445f
testl %eax, %eax
je 0xc690
movq 0x8(%r15), %rax
movq 0x10(%rax), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq 0x445f
testl %eax, %eax
je 0xc694
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 0x6851(%rip), %rax      # 0x12ea9
leaq 0x6847(%rip), %rsi      # 0x12ea6
cmoveq %rax, %rsi
callq 0x31d0
testq %rax, %rax
je 0xc698
movq %rax, %rbp
movl $0x1, %esi
movq %r12, %rdi
movq %r13, %rdx
movq %rax, %rcx
callq 0x3210
movq %rax, %r12
movq %rbp, %rdi
callq 0x30a0
jmp 0xc69e
xorl %ebx, %ebx
jmp 0xc707
xorl %ebx, %ebx
jmp 0xc6f8
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl %r13d, %r12d
jge 0xc6c9
callq 0x3040
movl (%rax), %edi
callq 0x3220
leaq 0x20(%rsp), %r13
movl $0x3f, %edx
movq %r13, %rdi
movq %rax, %rsi
callq 0x3050
movb $0x0, 0x3f(%r13)
movq 0x18(%rsp), %rax
cmpl 0x10(%rax), %r12d
je 0xc6e9
movq 0x8(%r15), %rsi
xorl %ebx, %ebx
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3cc3
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc6f8
callq 0x3979
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc707
callq 0x3979
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_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_unary_expression
static enum result evaluate_unary_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable var = { 0, NULL };
	enum result ret = this->parameters->evaluate( this->parameters, vars, &var );
	if( ret ) {
#if defined( FLOATING_POINT )
		switch( this->index ) {
			case 1: result->number_value = ~( ( long_int ) var.number_value ); break;
			case 2: result->number_value = log( var.number_value ); break;
			case 3: result->number_value = exp( var.number_value ); break;
			case 4: result->number_value = sqrt( var.number_value ); break;
			case 5: result->number_value = sin( var.number_value ); break;
			case 6: result->number_value = cos( var.number_value ); break;
			case 7: result->number_value = tan( var.number_value ); break;
			case 8: result->number_value = asin( var.number_value ); break;
			case 9: result->number_value = acos( var.number_value ); break;
			case 10:result->number_value = atan( var.number_value ); break;
		}
#else
		result->number_value = ~var.number_value;
#endif
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
movl %eax, %ebp
testl %eax, %eax
je 0xc74d
movl (%rsp), %eax
notl %eax
movl %eax, (%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc74d
callq 0x3979
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x18, %rsp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %r12
movq %r12, %rdi
callq *0x18(%r12)
testl %eax, %eax
je 0xc884
movl %eax, %ebx
movq %r13, 0x10(%rsp)
cmpl $0x0, (%rsp)
setne %r13b
movq 0x8(%rsp), %rdi
movl $0x0, (%rsp)
testq %rdi, %rdi
setne %bpl
je 0xc7bc
callq 0x3979
movq $0x0, 0x8(%rsp)
orb %bpl, %r13b
cmpl $0x21, 0x4(%r15)
jne 0xc7cf
xorb $0x1, %r13b
jmp 0xc88b
movq 0x10(%r12), %r12
testq %r12, %r12
je 0xc88b
xorl %ebp, %ebp
cmpl $0x26, 0x4(%r15)
jne 0xc83a
testb $0x1, %r13b
je 0xc888
movq %r12, %rdi
movq %r14, %rsi
movq %rsp, %rdx
callq *0x18(%r12)
testl %eax, %eax
je 0xc89b
movl %eax, %ebx
cmpl $0x0, (%rsp)
setne %al
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
setne %r13b
orb %al, %r13b
movl $0x0, (%rsp)
testq %rdi, %rdi
je 0xc874
callq 0x3979
movq $0x0, 0x8(%rsp)
jmp 0xc874
testb $0x1, %r13b
jne 0xc88b
movq %r12, %rdi
movq %r14, %rsi
movq %rsp, %rdx
callq *0x18(%r12)
testl %eax, %eax
je 0xc884
movl %eax, %ebx
cmpl $0x0, (%rsp)
setne %al
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
setne %r13b
orb %al, %r13b
testq %rdi, %rdi
je 0xc874
callq 0x3979
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0xc7df
jmp 0xc88b
xorl %ebp, %ebp
jmp 0xc89b
xorl %r13d, %r13d
movzbl %r13b, %eax
andl $0x1, %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movl %ebx, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_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 0xc905
movq 0x10(%r15), %rdi
cmpl $0x0, (%rsp)
jne 0xc8e9
cmpq $0x0, 0x8(%rsp)
jne 0xc8e9
movq 0x10(%rdi), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rdi)
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc907
callq 0x3979
jmp 0xc907
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
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 0xc98d
movq 0x10(%r15), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x18(%rdi)
movl %eax, %ebx
testl %eax, %eax
je 0xc97c
movl 0x10(%rsp), %eax
cmpl (%rsp), %eax
sete %al
movq 0x8(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
sete %cl
andb %al, %cl
movzbl %cl, %eax
movl %eax, (%r14)
testq %rdi, %rdi
je 0xc97c
callq 0x3979
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc98f
callq 0x3979
jmp 0xc98f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
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 0xca14
movq 0x10(%r15), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x18(%rdi)
movl %eax, %ebx
testl %eax, %eax
je 0xca03
leaq 0x10(%rsp), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0xc57e
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, (%r14)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xca03
callq 0x3979
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xca16
callq 0x3979
jmp 0xca16
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
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 0xcd20
movq 0x10(%r15), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x18(%rdi)
movl %eax, %ebx
testl %eax, %eax
je 0xcd0f
leaq 0x10(%rsp), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0xc57e
movl %eax, (%r14)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xcd0f
callq 0x3979
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xcd22
callq 0x3979
jmp 0xcd22
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rdi
leaq 0x4(%rsp), %rdx
callq 0x4714
testl %eax, %eax
je 0xcf47
movl %eax, %ebx
movl $0x1a, %edi
callq 0x31b0
testq %rax, %rax
je 0xcf4b
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movb $0x0, 0x19(%rax)
movq $0x1, (%rax)
movl $0x1, 0x10(%rax)
movb 0x4(%rsp), %cl
movb %cl, 0x18(%rax)
movq %rax, 0x8(%r14)
jmp 0xcf61
xorl %ebx, %ebx
jmp 0xcf61
movq 0xc21e(%rip), %rcx      # 0x19170
xorl %ebx, %ebx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3cc3
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: 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, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0xc(%rsp), %rdx
callq 0x4714
testl %eax, %eax
je 0xd00a
movl %eax, %ebp
movl $0x23, %edi
callq 0x31b0
testq %rax, %rax
je 0xd00f
movq %rax, %r13
movq %r15, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, %rdi
addq $0x18, %rdi
movq %rdi, 0x8(%rax)
movb $0x0, 0x22(%rax)
movq $0x1, (%rax)
movl $0xa, 0x10(%rax)
movl 0xc(%rsp), %edx
leaq 0x603f(%rip), %rsi      # 0x13026
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x3200
movl %eax, %r15d
testl %eax, %eax
jle 0xd023
movl %r15d, 0x10(%r13)
movq 0x10(%rsp), %rax
movq %r13, 0x8(%rax)
movl %ebp, %r12d
jmp 0xd040
xorl %r12d, %r12d
jmp 0xd040
movq 0xc15a(%rip), %rcx      # 0x19170
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
jmp 0xd03b
movq %r13, %rdi
callq 0x3979
leaq 0x5ffb(%rip), %rcx      # 0x1302d
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x3cc3
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_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 0xd0eb
movl %eax, %r14d
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xd0de
cmpb $0x2, 0x14(%rax)
jl 0xd0a8
movq 0x8(%r12), %rcx
movq %rsp, %rdi
movq %rdi, %rsi
movq %r15, %rdx
callq 0x4585
movl %eax, %r14d
jmp 0xd0cf
movq 0x8(%rax), %rdi
movq %rsp, %rsi
callq 0x4d7d
testl %eax, %eax
jne 0xd0cf
leaq 0x5f7c(%rip), %rcx      # 0x1303b
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3cc3
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd0de
callq 0x3979
testl %r14d, %r14d
je 0xd0eb
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_O1/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 0xd193
movl %eax, %r14d
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xd186
cmpb $0x2, 0x14(%rax)
jl 0xd150
movq 0x8(%r12), %rcx
movq %rsp, %rdi
movq %rdi, %rsi
movq %r15, %rdx
callq 0x4585
movl %eax, %r14d
jmp 0xd177
movq 0x8(%rax), %rdi
movq %rsp, %rsi
callq 0x4d7d
testl %eax, %eax
jne 0xd177
leaq 0x5ef9(%rip), %rcx      # 0x13060
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3cc3
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd186
callq 0x3979
testl %r14d, %r14d
je 0xd193
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_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_len_expression
static enum result evaluate_len_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable var = { 0, NULL };
	enum result ret = OKAY;
	struct string *str;
	if( parameter->evaluate == evaluate_local ) {
		str = vars->locals[ parameter->index ].string_value;
	} else {
		ret = parameter->evaluate( parameter, vars, &var );
		str = var.string_value;
	}
	if( ret ) {
		if( str ) {
			switch( str->type ) {
				default:
				case STRING:
					result->number_value = str->length;
					break;
				case ARRAY:
					result->number_value = ( ( struct array * ) str )->length;
					break;
				case STRUCT:
					result->number_value = ( ( struct structure * ) str )->length;
					break;
			}
		} else {
			ret = throw( vars, this, 0, "Not a string or array." );
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq 0x18(%rdi), %rax
leaq -0x8fbf(%rip), %rcx     # 0x420d
cmpq %rcx, %rax
je 0xd1e2
movq %rsp, %rdx
movq %r12, %rsi
callq *%rax
movl %eax, %ebx
leaq 0x8(%rsp), %rax
jmp 0xd1fb
movq 0x10(%r12), %rax
movslq 0x4(%rdi), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x8, %rax
movl $0x1, %ebx
testl %ebx, %ebx
je 0xd21a
movq (%rax), %rax
testq %rax, %rax
je 0xd21e
movzbl 0x14(%rax), %ecx
cmpl $0x2, %ecx
je 0xd236
cmpl $0x3, %ecx
jne 0xd23b
movl 0x18(%rax), %eax
jmp 0xd23e
xorl %ebx, %ebx
jmp 0xd250
leaq 0x5dea(%rip), %rcx      # 0x1300f
xorl %ebx, %ebx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3cc3
jmp 0xd241
movl 0x40(%rax), %eax
jmp 0xd23e
movl 0x10(%rax), %eax
movl %eax, (%r14)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd250
callq 0x3979
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_tup_expression
static enum result evaluate_tup_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable str = { 0, NULL };
	enum result ret = parameter->evaluate( parameter, vars, &str );
	if( ret ) {
		parameter = parameter->next;
		if( str.string_value ) {
			ret = evaluate_number( parameter, vars, &str.number_value );
			if( ret ) {
				result->number_value = str.number_value;
				result->string_value = str.string_value;
			} else {
				dispose_temporary( &str );
			}
		} else {
			str.number_value = 0;
			ret = parameter->evaluate( parameter, vars, &str );
			if( ret ) {
				result->number_value = str.number_value;
			}
			dispose_temporary( &str );
		}
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rdi), %r12
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq %r12, %rdi
callq *0x18(%r12)
xorl %ebx, %ebx
testl %eax, %eax
je 0xd2e3
movq 0x10(%r12), %rdi
cmpq $0x0, 0x8(%rsp)
je 0xd2b9
movq %rsp, %rdx
movq %r15, %rsi
callq 0x463a
testl %eax, %eax
je 0xd2d4
movl (%rsp), %ecx
movl %ecx, (%r14)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%r14)
movl %eax, %ebx
jmp 0xd2e3
movq %rsp, %rdx
movl $0x0, (%rdx)
movq %r15, %rsi
callq *0x18(%rdi)
movl %eax, %ebx
testl %eax, %eax
je 0xd2d4
movl (%rsp), %eax
movl %eax, (%r14)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd2e3
callq 0x3979
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_read_expression
static enum result evaluate_read_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	int count;
	char message[ 64 ];
	struct string *str;
	enum result ret = evaluate_integer( this->parameters, vars, &count );
	if( ret ) {
		if( count >= 0 ) {
			str = new_string( count );
			if( str ) {
				clearerr( stdin );
				if( count > 0 ) {
					count = fread( str->string, 1, count, stdin );
					str->string[ count ] = 0;
					str->length = count;
				}
				if( ferror( stdin ) ) {
					unref_string( str );
					strncpy( message, strerror( errno ), 63 );
					message[ 63 ] = 0;
					ret = throw( vars, this, 0, message );
				} else {
					result->string_value = str;
				}
			} else {
				ret = throw_out_of_memory( vars, this );
			}
		} else {
			ret = throw( vars, this, count, "Invalid length." );
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0xc(%rsp), %rdx
callq 0x4714
xorl %r12d, %r12d
testl %eax, %eax
je 0xd62a
movslq 0xc(%rsp), %r13
testq %r13, %r13
js 0xd601
movl %eax, %ebp
leaq 0x19(%r13), %rdi
callq 0x31b0
testq %rax, %rax
je 0xd613
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r12)
movb $0x0, 0x18(%r12,%r13)
movq $0x1, (%r12)
movl %r13d, 0x10(%r12)
movq 0xb9fd(%rip), %rax      # 0x18f70
movq (%rax), %rdi
callq 0x3170
testl %r13d, %r13d
je 0xd5b0
movq 0x8(%r12), %rdi
movq 0xb9e4(%rip), %rax      # 0x18f70
movq (%rax), %rcx
movl $0x1, %esi
movq %r13, %rdx
callq 0x3090
movl %eax, 0xc(%rsp)
movq 0x8(%r12), %rcx
cltq
movb $0x0, (%rcx,%rax)
movl %eax, 0x10(%r12)
movq 0xb9b9(%rip), %rax      # 0x18f70
movq (%rax), %rdi
callq 0x3080
testl %eax, %eax
je 0xd63c
movq %r12, %rdi
callq 0x3979
callq 0x3040
movl (%rax), %edi
callq 0x3220
leaq 0x10(%rsp), %r15
movl $0x3f, %edx
movq %r15, %rdi
movq %rax, %rsi
callq 0x3050
movb $0x0, 0x3f(%r15)
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
jmp 0xd625
leaq 0x5a91(%rip), %rcx      # 0x13099
movq %r14, %rdi
movq %rbx, %rsi
movl %r13d, %edx
jmp 0xd625
movq 0xbb56(%rip), %rcx      # 0x19170
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3cc3
movl %r12d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, 0x8(%r15)
movl %ebp, %r12d
jmp 0xd62a
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_flen_expression
static enum result evaluate_flen_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	long len;
	char message[ 64 ];
	struct variable file = { 0, NULL };
	enum result ret = evaluate_string( this->parameters, vars, &file );
	if( ret ) {
		len = load_file( file.string_value->string, NULL, 0, 0, message );
		if( len >= 0 ) {
			if( len < MAX_INTEGER ) {
				result->number_value = len;
			} else {
				ret = throw( vars, this, 0, "File too large." );
			}
		} else {
			ret = throw( vars, this, 0, message );
		}
		dispose_temporary( &file );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq 0x445f
testl %eax, %eax
je 0xd6a2
movl %eax, %ebp
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
xorl %ebx, %ebx
leaq 0x10(%rsp), %r8
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x383d
testq %rax, %rax
js 0xd6a6
cmpq $0x7ffffffe, %rax       # imm = 0x7FFFFFFE
jg 0xd6ad
movl %eax, (%r12)
movl %ebp, %ebx
jmp 0xd6c3
xorl %ebx, %ebx
jmp 0xd6d2
leaq 0x10(%rsp), %rcx
jmp 0xd6b6
leaq 0x5570(%rip), %rcx      # 0x12c24
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3cc3
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd6d2
callq 0x3979
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_stridx_expression
static enum result evaluate_stridx_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable str = { 0, NULL }, sep = { 0, NULL };
	int idx;
	enum result ret = evaluate_string( parameter, vars, &str );
	if( ret ) {
		parameter = parameter->next;
		ret = evaluate_string( parameter, vars, &sep );
		if( ret ) {
			parameter = parameter->next;
			if( parameter ) {
				ret = evaluate_integer( parameter, vars, &idx );
			} else {
				idx = -1;
			}
			if( ret ) {
				if( str.string_value->length > 0 && str.string_value->length > idx ) {
					result->number_value = str_idx( str.string_value->string, sep.string_value->string, idx );
				} else {
					ret = throw( vars, this, idx, "String index out of bounds." );
				}
			}
			dispose_temporary( &sep );
		}
		dispose_temporary( &str );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %r12
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rsp)
movq %r12, %rdi
callq 0x445f
testl %eax, %eax
je 0xd74c
movq 0x10(%r12), %r13
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x445f
testl %eax, %eax
je 0xd750
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0xd754
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x4714
movl %eax, %r12d
jmp 0xd75f
xorl %ebp, %ebp
jmp 0xd7c7
xorl %ebp, %ebp
jmp 0xd7b8
movl %eax, %r12d
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
xorl %ebp, %ebp
testl %r12d, %r12d
je 0xd7a9
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
testl %ecx, %ecx
jle 0xd793
movl 0xc(%rsp), %edx
cmpl %edx, %ecx
jle 0xd793
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x94a1
movl %eax, (%rbx)
movl %r12d, %ebp
jmp 0xd7a9
movl 0xc(%rsp), %edx
leaq 0x4aa1(%rip), %rcx      # 0x1223f
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cc3
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xd7b8
callq 0x3979
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xd7c7
callq 0x3979
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_argv_expression
static enum result evaluate_argv_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	int idx;
	char *val;
	struct string *str;
	enum result ret = evaluate_integer( this->parameters, vars, &idx );
	if( ret ) {
		if( idx >= 0 && idx < vars->func->env->argc ) {
			val = vars->func->env->argv[ idx ];
			str = new_string( strlen( val ) );
			if( str ) {
				memcpy( str->string, val, sizeof( char ) * str->length );
				result->string_value = str;
			} else {
				ret = throw_out_of_memory( vars, this );
			}
		} else {
			ret = throw( vars, this, idx, "Command-line argument index out of bounds." );
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0x4(%rsp), %rdx
callq 0x4714
xorl %r12d, %r12d
testl %eax, %eax
je 0xd8c2
movslq 0x4(%rsp), %rdx
testq %rdx, %rdx
js 0xd8b0
movl %eax, %ebp
movq 0x18(%r15), %rax
movq 0x40(%rax), %rax
cmpl 0xc(%rax), %edx
jge 0xd8b0
movq 0x10(%rax), %rax
movq (%rax,%rdx,8), %rdi
movq %rdi, 0x10(%rsp)
callq 0x30c0
movq %rax, %r13
movslq %r13d, %rcx
movq %rcx, 0x8(%rsp)
leaq 0x19(%rcx), %rdi
callq 0x31b0
testq %rax, %rax
je 0xd8d4
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r12)
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%r12,%rax)
movq $0x1, (%r12)
movl %r13d, 0x10(%r12)
movq 0x8(%r12), %rdi
movslq %r13d, %rdx
movq 0x10(%rsp), %rsi
callq 0x3180
movq %r12, 0x8(%rbx)
movl %ebp, %r12d
jmp 0xd8c2
leaq 0x57f2(%rip), %rcx      # 0x130a9
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cc3
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb895(%rip), %rcx      # 0x19170
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
jmp 0xd8bd
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_time_expression
static enum result evaluate_time_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	enum result ret = OKAY;
	time_t seconds = time( NULL );
	struct string *str = NULL;
	char *time_str;
	if( vars->func->env->worker == NULL ) {
		time_str = ctime( &seconds );
		str = new_string( strlen( time_str ) - 1 );
		if( str ) {
			memcpy( str->string, time_str, sizeof( char ) * str->length );
		} else {
			ret = throw_out_of_memory( vars, this );
		}
	}
	if( ret ) {
		result->number_value = seconds;
		result->string_value = str;
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x31a0
movq %rax, 0x10(%rsp)
movq 0x18(%r12), %rax
movq 0x40(%rax), %rcx
movl $0x1, %ebp
xorl %eax, %eax
cmpq $0x0, 0x3a0(%rcx)
jne 0xd9b6
movq %rbx, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x30b0
movq %rax, %r13
movq %rax, %rdi
callq 0x30c0
decl %eax
movslq %eax, %rbx
leaq 0x19(%rbx), %rdi
callq 0x31b0
testq %rax, %rax
je 0xd996
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r14)
movb $0x0, 0x18(%r14,%rbx)
movq $0x1, (%r14)
movl %ebx, 0x10(%r14)
movq 0x8(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x3180
xorl %eax, %eax
jmp 0xd9b1
movq 0xb7d3(%rip), %rcx      # 0x19170
xorl %r14d, %r14d
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3cc3
movb $0x1, %al
xorl %ebp, %ebp
movq 0x8(%rsp), %rbx
testb %al, %al
jne 0xd9c4
movl 0x10(%rsp), %eax
movl %eax, (%rbx)
movq %r14, 0x8(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_parse_expression
static enum result evaluate_parse_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable str = { 0, NULL };
	struct element *elem;
	char message[ 128 ] = "";
	enum result ret = evaluate_string( parameter, vars, &str );
	if( ret ) {
		elem = parse_element( str.string_value->string, vars->func->env->element_depth, message );
		if( message[ 0 ] == 0 ) {
			result->string_value = &elem->str;
		} else {
			ret = throw( vars, this, 0, message );
		}
		dispose_temporary( &str );
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
callq 0x445f
testl %eax, %eax
je 0xda6f
movl %eax, %ebx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%r15), %rax
movq 0x40(%rax), %rax
movl 0x8(%rax), %esi
leaq 0x10(%rsp), %r13
movq %r13, %rdx
callq 0x7906
cmpb $0x0, (%r13)
je 0xda73
xorl %ebx, %ebx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3cc3
jmp 0xda78
xorl %ebx, %ebx
jmp 0xda87
movq %rax, 0x8(%r12)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xda87
callq 0x3979
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_unparse_expression
static enum result evaluate_unparse_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	int len;
	struct string *str;
	struct element *elem;
	struct expression *parameter = this->parameters;
	struct environment *env = vars->func->env;
	struct variable var = { 0, NULL };
	enum result ret = evaluate_element( parameter, vars, &var, 0 );
	if( ret ) {
		elem = ( struct element * ) var.string_value;
		if( ( size_t ) &ret < env->stack_limit || ( elem->line < 1 && !check_element_depth( elem, env->element_depth ) ) ) {
			ret = throw_stack_overflow( vars, this );
		} else {
			len = write_element( elem, NULL );
			if( len >= 0 ) {
				str = new_string( len );
				if( str ) {
					write_element( elem, str->string );
					result->string_value = str;
				} else {
					ret = throw_out_of_memory( vars, this );
				}
			} else {
				ret = throw( vars, this, 0, "String too large." );
			}
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x18(%rsi), %rax
movq 0x40(%rax), %r13
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
xorl %ecx, %ecx
callq 0x44a9
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0xdbaa
leaq 0x4(%rsp), %rax
cmpq %rax, (%r13)
jbe 0xdaf2
leaq 0x476e(%rip), %rcx      # 0x1225b
jmp 0xdb86
movq 0x18(%rsp), %r12
cmpl $0x0, 0x28(%r12)
jg 0xdb0f
movl 0x8(%r13), %esi
movq %r12, %rdi
callq 0x7367
testl %eax, %eax
je 0xdae6
movq %r12, %rdi
xorl %esi, %esi
callq 0xe856
testl %eax, %eax
js 0xdb76
movl %eax, %ebp
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
leaq 0x19(%rcx), %rdi
callq 0x31b0
testq %rax, %rax
je 0xdb7f
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r13)
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%r13,%rax)
movq $0x1, (%r13)
movl %ebp, 0x10(%r13)
movq 0x8(%r13), %rsi
movq %r12, %rdi
callq 0xe856
movq %r13, 0x8(%rbx)
jmp 0xdb9b
leaq 0x546b(%rip), %rcx      # 0x12fe8
jmp 0xdb86
movq 0xb5ea(%rip), %rcx      # 0x19170
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3cc3
movl $0x0, 0x4(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xdbaa
callq 0x3979
movl 0x4(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_next_expression
static enum result evaluate_next_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable prev = { 0, NULL };
	struct element *next;
	enum result ret = evaluate_element( parameter, vars, &prev, 0 );
	if( ret ) {
		next = ( ( struct element * ) prev.string_value )->next;
		if( next ) {
			result->string_value = &next->str;
			next->str.reference_count++;
		}
		dispose_temporary( &prev );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
xorl %ecx, %ecx
callq 0x44a9
movl %eax, %ebp
testl %eax, %eax
je 0xdbff
movq 0x8(%rsp), %rdi
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xdbf5
movq %rax, 0x8(%rbx)
incq (%rax)
testq %rdi, %rdi
je 0xdbff
callq 0x3979
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_child_expression
static enum result evaluate_child_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable parent = { 0, NULL };
	struct element *child;
	enum result ret = evaluate_element( parameter, vars, &parent, 0 );
	if( ret ) {
		child = ( ( struct element * ) parent.string_value )->child;
		if( child ) {
			result->string_value = &child->str;
			child->str.reference_count++;
		}
		dispose_temporary( &parent );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
xorl %ecx, %ecx
callq 0x44a9
movl %eax, %ebp
testl %eax, %eax
je 0xdc4a
movq 0x8(%rsp), %rdi
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xdc40
movq %rax, 0x8(%rbx)
incq (%rax)
testq %rdi, %rdi
je 0xdc4a
callq 0x3979
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_line_expression
static enum result evaluate_line_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable elem = { 0, NULL };
	enum result ret = evaluate_element( parameter, vars, &elem, 0 );
	if( ret ) {
		result->number_value = ( ( struct element * ) elem.string_value )->line;
		dispose_temporary( &elem );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
xorl %ecx, %ecx
callq 0x44a9
movl %eax, %ebp
testl %eax, %eax
je 0xdc8a
movq 0x8(%rsp), %rdi
movl 0x28(%rdi), %eax
movl %eax, (%rbx)
testq %rdi, %rdi
je 0xdc8a
callq 0x3979
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_expr_expression
static enum result evaluate_expr_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct environment *env = vars->func->env;
	struct variable var = { 0, NULL };
	struct element *elem;
	char msg[ 128 ] = "";
	enum result ret = this->parameters->evaluate( this->parameters, vars, &var );
	if( ret ) {
		if( ( size_t ) &ret < env->stack_limit ) {
			ret = throw_stack_overflow( vars, this );
		} else {
			elem = value_to_element( var.number_value, var.string_value, env, env->element_depth, msg );
			if( elem ) {
				result->string_value = &elem->str;
			} else {
				ret = throw( vars, this, 0, msg );
			}
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rax
movq 0x40(%rax), %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xdf29
leaq 0xc(%rsp), %rax
cmpq %rax, (%r12)
jbe 0xdeda
leaq 0x4383(%rip), %rcx      # 0x1225b
jmp 0xdf05
movl 0x10(%rsp), %edi
movq 0x18(%rsp), %rsi
movl 0x8(%r12), %ecx
leaq 0x20(%rsp), %r8
movq %r12, %rdx
callq 0xe93a
testq %rax, %rax
je 0xdf00
movq %rax, 0x8(%r15)
jmp 0xdf1a
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3cc3
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xdf29
callq 0x3979
movl 0xc(%rsp), %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq