LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: error_exit_script
static void error_exit_script(script_t* script, const char* fmt, ...)
{
	fprintf(stderr, "\nError (%s:%i):\n", script->cur_file, script->cur_line);
	
	va_list args;
	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);
	
	fprintf(stderr, "\n");
	print_stack_trace(script);
	
	debug_script(script);

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3238
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)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x16d95(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x124(%rax), %ecx
leaq 0x110de(%rip), %rsi     # 0x14360
movb $0x0, %al
callq 0x2150
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x16d44(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x21e0
leaq -0x30(%rbp), %rax
movq 0x16d29(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0x11b63(%rip), %rsi     # 0x14e3c
movb $0x0, %al
callq 0x2150
movq -0x8(%rbp), %rdi
callq 0xc210
movq -0x8(%rbp), %rdi
callq 0x4cf0
movl $0x1, %edi
callq 0x2210
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: new_value
static script_value_t* new_value(script_t* script, script_value_type_t type)
{
	if(!script->in_extern && script->num_objects >= script->max_objects_until_gc) collect_garbage(script); 
	
	script_value_t* val = get_heap_value(script);
	
	val->marked = 0;
	val->type = type;
	
	val->next = script->gc_head;
	script->gc_head = val;
	
	++script->num_objects;
	
	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x119(%rax)
jne 0x338b
movq -0x8(%rbp), %rax
movl 0x168(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x16c(%rcx), %eax
jl 0x338b
movq -0x8(%rbp), %rdi
callq 0xc680
movq -0x8(%rbp), %rdi
callq 0xc6c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x158(%rax)
movq -0x8(%rbp), %rax
movl 0x168(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x168(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: script_pop_char
char script_pop_char(script_t* script)
{
	script_value_t* val = pop_value(script);
	if(val->type != VAL_CHAR)
		error_exit_script(script, "Expected char but received %s\n", g_value_types[val->type]);

	return val->code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3090
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0xc(%rax)
je 0x3439
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %ecx
leaq 0x16d19(%rip), %rax     # 0x1a140
movq (%rax,%rcx,8), %rdx
leaq 0x10342(%rip), %rsi     # 0x13774
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rax
movb 0x20(%rax), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: script_pop_number
double script_pop_number(script_t* script)
{
	script_value_t* val = pop_value(script);
	if(val->type != VAL_NUMBER)
		error_exit_script(script, "Expected number but received %s\n", g_value_types[val->type]);
	
	return val->number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3090
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0xc(%rax)
je 0x34e9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %ecx
leaq 0x16c69(%rip), %rax     # 0x1a140
movq (%rax,%rcx,8), %rdx
leaq 0x102b1(%rip), %rsi     # 0x13793
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: script_push_cstr
void script_push_cstr(script_t* script, const char* string)
{
	script_value_t* val = new_value(script, VAL_STRING);
	val->string.length = strlen(string);
	val->string.data = emalloc(val->string.length + 1);
	strcpy(val->string.data, string);
	
	push_value(script, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x3350
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3580
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2050
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: script_push_string
void script_push_string(script_t* script, script_string_t string)
{
	script_value_t* val = new_value(script, VAL_STRING);
	val->string.length = string.length;
	val->string.data = emalloc(string.length + 1);
	strcpy(val->string.data, string.data);
	
	push_value(script, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x3350
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3580
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: script_pop_string
script_string_t script_pop_string(script_t* script)
{
	script_value_t* val = pop_value(script);
	if (val->type != VAL_STRING)
		error_exit_script(script, "Expected string but received %s\n", g_value_types[val->type]);
	return val->string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3090
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, 0xc(%rax)
je 0x3679
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %ecx
leaq 0x16ad9(%rip), %rax     # 0x1a140
movq (%rax,%rcx,8), %rdx
leaq 0x10142(%rip), %rsi     # 0x137b4
movb $0x0, %al
callq 0x3200
movq -0x20(%rbp), %rax
movups 0x20(%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: script_push_array
void script_push_array(script_t* script, size_t length)
{
	script_value_t* val = new_value(script, VAL_ARRAY);
	vec_init(&val->array, sizeof(script_value_t*));
	vec_reserve(&val->array, length);
	push_value(script, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x3350
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movl $0x8, %esi
callq 0x114e0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x117c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: script_push_native
void script_push_native(script_t* script, void* value, script_native_callback_t on_mark, script_native_callback_t on_delete)
{
	script_value_t* val = new_value(script, VAL_NATIVE);
	val->nat.value = value;
	val->nat.on_mark = on_mark;
	val->nat.on_delete = on_delete;
	push_value(script, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x3350
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3140
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: script_load_parse_file
void script_load_parse_file(script_t* script, const char* filename, const char* module_name)
{
	FILE* in = fopen(filename, "rb");
	
	if (!in)
		error_exit("Failed to open file '%s'\n", filename);
	
	script_parse_file(script, in, filename, module_name);

	fclose(in);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xfed7(%rip), %rsi      # 0x13816
callq 0x21d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3961
movq -0x10(%rbp), %rsi
leaq 0xfebf(%rip), %rdi      # 0x13819
movb $0x0, %al
callq 0x3990
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x3a50
movq -0x20(%rbp), %rdi
callq 0x2090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.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
subq $0xd0, %rsp
testb %al, %al
je 0x39c5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x16605(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0x114b3(%rip), %rsi     # 0x14eb0
movb $0x0, %al
callq 0x2150
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x165c9(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x21e0
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x2210
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: script_parse_file
void script_parse_file(script_t* script, FILE* in, const char* local_path, const char* module_name)
{
	fseek(in, 0, SEEK_END);
	size_t length = ftell(in);
	fseek(in, 0, SEEK_SET);
	
	char* str = emalloc(length + 1);
	fread(str, sizeof(char), length, in);
	str[length] = '\0';
	
	rewind(in);
	
	script_parse_code(script, str, local_path, module_name);
	
	free(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21a0
movq -0x10(%rbp), %rdi
callq 0x2160
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x21a0
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x3580
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x2070
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x20d0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3b00
movq -0x30(%rbp), %rdi
callq 0x2030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
callq 0xca60
callq 0xd640
cmpl $0x32, 0x166ea(%rip)    # 0x1a5b0
je 0x3eed
movq -0x8(%rbp), %rdi
callq 0xd5a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3ede
jmp 0x3eed
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11960
jmp 0x3ebf
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4b60
movq -0x8(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0x11da0
movl $0xffffffff, 0x15969(%rip) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x11c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x11c(%rax)
jl 0x4b55
movq -0x8(%rbp), %rdi
callq 0x4c00
jmp 0x4b3d
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, 0x15b66(%rip)     # 0x1a6dc
leaq 0x15b53(%rip), %rax     # 0x1a6d0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2c8(%rcx), %rax
jae 0x4bd8
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq -0x18(%rbp), %rsi
callq 0x11890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x2100(%rax), %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4b8f
movq -0x8(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
movslq -0x14(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x11800
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: script_execute_cycle
void script_execute_cycle(script_t* script)
{
	if (script->debug_env.step && 
		(script->cur_line != script->debug_env.step_line ||
		 strcmp(script->cur_file, script->debug_env.step_file) != 0))
	{
		script->debug_env.step = 0;
		debug_script(script);
	}

	execute_cycle(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x114(%rax), %eax
cmpl $0x0, %eax
je 0x4c66
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x110(%rcx), %eax
jne 0x4c52
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rsi
callq 0x2130
cmpl $0x0, %eax
je 0x4c66
movq -0x8(%rbp), %rax
movb $0x0, 0x114(%rax)
movq -0x8(%rbp), %rdi
callq 0x4cf0
movq -0x8(%rbp), %rdi
callq 0x56a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4b60
movq -0x8(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0x11da0
movl $0xffffffff, 0x157e9(%rip) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x11c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x11c(%rax)
jl 0x4cd5
movq -0x8(%rbp), %rdi
callq 0x4c00
jmp 0x4cbd
movq -0x8(%rbp), %rax
movl $0x0, 0x11c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x288(%rcx), %rax
jae 0x663d
movq -0x10(%rbp), %rdi
addq $0x278, %rdi            # imm = 0x278
movslq -0x24(%rbp), %rsi
callq 0x11890
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x6630
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x66aa
jmp 0x6632
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x65db
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x248(%rcx), %rax
jae 0x66a6
movq -0x10(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
movslq -0x34(%rbp), %rsi
callq 0x11890
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x6699
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x66aa
jmp 0x669b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6644
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x190(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x6750
movq -0x10(%rbp), %rdi
addq $0x298, %rdi            # imm = 0x298
movslq -0x4(%rbp), %rsi
callq 0x11890
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x11c(%rax)
movq -0x10(%rbp), %rax
movl 0x190(%rax), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x19(%rbp)
jle 0x6734
movq -0x10(%rbp), %rax
cmpl $0x0, 0x11c(%rax)
setge %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x673d
jmp 0x6748
movq -0x10(%rbp), %rdi
callq 0x4c00
jmp 0x670f
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
leaq -0x10(%rbp), %rsi
callq 0x11960
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
movq -0x8(%rbp), %rsi
addq $0x120, %rsi            # imm = 0x120
callq 0x11960
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
movq -0x8(%rbp), %rsi
addq $0x11c, %rsi            # imm = 0x11C
callq 0x11960
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x120(%rax)
movq -0x8(%rbp), %rax
movl 0x190(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x190(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
leaq -0x399e(%rip), %rsi     # 0x2ec0
callq 0x11d40
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
callq 0x11dc0
movq -0x8(%rbp), %rdi
callq 0x2fc0
movq -0x8(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x11dc0
movq -0x8(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x11dc0
movq -0x8(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0x11dc0
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
callq 0x11dc0
movq -0x8(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
callq 0x11dc0
movq -0x8(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
leaq 0x92(%rip), %rsi        # 0x6970
callq 0x11d40
movq -0x8(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
callq 0x11dc0
movq -0x8(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
leaq 0xab(%rip), %rsi        # 0x69b0
callq 0x11d40
movq -0x8(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
callq 0x11dc0
movq -0x8(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
callq 0x11dc0
movq -0x8(%rbp), %rdi
addq $0x278, %rdi            # imm = 0x278
leaq 0x74(%rip), %rsi        # 0x69b0
callq 0x11d40
movq -0x8(%rbp), %rdi
addq $0x278, %rdi            # imm = 0x278
callq 0x11dc0
movq -0x8(%rbp), %rdi
addq $0x298, %rdi            # imm = 0x298
callq 0x11dc0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3890
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x8b90
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6a59
movq -0x8(%rbp), %rdi
callq 0x38c0
movq -0x8(%rbp), %rdi
callq 0x38f0
jmp 0x6a6f
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3140
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movq -0x8(%rbp), %rax
movq 0x140(%rax), %rsi
subq $0x1, %rsi
callq 0x11890
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movl $0x30, %edx
callq 0x2180
movq -0x8(%rbp), %rdi
callq 0x9440
movq -0x8(%rbp), %rdi
callq 0x4cf0
movq -0x8(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
leaq -0x40(%rbp), %rsi
callq 0x11960
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl %esi, -0x34(%rbp)
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3890
movq %rax, %rcx
movl -0x34(%rbp), %eax
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl %eax, %edx
callq 0x3b00
movq -0x8(%rbp), %rdi
movq 0x2c8(%rdi), %rax
decq %rax
movq %rax, %xmm0
movaps 0xcbb1(%rip), %xmm1     # 0x13720
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xcbb5(%rip), %xmm1     # 0x13730
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x3450
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3890
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3920
movq -0x8(%rbp), %rdi
movq 0x2c8(%rdi), %rax
decq %rax
movq %rax, %xmm0
movaps 0xcb0c(%rip), %xmm1     # 0x13720
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xcb10(%rip), %xmm1     # 0x13730
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x3450
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x30, %esi
callq 0x9480
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cvttsd2si 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq -0x1c(%rbp), %rsi
callq 0x11890
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3f80
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cvttsd2si 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq -0x1c(%rbp), %rsi
callq 0x11890
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, 0x49(%rax)
jne 0x6d27
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdx
leaq 0xcf7f(%rip), %rsi      # 0x13c9f
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x11c(%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x11c(%rcx)
movb %al, -0x2d(%rbp)
jl 0x6d73
movq -0x8(%rbp), %rax
movslq 0x11c(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x28(%rcx), %rax
setb %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x6d7c
jmp 0x6d87
movq -0x8(%rbp), %rdi
callq 0x4c00
jmp 0x6d48
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x11c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x13691(%rip)     # 0x1a498
jge 0x6e1b
movq -0x8(%rbp), %rdi
leaq 0xcf07(%rip), %rsi      # 0x13d1b
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cvttsd2si 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq -0x1c(%rbp), %rsi
callq 0x11890
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x3500
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x133f1(%rip)     # 0x1a498
jge 0x70bb
movq -0x8(%rbp), %rdi
leaq 0xcd27(%rip), %rsi      # 0x13ddb
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
cvtsi2sd %rax, %xmm0
callq 0x3450
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x13381(%rip)     # 0x1a498
jge 0x712b
movq -0x8(%rbp), %rdi
leaq 0xccfb(%rip), %rsi      # 0x13e1f
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x12ffb(%rip)     # 0x1a138
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, 0x12fe3(%rip)     # 0x1a130
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x9860
movq -0x18(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x132f1(%rip)     # 0x1a498
jge 0x71bb
movq -0x8(%rbp), %rdi
leaq 0xccb2(%rip), %rsi      # 0x13e66
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x12f6b(%rip)     # 0x1a138
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, 0x12f53(%rip)     # 0x1a130
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x9860
movq -0x18(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x13261(%rip)     # 0x1a498
jge 0x724b
movq -0x8(%rbp), %rdi
leaq 0xcc69(%rip), %rsi      # 0x13ead
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x12edb(%rip)     # 0x1a138
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, 0x12ec3(%rip)     # 0x1a130
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x9860
movq -0x18(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x131d1(%rip)     # 0x1a498
jge 0x72db
movq -0x8(%rbp), %rdi
leaq 0xcc22(%rip), %rsi      # 0x13ef6
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x12e4b(%rip)     # 0x1a138
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, 0x12e33(%rip)     # 0x1a130
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x9860
movq -0x18(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x13141(%rip)     # 0x1a498
jge 0x736b
movq -0x8(%rbp), %rdi
leaq 0xcbdb(%rip), %rsi      # 0x13f3f
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x12dbb(%rip)     # 0x1a138
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, 0x12da3(%rip)     # 0x1a130
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3890
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x9860
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x7425
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x11890
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
leaq -0x40(%rbp), %rsi
callq 0x11960
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x73d7
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x13031(%rip)     # 0x1a498
jge 0x747b
movq -0x8(%rbp), %rdi
leaq 0xcb16(%rip), %rsi      # 0x13f8a
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x12cab(%rip)     # 0x1a138
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, 0x12c93(%rip)     # 0x1a130
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x7, %esi
callq 0x9860
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12f81(%rip)     # 0x1a498
jge 0x752b
movq -0x8(%rbp), %rdi
leaq 0xcaae(%rip), %rsi      # 0x13fd2
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x12bfb(%rip)     # 0x1a138
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, 0x12be3(%rip)     # 0x1a130
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x9860
movq -0x18(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12ef1(%rip)     # 0x1a498
jge 0x75bb
movq -0x8(%rbp), %rdi
leaq 0xca67(%rip), %rsi      # 0x1401b
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x12b6b(%rip)     # 0x1a138
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, 0x12b53(%rip)     # 0x1a130
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x9860
movq -0x18(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12e61(%rip)     # 0x1a498
jge 0x764b
movq -0x8(%rbp), %rdi
leaq 0xca21(%rip), %rsi      # 0x14065
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x12adb(%rip)     # 0x1a138
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, 0x12ac3(%rip)     # 0x1a130
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x9860
movq -0x18(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3890
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x99a0
movq -0x38(%rbp), %rdi
movsbl %al, %esi
callq 0x30e0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12d51(%rip)     # 0x1a498
jge 0x775b
movq -0x8(%rbp), %rdi
leaq 0xcab6(%rip), %rsi      # 0x1420a
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12ce1(%rip)     # 0x1a498
jge 0x77cb
movq -0x8(%rbp), %rdi
leaq 0xca9a(%rip), %rsi      # 0x1425e
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9cb0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7814
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
jmp 0x781d
movq -0x8(%rbp), %rdi
callq 0x38c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)