LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_quote_expression
static enum result evaluate_quote_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	int length;
	struct expression *parameter = this->parameters;
	struct variable var = { 0, NULL };
	struct string *str;
	enum result ret = evaluate_string( parameter, vars, &var );
	if( ret ) {
		length = write_byte_string( var.string_value->string, var.string_value->length, NULL );
		if( length >= 0 ) {
			str = new_string( length );
			if( str ) {
				write_byte_string( var.string_value->string, var.string_value->length, str->string );
				result->string_value = str;
			} else {
				ret = throw_out_of_memory( vars, this );
			}
		} else {
			ret = throw( vars, this, 0, "String too large." );
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %rdi
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
callq 0x442e
testl %eax, %eax
je 0xddb7
movl %eax, %ebp
movq %rbx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %r13
movl 0x10(%rax), %esi
xorl %r15d, %r15d
movq %r13, %rdi
movl %esi, 0xc(%rsp)
xorl %edx, %edx
callq 0x3dad
testl %eax, %eax
js 0xddbc
movl %eax, %ebx
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
leaq 0x19(%rcx), %rdi
callq 0x31b0
testq %rax, %rax
je 0xddc5
movq %rax, %r15
movq $0x0, 0x10(%rax)
movq %rax, %rdx
addq $0x18, %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x18(%r15,%rax)
movq $0x1, (%r15)
movl %ebx, 0x10(%r15)
movq %r13, %rdi
movl 0xc(%rsp), %esi
callq 0x3dad
movq 0x18(%rsp), %rax
movq %r15, 0x8(%rax)
movl %ebp, %r15d
jmp 0xdddc
xorl %r15d, %r15d
jmp 0xddeb
leaq 0x5223(%rip), %rcx      # 0x12fe6
jmp 0xddcf
movq 0xb3a4(%rip), %rcx      # 0x19170
xorl %r15d, %r15d
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3c96
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xddeb
callq 0x394d
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_unquote_expression
static enum result evaluate_unquote_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct expression *parameter = this->parameters;
	struct variable var = { 0, NULL };
	struct string *str;
	enum result ret = evaluate_string( parameter, vars, &var );
	if( ret ) {
		str = new_string_literal( var.string_value->string );
		if( str ) {
			result->string_value = str;
		} else {
			ret = throw_out_of_memory( vars, this );
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
callq 0x442e
testl %eax, %eax
je 0xde43
movl %eax, %ebx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4172
testq %rax, %rax
je 0xde47
movq %rax, 0x8(%r12)
jmp 0xde5d
xorl %ebx, %ebx
jmp 0xde6c
movq 0xb322(%rip), %rcx      # 0x19170
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3c96
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xde6c
callq 0x394d
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_interrupted_expression
static enum result evaluate_interrupted_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct environment *env = vars->func->env; 
	result->number_value = env->interrupted;
	if( env->worker == NULL ) {
		env->interrupted = 0;
	}
	return OKAY;
}

// Assembly:
movq 0x18(%rsi), %rax
movq 0x40(%rax), %rax
movsbl 0x18(%rax), %ecx
movl %ecx, (%rdx)
cmpq $0x0, 0x3a0(%rax)
jne 0xde96
movb $0x0, 0x18(%rax)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_source_expression
static enum result evaluate_source_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable var = { 0, NULL };
	enum result ret = this->parameters->evaluate( this->parameters, vars, &var );
	if( ret ) {
		if( var.string_value && var.string_value->type == FUNCTION ) {
			result->string_value = ( ( struct function * ) var.string_value )->file;
			result->string_value->reference_count++;
		} else {
			ret = throw( vars, this, 0, "Not a function reference." );
		}
		dispose_temporary( &var );
	}
	return ret;
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq %r12, %rdi
callq *0x18(%r12)
testl %eax, %eax
je 0xe1c0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xe197
cmpb $0x3, 0x14(%rax)
jne 0xe197
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x46e7
xorl %ebp, %ebp
testl %eax, %eax
je 0xe1af
movl 0xc(%rsp), %edx
testl %edx, %edx
js 0xe1d1
movq 0x18(%rsp), %rcx
cmpl 0x18(%rcx), %edx
jge 0xe1d1
addq $0x20, %rcx
incl %edx
movq (%rcx), %rsi
leaq 0x8(%rsi), %rcx
decl %edx
jne 0xe17e
movq (%rsi), %rcx
movq %rcx, 0x8(%rbx)
incq (%rcx)
movl %eax, %ebp
jmp 0xe1af
movl 0x10(%rsp), %edx
leaq 0x4fa6(%rip), %rcx      # 0x13148
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c96
xorl %ebp, %ebp
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe1c2
callq 0x394d
jmp 0xe1c2
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f55(%rip), %rcx      # 0x1312d
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c96
jmp 0xe1af
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_instanceof_expression
static enum result evaluate_instanceof_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct variable arr = { 0, NULL }, struc = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &arr );
	if( ret ) {
		ret = parameter->next->evaluate( parameter->next, vars, &struc );
		if( ret ) {
			if( struc.string_value && struc.string_value->type == STRUCT ) {
				if( is_instance( &arr, ( struct structure * ) struc.string_value, NULL, NULL ) ) {
					assign_variable( &arr, result );
				}
			} else {
				ret = throw( vars, this, struc.number_value, "Not a structure." );
			}
			dispose_temporary( &struc );
		}
		dispose_temporary( &arr );
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, (%rsp)
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq *0x18(%rbx)
testl %eax, %eax
je 0xe25d
movq 0x10(%rbx), %rdi
movq %rsp, %rdx
movq %r12, %rsi
callq *0x18(%rdi)
testl %eax, %eax
je 0xe289
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0xe261
cmpb $0x3, 0x14(%rcx)
jne 0xe261
movl %eax, %ebx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xe278
cmpb $0x2, 0x14(%rax)
jne 0xe278
movq 0x28(%rax), %rdx
testq %rdx, %rdx
je 0xe278
cmpq %rcx, %rdx
je 0xe2a8
movq 0x30(%rdx), %rdx
jmp 0xe24d
xorl %ebx, %ebx
jmp 0xe29a
movl (%rsp), %edx
leaq 0x4edd(%rip), %rcx      # 0x13148
movq %r12, %rdi
movq %r15, %rsi
callq 0x3c96
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xe28b
callq 0x394d
jmp 0xe28b
xorl %ebx, %ebx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe29a
callq 0x394d
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xe2bb
callq 0x394d
movq 0x18(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, (%r14)
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0xe278
incq (%rax)
jmp 0xe278
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_trace_expression
static enum result evaluate_trace_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	char *msg = "";
	int msg_len = 0;
	struct array *arr;
	struct variable var = { 0, NULL };
	struct expression *parameter = this->parameters;
	enum result ret = parameter->evaluate( parameter, vars, &var );
	if( ret ) {
		if( var.string_value ) {
			msg = var.string_value->string;
			msg_len = var.string_value->length;
		}
		arr = stack_trace( this, vars, msg_len, 16 );
		if( arr ) {
			memcpy( arr->str.string, msg, msg_len );
			result->number_value = var.number_value;
			result->string_value = &arr->str;
		} else {
			ret = throw_out_of_memory( vars, this );
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
testl %eax, %eax
je 0xe317
movl %eax, %ebx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xe31b
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %ebp
jmp 0xe329
xorl %ebx, %ebx
jmp 0xe381
leaq 0x3d34(%rip), %rax      # 0x12056
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x3d46
testq %rax, %rax
je 0xe35c
movq %rax, %r13
movq 0x8(%rax), %rdi
movslq %ebp, %rdx
movq 0x8(%rsp), %rsi
callq 0x3180
movl 0x10(%rsp), %eax
movl %eax, (%r14)
movq %r13, 0x8(%r14)
jmp 0xe372
movq 0xae0d(%rip), %rcx      # 0x19170
xorl %ebx, %ebx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3c96
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe381
callq 0x394d
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: evaluate_eval_expression
static enum result evaluate_eval_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	struct environment *env = vars->func->env;
	struct variable var = { 0, NULL };
	struct expression prev;
	struct element *elem;
	char msg[ 128 ] = "";
	enum result ret = evaluate_element( this->parameters, vars, &var, 0 );
	if( ret ) {
		elem = ( struct element * ) var.string_value;
		if( ( size_t ) &ret < env->stack_limit || ( elem->line < 1 && !check_element_depth( elem, env->element_depth ) ) ) {
			ret = throw_stack_overflow( vars, this );
		} else {
			prev.next = NULL;
			parse_expression( elem, vars->func, NULL, &prev, msg );
			if( msg[ 0 ] == 0 ) {
				expr_set_line( prev.next, this->line );
				ret = prev.next->evaluate( prev.next, vars, result );
			} else {
				ret = throw( vars, this, 0, msg );
			}
			dispose_expressions( prev.next );
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rsi), %rax
movq 0x40(%rax), %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq 0x8(%rdi), %rdi
xorl %ecx, %ecx
callq 0x4478
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xe4d4
leaq 0xc(%rsp), %rax
cmpq %rax, (%r12)
jbe 0xe436
leaq 0x3e47(%rip), %rcx      # 0x12263
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3c96
movl $0x0, 0xc(%rsp)
jmp 0xe4c5
movq 0x18(%rsp), %r13
cmpl $0x0, 0x28(%r13)
jg 0xe453
movl 0x8(%r12), %esi
movq %r13, %rdi
callq 0x7229
testl %eax, %eax
je 0xe415
leaq 0x20(%rsp), %rcx
movq $0x0, 0x10(%rcx)
movq 0x18(%rbx), %rsi
xorl %r12d, %r12d
leaq 0x40(%rsp), %rbp
movq %r13, %rdi
xorl %edx, %edx
movq %rbp, %r8
callq 0x4f62
cmpb $0x0, (%rbp)
je 0xe498
leaq 0x40(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3c96
movq 0x30(%rsp), %r13
jmp 0xe4b8
movq 0x30(%rsp), %r13
movl (%r15), %esi
movq %r13, %rdi
callq 0x9ccf
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x18(%r13)
movl %eax, %r12d
movl %r12d, 0xc(%rsp)
movq %r13, %rdi
callq 0x3af9
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe4d4
callq 0x394d
movl 0xc(%rsp), %eax
addq $0xc8, %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: write_element
static int write_element( struct element *elem, char *output ) {
	int size, length = 0;
	if( output ) {
		while( elem ) {
			if( elem->child ) {
				output[ length++ ] = elem->str.string[ 0 ];
				length += write_element( elem->child, &output[ length ] );
				output[ length++ ] = elem->str.string[ 1 ];
			} else {
				memcpy( &output[ length ], elem->str.string, sizeof( char ) * elem->str.length );
				length += elem->str.length;
				output[ length++ ] = '\n';
			}
			elem = elem->next;
		}
	} else {
		while( elem && length >= 0 ) {
			if( elem->child ) {
				size = write_element( elem->child, NULL );
				if( size >= 0 && MAX_INTEGER - length - 2 > size ) {
					length += size + 2;
				} else {
					length = -1;
				}
			} else {
				size = elem->str.length;
				if( MAX_INTEGER - length - 1 > size ) {
					length += size + 1;
				} else {
					length = -1;
				}
			}
			elem = elem->next;
		}
	}
	return length;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0xe562
testq %rbx, %rbx
je 0xe5c5
movq %rsi, %r14
xorl %eax, %eax
cmpq $0x0, 0x18(%rbx)
movslq %eax, %r15
je 0xe537
movq 0x8(%rbx), %rax
movb (%rax), %al
leaq (%r14,%r15), %rsi
incq %rsi
movb %al, -0x1(%rsi)
movq 0x18(%rbx), %rdi
callq 0xe4ea
addl %eax, %r15d
incl %r15d
movq 0x8(%rbx), %rax
movb 0x1(%rax), %cl
jmp 0xe54e
leaq (%r14,%r15), %rdi
movq 0x8(%rbx), %rsi
movslq 0x10(%rbx), %rdx
callq 0x3180
addl 0x10(%rbx), %r15d
movb $0xa, %cl
movslq %r15d, %rax
movb %cl, (%r14,%rax)
incl %eax
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0xe505
jmp 0xe5c7
testq %rbx, %rbx
je 0xe5c5
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xe598
xorl %esi, %esi
callq 0xe4ea
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
js 0xe5c7
movl $0x7ffffffd, %edx       # imm = 0x7FFFFFFD
subl %r14d, %edx
cmpl %ecx, %edx
jle 0xe5c7
movl $0x2, %eax
jmp 0xe5ac
movl 0x10(%rbx), %ecx
movl $0x7ffffffe, %edx       # imm = 0x7FFFFFFE
subl %r14d, %edx
movl $0x1, %eax
cmpl %ecx, %edx
jle 0xe5d2
addl %eax, %r14d
addl %ecx, %r14d
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0xe5cd
movl %r14d, %eax
testl %r14d, %r14d
jns 0xe56a
jmp 0xe5c7
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl %r14d, %eax
jmp 0xe5c7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xe5c7
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/towntalk.c
// Function: new_string_element
static struct element* new_string_element( struct string *value ) {
	struct element *elem = NULL;
	int length = write_byte_string( value->string, value->length, NULL );
	if( length > 0 ) {
		elem = new_element( length );
		if( elem ) {
			write_byte_string( value->string, value->length, elem->str.string );
		}
	}
	return elem;
}

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x464(%rip), %r12       # 0xf2c2
cmpq %r12, 0x10(%rsi)
je 0xeeab
movq %rdx, %r15
movl $0x1, %edi
movl $0x38, %esi
callq 0x3130
testq %rax, %rax
je 0xeeef
movl (%rbx), %ecx
movl %ecx, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x8(%rbx)
movq %r12, 0x10(%rax)
leaq 0xdf7(%rip), %rcx       # 0xfc91
movq %rcx, 0x18(%rax)
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq %rax, %r15
jmp 0xeed9
movq 0x8(%rbx), %rax
movq %rax, %rdx
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0xeeb2
movq 0x8(%r14), %rdx
movq %rdx, 0x10(%rcx)
movq %rax, 0x8(%r14)
movq $0x0, 0x8(%rbx)
movq 0x20(%rbx), %rax
movq %r14, %r15
movq %rax, 0x20(%r14)
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x3abb
jmp 0xef04
leaq 0xa27a(%rip), %rax      # 0x19170
movq (%rax), %rsi
movq %r15, %rdi
callq 0x3070
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/optimizer.c
// Function: add_instruction
static struct instruction* add_instruction( struct instructions *insns,
	enum arithmetic_op oper, int local, struct expression *expr, char *message ) {
	struct instruction *list;
	int capacity = insns->capacity;
	if( capacity <= insns->count ) {
		capacity = ( capacity << 1 ) + 4;
		list = calloc( capacity + 1, sizeof( struct instruction ) );
		if( list ) {
			if( insns->list ) {
				memcpy( list, insns->list, insns->count * sizeof( struct instruction ) );
				free( insns->list );
			}
			insns->list = list;
			insns->capacity = capacity;
		} else {
			strcpy( message, OUT_OF_MEMORY );
			return NULL;
		}
	}
	list = &insns->list[ insns->count++ ];
	list->oper = oper;
	list->local = local;
	list->expr = expr;
	return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %r15
movl 0x8(%rdi), %ebp
movl 0xc(%rdi), %ebx
cmpl %ebx, %ebp
jle 0xf218
movq (%r15), %r12
jmp 0xf281
movq %r8, %r13
movl %edx, 0xc(%rsp)
movq %rcx, 0x10(%rsp)
leal 0x5(,%rbp,2), %eax
movslq %eax, %rdi
movl $0x18, %esi
callq 0x3130
testq %rax, %rax
je 0xf2ac
movq %rax, %r12
leal 0x4(,%rbp,2), %ebp
movq (%r15), %r13
testq %r13, %r13
je 0xf271
movslq %ebx, %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3180
movq %r13, %rdi
callq 0x3030
movl 0xc(%r15), %ebx
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %edx
movq %r12, (%r15)
movl %ebp, 0x8(%r15)
leal 0x1(%rbx), %eax
movl %eax, 0xc(%r15)
movslq %ebx, %rax
leaq (%rax,%rax,2), %rax
leaq (%r12,%rax,8), %rax
movl %r14d, (%rax)
movl %edx, 0x4(%rax)
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9ebd(%rip), %rax      # 0x19170
movq (%rax), %rsi
movq %r13, %rdi
callq 0x3070
xorl %eax, %eax
jmp 0xf29d
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/worker.c
// Function: parse_lock_statement
struct element* parse_lock_statement( struct element *elem,
	struct function *func, struct variables *vars, struct statement *prev, char *message ) {
	struct expression expr;
	struct element *next = elem->next;
	struct statement block = { 0 }, *stmt = calloc( 1, sizeof( struct block_statement ) );
	if( stmt ) {
		stmt->dispose = dispose_block_statement;
		prev->next = stmt;
		if( next->str.string[ 0 ] == '{' ) {
			expr.next = calloc( 1, sizeof( struct value_expression ) );
			if( expr.next ) {
				expr.next->line = elem->line;
				expr.next->evaluate = evaluate_number_literal_expression;
			} else {
				strcpy( message, OUT_OF_MEMORY );
			}
		} else {
			expr.next = NULL;
			next = parse_expression( next, func, vars, &expr, message );
		}
		if( message[ 0 ] == 0 ) {
			stmt->source = expr.next;
			stmt->execute = execute_lock_statement;
			if( next->child ) {
				block.next = NULL;
				parse_keywords_indexed( func->env->statements_index, next->child, func, vars, &block, message );
				( ( struct block_statement * ) stmt )->if_block = block.next;
			}
			if( message[ 0 ] == 0 ) {
				next = next->next;
			}
		}
	} else {
		strcpy( message, OUT_OF_MEMORY );
	}
	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbp
movq 0x20(%rdi), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movl $0x1, %edi
movl $0x48, %esi
callq 0x3130
testq %rax, %rax
je 0xfdc3
movq %rax, %r13
leaq -0xba00(%rip), %rax     # 0x4387
movq %rax, 0x18(%r13)
movq %r13, 0x20(%r15)
movq 0x8(%rbx), %rax
cmpb $0x7b, (%rax)
jne 0xfdda
movl $0x1, %edi
movl $0x30, %esi
callq 0x3130
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0xfdff
movl 0x28(%rbp), %ecx
movl %ecx, (%rax)
leaq -0xc323(%rip), %rcx     # 0x3a9a
movq %rcx, 0x18(%rax)
jmp 0xfe11
leaq 0x93a6(%rip), %rax      # 0x19170
movq (%rax), %rsi
movq %r14, %rdi
callq 0x3070
jmp 0xfe6f
leaq 0x10(%rsp), %rcx
movq $0x0, 0x10(%rcx)
movq %rbx, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r14, %r8
callq 0x4f62
movq %rax, %rbx
jmp 0xfe11
leaq 0x936a(%rip), %rax      # 0x19170
movq (%rax), %rsi
movq %r14, %rdi
callq 0x3070
cmpb $0x0, (%r14)
jne 0xfe6f
movq 0x20(%rsp), %rax
movq %rax, 0x8(%r13)
leaq 0x5a(%rip), %rax        # 0xfe81
movq %rax, 0x10(%r13)
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0xfe6b
leaq 0x30(%rsp), %r15
movq $0x0, 0x20(%r15)
movq 0x40(%r12), %rdi
subq $-0x80, %rdi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x6e94
movq 0x20(%r15), %rax
movq %rax, 0x28(%r13)
cmpb $0x0, (%r14)
jne 0xfe6f
movq 0x20(%rbx), %rbx
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/worker.c
// Function: execute_lock_statement
static enum result execute_lock_statement( struct statement *this,
	struct variables *vars, struct variable *result ) {
	struct statement *stmt = ( ( struct block_statement * ) this )->if_block;
	struct worker *work = ( struct worker * ) vars->func->env->worker;
	struct variable var = { 0, NULL };
	char *locked = NULL;
	enum result ret = this->source->evaluate( this->source, vars, &var );
	if( ret ) {
		if( is_custom_instance( var.string_value, &worker_type ) ) {
			work = ( struct worker * ) var.string_value;
			locked = &work->locked;
		} else if( work ) {
			locked = &work->worker_locked;
		} else {
			ret = throw( vars, this->source, 0, "Not a worker.");
		}
		if( locked ) {
			if( locked[ 0 ] == 0 && lock_worker( work ) ) {
				locked[ 0 ] = 1;
				while( stmt ) {
					ret = stmt->execute( stmt, vars, result );
					if( ret == OKAY ) {
						stmt = stmt->next;
					} else {
						break;
					}
				}
				locked[ 0 ] = 0;
				if( unlock_worker( work ) == 0 ) {
					locked[ 0 ] = 1;
					ret = throw( vars, this->source, 0, "Unable to unlock worker.");
				}
			} else {
				ret = throw( vars, this->source, 0, "Unable to lock worker.");
			}
		}
		dispose_temporary( &var );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq 0x28(%rdi), %r15
movq 0x18(%rsi), %rax
movq 0x40(%rax), %rax
movq 0x3a0(%rax), %r13
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
callq *0x18(%rdi)
testl %eax, %eax
je 0xfee3
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0xa0c3(%rip), %rsi      # 0x19f90
callq 0x47c1
testl %eax, %eax
je 0xfee7
movl $0x3f8, %r13d           # imm = 0x3F8
addq 0x8(%rsp), %r13
jmp 0xfef3
xorl %ebp, %ebp
jmp 0xff5d
testq %r13, %r13
je 0xff34
addq $0x3f9, %r13            # imm = 0x3F9
cmpb $0x0, (%r13)
je 0xff08
movq 0x8(%r12), %rsi
leaq 0x343b(%rip), %rcx      # 0x13341
jmp 0xff40
movb $0x1, (%r13)
testq %r15, %r15
je 0xff50
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x10(%r15)
cmpl $0x1, %eax
jne 0xff4e
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0xff12
movl $0x1, %ebp
jmp 0xff50
movq 0x8(%r12), %rsi
leaq 0x33f3(%rip), %rcx      # 0x13333
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3c96
movl %eax, %ebp
jmp 0xff55
movl %eax, %ebp
movb $0x0, (%r13)
movq %rsp, %rdi
callq 0x3a57
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq 0x3b8(%rdi), %rax
testq %rax, %rax
je 0x10817
movl 0x1c(%rax), %ebp
jmp 0x10819
xorl %ebp, %ebp
leaq 0x3d0(%rbx), %rdi
callq 0x3a57
leaq 0x3e0(%rbx), %rdi
callq 0x3a57
movq %r14, %rdi
callq 0x3b86
testl %ebp, %ebp
jle 0x1085f
movl %ebp, %r14d
shlq $0x4, %r14
xorl %r15d, %r15d
movq 0x3c8(%rbx), %rdi
addq %r15, %rdi
callq 0x3a57
addq $0x10, %r15
cmpq %r15, %r14
jne 0x10847
movq 0x3c8(%rbx), %rdi
callq 0x3030
movq 0x400(%rbx), %rdi
callq 0x3030
movq 0x3f0(%rbx), %rdi
callq 0x3030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3030
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rdi, %r12
movq 0x20(%rdi), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x10955
movq %rcx, %r13
movq %rsi, %r15
movq %rsp, %rcx
xorl %edx, %edx
movq %r14, %r8
callq 0x109aa
testl %eax, %eax
jle 0x1097d
movl %eax, %eax
leaq 0x30(,%rax,8), %rsi
movl $0x1, %edi
callq 0x3130
testq %rax, %rax
je 0x1096b
movq %rax, %rbp
movq %rax, 0x20(%r13)
movl $0x1, %edi
movl $0x20, %esi
callq 0x3130
movq %rax, 0x8(%rbp)
testq %rax, %rax
je 0x1096b
movl 0x28(%r12), %ecx
movl %ecx, (%rax)
movq %rbp, %rdx
addq $0x30, %rdx
movq %rdx, 0x28(%rbp)
movq 0x18(%rbx), %rdi
movq %rsp, %rcx
movq %r15, %rsi
movq %r14, %r8
callq 0x109aa
leaq 0xbcf(%rip), %rax       # 0x1151a
movq %rax, 0x10(%rbp)
movq 0x20(%rbx), %rbx
jmp 0x1097d
movl 0x28(%rbx), %edx
leaq 0x2ab1(%rip), %rsi      # 0x13410
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x10998
leaq 0x87fe(%rip), %rax      # 0x19170
movq (%rax), %rsi
movq %r14, %rdi
callq 0x3070
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x10998
movq 0x10(%rdi), %r14
callq 0x3030
movq %r14, %rdi
testq %r14, %r14
jne 0x10987
movq %rbx, %rax
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/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movb (%rdi), %al
xorl %ebx, %ebx
testb %al, %al
je 0x11bb8
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
ja 0x11c14
movb 0x1(%r14), %al
testb %al, %al
sete %cl
cmpl $0x2, %ebp
setl %dl
orb %cl, %dl
jne 0x11c0f
movl $0x2, %r12d
leaq 0x18d3(%rip), %r15      # 0x134ab
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jb 0x11bfa
movsbl %al, %esi
movl $0xc, %edx
movq %r15, %rdi
callq 0x3110
testq %rax, %rax
je 0x11c14
movb (%r14,%r12), %al
testb %al, %al
je 0x11c0f
leaq 0x1(%r12), %rcx
cmpl %ebp, %r12d
movq %rcx, %r12
jl 0x11bd8
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/martincameron[P]towntalk/ttasm.c
// Function: get_local_variable
static int get_local_variable( struct function *func, struct element *elem, char *suffix, char *message ) {
	int idx = 0;
	char *name = elem->str.string;
	size_t len = strlen( name ) - strlen( suffix );
	struct local_variable *local = func->variable_decls;
	if( len > 0 ) {
		while( local && ( strncmp( local->name, name, len ) || strlen( local->name ) != len ) ) {
			idx++;
			local = local->next;
		}
	}
	if( len <= 0 || local == NULL || idx > 127 ) {
		if( message ) {
			sprintf( message, "Invalid local variable '%.64s' on line %d.", name, elem->line );
		}
		idx = -1;
	}
	return idx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %rbx
movq %rdi, %r12
movq %rsi, 0x8(%rsp)
movq 0x8(%rsi), %r14
movq %r14, %rdi
callq 0x30c0
movq %rax, %r15
movq %rbx, %rdi
callq 0x30c0
movq %rax, %rbx
movq %r15, %r13
subq %rax, %r13
setne %al
testq %r12, %r12
setne %cl
andb %al, %cl
xorl %ebp, %ebp
cmpb $0x1, %cl
jne 0x11cab
movq %r15, (%rsp)
xorl %ebp, %ebp
movq 0x8(%r12), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x3060
testl %eax, %eax
jne 0x11c99
movq %r15, %rdi
callq 0x30c0
cmpq %r13, %rax
je 0x11ca7
incl %ebp
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x11c75
jmp 0x11cc6
movq (%rsp), %r15
cmpq %rbx, %r15
sete %al
testq %r12, %r12
sete %cl
cmpl $0x7f, %ebp
seta %dl
orb %cl, %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x11cee
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x11cee
movq 0x8(%rsp), %rax
movl 0x28(%rax), %ecx
leaq 0x17fc(%rip), %rsi      # 0x134e0
movq %r14, %rdx
xorl %eax, %eax
callq 0x3200
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_int_atomic_fetch_inc.c
// Function: shmem_int_atomic_fetch_inc
int shmem_int_atomic_fetch_inc( int* ptr, int pe)
{
	int* remote_ptr = (int*)shmem_ptr((void*)ptr, pe ); 
	long* x = (long*)shmem_ptr((void*)&__shmem.lock_atomic_int, pe);
	__set_spin_lock(x);
	int r = *remote_ptr;
	*remote_ptr = r + 1;
	__clear_spin_lock(x);
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
callq 0x1c0c
movq %rax, %r14
leaq 0x31e6(%rip), %rdi      # 0x61f0
addq $0x10, %rdi
movl %ebx, %esi
callq 0x1c0c
movq %rax, %rbx
movq %rax, %rdi
callq 0x32db
movl (%r14), %r15d
leal 0x1(%r15), %eax
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x32cc
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/erik[P]gamut/convolute.c
// Function: main
int main(int argc, char** argv)
{
    if (argc != 2) {
        fprintf(stderr, "usage: %s KERNEL\n", argv[0]);
        return 1;
    }

    const void *kernel = NULL;

    if (!strcmp("blur", argv[1]))
        kernel = &BLUR_KERNEL;
    else if (!strcmp("sharpen", argv[1]))
        kernel = &SHARPEN_KERNEL;
    else {
        fprintf(stderr, "unknown image kernel: %s\n", argv[1]);
        return 1;
    }

    return convolve(kernel);
}

// Assembly:
pushq %rbx
cmpl $0x2, %edi
jne 0x15c5
movq 0x8(%rsi), %rbx
leaq 0xaff(%rip), %rdi       # 0x208f
movq %rbx, %rsi
callq 0x1060
testl %eax, %eax
je 0x15b8
leaq 0xaf1(%rip), %rdi       # 0x2094
movq %rbx, %rsi
callq 0x1060
testl %eax, %eax
jne 0x15cf
leaq 0xa5a(%rip), %rdi       # 0x2010
jmp 0x15bf
leaq 0xa81(%rip), %rdi       # 0x2040
popq %rbx
jmp 0x126c
movq %rsi, %rdi
callq 0x1154
jmp 0x15ea
movq 0x2a22(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xabc(%rip), %rsi       # 0x209c
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1070
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nickglobal[P]usbloger/core.c
// Function: main
int main()
{
	// comment pushed via ssh
	int i,jj;
	printf("usb log core \n");
	printf("start count \n");
	jj = 0;
	for ( i=0; i<10; i++)
	{
		printf(" count rqqqqwerewrwe %d \n", i);
		if ( (jj++) == 5) {
		   printf("JJ\n");
		   jj = 123;
		} 	
	}
	if ( jj == 123 ) 
	{
		printf("remote branch added fix 1  \n");	
		printf("remote branch added fix 2  \n");
	
		printf("remote branch added fix 3  \n");	
		printf("remote branch added fix 4  \n");
		printf("commit once again \n");
		printf("count end\n");
	}
#ifdef USB_FEATURE
	printf("USB logger [ON]\n");
#endif
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xec4(%rip), %rdi       # 0x201e
callq 0x1030
leaq 0xec6(%rip), %rdi       # 0x202c
callq 0x1030
leaq 0xe92(%rip), %rbx       # 0x2004
leaq 0xf4d(%rip), %r14       # 0x20c6
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1040
cmpl $0x5, %r15d
je 0x119a
incl %r15d
cmpl $0x9, %ebp
jne 0x11ad
jmp 0x11b1
movq %r14, %rdi
callq 0x1030
movl $0x7b, %r15d
cmpl $0x9, %ebp
je 0x11b7
incl %ebp
jmp 0x117e
cmpl $0x7b, %r15d
jne 0x11ff
leaq 0xe7b(%rip), %rdi       # 0x2039
callq 0x1030
leaq 0xe8b(%rip), %rdi       # 0x2055
callq 0x1030
leaq 0xe9b(%rip), %rdi       # 0x2071
callq 0x1030
leaq 0xeab(%rip), %rdi       # 0x208d
callq 0x1030
leaq 0xebb(%rip), %rdi       # 0x20a9
callq 0x1030
leaq 0xec2(%rip), %rdi       # 0x20bc
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/upcrob[P]garry/chess.c
// Function: enqueueMove(Move*)
void enqueueMove(Move* move)
{
	if (queueFull == TRUE)
		free(moveQueue[queueIndex]);
	
	moveQueue[queueIndex++] = move;
	if (queueIndex >= MQ_SIZE)
	{
		queueFull = TRUE;
		queueIndex = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, 0xa561(%rip)      # 0xc124
jne 0x1bdc
movq 0xa54c(%rip), %rax      # 0xc118
movslq 0xa54d(%rip), %rcx      # 0xc120
movq (%rax,%rcx,8), %rdi
callq 0x1130
movq 0xa535(%rip), %rax      # 0xc118
movslq 0xa536(%rip), %rcx      # 0xc120
leal 0x1(%rcx), %edx
movl %edx, 0xa52d(%rip)      # 0xc120
movq %rbx, (%rax,%rcx,8)
cmpq $0x13, %rcx
jl 0x1c11
movl $0x1, 0xa51d(%rip)      # 0xc124
movl $0x0, 0xa50f(%rip)      # 0xc120
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/upcrob[P]garry/chess.c
// Function: moveLoopDetected()
int moveLoopDetected()
{
	// setup variables
	int i, j, type, len, dupCount;
	int duplicates[MQ_SIZE];
	if (queueFull == TRUE)
		len = MQ_SIZE;
	else
		len = queueIndex;
	
	// clear duplicate array
	for (i = 0; i < len; i++)
		duplicates[i] = 0;
	
	// check for duplicates
	type = 1;
	for (i = 0; i < len; i++)
	{
		// go to next move if this has been classified
		if (duplicates[i] != 0)
			continue;
		
		// classify
		duplicates[i] = type;
		
		// classify next moves
		for (j = i + 1; j < len; j++)
		{
			// skip if classified
			if (duplicates[j] != 0)
				continue;
		
			Move* a = moveQueue[i];
			Move* b = moveQueue[j];
			if (a->pieceId == b->pieceId && a->startRow == b->startRow &&
				a->startCol == b->startCol && a->endRow == b->endRow &&
				a->endCol == b->endCol)
			{
				// moves were the same
				duplicates[j] = type;
			}
		}
				
		// next type
		type++;
	}
	
	// count duplicates
	int playerDup = 0;
	for (i = 1; i <= type; i++)
	{
		dupCount = 0;
		for (j = 0; j < len; j++)
		{
			if (duplicates[j] == i)
				dupCount++;
		}
		
		if (dupCount > MAX_REPEATS)
		{
			playerDup++;
			if (playerDup > 1)
				return TRUE;
		}
	}
	
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x1, 0xa4f4(%rip)      # 0xc124
movl $0x14, %r14d
je 0x1c3f
movl 0xa4e1(%rip), %r14d     # 0xc120
movl $0x1, %r12d
movl %r14d, %r15d
movl $0x1, %ecx
testl %r14d, %r14d
jle 0x1d0d
leaq (,%r15,4), %rdx
leaq -0x80(%rbp), %rbx
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1080
movq 0xa4a2(%rip), %rax      # 0xc118
movl $0x1, %ecx
movq %r15, %rdx
movq %rax, %rsi
cmpl $0x0, -0x80(%rbp,%r13,4)
je 0x1c91
incq %r13
movq %r13, %rdi
jmp 0x1cf5
movl %ecx, -0x80(%rbp,%r13,4)
leaq 0x1(%r13), %rdi
cmpq %r15, %rdi
jge 0x1cf0
movl $0x1, %r8d
cmpl $0x0, (%rbx,%r8,4)
jne 0x1ce8
movq (%rax,%r13,8), %r9
movq (%rsi,%r8,8), %r10
movb (%r9), %r11b
cmpb (%r10), %r11b
jne 0x1ce8
movb 0x1(%r9), %r11b
cmpb 0x1(%r10), %r11b
jne 0x1ce8
movb 0x2(%r9), %r11b
cmpb 0x2(%r10), %r11b
jne 0x1ce8
movb 0x3(%r9), %r11b
cmpb 0x3(%r10), %r11b
jne 0x1ce8
movb 0x4(%r9), %r9b
cmpb 0x4(%r10), %r9b
jne 0x1ce8
movl %ecx, (%rbx,%r8,4)
incq %r8
cmpq %r8, %rdx
jne 0x1ca5
incl %ecx
movq %rdi, %r13
addq $0x8, %rsi
addq $0x4, %rbx
decq %rdx
cmpq %r15, %rdi
jne 0x1c81
testl %ecx, %ecx
jle 0x1d4d
xorl %edx, %edx
testl %r14d, %r14d
jle 0x1d40
xorl %eax, %eax
xorl %esi, %esi
xorl %edi, %edi
cmpl %r12d, -0x80(%rbp,%rax,4)
sete %dil
addl %edi, %esi
incq %rax
cmpq %rax, %r15
jne 0x1d18
cmpl $0x4, %esi
jb 0x1d40
movl $0x1, %eax
testl %edx, %edx
movl $0x1, %edx
jg 0x1d4f
leal 0x1(%r12), %eax
cmpl %ecx, %r12d
movl %eax, %r12d
jne 0x1d0f
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/upcrob[P]garry/chess.c
// Function: logMove(char const*, Move*)
void logMove(const char* filename, Move* move)
{
	//Open file
	FILE* fp = fopen(filename, "a");
	
	//Log move
	char* moveStr = moveToString(move);
	fprintf(fp, "%s", moveStr);
	free(moveStr);
	
	//Close file
	fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x72ed(%rip), %rsi      # 0x905c
callq 0x1120
movq %rax, %r14
movq %rbx, %rdi
callq 0x7d69
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1130
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10e0
// File: /workspace/github_c_makefile_star2_O3/upcrob[P]garry/chess.c
// Function: printScore(int)
void printScore(int score)
{
	if (score > 0)
		printf("Board Score = %d (WHITE).\n", score);
	else if (score < 0)
		printf("Board Score = %d (BLACK).\n", -score);
	else
		printf("Board Score = EVEN.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %esi
testl %edi, %edi
jle 0x1de7
leaq 0x7245(%rip), %rdi      # 0x9024
xorl %eax, %eax
popq %rbp
jmp 0x1030
js 0x1df6
leaq 0x7370(%rip), %rdi      # 0x9160
popq %rbp
jmp 0x1190
negl %esi
leaq 0x7240(%rip), %rdi      # 0x903f
jmp 0x1ddf
// File: /workspace/github_c_makefile_star2_O3/upcrob[P]garry/boardutil.c
// Function: printBoard(char*)
void printBoard(char* board)
{
	char black = '#';
	char white = '@';
	char pieceId;
	int i, j;
	for (i = 7; i >= 0; i--)
	{
		printf("%d|", i + 1);
		for (j = 0; j < 8; j++)
		{
			pieceId = getPieceAt(board, i, j);
			if (pieceId == EMPTY)
			{
				//empty square
				printf("  ");
			} else if (pieceId > BLACK) {
				//black
				pieceId = (char) (pieceId - BLACK);
				switch (pieceId)
				{
					case PAWN:
						printf("%cP", black);
						break;
					case ROOK:
						printf("%cR", black);
						break;
					case KNIGHT:
						printf("%cN", black);
						break;
					case BISHOP:
						printf("%cB", black);
						break;
					case QUEEN:
						printf("%cQ", black);
						break;
					case KING:
						printf("%cK", black);
						break;
				}
			} else {
				//white
				switch (pieceId)
				{
					case PAWN:
						printf("%cP", white);
						break;
					case ROOK:
						printf("%cR", white);
						break;
					case KNIGHT:
						printf("%cN", white);
						break;
					case BISHOP:
						printf("%cB", white);
						break;
					case QUEEN:
						printf("%cQ", white);
						break;
					case KING:
						printf("%cK", white);
						break;
				}
			}

			if (j < 8)
			{
				printf("|");
			}
		}
		printf("\n");
	}

	printf("-|--|--|--|--|--|--|--|--|\n");
	printf(" | A| B| C| D| E| F| G| H|\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x38, %rbx
movl $0x7, %r12d
leaq 0x71e8(%rip), %r13      # 0x918c
leaq 0x71c9(%rip), %r14      # 0x9174
leal 0x1(%r12), %esi
leaq 0x7452(%rip), %rdi      # 0x9409
xorl %eax, %eax
callq 0x1030
xorl %r15d, %r15d
movzbl (%rbx,%r15), %eax
testl %eax, %eax
je 0x1fed
cmpb $0x33, %al
jl 0x2000
addl $-0x33, %eax
cmpl $0x5, %eax
ja 0x2082
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
leaq 0x7425(%rip), %rdi      # 0x9410
jmp 0x2068
leaq 0x7419(%rip), %rdi      # 0x940d
xorl %eax, %eax
callq 0x1030
jmp 0x2082
decl %eax
cmpl $0x5, %eax
ja 0x2082
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
leaq 0x73f9(%rip), %rdi      # 0x9410
jmp 0x2076
leaq 0x7400(%rip), %rdi      # 0x9420
jmp 0x2068
leaq 0x73f7(%rip), %rdi      # 0x9420
jmp 0x2076
leaq 0x73e6(%rip), %rdi      # 0x9418
jmp 0x2068
leaq 0x73dd(%rip), %rdi      # 0x9418
jmp 0x2076
leaq 0x73d8(%rip), %rdi      # 0x941c
jmp 0x2068
leaq 0x73cf(%rip), %rdi      # 0x941c
jmp 0x2076
leaq 0x73be(%rip), %rdi      # 0x9414
jmp 0x2068
leaq 0x73b5(%rip), %rdi      # 0x9414
jmp 0x2076
leaq 0x73bc(%rip), %rdi      # 0x9424
movl $0x23, %esi
jmp 0x207b
leaq 0x73ae(%rip), %rdi      # 0x9424
movl $0x40, %esi
xorl %eax, %eax
callq 0x1030
movl $0x7c, %edi
callq 0x1150
incq %r15
cmpq $0x8, %r15
jne 0x1fc1
movl $0xa, %edi
callq 0x1150
addq $-0x8, %rbx
subq $0x1, %r12
jae 0x1fab
leaq 0x7370(%rip), %rdi      # 0x9428
callq 0x1190
leaq 0x737f(%rip), %rdi      # 0x9443
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
nop