LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_tuple_element
static struct element* new_tuple_element( struct string *string_value, number number_value,
	struct environment *env, int max_depth, char *message ) {
	struct element *elem = new_element( 4 ), *child = NULL;
	if( elem ) {
		strcpy( elem->str.string, "$tup" );
		elem->next = new_element( 2 );
		if( elem->next ) {
			strcpy( elem->next->str.string, "()" );
			child = value_to_element( 0, string_value, env, max_depth - 1, message );
			if( child ) {
				elem->next->child = child;
				while( child->next ) {
					child = child->next;
				}
				child->next = new_number_element( number_value );
				child = child->next;
			}
		}
		if( child == NULL ) {
			unref_string( &elem->str );
			elem = NULL;
		}
	}
	return elem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl $0x4, %edi
callq 0x3780
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x14083
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x841e(%rip), %rsi      # 0x1c3d8
callq 0x3070
movl $0x2, %edi
callq 0x3780
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x14069
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x85fe(%rip), %rsi      # 0x1c5f4
callq 0x3070
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movq -0x28(%rbp), %r8
xorl %edi, %edi
callq 0x13d80
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x14067
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x14048
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1402f
movl -0xc(%rbp), %edi
callq 0x14480
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x14069
cmpq $0x0, -0x38(%rbp)
jne 0x14081
movq -0x30(%rbp), %rdi
callq 0x3c20
movq $0x0, -0x30(%rbp)
jmp 0x14083
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_string_element
static struct element* new_string_element( struct string *value ) {
	struct element *elem = NULL;
	int length = write_byte_string( value->string, value->length, NULL );
	if( length > 0 ) {
		elem = new_element( length );
		if( elem ) {
			write_byte_string( value->string, value->length, elem->str.string );
		}
	}
	return elem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x4500
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x140f6
movl -0x14(%rbp), %edi
callq 0x3780
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x140f4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x4500
jmp 0x140f6
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_literal_element
static struct element* new_literal_element( struct element *child ) {
	struct element *elem = new_element( 1 );
	if( elem ) {
		elem->str.string[ 0 ] = '$';
		elem->next = new_element( 2 );
		if( elem->next ) {
			strcpy( elem->next->str.string, "{}" );
			child->str.reference_count++;
			elem->next->child = child;
		} else {
			unref_string( &elem->str );
			elem = NULL;
		}
	}
	return elem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
callq 0x3780
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x14197
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x24, (%rax)
movl $0x2, %edi
callq 0x3780
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x14184
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x7dd3(%rip), %rsi      # 0x1bf32
callq 0x3070
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x14195
movq -0x10(%rbp), %rdi
callq 0x3c20
movq $0x0, -0x10(%rbp)
jmp 0x14197
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/towntalk.c
// Function: new_number_element
static struct element* new_number_element( number value ) {
	char chars[ 32 ];
	struct element *elem;
#if defined( FLOATING_POINT )
	sprintf( chars, "%.16g", value );
#else
	sprintf( chars, "%d", value );
#endif
	elem = new_element( strlen( chars ) );
	if( elem ) {
		strcpy( elem->str.string, chars );
	}
	return elem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
movl -0x4(%rbp), %edx
leaq 0x7e17(%rip), %rsi      # 0x1c2b0
movb $0x0, %al
callq 0x31f0
leaq -0x30(%rbp), %rdi
callq 0x30c0
movl %eax, %edi
callq 0x3780
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x144cc
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3070
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/optimizer.c
// Function: optimize_statements
struct statement* optimize_statements( struct function *func, struct statement *prev, char *message ) {
	struct statement *stmt = prev, *next = stmt->next;
	while( next ) {
		if( next->execute == execute_local_assignment ) {
			next = optimize_local_assignment( next, prev, message );
		} else if( next->execute == execute_array_assignment ) {
			next = optimize_array_assignment( next, prev, message );
		} else if( next->execute == execute_increment_statement ) {
			next = optimize_increment( next, prev, INC_LOCAL, message );
		} else if( next->execute == execute_decrement_statement ) {
			next = optimize_increment( next, prev, DEC_LOCAL, message );
		} else if( next->execute == execute_return_statement ) {
			next = optimize_return( next, prev, message );
		}
		if( message[ 0 ] ) {
			return prev;
		}
		prev = next;
		next = next->next;
	}
#if defined( PRINT_INSNS )
	while( stmt ) {
		if( stmt->execute == execute_arithmetic_statement ) {
			print_insns( func, ( struct arithmetic_statement * ) stmt, stmt->source->line );
		}
		stmt = stmt->next;
	}
#endif
	return prev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1461d
movq -0x30(%rbp), %rax
leaq -0xf78e(%rip), %rcx     # 0x4d90
cmpq %rcx, 0x10(%rax)
jne 0x1453e
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x14630
movq %rax, -0x30(%rbp)
jmp 0x145f1
movq -0x30(%rbp), %rax
leaq -0xeeb9(%rip), %rcx     # 0x5690
cmpq %rcx, 0x10(%rax)
jne 0x14569
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x14740
movq %rax, -0x30(%rbp)
jmp 0x145ef
movq -0x30(%rbp), %rax
leaq -0xecc4(%rip), %rcx     # 0x58b0
cmpq %rcx, 0x10(%rax)
jne 0x14596
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x6, %edx
callq 0x148b0
movq %rax, -0x30(%rbp)
jmp 0x145ed
movq -0x30(%rbp), %rax
leaq -0xec71(%rip), %rcx     # 0x5930
cmpq %rcx, 0x10(%rax)
jne 0x145c3
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x8, %edx
callq 0x148b0
movq %rax, -0x30(%rbp)
jmp 0x145eb
movq -0x30(%rbp), %rax
leaq -0xf7ae(%rip), %rcx     # 0x4e20
cmpq %rcx, 0x10(%rax)
jne 0x145e9
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x14960
movq %rax, -0x30(%rbp)
jmp 0x145eb
jmp 0x145ed
jmp 0x145ef
jmp 0x145f1
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x14604
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14625
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x14508
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/optimizer.c
// Function: optimize_local_assignment
static struct statement* optimize_local_assignment( struct statement *stmt, struct statement *prev, char *message ) {
	struct instruction *insn;
	struct expression *expr = stmt->source;
	int local = stmt->local, oper, dest = POP_LOCAL;
	struct arithmetic_statement *arith = add_arithmetic_statement( stmt, prev, message );
	if( arith ) {
		stmt = &arith->stmt;
		if( compile_arithmetic_expression( arith, expr, 0, message ) ) {
			insn = &arith->insns.list[ arith->insns.count - 1 ];
			oper = insn->oper;
			if( oper == PUSH_EXPR ) {
				insn->oper = ASSIGN_EXPR;
				insn->local = local;
			} else {
				if( oper == PUSH_LOCAL || oper == PUSH_GLOBAL || oper == PUSH_ARRAY ) {
					dest = STORE_LOCAL;
					insn->oper++;
				}
				add_instruction( &arith->insns, dest, local, expr, message );
			}
		}
	}
	return stmt;
}

// 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 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x11, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14a00
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x1472d
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %edx, %edx
callq 0x14b60
cmpq $0x0, %rax
je 0x1472b
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x40(%rbp), %rcx
movl 0x34(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0xb, -0x30(%rbp)
jne 0x146ea
movq -0x20(%rbp), %rax
movl $0xa, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x14729
cmpl $0x2, -0x30(%rbp)
je 0x146fc
cmpl $0x4, -0x30(%rbp)
je 0x146fc
cmpl $0xd, -0x30(%rbp)
jne 0x1470e
movl $0x12, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movl -0x34(%rbp), %esi
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x14f70
jmp 0x1472b
jmp 0x1472d
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/optimizer.c
// Function: optimize_array_assignment
static struct statement* optimize_array_assignment( struct statement *stmt, struct statement *prev, char *message ) {
	struct expression *src = stmt->source, *arr = src->next, *idx = arr->next;
	struct arithmetic_statement *arith;
	int *oper, dest = POP_ARRAY;
	if( arr->evaluate == evaluate_local ) {
		arith = add_arithmetic_statement( stmt, prev, message );
		if( arith ) {
			stmt = &arith->stmt;
			if( compile_arithmetic_expression( arith, idx, 0, message )
			&& add_instruction( &arith->insns, CHECK_ARRAY, arr->index, idx, message )
			&& compile_arithmetic_expression( arith, src, 1, message ) ) {
				oper = &arith->insns.list[ arith->insns.count - 1 ].oper;
				if( *oper == PUSH_LOCAL || *oper == PUSH_GLOBAL || *oper == PUSH_EXPR || *oper == PUSH_ARRAY ) {
					dest = STORE_ARRAY;
					(*oper)++;
				}
				add_instruction( &arith->insns, dest, arr->index, arr, message );
			}
		}
	}
	return stmt;
}

// 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)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x14, -0x44(%rbp)
movq -0x28(%rbp), %rax
leaq -0xfbca(%rip), %rcx     # 0x4bc0
cmpq %rcx, 0x18(%rax)
jne 0x14899
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14a00
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x14897
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %edx, %edx
callq 0x14b60
cmpq $0x0, %rax
je 0x14895
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x13, %esi
callq 0x14f70
cmpq $0x0, %rax
je 0x14895
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x14b60
cmpq $0x0, %rax
je 0x14895
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x38(%rbp), %rcx
movl 0x34(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x2, (%rax)
je 0x14864
movq -0x40(%rbp), %rax
cmpl $0x4, (%rax)
je 0x14864
movq -0x40(%rbp), %rax
cmpl $0xb, (%rax)
je 0x14864
movq -0x40(%rbp), %rax
cmpl $0xd, (%rax)
jne 0x14876
movl $0x15, -0x44(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movl -0x44(%rbp), %esi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x14f70
jmp 0x14897
jmp 0x14899
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/optimizer.c
// Function: optimize_increment
static struct statement* optimize_increment( struct statement *stmt, struct statement *prev, enum arithmetic_op oper, char *message ) {
	if( prev->execute == execute_arithmetic_statement && add_instruction( &( ( struct arithmetic_statement * ) prev )->insns, oper, stmt->local, stmt->source, message ) ) {
		stmt->source->next = prev->source;
		prev->source = stmt->source;
		prev->next = stmt->next;
		free( stmt );
		return prev;
	}
	return stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
leaq 0x7be(%rip), %rcx       # 0x15090
cmpq %rcx, 0x10(%rax)
jne 0x14947
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x14f70
cmpq $0x0, %rax
je 0x14947
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x3030
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1494f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/optimizer.c
// Function: optimize_return
static struct statement* optimize_return( struct statement *stmt, struct statement *prev, char *message ) {
	struct arithmetic_statement *arith;
	struct expression *expr = stmt->source;
	if( expr->evaluate == evaluate_arithmetic_expression ) {
		arith = add_arithmetic_statement( stmt, prev, message );
		if( arith ) {
			stmt = &arith->stmt;
			if( compile_arithmetic_expression( arith, expr, 0, message ) ) {
				add_instruction( &arith->insns, POP_RETURN, 0, expr, message );
			}
		}
	}
	return stmt;
}

// 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), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
leaq -0xee4b(%rip), %rcx     # 0x5b40
cmpq %rcx, 0x18(%rax)
jne 0x149ee
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14a00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x149ec
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %edx, %edx
callq 0x14b60
cmpq $0x0, %rax
je 0x149ea
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x16, %esi
xorl %edx, %edx
callq 0x14f70
jmp 0x149ec
jmp 0x149ee
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/optimizer.c
// Function: add_arithmetic_statement
static struct arithmetic_statement* add_arithmetic_statement( struct statement *src, struct statement *prev, char *message ) {
	struct expression *expr;
	struct arithmetic_statement *arith;
	if( prev->execute == execute_arithmetic_statement ) {
		arith = ( struct arithmetic_statement * ) prev;
		expr = src->source;
		while( expr->next ) {
			expr = expr->next;
		}
		expr->next = arith->stmt.source;
		arith->stmt.source = src->source;
		src->source = NULL;
		prev->next = src->next;
	} else {
		arith = calloc( 1, sizeof( struct arithmetic_statement ) );
		if( arith ) {
			arith->stmt.local = src->local;
			arith->stmt.source = src->source;
			src->source = NULL;
			arith->stmt.execute = execute_arithmetic_statement;
			arith->stmt.dispose = dispose_arithmetic_statement;
			arith->stmt.next = src->next;
			prev->next = &arith->stmt;
		} else {
			strcpy( message, OUT_OF_MEMORY );
			return NULL;
		}
	}
	src->next = NULL;
	dispose_statements( src );
	return arith;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
leaq 0x671(%rip), %rcx       # 0x15090
cmpq %rcx, 0x10(%rax)
jne 0x14a93
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x14a52
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x14a39
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x14b30
movl $0x1, %edi
movl $0x38, %esi
callq 0x3120
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x14b11
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
leaq 0x5b0(%rip), %rcx       # 0x15090
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
leaq 0x1a41(%rip), %rcx      # 0x16530
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x14b2e
movq -0x20(%rbp), %rdi
leaq 0xc644(%rip), %rax      # 0x21160
movq (%rax), %rsi
callq 0x3070
movq $0x0, -0x8(%rbp)
jmp 0x14b4d
jmp 0x14b30
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x3e00
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/optimizer.c
// Function: add_instruction
static struct instruction* add_instruction( struct instructions *insns,
	enum arithmetic_op oper, int local, struct expression *expr, char *message ) {
	struct instruction *list;
	int capacity = insns->capacity;
	if( capacity <= insns->count ) {
		capacity = ( capacity << 1 ) + 4;
		list = calloc( capacity + 1, sizeof( struct instruction ) );
		if( list ) {
			if( insns->list ) {
				memcpy( list, insns->list, insns->count * sizeof( struct instruction ) );
				free( insns->list );
			}
			insns->list = list;
			insns->capacity = capacity;
		} else {
			strcpy( message, OUT_OF_MEMORY );
			return NULL;
		}
	}
	list = &insns->list[ insns->count++ ];
	list->oper = oper;
	list->local = local;
	list->expr = expr;
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x15035
movl -0x34(%rbp), %eax
shll %eax
addl $0x4, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x18, %esi
callq 0x3120
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x15016
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x14fff
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0xc(%rax), %rax
imulq $0x18, %rax, %rdx
callq 0x3170
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x15033
movq -0x28(%rbp), %rdi
leaq 0xc13f(%rip), %rax      # 0x21160
movq (%rax), %rsi
callq 0x3070
movq $0x0, -0x8(%rbp)
jmp 0x15080
jmp 0x15035
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movl 0xc(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc(%rdx)
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/optimizer.c
// Function: divide
static enum result divide( number *lhs, number rhs, struct variables *vars, struct expression *src ) {
	if( rhs == 0 ) {
		return throw( vars, src, 0, "Integer division by zero." );
	}
	*lhs = ( long_int ) *lhs / ( long_int ) rhs;
	return OKAY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x16598
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
leaq 0x5147(%rip), %rcx      # 0x1b6d5
callq 0x4330
movl %eax, -0x4(%rbp)
jmp 0x165b1
movq -0x10(%rbp), %rax
movl (%rax), %eax
cltd
idivl -0x14(%rbp)
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/optimizer.c
// Function: modulo
static enum result modulo( number *lhs, number rhs, struct variables *vars, struct expression *src ) {
	if( rhs == 0 ) {
		return throw( vars, src, 0, "Modulo division by zero." );
	}
	*lhs = ( long_int ) *lhs % ( long_int ) rhs;
	return OKAY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x165f8
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
leaq 0x50ce(%rip), %rcx      # 0x1b6bc
callq 0x4330
movl %eax, -0x4(%rbp)
jmp 0x1660f
movq -0x10(%rbp), %rax
movl (%rax), %eax
cltd
idivl -0x14(%rbp)
movq -0x10(%rbp), %rax
movl %edx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/optimizer.c
// Function: get_arithmetic_op
static enum arithmetic_op get_arithmetic_op( struct expression *expr ) {
	char *chr;
	const char *OPS = "&:3+-*0/%12";
	enum arithmetic_op oper = HALT;
	if( expr->evaluate == evaluate_arithmetic_expression ) {
		chr = strchr( OPS, expr->index );
		if( chr ) {
			oper = AND_STACK + ( chr - OPS );
		}
	}
	return oper;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x60e1(%rip), %rax      # 0x1c714
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
leaq -0x10b09(%rip), %rcx    # 0x5b40
cmpq %rcx, 0x18(%rax)
jne 0x1667e
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x30d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1667c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
addq $0x17, %rax
movl %eax, -0x1c(%rbp)
jmp 0x1667e
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/worker.c
// Function: start_worker
int start_worker( struct worker *work ) {
	struct variables vars = { 0 };
	struct function_expression expr = { 0 };
	vars.exception = &work->exception;
	initialize_entry_point( &expr, work->env.entry_point );
	expr.expr.parameters = work->parameters;
	work->ret = expr.expr.evaluate( &expr.expr, &vars, &work->result );
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x30f0
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
addq $0x3e0, %rax            # imm = 0x3E0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x3b8(%rax), %rsi
leaq -0x58(%rbp), %rdi
callq 0xa600
movq -0x8(%rbp), %rax
movq 0x3f0(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
leaq -0x58(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0x3d0, %rdx            # imm = 0x3D0
leaq -0x30(%rbp), %rsi
callq *%rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x418(%rax)
movl $0x1, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/worker.c
// Function: new_worker
static struct worker* new_worker( char *message ) {
	struct worker *work = calloc( 1, sizeof( struct worker ) );
	if( work ) {
		work->custom.type = &worker_type;
		work->custom.str.string = worker_type.name;
		work->custom.str.length = strlen( worker_type.name );
		work->custom.str.reference_count = 1;
		work->custom.str.type = CUSTOM;
		if( initialize_environment( &work->env, MAX_STACK, message )
		&& add_statements( locked_statement, &work->env, message )
		&& initialize_worker( work, message ) ) {
			work->env.worker = &work->custom;
		} else {
			unref_string( &work->custom.str );
			work = NULL;
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return work;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x420, %esi            # imm = 0x420
callq 0x3120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x177ae
movq -0x10(%rbp), %rax
leaq 0xa87b(%rip), %rcx      # 0x21f80
movq %rcx, 0x18(%rax)
movq 0xa870(%rip), %rcx      # 0x21f80
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0xa861(%rip), %rdi      # 0x21f80
callq 0x30c0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x1, (%rax)
movq -0x10(%rbp), %rax
movb $0x9, 0x14(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rdx
movl $0x10000, %esi          # imm = 0x10000
callq 0xa560
cmpl $0x0, %eax
je 0x1779b
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq -0x8(%rbp), %rdx
leaq 0xa872(%rip), %rdi      # 0x21fe0
callq 0xa260
cmpl $0x0, %eax
je 0x1779b
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x16690
cmpl $0x0, %eax
je 0x1779b
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x3c0(%rax)
jmp 0x177ac
movq -0x10(%rbp), %rdi
callq 0x3c20
movq $0x0, -0x10(%rbp)
jmp 0x177c1
movq -0x8(%rbp), %rdi
leaq 0x99a7(%rip), %rax      # 0x21160
movq (%rax), %rsi
callq 0x3070
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/worker.c
// Function: dispose_worker
static void dispose_worker( struct string *str ) {
	int idx, len = 0;
	struct worker *work = ( struct worker * ) str;
	await_worker( work, 1 );
	if( work->env.entry_point ) {
		len = work->env.entry_point->num_parameters;
	}
	dispose_temporary( &work->result );
	dispose_temporary( &work->exception );
	dispose_environment( &work->env );
	for( idx = 0; idx < len; idx++ ) {
		dispose_temporary( &work->args[ idx ] );
	}
	free( work->args );
	free( work->strings );
	free( work->parameters );
	free( work );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x16760
movq -0x18(%rbp), %rax
cmpq $0x0, 0x3b8(%rax)
je 0x17818
movq -0x18(%rbp), %rax
movq 0x3b8(%rax), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
addq $0x3d0, %rdi            # imm = 0x3D0
callq 0x3ce0
movq -0x18(%rbp), %rdi
addq $0x3e0, %rdi            # imm = 0x3E0
callq 0x3ce0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x40e0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1787a
movq -0x18(%rbp), %rax
movq 0x3c8(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3ce0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1784c
movq -0x18(%rbp), %rax
movq 0x3c8(%rax), %rdi
callq 0x3030
movq -0x18(%rbp), %rax
movq 0x400(%rax), %rdi
callq 0x3030
movq -0x18(%rbp), %rax
movq 0x3f0(%rax), %rdi
callq 0x3030
movq -0x18(%rbp), %rdi
callq 0x3030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/ttasm.c
// Function: parse_asm_statement
struct element* parse_asm_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct element *next = elem->next;
	struct label labels = { 0 };
	struct asm_statement *stmt;
	int count;
	if( next->child ) {
		count = parse_instructions( next->child, func, NULL, &labels, message );
		if( count > 0 ) {
			stmt = calloc( 1, sizeof( struct asm_statement ) + sizeof( struct instruction ) * count );
			if( stmt ) {
				prev->next = &stmt->stmt;
				stmt->stmt.source = calloc( 1, sizeof( struct expression ) );
			}
			if( stmt && stmt->stmt.source ) {
				stmt->stmt.source->line = elem->line;
				stmt->instructions = ( struct instruction * ) &stmt[ 1 ];
				parse_instructions( next->child, func, stmt->instructions, &labels, message );
				stmt->stmt.execute = execute_asm_statement;
				next = next->next;
			} else {
				strcpy( message, OUT_OF_MEMORY );
			}
		}
		dispose_labels( labels.next );
	} else {
		sprintf( message, "Empty asm statement on line %d.", next->line );
	}
	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 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x30f0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x17a09
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
leaq -0x48(%rbp), %rcx
callq 0x17a30
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jle 0x179fe
movslq -0x54(%rbp), %rsi
shlq $0x3, %rsi
addq $0x30, %rsi
movl $0x1, %edi
callq 0x3120
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x17978
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, %edi
movl $0x20, %esi
callq 0x3120
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x50(%rbp)
je 0x179e9
movq -0x50(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x179e9
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movq -0x50(%rbp), %rcx
addq $0x30, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x50(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x28(%rbp), %r8
leaq -0x48(%rbp), %rcx
callq 0x17a30
movq -0x50(%rbp), %rax
leaq 0x2e9(%rip), %rcx       # 0x17cc0
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x179fc
movq -0x28(%rbp), %rdi
leaq 0x976c(%rip), %rax      # 0x21160
movq (%rax), %rsi
callq 0x3070
jmp 0x179fe
movq -0x38(%rbp), %rdi
callq 0x196d0
jmp 0x17a22
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x4ec5(%rip), %rsi      # 0x1c8e0
movb $0x0, %al
callq 0x31f0
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/ttasm.c
// Function: dispose_labels
static void dispose_labels( struct label *labels ) {
	struct label *next;
	while( labels ) {
		next = labels->next;
		free( labels );
		labels = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x19702
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x196dc
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/ttasm.c
// Function: new_label
static struct label* new_label( struct element *elem, int idx, char *message ) {
	struct label *label = NULL;
	int len = elem->str.length - 1;
	if( validate_label( elem->str.string, len ) ) {
		label = malloc( sizeof( struct label ) + ( len + 1 ) * sizeof( char ) );
		if( label ) {
			label->idx = idx;
			label->name = ( char * ) &label[ 1 ];
			strncpy( label->name, elem->str.string, len );
			label->name[ len ] = 0;
			label->next = NULL;
		} else {
			strcpy( message, OUT_OF_MEMORY );
		}
	} else {
		sprintf( message, "Invalid label '%.64s' on line %d.", elem->str.string, elem->line );
	}
	return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x24(%rbp), %esi
callq 0x19dc0
cmpl $0x0, %eax
je 0x197d7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
addq $0x18, %rdi
callq 0x31a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x197c2
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x24(%rbp), %rdx
callq 0x3050
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x197d5
movq -0x18(%rbp), %rdi
leaq 0x7993(%rip), %rax      # 0x21160
movq (%rax), %rsi
callq 0x3070
jmp 0x197f8
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x3168(%rip), %rsi      # 0x1c959
movb $0x0, %al
callq 0x31f0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/ttasm.c
// Function: parse_let
static struct element* parse_let( struct element *elem, struct function *func, struct instruction *output, char *message ) {
	char *src = elem->next->str.string;
	char *dest = elem->next->next->next->str.string;
	char *param = elem->next->next->next->next->str.string;
	if( src[ 0 ] == '[' ) {
		return parse_leta( elem, func, output, message );
	} else if( dest[ 0 ] == '[' ) {
		return parse_letv_a( elem, func, output, message );
	} else if( param[ 0 ] == '(' ) {
		return parse_letv_opr( elem, func, output, message );
	} else if( dest[ 0 ] == '-' || ( dest[ 0 ] >= '0' && dest[ 0 ] <= '9' ) ) {
		return parse_letv_i( elem, func, output, message );
	} else {
		return parse_letv_v( elem, func, output, message );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x19896
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x19f00
movq %rax, -0x8(%rbp)
jmp 0x1993c
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x198bd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1a230
movq %rax, -0x8(%rbp)
jmp 0x1993c
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x198e4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1a460
movq %rax, -0x8(%rbp)
jmp 0x1993c
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x19908
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x19923
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x19923
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1a7d0
movq %rax, -0x8(%rbp)
jmp 0x1993c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1a8a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/ttasm.c
// Function: validate_let
static struct element* validate_let( struct element *elem, char *message ) {
	if( elem->next && alphachar( elem->next->str.string[ 0 ], "[" ) ) {
		elem = elem->next;
		if( elem->next && strcmp( "=", elem->next->str.string ) == 0 ) {
			elem = elem->next;
			if( elem->next && elem->next->str.string[ 0 ] != ';' ) {
				elem = elem->next;
				if( elem->next && strcmp( "()", elem->next->str.string ) == 0 ) {
					elem = elem->next;
				}
			} else {
				sprintf( message, "Invalid source after '=' on line %d.", elem->line );
				elem = NULL;
			}
		} else {
			sprintf( message, "Expected '=' after destination on line %d.", elem->line );
			elem = NULL;
		}
	} else {
		sprintf( message, "Invalid destination after 'let' on line %d.", elem->line );
		elem = NULL;
	}
	return elem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x19a82
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
leaq 0x1fbf(%rip), %rsi      # 0x1b941
movsbl (%rax), %edi
callq 0x19e90
cmpl $0x0, %eax
je 0x19a82
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x19a5f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x29ca(%rip), %rdi      # 0x1c38b
callq 0x3130
cmpl $0x0, %eax
jne 0x19a5f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x19a3c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
je 0x19a3c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x19a3a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x2bd0(%rip), %rdi      # 0x1c5f4
callq 0x3130
cmpl $0x0, %eax
jne 0x19a3a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x19a5d
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x2fec(%rip), %rsi      # 0x1ca3a
movb $0x0, %al
callq 0x31f0
movq $0x0, -0x8(%rbp)
jmp 0x19a80
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x2fee(%rip), %rsi      # 0x1ca5f
movb $0x0, %al
callq 0x31f0
movq $0x0, -0x8(%rbp)
jmp 0x19aa3
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x2ff6(%rip), %rsi      # 0x1ca8a
movb $0x0, %al
callq 0x31f0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/ttasm.c
// Function: validate_jump
static struct element* validate_jump( struct element *elem, char *message ) {
	if( elem->next ) {
		elem = elem->next;
		if( elem->next && strcmp( "()", elem->next->str.string ) == 0 ) {
			elem = elem->next;
			if( elem->child && elem->child->next && elem->child->next->next == NULL ) {
				if( elem->next ) {
					elem = elem->next;
					if( !validate_label( elem->str.string, elem->str.length ) ) {
						sprintf( message, "Invalid jump label '%.64s' on line %d.", elem->str.string, elem->line );
						elem = NULL;
					}
				} else {
					sprintf( message, "Expected label after jump condition on line %d.", elem->line );
					elem = NULL;
				}
			} else {
				sprintf( message, "Invalid jump condition on line %d.", elem->line );
				elem = NULL;
			}
		} else {
			sprintf( message, "Expected '(' after jump condition on line %d.", elem->line );
			elem = NULL;
		}
	} else {
		sprintf( message, "Expected jump condition on line %d.", elem->line );
		elem = NULL;
	}
	return elem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x19d90
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x19d6d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x2977(%rip), %rdi      # 0x1c5f4
callq 0x3130
cmpl $0x0, %eax
jne 0x19d6d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x19d4a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x19d4a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x19d4a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x19d27
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x19dc0
cmpl $0x0, %eax
jne 0x19d25
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x2df5(%rip), %rsi      # 0x1cb0b
movb $0x0, %al
callq 0x31f0
movq $0x0, -0x8(%rbp)
jmp 0x19d48
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x2df9(%rip), %rsi      # 0x1cb32
movb $0x0, %al
callq 0x31f0
movq $0x0, -0x8(%rbp)
jmp 0x19d6b
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x2e06(%rip), %rsi      # 0x1cb62
movb $0x0, %al
callq 0x31f0
movq $0x0, -0x8(%rbp)
jmp 0x19d8e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x2e06(%rip), %rsi      # 0x1cb85
movb $0x0, %al
callq 0x31f0
movq $0x0, -0x8(%rbp)
jmp 0x19db1
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x2e11(%rip), %rsi      # 0x1cbb3
movb $0x0, %al
callq 0x31f0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/ttasm.c
// Function: validate_label
static int validate_label( char *name, int len ) {
	int chr = name[ 0 ], idx = 1, result = 1;
	if( alphachar( chr, "" ) ) {
		chr = name[ idx++ ];
		while( chr && idx <= len ) {
			if( alphachar( chr, "_0123456789" ) ) {
				chr = name[ idx++ ];
			} else {
				result = chr = 0;
			}
		}
	} else {
		result = 0;
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x10(%rbp), %eax
leaq 0x1265(%rip), %rsi      # 0x1b056
movsbl %al, %edi
callq 0x19e90
cmpl $0x0, %eax
je 0x19e7b
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x19e2e
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x19e37
jmp 0x19e79
movl -0x10(%rbp), %eax
leaq 0x2b3a(%rip), %rsi      # 0x1c97b
movsbl %al, %edi
callq 0x19e90
cmpl $0x0, %eax
je 0x19e69
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x10(%rbp)
jmp 0x19e77
movl $0x0, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
jmp 0x19e17
jmp 0x19e82
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/ttasm.c
// Function: parse_letv_i
static struct element* parse_letv_i( struct element *elem, struct function *func, struct instruction *output, char *message ) {
	/*
		opcode      x y z imm : mnemonic
		letv_i      x 0 0 imm : let x = imm;
	*/
	struct element *next = elem->next;
	int idx = get_local_variable( func, next, "", message );
	if( idx >= 0 ) {
		output->x = idx;
		next = next->next->next;
		if( parse_number( next->str.string, &output->imm ) ) {
			output->opcode = LETV_I;
		} else {
			sprintf( message, "Invalid immediate '%.64s' at line %d.", next->str.string, next->line );
			next = NULL;
		}
	} else {
		next = NULL;
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x84f(%rip), %rdx       # 0x1b056
callq 0x1a960
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x1a87f
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
callq 0x5d90
cmpl $0x0, %eax
je 0x1a854
movq -0x18(%rbp), %rax
movb $0x7, (%rax)
jmp 0x1a87d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x2119(%rip), %rsi      # 0x1c987
movb $0x0, %al
callq 0x31f0
movq $0x0, -0x28(%rbp)
jmp 0x1a887
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martincameron[P]towntalk/ttasm.c
// Function: parse_letv_v
static struct element* parse_letv_v( struct element *elem, struct function *func, struct instruction *output, char *message ) {
	/*
		opcode      x y z imm : mnemonic
		letv_v      x y 0   0 : let x = y;
	*/
	struct element *next = elem->next;
	int idx = get_local_variable( func, next, "", message );
	if( idx >= 0 ) {
		output->x = idx;
		next = next->next->next;
		idx = get_local_variable( func, next, "", message );
		if( idx >= 0 ) {
			output->y = idx;
			output->opcode = LETV_V;
		} else {
			next = NULL;
		}
	} else {
		next = NULL;
	}
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x77f(%rip), %rdx       # 0x1b056
callq 0x1a960
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x1a941
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x742(%rip), %rdx       # 0x1b056
callq 0x1a960
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x1a937
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
movb $0x8, (%rax)
jmp 0x1a93f
movq $0x0, -0x28(%rbp)
jmp 0x1a949
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)