LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: add_local_variable
static int add_local_variable( struct element *elem,
	struct function *func, struct structure *type, struct expression *initializer,
	struct statement *prev, char *message ) {
	struct statement *stmt;
	struct local_variable *param = new_local_variable( func, elem, type, message );
	if( param ) {
		/*printf("Local variable '%s'\n", elem->str.string);*/
		if( get_local_variable( func->variable_decls, elem->str.string, "" ) == NULL ) {
			func->num_variables = func->num_variables + 1;
			if( func->variable_decls ) {
				func->variable_decls_tail->next = param;
			} else {
				func->variable_decls = param;
			}
			func->variable_decls_tail = param;
			if( initializer ) {
				stmt = calloc( 1, sizeof( struct statement ) );
				if( stmt ) {
					prev->next = stmt;
					stmt->source = initializer;
					stmt->local = func->num_variables - 1;
					stmt->execute = execute_local_assignment;
				} else {
					strcpy( message, OUT_OF_MEMORY );
				}
			}
		} else {
			dispose_local_variables( param );
			sprintf( message, "Local variable '%.64s' already declared on line %d.", elem->str.string, elem->line );
		}
	}
	return message[ 0 ] == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xb880
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xeb2a
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xc61b(%rip), %rdx      # 0x1b056
callq 0x74c0
cmpq $0x0, %rax
jne 0xeafe
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xea78
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0xea84
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
cmpq $0x0, -0x20(%rbp)
je 0xeafc
movl $0x1, %edi
movl $0x28, %esi
callq 0x3120
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xeaea
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
subl $0x1, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
leaq -0x9d54(%rip), %rcx     # 0x4d90
movq %rcx, 0x10(%rax)
jmp 0xeafa
movq -0x30(%rbp), %rdi
movq 0x1266b(%rip), %rsi     # 0x21160
callq 0x3070
jmp 0xeafc
jmp 0xeb28
movq -0x40(%rbp), %rdi
callq 0xa6f0
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0xd69f(%rip), %rsi      # 0x1c1c0
movb $0x0, %al
callq 0x31f0
jmp 0xeb2a
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: parse_array_assignment
static struct element* parse_array_assignment( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct expression expr;
	struct element *next = elem, *child = elem->child;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		prev->next = stmt;
		expr.next = NULL;
		child = parse_expression( child, func, vars, &expr, message );
		if( expr.next ) {
			stmt->source = expr.next;
			if( child->str.string[ 0 ] == ',' ) {
				child = child->next;
			}
			expr.next = NULL;
			child = parse_expression( child, func, vars, &expr, message );
			if( expr.next ) {
				stmt->source->next = expr.next;
				expr.next = NULL;
				next = parse_expression( next->next->next, func, vars, &expr, message );
				if( expr.next ) {
					expr.next->next = stmt->source;
					stmt->source = expr.next;
					stmt->execute = execute_array_assignment;
				}
			}
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x3120
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0xeca3
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq $0x0, -0x38(%rbp)
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
leaq -0x48(%rbp), %rcx
callq 0x60c0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xeca1
movq -0x38(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0xec02
movq -0x58(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
leaq -0x48(%rbp), %rcx
callq 0x60c0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xec9f
movq -0x38(%rbp), %rcx
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x38(%rbp)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
leaq -0x48(%rbp), %rcx
callq 0x60c0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xec9d
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rax
leaq -0x9609(%rip), %rcx     # 0x5690
movq %rcx, 0x10(%rax)
jmp 0xec9f
jmp 0xeca1
jmp 0xecb3
movq -0x28(%rbp), %rdi
movq 0x124b2(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: execute_struct_assignment
static enum result execute_struct_assignment( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct array *arr;
	struct expression *destination = this->source->next;
	struct variable obj = { 0, NULL }, var = { 0, NULL };
	enum result ret = destination->evaluate( destination, vars, &obj );
	if( ret ) {
		ret = is_instance( &obj, ( ( struct structure_statement * ) this )->structure, vars, destination );
		if( ret ) {
			arr = ( struct array * ) obj.string_value;
			ret = this->source->evaluate( this->source, vars, &var );
			if( ret ) {
				arr->number_values[ this->local ] = var.number_value;
				if( arr->string_values ) {
					if( arr->string_values[ this->local ] ) {
						unref_string( arr->string_values[ this->local ] );
					}
					arr->string_values[ this->local ] = var.string_value;
				} else {
					dispose_temporary( &var );
				}
			}
		}
		dispose_temporary( &obj );
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq *%rax
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0xf569
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x4f10
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0xf560
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq *%rax
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0xf55e
movl -0x48(%rbp), %edx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xf553
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xf53a
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3c20
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xf55c
leaq -0x48(%rbp), %rdi
callq 0x3ce0
jmp 0xf55e
jmp 0xf560
leaq -0x38(%rbp), %rdi
callq 0x3ce0
movl -0x4c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: execute_global_assignment
static enum result execute_global_assignment( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable var = { 0 }, *dest = ( ( struct global_assignment_statement * ) this )->destination;
	enum result ret = this->source->evaluate( this->source, vars, &var );
	if( ret ) {
		dispose_temporary( dest );
		dest->number_value = var.number_value;
		dest->string_value = var.string_value;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xf5f5
movq -0x30(%rbp), %rdi
callq 0x3ce0
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: write_string_expression
static enum result write_string_expression( struct expression *expr, struct variables *vars, int lf, FILE *output ) {
	struct variable value = { 0, NULL };
	struct string *str;
	enum result ret = expr->evaluate( expr, vars, &value );
	if( ret ) {
		if( value.string_value ) {
			if( value.string_value->type == CUSTOM && ( ( struct custom * ) value.string_value )->type->to_str ) {
				ret = ( ( struct custom * ) value.string_value )->type->to_str( &value, &str, vars, expr );
				dispose_temporary( &value );
				if( ret ) {
					value.string_value = str;
				} else {
					return ret;
				}
			}
			fwrite( value.string_value->string, 1, value.string_value->length, output );
		} else {
#if defined( FLOATING_POINT )
			fprintf( output, "%.16g", value.number_value );
#else
			fprintf( output, "%d", value.number_value );
#endif
		}
		if( lf ) {
			fputc( '\n', output );
		}
		dispose_temporary( &value );
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xf747
cmpq $0x0, -0x30(%rbp)
je 0xf715
movq -0x30(%rbp), %rax
movsbl 0x14(%rax), %eax
cmpl $0x9, %eax
jne 0xf6f5
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xf6f5
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3ce0
cmpl $0x0, -0x44(%rbp)
je 0xf6eb
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xf6f3
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf74d
jmp 0xf6f5
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rax
movslq 0x10(%rax), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x3200
jmp 0xf72a
movq -0x28(%rbp), %rdi
movl -0x38(%rbp), %edx
leaq 0xcb8d(%rip), %rsi      # 0x1c2b0
movb $0x0, %al
callq 0x3140
cmpl $0x0, -0x1c(%rbp)
je 0xf73e
movq -0x28(%rbp), %rsi
movl $0xa, %edi
callq 0x3100
leaq -0x38(%rbp), %rdi
callq 0x3ce0
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: execute_throw_statement
static enum result execute_throw_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable exc = { 0, NULL };
	this->source->evaluate( this->source, vars, &exc );
	dispose_temporary( vars->exception );
	vars->exception->number_value = exc.number_value;
	vars->exception->string_value = exc.string_value;
	return EXCEPTION;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq *%rax
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3ce0
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: execute_exit_statement
static enum result execute_exit_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable exit_code = { 0, NULL };
	char *message = NULL;
	enum result ret = this->source->evaluate( this->source, vars, &exit_code );
	if( ret ) {
		vars->func->env->interrupted = 1;
		if( vars->func->env->worker ) {
			message = "Worker exited.";
		}
		ret = throw_exit( vars, exit_code.number_value, message );
		dispose_temporary( &exit_code );
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xf900
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x40(%rax), %rax
movb $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x3a0(%rax)
je 0xf8e4
leaq 0xc9d3(%rip), %rax      # 0x1c2b3
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x42b0
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3ce0
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: execute_if_statement
static enum result execute_if_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct statement *stmt = ( ( struct block_statement * ) this )->if_block;
	struct variable condition = { 0 };
	enum result ret = this->source->evaluate( this->source, vars, &condition );
	if( ret ) {
		if( condition.string_value ) {
			dispose_temporary( &condition );
		} else if( condition.number_value == 0 ) {
			stmt = ( ( struct block_statement * ) this )->else_block;
		}
		while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
			stmt = stmt->next;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xfa16
cmpq $0x0, -0x28(%rbp)
je 0xf9b9
leaq -0x30(%rbp), %rdi
callq 0x3ce0
jmp 0xf9cd
cmpl $0x0, -0x30(%rbp)
jne 0xf9cb
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xf9cd
jmp 0xf9cf
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x35(%rbp)
je 0xf9fd
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x1, %eax
sete %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0xfa06
jmp 0xfa14
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xf9cf
jmp 0xfa16
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: execute_while_statement
static enum result execute_while_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct environment *env = vars->func->env;
	struct variable condition = { 0 };
	struct statement *stmt;
	enum result ret;
	while( 1 ) {
		if( this->source->evaluate( this->source, vars, &condition ) ) {
			if( condition.string_value ) {
				dispose_variable( &condition );
			} else if( condition.number_value ) {
				condition.number_value = 0;
			} else {
				return OKAY;
			}
		} else {
			return EXCEPTION;
		}
		stmt = ( ( struct block_statement * ) this )->if_block;
		while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
			stmt = stmt->next;
		}
		if( stmt ) {
			if( ret == RETURN ) {
				return RETURN;
			} else if( ret == BREAK ) {
				return OKAY;
			} else if( ret == EXCEPTION ) {
				return EXCEPTION;
			}
		}
		if( env->interrupted ) {
			return throw_interrupted( vars, this->source );
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
je 0xfe58
cmpq $0x0, -0x30(%rbp)
je 0xfe39
leaq -0x38(%rbp), %rdi
callq 0x3be0
jmp 0xfe56
cmpl $0x0, -0x38(%rbp)
je 0xfe48
movl $0x0, -0x38(%rbp)
jmp 0xfe54
movl $0x1, -0x4(%rbp)
jmp 0xff14
jmp 0xfe56
jmp 0xfe64
movl $0x0, -0x4(%rbp)
jmp 0xff14
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x40(%rbp)
movb %al, -0x45(%rbp)
je 0xfe9e
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x1, %eax
sete %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0xfea7
jmp 0xfeb5
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xfe70
cmpq $0x0, -0x40(%rbp)
je 0xfeef
cmpl $0x2, -0x44(%rbp)
jne 0xfecb
movl $0x2, -0x4(%rbp)
jmp 0xff14
cmpl $0x3, -0x44(%rbp)
jne 0xfeda
movl $0x1, -0x4(%rbp)
jmp 0xff14
cmpl $0x0, -0x44(%rbp)
jne 0xfee9
movl $0x0, -0x4(%rbp)
jmp 0xff14
jmp 0xfeeb
jmp 0xfeed
jmp 0xfeef
movq -0x28(%rbp), %rax
cmpb $0x0, 0x18(%rax)
je 0xff0f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4e70
movl %eax, -0x4(%rbp)
jmp 0xff14
jmp 0xfe04
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: execute_call_statement
static enum result execute_call_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable var = { 0, NULL };
	enum result ret = this->source->evaluate( this->source, vars, &var );
	if( ret ) {
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x10524
leaq -0x28(%rbp), %rdi
callq 0x3ce0
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: execute_try_catch_statement
static enum result execute_try_catch_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	enum result ret = OKAY;
	int idx = this->local;
	struct variables try_vars;
	struct local_variable *exception_var;
	try_vars.parent = vars->parent;
	try_vars.exception = &vars->locals[ idx ];
	try_vars.locals = vars->locals;
	try_vars.func = vars->func;
	try_vars.line = vars->line;
	ret = execute_statements( ( ( struct block_statement * ) this )->if_block, &try_vars, result );
	if( ret == EXCEPTION ) {
		exception_var = vars->func->variable_decls;
		while( idx-- > 0 )
		{
			exception_var = exception_var->next;
		}
		if( is_exit( try_vars.exception )
		|| ( exception_var->type && !is_instance( try_vars.exception, exception_var->type, NULL, NULL ) ) ) {
			assign_variable( try_vars.exception, vars->exception );
		} else {
			return execute_statements( ( ( struct block_statement * ) this )->else_block, vars, result );
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0x10a90
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x107fd
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x48(%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x28(%rbp)
cmpl $0x0, %eax
jle 0x10798
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x1077a
movq -0x48(%rbp), %rdi
callq 0x10b00
cmpl $0x0, %eax
jne 0x107ce
movq -0x58(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x107e1
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x4f10
cmpl $0x0, %eax
jne 0x107e1
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3d10
jmp 0x107fb
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10a90
movl %eax, -0x4(%rbp)
jmp 0x10803
jmp 0x107fd
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: execute_statements
static enum result execute_statements( struct statement *stmt, struct variables *vars, struct variable *result ) {
	enum result ret = OKAY;
	while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
		stmt = stmt->next;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x1d(%rbp)
je 0x10ad9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x1, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x10ae2
jmp 0x10af0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x10aab
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x30f0
movl $0x1, %edi
movl $0x48, %esi
callq 0x3120
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
je 0x10e18
movq -0x80(%rbp), %rax
leaq -0xbe94(%rip), %rcx     # 0x4ed0
movq %rcx, 0x18(%rax)
movq -0x80(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movl $0x7b, %ecx
leaq -0x48(%rbp), %r8
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0xac40
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x10e16
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x80, %rdi
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r9
leaq -0x78(%rbp), %r8
callq 0x9050
movq -0x58(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x10e14
movq -0x80(%rbp), %rax
leaq 0x13c(%rip), %rcx       # 0x10f40
movq %rcx, 0x10(%rax)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x10e16
jmp 0x10e28
movq -0x28(%rbp), %rdi
movq 0x1033d(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x50(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x30f0
movl $0x1, %edi
movl $0x48, %esi
callq 0x3120
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x10f1a
movq -0x60(%rbp), %rax
leaq -0xbfd1(%rip), %rcx     # 0x4ed0
movq %rcx, 0x18(%rax)
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x80, %rdi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r9
leaq -0x58(%rbp), %r8
callq 0x9050
movq -0x38(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x10f18
movq -0x60(%rbp), %rax
leaq 0x38(%rip), %rcx        # 0x10f40
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x10f2a
movq -0x28(%rbp), %rdi
movq 0x1023b(%rip), %rsi     # 0x21160
callq 0x3070
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x25(%rbp)
je 0x10f95
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x1, %eax
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x10f9e
jmp 0x10fac
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x10f67
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x10fea
movl $0x1, -0x14(%rbp)
jmp 0x110fd
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x11004
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x110fb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x110f2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x110c3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x110c3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0x11086
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rax
movslq 0x10(%rax), %rdx
shlq $0x0, %rdx
callq 0x3110
movl %eax, -0x14(%rbp)
jmp 0x110aa
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movslq 0x10(%rax), %rdx
shlq $0x0, %rdx
callq 0x3110
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x110c1
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x28(%rbp), %rcx
subl 0x10(%rcx), %eax
movl %eax, -0x14(%rbp)
jmp 0x110f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x110e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
xorl %eax, %eax
subl 0x10(%rcx), %eax
movl %eax, -0x14(%rbp)
jmp 0x110ee
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x110f0
jmp 0x110f9
movl $0x0, -0x14(%rbp)
jmp 0x110fb
jmp 0x110fd
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x4ff0
movl %eax, -0x84(%rbp)
cmpl $0x0, -0x84(%rbp)
je 0x111fb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x4ff0
movl %eax, -0x84(%rbp)
cmpl $0x0, -0x84(%rbp)
je 0x111f2
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x68(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
leaq -0x60(%rbp), %r8
callq 0x11210
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x68(%rbp), %rcx
cmpl 0x10(%rcx), %eax
je 0x111e9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x60(%rbp), %rcx
xorl %edx, %edx
callq 0x4330
movl %eax, -0x84(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3ce0
leaq -0x70(%rbp), %rdi
callq 0x3ce0
movl -0x84(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: save_file
static int save_file( char *file_name, char *buffer, int length, int append, char *message ) {
	int count = -1;
	FILE *output_file = fopen( file_name, append ? "ab" : "wb" );
	if( output_file != NULL ) {
		count = fwrite( buffer, sizeof( char ), length, output_file );
		fclose( output_file );
	}
	if( count < length ) {
		strncpy( message, strerror( errno ), 63 );
		message[ 63 ] = 0;
	}
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %ecx
leaq 0xb136(%rip), %rsi      # 0x1c375
leaq 0xb12c(%rip), %rax      # 0x1c372
cmpl $0x0, %ecx
cmovneq %rax, %rsi
callq 0x31c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1127f
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x1, %esi
callq 0x3200
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rdi
callq 0x30a0
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x112b4
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x3040
movl (%rax), %edi
callq 0x3210
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl $0x3f, %edx
callq 0x3050
movq -0x20(%rbp), %rax
movb $0x0, 0x3f(%rax)
movl -0x24(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x11320
movl -0x28(%rbp), %ecx
xorl $-0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x3ce0
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x11576
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x11554
cmpq $0x0, -0x20(%rbp)
jne 0x11554
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3ce0
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: evaluate_same_expression
static enum result evaluate_same_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable lhs = { 0, NULL }, rhs = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &lhs );
	if( ret ) {
		parameter = parameter->next;
		ret = parameter->evaluate( parameter, vars, &rhs );
		if( ret ) {
			result->number_value = ( lhs.number_value == rhs.number_value )
				&& ( lhs.string_value == rhs.string_value );
			dispose_temporary( &rhs );
		}
		dispose_temporary( &lhs );
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x11645
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x1163c
movl -0x28(%rbp), %ecx
xorl %eax, %eax
cmpl -0x38(%rbp), %ecx
movb %al, -0x45(%rbp)
jne 0x11625
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
sete %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3ce0
leaq -0x28(%rbp), %rdi
callq 0x3ce0
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: evaluate_eq_expression
static enum result evaluate_eq_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable lhs = { 0, NULL }, rhs = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &lhs );
	if( ret ) {
		parameter = parameter->next;
		ret = parameter->evaluate( parameter, vars, &rhs );
		if( ret ) {
			result->number_value = compare_variables( &lhs, &rhs ) == 0;
			dispose_temporary( &rhs );
		}
		dispose_temporary( &lhs );
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x1170a
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x11701
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10fc0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3ce0
leaq -0x28(%rbp), %rdi
callq 0x3ce0
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: evaluate_cmp_expression
static enum result evaluate_cmp_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable var1 = { 0, NULL }, var2 = { 0, NULL };
	enum result ret = parameter->evaluate( parameter, vars, &var1 );
	if( ret ) {
		parameter = parameter->next;
		ret = parameter->evaluate( parameter, vars, &var2 );
		if( ret ) {
			result->number_value = compare_variables( &var1, &var2 );
			dispose_temporary( &var2 );
		}
		dispose_temporary( &var1 );
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30f0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x11a41
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x11a38
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x10fc0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x3ce0
leaq -0x30(%rbp), %rdi
callq 0x3ce0
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: evaluate_asc_expression
static enum result evaluate_asc_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct string *str;
	int val;
	enum result ret = evaluate_integer( this->parameters, vars, &val );
	if( ret ) {
		str = new_string( 1 );
		if( str ) {
			str->string[ 0 ] = val;
			result->string_value = str;
		} else {
			ret = throw_out_of_memory( vars, this );
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x5460
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x11cd6
movl $0x1, %edi
callq 0x39b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x11cc4
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x11cd4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5f20
movl %eax, -0x28(%rbp)
jmp 0x11cd6
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5460
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x11d9c
movl $0xa, %edi
callq 0x39b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x11d8a
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x20(%rbp), %edx
leaq 0xa7b5(%rip), %rsi      # 0x1c4f2
movb $0x0, %al
callq 0x31f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x11d65
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x11d88
movq -0x28(%rbp), %rdi
callq 0x3c20
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq 0xa779(%rip), %rcx      # 0x1c4f9
callq 0x4330
movl %eax, -0x2c(%rbp)
jmp 0x11d9a
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5f20
movl %eax, -0x2c(%rbp)
jmp 0x11d9c
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)