LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xc1ba
movq %rax, %r13
leaq -0x7db6(%rip), %rax     # 0x4387
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 0x8142
movq %rax, %rbx
movq 0x10(%rbp), %rax
movq %rax, 0x8(%r13)
cmpb $0x0, (%r14)
jne 0xc1c9
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 0x6e94
movq 0x20(%rbp), %rax
movq %rax, 0x28(%r13)
cmpb $0x0, (%r14)
jne 0xc1c9
leaq 0xfa(%rip), %rax        # 0xc2aa
movq %rax, 0x10(%r13)
movq 0x20(%rbx), %rbx
jmp 0xc1c9
movq 0xcfaf(%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_O3/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 0xc284
movq %rax, %r12
leaq -0x7eab(%rip), %rax     # 0x4387
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 0x6e94
movq 0x20(%rbp), %rax
movq %rax, 0x28(%r12)
cmpb $0x0, (%r14)
jne 0xc293
leaq 0x2d(%rip), %rax        # 0xc2aa
movq %rax, 0x10(%r12)
jmp 0xc293
movq 0xcee5(%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_O3/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 0xc2e7
movq %rdx, %r14
movq %rsi, %r15
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%r12)
cmpl $0x1, %eax
jne 0xc2e5
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0xc2c6
jmp 0xc2e7
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: 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 $0x1, %ebx
cmpl %edx, %edi
jg 0xc352
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jl 0xc352
cmpq %rcx, %rsi
je 0xc327
testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
je 0xc32b
testq %rcx, %rcx
je 0xc34f
xorl %ebx, %ebx
subl 0x10(%rcx), %ebx
jmp 0xc352
xorl %ebx, %ebx
jmp 0xc352
movl 0x10(%rsi), %eax
movl 0x10(%rcx), %edx
movq 0x8(%rsi), %rdi
movq 0x8(%rcx), %rsi
movl %eax, %ebx
subl %edx, %ebx
cmovll %eax, %edx
movslq %edx, %rdx
callq 0x3120
testl %eax, %eax
cmovnel %eax, %ebx
jmp 0xc352
movl 0x10(%rsi), %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x442e
testl %eax, %eax
je 0xc3f8
movq 0x8(%r15), %rax
movq 0x10(%rax), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq 0x442e
testl %eax, %eax
je 0xc3fc
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 0x6ae5(%rip), %rax      # 0x12ea5
leaq 0x6adb(%rip), %rsi      # 0x12ea2
cmoveq %rax, %rsi
callq 0x31d0
testq %rax, %rax
je 0xc400
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 0xc406
xorl %ebx, %ebx
jmp 0xc46f
xorl %ebx, %ebx
jmp 0xc460
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl %r13d, %r12d
jge 0xc431
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 0xc451
movq 0x8(%r15), %rsi
xorl %ebx, %ebx
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3c96
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc460
callq 0x394d
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc46f
callq 0x394d
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_O3/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 0xc4b5
movl (%rsp), %eax
notl %eax
movl %eax, (%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc4b5
callq 0x394d
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc5ec
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 0xc524
callq 0x394d
movq $0x0, 0x8(%rsp)
orb %bpl, %r13b
cmpl $0x21, 0x4(%r15)
jne 0xc537
xorb $0x1, %r13b
jmp 0xc5f8
movq 0x10(%r12), %r12
testq %r12, %r12
je 0xc5f8
xorl %ebp, %ebp
cmpl $0x26, 0x4(%r15)
jne 0xc5a2
testb $0x1, %r13b
je 0xc5f5
movq %r12, %rdi
movq %r14, %rsi
movq %rsp, %rdx
callq *0x18(%r12)
testl %eax, %eax
je 0xc605
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 0xc5dc
callq 0x394d
movq $0x0, 0x8(%rsp)
jmp 0xc5dc
testb $0x1, %r13b
jne 0xc5f0
movq %r12, %rdi
movq %r14, %rsi
movq %rsp, %rdx
callq *0x18(%r12)
testl %eax, %eax
je 0xc5ec
movl %eax, %ebx
cmpl $0x0, (%rsp)
setne %al
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
setne %r13b
orb %al, %r13b
testq %rdi, %rdi
je 0xc5dc
callq 0x394d
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0xc547
jmp 0xc5f8
xorl %ebp, %ebp
jmp 0xc605
movb $0x1, %r13b
jmp 0xc5f8
xorl %r13d, %r13d
movzbl %r13b, %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_O3/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 0xc66f
movq 0x10(%r15), %rdi
cmpl $0x0, (%rsp)
jne 0xc653
cmpq $0x0, 0x8(%rsp)
jne 0xc653
movq 0x10(%rdi), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rdi)
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc671
callq 0x394d
jmp 0xc671
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc6f7
movq 0x10(%r15), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x18(%rdi)
movl %eax, %ebx
testl %eax, %eax
je 0xc6e6
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 0xc6e6
callq 0x394d
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc6f9
callq 0x394d
jmp 0xc6f9
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc786
movq 0x10(%r15), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x18(%rdi)
movl %eax, %ebx
testl %eax, %eax
je 0xc775
movl 0x10(%rsp), %edi
movq 0x18(%rsp), %rsi
movl (%rsp), %edx
movq 0x8(%rsp), %r15
movq %r15, %rcx
callq 0xc2f5
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, (%r14)
testq %r15, %r15
je 0xc775
movq %r15, %rdi
callq 0x394d
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xc788
callq 0x394d
jmp 0xc788
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xca8a
movq 0x10(%r15), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x18(%rdi)
movl %eax, %ebx
testl %eax, %eax
je 0xca79
movl 0x10(%rsp), %edi
movq 0x18(%rsp), %rsi
movl (%rsp), %edx
movq 0x8(%rsp), %r15
movq %r15, %rcx
callq 0xc2f5
movl %eax, (%r14)
testq %r15, %r15
je 0xca79
movq %r15, %rdi
callq 0x394d
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xca8c
callq 0x394d
jmp 0xca8c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x46e7
testl %eax, %eax
je 0xcc9e
movl %eax, %ebx
movl $0x1a, %edi
callq 0x31b0
testq %rax, %rax
je 0xcca2
movl $0x1, %ecx
movq %rcx, 0x10(%rax)
movq %rax, %rdx
addq $0x18, %rdx
movq %rdx, 0x8(%rax)
movb $0x0, 0x19(%rax)
movq %rcx, (%rax)
movb 0x4(%rsp), %cl
movb %cl, 0x18(%rax)
movq %rax, 0x8(%r14)
jmp 0xccb8
xorl %ebx, %ebx
jmp 0xccb8
movq 0xc4c7(%rip), %rcx      # 0x19170
xorl %ebx, %ebx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3c96
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: 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 0x46e7
testl %eax, %eax
je 0xcd54
movl %eax, %r12d
movl $0x23, %edi
callq 0x31b0
testq %rax, %rax
je 0xcd58
movq %rax, %r13
movq %r15, 0x10(%rsp)
movq $0xa, 0x10(%rax)
movq %rax, %rdi
addq $0x18, %rdi
movq %rdi, 0x8(%rax)
movb $0x0, 0x22(%rax)
movq $0x1, (%rax)
movl 0xc(%rsp), %edx
leaq 0x62f2(%rip), %rsi      # 0x13024
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x3200
movl %eax, %r15d
testl %eax, %eax
jle 0xcd6b
movl %r15d, 0x10(%r13)
movq 0x10(%rsp), %rax
movq %r13, 0x8(%rax)
movl %r12d, %ebp
jmp 0xcd88
xorl %ebp, %ebp
jmp 0xcd88
movq 0xc411(%rip), %rcx      # 0x19170
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
jmp 0xcd83
movq %r13, %rdi
callq 0x394d
leaq 0x62b1(%rip), %rcx      # 0x1302b
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x3c96
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_O3/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 0xce32
movl %eax, %r14d
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xce2a
cmpb $0x2, 0x14(%rax)
jl 0xcdef
movq 0x8(%r12), %rcx
movq %rsp, %rdi
movq %rdi, %rsi
movq %r15, %rdx
callq 0x4559
movl %eax, %r14d
jmp 0xce16
movq 0x8(%rax), %rdi
movq %rsp, %rsi
callq 0x4d47
testl %eax, %eax
jne 0xce16
leaq 0x6233(%rip), %rcx      # 0x13039
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3c96
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xce25
callq 0x394d
testl %r14d, %r14d
je 0xce32
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_O3/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 0xceda
movl %eax, %r14d
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xced2
cmpb $0x2, 0x14(%rax)
jl 0xce97
movq 0x8(%r12), %rcx
movq %rsp, %rdi
movq %rdi, %rsi
movq %r15, %rdx
callq 0x4559
movl %eax, %r14d
jmp 0xcebe
movq 0x8(%rax), %rdi
movq %rsp, %rsi
callq 0x4d47
testl %eax, %eax
jne 0xcebe
leaq 0x61b0(%rip), %rcx      # 0x1305e
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3c96
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xcecd
callq 0x394d
testl %r14d, %r14d
je 0xceda
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_O3/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 -0x8d37(%rip), %rcx     # 0x41dc
cmpq %rcx, %rax
je 0xcf30
movq %rsp, %rdx
movq %r12, %rsi
callq *%rax
testl %eax, %eax
je 0xcf7e
movl %eax, %ebx
movq 0x8(%rsp), %rdi
movq %rdi, %rax
jmp 0xcf49
movq 0x10(%r12), %rax
movslq 0x4(%rdi), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rax
movl $0x1, %ebx
xorl %edi, %edi
testq %rax, %rax
je 0xcf61
movzbl 0x14(%rax), %ecx
cmpl $0x2, %ecx
je 0xcf82
cmpl $0x3, %ecx
jne 0xcf87
movl 0x18(%rax), %eax
jmp 0xcf8a
leaq 0x60a5(%rip), %rcx      # 0x1300d
xorl %ebx, %ebx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3c96
movq 0x8(%rsp), %rdi
jmp 0xcf8d
xorl %ebx, %ebx
jmp 0xcf97
movl 0x40(%rax), %eax
jmp 0xcf8a
movl 0x10(%rax), %eax
movl %eax, (%r14)
testq %rdi, %rdi
je 0xcf97
callq 0x394d
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x46e7
xorl %r12d, %r12d
testl %eax, %eax
je 0xd341
movslq 0xc(%rsp), %r13
testq %r13, %r13
js 0xd318
movl %eax, %ebp
leaq 0x19(%r13), %rdi
callq 0x31b0
testq %rax, %rax
je 0xd32a
movq %rax, %r12
movq $0x0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r12)
movb $0x0, 0x18(%r12,%r13)
movq $0x1, (%r12)
movl %r13d, 0x10(%r12)
movq 0xbce2(%rip), %rax      # 0x18f70
movq (%rax), %rdi
callq 0x3170
testl %r13d, %r13d
je 0xd2c7
movq 0x8(%r12), %rdi
movq 0xbcc9(%rip), %rax      # 0x18f70
movq (%rax), %rcx
movl $0x1, %esi
movq %r13, %rdx
callq 0x3090
movq 0x8(%r12), %rcx
cltq
movb $0x0, (%rcx,%rax)
movl %eax, 0x10(%r12)
movq 0xbca2(%rip), %rax      # 0x18f70
movq (%rax), %rdi
callq 0x3080
testl %eax, %eax
je 0xd353
movq %r12, %rdi
callq 0x394d
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 0xd33c
leaq 0x5d78(%rip), %rcx      # 0x13097
movq %r14, %rdi
movq %rbx, %rsi
movl %r13d, %edx
jmp 0xd33c
movq 0xbe3f(%rip), %rcx      # 0x19170
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3c96
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 0xd341
// File: /workspace/github_c_makefile_star2_O3/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 0x442e
testl %eax, %eax
je 0xd3b9
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 0x381a
testq %rax, %rax
js 0xd3bd
cmpq $0x7ffffffe, %rax       # imm = 0x7FFFFFFE
ja 0xd3c4
movl %eax, (%r12)
movl %ebp, %ebx
jmp 0xd3da
xorl %ebx, %ebx
jmp 0xd3e9
leaq 0x10(%rsp), %rcx
jmp 0xd3cd
leaq 0x5855(%rip), %rcx      # 0x12c20
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3c96
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd3e9
callq 0x394d
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x442e
testl %eax, %eax
je 0xd468
movq 0x10(%rbx), %r13
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x442e
testl %eax, %eax
je 0xd46c
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0xd470
leaq 0xc(%rsp), %rdx
movq %r12, %rsi
callq 0x46e7
testl %eax, %eax
je 0xd4bb
movl %eax, %ebx
movl 0xc(%rsp), %edx
jmp 0xd477
xorl %ebx, %ebx
jmp 0xd4db
xorl %ebx, %ebx
jmp 0xd4cc
movl %eax, %ebx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
testl %ecx, %ecx
setg %sil
cmpl %edx, %ecx
setg %cl
andb %sil, %cl
cmpb $0x1, %cl
jne 0xd4a9
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x9332
movl %eax, (%r14)
jmp 0xd4bd
leaq 0x4d97(%rip), %rcx      # 0x12247
movq %r12, %rdi
movq %r15, %rsi
callq 0x3c96
xorl %ebx, %ebx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xd4cc
callq 0x394d
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xd4db
callq 0x394d
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x46e7
xorl %r12d, %r12d
testl %eax, %eax
je 0xd5c8
movslq 0x4(%rsp), %rdx
testq %rdx, %rdx
js 0xd5b6
movl %eax, %ebp
movq 0x18(%r15), %rax
movq 0x40(%rax), %rax
cmpl 0xc(%rax), %edx
jge 0xd5b6
movq 0x10(%rax), %rax
movq (%rax,%rdx,8), %rdi
movq %rdi, 0x10(%rsp)
callq 0x30c0
movq %rax, 0x8(%rsp)
movslq %eax, %r13
leaq 0x19(%r13), %rdi
callq 0x31b0
testq %rax, %rax
je 0xd5da
movq %rax, %r12
movq $0x0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r12)
movb $0x0, 0x18(%r12,%r13)
movq $0x1, (%r12)
movq 0x8(%rsp), %rax
movl %eax, 0x10(%r12)
movq 0x8(%r12), %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rdx
callq 0x3180
movq %r12, 0x8(%rbx)
movl %ebp, %r12d
jmp 0xd5c8
leaq 0x5aea(%rip), %rcx      # 0x130a7
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c96
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xbb8f(%rip), %rcx      # 0x19170
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
jmp 0xd5c3
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x31a0
movq %rax, (%rsp)
movq 0x18(%r15), %rcx
movq 0x40(%rcx), %rcx
cmpq $0x0, 0x3a0(%rcx)
jne 0xd683
movq %rsp, %rdi
callq 0x30b0
movq %rax, %r13
movq %rax, %rdi
callq 0x30c0
decl %eax
movslq %eax, %rbp
leaq 0x19(%rbp), %rdi
callq 0x31b0
testq %rax, %rax
je 0xd69f
movq %rax, %r12
movq $0x0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r12)
movb $0x0, 0x18(%r12,%rbp)
movq $0x1, (%r12)
movl %ebp, 0x10(%r12)
movq 0x8(%r12), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x3180
movq (%rsp), %rax
movl %eax, (%rbx)
movq %r12, 0x8(%rbx)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xbaca(%rip), %rcx      # 0x19170
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3c96
jmp 0xd68e
// File: /workspace/github_c_makefile_star2_O3/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 0x442e
testl %eax, %eax
je 0xd751
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 0x77be
cmpb $0x0, (%r13)
je 0xd755
xorl %ebx, %ebx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3c96
jmp 0xd75a
xorl %ebx, %ebx
jmp 0xd769
movq %rax, 0x8(%r12)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd769
callq 0x394d
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4478
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0xd885
leaq 0x4(%rsp), %rax
cmpq %rax, (%r13)
jbe 0xd7d4
leaq 0x4a94(%rip), %rcx      # 0x12263
jmp 0xd861
movq 0x18(%rsp), %r12
cmpl $0x0, 0x28(%r12)
jg 0xd7f1
movl 0x8(%r13), %esi
movq %r12, %rdi
callq 0x7229
testl %eax, %eax
je 0xd7c8
movq %r12, %rdi
xorl %esi, %esi
callq 0xe4ea
testl %eax, %eax
js 0xd851
movl %eax, %ebp
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
leaq 0x19(%rcx), %rdi
callq 0x31b0
testq %rax, %rax
je 0xd85a
movq %rax, %r13
movq $0x0, 0x10(%rax)
movq %rax, %rsi
addq $0x18, %rsi
movq %rsi, 0x8(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%r13,%rax)
movq $0x1, (%r13)
movl %ebp, 0x10(%r13)
movq %r12, %rdi
callq 0xe4ea
movq %r13, 0x8(%rbx)
jmp 0xd876
leaq 0x578e(%rip), %rcx      # 0x12fe6
jmp 0xd861
movq 0xb90f(%rip), %rcx      # 0x19170
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3c96
movl $0x0, 0x4(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xd885
callq 0x394d
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_O3/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 0x4478
movl %eax, %ebp
testl %eax, %eax
je 0xd8d5
movq 0x8(%rsp), %rdi
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xd8d0
movq %rax, 0x8(%rbx)
incq (%rax)
callq 0x394d
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4478
movl %eax, %ebp
testl %eax, %eax
je 0xd91b
movq 0x8(%rsp), %rdi
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xd916
movq %rax, 0x8(%rbx)
incq (%rax)
callq 0x394d
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4478
movl %eax, %ebp
testl %eax, %eax
je 0xd956
movq 0x8(%rsp), %rdi
movl 0x28(%rdi), %eax
movl %eax, (%rbx)
callq 0x394d
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdbe6
leaq 0xc(%rsp), %rax
cmpq %rax, (%r12)
jbe 0xdb97
leaq 0x46ce(%rip), %rcx      # 0x12263
jmp 0xdbc2
movl 0x10(%rsp), %edi
movq 0x18(%rsp), %rsi
movl 0x8(%r12), %ecx
leaq 0x20(%rsp), %r8
movq %r12, %rdx
callq 0xe5d9
testq %rax, %rax
je 0xdbbd
movq %rax, 0x8(%r15)
jmp 0xdbd7
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3c96
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xdbe6
callq 0x394d
movl 0xc(%rsp), %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_pack_expression
static enum result evaluate_pack_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	int idx, len;
	long_int in;
	number *src;
	char *out;
	struct string *str;
	struct variable val = { 0, NULL };
	enum result ret = this->parameters->evaluate( this->parameters, vars, &val );
	if( ret ) {
		if( val.string_value && val.string_value && val.string_value->type == ARRAY ) {
			src = ( ( struct array * ) val.string_value )->number_values;
			len = ( ( struct array * ) val.string_value )->length * 4;
		} else {
			src = &val.number_value;
			ret = to_num( &val, src, vars, this->parameters );
			len = 4;
		}
		if( ret ) {
			str = new_string( len );
			if( str ) {
				idx = 0;
				out = str->string;
				while( idx < len ) {
					in = src[ idx >> 2 ];
					out[ idx ] = in >> 24;
					out[ idx + 1 ] = in >> 16;
					out[ idx + 2 ] = in >> 8;
					out[ idx + 3 ] = in;
					idx += 4;
				}
				out[ idx ] = 0;
				result->string_value = str;
			} else {
				ret = throw_out_of_memory( vars, this );
			}
		}
		dispose_temporary( &val );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq 0x8(%rdi), %rdi
movq %r15, %rdx
callq *0x18(%rdi)
testl %eax, %eax
je 0xdcc1
movl %eax, %ebx
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xdc4a
cmpb $0x2, 0x14(%rax)
jne 0xdc4a
movq 0x18(%rax), %r15
movl 0x40(%rax), %eax
shll $0x2, %eax
jmp 0xdc68
movq 0x8(%r12), %rcx
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4559
testl %eax, %eax
je 0xdcdd
movl %eax, %ebx
movl $0x4, %eax
movslq %eax, %rbp
leaq 0x19(%rbp), %rdi
callq 0x31b0
testq %rax, %rax
je 0xdcc5
movq $0x0, 0x10(%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movb $0x0, 0x18(%rax,%rbp)
movq $0x1, (%rax)
movl %ebp, 0x10(%rax)
movq 0x8(%rax), %rcx
xorl %edx, %edx
testl %ebp, %ebp
jle 0xdcb7
movl (%r15,%rdx), %esi
bswapl %esi
movl %esi, (%rcx,%rdx)
addq $0x4, %rdx
cmpq %rbp, %rdx
jl 0xdca5
movb $0x0, (%rcx,%rdx)
movq %rax, 0x8(%r14)
jmp 0xdcdf
xorl %ebx, %ebx
jmp 0xdcee
movq 0xb4a4(%rip), %rcx      # 0x19170
xorl %ebx, %ebx
movq %r13, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3c96
jmp 0xdcdf
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xdcee
callq 0x394d
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq