LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_import
static struct element* parse_import( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next, *name = next;
	struct string *library = get_decl_indexed( func, name->str.string, name->str.length, LIBRARY );
	if( library ) {
		next = next->next->next->next->next;
	} else {
		next = parse_include( next->next, func, vars, prev, message );
		library = get_decl_indexed( func, name->str.string, name->str.length, LIBRARY );
	}
	if( message[ 0 ] == 0 ) {
		if( library ) {
			import_library( library, func->file, message );
		} else {
			sprintf( message, "Library '%.32s' not found in file %.64s on line %d.\n", name->str.string, name->next->next->str.string, elem->line );
		}
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %rbp
movq 0x8(%rbp), %r12
movl 0x10(%rbp), %edx
movq 0x40(%rsi), %rdi
movq %r12, %rsi
movl $0x7, %ecx
callq 0x8851
movq 0x20(%rbp), %rdi
testq %rax, %rax
je 0x8e86
movq 0x20(%rdi), %rcx
movq 0x20(%rcx), %rcx
movq 0x20(%rcx), %r13
jmp 0x8eac
movq %r15, %rsi
movq %rbx, %r8
callq 0x8efd
movq %rax, %r13
movq 0x8(%rbp), %r12
movl 0x10(%rbp), %edx
movq 0x40(%r15), %rdi
movq %r12, %rsi
movl $0x7, %ecx
callq 0x8851
cmpb $0x0, (%rbx)
jne 0x8eeb
testq %rax, %rax
je 0x8ec7
movq 0x28(%r15), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x92be
jmp 0x8eeb
movq 0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rcx
movl 0x28(%r14), %r8d
leaq 0x9c03(%rip), %rsi      # 0x12ae1
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x3200
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_library_declaration
static struct element* parse_library_declaration( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct function *init;
	struct element *next = elem->next;
	struct string *library = get_decl_indexed( func, next->str.string, next->str.length, LIBRARY );
	if( library ) {
		library->reference_count++;
	} else {
		library = new_string_value( next->str.string );
		if( library ) {
			library->type = LIBRARY;
			add_decl( library, next->line, func->env, message );
		} else {
			strcpy( message, OUT_OF_MEMORY );
		}
	}
	if( message[ 0 ] == 0 && import_library( library, func->file, message ) ) {
		init = new_function( "[Init]", NULL );
		if( init ) {
			init->file = func->file;
			init->file->reference_count++;
			init->library = library;
			library->reference_count++;
			init->env = func->env;
			next = next->next;
			parse_keywords( library_decls, next->child, init, NULL, NULL, message );
			next = next->next;
			unref_string( &init->str );
		} else {
			strcpy( message, OUT_OF_MEMORY );
		}
		unref_string( library );
	}
	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rsi, %r12
movq 0x20(%rdi), %rbx
movq 0x8(%rbx), %r13
movl 0x10(%rbx), %edx
movq 0x40(%rsi), %rdi
movq %r13, %rsi
movl $0x7, %ecx
callq 0x8851
testq %rax, %rax
je 0x9146
movq %rax, %r15
incq (%rax)
jmp 0x9181
movq %r13, %rdi
callq 0x37b3
testq %rax, %rax
je 0x916f
movq %rax, %r15
movb $0x7, 0x14(%rax)
movl 0x28(%rbx), %esi
movq 0x40(%r12), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x3edc
jmp 0x9181
movq 0xfffa(%rip), %rsi      # 0x19170
movq %r14, %rdi
callq 0x3070
xorl %r15d, %r15d
cmpb $0x0, (%r14)
jne 0x9215
movq 0x28(%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x92be
testl %eax, %eax
je 0x9215
leaq 0x936c(%rip), %rdi      # 0x12512
xorl %esi, %esi
callq 0x7275
testq %rax, %rax
je 0x91fe
movq %rax, %r13
movq 0x28(%r12), %rax
movq %rax, 0x28(%r13)
incq (%rax)
movq %r15, 0x30(%r13)
incq (%r15)
movq 0x40(%r12), %rax
movq %rax, 0x40(%r13)
movq 0x20(%rbx), %rbx
movq 0x18(%rbx), %rsi
leaq 0x10bf0(%rip), %rdi     # 0x19dd0
movq %r13, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x7850
movq 0x20(%rbx), %rbx
movq %r13, %rdi
callq 0x394d
jmp 0x920d
movq 0xff6b(%rip), %rsi      # 0x19170
movq %r14, %rdi
callq 0x3070
movq %r15, %rdi
callq 0x394d
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_program_declaration
static struct element* parse_program_declaration( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct environment *env = func->env;
	struct element *next = elem->next;
	struct function *prog = new_function( next->str.string, NULL );
	if( prog ) {
		prog->line = elem->line;
		prog->file = func->file;
		prog->file->reference_count++;
		if( func->library ) {
			prog->library = func->library;
			prog->library->reference_count++;
		}
		prog->body = next->next;
		prog->env = env;
		if( add_decl( &prog->str, next->line, env, message ) ) {
			env->entry_point = prog;
			next = next->next->next;
		}
		unref_string( &prog->str );
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x40(%rsi), %r14
movq 0x20(%rdi), %rbx
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x7275
testq %rax, %rax
je 0x92ac
movq %rax, %r15
movl 0x28(%rbp), %eax
movl %eax, 0x18(%r15)
movq 0x28(%r13), %rax
movq %rax, 0x28(%r15)
incq (%rax)
movq 0x30(%r13), %rax
testq %rax, %rax
je 0x9273
movq %rax, 0x30(%r15)
incq (%rax)
movq 0x20(%rbx), %rax
movq %rax, 0x38(%r15)
movq %r14, 0x40(%r15)
movl 0x28(%rbx), %esi
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x3edc
testq %rax, %rax
je 0x92a4
movq %r15, 0x398(%r14)
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rbx
movq %r15, %rdi
callq 0x394d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: import_library
static int import_library( struct string *library, struct string *source, char *message ) {
	struct string_list *imports;
	if( source->type == SOURCE ) {
		imports = ( ( struct source * ) source )->imports;
		while( imports ) {
			if( imports->str == library ) {
				return 1;
			}
			imports = imports->next;
		}
		imports = new_string_list( library, ( ( struct source * ) source )->imports );
		if( imports ) {
			( ( struct source * ) source )->imports = imports;
		} else {
			strcpy( message, OUT_OF_MEMORY );
			return 0;
		}
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x1, %ebx
cmpb $0x8, 0x14(%rsi)
jne 0x9326
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq 0x18(%rsi), %r13
testq %r13, %r13
je 0x92f5
movq %r13, %rax
cmpq %r12, (%rax)
je 0x9326
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x92e7
movl $0x10, %edi
callq 0x31b0
testq %rax, %rax
je 0x9315
movq %r12, (%rax)
incq (%r12)
movq %r13, 0x8(%rax)
movq %rax, 0x18(%r14)
jmp 0x9326
movq 0xfe54(%rip), %rsi      # 0x19170
movq %r15, %rdi
callq 0x3070
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: str_idx
static int str_idx( char *str, char *chars, int idx ) {
	char *chr, *end;
	if( idx < 0 ) {
		chr = end = field_end( str, chars );
		while( *end ) {
			chr = end;
			end = field_end( end + 1, chars );
		}
	} else {
		chr = field_end( str + idx, chars );
	}
	if( *chr ) {
		return chr - str;
	}
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
js 0x9353
movl %edx, %edi
addq %rbx, %rdi
movq %r14, %rsi
callq 0x8312
movq %rax, %r15
jmp 0x9377
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8312
cmpb $0x0, (%rax)
je 0x934e
movq %rax, %r15
leaq 0x1(%rax), %rdi
movq %r14, %rsi
callq 0x8312
cmpb $0x0, (%rax)
jne 0x9363
movl %r15d, %ecx
subl %ebx, %ecx
xorl %eax, %eax
cmpb $0x1, (%r15)
sbbl %eax, %eax
orl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_function_declaration
static struct element* parse_function_declaration( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next;
	struct function *decl = parse_function( next->next, next->str.string, func, message );
	if( decl ) {
		if( add_decl( &decl->str, next->line, func->env, message ) ) {
			next = next->next->next->next;
		}
		unref_string( &decl->str );
	}
	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rsi, %r12
movq 0x20(%rdi), %rbx
movq 0x8(%rbx), %rsi
movq 0x20(%rbx), %rdi
movq %r12, %rdx
movq %r8, %rcx
callq 0x7020
testq %rax, %rax
je 0x93e5
movq %rax, %r14
movl 0x28(%rbx), %esi
movq 0x40(%r12), %rdx
movq %rax, %rdi
movq %r15, %rcx
callq 0x3edc
testq %rax, %rax
je 0x93dd
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rbx
movq %r14, %rdi
callq 0x394d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: add_global_constant
static int add_global_constant( struct element *elem,
	struct function *func, struct structure *type, struct expression *initializer,
	struct statement *prev, char *message ) {
	struct global_variable *global = new_global_variable( elem->str.string, type, func, initializer, message );
	if( global ) {
		if( add_global( global, elem->line, func->env, message ) ) {
			global->str.type = CONST;
		}
		unref_string( &global->str );
	}
	return message[ 0 ] == 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
movq %r15, %rdx
movq %r9, %r8
callq 0x4040
testq %rax, %rax
je 0x99b6
movq %rax, %r14
movl 0x28(%r12), %esi
movq 0x40(%r15), %rdx
movq %rax, %rdi
movq %rbx, %rcx
callq 0x410f
testq %rax, %rax
je 0x99ae
movb $0x5, 0x14(%r14)
movq %r14, %rdi
callq 0x394d
xorl %eax, %eax
cmpb $0x0, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: expr_set_line
static void expr_set_line( struct expression *expr, int line ) {
	while( expr ) {
		expr->line = line;
		expr_set_line( expr->parameters, line );
		expr = expr->next;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x9cfb
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %ebx, (%r14)
movq 0x8(%r14), %rdi
movl %ebx, %esi
callq 0x9ccf
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x9cdd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: add_global_variable
static int add_global_variable( struct element *elem,
	struct function *func, struct structure *type, struct expression *initializer,
	struct statement *prev, char *message ) {
	struct global_variable *global = new_global_variable( elem->str.string, type, func, initializer, message );
	if( global ) {
		add_global( global, elem->line, func->env, message );
		unref_string( &global->str );
	}
	return message[ 0 ] == 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %r9, %r8
callq 0x4040
testq %rax, %rax
je 0x9d43
movq %rax, %r15
movl 0x28(%r12), %esi
movq 0x40(%r14), %rdx
movq %rax, %rdi
movq %rbx, %rcx
callq 0x410f
movq %r15, %rdi
callq 0x394d
xorl %eax, %eax
cmpb $0x0, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_break_statement
static struct element* parse_break_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		stmt->execute = execute_break_statement;
		prev->next = stmt;
		next = next->next;
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r15
movq %rcx, %r14
movq 0x20(%rdi), %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x3130
testq %rax, %rax
je 0xa649
leaq 0xdbd(%rip), %rcx       # 0xb3f8
movq %rcx, 0x10(%rax)
movq %rax, 0x20(%r14)
movq 0x20(%rbx), %rbx
jmp 0xa658
movq 0xeb20(%rip), %rsi      # 0x19170
movq %r15, %rdi
callq 0x3070
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_continue_statement
static struct element* parse_continue_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		stmt->execute = execute_continue_statement;
		prev->next = stmt;
		next = next->next;
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r15
movq %rcx, %r14
movq 0x20(%rdi), %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x3130
testq %rax, %rax
je 0xa699
leaq 0xd73(%rip), %rcx       # 0xb3fe
movq %rcx, 0x10(%rax)
movq %rax, 0x20(%r14)
movq 0x20(%rbx), %rbx
jmp 0xa6a8
movq 0xead0(%rip), %rsi      # 0x19170
movq %r15, %rdi
callq 0x3070
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_until_statement
static struct element* parse_until_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = parse_while_statement( elem, func, vars, prev, message );
	if( message[ 0 ] == 0 ) {
		prev->next->execute = execute_until_statement;
	}
	return next;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
callq 0xa95b
cmpb $0x0, (%r14)
jne 0xab23
movq 0x20(%rbx), %rcx
leaq 0xeb8(%rip), %rdx       # 0xb9d7
movq %rdx, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_try_statement
static struct element* parse_try_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct statement try_block = { 0 };
	struct block_statement *try_stmt = calloc( 1, sizeof( struct block_statement ) );
	if( try_stmt ) {
		try_stmt->stmt.dispose = dispose_block_statement;
		prev->next = &try_stmt->stmt;
		elem = elem->next;
		if( elem->child ) {
			parse_keywords_indexed( func->env->statements_index, elem->child, func, vars, &try_block, message );
			try_stmt->if_block = try_block.next;
		}
		if( message[ 0 ] == 0 ) {
			elem = parse_catch_block( elem->next, func, vars, try_stmt, message );
			while( message[ 0 ] == 0 && elem
			&& ( is_keyword( elem->str.string, "catch" ) || is_keyword( elem->str.string, "finally" ) ) ) {
				try_stmt = calloc( 1, sizeof( struct block_statement ) );
				if( try_stmt ) {
					try_stmt->stmt.dispose = dispose_block_statement;
					try_stmt->if_block = prev->next;
					prev->next = &try_stmt->stmt;
					elem = parse_catch_block( elem, func, vars, try_stmt, message );
				} else {
					strcpy( message, OUT_OF_MEMORY );
				}
			}
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return elem;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x20(%rsp)
movl $0x1, %edi
movl $0x48, %esi
callq 0x3130
testq %rax, %rax
je 0xac73
movq %rax, %rbp
leaq -0x6807(%rip), %rax     # 0x4387
movq %rax, 0x18(%rbp)
movq %rbp, 0x20(%r15)
movq 0x20(%rbx), %rbx
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0xabc7
movq 0x40(%r13), %rdi
subq $-0x80, %rdi
movq %rsp, %r8
movq %r13, %rdx
movq %r12, %rcx
movq %r14, %r9
callq 0x6e94
movq %rsp, %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rbp)
cmpb $0x0, (%r14)
jne 0xac82
movq 0x20(%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %rcx
movq %r14, %r8
callq 0xbac2
movq %rax, %rbx
cmpb $0x0, (%r14)
jne 0xac82
testq %rbx, %rbx
je 0xac82
movq 0x8(%rbx), %rbp
movq %rbp, %rdi
leaq 0x77cb(%rip), %rsi      # 0x123d5
callq 0x65ba
testl %eax, %eax
jne 0xac26
movq %rbp, %rdi
leaq 0x77be(%rip), %rsi      # 0x123db
callq 0x65ba
testl %eax, %eax
je 0xac82
movl $0x1, %edi
movl $0x48, %esi
callq 0x3130
testq %rax, %rax
jne 0xac4b
movq 0xe52f(%rip), %rsi      # 0x19170
movq %r14, %rdi
callq 0x3070
jmp 0xabe9
leaq -0x68cb(%rip), %rcx     # 0x4387
movq %rcx, 0x18(%rax)
movq 0x20(%r15), %rcx
movq %rcx, 0x28(%rax)
movq %rax, 0x20(%r15)
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
jmp 0xabde
movq 0xe4f6(%rip), %rsi      # 0x19170
movq %r14, %rdi
callq 0x3070
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_increment_statement
static struct element* parse_increment_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct local_variable *local;
	struct element *next = elem->next;
	struct statement *stmt = calloc( 1, sizeof( struct statement ) );
	if( stmt ) {
		prev->next = stmt;
		local = get_local_variable( func->variable_decls, next->str.string, "" );
		if( local ) {
			stmt->source = calloc( 1, sizeof( struct expression ) );
			if( stmt->source ) {
				stmt->local = local->index;
				stmt->source->line = next->line;
				stmt->execute = execute_increment_statement;
				next = next->next->next;
			} else {
				strcpy( message, OUT_OF_MEMORY );
			}
		} else {
			sprintf( message, "Undeclared local variable '%.64s' on line %d.", next->str.string, next->line );
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rsi, %r12
movq 0x20(%rdi), %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x3130
testq %rax, %rax
je 0xaea9
movq %rax, %r15
movq %rax, 0x20(%r13)
movq 0x48(%r12), %rdi
movq 0x8(%rbx), %r12
leaq 0x71f6(%rip), %rdx      # 0x12056
movq %r12, %rsi
callq 0x5d92
testq %rax, %rax
je 0xaeba
movq %rax, %r13
movl $0x1, %edi
movl $0x20, %esi
callq 0x3130
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0xaea9
movl (%r13), %ecx
movl %ecx, (%r15)
movl 0x28(%rbx), %ecx
movl %ecx, (%rax)
leaq -0x64af(%rip), %rax     # 0x49ec
movq %rax, 0x10(%r15)
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rbx
jmp 0xaed1
movq 0xe2c0(%rip), %rsi      # 0x19170
movq %r14, %rdi
callq 0x3070
jmp 0xaed1
movl 0x28(%rbx), %ecx
leaq 0x7f68(%rip), %rsi      # 0x12e2c
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x3200
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: parse_append_statement
static struct element* parse_append_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = parse_save_statement( elem, func, vars, prev, message );
	if( prev->next && message[ 0 ] == 0 ) {
		prev->next->local = 1;
	}
	return next;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
leaq 0x1399(%rip), %r8       # 0xc356
movq %rbx, %r9
callq 0x64e9
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0xafd9
cmpb $0x0, (%rbx)
jne 0xafd9
movl $0x1, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, (%rsp)
movq %rsi, %r13
movq %rdi, %rbp
movq %rsi, %rdi
movq %rbp, %rsi
movq %r9, %rcx
callq 0x88e6
testq %rax, %rax
je 0xb05b
movq %rax, %r12
movq 0x48(%r13), %r15
movq 0x8(%rbp), %rsi
leaq 0x7035(%rip), %rdx      # 0x12056
movq %r15, %rdi
callq 0x5d92
testq %rax, %rax
je 0xb072
movq 0x18(%r12), %r14
movq %r12, %rdi
callq 0x3030
movq %r14, %r12
testq %r14, %r14
jne 0xb02e
movq 0x8(%rbp), %rdx
movl 0x28(%rbp), %ecx
leaq 0x7c9f(%rip), %rsi      # 0x12cf0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3200
xorl %eax, %eax
cmpb $0x0, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x20(%r13), %ebp
leal 0x1(%rbp), %eax
movl %eax, 0x20(%r13)
testq %r15, %r15
je 0xb08c
movq 0x50(%r13), %rax
addq $0x18, %rax
jmp 0xb090
leaq 0x48(%r13), %rax
movq %r12, (%rax)
movq %r12, 0x50(%r13)
cmpq $0x0, (%rsp)
je 0xb05b
movl $0x1, %edi
movl $0x28, %esi
callq 0x3130
testq %rax, %rax
je 0xb0cd
movq %rax, 0x20(%r14)
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movl %ebp, (%rax)
leaq -0x6e1a(%rip), %rcx     # 0x42ad
movq %rcx, 0x10(%rax)
jmp 0xb05b
movq 0xe09c(%rip), %rsi      # 0x19170
movq %rbx, %rdi
callq 0x3070
jmp 0xb05b
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: execute_struct_assignment
static enum result execute_struct_assignment( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct array *arr;
	struct expression *destination = this->source->next;
	struct variable obj = { 0, NULL }, var = { 0, NULL };
	enum result ret = destination->evaluate( destination, vars, &obj );
	if( ret ) {
		ret = is_instance( &obj, ( ( struct structure_statement * ) this )->structure, vars, destination );
		if( ret ) {
			arr = ( struct array * ) obj.string_value;
			ret = this->source->evaluate( this->source, vars, &var );
			if( ret ) {
				arr->number_values[ this->local ] = var.number_value;
				if( arr->string_values ) {
					if( arr->string_values[ this->local ] ) {
						unref_string( arr->string_values[ this->local ] );
					}
					arr->string_values[ this->local ] = var.string_value;
				} else {
					dispose_temporary( &var );
				}
			}
		}
		dispose_temporary( &obj );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq *0x18(%r14)
testl %eax, %eax
je 0xb184
movq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x43a6
xorl %r14d, %r14d
testl %eax, %eax
je 0xb19b
movq 0x18(%rsp), %r12
movq 0x8(%rbx), %rdi
movq %rsp, %rdx
movq %r15, %rsi
callq *0x18(%rdi)
testl %eax, %eax
je 0xb19b
movl %eax, %ebp
movl (%rsp), %eax
movq 0x18(%r12), %rcx
movslq (%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
movq 0x20(%r12), %rax
testq %rax, %rax
je 0xb189
movslq (%rbx), %rcx
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0xb179
callq 0x394d
movq 0x20(%r12), %rax
movslq (%rbx), %rcx
movq 0x8(%rsp), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0xb198
xorl %r14d, %r14d
jmp 0xb1aa
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb198
callq 0x394d
movl %ebp, %r14d
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xb1aa
callq 0x394d
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: 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 %r14
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %r14
movq %rax, %rdi
callq *0x18(%rax)
movl %eax, %ebx
testl %eax, %eax
je 0xb1fb
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb1ec
callq 0x394d
movl (%rsp), %eax
movl %eax, (%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: write_string_expression
static enum result write_string_expression( struct expression *expr, struct variables *vars, int lf, FILE *output ) {
	struct variable value = { 0, NULL };
	struct string *str;
	enum result ret = expr->evaluate( expr, vars, &value );
	if( ret ) {
		if( value.string_value ) {
			if( value.string_value->type == CUSTOM && ( ( struct custom * ) value.string_value )->type->to_str ) {
				ret = ( ( struct custom * ) value.string_value )->type->to_str( &value, &str, vars, expr );
				dispose_temporary( &value );
				if( ret ) {
					value.string_value = str;
				} else {
					return ret;
				}
			}
			fwrite( value.string_value->string, 1, value.string_value->length, output );
		} else {
#if defined( FLOATING_POINT )
			fprintf( output, "%.16g", value.number_value );
#else
			fprintf( output, "%d", value.number_value );
#endif
		}
		if( lf ) {
			fputc( '\n', output );
		}
		dispose_temporary( &value );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r12
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
callq *0x18(%rdi)
xorl %r15d, %r15d
testl %eax, %eax
je 0xb2ec
movl %eax, %r14d
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xb2b5
cmpb $0x9, 0x14(%rax)
jne 0xb29e
movq 0x18(%rax), %rcx
movq 0x10(%rcx), %r8
testq %r8, %r8
je 0xb29e
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *%r8
movl %eax, %r14d
movq %rsp, %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0xb28f
callq 0x394d
testl %r14d, %r14d
je 0xb2ec
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x3210
jmp 0xb2c9
movl (%rsp), %edx
leaq 0x7b21(%rip), %rsi      # 0x12de0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3150
testl %ebp, %ebp
je 0xb2da
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3100
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb2e9
callq 0x394d
movl %r14d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: 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 %rbx
subq $0x10, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0xb359
callq 0x394d
movq 0x8(%rbx), %rax
movl (%rsp), %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
testl %eax, %eax
je 0xb3ed
movq 0x18(%rbx), %rax
movq 0x40(%rax), %rax
movb $0x1, 0x18(%rax)
movq 0x3a0(%rax), %rcx
testq %rcx, %rcx
leaq 0x7a38(%rip), %rdx      # 0x12de3
cmoveq %rcx, %rdx
movl (%rsp), %ebp
movq 0x8(%rbx), %rbx
leaq 0x20(%rax), %r14
movq $0x2, 0x20(%rax)
movb $0xa, 0x34(%rax)
movq %rdx, 0x28(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xb3d8
callq 0x394d
movl %ebp, (%rbx)
movq %r14, 0x8(%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb3ed
callq 0x394d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: execute_if_statement
static enum result execute_if_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct statement *stmt = ( ( struct block_statement * ) this )->if_block;
	struct variable condition = { 0 };
	enum result ret = this->source->evaluate( this->source, vars, &condition );
	if( ret ) {
		if( condition.string_value ) {
			dispose_temporary( &condition );
		} else if( condition.number_value == 0 ) {
			stmt = ( ( struct block_statement * ) this )->else_block;
		}
		while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
			stmt = stmt->next;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x28(%rdi), %r15
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
testl %eax, %eax
je 0xb444
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb448
callq 0x394d
jmp 0xb453
xorl %ebp, %ebp
jmp 0xb47c
cmpl $0x0, (%rsp)
jne 0xb453
movq 0x30(%r12), %r15
testq %r15, %r15
je 0xb47c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%r15)
cmpl $0x1, %eax
jne 0xb47a
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0xb458
movl $0x1, %ebp
jmp 0xb47c
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: execute_if_local_statement
static enum result execute_if_local_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable *lhs = &vars->locals[ this->local ];
	struct variable *rhs = &vars->locals[ ( ( struct block_statement * ) this )->rhs ];
	struct statement *stmt = ( ( struct block_statement * ) this )->if_block;
	enum result ret = OKAY;
	if( lhs->string_value || rhs->string_value ) {
		return execute_if_statement( this, vars, result );
	}
	switch( ( ( struct block_statement * ) this )->oper ) {
		case '!': if( lhs->number_value == rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		case '(': if( lhs->number_value >  rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		case ')': if( lhs->number_value <  rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		case '<': if( lhs->number_value >= rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		case '=': if( lhs->number_value != rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		case '>': if( lhs->number_value <= rhs->number_value ) stmt = ( ( struct block_statement * ) this )->else_block; break;
		default: return execute_if_statement( this, vars, result );
	}
	while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
		stmt = stmt->next;
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rsi), %rax
movslq (%rdi), %rdx
shlq $0x4, %rdx
cmpq $0x0, 0x8(%rax,%rdx)
jne 0xb4bd
movslq 0x3c(%rdi), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
cmpq $0x0, 0x8(%rcx)
je 0xb4d2
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb404
addq %rdx, %rax
movq 0x28(%rdi), %r15
movl 0x38(%rdi), %edx
cmpl $0x3b, %edx
jg 0xb4f8
cmpl $0x21, %edx
je 0xb50f
cmpl $0x28, %edx
je 0xb552
cmpl $0x29, %edx
jne 0xb4bd
movl (%rax), %eax
cmpl (%rcx), %eax
jl 0xb51d
jmp 0xb521
cmpl $0x3c, %edx
je 0xb517
cmpl $0x3d, %edx
je 0xb55a
cmpl $0x3e, %edx
jne 0xb4bd
movl (%rax), %eax
cmpl (%rcx), %eax
jle 0xb51d
jmp 0xb521
movl (%rax), %eax
cmpl (%rcx), %eax
je 0xb51d
jmp 0xb521
movl (%rax), %eax
cmpl (%rcx), %eax
jl 0xb521
movq 0x30(%rdi), %r15
movl $0x1, %ebp
testq %r15, %r15
je 0xb545
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%r15)
cmpl $0x1, %eax
jne 0xb543
movq 0x20(%r15), %r15
jmp 0xb526
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl (%rax), %eax
cmpl (%rcx), %eax
jg 0xb51d
jmp 0xb521
movl (%rax), %eax
cmpl (%rcx), %eax
jne 0xb51d
jmp 0xb521
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: execute_if_const_statement
static enum result execute_if_const_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable *lhs = &vars->locals[ this->local ];
	number rhs = ( ( struct block_statement * ) this )->num;
	struct statement *stmt = ( ( struct block_statement * ) this )->if_block;
	enum result ret = OKAY;
	if( lhs->string_value ) {
		if( ( ( struct block_statement * ) this )->oper ) {
			return execute_if_statement( this, vars, result );
		}
	} else {
		switch( ( ( struct block_statement * ) this )->oper ) {
			case  0 : if( lhs->number_value == 0 ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case '!': if( lhs->number_value == rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case '(': if( lhs->number_value >  rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case ')': if( lhs->number_value <  rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case '<': if( lhs->number_value >= rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case '=': if( lhs->number_value != rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			case '>': if( lhs->number_value <= rhs ) stmt = ( ( struct block_statement * ) this )->else_block; break;
			default: return execute_if_statement( this, vars, result );
		}
	}
	while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
		stmt = stmt->next;
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rsi), %rax
movslq (%rdi), %rcx
shlq $0x4, %rcx
movq 0x28(%rdi), %r15
cmpq $0x0, 0x8(%rax,%rcx)
movl 0x38(%rdi), %edx
je 0xb5a2
testl %edx, %edx
je 0xb5fb
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb404
addq %rcx, %rax
movl 0x40(%rdi), %ecx
cmpl $0x28, %edx
jle 0xb5c2
cmpl $0x3c, %edx
jg 0xb5d6
cmpl $0x29, %edx
je 0xb5ed
cmpl $0x3c, %edx
jne 0xb58d
cmpl %ecx, (%rax)
jge 0xb5f7
jmp 0xb5fb
testl %edx, %edx
je 0xb5e6
cmpl $0x21, %edx
je 0xb62c
cmpl $0x28, %edx
jne 0xb58d
cmpl %ecx, (%rax)
jg 0xb5f7
jmp 0xb5fb
cmpl $0x3d, %edx
je 0xb5f3
cmpl $0x3e, %edx
jne 0xb58d
cmpl %ecx, (%rax)
jle 0xb5f7
jmp 0xb5fb
cmpl $0x0, (%rax)
jne 0xb5fb
jmp 0xb5f7
cmpl %ecx, (%rax)
jl 0xb5f7
jmp 0xb5fb
cmpl %ecx, (%rax)
je 0xb5fb
movq 0x30(%rdi), %r15
movl $0x1, %ebp
testq %r15, %r15
je 0xb61f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%r15)
cmpl $0x1, %eax
jne 0xb61d
movq 0x20(%r15), %r15
jmp 0xb600
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl %ecx, (%rax)
je 0xb5f7
jmp 0xb5fb
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: execute_while_statement
static enum result execute_while_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct environment *env = vars->func->env;
	struct variable condition = { 0 };
	struct statement *stmt;
	enum result ret;
	while( 1 ) {
		if( this->source->evaluate( this->source, vars, &condition ) ) {
			if( condition.string_value ) {
				dispose_variable( &condition );
			} else if( condition.number_value ) {
				condition.number_value = 0;
			} else {
				return OKAY;
			}
		} else {
			return EXCEPTION;
		}
		stmt = ( ( struct block_statement * ) this )->if_block;
		while( stmt && ( ret = stmt->execute( stmt, vars, result ) ) == OKAY ) {
			stmt = stmt->next;
		}
		if( stmt ) {
			if( ret == RETURN ) {
				return RETURN;
			} else if( ret == BREAK ) {
				return OKAY;
			} else if( ret == EXCEPTION ) {
				return EXCEPTION;
			}
		}
		if( env->interrupted ) {
			return throw_interrupted( vars, this->source );
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq 0x18(%rsi), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %r13
movaps %xmm0, (%r13)
xorl %ebx, %ebx
movq 0x8(%r12), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq *0x18(%rdi)
testl %eax, %eax
je 0xb6f9
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb69a
movl $0x0, (%rsp)
callq 0x394d
movq $0x0, 0x8(%rsp)
jmp 0xb6a7
cmpl $0x0, (%rsp)
je 0xb6f4
movl $0x0, (%rsp)
movq 0x28(%r12), %rbp
testq %rbp, %rbp
je 0xb6d6
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x10(%rbp)
cmpl $0x1, %eax
jne 0xb6c8
movq 0x20(%rbp), %rbp
jmp 0xb6ac
testl %eax, %eax
je 0xb6f0
cmpl $0x2, %eax
je 0xb6f0
cmpl $0x3, %eax
je 0xb6f4
movq 0x10(%rsp), %rax
cmpb $0x0, 0x18(%rax)
je 0xb663
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x4320
jmp 0xb6f9
movl %eax, %ebx
jmp 0xb6f9
movl $0x1, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: execute_call_statement
static enum result execute_call_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct variable var = { 0, NULL };
	enum result ret = this->source->evaluate( this->source, vars, &var );
	if( ret ) {
		dispose_temporary( &var );
	}
	return ret;
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x20(%rsp)
movq 0x8(%rdi), %rax
movzbl (%rax), %eax
testl %eax, %eax
je 0xbb09
cmpl $0x63, %eax
je 0xbb09
cmpl $0x43, %eax
jne 0xbb71
movq 0x20(%rbx), %rbx
movq 0x8(%rbx), %rbp
cmpb $0x28, (%rbp)
jne 0xbb45
leaq -0xb3d(%rip), %r8       # 0xafe1
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
movq %r14, %r9
callq 0x971c
cmpb $0x0, (%r14)
jne 0xbbbd
movq 0x20(%rbx), %rbx
movq 0x8(%rbx), %rbp
jmp 0xbb4b
cmpb $0x0, (%r14)
jne 0xbbbd
movq 0x48(%r13), %rdi
leaq 0x6500(%rip), %rdx      # 0x12056
movq %rbp, %rsi
callq 0x5d92
testq %rax, %rax
je 0xbbcf
movl (%rax), %eax
movl %eax, (%r15)
leaq 0x79(%rip), %rax        # 0xbbe8
jmp 0xbb78
leaq 0x18e(%rip), %rax       # 0xbd06
movq %rax, 0x10(%r15)
cmpb $0x0, (%r14)
jne 0xbbbd
movq 0x20(%rbx), %rbx
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0xbbb9
movq 0x40(%r13), %rdi
subq $-0x80, %rdi
movq %rsp, %rbp
movq %r13, %rdx
movq %r12, %rcx
movq %rbp, %r8
movq %r14, %r9
callq 0x6e94
movq 0x20(%rbp), %rax
movq %rax, 0x30(%r15)
cmpb $0x0, (%r14)
jne 0xbbbd
movq 0x20(%rbx), %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x28(%rbx), %ecx
leaq 0x7253(%rip), %rsi      # 0x12e2c
movq %r14, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x3200
jmp 0xbb7c
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movslq (%rdi), %rbx
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x10(%rsi), %rax
movq %rbx, %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x18(%rsi), %rax
movq %rax, 0x18(%rsp)
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rdi), %r13
movl $0x1, %eax
testq %r13, %r13
je 0xbccf
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq %rsp, %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq *0x10(%r13)
cmpl $0x1, %eax
jne 0xbc68
movq 0x20(%r13), %r13
testq %r13, %r13
jne 0xbc46
movl $0x1, %eax
jmp 0xbccf
testl %eax, %eax
jne 0xbccf
movq 0x18(%r14), %rax
movq 0x48(%rax), %rax
testl %ebx, %ebx
jle 0xbc85
incl %ebx
movq 0x18(%rax), %rax
decl %ebx
cmpl $0x1, %ebx
ja 0xbc7a
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xbcbd
movb 0x14(%rcx), %dl
cmpb $0xa, %dl
je 0xbcc4
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xbcde
cmpb $0x2, %dl
jne 0xbcc4
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
je 0xbcc4
cmpq %rax, %rcx
je 0xbcde
movq 0x30(%rcx), %rcx
jmp 0xbcad
cmpq $0x0, 0x10(%rax)
je 0xbcde
movq 0x8(%r14), %rsi
callq 0x3a65
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%r12), %r12
testq %r12, %r12
je 0xbc61
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x10(%r12)
cmpl $0x1, %eax
jne 0xbccf
movq 0x20(%r12), %r12
jmp 0xbce3
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: execute_switch_statement
static enum result execute_switch_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	int matched = 0;
	struct expression *case_expr;
	struct variable switch_value = { 0, NULL }, case_value = { 0, NULL };
	struct statement *cases = ( ( struct block_statement * ) this )->if_block;
	struct statement *deflt = ( ( struct block_statement * ) this )->else_block;
	enum result ret = this->source->evaluate( this->source, vars, &switch_value );
	if( ret ) {
		while( cases && ret && !matched ) {
			case_expr = cases->source;
			while( case_expr && ret && !matched ) {
				ret = case_expr->evaluate( case_expr, vars, &case_value );
				if( ret ) {
					matched = compare_variables( &switch_value, &case_value ) == 0;
					dispose_variable( &case_value );
					if( matched ) {
						ret = cases->execute( cases, vars, result );
					}
				}
				case_expr = case_expr->next;
			}
			cases = cases->next;
		}
		if( ret && !matched && deflt ) {
			ret = deflt->execute( deflt, vars, result );
		}
		dispose_temporary( &switch_value );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rsp)
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %r12
movq 0x30(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, %rdi
callq *0x18(%rax)
testl %eax, %eax
je 0xc073
movl %eax, %ebp
testq %r12, %r12
je 0xc077
movq %rbx, (%rsp)
movq 0x8(%r12), %rbx
testq %rbx, %rbx
je 0xc061
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x10(%rsp), %rdx
callq *0x18(%rbx)
movl %eax, %ebp
testl %eax, %eax
je 0xc07b
movl 0x20(%rsp), %edi
movq 0x28(%rsp), %rsi
movl 0x10(%rsp), %edx
movq 0x18(%rsp), %r15
movq %r15, %rcx
callq 0xc2f5
movl %eax, %r13d
movl $0x0, 0x10(%rsp)
testq %r15, %r15
je 0xc056
movq %r15, %rdi
callq 0x394d
movq $0x0, 0x18(%rsp)
testl %r13d, %r13d
je 0xc083
movq 0x10(%rbx), %rbx
jmp 0xc002
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0xbffd
xorl %ecx, %ecx
movq (%rsp), %rbx
jmp 0xc0a3
xorl %ebp, %ebp
jmp 0xc0cc
xorl %ecx, %ecx
jmp 0xc0a3
xorl %eax, %eax
movq (%rsp), %rbx
jmp 0xc095
movq %r12, %rdi
movq %r14, %rsi
movq (%rsp), %rbx
movq %rbx, %rdx
callq *0x10(%r12)
testl %ebp, %ebp
setne %dl
testl %eax, %eax
sete %cl
orb %dl, %cl
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
sete %al
orb %cl, %al
jne 0xc0bd
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rdi)
movl %eax, %ebp
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xc0cc
callq 0x394d
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq