LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12c51(%rip)     # 0x1a498
jge 0x785b
movq -0x8(%rbp), %rdi
leaq 0xca4f(%rip), %rsi      # 0x142a3
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 0x18(%rax), %rsi
callq 0x3500
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_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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12be1(%rip)     # 0x1a498
jge 0x78cb
movq -0x8(%rbp), %rdi
leaq 0xca28(%rip), %rsi      # 0x142ec
movb $0x0, %al
callq 0x3200
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 -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x3890
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x3890
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x7959
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
cvttsd2si 0x20(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movq %rax, 0x12b44(%rip)     # 0x1a4a8
movl -0x4c(%rbp), %eax
movl %eax, 0x12b33(%rip)     # 0x1a4a0
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x9d80
movq -0x58(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12ad1(%rip)     # 0x1a498
jge 0x79db
movq -0x8(%rbp), %rdi
leaq 0xc99d(%rip), %rsi      # 0x14371
movb $0x0, %al
callq 0x3200
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 -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x3890
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x7a4b
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cvttsd2si 0x20(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movq %rax, 0x12a52(%rip)     # 0x1a4a8
movl -0x3c(%rbp), %eax
movl %eax, 0x12a41(%rip)     # 0x1a4a0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9f10
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x7a8f
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0xc934(%rip), %rsi      # 0x143ba
movb $0x0, %al
callq 0x3200
jmp 0x7aa3
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x129be(%rip)     # 0x1a498
jge 0x7aee
movq -0x8(%rbp), %rdi
leaq 0xc906(%rip), %rsi      # 0x143ed
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq 0x12998(%rip), %rsi     # 0x1a498
callq 0x11890
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0xbef2(%rip), %rax      # 0x13a1d
movq %rax, 0x12606(%rip)     # 0x1a138
movq -0x28(%rbp), %rax
movq %rax, 0x12953(%rip)     # 0x1a490
movl $0x1, 0x125e9(%rip)     # 0x1a130
leaq -0x48(%rbp), %rdi
movl $0x8, %esi
callq 0x114e0
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3ea0
leaq -0x68(%rbp), %rdi
movl $0x8, %esi
callq 0x114e0
movl $0x0, -0x6c(%rbp)
movslq -0x6c(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x7be3
movslq -0x6c(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x11890
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x3350
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x80(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x78(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x11960
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x7b77
leaq -0x48(%rbp), %rdi
callq 0x11dc0
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x3700
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12851(%rip)     # 0x1a498
jge 0x7c5b
movq -0x8(%rbp), %rdi
leaq 0xc7da(%rip), %rsi      # 0x1442e
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x9, %edi
callq 0xa1b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
callq 0xa230
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x38(%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
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x127c1(%rip)     # 0x1a498
jge 0x7ceb
movq -0x8(%rbp), %rdi
leaq 0xc74a(%rip), %rsi      # 0x1442e
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)
movl $0xa, %edi
callq 0xa1b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa2c0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x38(%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_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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12731(%rip)     # 0x1a498
jge 0x7d7b
movq -0x8(%rbp), %rdi
leaq 0xc6fe(%rip), %rsi      # 0x14472
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)
movl $0x5, %edi
callq 0xa1b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2500
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%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,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12691(%rip)     # 0x1a498
jge 0x7e1b
movq -0x8(%rbp), %rdi
leaq 0xc6a2(%rip), %rsi      # 0x144b6
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movl $0x5, %edi
callq 0xa1b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2500
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12601(%rip)     # 0x1a498
jge 0x7eab
movq -0x8(%rbp), %rdi
leaq 0xc661(%rip), %rsi      # 0x14505
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movl $0xc, %edi
callq 0xa1b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %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,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12581(%rip)     # 0x1a498
jge 0x7f2b
movq -0x8(%rbp), %rdi
leaq 0xc627(%rip), %rsi      # 0x1454b
movb $0x0, %al
callq 0x3200
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 -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x3890
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0xe, %edi
callq 0xa1b0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x40(%rbp), %rdi
leaq 0xcdc9(%rip), %rsi      # 0x14d7c
callq 0x2130
cmpl $0x0, %eax
jne 0x7fca
movq -0x48(%rbp), %rax
movl $0x24, 0x48(%rax)
jmp 0x7fe0
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0xc5b6(%rip), %rsi      # 0x1458f
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x37c0
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12471(%rip)     # 0x1a498
jge 0x803b
movq -0x8(%rbp), %rdi
leaq 0xc58b(%rip), %rsi      # 0x145bf
movb $0x0, %al
callq 0x3200
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)
movl $0xf, %edi
callq 0xa1b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
addq $0x8, %rdi
movl $0x8, %esi
callq 0x114e0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x80e1
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x11890
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
addq $0x8, %rdi
movq -0x38(%rbp), %rsi
addq $0x20, %rsi
callq 0x11960
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8097
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
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12371(%rip)     # 0x1a498
jge 0x813b
movq -0x8(%rbp), %rdi
leaq 0xc4d0(%rip), %rsi      # 0x14604
movb $0x0, %al
callq 0x3200
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)
movl $0x6, %edi
callq 0xa1b0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%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_get_func_expr_decl
static void ext_get_func_expr_decl(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("get_func_expr_decl");
	
	script_value_t* exp_val = script_get_arg(args, 0);
	expr_t* exp = exp_val->nat.value;
	
	if(exp->type != EXP_FUNC) error_exit_script(script, "Passed non-func expression into 'get_func_expr_decl'\n");
	
	script_push_native(script, exp->funcx.decl, 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, 0x122d1(%rip)     # 0x1a498
jge 0x81db
movq -0x8(%rbp), %rdi
leaq 0xc47c(%rip), %rsi      # 0x14650
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 -0x20(%rbp), %rax
cmpl $0x19, 0x28(%rax)
je 0x8212
movq -0x8(%rbp), %rdi
leaq 0xc48e(%rip), %rsi      # 0x14699
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x38(%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_get_expr_type
static void ext_get_expr_type(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("get_expr_type");

	script_value_t* exp_val = script_get_arg(args, 0);
	expr_t* exp = exp_val->nat.value;

	// TODO: make script_create_native etc
	script_push_native(script, exp->tag, 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, 0x12241(%rip)     # 0x1a498
jge 0x826b
movq -0x8(%rbp), %rdi
leaq 0xc46b(%rip), %rsi      # 0x146cf
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 0x30(%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_get_var_expr_name
static void ext_get_var_expr_name(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("get_var_expr_name");

	script_value_t* exp_val = script_get_arg(args, 0);
	expr_t* exp = exp_val->nat.value;

	script_push_cstr(script, exp->varx.name);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x121d1(%rip)     # 0x1a498
jge 0x82db
movq -0x8(%rbp), %rdi
leaq 0xc43f(%rip), %rsi      # 0x14713
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 0x38(%rax), %rsi
callq 0x3500
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_resolve_expr_symbols
static void ext_resolve_expr_symbols(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("resolve_expr_symbols");

	script_value_t* exp_val = script_get_arg(args, 0);
	resolve_symbols(script, exp_val->nat.value);

	script_push_bool(script, !g_has_error);
	g_has_error = 0;
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12161(%rip)     # 0x1a498
jge 0x834b
movq -0x8(%rbp), %rdi
leaq 0xc417(%rip), %rsi      # 0x1475b
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0xa380
movq -0x8(%rbp), %rdi
cmpb $0x0, 0x12126(%rip)     # 0x1a49c
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movsbl %al, %esi
callq 0x30e0
movb $0x0, 0x1210d(%rip)     # 0x1a49c
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: ext_resolve_expr_types
static void ext_resolve_expr_types(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("resolve_expr_types");

	script_value_t* exp_val = script_get_arg(args, 0);
	resolve_type_tags(script, exp_val->nat.value);
	
	script_push_bool(script, !g_has_error);
	g_has_error = 0;
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x120e1(%rip)     # 0x1a498
jge 0x83cb
movq -0x8(%rbp), %rdi
leaq 0xc458(%rip), %rsi      # 0x1481c
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0xaa40
movq -0x8(%rbp), %rdi
cmpb $0x0, 0x120a6(%rip)     # 0x1a49c
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movsbl %al, %esi
callq 0x30e0
movb $0x0, 0x1208d(%rip)     # 0x1a49c
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: ext_add_expr_to_module
static void ext_add_expr_to_module(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("add_expr_to_module");
	
	script_value_t* mod_val = script_get_arg(args, 0);
	script_value_t* exp_val = script_get_arg(args, 1);
	
	int module_index = (int)mod_val->number;
	expr_t* exp = exp_val->nat.value;
	
	script_module_t* module = vec_get(&script->modules, module_index);
	vec_push_back(&module->expr_list, &exp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x12061(%rip)     # 0x1a498
jge 0x844b
movq -0x8(%rbp), %rdi
leaq 0xc93e(%rip), %rsi      # 0x14d82
movb $0x0, %al
callq 0x3200
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
cvttsd2si 0x20(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq -0x24(%rbp), %rsi
callq 0x11890
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
leaq -0x30(%rbp), %rsi
callq 0x11960
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: ext_insert_expr_into_module
static void ext_insert_expr_into_module(script_t* script, vector_t* args)
{
	EXT_CHECK_IF_CT("insert_expr_into_module");
	
	script_value_t* mod_val = script_get_arg(args, 0);
	script_value_t* exp_val = script_get_arg(args, 1);
	script_value_t* loc_val = script_get_arg(args, 2);
	
	int module_index = (int)mod_val->number;
	expr_t* exp = exp_val->nat.value;
	int location = (int)loc_val->number;
	
	script_module_t* module = vec_get(&script->modules, module_index);
	vec_insert(&module->expr_list, &exp, location);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x11fc1(%rip)     # 0x1a498
jge 0x84eb
movq -0x8(%rbp), %rdi
leaq 0xc8e7(%rip), %rsi      # 0x14dcb
movb $0x0, %al
callq 0x3200
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 -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x3890
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cvttsd2si 0x20(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cvttsd2si 0x20(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq -0x2c(%rbp), %rsi
callq 0x11890
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
addq $0x50, %rdi
movslq -0x3c(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x11a80
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: ext_make_array_of_length
static void ext_make_array_of_length(script_t* script, vector_t* args)
{
	script_value_t* val = script_get_arg(args, 0);
	int length = (int)val->number;
	
	vector_t array;
	vec_init(&array, sizeof(script_value_t*));
	script_value_t* null_value = NULL;
	vec_resize(&array, length, &null_value);
	
	script_push_premade_array(script, array);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %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)
leaq -0x40(%rbp), %rdi
movl $0x8, %esi
callq 0x114e0
movq $0x0, -0x48(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x11800
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x3700
movq -0x8(%rbp), %rdi
callq 0x38f0
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: ext_array_push
static void ext_array_push(script_t* script, vector_t* args)
{
	script_value_t* array_val = script_get_arg(args, 0);
	script_value_t* value_val = script_get_arg(args, 1);

	vector_t* array = &array_val->array;
	
	vec_push_back(array, &value_val);
}

// 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
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11960
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: ext_array_pop
static void ext_array_pop(script_t* script, vector_t* args)
{
	script_value_t* array_val = script_get_arg(args, 0);
	script_value_t* value;

	vector_t* array = &array_val->array;

	vec_pop_back(array, &value);

	push_value(script, value);
	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 -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11a00
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3140
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_number_to_string
static void ext_number_to_string(script_t* script, vector_t* args)
{
	script_value_t* val = script_get_arg(args, 0);
	
	static char buf[256]; // TODO: don't use a magic number here
	sprintf(buf, "%g", val->number);
	
	script_push_cstr(script, buf);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %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
movsd 0x20(%rax), %xmm0
leaq 0x11d21(%rip), %rdi     # 0x1a4b0
leaq 0xc683(%rip), %rsi      # 0x14e19
movb $0x1, %al
callq 0x2200
movq -0x8(%rbp), %rdi
leaq 0x11d08(%rip), %rsi     # 0x1a4b0
callq 0x3500
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_create_u8_buffer
static void ext_create_u8_buffer(script_t* script, vector_t* args)
{
	vector_t* buf = emalloc(sizeof(vector_t));
	vec_init(buf, sizeof(uint8_t));
	script_push_native(script, buf, NULL, delete_u8_buffer);
	script_return_top(script); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
callq 0x3580
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x114e0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq 0x3401(%rip), %rcx      # 0xbd80
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_u8_buffer_push
static void ext_u8_buffer_push(script_t* script, vector_t* args)
{
	script_native_t* nat = &script_get_arg(args, 0)->nat;
	script_value_t* val = script_get_arg(args, 1);
	
	uint8_t value = (uint8_t)val->number;
	
	vec_push_back(nat->value, &value);
}

// 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
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cvttsd2si 0x20(%rax), %eax
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0x21(%rbp), %rsi
callq 0x11960
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: ext_u8_buffer_pop
static void ext_u8_buffer_pop(script_t* script, vector_t* args)
{
	script_native_t* nat = &script_get_arg(args, 0)->nat;
	uint8_t value;
	vec_pop_back(nat->value, &value);
	
	script_push_number(script, value);
	script_return_top(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3890
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0x19(%rbp), %rsi
callq 0x11a00
movq -0x8(%rbp), %rdi
movzbl -0x19(%rbp), %eax
cvtsi2sd %eax, %xmm0
callq 0x3450
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_u8_buffer_to_string
static void ext_u8_buffer_to_string(script_t* script, vector_t* args)
{
	script_native_t* nat = &script_get_arg(args, 0)->nat;
	vector_t* buf = nat->value;
	unsigned char null_terminator = '\0';
	vec_push_back(buf, &null_terminator);
	script_string_t str = { buf->length - 1, (char*)buf->data };
	
	script_push_string(script, str);
	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
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x21(%rbp), %rsi
callq 0x11960
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x35c0
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: create_type_tag
static type_tag_t* create_type_tag(script_t* script, tag_t type)
{
	type_tag_t* tag = emalloc(sizeof(type_tag_t)); 
	
	tag->defined = 1;
	tag->finalized = 0;
	
	tag->ctx.file = g_file;
	tag->ctx.line = g_line;
	tag->ctx.scope = g_scope;
	
	tag->type = type;
	
	switch(type)
	{
		case TAG_FUNC:
		{
			vec_init(&tag->func.arg_types, sizeof(type_tag_t*));
			tag->func.return_type = NULL;
		} break;
		
		case TAG_ARRAY:
		{
			tag->contained = NULL;
		} break;
		
		case TAG_STRUCT:
		{
			tag->ds.name = NULL;
			tag->ds.is_union = 0;
			tag->ds.size = 0;
			vec_init(&tag->ds.using, sizeof(type_tag_t*));
			vec_init(&tag->ds.members, sizeof(type_tag_member_t));
		} break;
		
		default: break;
	}
	
	script_module_t* module = vec_get(&script->modules, g_cur_module_index);
	vec_push_back(&module->all_type_tags, &tag);

	return tag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x80, %edi
callq 0x3580
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, 0x24(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x25(%rax)
movq 0x108a4(%rip), %rcx     # 0x1a138
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl 0x1088e(%rip), %ecx     # 0x1a130
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl 0x10bf2(%rip), %ecx     # 0x1a4a0
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x6, %eax
je 0x98e0
jmp 0x98cc
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x9900
jmp 0x98d6
movl -0x24(%rbp), %eax
subl $0xa, %eax
je 0x990e
jmp 0x995c
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movl $0x8, %esi
callq 0x114e0
movq -0x18(%rbp), %rax
movq $0x0, 0x48(%rax)
jmp 0x995e
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x995e
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
addq $0x18, %rdi
movl $0x8, %esi
callq 0x114e0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
addq $0x38, %rdi
movl $0x20, %esi
callq 0x114e0
jmp 0x995e
jmp 0x995e
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq 0x10b28(%rip), %rsi     # 0x1a498
callq 0x11890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
leaq -0x18(%rbp), %rsi
callq 0x11960
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: warn_c
static void warn_c(context_t ctx, script_warning_t warning, ...)
{
	if(!g_warning_disabled[(int)warning])
	{
		fprintf(stderr, "\nWarning %s (%s:%i):\n", g_warning_name[(int)warning], ctx.file, ctx.line);
	
		va_list args;
		va_start(args, warning);
		vfprintf(stderr, g_warning_format[(int)warning], args);
		va_end(args);
		
		fprintf(stderr, "\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x9bc5
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)
leaq 0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x1089c(%rip), %rax     # 0x1a49d
cmpb $0x0, (%rax,%rcx)
jne 0x9ca2
movq -0xd8(%rbp), %rax
movq 0x103df(%rip), %rcx     # 0x19ff8
movq (%rcx), %rdi
movslq -0x4(%rbp), %rdx
leaq 0x10569(%rip), %rcx     # 0x1a190
movq (%rcx,%rdx,8), %rdx
movq 0x8(%rax), %rcx
movl (%rax), %r8d
leaq 0xa473(%rip), %rsi      # 0x140ac
movb $0x0, %al
callq 0x2150
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x1038d(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movslq -0x4(%rbp), %rcx
leaq 0x10537(%rip), %rax     # 0x1a1b0
movq (%rax,%rcx,8), %rsi
leaq -0x20(%rbp), %rdx
callq 0x21e0
leaq -0x20(%rbp), %rax
movq 0x10367(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xb1a1(%rip), %rsi      # 0x14e3c
movb $0x0, %al
callq 0x2150
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: reference_function
static func_decl_t* reference_function(script_t* script, const char* name)
{
	for (int module_index = 0; module_index < script->modules.length; ++module_index)
	{
		script_module_t* module = vec_get(&script->modules, module_index);
		for (int i = 0; i < module->functions.length; ++i)
		{
			func_decl_t* decl = vec_get_value(&module->functions, i, func_decl_t*);
			if (strcmp(decl->name, name) == 0)
				return decl;
		}
	}
	
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x2c8(%rcx), %rax
jae 0x9d64
movq -0x10(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq -0x1c(%rbp), %rsi
callq 0x11890
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x20e0(%rcx), %rax
jae 0x9d54
movq -0x28(%rbp), %rdi
addq $0x20d0, %rdi           # imm = 0x20D0
movslq -0x2c(%rbp), %rsi
callq 0x11890
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x9d47
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9d6c
jmp 0x9d49
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9cfb
jmp 0x9d56
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9cc7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: error_exit_p
static void error_exit_p(const char* fmt, ...)
{
	fprintf(stderr, "\nError (%s:%i):\n", g_file, g_line);
	
	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 0xa115
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 0xfeb5(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
movq 0xffeb(%rip), %rdx      # 0x1a138
movl 0xffdd(%rip), %ecx      # 0x1a130
leaq 0xa206(%rip), %rsi      # 0x14360
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 0xfe6c(%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
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: create_expr
static expr_t* create_expr(expr_type_t type)
{
	expr_t* exp = emalloc(sizeof(expr_t));

	exp->is_shallow_copy = 0;
	exp->tag = NULL;
	exp->ctx.file = g_file;
	exp->ctx.line = g_line;
	exp->ctx.scope = g_scope;
	exp->ctx.func = g_cur_func;
	exp->type = type;
	
	return exp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x60, %edi
callq 0x3580
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq 0xff55(%rip), %rcx      # 0x1a138
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl 0xff3f(%rip), %ecx      # 0x1a130
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl 0x102a2(%rip), %ecx     # 0x1a4a0
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq 0x1029c(%rip), %rcx     # 0x1a4a8
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: register_number
static int register_number(script_t* script, double number)
{
	for(int i = 0; i < script->numbers.length; ++i)
	{
		if(vec_get_value(&script->numbers, i, double) == number)
			return i;
	}
	
	vec_push_back(&script->numbers, &number);
	return script->numbers.length - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x208(%rcx), %rax
jae 0xa28f
movq -0x10(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
movslq -0x1c(%rbp), %rsi
callq 0x11890
movsd (%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
jne 0xa282
jp 0xa282
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa2b5
jmp 0xa284
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa248
movq -0x10(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
leaq -0x18(%rbp), %rsi
callq 0x11960
movq -0x10(%rbp), %rax
movq 0x208(%rax), %rax
subq $0x1, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: register_string
static int register_string(script_t* script, const char* string)
{
	for(int i = 0; i < script->strings.length; ++i)
	{
		if(strcmp(vec_get_value(&script->strings, i, script_string_t).data, string) == 0)
			return i;
	}
	
	script_string_t str;
	str.length = strlen(string);
	str.data = emalloc(str.length + 1);
	strcpy(str.data, string);
	
	vec_push_back(&script->strings, &str);
	return script->strings.length - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x228(%rcx), %rax
jae 0xa323
movq -0x10(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movslq -0x1c(%rbp), %rsi
callq 0x11890
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0xa316
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa375
jmp 0xa318
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa2d7
movq -0x18(%rbp), %rdi
callq 0x20a0
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3580
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2050
movq -0x10(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
leaq -0x30(%rbp), %rsi
callq 0x11960
movq -0x10(%rbp), %rax
movq 0x228(%rax), %rax
subq $0x1, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: get_type_tag_from_name
static type_tag_t* get_type_tag_from_name(script_t* script, const char* name)
{
	type_tag_t* user_tag = get_user_type_tag_from_name(script, name);
	if(user_tag) return user_tag;
	
	for(int i = 0; i < NUM_BUILTIN_TAGS; ++i)
	{
		if(strcmp(g_builtin_type_tags[i], name) == 0)
			return create_type_tag(script, (tag_t)i);
	}
	
	type_tag_t* potential_tag = create_type_tag(script, TAG_STRUCT);
	
	potential_tag->ds.name = estrdup(name);
	vec_init(&potential_tag->ds.members, sizeof(type_tag_member_t));
	potential_tag->defined = 0;
	
	script_module_t* module = vec_get(&script->modules, g_cur_module_index);
	map_set(&module->user_type_tags, name, potential_tag);
	
	return potential_tag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa9b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa805
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa8d0
movl $0x0, -0x24(%rbp)
cmpl $0x9, -0x24(%rbp)
jge 0xa851
movslq -0x24(%rbp), %rcx
leaq 0xf9b3(%rip), %rax      # 0x1a1d0
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0xa844
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x9860
movq %rax, -0x8(%rbp)
jmp 0xa8d0
jmp 0xa846
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa80c
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x9860
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2500
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
addq $0x38, %rdi
movl $0x20, %esi
callq 0x114e0
movq -0x30(%rbp), %rax
movb $0x0, 0x24(%rax)
movq -0x10(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq 0xfbf1(%rip), %rsi      # 0x1a498
callq 0x11890
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0xb0, %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x11e50
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)