LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 -0x841b(%rip), %rcx     # 0x407b
cmpq %rcx, %rax
je 0xc4b0
movq %rsp, %rdx
movq %r12, %rsi
callq *%rax
testl %eax, %eax
je 0xc4f5
movl %eax, %ebx
movq 0x8(%rsp), %rax
jmp 0xc4c5
movq 0x10(%r12), %rax
movslq 0x4(%rdi), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rax
pushq $0x1
popq %rbx
testq %rax, %rax
je 0xc4dd
movzbl 0x14(%rax), %ecx
cmpl $0x2, %ecx
je 0xc4f9
cmpl $0x3, %ecx
jne 0xc4fe
movl 0x18(%rax), %eax
jmp 0xc501
leaq 0x5b69(%rip), %rcx      # 0x1204d
xorl %ebx, %ebx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3bb2
jmp 0xc504
xorl %ebx, %ebx
jmp 0xc50c
movl 0x40(%rax), %eax
jmp 0xc501
movl 0x10(%rax), %eax
movl %eax, (%r14)
movq %rsp, %rdi
callq 0x3988
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %r15
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq %r15, %rdi
callq *0x18(%r15)
xorl %ebp, %ebp
testl %eax, %eax
je 0xc590
movq 0x10(%r15), %rdi
cmpq $0x0, 0x8(%rsp)
je 0xc571
movq %rsp, %rdx
movq %r14, %rsi
callq 0x4449
testl %eax, %eax
je 0xc588
movl (%rsp), %ecx
movl %ecx, (%rbx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movl %eax, %ebp
jmp 0xc590
movq %rsp, %rdx
andl $0x0, (%rdx)
movq %r14, %rsi
callq *0x18(%rdi)
movl %eax, %ebp
testl %eax, %eax
je 0xc588
movl (%rsp), %eax
movl %eax, (%rbx)
movq %rsp, %rdi
callq 0x3988
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x4(%rsp), %rdx
callq 0x4514
xorl %r12d, %r12d
testl %eax, %eax
je 0xc848
movslq 0x4(%rsp), %r15
testq %r15, %r15
js 0xc818
movl %eax, %ebp
movq %r13, 0x8(%rsp)
movl %r15d, %edi
callq 0x3723
testq %rax, %rax
je 0xc82f
movq %rax, %r13
movq 0xb7d0(%rip), %r12      # 0x17f70
movq (%r12), %rdi
callq 0x3170
testl %r15d, %r15d
je 0xc7cf
movq 0x8(%r13), %rdi
movq (%r12), %rcx
pushq $0x1
popq %rsi
movq %r15, %rdx
callq 0x3090
movq 0x8(%r13), %rcx
cltq
movb $0x0, (%rcx,%rax)
movl %eax, 0x10(%r13)
movq (%r12), %rdi
callq 0x3080
testl %eax, %eax
je 0xc83c
movq %r13, %rdi
callq 0x38b2
callq 0x3040
movl (%rax), %edi
callq 0x3220
leaq 0x10(%rsp), %r15
pushq $0x3f
popq %rdx
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 0xc828
leaq 0x58b8(%rip), %rcx      # 0x120d7
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x3bb2
jmp 0xc848
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c90
jmp 0xc848
movq 0x8(%rsp), %rax
movq %r13, 0x8(%rax)
movl %ebp, %r12d
movl %r12d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_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 0x4284
testl %eax, %eax
je 0xc8b7
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 0x3788
testq %rax, %rax
js 0xc8bb
cmpq $0x7ffffffe, %rax       # imm = 0x7FFFFFFE
ja 0xc8c2
movl %eax, (%r12)
movl %ebp, %ebx
jmp 0xc8d8
xorl %ebx, %ebx
jmp 0xc8e0
leaq 0x10(%rsp), %rcx
jmp 0xc8cb
leaq 0x5397(%rip), %rcx      # 0x11c60
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3bb2
movq %rsp, %rdi
callq 0x3988
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_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 %r12
pushq %rbx
subq $0x30, %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 0x4284
testl %eax, %eax
je 0xc960
movq 0x10(%r12), %r12
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x4284
testl %eax, %eax
je 0xc964
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0xc968
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x4514
testl %eax, %eax
je 0xc9b0
movl %eax, %ebp
movl 0xc(%rsp), %edx
jmp 0xc96d
xorl %ebp, %ebp
jmp 0xc9c6
xorl %ebp, %ebp
jmp 0xc9bc
movl %eax, %ebp
pushq $-0x1
popq %rdx
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 0xc99e
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x8ba5
movl %eax, (%rbx)
jmp 0xc9b2
leaq 0x48e2(%rip), %rcx      # 0x11287
movq %r15, %rdi
movq %r14, %rsi
callq 0x3bb2
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
callq 0x3988
leaq 0x20(%rsp), %rdi
callq 0x3988
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_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, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rdi
leaq 0xc(%rsp), %rdx
callq 0x4514
xorl %ebx, %ebx
testl %eax, %eax
je 0xca78
movslq 0xc(%rsp), %rdx
testq %rdx, %rdx
js 0xca66
movl %eax, %ebp
movq 0x18(%r12), %rax
movq 0x40(%rax), %rax
cmpl 0xc(%rax), %edx
jge 0xca66
movq 0x10(%rax), %rax
movq (%rax,%rdx,8), %rdi
movq %rdi, 0x10(%rsp)
callq 0x30c0
movl %eax, %edi
callq 0x3723
testq %rax, %rax
je 0xca89
movq %rax, %r13
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rdx
movq 0x10(%rsp), %rsi
callq 0x3180
movq %r13, 0x8(%r14)
movl %ebp, %ebx
jmp 0xca78
leaq 0x567a(%rip), %rcx      # 0x120e7
movq %r12, %rdi
movq %r15, %rsi
callq 0x3bb2
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r15, %rsi
callq 0x4c90
jmp 0xca78
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x31a0
movq %rax, 0x8(%rsp)
movq 0x18(%r15), %rcx
movq 0x40(%rcx), %rcx
cmpq $0x0, 0x3a0(%rcx)
jne 0xcb07
leaq 0x8(%rsp), %rdi
callq 0x30b0
movq %rax, %r13
movq %rax, %rdi
callq 0x30c0
leal -0x1(%rax), %edi
callq 0x3723
testq %rax, %rax
je 0xcb1e
movq %rax, %r12
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rdx
movq %r13, %rsi
callq 0x3180
movq 0x8(%rsp), %rax
movl %eax, (%rbx)
movq %r12, 0x8(%rbx)
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c90
xorl %eax, %eax
jmp 0xcb10
// File: /workspace/github_c_makefile_star2_O2/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 0x4284
testl %eax, %eax
je 0xcbc7
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 0x7253
cmpb $0x0, (%r13)
je 0xcbcb
xorl %ebx, %ebx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3bb2
jmp 0xcbd0
xorl %ebx, %ebx
jmp 0xcbd8
movq %rax, 0x8(%r12)
movq %rsp, %rdi
callq 0x3988
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x18(%rsi), %rax
movq 0x40(%rax), %r13
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
xorl %ebp, %ebp
xorl %ecx, %ecx
callq 0x42ce
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xccc6
leaq 0xc(%rsp), %rax
cmpq %rax, (%r13)
jbe 0xcc46
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4ca3
jmp 0xccb3
movq 0x18(%rsp), %r12
cmpl $0x0, 0x28(%r12)
jg 0xcc63
movl 0x8(%r13), %esi
movq %r12, %rdi
callq 0x6d2b
testl %eax, %eax
je 0xcc39
movq %r12, %rdi
xorl %esi, %esi
callq 0xd813
testl %eax, %eax
js 0xcc92
movl %eax, %edi
callq 0x3723
testq %rax, %rax
je 0xcca8
movq %rax, %r13
movq 0x8(%rax), %rsi
movq %r12, %rdi
callq 0xd813
movq %r13, 0x8(%r14)
jmp 0xccb8
leaq 0x538d(%rip), %rcx      # 0x12026
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3bb2
jmp 0xccb3
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4c90
andl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3988
movl 0xc(%rsp), %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: 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 0x42ce
movl %eax, %ebp
testl %eax, %eax
je 0xcd17
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xcd0f
movq %rax, 0x8(%rbx)
incq (%rax)
movq %rsp, %rdi
callq 0x3988
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x42ce
movl %eax, %ebp
testl %eax, %eax
je 0xcd60
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xcd58
movq %rax, 0x8(%rbx)
incq (%rax)
movq %rsp, %rdi
callq 0x3988
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x42ce
movl %eax, %ebp
testl %eax, %eax
je 0xcd9d
movq %rsp, %rdi
movq 0x8(%rdi), %rax
movl 0x28(%rax), %eax
movl %eax, (%rbx)
callq 0x3988
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcfbe
leaq 0xc(%rsp), %rax
cmpq %rax, (%r12)
jbe 0xcfc2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4ca3
jmp 0xcffa
xorl %eax, %eax
jmp 0xd00d
movl 0x10(%rsp), %edi
movq 0x18(%rsp), %rsi
movl 0x8(%r12), %ecx
leaq 0x20(%rsp), %r8
movq %r12, %rdx
callq 0xd8f5
testq %rax, %rax
je 0xcfe8
movq %rax, 0x8(%r15)
jmp 0xcfff
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3bb2
andl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3988
movl 0xc(%rsp), %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rsi, %r12
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq 0x8(%rdi), %rdi
movq %r14, %rdx
callq *0x18(%rdi)
testl %eax, %eax
je 0xd0b1
movl %eax, %ebp
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xd06b
cmpb $0x2, 0x14(%rax)
jne 0xd06b
movq 0x18(%rax), %r14
movl 0x40(%rax), %r13d
shll $0x2, %r13d
jmp 0xd087
movq 0x8(%r15), %rcx
movq %r14, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4399
testl %eax, %eax
je 0xd0ca
movl %eax, %ebp
pushq $0x4
popq %r13
movl %r13d, %edi
callq 0x3723
testq %rax, %rax
je 0xd0bf
movq 0x8(%rax), %rcx
movslq %r13d, %rsi
xorl %edx, %edx
cmpq %rsi, %rdx
jge 0xd0b5
movl (%r14,%rdx), %edi
bswapl %edi
movl %edi, (%rcx,%rdx)
addq $0x4, %rdx
jmp 0xd09d
xorl %ebp, %ebp
jmp 0xd0d4
movb $0x0, (%rcx,%rdx)
movq %rax, 0x8(%rbx)
jmp 0xd0cc
movq %r12, %rdi
movq %r15, %rsi
callq 0x4c90
xorl %ebp, %ebp
movq %rsp, %rdi
callq 0x3988
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_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_quote_expression
static enum result evaluate_quote_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	int length;
	struct expression *parameter = this->parameters;
	struct variable var = { 0, NULL };
	struct string *str;
	enum result ret = evaluate_string( parameter, vars, &var );
	if( ret ) {
		length = write_byte_string( var.string_value->string, var.string_value->length, NULL );
		if( length >= 0 ) {
			str = new_string( length );
			if( str ) {
				write_byte_string( var.string_value->string, var.string_value->length, 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 $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
callq 0x4284
testl %eax, %eax
je 0xd15b
movl %eax, %ebp
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x3c90
testl %eax, %eax
js 0xd160
movl %eax, %edi
callq 0x3723
testq %rax, %rax
je 0xd176
movq %rax, %r13
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
movq 0x8(%r13), %rdx
callq 0x3c90
movq %r13, 0x8(%rbx)
movl %ebp, %r14d
jmp 0xd181
xorl %r14d, %r14d
jmp 0xd189
leaq 0x4ebf(%rip), %rcx      # 0x12026
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3bb2
jmp 0xd181
movq %r12, %rdi
movq %r15, %rsi
callq 0x4c90
movq %rsp, %rdi
callq 0x3988
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_unquote_expression
static enum result evaluate_unquote_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable var = { 0, NULL };
	struct string *str;
	enum result ret = evaluate_string( parameter, vars, &var );
	if( ret ) {
		str = new_string_literal( var.string_value->string );
		if( str ) {
			result->string_value = str;
		} else {
			ret = throw_out_of_memory( vars, this );
		}
		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
movq %rsp, %rdx
movaps %xmm0, (%rdx)
callq 0x4284
testl %eax, %eax
je 0xd1e0
movl %eax, %ebx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x403d
testq %rax, %rax
je 0xd1e4
movq %rax, 0x8(%r14)
jmp 0xd1f1
xorl %ebx, %ebx
jmp 0xd1f9
movq %r12, %rdi
movq %r15, %rsi
callq 0x4c90
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x3988
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_interrupted_expression
static enum result evaluate_interrupted_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct environment *env = vars->func->env; 
	result->number_value = env->interrupted;
	if( env->worker == NULL ) {
		env->interrupted = 0;
	}
	return OKAY;
}

// Assembly:
movq 0x18(%rsi), %rax
movq 0x40(%rax), %rax
movsbl 0x18(%rax), %ecx
movl %ecx, (%rdx)
cmpq $0x0, 0x3a0(%rax)
jne 0xd223
movb $0x0, 0x18(%rax)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_source_expression
static enum result evaluate_source_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( var.string_value && var.string_value->type == FUNCTION ) {
			result->string_value = ( ( struct function * ) var.string_value )->file;
			result->string_value->reference_count++;
		} else {
			ret = throw( vars, this, 0, "Not a function reference." );
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
testl %eax, %eax
je 0xd419
movl %eax, %ebx
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xd3f9
cmpb $0x6, 0x14(%rax)
jne 0xd3f9
movq 0x28(%rax), %rax
movq %rax, 0x8(%r12)
incq (%rax)
jmp 0xd40f
leaq 0x4327(%rip), %rcx      # 0x11727
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3bb2
movq %rsp, %rdi
callq 0x3988
jmp 0xd41b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_type_expression
static enum result evaluate_type_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct structure *struc;
	struct variable var = { 0, NULL };
	enum result ret = this->parameters->evaluate( this->parameters, vars, &var );
	if( ret && var.string_value ) {
		result->number_value = var.string_value->type + 1;
		if( var.string_value->type == ARRAY ) {
			struc = ( ( struct array * ) var.string_value )->structure;
			if( struc ) {
				result->string_value = &struc->str;
				struc->str.reference_count++;
			}
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq 0x8(%rdi), %rdi
movq %r14, %rdx
callq *0x18(%rdi)
movl %eax, %ebp
testl %eax, %eax
setne %cl
movq 0x8(%r14), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xd486
movsbl 0x14(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
cmpl $0x2, %ecx
jne 0xd47e
movq 0x28(%rax), %rax
testq %rax, %rax
je 0xd47e
movq %rax, 0x8(%rbx)
incq (%rax)
movq %rsp, %rdi
callq 0x3988
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_field_expression
static enum result evaluate_field_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable struc = { 0, NULL };
	struct string_list *field;
	int idx;
	enum result ret = parameter->evaluate( parameter, vars, &struc );
	if( ret ) {
		if( struc.string_value && struc.string_value->type == STRUCT ) {
			ret = evaluate_integer( parameter->next, vars, &idx );
			if( ret ) {
				if( idx >= 0 && idx < ( ( struct structure * ) struc.string_value )->length ) {
					field = ( ( struct structure * ) struc.string_value )->fields;
					while( idx-- ) {
						field = field->next;
					}
					result->string_value = field->str;
					result->string_value->reference_count++;
				} else {
					ret = throw( vars, this, idx, "Field index out of bounds." );
				}
			}
		} else {
			ret = throw( vars, this, struc.number_value, "Not a structure." );
		}
		dispose_temporary( &struc );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq %r12, %rdi
callq *0x18(%r12)
testl %eax, %eax
je 0xd53e
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xd51a
cmpb $0x3, 0x14(%rax)
jne 0xd51a
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x4514
xorl %ebp, %ebp
testl %eax, %eax
je 0xd532
movl 0xc(%rsp), %edx
testl %edx, %edx
js 0xd54f
movq 0x18(%rsp), %rcx
cmpl 0x18(%rcx), %edx
jge 0xd54f
addq $0x20, %rcx
incl %edx
movq (%rcx), %rsi
leaq 0x8(%rsi), %rcx
decl %edx
jne 0xd501
movq (%rsi), %rcx
movq %rcx, 0x8(%rbx)
incq (%rcx)
movl %eax, %ebp
jmp 0xd532
movl 0x10(%rsp), %edx
leaq 0x4c63(%rip), %rcx      # 0x12188
movq %r15, %rdi
movq %r14, %rsi
callq 0x3bb2
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
callq 0x3988
jmp 0xd540
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4c17(%rip), %rcx      # 0x1216d
movq %r15, %rdi
movq %r14, %rsi
callq 0x3bb2
jmp 0xd532
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_instanceof_expression
static enum result evaluate_instanceof_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable arr = { 0, NULL }, struc = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &arr );
	if( ret ) {
		ret = parameter->next->evaluate( parameter->next, vars, &struc );
		if( ret ) {
			if( struc.string_value && struc.string_value->type == STRUCT ) {
				if( is_instance( &arr, ( struct structure * ) struc.string_value, NULL, NULL ) ) {
					assign_variable( &arr, result );
				}
			} else {
				ret = throw( vars, this, struc.number_value, "Not a structure." );
			}
			dispose_temporary( &struc );
		}
		dispose_temporary( &arr );
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, (%rsp)
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq *0x18(%rbx)
testl %eax, %eax
je 0xd5d8
movq 0x10(%rbx), %rdi
movq %rsp, %rdx
movq %r12, %rsi
callq *0x18(%rdi)
testl %eax, %eax
je 0xd5fd
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0xd5dc
cmpb $0x3, 0x14(%rsi)
jne 0xd5dc
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x41fd
testl %eax, %eax
je 0xd5f3
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x3996
jmp 0xd5f3
xorl %ebx, %ebx
jmp 0xd609
movl (%rsp), %edx
leaq 0x4ba2(%rip), %rcx      # 0x12188
movq %r12, %rdi
movq %r15, %rsi
callq 0x3bb2
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x3988
jmp 0xd5ff
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x3988
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_trace_expression
static enum result evaluate_trace_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	char *msg = "";
	int msg_len = 0;
	struct array *arr;
	struct variable var = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &var );
	if( ret ) {
		if( var.string_value ) {
			msg = var.string_value->string;
			msg_len = var.string_value->length;
		}
		arr = stack_trace( this, vars, msg_len, 16 );
		if( arr ) {
			memcpy( arr->str.string, msg, msg_len );
			result->number_value = var.number_value;
			result->string_value = &arr->str;
		} else {
			ret = throw_out_of_memory( vars, this );
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
testl %eax, %eax
je 0xd65e
movl %eax, %ebx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xd662
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %ebp
jmp 0xd670
xorl %ebx, %ebx
jmp 0xd6ba
leaq 0x39ed(%rip), %rax      # 0x11056
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x3c2c
testq %rax, %rax
je 0xd6a3
movq %rax, %r13
movq 0x8(%rax), %rdi
movslq %ebp, %rdx
movq 0x8(%rsp), %rsi
callq 0x3180
movl 0x10(%rsp), %eax
movl %eax, (%r14)
movq %r13, 0x8(%r14)
jmp 0xd6b0
movq %r12, %rdi
movq %r15, %rsi
callq 0x4c90
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x3988
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: evaluate_eval_expression
static enum result evaluate_eval_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct environment *env = vars->func->env;
	struct variable var = { 0, NULL };
	struct expression prev;
	struct element *elem;
	char msg[ 128 ] = "";
	enum result ret = evaluate_element( this->parameters, 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 {
			prev.next = NULL;
			parse_expression( elem, vars->func, NULL, &prev, msg );
			if( msg[ 0 ] == 0 ) {
				expr_set_line( prev.next, this->line );
				ret = prev.next->evaluate( prev.next, vars, result );
			} else {
				ret = throw( vars, this, 0, msg );
			}
			dispose_expressions( prev.next );
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rsi), %rax
movq 0x40(%rax), %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq 0x8(%rdi), %rdi
xorl %ebp, %ebp
xorl %ecx, %ecx
callq 0x42ce
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xd7ff
leaq 0xc(%rsp), %rax
cmpq %rax, (%r12)
jbe 0xd765
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4ca3
andl $0x0, 0xc(%rsp)
jmp 0xd7f1
movq 0x18(%rsp), %r13
cmpl $0x0, 0x28(%r13)
jg 0xd782
movl 0x8(%r12), %esi
movq %r13, %rdi
callq 0x6d2b
testl %eax, %eax
je 0xd750
leaq 0x20(%rsp), %rcx
andq $0x0, 0x10(%rcx)
movq 0x18(%rbx), %rsi
xorl %r12d, %r12d
leaq 0x40(%rsp), %rbp
movq %r13, %rdi
xorl %edx, %edx
movq %rbp, %r8
callq 0x4d6c
cmpb $0x0, (%rbp)
je 0xd7c4
leaq 0x40(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3bb2
movq 0x30(%rsp), %r13
jmp 0xd7e4
movq 0x30(%rsp), %r13
movl (%r15), %esi
movq %r13, %rdi
callq 0x953f
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x18(%r13)
movl %eax, %r12d
movl %r12d, 0xc(%rsp)
movq %r13, %rdi
callq 0x3a26
leaq 0x10(%rsp), %rdi
callq 0x3988
movl 0xc(%rsp), %ebp
movl %ebp, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: write_element
static int write_element( struct element *elem, char *output ) {
	int size, length = 0;
	if( output ) {
		while( elem ) {
			if( elem->child ) {
				output[ length++ ] = elem->str.string[ 0 ];
				length += write_element( elem->child, &output[ length ] );
				output[ length++ ] = elem->str.string[ 1 ];
			} else {
				memcpy( &output[ length ], elem->str.string, sizeof( char ) * elem->str.length );
				length += elem->str.length;
				output[ length++ ] = '\n';
			}
			elem = elem->next;
		}
	} else {
		while( elem && length >= 0 ) {
			if( elem->child ) {
				size = write_element( elem->child, NULL );
				if( size >= 0 && MAX_INTEGER - length - 2 > size ) {
					length += size + 2;
				} else {
					length = -1;
				}
			} else {
				size = elem->str.length;
				if( MAX_INTEGER - length - 1 > size ) {
					length += size + 1;
				} else {
					length = -1;
				}
			}
			elem = elem->next;
		}
	}
	return length;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xd88a
movq %rsi, %r15
xorl %r14d, %r14d
testq %rbx, %rbx
je 0xd8e7
cmpq $0x0, 0x18(%rbx)
movslq %r14d, %r14
je 0xd863
movq 0x8(%rbx), %rax
movb (%rax), %al
leaq (%r15,%r14), %rsi
incq %rsi
movb %al, -0x1(%rsi)
movq 0x18(%rbx), %rdi
callq 0xd813
addl %eax, %r14d
incl %r14d
movq 0x8(%rbx), %rax
movb 0x1(%rax), %al
jmp 0xd87a
leaq (%r15,%r14), %rdi
movq 0x8(%rbx), %rsi
movslq 0x10(%rbx), %rdx
callq 0x3180
addl 0x10(%rbx), %r14d
movb $0xa, %al
movslq %r14d, %r14
movb %al, (%r15,%r14)
incl %r14d
movq 0x20(%rbx), %rbx
jmp 0xd828
xorl %r14d, %r14d
pushq $-0x1
popq %rbp
testq %rbx, %rbx
je 0xd8e7
testl %r14d, %r14d
js 0xd8e7
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xd8c7
xorl %esi, %esi
callq 0xd813
movl %ebp, %ecx
testl %eax, %eax
js 0xd8de
movl $0x7ffffffd, %edx       # imm = 0x7FFFFFFD
subl %r14d, %edx
movl %ebp, %ecx
cmpl %eax, %edx
jle 0xd8de
leal (%r14,%rax), %ecx
addl $0x2, %ecx
jmp 0xd8de
movl 0x10(%rbx), %eax
movl $0x7ffffffe, %edx       # imm = 0x7FFFFFFE
subl %r14d, %edx
movl %ebp, %ecx
cmpl %eax, %edx
jle 0xd8de
leal (%r14,%rax), %ecx
incl %ecx
movq 0x20(%rbx), %rbx
movl %ecx, %r14d
jmp 0xd890
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: new_string_element
static struct element* new_string_element( struct string *value ) {
	struct element *elem = NULL;
	int length = write_byte_string( value->string, value->length, NULL );
	if( length > 0 ) {
		elem = new_element( length );
		if( elem ) {
			write_byte_string( value->string, value->length, elem->str.string );
		}
	}
	return elem;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movl 0x10(%r14), %esi
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x3c90
testl %eax, %eax
jle 0xdcef
movl %eax, %edi
callq 0x3638
testq %rax, %rax
je 0xdced
movq %rax, %rbx
movq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
movq 0x8(%rax), %rdx
callq 0x3c90
jmp 0xdcef
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/towntalk.c
// Function: new_number_element
static struct element* new_number_element( number value ) {
	char chars[ 32 ];
	struct element *elem;
#if defined( FLOATING_POINT )
	sprintf( chars, "%.16g", value );
#else
	sprintf( chars, "%d", value );
#endif
	elem = new_element( strlen( chars ) );
	if( elem ) {
		strcpy( elem->str.string, chars );
	}
	return elem;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edi, %edx
leaq 0x4118(%rip), %rsi      # 0x11e20
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3200
movq %rbx, %rdi
callq 0x30c0
movl %eax, %edi
callq 0x3638
movq %rax, %rbx
testq %rax, %rax
je 0xdd38
movq 0x8(%rbx), %rdi
movq %rsp, %rsi
callq 0x3070
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/optimizer.c
// Function: optimize_increment
static struct statement* optimize_increment( struct statement *stmt, struct statement *prev, enum arithmetic_op oper, char *message ) {
	if( prev->execute == execute_arithmetic_statement && add_instruction( &( ( struct arithmetic_statement * ) prev )->insns, oper, stmt->local, stmt->source, message ) ) {
		stmt->source->next = prev->source;
		prev->source = stmt->source;
		prev->next = stmt->next;
		free( stmt );
		return prev;
	}
	return stmt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x480(%rip), %rax       # 0xe449
cmpq %rax, 0x10(%rsi)
je 0xdfd4
movq %r14, %rbx
jmp 0xe013
movq %rcx, %r8
movq %rsi, %rbx
leaq 0x28(%rsi), %rdi
movl (%r14), %eax
movq 0x8(%r14), %rcx
movl %edx, %esi
movl %eax, %edx
callq 0xe37e
testq %rax, %rax
je 0xdfcf
movq 0x8(%rbx), %rax
movq 0x8(%r14), %rcx
movq %rax, 0x10(%rcx)
movq %rcx, 0x8(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0x3030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/optimizer.c
// Function: add_arithmetic_statement
static struct arithmetic_statement* add_arithmetic_statement( struct statement *src, struct statement *prev, char *message ) {
	struct expression *expr;
	struct arithmetic_statement *arith;
	if( prev->execute == execute_arithmetic_statement ) {
		arith = ( struct arithmetic_statement * ) prev;
		expr = src->source;
		while( expr->next ) {
			expr = expr->next;
		}
		expr->next = arith->stmt.source;
		arith->stmt.source = src->source;
		src->source = NULL;
		prev->next = src->next;
	} else {
		arith = calloc( 1, sizeof( struct arithmetic_statement ) );
		if( arith ) {
			arith->stmt.local = src->local;
			arith->stmt.source = src->source;
			src->source = NULL;
			arith->stmt.execute = execute_arithmetic_statement;
			arith->stmt.dispose = dispose_arithmetic_statement;
			arith->stmt.next = src->next;
			prev->next = &arith->stmt;
		} else {
			strcpy( message, OUT_OF_MEMORY );
			return NULL;
		}
	}
	src->next = NULL;
	dispose_statements( src );
	return arith;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x416(%rip), %r12       # 0xe449
cmpq %r12, 0x10(%rsi)
je 0xe079
movq %rdx, %r15
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x3130
testq %rax, %rax
je 0xe0b7
movl (%rbx), %ecx
movl %ecx, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x8(%rbx)
movq %r12, 0x10(%rax)
leaq 0xd61(%rip), %rcx       # 0xedc9
movq %rcx, 0x18(%rax)
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq %rax, %r15
jmp 0xe0a4
movq 0x8(%rbx), %rax
movq %rax, %rdx
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0xe080
movq 0x8(%r14), %rdx
movq %rdx, 0x10(%rcx)
movq %rax, 0x8(%r14)
andq $0x0, 0x8(%rbx)
movq 0x20(%rbx), %rax
movq %r14, %r15
movq %rax, 0x20(%r14)
andq $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x39e8
jmp 0xe0cc
leaq 0xa0b2(%rip), %rax      # 0x18170
movq (%rax), %rsi
movq %r15, %rdi
callq 0x3070
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/optimizer.c
// Function: add_instruction
static struct instruction* add_instruction( struct instructions *insns,
	enum arithmetic_op oper, int local, struct expression *expr, char *message ) {
	struct instruction *list;
	int capacity = insns->capacity;
	if( capacity <= insns->count ) {
		capacity = ( capacity << 1 ) + 4;
		list = calloc( capacity + 1, sizeof( struct instruction ) );
		if( list ) {
			if( insns->list ) {
				memcpy( list, insns->list, insns->count * sizeof( struct instruction ) );
				free( insns->list );
			}
			insns->list = list;
			insns->capacity = capacity;
		} else {
			strcpy( message, OUT_OF_MEMORY );
			return NULL;
		}
	}
	list = &insns->list[ insns->count++ ];
	list->oper = oper;
	list->local = local;
	list->expr = expr;
	return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %r15
movl 0x8(%rdi), %ebp
movl 0xc(%rdi), %ebx
cmpl %ebx, %ebp
jle 0xe3a1
movq (%r15), %r12
jmp 0xe404
movq %r8, %r13
movl %edx, 0xc(%rsp)
movq %rcx, 0x10(%rsp)
leal 0x5(,%rbp,2), %eax
movslq %eax, %rdi
pushq $0x18
popq %rsi
callq 0x3130
testq %rax, %rax
je 0xe433
movq %rax, %r12
leal 0x4(,%rbp,2), %ebp
movq (%r15), %r13
testq %r13, %r13
je 0xe3f4
movslq %ebx, %rax
imulq $0x18, %rax, %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3180
movq %r13, %rdi
callq 0x3030
movl 0xc(%r15), %ebx
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %edx
movq %r12, (%r15)
movl %ebp, 0x8(%r15)
leal 0x1(%rbx), %eax
movl %eax, 0xc(%r15)
movslq %ebx, %rax
imulq $0x18, %rax, %rsi
leaq (%r12,%rsi), %rax
movl %r14d, (%r12,%rsi)
movl %edx, 0x4(%r12,%rsi)
movq %rcx, 0x8(%r12,%rsi)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9d36(%rip), %rax      # 0x18170
movq (%rax), %rsi
movq %r13, %rdi
callq 0x3070
xorl %eax, %eax
jmp 0xe424
// File: /workspace/github_c_makefile_star2_O2/martincameron[P]towntalk/worker.c
// Function: start_worker
int start_worker( struct worker *work ) {
	struct variables vars = { 0 };
	struct function_expression expr = { 0 };
	vars.exception = &work->exception;
	initialize_entry_point( &expr, work->env.entry_point );
	expr.expr.parameters = work->parameters;
	work->ret = expr.expr.evaluate( &expr.expr, &vars, &work->result );
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
andq $0x0, 0x20(%r14)
movq %rsp, %r15
movaps %xmm0, 0x10(%r15)
andq $0x0, 0x20(%r15)
movaps %xmm0, (%r15)
leaq 0x3e0(%rdi), %rax
movq %rax, 0x8(%r14)
movq 0x3b8(%rdi), %rsi
movq %r15, %rdi
callq 0x77e7
movq 0x3f0(%rbx), %rax
movq %rax, 0x8(%r15)
leaq 0x3d0(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *0x18(%r15)
movl %eax, 0x418(%rbx)
pushq $0x1
popq %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq