LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/towntalk.c
// Function: evaluate_pack_expression
static enum result evaluate_pack_expression( struct expression *this,
	struct variables *vars, struct variable *result ) {
	int idx, len;
	long_int in;
	number *src;
	char *out;
	struct string *str;
	struct variable val = { 0, NULL };
	enum result ret = this->parameters->evaluate( this->parameters, vars, &val );
	if( ret ) {
		if( val.string_value && val.string_value && val.string_value->type == ARRAY ) {
			src = ( ( struct array * ) val.string_value )->number_values;
			len = ( ( struct array * ) val.string_value )->length * 4;
		} else {
			src = &val.number_value;
			ret = to_num( &val, src, vars, this->parameters );
			len = 4;
		}
		if( ret ) {
			str = new_string( len );
			if( str ) {
				idx = 0;
				out = str->string;
				while( idx < len ) {
					in = src[ idx >> 2 ];
					out[ idx ] = in >> 24;
					out[ idx + 1 ] = in >> 16;
					out[ idx + 2 ] = in >> 8;
					out[ idx + 3 ] = in;
					idx += 4;
				}
				out[ idx ] = 0;
				result->string_value = str;
			} else {
				ret = throw_out_of_memory( vars, this );
			}
		}
		dispose_temporary( &val );
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movq 0x8(%rdi), %rdi
movq %r15, %rdx
callq *0x18(%rdi)
testl %eax, %eax
je 0xe013
movl %eax, %ebx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xdf8f
cmpb $0x2, 0x14(%rax)
jne 0xdf8f
movq 0x18(%rax), %r15
movl 0x40(%rax), %ebp
shll $0x2, %ebp
jmp 0xdfa9
movq 0x8(%r12), %rcx
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4585
movl %eax, %ebx
movl $0x4, %ebp
testl %ebx, %ebx
je 0xe017
movq %r14, 0x8(%rsp)
movslq %ebp, %r14
leaq 0x19(%r14), %rdi
callq 0x31b0
testq %rax, %rax
je 0xe01b
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movb $0x0, 0x18(%rax,%r14)
movq $0x1, (%rax)
movl %r14d, 0x10(%rax)
movq 0x8(%rax), %rcx
testl %r14d, %r14d
jle 0xe033
movl %ebp, %esi
xorl %edx, %edx
movq 0x8(%rsp), %r8
movl (%r15,%rdx), %edi
bswapl %edi
movl %edi, (%rcx,%rdx)
addq $0x4, %rdx
cmpq %rsi, %rdx
jb 0xdfff
jmp 0xe03a
xorl %ebx, %ebx
jmp 0xe051
xorl %ebx, %ebx
jmp 0xe042
movq 0xb14e(%rip), %rcx      # 0x19170
xorl %ebx, %ebx
movq %r13, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3cc3
jmp 0xe042
xorl %edx, %edx
movq 0x8(%rsp), %r8
movb $0x0, (%rcx,%rdx)
movq %rax, 0x8(%r8)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe051
callq 0x3979
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_O1/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 $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %rdi
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
callq 0x445f
testl %eax, %eax
je 0xe119
movl %eax, %ebp
movq %rbx, 0x8(%rsp)
movq 0x18(%rsp), %rbx
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x3ddf
testl %eax, %eax
js 0xe11e
movl %eax, %r13d
movl %eax, %ecx
movq %rcx, (%rsp)
leaq 0x19(%rcx), %rdi
callq 0x31b0
testq %rax, %rax
je 0xe127
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%r15)
movq (%rsp), %rax
movb $0x0, 0x18(%r15,%rax)
movq $0x1, (%r15)
movl %r13d, 0x10(%r15)
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
movq 0x8(%r15), %rdx
callq 0x3ddf
movq 0x8(%rsp), %rax
movq %r15, 0x8(%rax)
movl %ebp, %r15d
jmp 0xe13e
xorl %r15d, %r15d
jmp 0xe14d
leaq 0x4ec3(%rip), %rcx      # 0x12fe8
jmp 0xe131
movq 0xb042(%rip), %rcx      # 0x19170
xorl %r15d, %r15d
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3cc3
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe14d
callq 0x3979
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x445f
testl %eax, %eax
je 0xe1a5
movl %eax, %ebx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x419c
testq %rax, %rax
je 0xe1a9
movq %rax, 0x8(%r12)
jmp 0xe1bf
xorl %ebx, %ebx
jmp 0xe1ce
movq 0xafc0(%rip), %rcx      # 0x19170
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3cc3
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xe1ce
callq 0x3979
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe1f8
movb $0x0, 0x18(%rax)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe3f7
movl %eax, %ebx
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xe3d0
cmpb $0x6, 0x14(%rax)
jne 0xe3d0
movq 0x28(%rax), %rax
movq %rax, 0x8(%r12)
incq (%rax)
jmp 0xe3e6
leaq 0x430b(%rip), %rcx      # 0x126e2
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3cc3
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xe3f9
callq 0x3979
jmp 0xe3f9
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe461
movsbl 0x14(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x2, %eax
jne 0xe45c
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xe45c
movq %rax, 0x8(%rbx)
incq (%rax)
callq 0x3979
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe52e
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xe505
cmpb $0x3, 0x14(%rax)
jne 0xe505
movq 0x10(%r12), %rdi
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x4714
xorl %ebp, %ebp
testl %eax, %eax
je 0xe51d
movl 0xc(%rsp), %edx
testl %edx, %edx
js 0xe53f
movq 0x18(%rsp), %rcx
cmpl 0x18(%rcx), %edx
jge 0xe53f
addq $0x20, %rcx
movl 0xc(%rsp), %edx
incl %edx
movq (%rcx), %rsi
leaq 0x8(%rsi), %rcx
decl %edx
jne 0xe4e4
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movq (%rsi), %rcx
movq %rcx, 0x8(%rbx)
incq (%rcx)
movl %eax, %ebp
jmp 0xe51d
movl 0x10(%rsp), %edx
leaq 0x4c3a(%rip), %rcx      # 0x1314a
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cc3
xorl %ebp, %ebp
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe530
callq 0x3979
jmp 0xe530
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4be9(%rip), %rcx      # 0x1312f
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cc3
jmp 0xe51d
// File: /workspace/github_c_makefile_star2_O1/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 0xe5cb
movq 0x10(%rbx), %rdi
movq %rsp, %rdx
movq %r12, %rsi
callq *0x18(%rdi)
testl %eax, %eax
je 0xe5f7
movl %eax, %ebx
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xe5cf
cmpb $0x3, 0x14(%rax)
jne 0xe5cf
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
je 0xe5e6
cmpb $0x2, 0x14(%rcx)
jne 0xe5e6
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
je 0xe5e6
cmpq %rax, %rcx
je 0xe616
movq 0x30(%rcx), %rcx
jmp 0xe5bb
xorl %ebx, %ebx
jmp 0xe608
movl (%rsp), %edx
leaq 0x4b71(%rip), %rcx      # 0x1314a
movq %r12, %rdi
movq %r15, %rsi
callq 0x3cc3
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xe5f9
callq 0x3979
jmp 0xe5f9
xorl %ebx, %ebx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe608
callq 0x3979
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xe624
callq 0x3979
movl 0x10(%rsp), %eax
movl %eax, (%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0xe5e6
incq (%rax)
jmp 0xe5e6
// File: /workspace/github_c_makefile_star2_O1/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 0xe685
movl %eax, %ebx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xe689
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %ebp
jmp 0xe697
xorl %ebx, %ebx
jmp 0xe6ef
leaq 0x39c6(%rip), %rax      # 0x12056
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x3d73
testq %rax, %rax
je 0xe6ca
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 0xe6e0
movq 0xaa9f(%rip), %rcx      # 0x19170
xorl %ebx, %ebx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3cc3
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe6ef
callq 0x3979
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_O1/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 0x44a9
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xe840
leaq 0xc(%rsp), %rax
cmpq %rax, (%r12)
jbe 0xe7a4
leaq 0x3ad1(%rip), %rcx      # 0x1225b
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3cc3
movl $0x0, 0xc(%rsp)
jmp 0xe831
movq 0x18(%rsp), %r13
cmpl $0x0, 0x28(%r13)
jg 0xe7c1
movl 0x8(%r12), %esi
movq %r13, %rdi
callq 0x7367
testl %eax, %eax
je 0xe783
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 0x4f9b
cmpb $0x0, (%rbp)
je 0xe801
leaq 0x40(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3cc3
jmp 0xe822
movq 0x30(%rsp), %r12
movl (%r15), %esi
movq %r12, %rdi
callq 0x9e89
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x18(%r12)
movl %eax, %r12d
movl %r12d, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3b29
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe840
callq 0x3979
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_O1/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 0xe8ce
testq %rbx, %rbx
je 0xe932
movq %rsi, %r14
xorl %eax, %eax
cmpq $0x0, 0x18(%rbx)
movslq %eax, %r15
je 0xe8a3
movq 0x8(%rbx), %rax
movb (%rax), %al
leaq (%r14,%r15), %rsi
incq %rsi
movb %al, -0x1(%rsi)
movq 0x18(%rbx), %rdi
callq 0xe856
addl %eax, %r15d
incl %r15d
movq 0x8(%rbx), %rax
movb 0x1(%rax), %cl
jmp 0xe8ba
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 0xe871
jmp 0xe934
testq %rbx, %rbx
je 0xe932
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xe906
xorl %esi, %esi
callq 0xe856
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
js 0xe920
movl $0x7ffffffd, %edx       # imm = 0x7FFFFFFD
subl %r14d, %edx
cmpl %ecx, %edx
jle 0xe920
leal (%r14,%rcx), %eax
addl $0x2, %eax
jmp 0xe920
movl 0x10(%rbx), %ecx
movl $0x7ffffffe, %edx       # imm = 0x7FFFFFFE
subl %r14d, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %edx
jle 0xe920
leal (%r14,%rcx), %eax
incl %eax
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0xe934
movl %eax, %r14d
testl %eax, %eax
jns 0xe8d6
jmp 0xe934
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ddf
testl %eax, %eax
jle 0xee7b
movl %eax, %edi
callq 0x36a0
testq %rax, %rax
je 0xee79
movq %rax, %rbx
movq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
movq 0x8(%rax), %rdx
callq 0x3ddf
jmp 0xee7b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f50(%rip), %rsi      # 0x12de4
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3200
movq %rbx, %rdi
callq 0x30c0
movl %eax, %edi
callq 0x36a0
movq %rax, %rbx
testq %rax, %rax
je 0xeec4
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_O1/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 0x4bb(%rip), %rax       # 0xf626
cmpq %rax, 0x10(%rsi)
je 0xf176
movq %r14, %rbx
jmp 0xf1b5
movq %rcx, %r8
movq %rsi, %rbx
leaq 0x28(%rsi), %rdi
movl (%r14), %eax
movq 0x8(%r14), %rcx
movl %edx, %esi
movl %eax, %edx
callq 0xf560
testq %rax, %rax
je 0xf171
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_O1/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 0x451(%rip), %r12       # 0xf626
cmpq %r12, 0x10(%rsi)
je 0xf222
movq %rdx, %r15
movl $0x1, %edi
movl $0x38, %esi
callq 0x3130
testq %rax, %rax
je 0xf266
movl (%rbx), %ecx
movl %ecx, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x8(%rbx)
movq %r12, 0x10(%rax)
leaq 0xddf(%rip), %rcx       # 0xfff0
movq %rcx, 0x18(%rax)
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq %rax, %r15
jmp 0xf250
movq 0x8(%rbx), %rax
movq %rax, %rdx
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0xf229
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 0x3aeb
jmp 0xf27b
leaq 0x9f03(%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_O1/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
movslq 0xc(%rdi), %rbx
cmpl %ebx, %ebp
jg 0xf5e1
movq %r8, %r12
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 0xf610
movq %rax, %r13
leal 0x4(,%rbp,2), %ebp
movq (%r15), %r12
testq %r12, %r12
je 0xf5d1
shlq $0x3, %rbx
leaq (%rbx,%rbx,2), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x3180
movq %r12, %rdi
callq 0x3030
movq %r13, (%r15)
movl %ebp, 0x8(%r15)
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %edx
movq (%r15), %rax
movslq 0xc(%r15), %rsi
leal 0x1(%rsi), %edi
movl %edi, 0xc(%r15)
leaq (%rsi,%rsi,2), %rsi
leaq (%rax,%rsi,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 0x9b59(%rip), %rax      # 0x19170
movq (%rax), %rsi
movq %r12, %rdi
callq 0x3070
xorl %eax, %eax
jmp 0xf601
// File: /workspace/github_c_makefile_star2_O1/martincameron[P]towntalk/worker.c
// Function: start_worker
int start_worker( struct worker *work ) {
	struct variables vars = { 0 };
	struct function_expression expr = { 0 };
	vars.exception = &work->exception;
	initialize_entry_point( &expr, work->env.entry_point );
	expr.expr.parameters = work->parameters;
	work->ret = expr.expr.evaluate( &expr.expr, &vars, &work->result );
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
xorl %eax, %eax
movq %rax, 0x20(%r14)
movq %rsp, %r15
movq %rax, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x3e0(%rdi), %rax
movq %rax, 0x8(%r14)
movq 0x3b8(%rdi), %rsi
movq %r15, %rdi
callq 0x7f7a
movq 0x3f0(%rbx), %rax
movq %rax, 0x8(%r15)
leaq 0x3d0(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *0x18(%r15)
movl %eax, 0x418(%rbx)
movl $0x1, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x1, %edi
movl $0x48, %esi
callq 0x3130
testq %rax, %rax
je 0x1012c
movq %rax, %r13
leaq -0xbd38(%rip), %rax     # 0x43b8
movq %rax, 0x18(%r13)
movq %r13, 0x20(%r15)
movq 0x8(%rbx), %rax
cmpb $0x7b, (%rax)
jne 0x10143
movl $0x1, %edi
movl $0x30, %esi
callq 0x3130
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x10168
movl 0x28(%rbp), %ecx
movl %ecx, (%rax)
leaq -0xc65c(%rip), %rcx     # 0x3aca
movq %rcx, 0x18(%rax)
jmp 0x1017a
leaq 0x903d(%rip), %rax      # 0x19170
movq (%rax), %rsi
movq %r14, %rdi
callq 0x3070
jmp 0x101d8
leaq 0x38(%rsp), %rcx
movq $0x0, 0x10(%rcx)
movq %rbx, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r14, %r8
callq 0x4f9b
movq %rax, %rbx
jmp 0x1017a
leaq 0x9001(%rip), %rax      # 0x19170
movq (%rax), %rsi
movq %r14, %rdi
callq 0x3070
cmpb $0x0, (%r14)
jne 0x101d8
movq 0x48(%rsp), %rax
movq %rax, 0x8(%r13)
leaq 0x5a(%rip), %rax        # 0x101ea
movq %rax, 0x10(%r13)
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x101ce
leaq 0x10(%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 0x6fe6
movq 0x20(%r15), %rax
movq %rax, 0x28(%r13)
cmpb $0x0, (%r14)
jne 0x101d8
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_O1/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 0x1024c
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x9d5a(%rip), %rsi      # 0x19f90
callq 0x47ee
testl %eax, %eax
je 0x10253
movl $0x3f8, %r13d           # imm = 0x3F8
addq 0x8(%rsp), %r13
jmp 0x1027c
xorl %ebp, %ebp
jmp 0x102dd
testq %r13, %r13
je 0x10261
addq $0x3f9, %r13            # imm = 0x3F9
jmp 0x1027c
movq 0x8(%r12), %rsi
leaq 0x309a(%rip), %rcx      # 0x13307
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3cc3
movl %eax, %ebp
testq %r13, %r13
je 0x102d5
cmpb $0x0, (%r13)
je 0x102a2
movq 0x8(%r12), %rsi
leaq 0x3081(%rip), %rcx      # 0x13315
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3cc3
movl %eax, %ebp
jmp 0x102d5
movb $0x1, (%r13)
testq %r15, %r15
je 0x102d0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x10(%r15)
cmpl $0x1, %eax
jne 0x102ce
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x102ac
movl $0x1, %ebp
jmp 0x102d0
movl %eax, %ebp
movb $0x0, (%r13)
movq %rsp, %rdi
callq 0x3a87
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_O1/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 0x10b10
movl 0x1c(%rax), %ebp
jmp 0x10b12
xorl %ebp, %ebp
leaq 0x3d0(%rbx), %rdi
callq 0x3a87
leaq 0x3e0(%rbx), %rdi
callq 0x3a87
movq %r14, %rdi
callq 0x3bb8
testl %ebp, %ebp
jle 0x10b58
movl %ebp, %r14d
shlq $0x4, %r14
xorl %r15d, %r15d
movq 0x3c8(%rbx), %rdi
addq %r15, %rdi
callq 0x3a87
addq $0x10, %r15
cmpq %r15, %r14
jne 0x10b40
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
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x10c4d
movq %rcx, %r13
movq %rsi, %r15
movq %rsp, %rcx
xorl %edx, %edx
movq %r14, %r8
callq 0x10ca2
testl %eax, %eax
jle 0x10c75
movl %eax, %eax
leaq 0x30(,%rax,8), %rsi
movl $0x1, %edi
callq 0x3130
testq %rax, %rax
je 0x10c63
movq %rax, %rbp
movq %rax, 0x20(%r13)
movl $0x1, %edi
movl $0x20, %esi
callq 0x3130
movq %rax, 0x8(%rbp)
testq %rax, %rax
je 0x10c63
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 0x10ca2
leaq 0xb14(%rip), %rax       # 0x11757
movq %rax, 0x10(%rbp)
movq 0x20(%rbx), %rbx
jmp 0x10c75
movl 0x28(%rbx), %edx
leaq 0x278d(%rip), %rsi      # 0x133e4
movq %r14, %rdi
xorl %eax, %eax
callq 0x3200
jmp 0x10c90
leaq 0x8506(%rip), %rax      # 0x19170
movq (%rax), %rsi
movq %r14, %rdi
callq 0x3070
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x10c90
movq 0x10(%rdi), %r14
callq 0x3030
movq %r14, %rdi
testq %r14, %r14
jne 0x10c7f
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_O1/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
movb (%rdi), %al
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1a, %cl
setb %cl
testb %al, %al
setne %al
xorl %ebp, %ebp
testb %al, %cl
jne 0x11ec2
movl %esi, %ebx
movq %rdi, %r14
movsbl 0x1(%rdi), %esi
testl %esi, %esi
sete %al
cmpl $0x2, %ebx
setl %cl
movl $0x1, %ebp
orb %al, %cl
jne 0x11ec2
movl $0x2, %r12d
leaq 0x15f5(%rip), %r15      # 0x1347f
movl %esi, %eax
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x1a, %al
jb 0x11ea6
movl $0xc, %edx
movq %r15, %rdi
callq 0x3110
testq %rax, %rax
je 0x11ebc
movslq %r12d, %rax
incl %r12d
movsbl (%r14,%rax), %esi
testl %esi, %esi
je 0x11ec2
cmpl %ebx, %r12d
jle 0x11e8a
jmp 0x11ec2
xorl %esi, %esi
xorl %ebp, %ebp
jmp 0x11eb1
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x8(%rsp)
movq %rdx, %r15
movq %rdi, %rbp
movq %rsi, (%rsp)
movq 0x8(%rsi), %r14
movq %r14, %rdi
callq 0x30c0
movq %rax, %r12
movq %r15, %rdi
callq 0x30c0
movq %rax, %r13
movq %r12, 0x10(%rsp)
subq %rax, %r12
movq 0x48(%rbp), %rbx
setne %al
testq %rbx, %rbx
setne %cl
andb %al, %cl
xorl %ebp, %ebp
cmpb $0x1, %cl
jne 0x11f54
xorl %ebp, %ebp
movq 0x8(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3060
testl %eax, %eax
jne 0x11f47
movq %r15, %rdi
callq 0x30c0
cmpq %r12, %rax
je 0x11f54
incl %ebp
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x11f24
xorl %ebx, %ebx
cmpq %r13, 0x10(%rsp)
sete %al
testq %rbx, %rbx
sete %cl
cmpl $0x7f, %ebp
setg %dl
orb %cl, %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x11f98
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x11f98
movq (%rsp), %rax
movl 0x28(%rax), %ecx
leaq 0x1523(%rip), %rsi      # 0x134b1
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_O1/giometti[P]mastering_UNIX_programming/chapter_01/unbuffered.c
// Function: main
int main(void)
{
	int n;
	char buf[DATA_SIZE];

        memset(buf, 0, DATA_SIZE);
	for (n = 0; n < DATA_SIZE; n++)
		if (write(STDOUT_FILENO, &buf[n], 1) != 1) {
			err("write error\n");
			break;
		}

	return 0;
}

// Assembly:
pushq %rbx
subq $0x20000, %rsp          # imm = 0x20000
movq %rsp, %rdi
xorl %ebx, %ebx
movl $0x20000, %edx          # imm = 0x20000
xorl %esi, %esi
callq 0x1040
leaq (%rsp,%rbx), %rsi
movl $0x1, %edx
movl $0x1, %edi
callq 0x1030
cmpq $0x1, %rax
jne 0x118c
incq %rbx
cmpq $0x20000, %rbx          # imm = 0x20000
jne 0x1165
jmp 0x11a2
leaq 0xe71(%rip), %rsi       # 0x2004
movl $0xd, %edx
movl $0x2, %edi
callq 0x1030
xorl %eax, %eax
addq $0x20000, %rsp          # imm = 0x20000
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1bf0
movq %rax, %r14
leaq 0x32ae(%rip), %rdi      # 0x61f0
addq $0x10, %rdi
movl %ebx, %esi
callq 0x1bf0
movq %rax, %rbx
movq %rax, %rdi
callq 0x31ef
movl (%r14), %r15d
leal 0x1(%r15), %eax
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x31e0
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x15ec
movq 0x8(%rsi), %rbx
leaq 0xad8(%rip), %rdi       # 0x208f
movq %rbx, %rsi
callq 0x1060
testl %eax, %eax
je 0x15df
leaq 0xaca(%rip), %rdi       # 0x2094
movq %rbx, %rsi
callq 0x1060
testl %eax, %eax
jne 0x15f6
leaq 0xa33(%rip), %rdi       # 0x2010
jmp 0x15e6
leaq 0xa5a(%rip), %rdi       # 0x2040
popq %rbx
jmp 0x126c
movq %rsi, %rdi
callq 0x1154
jmp 0x1611
movq 0x29fb(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xa95(%rip), %rsi       # 0x209c
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1070
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1195
incl %r15d
jmp 0x11a3
movq %r14, %rdi
callq 0x1030
movl $0x7b, %r15d
incl %ebp
cmpl $0xa, %ebp
jne 0x117e
cmpl $0x7b, %r15d
jne 0x11f8
leaq 0xe82(%rip), %rdi       # 0x2039
callq 0x1030
leaq 0xe92(%rip), %rdi       # 0x2055
callq 0x1030
leaq 0xea2(%rip), %rdi       # 0x2071
callq 0x1030
leaq 0xeb2(%rip), %rdi       # 0x208d
callq 0x1030
leaq 0xec2(%rip), %rdi       # 0x20a9
callq 0x1030
leaq 0xec9(%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_O1/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, 0xa4ad(%rip)      # 0xc124
jne 0x1c90
movq 0xa498(%rip), %rax      # 0xc118
movslq 0xa499(%rip), %rcx      # 0xc120
movq (%rax,%rcx,8), %rdi
callq 0x1130
movq 0xa481(%rip), %rax      # 0xc118
movslq 0xa482(%rip), %rcx      # 0xc120
leal 0x1(%rcx), %edx
movl %edx, 0xa479(%rip)      # 0xc120
movq %rbx, (%rax,%rcx,8)
cmpq $0x13, %rcx
jl 0x1cc5
movl $0x1, 0xa469(%rip)      # 0xc124
movl $0x0, 0xa45b(%rip)      # 0xc120
addq $0x8, %rsp
popq %rbx
popq %rbp
retq