LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: parse_type_tag
static type_tag_t* parse_type_tag(script_t* script)
{
	type_tag_t* tag = get_type_tag_from_name(script, g_lexeme);
	if(!tag) error_exit_p("Invalid type tag '%s'\n", g_lexeme);
	get_next_token();

	switch(tag->type)
	{
		case TAG_FUNC: // parse argument types and return type
		{
			if(g_cur_tok != TOK_OPENPAREN) error_exit_p("Expected '(' after 'func' in type definition but received '%s'\n", g_token_names[g_cur_tok]);
			get_next_token();
			
			while(g_cur_tok != TOK_CLOSEPAREN)
			{
				type_tag_t* arg_tag = parse_type_tag(script);
				vec_push_back(&tag->func.arg_types, &arg_tag);
				if(g_cur_tok == TOK_COMMA) get_next_token();
				else if(g_cur_tok != TOK_CLOSEPAREN) error_exit_p("Expected ')' at the end of function argument list '%s'\n", g_token_names[g_cur_tok]);
			}
			get_next_token();
			
			if(g_cur_tok != TOK_MINUS) error_exit_p("Expected '-' after ')' but received '%s'\n", g_token_names[g_cur_tok]);
			get_next_token();
			
			tag->func.return_type = parse_type_tag(script);
		} break;
		
		case TAG_ARRAY: // parse contained type
		{
			if(g_cur_tok != TOK_MINUS) error_exit_p("Expected '-' after 'array' but received '%s'\n", g_token_names[g_cur_tok]);
			get_next_token();
			
			tag->contained = parse_type_tag(script);
		} break;
		
		default: break;
	}

	return tag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x9aad(%rip), %rsi      # 0x14370
callq 0x7d02
testq %rax, %rax
je 0xa9b9
movq %rax, %rbx
callq 0x9824
movl 0x20(%rbx), %eax
cmpl $0x7, %eax
je 0xa94a
cmpl $0x6, %eax
jne 0xa990
movl 0x9a70(%rip), %eax      # 0x14360
cmpq $0x19, %rax
jne 0xa9c9
callq 0x9824
movq %rbx, %r15
addq $0x28, %r15
movl 0x9a54(%rip), %eax      # 0x14360
leaq -0x28(%rbp), %r12
cmpl $0x1a, %eax
je 0xa96b
movq %r14, %rdi
callq 0xa8aa
movq %rax, -0x28(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xc1b9
movl 0x9a2e(%rip), %eax      # 0x14360
cmpq $0x1a, %rax
je 0xa910
cmpl $0x1f, %eax
jne 0xa9a0
callq 0x9824
movl 0x9a18(%rip), %eax      # 0x14360
jmp 0xa910
movl 0x9a10(%rip), %eax      # 0x14360
cmpq $0x26, %rax
jne 0xa9dd
callq 0x9824
movq %r14, %rdi
callq 0xa8aa
pushq $0x28
jmp 0xa98b
callq 0x9824
movl 0x99ea(%rip), %eax      # 0x14360
cmpq $0x26, %rax
jne 0xa9f1
callq 0x9824
movq %r14, %rdi
callq 0xa8aa
pushq $0x48
popq %rcx
movq %rax, (%rbx,%rcx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9299(%rip), %rcx      # 0x13c40
movq (%rcx,%rax,8), %rsi
leaq 0x46b4(%rip), %rdi      # 0xf066
xorl %eax, %eax
callq 0x78e4
leaq 0x464f(%rip), %rdi      # 0xf00f
leaq 0x99a9(%rip), %rsi      # 0x14370
jmp 0xa9b2
leaq 0x9270(%rip), %rcx      # 0x13c40
movq (%rcx,%rax,8), %rsi
leaq 0x464b(%rip), %rdi      # 0xf026
jmp 0xa9b2
leaq 0x925c(%rip), %rcx      # 0x13c40
movq (%rcx,%rax,8), %rsi
leaq 0x46d9(%rip), %rdi      # 0xf0c8
jmp 0xa9b2
leaq 0x9248(%rip), %rcx      # 0x13c40
movq (%rcx,%rax,8), %rsi
leaq 0x469b(%rip), %rdi      # 0xf09e
jmp 0xa9b2
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: declare_function
static func_decl_t* declare_function(script_t* script, const char* name)
{
	script_module_t* module = vec_get(&script->modules, g_cur_module_index);
	func_decl_t* decl = emalloc(sizeof(func_decl_t));
	
	decl->parent = g_cur_func;
	decl->type = DECL_FUNCTION;
	decl->tag = create_type_tag(script, TAG_FUNC);
	decl->name = estrdup(name);
	
	vec_init(&decl->locals, sizeof(var_decl_t*));
	vec_init(&decl->args, sizeof(var_decl_t*));

	decl->index = script->function_names.length;
	
	char* dup_name = estrdup(name);
	vec_push_back(&script->function_names, &dup_name);
	
	int undef_pc = -1;
	vec_push_back(&script->function_pcs, &undef_pc);
	
	decl->has_return = 0;

	vec_push_back(&module->functions, &decl);
	return decl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %rbx
addq $0x2b8, %rdi            # imm = 0x2B8
movslq 0x981e(%rip), %rsi      # 0x14248
callq 0xc15c
movq %rax, %r14
pushq $0x68
popq %rdi
callq 0x325f
movq %rax, %r12
leaq -0x30(%rbp), %rax
movq %r12, (%rax)
movq 0x980d(%rip), %rax      # 0x14258
movq %rax, (%r12)
andl $0x0, 0x8(%r12)
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x731e
movq %rax, 0x10(%r12)
movq %r13, %rdi
callq 0x24df
movq %rax, 0x18(%r12)
leaq 0x20(%r12), %rdi
pushq $0x8
popq %r15
movq %r15, %rsi
callq 0xbf0c
leaq 0x40(%r12), %rdi
movq %r15, %rsi
callq 0xbf0c
leaq 0x278(%rbx), %r15
movl 0x288(%rbx), %eax
movl %eax, 0x60(%r12)
movq %r13, %rdi
callq 0x24df
leaq -0x40(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0xc1b9
leaq -0x34(%rbp), %rsi
orl $-0x1, (%rsi)
addq $0x298, %rbx            # imm = 0x298
movq %rbx, %rdi
callq 0xc1b9
movb $0x0, 0x64(%r12)
addq $0x20d0, %r14           # imm = 0x20D0
movq %r14, %rdi
leaq -0x30(%rbp), %rbx
movq %rbx, %rsi
callq 0xc1b9
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_O2/goodpaul6[P]generic/script.c
// Function: declare_argument
static var_decl_t* declare_argument(const char* name, type_tag_t* tag)
{
	if(!g_cur_func) error_exit("Attempting to declare argument outside of function\n");
	
	var_decl_t* decl = emalloc(sizeof(var_decl_t));
	
	vec_push_back(&g_cur_func->tag->func.arg_types, &tag);
	
	decl->parent = g_cur_func;
	decl->tag = tag;
	decl->name = estrdup(name);
	decl->scope = g_scope;
	decl->index = INVALID_VAR_DECL_INDEX;
	
	vec_push_back(&g_cur_func->args, &decl);
	return decl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, -0x28(%rbp)
cmpq $0x0, 0x9740(%rip)      # 0x14258
je 0xab9e
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x325f
movq %rax, %r15
leaq -0x30(%rbp), %rbx
movq %rax, (%rbx)
movq 0x971e(%rip), %rax      # 0x14258
movq 0x10(%rax), %rdi
addq $0x28, %rdi
leaq -0x28(%rbp), %r12
movq %r12, %rsi
callq 0xc1b9
movq 0x9703(%rip), %rax      # 0x14258
movq %rax, (%r15)
movq (%r12), %rax
movq %rax, 0x8(%r15)
movq %r14, %rdi
callq 0x24df
movq %rax, 0x10(%r15)
movl 0x96de(%rip), %eax      # 0x14250
movl %eax, 0x18(%r15)
movl $0xffffd8f1, 0x1c(%r15) # imm = 0xFFFFD8F1
movq 0x96d3(%rip), %rdi      # 0x14258
addq $0x40, %rdi
movq %rbx, %rsi
callq 0xc1b9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4666(%rip), %rdi      # 0xf20b
xorl %eax, %eax
callq 0x34e8
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: finalize_args
static void finalize_args()
{
	if (!g_cur_func) error_exit("Attempting to finalize arguments outside of function\n");

	for (int i = 0; i < g_cur_func->args.length; ++i)
	{
		var_decl_t* arg = vec_get_value(&g_cur_func->args, i, var_decl_t*);
		arg->index = -(int)g_cur_func->args.length + i;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x969f(%rip), %rdi      # 0x14258
testq %rdi, %rdi
je 0xabf6
movq 0x50(%rdi), %rax
xorl %ebx, %ebx
cmpq %rbx, %rax
jbe 0xabef
addq $0x40, %rdi
movq %rbx, %rsi
callq 0xc15c
movq (%rax), %rcx
movq 0x9679(%rip), %rdi      # 0x14258
movq 0x50(%rdi), %rax
movl %ebx, %edx
subl %eax, %edx
movl %edx, 0x1c(%rcx)
incq %rbx
jmp 0xabc4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4642(%rip), %rdi      # 0xf23f
xorl %eax, %eax
callq 0x34e8
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: error_defer_c
static void error_defer_c(context_t ctx, const char* fmt, ...)
{
	fprintf(stderr, "\nError (%s:%i):\n", ctx.file, ctx.line);
	
	va_list args;
	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);
	
	g_has_error = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
testb %al, %al
je 0xb237
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0xe0(%rbp), %rbx
movq %rsi, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
movq %r8, 0x20(%rbx)
movq %r9, 0x28(%rbx)
movq 0x8d97(%rip), %r14      # 0x13ff0
movq (%r14), %rdi
movq 0x18(%rbp), %rdx
movl 0x10(%rbp), %ecx
leaq 0x3034(%rip), %rsi      # 0xe29e
xorl %eax, %eax
callq 0x2170
leaq -0x30(%rbp), %rdx
movq %rbx, 0x10(%rdx)
leaq 0x30(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq (%r14), %rdi
leaq 0x4246(%rip), %rsi      # 0xf4de
callq 0x2210
movb $0x1, 0x8fa8(%rip)      # 0x1424c
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: finalize_type
static void finalize_type(const char* key, void* v_tag, void* data)
{
	type_tag_t* tag = v_tag;
	if(tag->defined && !tag->finalized)
	{
		if(tag->type != TAG_STRUCT) error_exit_c(tag->ctx, "Attempted to use non-struct type in struct '%s'\n", tag->ds.name);
		
		for(int using_index = 0; using_index < tag->ds.using.length; ++using_index)
		{
			type_tag_t* using = vec_get_value(&tag->ds.using, using_index, type_tag_t*);
			
			for(int mem_id = 0; mem_id < using->ds.members.length; ++mem_id)
			{
				type_tag_member_t* mem = vec_get(&using->ds.members, mem_id);
				
				type_tag_member_t mem_copy;
				mem_copy.name = estrdup(mem->name);
				mem_copy.index = mem->index + tag->ds.size;
				mem_copy.type = mem->type;
			
				if(mem->default_value)
				{
					// NOTE: Making a shallow copy of the default_value expression
					mem_copy.default_value = emalloc(sizeof(expr_t));
					memcpy(mem_copy.default_value, mem->default_value, sizeof(expr_t));
					mem_copy.default_value->is_shallow_copy = 1;
				}
				else
					mem_copy.default_value = NULL;
				
				vec_push_back(&tag->ds.members, &mem_copy);
			}
			
			tag->ds.size += using->ds.size;
		}
		
		tag->finalized = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpb $0x0, 0x24(%rsi)
je 0xb39e
movq %rsi, %r15
cmpb $0x0, 0x25(%rsi)
jne 0xb39e
cmpl $0xa, 0x20(%r15)
jne 0xb3ad
leaq 0x40(%r15), %rcx
movq %rcx, -0x30(%rbp)
leaq 0x60(%r15), %rcx
movq %rcx, -0x40(%rbp)
xorl %esi, %esi
cmpq %rsi, 0x50(%r15)
jbe 0xb399
movq -0x30(%rbp), %rdi
movq %rsi, -0x38(%rbp)
callq 0xc15c
movq (%rax), %rbx
leaq 0x60(%rbx), %r14
xorl %r12d, %r12d
cmpq %r12, 0x70(%rbx)
jbe 0xb385
movq %r14, %rdi
movq %r12, %rsi
callq 0xc15c
movq %rax, %r13
movq (%rax), %rdi
callq 0x24df
movq %rax, -0x60(%rbp)
movl 0x8(%r13), %eax
addl 0x38(%r15), %eax
movl %eax, -0x58(%rbp)
movq 0x10(%r13), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, 0x18(%r13)
je 0xb36e
pushq $0x60
popq %rdi
callq 0x325f
movq %rax, -0x48(%rbp)
movq 0x18(%r13), %rsi
pushq $0xc
popq %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movb $0x1, (%rax)
jmp 0xb373
andq $0x0, -0x48(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xc1b9
incq %r12
jmp 0xb316
movq 0x38(%rbx), %rax
addq %rax, 0x38(%r15)
movq -0x38(%rbp), %rsi
incq %rsi
jmp 0xb2f5
movb $0x1, 0x25(%r15)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%r15), %rsi
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorl %eax, %eax
callq 0xb3ca
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: error_exit_c
static void error_exit_c(context_t ctx, const char* fmt, ...)
{
	fprintf(stderr, "\nError (%s:%i):\n", ctx.file, ctx.line);
	
	va_list args;
	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);
	
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
testb %al, %al
je 0xb405
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0xe0(%rbp), %rbx
movq %rsi, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
movq %r8, 0x20(%rbx)
movq %r9, 0x28(%rbx)
movq 0x8bc9(%rip), %r14      # 0x13ff0
movq (%r14), %rdi
movq 0x18(%rbp), %rdx
movl 0x10(%rbp), %ecx
leaq 0x2e66(%rip), %rsi      # 0xe29e
xorl %eax, %eax
callq 0x2170
leaq -0x30(%rbp), %rdx
movq %rbx, 0x10(%rdx)
leaq 0x30(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq (%r14), %rdi
leaq 0x4094(%rip), %rsi      # 0xf4fa
callq 0x2210
pushq $0x1
popq %rdi
callq 0x2240
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: compile_file_line_info
static void compile_file_line_info(script_t* script, expr_t* exp, char ignore_last)
{
	if (exp->ctx.file)
	{
		if (ignore_last || !g_last_compiled_file || strcmp(g_last_compiled_file, exp->ctx.file) != 0)
		{
			append_code(script, OP_FILE);
			append_int(script, register_string(script, exp->ctx.file));
		}
		g_last_compiled_file = exp->ctx.file;
	}

	if(ignore_last || g_last_compiled_line != exp->ctx.line)
	{
		append_code(script, OP_LINE);
		append_int(script, exp->ctx.line);
	}
	g_last_compiled_line = exp->ctx.line;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r12
testq %r12, %r12
je 0xb4e2
testb %r15b, %r15b
sete %al
movq 0x8fd3(%rip), %rdi      # 0x14470
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xb4b6
movq %r12, %rsi
callq 0x2150
testl %eax, %eax
je 0xb4db
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x7117
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x7a4c
movq %r14, %rdi
movl %eax, %esi
callq 0xba1b
movq 0x10(%rbx), %r12
movq %r12, 0x8f8e(%rip)      # 0x14470
testb %r15b, %r15b
jne 0xb4f2
movl 0x8f8b(%rip), %eax      # 0x14478
cmpl 0x8(%rbx), %eax
je 0xb50b
pushq $0x2d
popq %rsi
movq %r14, %rdi
callq 0x7117
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0xba1b
movl 0x8(%rbx), %eax
movl %eax, 0x8f67(%rip)      # 0x14478
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: compile_call
static void compile_call(script_t* script, expr_t* exp)
{
	int nargs = exp->callx.args.length;

	if (exp->callx.func->type == EXP_COLON)
	{
		compile_value_expr(script, exp->callx.func->dotx.value);
		nargs += 1;
	}

	for(int i = 0; i < exp->callx.args.length; ++i)
	{
		expr_t* e = vec_get_value(&exp->callx.args, i, expr_t*);
		compile_value_expr(script, e);
	}

	compile_value_expr(script, exp->callx.func);
	
	append_code(script, OP_CALL);
	append_code(script, nargs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x50(%rsi), %r13b
movq 0x38(%rsi), %rax
cmpl $0x3, 0x28(%rax)
jne 0xbac9
movq 0x38(%rax), %rsi
movq %rbx, %rdi
callq 0xb51a
incb %r13b
leaq 0x40(%r14), %r15
xorl %r12d, %r12d
cmpq %r12, 0x50(%r14)
jbe 0xbaf1
movq %r15, %rdi
movq %r12, %rsi
callq 0xc15c
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xb51a
incq %r12
jmp 0xbad0
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0xb51a
pushq $0x29
popq %rsi
movq %rbx, %rdi
callq 0x7117
movzbl %r13b, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7117
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: read_int_at
static int read_int_at(script_t* script, int pc)
{
	int value = 0;
	word* vp = (word*)(&value);
	
	for(int i = 0; i < sizeof(int) / sizeof(word); ++i)
		*vp++ = vec_get_value(&script->code, pc + i, word);
		
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
andl $0x0, -0x1c(%rbp)
movq %rdi, %rbx
addq $0x1d8, %rbx            # imm = 0x1D8
movslq %esi, %r14
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0xbb5e
leaq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0xc15c
movb (%rax), %al
movb %al, -0x1c(%rbp,%r15)
incq %r15
jmp 0xbb40
movl -0x1c(%rbp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: get_executing_module
static script_module_t* get_executing_module(script_t* script)
{
	for (int i = 0; i < script->modules.length; ++i)
	{
		script_module_t* m = vec_get(&script->modules, i);
		if (m->start_pc <= script->pc && m->end_pc >= script->pc)
			return m;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2b8(%rdi), %r14
xorl %r15d, %r15d
cmpq %r15, 0x2c8(%rbx)
jbe 0xbbaf
movq %r14, %rdi
movq %r15, %rsi
callq 0xc15c
movslq 0x11c(%rbx), %rcx
cmpq %rcx, 0x20(%rax)
ja 0xbbaa
cmpq %rcx, 0x28(%rax)
jae 0xbbb1
incq %r15
jmp 0xbb83
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: read_int
static int read_int(script_t* script)
{
	int value = 0;
	word* vp = (word*)(&value);
	
	for(int i = 0; i < sizeof(int) / sizeof(word); ++i)
		*vp++ = vec_get_value(&script->code, script->pc++, word);
	
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
andl $0x0, -0x1c(%rbp)
movq %rdi, %rbx
leaq 0x1d8(%rdi), %r14
xorl %r15d, %r15d
cmpl $0x4, %r15d
je 0xbc01
movslq 0x11c(%rbx), %rsi
leal 0x1(%rsi), %eax
movl %eax, 0x11c(%rbx)
movq %r14, %rdi
callq 0xc15c
movb (%rax), %al
movb %al, -0x1c(%rbp,%r15)
incq %r15
jmp 0xbbd7
movl -0x1c(%rbp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: push_func
static void push_func(script_t* script, char is_extern, int index)
{
	script_value_t* val = new_value(script, VAL_FUNC);
	val->function.is_extern = is_extern;
	val->function.index = index;
	push_value(script, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
pushq $0x5
popq %rsi
callq 0x2fb8
movb %r14b, 0x20(%rax)
movl %ebx, 0x24(%rax)
movq %r15, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2e40
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: compare_values
static char compare_values(script_value_t* a, script_value_t* b)
{
	if(a->type != b->type) return 0;
	switch(a->type)
	{
		case VAL_NATIVE: return a->nat.value == b->nat.value;
		case VAL_BOOL: return a->boolean == b->boolean;
		case VAL_CHAR: return a->code == b->code;
		case VAL_NUMBER: return a->number == b->number;
		case VAL_STRING: return strcmp(a->string.data, b->string.data) == 0;
		case VAL_NULL: return 1;
		case VAL_FUNC: return (a->function.is_extern == b->function.is_extern) && (a->function.index == b->function.index);
		case VAL_ARRAY:
		{
			int min_index = (int)(a->array.length < b->array.length ? a->array.length : b->array.length);
			for(int i = 0; i < min_index; ++i)
			{
				if(!compare_values(vec_get_value(&a->array, i, script_value_t*), vec_get_value(&b->array, i, script_value_t*)))
					return 0;
			}
			
			return 1;
		} break;
		case VAL_STRUCT_INSTANCE:
		{
			if(a->ds.members.length != b->ds.members.length) return 0;
			for(int i = 0; i < a->ds.members.length; ++i)
			{
				if(!compare_values(vec_get_value(&a->ds.members, i, script_value_t*), vec_get_value(&b->ds.members, i, script_value_t*)))
					return 0;
			}
			
			return 1;
		} break;
	}
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0xbd6a
cmpl $0x8, %eax
ja 0xbd6a
movq %rsi, %rbx
movq %rdi, %r14
movl %eax, %eax
leaq 0x1917(%rip), %rcx      # 0xd5cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb 0x20(%r14), %al
cmpb 0x20(%rbx), %al
jmp 0xbdd9
movq 0x28(%r14), %rdi
movq 0x28(%rbx), %rsi
callq 0x2150
testl %eax, %eax
jmp 0xbdd9
movb $0x1, %r15b
jmp 0xbddd
movsd 0x20(%rbx), %xmm0
cmpeqsd 0x20(%r14), %xmm0
movq %xmm0, %r15
andl $0x1, %r15d
jmp 0xbddd
movq 0x30(%r14), %rax
cmpq 0x30(%rbx), %rax
jne 0xbd6a
leaq 0x20(%r14), %rax
movq %rax, -0x30(%rbp)
addq $0x20, %rbx
xorl %r13d, %r13d
cmpq %r13, 0x30(%r14)
setbe %r15b
jbe 0xbddd
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0xc15c
movq (%rax), %r12
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc15c
movq (%rax), %rsi
movq %r12, %rdi
callq 0xbc83
incq %r13
testb %al, %al
jne 0xbd19
jmp 0xbddd
movb 0x20(%r14), %al
cmpb 0x20(%rbx), %al
jne 0xbd6a
movl 0x24(%r14), %eax
cmpl 0x24(%rbx), %eax
jmp 0xbdd9
xorl %r15d, %r15d
jmp 0xbddd
movq 0x30(%r14), %rax
addq $0x20, %r14
movq 0x30(%rbx), %rcx
addq $0x20, %rbx
cmpq %rcx, %rax
cmovbq %rax, %rcx
movslq %ecx, %rax
xorl %r12d, %r12d
testl %eax, %eax
movl $0x0, %r13d
movq %rax, -0x30(%rbp)
cmovgl %eax, %r13d
cmpq %r12, %r13
je 0xbdef
movq %r14, %rdi
movq %r12, %rsi
callq 0xc15c
movq (%rax), %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc15c
movq (%rax), %rsi
movq %r15, %rdi
callq 0xbc83
incq %r12
xorl %r15d, %r15d
testb %al, %al
jne 0xbd9c
jmp 0xbddd
movq 0x20(%r14), %rax
cmpq 0x20(%rbx), %rax
sete %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq -0x30(%rbp), %r12
setge %r15b
jmp 0xbddd
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: pop_stack_frame
static void pop_stack_frame(script_t* script)
{
	if (script->indir_depth <= 0)
	{
		script->pc = -1;
		vec_clear(&script->stack);
		return;
	}
	
	// NOTE: Remove local values
	vec_resize(&script->stack, script->fp, NULL);

	// NOTE: Reset pc and fp
	vec_pop_back(&script->indir, &script->pc);
	vec_pop_back(&script->indir, &script->fp);
	
	int nargs;
	vec_pop_back(&script->indir, &nargs);

	// NOTE: Remove arguments
	vec_resize(&script->stack, script->stack.length - nargs, NULL);

	--script->indir_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x190(%rdi)
jle 0xbee7
leaq 0x198(%rbx), %r14
leaq 0x120(%rbx), %r15
movslq 0x120(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc10a
leaq 0x1b8(%rbx), %r12
leaq 0x11c(%rbx), %rsi
movq %r12, %rdi
callq 0xc219
movq %r12, %rdi
movq %r15, %rsi
callq 0xc219
leaq -0x24(%rbp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0xc219
movq 0x1a8(%rbx), %rsi
movslq (%r15), %rax
subq %rax, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc10a
decl 0x190(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
orl $-0x1, 0x11c(%rbx)
addq $0x198, %rbx            # imm = 0x198
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc3ea
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/vector.c
// Function: vec_copy
void vec_copy(vector_t* me, vector_t* other)
{
	if(me->datum_size != other->datum_size) error_exit("Attempted to copy vectors with different data sizes\n");
	if(me->capacity < other->capacity)
	{
		me->capacity = other->capacity;
		vec_realloc(me);
	}
	
	memcpy(me->data, other->data, me->datum_size * other->capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0xbf69
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rdx
cmpq %rdx, 0x18(%rdi)
jae 0xbf56
movq %rdx, 0x18(%r14)
movq %r14, %rdi
callq 0xc01e
movq 0x8(%r14), %rax
movq 0x18(%rbx), %rdx
imulq %rax, %rdx
movq (%r14), %rdi
movq (%rbx), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x21a0
leaq 0x3b64(%rip), %rdi      # 0xfad4
xorl %eax, %eax
callq 0xbf77
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/vector.c
// Function: error_exit
static void error_exit(const char* fmt, ...)
{
	fprintf(stderr, "\nError:\n");
	
	va_list args;
	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);
	
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
testb %al, %al
je 0xbfb7
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0xe0(%rbp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
movq 0x8017(%rip), %r15      # 0x13ff0
movq (%r15), %rcx
leaq 0x2e08(%rip), %rdi      # 0xedeb
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
leaq -0x30(%rbp), %rdx
movq %r14, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2210
pushq $0x1
popq %rdi
callq 0x2240
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/vector.c
// Function: vec_copy_region
void vec_copy_region(vector_t* me, vector_t* other, size_t index, size_t start, size_t amount)
{
	if(me->datum_size != other->datum_size) error_exit("Attempted to copy vectors with different data sizes\n");
	
	if(start < 0 || start > other->length ||
		start + amount > other->length) error_exit("Attempted to copy from region outside of bounds of vector\n");
	
	vec_reserve(me, index + amount);

	if(index + amount > me->length) me->length = index + amount;
	memcpy(&me->data[index * me->datum_size], &other->data[start * other->datum_size], amount * other->datum_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0xc0dd
movq %rcx, %r14
movq %rsi, -0x30(%rbp)
movq 0x10(%rsi), %rax
cmpq %rcx, %rax
jb 0xc0e6
movq %r8, %rbx
leaq (%r8,%r14), %rcx
cmpq %rax, %rcx
ja 0xc0e6
movq %rdx, %r15
movq %rdi, %r13
leaq (%rbx,%rdx), %r12
movq %r12, %rsi
callq 0xc0f4
cmpq 0x10(%r13), %r12
jbe 0xc0a5
movq %r12, 0x10(%r13)
imulq 0x8(%r13), %r15
addq (%r13), %r15
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
imulq %rax, %r14
addq (%rcx), %r14
imulq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
leaq 0x39f0(%rip), %rdi      # 0xfad4
jmp 0xc0ed
leaq 0x3a1c(%rip), %rdi      # 0xfb09
xorl %eax, %eax
callq 0xbf77
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/vector.c
// Function: vec_resize
void vec_resize(vector_t* vector, size_t amount, void* p_initial_value)
{
	vec_reserve(vector, amount);
	vector->length = amount;
	
	if(p_initial_value)
	{
		for(int i = 0; i < vector->length; ++i)
			memcpy(&vector->data[i * vector->datum_size], p_initial_value, vector->datum_size);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xc0f4
movq %r15, 0x10(%r14)
testq %rbx, %rbx
je 0xc153
xorl %r12d, %r12d
cmpq %r12, %r15
jbe 0xc153
movq 0x8(%r14), %rdx
movq %rdx, %rdi
imulq %r12, %rdi
addq (%r14), %rdi
movq %rbx, %rsi
callq 0x21a0
incq %r12
movq 0x10(%r14), %r15
jmp 0xc12f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/vector.c
// Function: vec_push_back
void vec_push_back(vector_t* vector, void* object)
{
	while(vector->length + 1 >= vector->capacity)
	{
		if(vector->capacity == 0)
			vector->capacity = 8;
		vector->capacity *= 2;
		vec_realloc(vector);
	}
	
	memcpy(&vector->data[vector->length * vector->datum_size], object, vector->datum_size);
	vector->length++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %r15
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rax
leaq 0x1(%rdi), %rcx
cmpq %rax, %rcx
jb 0xc1f7
leaq (%rax,%rax), %rcx
testq %rax, %rax
cmoveq %r15, %rcx
movq %rcx, 0x18(%rbx)
movq %rbx, %rdi
callq 0xc01e
jmp 0xc1cd
movq 0x8(%rbx), %rdx
imulq %rdx, %rdi
addq (%rbx), %rdi
movq %r14, %rsi
callq 0x21a0
incq 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/vector.c
// Function: vec_pop_back
void vec_pop_back(vector_t* vector, void* into)
{
	if(vector->length == 0) error_exit("Attempted to perform vec_pop_back on empty vector");
	
	if (!into)
	{
		--vector->length;
		return;
	}

	memcpy(into, &vector->data[(--vector->length) * vector->datum_size], vector->datum_size);
}

// Assembly:
movq %rsi, %rax
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0xc249
decq %rsi
testq %rax, %rax
je 0xc244
movq %rsi, 0x10(%rdi)
movq 0x8(%rdi), %rdx
imulq %rdx, %rsi
addq (%rdi), %rsi
movq %rax, %rdi
jmp 0x21a0
movq %rsi, 0x10(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x3974(%rip), %rdi      # 0xfbc8
xorl %eax, %eax
callq 0xbf77
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/vector.c
// Function: vec_insert
void vec_insert(vector_t* vector, void* object, size_t index)
{
	if(index >= vector->length) error_exit("Provided out of bounds index (%i) to vec_insert (vector length: %i)", (int)index, (int)vector->length);
	
	while(vector->length + 1 >= vector->capacity)
	{
		vector->capacity *= 2;
		vec_realloc(vector);
	}
	
	memmove(&vector->data[(index + 1) * vector->datum_size], &vector->data[index * vector->datum_size], (vector->length - index) * vector->datum_size);
	memcpy(&vector->data[index * vector->datum_size], object, vector->datum_size);
	vector->length += 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x10(%rdi), %rdx
cmpq %rbx, %rdx
jbe 0xc2e3
movq %rsi, %r15
movq %rdi, %r14
leaq 0x1(%rdx), %rcx
movq 0x18(%r14), %rax
cmpq %rax, %rcx
jb 0xc299
addq %rax, %rax
movq %rax, 0x18(%r14)
movq %r14, %rdi
callq 0xc01e
movq 0x10(%r14), %rdx
jmp 0xc277
leaq 0x1(%rbx), %rdi
movq (%r14), %rax
movq 0x8(%r14), %rsi
imulq %rsi, %rdi
addq %rax, %rdi
subq %rbx, %rdx
imulq %rsi, %rdx
imulq %rbx, %rsi
addq %rax, %rsi
callq 0x21f0
movq 0x8(%r14), %rdx
imulq %rdx, %rbx
addq (%r14), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21a0
incq 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3910(%rip), %rdi      # 0xfbfa
movl %ebx, %esi
xorl %eax, %eax
callq 0xbf77
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/vector.c
// Function: vec_flip
void vec_flip(vector_t* vector)
{
	if(vector->length == 0) return;
	
	unsigned char* lo = vector->data;
	unsigned char* hi = &vector->data[vector->length - 1];
	unsigned char swap;
	
	while(lo < hi)
	{
		swap = *lo;
		*lo++ = *hi;
		*hi-- = swap;
	}
}

// Assembly:
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0xc398
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
addq %rax, %rcx
decq %rcx
cmpq %rcx, %rax
jae 0xc397
movb (%rax), %dl
movb (%rcx), %sil
movb %sil, (%rax)
incq %rax
movb %dl, (%rcx)
decq %rcx
jmp 0xc380
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/vector.c
// Function: vec_destroy
void vec_destroy(vector_t* vector)
{
	if(vector->data)
		free(vector->data);
	vector->data = NULL;
	vector->length = 0;
	vector->capacity = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2030
andq $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/hashmap.c
// Function: map_set
void map_set(hashmap_t* map, const char* key, void* value)
{
	unsigned long pos = map_hash_function(key) % HASHMAP_BUCKET_AMT;
	
	hashmap_node_t* node = create_node(key, value);
	
	if(!map->buckets[pos])
		vec_push_back(&map->active_buckets, &pos);
	
	node->next = map->buckets[pos];
	map->buckets[pos] = node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xc50e
movq %rax, %r14
andl $0x3ff, %r14d           # imm = 0x3FF
movq %r14, -0x38(%rbp)
pushq $0x18
popq %rdi
callq 0x21b0
testq %rax, %rax
je 0xc4ef
movq %rax, %r15
movq %r12, %rdi
callq 0x20b0
leaq 0x1(%rax), %rdi
callq 0x21b0
testq %rax, %rax
je 0xc500
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x2050
movq %r13, 0x8(%r15)
movq -0x30(%rbp), %rax
movq %rax, 0x10(%r15)
movq (%rbx,%r14,8), %rax
testq %rax, %rax
jne 0xc4d9
leaq 0x2000(%rbx), %rdi
leaq -0x38(%rbp), %r14
movq %r14, %rsi
callq 0xc1b9
movq (%r14), %r14
movq (%rbx,%r14,8), %rax
movq %rax, (%r15)
movq %r15, (%rbx,%r14,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37b9(%rip), %rdi      # 0xfcaf
movq %r12, %rsi
xorl %eax, %eax
callq 0xc76a
leaq 0x3798(%rip), %rdi      # 0xfc9f
xorl %eax, %eax
callq 0xc76a
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/hashmap.c
// Function: map_hash_function
static unsigned long map_hash_function(const char* str)
{
	unsigned long hash = 5381;
	int c;

	while ((c = *str++))
		hash = ((hash << 5) + hash) + c; /* hash * 33 + c */

	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1505, %eax           # imm = 0x1505
movsbq (%rdi), %rcx
testq %rcx, %rcx
je 0xc52c
incq %rdi
imulq $0x21, %rax, %rax
addq %rcx, %rax
jmp 0xc517
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/hashmap.c
// Function: map_get
void* map_get(hashmap_t* map, const char* key)
{
	unsigned long pos = map_hash_function(key) % HASHMAP_BUCKET_AMT;
	
	if(!map->buckets[pos])
		return NULL;
	else 
	{
		hashmap_node_t* node = map->buckets[pos];
		
		while(node)
		{
			if(strcmp(node->key, key) == 0)
				return node->value;
			node = node->next;
		}
	}
	
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xc50e
andl $0x3ff, %eax            # imm = 0x3FF
movq (%r14,%rax,8), %r15
xorl %r14d, %r14d
testq %r15, %r15
je 0xc575
testq %r15, %r15
je 0xc575
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0x2150
testl %eax, %eax
je 0xc571
movq (%r15), %r15
jmp 0xc557
movq 0x10(%r15), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/hashmap.c
// Function: map_remove
void* map_remove(hashmap_t* map, const char* key)
{
	unsigned long pos = map_hash_function(key) % HASHMAP_BUCKET_AMT;
	
	if(!map->buckets[pos])
		return NULL;
	else 
	{
		hashmap_node_t* node = map->buckets[pos];
		hashmap_node_t* prev = NULL;
		
		while(node)
		{
			if(strcmp(node->key, key) == 0)
			{
				if(prev)
					prev->next = node->next;
				else
				{
					map->buckets[pos] = NULL;
					int to_remove = -1;
					for(size_t i = 0; i < map->active_buckets.length; ++i)
					{
						if(*(unsigned long*)vec_get(&map->active_buckets, i) == pos)
						{
							to_remove = i;
							break;
						}
					}
					
					if(to_remove >= 0) vec_remove(&map->active_buckets, to_remove);
				}
				
				void* value = node->value;
				
				free(node->key);
				free(node);
				
				return value;
			}
			
			prev = node;
			node = node->next;
		}
	}
	
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0xc50e
movq %rax, %r15
andl $0x3ff, %r15d           # imm = 0x3FF
movl %r15d, %eax
movq (%r14,%rax,8), %rax
testq %rax, %rax
je 0xc5d8
xorl %r12d, %r12d
testq %rax, %rax
je 0xc5d8
movq %rax, %rbx
movq 0x8(%rax), %rdi
movq %r13, %rsi
callq 0x2150
testl %eax, %eax
je 0xc5dd
movq (%rbx), %rax
movq %rbx, %r12
jmp 0xc5b8
xorl %r14d, %r14d
jmp 0xc5fe
testq %r12, %r12
je 0xc610
movq (%rbx), %rax
movq %rax, (%r12)
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0x2030
movq %rbx, %rdi
callq 0x2030
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andq $0x0, (%r14,%r15,8)
leaq 0x2000(%r14), %r12
xorl %r13d, %r13d
cmpq 0x2010(%r14), %r13
jae 0xc5e9
movq %r12, %rdi
movq %r13, %rsi
callq 0xc15c
cmpq %r15, (%rax)
je 0xc63d
incq %r13
jmp 0xc61f
testl %r13d, %r13d
js 0xc5e9
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
movq %r12, %rdi
movq %r13, %rsi
callq 0xc2f3
jmp 0xc5e9
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/hashmap.c
// Function: map_traverse
void map_traverse(hashmap_t* map, hashmap_traverse_t traverse, void* data)
{
	for(size_t i = 0; i < map->active_buckets.length; ++i)
	{
		unsigned long pos = *(unsigned long*)vec_get(&map->active_buckets, i);
		hashmap_node_t* node = map->buckets[pos];
		while(node)
		{
			traverse(node->key, node->value, data);
			node = node->next;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2000(%rdi), %rax
movq %rax, -0x30(%rbp)
xorl %r13d, %r13d
cmpq 0x2010(%r15), %r13
jae 0xc6b7
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0xc15c
movq (%rax), %rax
leaq (%r15,%rax,8), %r12
movq (%r12), %r12
testq %r12, %r12
je 0xc6b2
movq 0x8(%r12), %rdi
movq 0x10(%r12), %rsi
movq %rbx, %rdx
callq *%r14
jmp 0xc697
incq %r13
jmp 0xc67b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/hashmap.c
// Function: map_clear
void map_clear(hashmap_t* map)
{
	for(size_t i = 0; i < map->active_buckets.length; ++i)
	{
		unsigned long pos = *(unsigned long*)vec_get(&map->active_buckets, i);
		hashmap_node_t* node = map->buckets[pos];
		free_bucket(node);
		map->buckets[pos] = NULL;
	}
	
	vec_clear(&map->active_buckets);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x2000(%rdi), %rax
movq %rax, -0x30(%rbp)
xorl %r15d, %r15d
cmpq 0x2010(%r14), %r15
jae 0xc730
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0xc15c
movq (%rax), %r13
movq (%r14,%r13,8), %r12
testq %r12, %r12
jne 0xc721
jmp 0xc726
movq (%r12), %rbx
movq 0x8(%r12), %rdi
callq 0x2030
movq %r12, %rdi
callq 0x2030
movq %rbx, %r12
testq %r12, %r12
jne 0xc708
andq $0x0, (%r14,%r13,8)
incq %r15
jmp 0xc6e5
movq -0x30(%rbp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc3ea
// File: /workspace/github_c_makefile_star2_O2/smilingthax[P]libfontembed/woffer.c
// Function: parse_uni
static int parse_uni(const char **str,int *is_wildcard) // {{{
{
  const char *end=*str;
  int iA,ret=0,wildcard=1;

  for (iA=0;(*end)&&(iA<6);end++,iA++) {
    if (*end=='?') {
      wildcard*=16;
      ret*=16;
    } else if (wildcard>1) {
      ret=-1;
      break;
    } else if ( (*end>='0')&&(*end<='9') ) {
      ret=16*ret+(*end-'0');
    } else if ( (*end>='a')&&(*end<='f') ) {
      ret=16*ret+10+(*end-'a');
    } else if ( (*end>='A')&&(*end<='F') ) {
      ret=16*ret+10+(*end-'A');
    } else {
      break;
    }
  }
  if (  (wildcard>0x100000)||
        ( (ret==0x100000)&&(wildcard>0x10000) )  ) {
    ret=-1;
  } else if (is_wildcard) {
    *is_wildcard=wildcard-1;
  } else if (wildcard>1) {
    ret=-1;
  }
  if ( (iA==0)||(iA>=6)||(ret<0)||(ret>0x10ffff) ) {
    fprintf(stderr,"Parse error in unicode point\n");
    return -1;
  }
  *str=end;

  return ret;
}

// Assembly:
pushq %rax
movq (%rdi), %rcx
pushq $0x1
popq %r9
xorl %r8d, %r8d
pushq $-0x6
popq %rdx
pushq $-0x1
popq %rax
movl %edx, %r10d
addl $0x6, %r10d
setb %r11b
movb (%rcx), %r10b
testb %r10b, %r10b
je 0x1851
testb %r11b, %r11b
je 0x1851
cmpb $0x3f, %r10b
jne 0x17fd
shll $0x4, %r9d
shll $0x4, %r8d
jmp 0x1847
cmpl $0x1, %r9d
jg 0x184e
leal -0x30(%r10), %r11d
cmpb $0x9, %r11b
ja 0x181a
shll $0x4, %r8d
movzbl %r11b, %r10d
orl %r10d, %r8d
jmp 0x1847
leal -0x61(%r10), %r11d
cmpb $0x5, %r11b
ja 0x182e
shll $0x4, %r8d
movzbl %r11b, %r10d
jmp 0x1840
addb $-0x41, %r10b
cmpb $0x5, %r10b
ja 0x1875
shll $0x4, %r8d
movzbl %r10b, %r10d
addl %r10d, %r8d
addl $0xa, %r8d
incq %rcx
incl %edx
jmp 0x17d5
movl %eax, %r8d
cmpl $0x100000, %r9d         # imm = 0x100000
jg 0x1890
cmpl $0x100000, %r8d         # imm = 0x100000
sete %r10b
cmpl $0x10001, %r9d          # imm = 0x10001
setge %r11b
testb %r11b, %r10b
jne 0x1890
testq %rsi, %rsi
je 0x1882
decl %r9d
movl %r9d, (%rsi)
jmp 0x188d
cmpl $0x2, %r9d
pushq $-0x1
popq %rax
cmovgel %eax, %r8d
movl %r8d, %eax
cmpl $-0x5, %edx
jb 0x18a1
cmpl $0x110000, %eax         # imm = 0x110000
jae 0x18a1
movq %rcx, (%rdi)
popq %rcx
retq
movq 0x6730(%rip), %rax      # 0x7fd8
movq (%rax), %rcx
leaq 0x3943(%rip), %rdi      # 0x51f5
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x11e0
pushq $-0x1
popq %rax
jmp 0x189f
// File: /workspace/github_c_makefile_star2_O2/codeniko[P]CS214-Malloc-Free/Test3.c
// Function: main
void main()
{
    int i;
    for(i = 0; i < 5; i++){
        int* p = malloc(sizeof(int));
        *p = i;
        printf("address: %p, value: %d\n",p, *p);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xea3(%rip), %rbx       # 0x2004
pushq $0x4
popq %r14
pushq $0x8
popq %r15
leaq 0xe9c(%rip), %r12       # 0x200c
xorl %r13d, %r13d
cmpl $0x5, %r13d
je 0x119f
movl %r14d, %edi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x11b0
movl %r13d, (%rax)
movq %r12, %rdi
movq %rax, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x1030
incl %r13d
jmp 0x1173
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/bokunimowakaru[P]petit15term/./kbhit.c
// Function: kbhit
int kbhit(void){
    struct termios oldt, newt;
    int ch;
    int oldf;

    tcgetattr(STDIN_FILENO, &oldt);
    newt = oldt;
    newt.c_lflag &= ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, &newt);
    oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
    fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);

    ch = getchar();

    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
    fcntl(STDIN_FILENO, F_SETFL, oldf);

    if (ch != EOF) {
        ungetc(ch, stdin);
        return 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
xorl %ebx, %ebx
leaq 0x44(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x1130
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x2c(%r14), %xmm3
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm1, 0x10(%rdx)
movaps %xmm2, 0x20(%rdx)
movups %xmm3, 0x2c(%rdx)
andb $-0xb, 0xc(%rdx)
xorl %edi, %edi
xorl %esi, %esi
callq 0x1140
pushq $0x3
popq %rsi
xorl %edi, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1070
movl %eax, %r15d
movl %eax, %edx
orl $0x800, %edx            # imm = 0x800
pushq $0x4
popq %r12
xorl %edi, %edi
movl %r12d, %esi
xorl %eax, %eax
callq 0x1070
callq 0x10f0
movl %eax, %ebp
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1140
xorl %edi, %edi
movl %r12d, %esi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1070
cmpl $-0x1, %ebp
je 0x1362
movq 0x2c8b(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
movl %ebp, %edi
callq 0x1120
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bokunimowakaru[P]petit15term/petit15writer.c
// Function: uart_open
int uart_open(char const *device, struct termios *saveattr)
{
    struct termios ComTio;                          // シリアル端末設定用の構造体変数
    speed_t speed = B115200;                        // 通信速度の設定

    ComFd=open(device, O_RDWR|O_NONBLOCK);   // シリアルポートのオープン

    if (ComFd < 0) {
        return -1;
    }
    tcgetattr(ComFd, &ComTio_Bk);           // 現在のシリアル端末設定状態を保存
    ComTio.c_iflag = 0;                     // シリアル入力設定の初期化
    ComTio.c_oflag = 0;                     // シリアル出力設定の初期化
    ComTio.c_cflag = CLOCAL|CREAD|CS8;      // シリアル制御設定の初期化
    ComTio.c_lflag = 0;                     // シリアルローカル設定の初期化
    bzero(ComTio.c_cc,sizeof(ComTio.c_cc)); // シリアル特殊文字設定の初期化
    cfsetispeed(&ComTio, speed);            // シリアル入力の通信速度の設定
    cfsetospeed(&ComTio, speed);            // シリアル出力の通信速度の設定
    ComTio.c_cc[VMIN] = 0;                  // リード待ち容量0バイト(待たない)
    ComTio.c_cc[VTIME] = 1;                 // リード待ち時間
    tcflush(ComFd,TCIFLUSH);                // バッファのクリア
    tcsetattr(ComFd, TCSANOW, &ComTio);     // シリアル端末に設定
    return ComFd;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movl $0x802, %esi            # imm = 0x802
xorl %eax, %eax
callq 0x1150
movl %eax, 0x2d17(%rip)      # 0x40f0
testl %eax, %eax
js 0x1448
leaq 0x2d10(%rip), %rsi      # 0x40f4
movl %eax, %edi
callq 0x1130
movaps 0xc1e(%rip), %xmm0      # 0x2010
movq %rsp, %rbx
movaps %xmm0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x11(%rbx)
movups %xmm0, 0x21(%rbx)
movq %rbx, %rdi
movl $0x1002, %esi           # imm = 0x1002
callq 0x1160
movq %rbx, %rdi
movl $0x1002, %esi           # imm = 0x1002
callq 0x1080
movw $0x1, 0x16(%rbx)
movl 0x2cc7(%rip), %edi      # 0x40f0
xorl %esi, %esi
callq 0x10a0
movl 0x2cba(%rip), %edi      # 0x40f0
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1140
movl 0x2caa(%rip), %eax      # 0x40f0
jmp 0x144b
pushq $-0x1
popq %rax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/bokunimowakaru[P]petit15term/petit15writer.c
// Function: read_serial_port
char read_serial_port(void){
    char c='\0';                                    // シリアル受信した文字の代入用
    fd_set ComReadFds;                              // select命令用構造体ComReadFdを定義
    struct timeval tv;                              // タイムアウト値の保持用
    FD_ZERO(&ComReadFds);                           // ComReadFdの初期化
    FD_SET(ComFd, &ComReadFds);                     // ファイルディスクリプタを設定
    tv.tv_sec=0; tv.tv_usec=10000;                  // 受信のタイムアウト設定(10ms)
    if(select(ComFd+1, &ComReadFds, 0, 0, &tv)) read(ComFd, &c, 1); // データを受信
    usleep(5000);                                   // 5msの(IchigoJam処理)待ち時間
    return c;                                       // 戻り値＝受信データ(文字変数c)
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movb $0x0, 0xf(%rsp)
xorl %eax, %eax
cmpq $0x10, %rax
je 0x1471
andq $0x0, 0x20(%rsp,%rax,8)
incq %rax
jmp 0x1460
movl 0x2c79(%rip), %edi      # 0x40f0
pushq $0x40
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
movslq %eax, %rdx
shll $0x6, %eax
movl %edi, %ecx
subl %eax, %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
orq %rax, 0x20(%rsp,%rdx,8)
leaq 0x10(%rsp), %r8
andq $0x0, (%r8)
movq $0x2710, 0x8(%r8)       # imm = 0x2710
incl %edi
xorl %ebx, %ebx
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1110
testl %eax, %eax
je 0x14d3
movl 0x2c2f(%rip), %edi      # 0x40f0
leaq 0xf(%rsp), %rbx
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x10e0
movb (%rbx), %bl
movl $0x1388, %edi           # imm = 0x1388
callq 0x11a0
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/marcespie[P]unix-samples/lab/pollsig1.c
// Function: main
int
main()
{
	struct pollfd pfd[1];

	int pip[2];
	errwrap(pipe(pip));

	int pid;

	errwrap(pid = fork());
	if (pid == 0) {
		sleep(5);
		fprintf(stderr, "Okay thxbye\n");
		exit(0);
	}

	// now we "wait"
	pfd[0].fd = pip[0];
	pfd[0].events = POLLIN;
	// note that by default this WON'T exit, with SIGCHLD's default
	// behavior.
	int n = poll(pfd, 1, INFTIM);
	if (n == -1 && errno == EINTR) {
		fprintf(stderr, "Everything is okay\n");
	}
}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rdi
callq 0x1040
cmpl $-0x1, %eax
je 0x1221
callq 0x10a0
testl %eax, %eax
je 0x122a
cmpl $-0x1, %eax
je 0x1255
movl 0x8(%rsp), %eax
leaq 0x10(%rsp), %rdi
movl %eax, (%rdi)
movw $0x1, 0x4(%rdi)
pushq $0x1
popq %rsi
pushq $-0x1
popq %rdx
callq 0x1060
cmpl $-0x1, %eax
jne 0x11fc
callq 0x1030
cmpl $0x4, (%rax)
je 0x1203
xorl %eax, %eax
addq $0x18, %rsp
retq
movq 0x2dee(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xe14(%rip), %rdi       # 0x2028
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x1080
jmp 0x11fc
leaq 0xddc(%rip), %rsi       # 0x2004
jmp 0x125c
pushq $0x5
popq %rdi
callq 0x1090
movq 0x2dbf(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xdd8(%rip), %rdi       # 0x201b
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x1080
xorl %edi, %edi
callq 0x1070
leaq 0xdb2(%rip), %rsi       # 0x200e
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1050