LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: add_module
static int add_module(script_t* script, const char* local_path, const char* module_name, const char* code)
{
	// NOTE: This'll slow down add module a bit (but who cares, how many modules could you possibly have :)
	if (local_path)
	{
		for (int i = 0; i < script->modules.length; ++i)
		{
			script_module_t* module = vec_get(&script->modules, i);
			if (module->local_path)
			{
				if (strcmp(module->local_path, local_path) == 0)
					return i;
			}
		}
	}
	
	script_module_t module;
	
	module.start_pc = -1;
	module.end_pc = -1;
	module.name = module_name ? estrdup(module_name) : NULL;
	module.local_path = local_path ? estrdup(local_path) : NULL;
	module.source_code = estrdup(code);
	module.parsed = 0;
	module.compiled = 0;
	
	vec_init(&module.referenced_modules, sizeof(int));

	vec_init(&module.expr_list, sizeof(expr_t*));
	vec_init(&module.compile_time_blocks, sizeof(expr_t*));
	
	vec_init(&module.globals, sizeof(var_decl_t*));
	vec_init(&module.functions, sizeof(func_decl_t*));
	vec_init(&module.all_type_tags, sizeof(type_tag_t*));
	map_init(&module.user_type_tags);

	vec_push_back(&script->modules, &module);
	return script->modules.length - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2118, %rsp           # imm = 0x2118
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
je 0x37a5
leaq 0x2b8(%rbx), %r14
xorl %r13d, %r13d
cmpq %r13, 0x2c8(%rbx)
jbe 0x37a5
movq %r14, %rdi
movq %r13, %rsi
callq 0xc15c
movq 0x40(%rax), %rdi
testq %rdi, %rdi
je 0x37a0
movq %r15, %rsi
callq 0x2150
testl %eax, %eax
je 0x3871
incq %r13
jmp 0x3773
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, -0x2120(%rbp)
testq %r12, %r12
je 0x37c0
movq %r12, %rdi
callq 0x24df
jmp 0x37c2
xorl %eax, %eax
movq %rax, -0x2108(%rbp)
testq %r15, %r15
je 0x37d8
movq %r15, %rdi
callq 0x24df
jmp 0x37da
xorl %eax, %eax
leaq -0x2140(%rbp), %r15
movq %rax, 0x40(%r15)
movq -0x30(%rbp), %rdi
callq 0x24df
movq %rax, 0x30(%r15)
andw $0x0, 0x48(%r15)
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0xbf0c
leaq -0x20f0(%rbp), %rdi
pushq $0x8
popq %r14
movq %r14, %rsi
callq 0xbf0c
leaq -0x20d0(%rbp), %rdi
movq %r14, %rsi
callq 0xbf0c
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0xbf0c
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0xbf0c
leaq -0x20b0(%rbp), %rdi
movq %r14, %rsi
callq 0xbf0c
leaq -0x2090(%rbp), %rdi
callq 0xc418
leaq 0x2b8(%rbx), %rdi
movq %r15, %rsi
callq 0xc1b9
movl 0x2c8(%rbx), %r13d
decl %r13d
movl %r13d, %eax
addq $0x2118, %rsp           # imm = 0x2118
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: parse_program
static void parse_program(script_t* script, vector_t* program)
{
	get_token(1);
	get_next_token();
	
	while(g_cur_tok != TOK_EOF)
	{
		expr_t* e = parse_expr(script);
		if (!e) break;
		vec_push_back(program, &e);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
callq 0x9078
callq 0x9824
cmpl $0x32, 0x10ab6(%rip)    # 0x14360
je 0x38d5
leaq -0x20(%rbp), %r15
movq %r14, %rdi
callq 0x97cd
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x38d5
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc1b9
cmpl $0x32, 0x10a8d(%rip)    # 0x14360
jne 0x38b0
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: script_run
void script_run(script_t* script)
{
	allocate_globals(script);
	vec_clear(&script->stack);
	
	// NOTE: making sure that compile-time externs
	// cannot be called at this point
	g_cur_module_index = -1;
	
	script->pc = 0;
	while(script->pc >= 0)
		script_execute_cycle(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4140
leaq 0x198(%rbx), %rdi
callq 0xc3ea
orl $-0x1, 0x1012c(%rip)    # 0x14248
andl $0x0, 0x11c(%rbx)
xorl %eax, %eax
testl %eax, %eax
js 0x4139
movq %rbx, %rdi
callq 0x41b4
movl 0x11c(%rbx), %eax
jmp 0x4125
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: allocate_globals
static void allocate_globals(script_t* script)
{
	static script_value_t null_val;
	null_val.type = VAL_NULL;

	script_value_t* pv = &null_val;

	int num_globals = 0;
	for (int i = 0; i < script->modules.length; ++i)
	{
		script_module_t* module = vec_get(&script->modules, i);
		num_globals += module->globals.length;
	}

	vec_resize(&script->globals, num_globals, &pv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
andl $0x0, 0x10333(%rip)     # 0x1448c
leaq 0x10320(%rip), %rax     # 0x14480
movq %rax, -0x28(%rbp)
leaq 0x2b8(%rdi), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r15, 0x2c8(%rbx)
jbe 0x4191
movq %r14, %rdi
movq %r15, %rsi
callq 0xc15c
addl 0x2100(%rax), %r12d
incq %r15
jmp 0x4171
addq $0x170, %rbx            # imm = 0x170
movslq %r12d, %rsi
leaq -0x28(%rbp), %rdx
movq %rbx, %rdi
callq 0xc10a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_start
void script_start(script_t* script)
{
	allocate_globals(script);
	vec_clear(&script->stack);
	
	g_cur_module_index = -1;

	script->pc = 0;

	// NOTE: All global code needs to be run at startup
	// because otherwise globals remain uninitialized
	// etc
	while (script->pc >= 0)
		script_execute_cycle(script);
	
	script->pc = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4140
leaq 0x198(%rbx), %rdi
callq 0xc3ea
orl $-0x1, 0xf78e(%rip)     # 0x14248
andl $0x0, 0x11c(%rbx)
xorl %eax, %eax
testl %eax, %eax
js 0x4ad7
movq %rbx, %rdi
callq 0x41b4
movl 0x11c(%rbx), %eax
jmp 0x4ac3
andl $0x0, 0x11c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_get_function_by_name
char script_get_function_by_name(script_t* script, const char* name, script_function_t* function)
{
	for(int i = 0; i < script->function_names.length; ++i)
	{
		char* func_name = vec_get_value(&script->function_names, i, char*);
		if(strcmp(name, func_name) == 0)
		{
			function->index = i;
			function->is_extern = 0;
			return 1;
		}
	}
	
	for(int i = 0; i < script->extern_names.length; ++i)
	{
		char* extern_name = vec_get_value(&script->extern_names, i, char*);
		if(strcmp(name, extern_name) == 0)
		{
			function->index = i;
			function->is_extern = 1;
			return 1;
		}
	}
	
	return 0;
}

// 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 0x278(%rdi), %r13
xorl %r12d, %r12d
cmpq %r12, 0x288(%r15)
jbe 0x51df
movq %r13, %rdi
movq %r12, %rsi
callq 0xc15c
movq (%rax), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
je 0x5218
incq %r12
jmp 0x51b7
movq %rbx, -0x30(%rbp)
leaq 0x238(%r15), %r13
xorl %r12d, %r12d
movq 0x248(%r15), %rbx
cmpq %r12, %rbx
jbe 0x522e
movq %r13, %rdi
movq %r12, %rsi
callq 0xc15c
movq (%rax), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
je 0x5223
incq %r12
jmp 0x51ed
movl %r12d, 0x4(%rbx)
movb $0x0, (%rbx)
movb $0x1, %al
jmp 0x5234
movq -0x30(%rbp), %rax
movl %r12d, 0x4(%rax)
movb $0x1, (%rax)
cmpq %r12, %rbx
seta %al
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/script.c
// Function: script_call_function
void script_call_function(script_t* script, script_function_t function, int nargs)
{
	int depth = script->indir_depth;
	push_stack_frame(script, (word)nargs);
	script->pc = vec_get_value(&script->function_pcs, function.index, int);
	
	while (script->indir_depth > depth && script->pc >= 0)
		script_execute_cycle(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x190(%rdi), %r15d
movzbl %dl, %esi
callq 0x52a4
leaq 0x298(%rbx), %rdi
sarq $0x20, %r14
movq %r14, %rsi
callq 0xc15c
movl (%rax), %eax
movl %eax, 0x11c(%rbx)
cmpl %r15d, 0x190(%rbx)
jle 0x5299
cmpl $0x0, 0x11c(%rbx)
js 0x5299
movq %rbx, %rdi
callq 0x41b4
jmp 0x527d
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_stack_frame
static void push_stack_frame(script_t* script, word nargs)
{
	int i_nargs = (int)nargs;

	vec_push_back(&script->indir, &i_nargs);
	vec_push_back(&script->indir, &script->fp);
	vec_push_back(&script->indir, &script->pc);
	
	script->fp = script->stack.length;
	++script->indir_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x14(%rbp), %rax
movl %esi, (%rax)
leaq 0x1b8(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xc1b9
leaq 0x120(%rbx), %rsi
movq %r14, %rdi
callq 0xc1b9
leaq 0x11c(%rbx), %rsi
movq %r14, %rdi
callq 0xc1b9
movl 0x1a8(%rbx), %eax
movl %eax, 0x120(%rbx)
incl 0x190(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_destroy
void script_destroy(script_t* script)
{
	vec_traverse(&script->modules, destroy_module);
	vec_destroy(&script->modules);
	
	destroy_all_values(script);
	
	vec_destroy(&script->globals);
	
	vec_destroy(&script->code);
	
	vec_destroy(&script->stack);
	vec_destroy(&script->indir);
	
	vec_destroy(&script->numbers);
	
	vec_traverse(&script->strings, destroy_string);
	vec_destroy(&script->strings);
	
	vec_traverse(&script->extern_names, destroy_cstring);
	vec_destroy(&script->extern_names);
	
	vec_destroy(&script->externs);
	
	vec_traverse(&script->function_names, destroy_cstring);
	vec_destroy(&script->function_names);
	
	vec_destroy(&script->function_pcs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2b8(%rdi), %r14
leaq -0x26cd(%rip), %rsi     # 0x2c87
movq %r14, %rdi
callq 0xc3b4
movq %r14, %rdi
callq 0xc3f5
movq %rbx, %rdi
callq 0x2d39
leaq 0x170(%rbx), %rdi
callq 0xc3f5
leaq 0x1d8(%rbx), %rdi
callq 0xc3f5
leaq 0x198(%rbx), %rdi
callq 0xc3f5
leaq 0x1b8(%rbx), %rdi
callq 0xc3f5
leaq 0x1f8(%rbx), %rdi
callq 0xc3f5
leaq 0x218(%rbx), %r14
leaq 0x70(%rip), %rsi        # 0x5426
movq %r14, %rdi
callq 0xc3b4
movq %r14, %rdi
callq 0xc3f5
leaq 0x238(%rbx), %r14
leaq 0x6e(%rip), %r15        # 0x5442
movq %r14, %rdi
movq %r15, %rsi
callq 0xc3b4
movq %r14, %rdi
callq 0xc3f5
leaq 0x258(%rbx), %rdi
callq 0xc3f5
leaq 0x278(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xc3b4
movq %r14, %rdi
callq 0xc3f5
addq $0x298, %rbx            # imm = 0x298
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc3f5
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_unmarshal
static void ext_unmarshal(script_t* script, vector_t* args)
{
	script_value_t* desc_val = script_get_arg(args, 0);
	script_value_t* mem_val = script_get_arg(args, 1);

	const char* desc = desc_val->string.data;
	char* mem = (char*)mem_val->nat.value;
	
	script_value_t* val = unmarshal(script, &desc, &mem);
	if (!val)
	{
		script_push_null(script);
		script_return_top(script);
	}
	else
	{
		push_value(script, val);
		script_return_top(script);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3446
movq 0x28(%r15), %rcx
leaq -0x28(%rbp), %rsi
movq %rcx, (%rsi)
movq 0x20(%rax), %rax
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
movq %rbx, %rdi
callq 0x6c85
movq %rbx, %rdi
testq %rax, %rax
je 0x54aa
movq %rax, %rsi
callq 0x2e40
jmp 0x54af
callq 0x3457
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x346f
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_debug_break
static void ext_debug_break(script_t* script, vector_t* args)
{
	// NOTE: HACK: pop call record off because we want to be
	// in the scope of the enclosing function
	script_call_record_t record = vec_get_value(&script->call_records, script->call_records.length - 1, script_call_record_t);
	pop_call_record(script);

	debug_script(script);
	
	vec_push_back(&script->call_records, &record);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x130(%rdi), %r14
movq 0x140(%rdi), %rsi
decq %rsi
movq %r14, %rdi
callq 0xc15c
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq -0x50(%rbp), %r15
movaps %xmm0, (%r15)
movaps %xmm1, 0x10(%r15)
movaps %xmm2, 0x20(%r15)
movq %rbx, %rdi
callq 0x70ef
movq %rbx, %rdi
callq 0x4ae5
movq %r14, %rdi
movq %r15, %rsi
callq 0xc1b9
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_add_module
static void ext_add_module(script_t* script, vector_t* args)
{
	script_value_t* name_val = script_get_arg(args, 0);
	script_value_t* code_val = script_get_arg(args, 1);
	
	const char* name = name_val->string.data;
	const char* code = code_val->string.data;
	
	script_parse_code(script, code, NULL, name);
	script_push_number(script, script->modules.length - 1);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3446
movq 0x28(%r15), %rcx
movq 0x28(%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3620
movq 0x2c8(%rbx), %rax
decq %rax
movq %rax, %xmm1
punpckldq 0x8102(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x810a(%rip), %xmm1     # 0xd690
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x319c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x346f
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_load_module
static void ext_load_module(script_t* script, vector_t* args)
{
	script_value_t* name_val = script_get_arg(args, 0);
	script_value_t* path_val = script_get_arg(args, 1);

	const char* name = name_val->string.data;
	const char* path = path_val->string.data;

	script_load_parse_file(script, path, name);
	script_push_number(script, script->modules.length - 1);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3446
movq 0x28(%r15), %rdx
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x348b
movq 0x2c8(%rbx), %rax
decq %rax
movq %rax, %xmm1
punpckldq 0x8085(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x808d(%rip), %xmm1     # 0xd690
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x319c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x346f
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_compile_module
static void ext_compile_module(script_t* script, vector_t* args)
{
	append_code(script, OP_HALT);
	
	script_value_t* idx_val = script_get_arg(args, 0);
	int module_index = (int)idx_val->number;
	
	script_module_t* module = vec_get(&script->modules, module_index);
	compile_module(script, module);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x30
popq %rsi
callq 0x7117
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3446
cvttsd2si 0x20(%rax), %eax
leaq 0x2b8(%r14), %rdi
movslq %eax, %rsi
callq 0xc15c
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3934
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_run_module
static void ext_run_module(script_t* script, vector_t* args)
{
	script_value_t* idx_val = script_get_arg(args, 0);
	int module_index = (int)idx_val->number;
	
	script_module_t* module = vec_get(&script->modules, module_index);

	if(!module->compiled)
		error_exit_script(script, "Attempting to run an uncompiled module '%s'\n", module->name);

	int pc = script->pc;
	script->pc = module->start_pc;
	
	while (script->pc >= 0 && script->pc < module->end_pc)
		script_execute_cycle(script);

	script->pc = pc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
cvttsd2si 0x20(%rax), %eax
leaq 0x2b8(%rbx), %rdi
movslq %eax, %rsi
callq 0xc15c
movq %rax, %r14
cmpb $0x0, 0x49(%rax)
je 0x56de
movl 0x11c(%rbx), %r15d
movl 0x20(%r14), %eax
movl %eax, 0x11c(%rbx)
testl %eax, %eax
js 0x56cc
movl %eax, %eax
cmpq %rax, 0x28(%r14)
jbe 0x56cc
movq %rbx, %rdi
callq 0x41b4
movl 0x11c(%rbx), %eax
jmp 0x56b0
movl %r15d, 0x11c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%r14), %rdx
leaq 0x84f4(%rip), %rsi      # 0xdbdd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_get_module_source_code
static void ext_get_module_source_code(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("get_module_source_code");
	
	script_value_t* val = script_get_arg(args, 0);
	int module_index = (int)val->number;
	
	script_module_t* module = vec_get(&script->modules, module_index);
	script_push_cstr(script, module->source_code);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xeb20(%rip)      # 0x14248
js 0x5762
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
cvttsd2si 0x20(%rax), %eax
leaq 0x2b8(%rbx), %rdi
movslq %eax, %rsi
callq 0xc15c
movq 0x30(%rax), %rsi
movq %rbx, %rdi
callq 0x320c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x84f0(%rip), %rsi      # 0xdc59
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_get_expr_kind
static void ext_get_expr_kind(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("get_expr_kind");
	
	script_value_t* exp_val = script_get_arg(args, 0);
	expr_t* exp = exp_val->nat.value;
	
	script_push_number(script, exp->type);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe925(%rip)      # 0x14248
js 0x5951
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq 0x20(%rax), %rax
movl 0x28(%rax), %eax
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
callq 0x319c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x83c1(%rip), %rsi      # 0xdd19
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_create_bool_type
static void ext_create_bool_type(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("create_bool_type");

	g_file = script->cur_file;
	g_line = script->cur_line;
	
	script_push_native(script, create_type_tag(script, TAG_BOOL), NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe8d6(%rip)      # 0x14248
js 0x59b6
movq 0x128(%rbx), %rax
movq %rax, 0xe7d6(%rip)      # 0x14158
movl 0x124(%rbx), %eax
movl %eax, 0xe7c2(%rip)      # 0x14150
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x731e
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x83a0(%rip), %rsi      # 0xdd5d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_create_char_type
static void ext_create_char_type(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("create_char_type");

	g_file = script->cur_file;
	g_line = script->cur_line;

	script_push_native(script, create_type_tag(script, TAG_CHAR), NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe871(%rip)      # 0x14248
js 0x5a1b
movq 0x128(%rbx), %rax
movq %rax, 0xe771(%rip)      # 0x14158
movl 0x124(%rbx), %eax
movl %eax, 0xe75d(%rip)      # 0x14150
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x731e
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x8382(%rip), %rsi      # 0xdda4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_create_number_type
static void ext_create_number_type(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("create_number_type");

	g_file = script->cur_file;
	g_line = script->cur_line;

	script_push_native(script, create_type_tag(script, TAG_NUMBER), NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe80c(%rip)      # 0x14248
js 0x5a80
movq 0x128(%rbx), %rax
movq %rax, 0xe70c(%rip)      # 0x14158
movl 0x124(%rbx), %eax
movl %eax, 0xe6f8(%rip)      # 0x14150
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x731e
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x8364(%rip), %rsi      # 0xddeb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_create_string_type
static void ext_create_string_type(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("create_string_type");

	g_file = script->cur_file;
	g_line = script->cur_line;

	script_push_native(script, create_type_tag(script, TAG_STRING), NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe7a7(%rip)      # 0x14248
js 0x5ae5
movq 0x128(%rbx), %rax
movq %rax, 0xe6a7(%rip)      # 0x14158
movl 0x124(%rbx), %eax
movl %eax, 0xe693(%rip)      # 0x14150
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x731e
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x8348(%rip), %rsi      # 0xde34
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_create_function_type
static void ext_create_function_type(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("create_function_type");

	g_file = script->cur_file;
	g_line = script->cur_line;

	script_value_t* return_type_val = script_get_arg(args, 0);
	script_value_t* arg_types_val = script_get_arg(args, 1);
	
	type_tag_t* tag = create_type_tag(script, TAG_FUNC);
	tag->func.return_type = return_type_val->nat.value;
	for(int i = 0; i < arg_types_val->array.length; ++i)
	{
		script_value_t* arg_type_val = vec_get_value(&arg_types_val->array, i, script_value_t*);
		type_tag_t* arg_tag = arg_type_val->nat.value;
		
		vec_push_back(&tag->func.arg_types, &arg_tag);
	}
	
	script_push_native(script, tag, NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
cmpl $0x0, 0xe737(%rip)      # 0x14248
js 0x5bd9
movq %rsi, %rbx
movq 0x128(%r12), %rax
movq %rax, 0xe62f(%rip)      # 0x14158
movl 0x124(%r12), %eax
movl %eax, 0xe619(%rip)      # 0x14150
xorl %r14d, %r14d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3446
movq %rax, %rbx
pushq $0x6
popq %rsi
movq %r12, -0x38(%rbp)
movq %r12, %rdi
callq 0x731e
movq %rax, %r13
movq 0x20(%r15), %rax
movq %rax, 0x48(%r13)
movq %r13, -0x30(%rbp)
addq $0x28, %r13
movq %rbx, %r15
addq $0x20, %r15
leaq -0x40(%rbp), %r12
cmpq %r14, 0x30(%rbx)
jbe 0x5bae
movq %r15, %rdi
movq %r14, %rsi
callq 0xc15c
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq %r13, %rdi
movq %r12, %rsi
callq 0xc1b9
incq %r14
jmp 0x5b82
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
callq 0x346f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x829d(%rip), %rsi      # 0xde7d
movq %r12, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_create_array_type
static void ext_create_array_type(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("create_array_type");

	g_file = script->cur_file;
	g_line = script->cur_line;

	script_value_t* contained_val = script_get_arg(args, 0);
	type_tag_t* contained = contained_val->nat.value;
	
	type_tag_t* array = create_type_tag(script, TAG_ARRAY);
	array->contained = contained;
	
	script_push_native(script, array, NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xe64d(%rip)      # 0x14248
js 0x5c4f
movq 0x128(%rbx), %rax
movq %rax, 0xe54d(%rip)      # 0x14158
movl 0x124(%rbx), %eax
movl %eax, 0xe539(%rip)      # 0x14150
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq 0x20(%rax), %r14
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x731e
movq %r14, 0x28(%rax)
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x346f
leaq 0x8272(%rip), %rsi      # 0xdec8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_create_native_type
static void ext_create_native_type(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("create_native_type");

	g_file = script->cur_file;
	g_line = script->cur_line;

	script_push_native(script, create_type_tag(script, TAG_NATIVE), NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe5d8(%rip)      # 0x14248
js 0x5cb4
movq 0x128(%rbx), %rax
movq %rax, 0xe4d8(%rip)      # 0x14158
movl 0x124(%rbx), %eax
movl %eax, 0xe4c4(%rip)      # 0x14150
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x731e
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x8255(%rip), %rsi      # 0xdf10
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_create_dynamic_type
static void ext_create_dynamic_type(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("create_dynamic_type");

	g_file = script->cur_file;
	g_line = script->cur_line;

	script_push_native(script, create_type_tag(script, TAG_DYNAMIC), NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe573(%rip)      # 0x14248
js 0x5d19
movq 0x128(%rbx), %rax
movq %rax, 0xe473(%rip)      # 0x14158
movl 0x124(%rbx), %eax
movl %eax, 0xe45f(%rip)      # 0x14150
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x731e
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x8239(%rip), %rsi      # 0xdf59
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_create_void_type
static void ext_create_void_type(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("create_void_type");

	g_file = script->cur_file;
	g_line = script->cur_line;

	script_push_native(script, create_type_tag(script, TAG_VOID), NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe50e(%rip)      # 0x14248
js 0x5d7d
movq 0x128(%rbx), %rax
movq %rax, 0xe40e(%rip)      # 0x14158
movl 0x124(%rbx), %eax
movl %eax, 0xe3fa(%rip)      # 0x14150
movq %rbx, %rdi
xorl %esi, %esi
callq 0x731e
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x821f(%rip), %rsi      # 0xdfa3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_compare_types
static void ext_compare_types(script_t* script, vector_t* args)
{
	script_value_t* a_val = script_get_arg(args, 0);
	script_value_t* b_val = script_get_arg(args, 1);
	
	type_tag_t* a = a_val->nat.value;
	type_tag_t* b = b_val->nat.value;

	script_push_bool(script, compare_type_tags(a, b));
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3446
movq 0x20(%r15), %rdi
movq 0x20(%rax), %rsi
callq 0x73f5
movsbl %al, %esi
movq %r14, %rdi
callq 0x2e02
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x346f
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_get_array_type_contained_type
static void ext_get_array_type_contained_type(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("get_array_type_contained_type");

	script_value_t* type_val = script_get_arg(args, 0);
	type_tag_t* array_tag = type_val->nat.value;

	script_push_native(script, array_tag->contained, NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe458(%rip)      # 0x14248
js 0x5e1e
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq 0x20(%rax), %rax
movq 0x28(%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x8323(%rip), %rsi      # 0xe148
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_reference_func
static void ext_reference_func(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("reference_func");
	
	script_value_t* name_val = script_get_arg(args, 0);
	const char* name = name_val->string.data;
	
	func_decl_t* decl = reference_function(script, name);
	if(decl)
		script_push_native(script, decl, NULL, NULL);
	else
		script_push_null(script);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe409(%rip)      # 0x14248
js 0x5e80
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x760e
movq %rbx, %rdi
testq %rax, %rax
je 0x5e6d
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
jmp 0x5e72
callq 0x3457
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x8315(%rip), %rsi      # 0xe19c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_get_func_decl_name
static void ext_get_func_decl_name(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("get_func_decl_name");
	
	script_value_t* decl_val = script_get_arg(args, 0);
	func_decl_t* decl = decl_val->nat.value;
	
	script_push_cstr(script, decl->name);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe3a7(%rip)      # 0x14248
js 0x5ecb
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq 0x20(%rax), %rax
movq 0x18(%rax), %rsi
movq %rbx, %rdi
callq 0x320c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x346f
leaq 0x830f(%rip), %rsi      # 0xe1e1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_declare_variable
static void ext_declare_variable(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("declare_variable");
	
	script_value_t* name_val = script_get_arg(args, 0);
	script_value_t* type_val = script_get_arg(args, 1);
	script_value_t* func_decl_val = script_get_arg(args, 2);
	script_value_t* scope_val = script_get_arg(args, 3);
	
	const char* name = name_val->string.data;
	type_tag_t* tag = type_val->nat.value;
	func_decl_t* decl = NULL;
	int scope = 0;
	
	if(func_decl_val->type != VAL_NULL)
	{
		decl = func_decl_val->nat.value;
		scope = (int)scope_val->number;
	}

	g_cur_func = decl;
	g_scope = scope;
	
	script_push_native(script, declare_variable(script, name, tag), NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe354(%rip)      # 0x14248
js 0x5f8a
movq %rsi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r12
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3446
movq %rax, %r13
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x3446
movq %rax, %r15
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x3446
movq 0x28(%r12), %rsi
movq 0x20(%r13), %rdx
cmpl $0x0, 0xc(%r15)
je 0x5f4c
movq 0x20(%r15), %rcx
cvttsd2si 0x20(%rax), %eax
jmp 0x5f50
xorl %ecx, %ecx
xorl %eax, %eax
movq %rcx, 0xe301(%rip)      # 0x14258
movl %eax, 0xe2f3(%rip)      # 0x14250
movq %rbx, %rdi
callq 0x76ab
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x346f
leaq 0x8299(%rip), %rsi      # 0xe22a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_reference_variable
static void ext_reference_variable(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("reference_variable");
	
	script_value_t* name_val = script_get_arg(args, 0);
	script_value_t* func_decl_val = script_get_arg(args, 1);
	script_value_t* scope_val = script_get_arg(args, 2);
	
	const char* name = name_val->string.data;
	func_decl_t* decl = NULL;
	int scope = 0;
	
	if(func_decl_val->type != VAL_NULL)
	{
		decl = func_decl_val->nat.value;
		scope = (int)scope_val->number;
	}

	g_cur_func = decl;
	g_scope = scope;
	
	var_decl_t* vdecl = reference_variable(script, name);
	if(!vdecl)
		error_exit_script(script, "Attempted to reference non-existent variable '%s'\n", name);
	else
		script_push_native(script, vdecl, NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe295(%rip)      # 0x14248
js 0x6042
movq %rsi, %r14
xorl %r13d, %r13d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r12
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3446
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x3446
movq 0x28(%r12), %r14
cmpl $0x0, 0xc(%r15)
je 0x5ffd
movq 0x20(%r15), %rcx
cvttsd2si 0x20(%rax), %r13d
jmp 0x5fff
xorl %ecx, %ecx
movq %rcx, 0xe252(%rip)      # 0x14258
movl %r13d, 0xe243(%rip)     # 0x14250
movq %rbx, %rdi
movq %r14, %rsi
callq 0x77b1
testq %rax, %rax
je 0x6053
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x346f
leaq 0x8266(%rip), %rsi      # 0xe2af
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
leaq 0x829e(%rip), %rsi      # 0xe2f8
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_parse_code
static void ext_parse_code(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("parse_code");
	
	script_module_t* module = vec_get(&script->modules, g_cur_module_index);
	script_value_t* code_val = script_get_arg(args, 0);
	
	const char* code = code_val->string.data;

	g_file = "parse_code";
	g_code = code;
	g_line = 1;

	vector_t expr_list;
	vec_init(&expr_list, sizeof(expr_t*));

	parse_program(script, &expr_list);

	vector_t expr_nat_list;
	vec_init(&expr_nat_list, sizeof(script_value_t*));

	for (int i = 0; i < expr_list.length; ++i)
	{
		expr_t* exp = vec_get_value(&expr_list, i, expr_t*);

		script_value_t* val = new_value(script, VAL_NATIVE);
		
		val->nat.on_mark = NULL;
		val->nat.on_delete = NULL;
		
		val->nat.value = exp;

		vec_push_back(&expr_nat_list, &val);
	}

	vec_destroy(&expr_list);

	script_push_premade_array(script, expr_nat_list);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movslq 0xe1c3(%rip), %rsi      # 0x14248
testq %rsi, %rsi
js 0x6175
leaq 0x2b8(%rbx), %rdi
callq 0xc15c
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x3446
movq 0x28(%rax), %rax
leaq 0x78db(%rip), %rcx      # 0xd98d
movq %rcx, 0xe09f(%rip)      # 0x14158
movq %rax, 0xe180(%rip)      # 0x14240
movl $0x1, 0xe086(%rip)      # 0x14150
leaq -0x70(%rbp), %r12
pushq $0x8
popq %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0xbf0c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3886
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0xbf0c
pushq $0x8
popq %r13
leaq -0x30(%rbp), %r15
cmpq %r14, -0x60(%rbp)
jbe 0x613c
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0xc15c
movq (%rax), %r12
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2fb8
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %r12, 0x20(%rax)
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0xc1b9
incq %r14
jmp 0x60fc
leaq -0x70(%rbp), %rdi
callq 0xc3f5
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x335a
movq %rbx, %rdi
callq 0x346f
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x81af(%rip), %rsi      # 0xe32b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_make_num_expr
static void ext_make_num_expr(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("make_num_expr");
	
	script_value_t* val = script_get_arg(args, 0);
	double number = val->number;
	
	expr_t* exp = create_expr(EXP_NUMBER);
	exp->number_index = register_number(script, number);
	
	script_push_native(script, exp, NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0xe0ad(%rip)      # 0x14248
js 0x61ec
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
pushq $0x9
popq %rdi
callq 0x7994
movq %rax, %r14
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x79de
movl %eax, 0x38(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x346f
leaq 0x8179(%rip), %rsi      # 0xe36c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_make_string_expr
static void ext_make_string_expr(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("make_num_expr");
	
	script_value_t* val = script_get_arg(args, 0);
	const char* string = val->string.data;
	
	expr_t* exp = create_expr(EXP_STRING);
	exp->string_index = register_string(script, string);
	
	script_push_native(script, exp, NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe037(%rip)      # 0x14248
js 0x625c
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq 0x28(%rax), %r14
pushq $0xa
popq %rdi
callq 0x7994
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7a4c
movl %eax, 0x38(%r15)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x346f
leaq 0x8109(%rip), %rsi      # 0xe36c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_make_var_expr
static void ext_make_var_expr(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("make_var_expr");
	
	script_value_t* decl_val = script_get_arg(args, 0);
	var_decl_t* decl = decl_val->nat.value;
	
	expr_t* exp = create_expr(EXP_VAR);
	
	exp->varx.decl = decl;
	exp->varx.name = estrdup(decl->name);
	
	script_push_native(script, exp, NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xdfc7(%rip)      # 0x14248
js 0x62ce
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq 0x20(%rax), %r15
pushq $0x5
popq %rdi
callq 0x7994
movq %rax, %r14
movq %r15, 0x40(%rax)
movq 0x10(%r15), %rdi
callq 0x24df
movq %rax, 0x38(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x346f
leaq 0x80db(%rip), %rsi      # 0xe3b0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_make_undeclared_var_expr
static void ext_make_undeclared_var_expr(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("make_undeclared_var_expr");
	
	script_value_t* name_val = script_get_arg(args, 0);
	expr_t* exp = create_expr(EXP_VAR);
	
	exp->varx.decl = NULL;
	exp->varx.name = estrdup(name_val->string.data);
	
	script_push_native(script, exp, NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xdf55(%rip)      # 0x14248
js 0x6340
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r14
pushq $0x5
popq %rdi
callq 0x7994
movq %rax, %r15
andq $0x0, 0x40(%rax)
movq 0x28(%r14), %rdi
callq 0x24df
movq %rax, 0x38(%r15)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x346f
leaq 0x80ad(%rip), %rsi      # 0xe3f4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_make_write_expr
static void ext_make_write_expr(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("make_write_expr");
	
	script_value_t* val = script_get_arg(args, 0);
	
	expr_t* exp = create_expr(EXP_WRITE);
	exp->write = val->nat.value;
	
	script_push_native(script, exp, NULL, NULL);
	script_return_top(script); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xdee6(%rip)      # 0x14248
js 0x639c
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r14
pushq $0xc
popq %rdi
callq 0x7994
movq 0x20(%r14), %rcx
movq %rcx, 0x38(%rax)
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x346f
leaq 0x80a0(%rip), %rsi      # 0xe443
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_make_bin_expr
static void ext_make_bin_expr(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("make_bin_expr");
	
	script_value_t* lhs_val = script_get_arg(args, 0);
	script_value_t* rhs_val = script_get_arg(args, 1);
	script_value_t* op_val = script_get_arg(args, 2);

	expr_t* lhs = lhs_val->nat.value;
	expr_t* rhs = rhs_val->nat.value;
	const char* op = op_val->string.data;
	
	expr_t* exp = create_expr(EXP_BINARY);
	exp->binx.lhs = lhs;
	exp->binx.rhs = rhs;
	
	if(strcmp(op, "=") == 0) exp->binx.op = TOK_ASSIGN;
	else error_exit_script(script, "Invalid operator '%s' given to 'make_bin_expr'\n", op);
	
	script_push_native(script, exp, NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xde86(%rip)      # 0x14248
js 0x6455
movq %rsi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3446
movq %rax, %r12
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x3446
movq 0x20(%r15), %r15
movq 0x20(%r12), %r12
movq 0x28(%rax), %r14
pushq $0xe
popq %rdi
callq 0x7994
movq %r15, 0x38(%rax)
movq %r12, 0x40(%rax)
cmpb $0x3d, (%r14)
jne 0x6441
cmpb $0x0, 0x1(%r14)
jne 0x6441
movl $0x24, 0x48(%rax)
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x346f
leaq 0x8085(%rip), %rsi      # 0xe4cd
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2ec0
leaq 0x802d(%rip), %rsi      # 0xe489
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_make_call_expr
static void ext_make_call_expr(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("make_call_expr");
	
	script_value_t* func_val = script_get_arg(args, 0);
	script_value_t* args_val = script_get_arg(args, 1);
	
	expr_t* exp = create_expr(EXP_CALL);
	vec_init(&exp->callx.args, sizeof(expr_t*));
	exp->callx.func = func_val->nat.value;
	
	for(int i = 0; i < args_val->array.length; ++i)
	{
		script_value_t* arg_exp_val = vec_get_value(&args_val->array, i, script_value_t*);
		vec_push_back(&exp->callx.args, &arg_exp_val->nat.value);
	}
	
	script_push_native(script, exp, NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
cmpl $0x0, 0xddc9(%rip)      # 0x14248
js 0x651e
movq %rsi, %rbx
xorl %r14d, %r14d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3446
movq %rax, %rbx
pushq $0xf
popq %rdi
callq 0x7994
movq %rax, %r12
leaq 0x40(%rax), %r13
pushq $0x8
popq %rsi
movq %r13, %rdi
callq 0xbf0c
movq 0x20(%r15), %rax
movq %rax, 0x38(%r12)
movq %rbx, %r15
addq $0x20, %r15
cmpq %r14, 0x30(%rbx)
jbe 0x64f5
movq %r15, %rdi
movq %r14, %rsi
callq 0xc15c
movq (%rax), %rsi
addq $0x20, %rsi
movq %r13, %rdi
callq 0xc1b9
incq %r14
jmp 0x64d0
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x346f
leaq 0x7fd8(%rip), %rsi      # 0xe4fd
movq -0x30(%rbp), %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: ext_make_array_index_expr
static void ext_make_array_index_expr(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("make_array_index_expr");
	
	script_value_t* array_exp_val = script_get_arg(args, 0);
	script_value_t* index_exp_val = script_get_arg(args, 1);
	
	expr_t* exp = create_expr(EXP_ARRAY_INDEX);
	exp->array_index.array = array_exp_val->nat.value;
	exp->array_index.index = index_exp_val->nat.value;
	
	script_push_native(script, exp, NULL, NULL);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xdd04(%rip)      # 0x14248
js 0x659d
movq %rsi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3446
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3446
movq %rax, %r14
pushq $0x6
popq %rdi
callq 0x7994
movq 0x20(%r15), %rcx
movq %rcx, 0x38(%rax)
movq 0x20(%r14), %rcx
movq %rcx, 0x40(%rax)
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x33ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x346f
leaq 0x7f9e(%rip), %rsi      # 0xe542
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0