LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: parse_extern_decl
static expr_t* parse_extern_decl(script_t* script)
{
	expr_t* exp = create_expr(EXP_EXTERN);

	char* name = estrdup(g_lexeme);

	get_next_token();

	exp->extern_decl = declare_extern(script, name);

	if (g_cur_tok != TOK_OPENPAREN) error_exit_p("Expected '(' after extern %s\n", name);
	get_next_token();

	while (g_cur_tok != TOK_CLOSEPAREN)
	{
		type_tag_t* arg_tag = parse_type_tag(script);
		vec_push_back(&exp->extern_decl->tag->func.arg_types, &arg_tag);

		if (g_cur_tok == TOK_COMMA) get_next_token();
		else if (g_cur_tok != TOK_CLOSEPAREN) error_exit_p("Unexpected token '%s'\n", g_token_names[g_cur_tok]);
	}
	get_next_token();

	if (g_cur_tok != TOK_COLON) error_exit_p("Expected ':' but received '%s'\n", g_token_names[g_cur_tok]);
	get_next_token();

	exp->extern_decl->tag->func.return_type = parse_type_tag(script);

	free(name);

	return exp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x17, %edi
callq 0xa1b0
movq %rax, -0x10(%rbp)
leaq 0xb16f(%rip), %rdi      # 0x1a5c0
callq 0x2500
movq %rax, -0x18(%rbp)
callq 0xd640
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf570
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
cmpl $0x19, 0xb132(%rip)     # 0x1a5b0
je 0xf492
movq -0x18(%rbp), %rsi
leaq 0x5f75(%rip), %rdi      # 0x15400
movb $0x0, %al
callq 0xa0e0
callq 0xd640
cmpl $0x1a, 0xb112(%rip)     # 0x1a5b0
je 0xf503
movq -0x8(%rbp), %rdi
callq 0xef40
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rdi
addq $0x28, %rdi
leaq -0x20(%rbp), %rsi
callq 0x11960
cmpl $0x1f, 0xb0e3(%rip)     # 0x1a5b0
jne 0xf4d6
callq 0xd640
jmp 0xf501
cmpl $0x1a, 0xb0d3(%rip)     # 0x1a5b0
je 0xf4ff
movslq 0xb0ca(%rip), %rcx      # 0x1a5b0
leaq 0xad33(%rip), %rax      # 0x1a220
movq (%rax,%rcx,8), %rsi
leaq 0x5b25(%rip), %rdi      # 0x1501d
movb $0x0, %al
callq 0xa0e0
jmp 0xf501
jmp 0xf497
callq 0xd640
cmpl $0x1d, 0xb0a1(%rip)     # 0x1a5b0
je 0xf531
movslq 0xb098(%rip), %rcx      # 0x1a5b0
leaq 0xad01(%rip), %rax      # 0x1a220
movq (%rax,%rcx,8), %rsi
leaq 0x5ef4(%rip), %rdi      # 0x1541e
movb $0x0, %al
callq 0xa0e0
callq 0xd640
movq -0x8(%rbp), %rdi
callq 0xef40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: declare_extern
static func_decl_t* declare_extern(script_t* script, const char* name)
{
	script_module_t* module = vec_get(&script->modules, g_cur_module_index);
	func_decl_t* decl = emalloc(sizeof(func_decl_t));
	
	decl->parent = g_cur_func;
	decl->type = DECL_EXTERN;
	decl->tag = create_type_tag(script, TAG_FUNC);
	decl->name = estrdup(name);
	
	vec_init(&decl->locals, sizeof(var_decl_t*));
	vec_init(&decl->args, sizeof(var_decl_t*));

	int index = get_extern_index(script, name);
	if(index < 0) error_exit_p("Attempted to declare unbound extern by name '%s'\n", name);
	decl->index = index;

	vec_push_back(&module->functions, &decl);
	return decl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq 0xaf06(%rip), %rsi      # 0x1a498
callq 0x11890
movq %rax, -0x18(%rbp)
movl $0x68, %edi
callq 0x3580
movq %rax, -0x20(%rbp)
movq 0xaef8(%rip), %rcx      # 0x1a4a8
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x9860
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x2500
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl $0x8, %esi
callq 0x114e0
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movl $0x8, %esi
callq 0x114e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf670
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0xf63b
movq -0x10(%rbp), %rsi
leaq 0x5e0a(%rip), %rdi      # 0x1543e
movb $0x0, %al
callq 0xa0e0
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x18(%rbp), %rdi
addq $0x20d0, %rdi           # imm = 0x20D0
leaq -0x20(%rbp), %rsi
callq 0x11960
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: get_extern_index
static int get_extern_index(script_t* script, const char* name)
{
	for(int i = 0; i < script->extern_names.length; ++i)
	{
		if(strcmp(vec_get_value(&script->extern_names, i, char*), name) == 0) 
			return i;
	}
	
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x248(%rcx), %rax
jae 0xf6d2
movq -0x10(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
movslq -0x1c(%rbp), %rsi
callq 0x11890
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0xf6c5
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf6d9
jmp 0xf6c7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf687
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: define_struct_type
static type_tag_t* define_struct_type(script_t* script, const char* name, char is_union)
{
	script_module_t* module = vec_get(&script->modules, g_cur_module_index);
	type_tag_t* tag = map_get(&module->user_type_tags, name);
	if(!tag)
	{
		tag = create_type_tag(script, TAG_STRUCT);
		tag->ds.name = estrdup(name);
		map_set(&module->user_type_tags, name, tag);
	}
	
	tag->ds.is_union = is_union;
	tag->defined = 1;
	
	return tag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq 0xad81(%rip), %rsi      # 0x1a498
callq 0x11890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0xb0, %rdi
movq -0x10(%rbp), %rsi
callq 0x11fa0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf77d
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x9860
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2500
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rdi
addq $0xb0, %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x11e50
movb -0x11(%rbp), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x28(%rax)
movq -0x28(%rbp), %rax
movb $0x1, 0x24(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: get_prec
static int get_prec(int op)
{
	switch(op)
	{
		case TOK_ASSIGN: return 0;
		case TOK_LAND: case TOK_LOR: return 1;
		case TOK_LT: case TOK_GT: case TOK_LTE: case TOK_GTE: case TOK_EQUALS: case TOK_NOTEQUAL: return 2;
		case TOK_PLUS: case TOK_MINUS: return 3;
		case TOK_MUL: case TOK_DIV: case TOK_MOD: return 4;
	
		default:
			return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x24, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xd, %eax
ja 0xf7f9
movq -0x10(%rbp), %rax
leaq 0x3df9(%rip), %rcx      # 0x135bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0xf800
movl $0x1, -0x4(%rbp)
jmp 0xf800
movl $0x2, -0x4(%rbp)
jmp 0xf800
movl $0x3, -0x4(%rbp)
jmp 0xf800
movl $0x4, -0x4(%rbp)
jmp 0xf800
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: check_all_tags_defined
static void check_all_tags_defined(script_t* script)
{
	script_module_t* module = vec_get(&script->modules, g_cur_module_index);
	for(int i = 0; i < module->all_type_tags.length; ++i)
	{
		type_tag_t* tag = vec_get_value(&module->all_type_tags, i, type_tag_t*);
		if(!tag->defined) error_defer_c(tag->ctx, "Use of undefined type '%s'\n", tag->ds.name);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq 0xac6a(%rip), %rsi      # 0x1a498
callq 0x11890
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0xa0(%rcx), %rax
jae 0xf8bd
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
movslq -0x14(%rbp), %rsi
callq 0x11890
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, 0x24(%rax)
jne 0xf8b0
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x30(%rcx), %rsi
leaq 0x5d66(%rip), %rdi      # 0x155ed
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)
movb $0x0, %al
callq 0xfdb0
jmp 0xf8b2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf83e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: error_defer_c
static void error_defer_c(context_t ctx, const char* fmt, ...)
{
	fprintf(stderr, "\nError (%s:%i):\n", ctx.file, ctx.line);
	
	va_list args;
	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);
	
	g_has_error = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0xfde5
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 %rdi, -0x8(%rbp)
movq 0xa1e1(%rip), %rcx      # 0x19ff8
movq %rcx, -0xd8(%rbp)
movq (%rcx), %rdi
movq 0x8(%rax), %rdx
movl (%rax), %ecx
leaq 0x4532(%rip), %rsi      # 0x14360
xorl %eax, %eax
callq 0x2150
movq -0xd8(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, -0x10(%rbp)
leaq 0x30(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x21e0
movb $0x1, 0xa628(%rip)      # 0x1a49c
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: error_exit_c
static void error_exit_c(context_t ctx, const char* fmt, ...)
{
	fprintf(stderr, "\nError (%s:%i):\n", ctx.file, ctx.line);
	
	va_list args;
	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);
	
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x10065
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 %rdi, -0x8(%rbp)
movq 0x9f61(%rip), %rcx      # 0x19ff8
movq (%rcx), %rdi
movq 0x8(%rax), %rdx
movl (%rax), %ecx
leaq 0x42b9(%rip), %rsi      # 0x14360
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 0x9f1f(%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: compile_file_line_info
static void compile_file_line_info(script_t* script, expr_t* exp, char ignore_last)
{
	if (exp->ctx.file)
	{
		if (ignore_last || !g_last_compiled_file || strcmp(g_last_compiled_file, exp->ctx.file) != 0)
		{
			append_code(script, OP_FILE);
			append_int(script, register_string(script, exp->ctx.file));
		}
		g_last_compiled_file = exp->ctx.file;
	}

	if(ignore_last || g_last_compiled_line != exp->ctx.line)
	{
		append_code(script, OP_LINE);
		append_int(script, exp->ctx.line);
	}
	g_last_compiled_line = exp->ctx.line;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1018d
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x1014c
cmpq $0x0, 0xa58f(%rip)      # 0x1a6c0
je 0x1014c
movq 0xa586(%rip), %rdi      # 0x1a6c0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2130
cmpl $0x0, %eax
je 0x1017e
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x9480
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xa2c0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x109d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xa533(%rip)      # 0x1a6c0
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x101a5
movl 0xa52c(%rip), %eax      # 0x1a6c8
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x101c3
movq -0x8(%rbp), %rdi
movl $0x2d, %esi
callq 0x9480
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x109d0
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xa4f8(%rip)      # 0x1a6c8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: compile_assign
static void compile_assign(script_t* script, expr_t* exp)
{
	switch(exp->type)
	{
		case EXP_VAR:
		{
			if(exp->varx.decl)
			{
				if(exp->varx.decl->parent)
					append_code(script, OP_SETLOCAL);
				else
					append_code(script, OP_SET);
				append_int(script, exp->varx.decl->index);
			}
			else
				error_exit_e(exp, "Attempted to assign to unassignable value\n");
		} break;
		
		case EXP_ARRAY_INDEX:
		{
			compile_value_expr(script, exp->array_index.index);
			compile_value_expr(script, exp->array_index.array);
			append_code(script, OP_ARRAY_SET);
		} break;
		
		case EXP_DOT:
		{
			int index = get_struct_type_member_index(exp->dotx.value->tag, exp->dotx.name);
			if (index < 0) error_exit_e(exp, "Attempted to access non-existent member '%s' in struct '%s'\n", exp->dotx.name, exp->dotx.value->tag->ds.name);
			
			compile_value_expr(script, exp->dotx.value);
			append_code(script, OP_STRUCT_SET);
			append_int(script, index);
		} break;
		
		default: 
			error_exit_e(exp, "Invalid left-hand-side in assignment expression\n");
			break;
	};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x4, %eax
je 0x10b75
jmp 0x10ac5
movl -0x18(%rbp), %eax
subl $0x5, %eax
je 0x10adc
jmp 0x10acf
movl -0x18(%rbp), %eax
subl $0x6, %eax
je 0x10b40
jmp 0x10bee
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x10b29
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, (%rax)
je 0x10b05
movq -0x8(%rbp), %rdi
movl $0x27, %esi
callq 0x9480
jmp 0x10b13
movq -0x8(%rbp), %rdi
movl $0x25, %esi
callq 0x9480
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x1c(%rax), %esi
callq 0x109d0
jmp 0x10b3b
movq -0x10(%rbp), %rdi
leaq 0x4bfe(%rip), %rsi      # 0x15732
movb $0x0, %al
callq 0xba00
jmp 0x10c00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x101e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x101e0
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x9480
jmp 0x10c00
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0xbad0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x10bc1
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rcx
leaq 0x4ba3(%rip), %rsi      # 0x1575d
movb $0x0, %al
callq 0xba00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x101e0
movq -0x8(%rbp), %rdi
movl $0x12, %esi
callq 0x9480
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x109d0
jmp 0x10c00
movq -0x10(%rbp), %rdi
leaq 0x4ba1(%rip), %rsi      # 0x1579a
movb $0x0, %al
callq 0xba00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: compile_call
static void compile_call(script_t* script, expr_t* exp)
{
	int nargs = exp->callx.args.length;

	if (exp->callx.func->type == EXP_COLON)
	{
		compile_value_expr(script, exp->callx.func->dotx.value);
		nargs += 1;
	}

	for(int i = 0; i < exp->callx.args.length; ++i)
	{
		expr_t* e = vec_get_value(&exp->callx.args, i, expr_t*);
		compile_value_expr(script, e);
	}

	compile_value_expr(script, exp->callx.func);
	
	append_code(script, OP_CALL);
	append_code(script, nargs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpl $0x3, 0x28(%rax)
jne 0x10c57
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x38(%rax), %rsi
callq 0x101e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x10ca0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
addq $0x8, %rdi
movslq -0x18(%rbp), %rsi
callq 0x11890
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x101e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x10c5e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x101e0
movq -0x8(%rbp), %rdi
movl $0x29, %esi
callq 0x9480
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x9480
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: read_int_at
static int read_int_at(script_t* script, int pc)
{
	int value = 0;
	word* vp = (word*)(&value);
	
	for(int i = 0; i < sizeof(int) / sizeof(word); ++i)
		*vp++ = vec_get_value(&script->code, pc + i, word);
		
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x4, %rax
jae 0x10d46
movq -0x8(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movl -0xc(%rbp), %eax
addl -0x1c(%rbp), %eax
movslq %eax, %rsi
callq 0x11890
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10d05
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: print_current_script_line
static void print_current_script_line(script_t* script)
{
	script_module_t* mod = get_executing_module(script);

	const char* code = mod->source_code;
	int line = 1;
	size_t line_len = 0;

	while (*code)
	{
		line_len = strcspn(code, "\n\r");
		if (line == script->cur_line)
			break;

		code += line_len;

		while (isspace(*code))
		{
			if (*code == '\n') ++line;
			++code;
		}
	}

	if (line != script->cur_line)
		printf("Current line not found...\n");
	else
		printf("(%s, %d): %.*s\n", mod->local_path, line, line_len, code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10e50
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x10e03
movq -0x18(%rbp), %rdi
leaq 0x4d52(%rip), %rsi      # 0x15aea
callq 0x2110
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x124(%rcx), %eax
jne 0x10db2
jmp 0x10e03
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x2230
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x10e01
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x10df3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10dbe
jmp 0x10d84
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x124(%rcx), %eax
je 0x10e22
leaq 0x4cd4(%rip), %rdi      # 0x15aed
movb $0x0, %al
callq 0x20c0
jmp 0x10e43
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq 0x4ccc(%rip), %rdi      # 0x15b08
movb $0x0, %al
callq 0x20c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: get_executing_module
static script_module_t* get_executing_module(script_t* script)
{
	for (int i = 0; i < script->modules.length; ++i)
	{
		script_module_t* m = vec_get(&script->modules, i);
		if (m->start_pc <= script->pc && m->end_pc >= script->pc)
			return m;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x2c8(%rcx), %rax
jae 0x10ed3
movq -0x10(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movslq -0x14(%rbp), %rsi
callq 0x11890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x11c(%rcx), %rcx
cmpq %rcx, %rax
ja 0x10ec6
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x11c(%rcx), %rcx
cmpq %rcx, %rax
jb 0x10ec6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10edb
jmp 0x10ec8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10e63
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: read_int
static int read_int(script_t* script)
{
	int value = 0;
	word* vp = (word*)(&value);
	
	for(int i = 0; i < sizeof(int) / sizeof(word); ++i)
		*vp++ = vec_get_value(&script->code, script->pc++, word);
	
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x4, %rax
jae 0x10f62
movq -0x8(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movq -0x8(%rbp), %rcx
movl 0x11c(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x11c(%rcx)
movslq %eax, %rsi
callq 0x11890
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10f12
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: push_func
static void push_func(script_t* script, char is_extern, int index)
{
	script_value_t* val = new_value(script, VAL_FUNC);
	val->function.is_extern = is_extern;
	val->function.index = index;
	push_value(script, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x3350
movq %rax, -0x18(%rbp)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x20(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: push_call_record
static void push_call_record(script_t* script, script_function_t function, word nargs)
{
	script_call_record_t record;

	record.stack_size = script->stack.length;
	record.pc = script->pc - 1;
	record.fp = script->fp;
	record.nargs = nargs;
	record.function = function;
	record.file = script->cur_file;
	record.line = script->cur_line;

	vec_push_back(&script->call_records, &record);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x1a8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl 0x11c(%rax), %eax
subl $0x1, %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x120(%rax), %eax
movl %eax, -0x3c(%rbp)
movzbl -0x11(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
leaq -0x48(%rbp), %rsi
callq 0x11960
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: pop_stack_frame
static void pop_stack_frame(script_t* script)
{
	if (script->indir_depth <= 0)
	{
		script->pc = -1;
		vec_clear(&script->stack);
		return;
	}
	
	// NOTE: Remove local values
	vec_resize(&script->stack, script->fp, NULL);

	// NOTE: Reset pc and fp
	vec_pop_back(&script->indir, &script->pc);
	vec_pop_back(&script->indir, &script->fp);
	
	int nargs;
	vec_pop_back(&script->indir, &nargs);

	// NOTE: Remove arguments
	vec_resize(&script->stack, script->stack.length - nargs, NULL);

	--script->indir_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x190(%rax)
jg 0x1142c
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x11c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0x11da0
jmp 0x114ce
movq -0x8(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
movq -0x8(%rbp), %rax
movslq 0x120(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x11800
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
movq -0x8(%rbp), %rsi
addq $0x11c, %rsi            # imm = 0x11C
callq 0x11a00
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
movq -0x8(%rbp), %rsi
addq $0x120, %rsi            # imm = 0x120
callq 0x11a00
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
leaq -0xc(%rbp), %rsi
callq 0x11a00
movq -0x8(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
movslq -0xc(%rbp), %rax
subq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x11800
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)
nop
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/vector.c
// Function: vec_init
void vec_init(vector_t* vector, size_t datum_size)
{
	vector->data = NULL;
	vector->datum_size = datum_size;
	vector->length = 0;
	vector->capacity = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/vector.c
// Function: vec_copy
void vec_copy(vector_t* me, vector_t* other)
{
	if(me->datum_size != other->datum_size) error_exit("Attempted to copy vectors with different data sizes\n");
	if(me->capacity < other->capacity)
	{
		me->capacity = other->capacity;
		vec_realloc(me);
	}
	
	memcpy(me->data, other->data, me->datum_size * other->capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x11550
leaq 0x462f(%rip), %rdi      # 0x15b78
movb $0x0, %al
callq 0x115b0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x1157b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x11670
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
imulq 0x18(%rax), %rdx
callq 0x2180
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/vector.c
// Function: error_exit
static void error_exit(const char* fmt, ...)
{
	fprintf(stderr, "\nError:\n");
	
	va_list args;
	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);
	
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x115e5
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 0x89e5(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x3893(%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 0x89a9(%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/vector.c
// Function: vec_copy_region
void vec_copy_region(vector_t* me, vector_t* other, size_t index, size_t start, size_t amount)
{
	if(me->datum_size != other->datum_size) error_exit("Attempted to copy vectors with different data sizes\n");
	
	if(start < 0 || start > other->length ||
		start + amount > other->length) error_exit("Attempted to copy from region outside of bounds of vector\n");
	
	vec_reserve(me, index + amount);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x1170c
leaq 0x4473(%rip), %rdi      # 0x15b78
movb $0x0, %al
callq 0x115b0
cmpq $0x0, -0x20(%rbp)
jb 0x11733
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
ja 0x11733
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x11741
leaq 0x4473(%rip), %rdi      # 0x15bad
movb $0x0, %al
callq 0x115b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
callq 0x117c0
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x11774
movq -0x18(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq 0x8(%rcx), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq 0x8(%rcx), %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
imulq 0x8(%rax), %rdx
callq 0x2180
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/vector.c
// Function: vec_resize
void vec_resize(vector_t* vector, size_t amount, void* p_initial_value)
{
	vec_reserve(vector, amount);
	vector->length = amount;
	
	if(p_initial_value)
	{
		for(int i = 0; i < vector->length; ++i)
			memcpy(&vector->data[i * vector->datum_size], p_initial_value, vector->datum_size);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x117c0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x1187e
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1187c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq 0x8(%rcx), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2180
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1183b
jmp 0x1187e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/vector.c
// Function: vec_push_back
void vec_push_back(vector_t* vector, void* object)
{
	while(vector->length + 1 >= vector->capacity)
	{
		if(vector->capacity == 0)
			vector->capacity = 8;
		vector->capacity *= 2;
		vec_realloc(vector);
	}
	
	memcpy(&vector->data[vector->length * vector->datum_size], object, vector->datum_size);
	vector->length++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x119b7
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1199d
movq -0x8(%rbp), %rax
movq $0x8, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
shlq %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x11670
jmp 0x11970
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
imulq 0x8(%rcx), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2180
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/vector.c
// Function: vec_pop_back
void vec_pop_back(vector_t* vector, void* into)
{
	if(vector->length == 0) error_exit("Attempted to perform vec_pop_back on empty vector");
	
	if (!into)
	{
		--vector->length;
		return;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x11a29
leaq 0x424a(%rip), %rdi      # 0x15c6c
movb $0x0, %al
callq 0x115b0
cmpq $0x0, -0x10(%rbp)
jne 0x11a42
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x11a76
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rcx)
movq -0x8(%rbp), %rcx
imulq 0x8(%rcx), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2180
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/vector.c
// Function: vec_insert
void vec_insert(vector_t* vector, void* object, size_t index)
{
	if(index >= vector->length) error_exit("Provided out of bounds index (%i) to vec_insert (vector length: %i)", (int)index, (int)vector->length);
	
	while(vector->length + 1 >= vector->capacity)
	{
		vector->capacity *= 2;
		vec_realloc(vector);
	}
	
	memmove(&vector->data[(index + 1) * vector->datum_size], &vector->data[index * vector->datum_size], (vector->length - index) * vector->datum_size);
	memcpy(&vector->data[index * vector->datum_size], object, vector->datum_size);
	vector->length += 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x11ac0
movq -0x18(%rbp), %rax
movl %eax, %esi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %edx
leaq 0x41e5(%rip), %rdi      # 0x15c9e
movb $0x0, %al
callq 0x115b0
jmp 0x11ac2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x11af2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
shlq %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x11670
jmp 0x11ac2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
imulq 0x8(%rcx), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq 0x8(%rcx), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
subq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
imulq 0x8(%rax), %rdx
callq 0x21c0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq 0x8(%rcx), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2180
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/vector.c
// Function: vec_flip
void vec_flip(vector_t* vector)
{
	if(vector->length == 0) return;
	
	unsigned char* lo = vector->data;
	unsigned char* hi = &vector->data[vector->length - 1];
	unsigned char swap;
	
	while(lo < hi)
	{
		swap = *lo;
		*lo++ = *hi;
		*hi-- = swap;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x11c95
jmp 0x11cfa
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x11cfa
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x11cba
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/vector.c
// Function: vec_destroy
void vec_destroy(vector_t* vector)
{
	if(vector->data)
		free(vector->data);
	vector->data = NULL;
	vector->length = 0;
	vector->capacity = 0;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11ee0
andq $0x3ff, %rax            # imm = 0x3FF
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11f30
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x11eab
movq -0x8(%rbp), %rdi
addq $0x2000, %rdi           # imm = 0x2000
leaq -0x20(%rbp), %rsi
callq 0x11960
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/hashmap.c
// Function: map_hash_function
static unsigned long map_hash_function(const char* str)
{
	unsigned long hash = 5381;
	int c;

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

	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x1505, -0x10(%rbp)    # imm = 0x1505
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x11f23
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x11ef0
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/hashmap.c
// Function: create_node
static hashmap_node_t* create_node(const char* key, void* value)
{
	hashmap_node_t* node = malloc(sizeof(hashmap_node_t));
	if(!node) error_exit("failed to create hashmap node (key: '%s'); out of memory", key);
	
	node->key = my_strdup(key);
	node->value = value;
	node->next = NULL;
	
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x2190
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11f67
movq -0x8(%rbp), %rsi
leaq 0x3df3(%rip), %rdi      # 0x15d53
movb $0x0, %al
callq 0x12370
movq -0x8(%rbp), %rdi
callq 0x12450
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/hashmap.c
// Function: map_get
void* map_get(hashmap_t* map, const char* key)
{
	unsigned long pos = map_hash_function(key) % HASHMAP_BUCKET_AMT;
	
	if(!map->buckets[pos])
		return NULL;
	else 
	{
		hashmap_node_t* node = map->buckets[pos];
		
		while(node)
		{
			if(strcmp(node->key, key) == 0)
				return node->value;
			node = node->next;
		}
	}
	
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11ee0
andq $0x3ff, %rax            # imm = 0x3FF
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x11fdc
movq $0x0, -0x8(%rbp)
jmp 0x1202e
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12024
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x12017
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1202e
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x11fec
jmp 0x12026
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/hashmap.c
// Function: map_remove
void* map_remove(hashmap_t* map, const char* key)
{
	unsigned long pos = map_hash_function(key) % HASHMAP_BUCKET_AMT;
	
	if(!map->buckets[pos])
		return NULL;
	else 
	{
		hashmap_node_t* node = map->buckets[pos];
		hashmap_node_t* prev = NULL;
		
		while(node)
		{
			if(strcmp(node->key, key) == 0)
			{
				if(prev)
					prev->next = node->next;
				else
				{
					map->buckets[pos] = NULL;
					int to_remove = -1;
					for(size_t i = 0; i < map->active_buckets.length; ++i)
					{
						if(*(unsigned long*)vec_get(&map->active_buckets, i) == pos)
						{
							to_remove = i;
							break;
						}
					}
					
					if(to_remove >= 0) vec_remove(&map->active_buckets, to_remove);
				}
				
				void* value = node->value;
				
				free(node->key);
				free(node);
				
				return value;
			}
			
			prev = node;
			node = node->next;
		}
	}
	
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11ee0
andq $0x3ff, %rax            # imm = 0x3FF
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1207f
movq $0x0, -0x8(%rbp)
jmp 0x121a6
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1219c
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x12184
cmpq $0x0, -0x30(%rbp)
je 0x120d6
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x12158
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x2010(%rcx), %rax
jae 0x1213c
movq -0x10(%rbp), %rdi
addq $0x2000, %rdi           # imm = 0x2000
movq -0x40(%rbp), %rsi
callq 0x11890
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x1212c
movq -0x40(%rbp), %rax
movl %eax, -0x34(%rbp)
jmp 0x1213c
jmp 0x1212e
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x120f5
cmpl $0x0, -0x34(%rbp)
jl 0x12156
movq -0x10(%rbp), %rdi
addq $0x2000, %rdi           # imm = 0x2000
movslq -0x34(%rbp), %rsi
callq 0x11b80
jmp 0x12158
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x121a6
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x12097
jmp 0x1219e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/hashmap.c
// Function: map_traverse
void map_traverse(hashmap_t* map, hashmap_traverse_t traverse, void* data)
{
	for(size_t i = 0; i < map->active_buckets.length; ++i)
	{
		unsigned long pos = *(unsigned long*)vec_get(&map->active_buckets, i);
		hashmap_node_t* node = map->buckets[pos];
		while(node)
		{
			traverse(node->key, node->value, data);
			node = node->next;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2010(%rcx), %rax
jae 0x12246
movq -0x8(%rbp), %rdi
addq $0x2000, %rdi           # imm = 0x2000
movq -0x20(%rbp), %rsi
callq 0x11890
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x12236
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x12208
jmp 0x12238
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x121cc
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/hashmap.c
// Function: map_clear
void map_clear(hashmap_t* map)
{
	for(size_t i = 0; i < map->active_buckets.length; ++i)
	{
		unsigned long pos = *(unsigned long*)vec_get(&map->active_buckets, i);
		hashmap_node_t* node = map->buckets[pos];
		free_bucket(node);
		map->buckets[pos] = NULL;
	}
	
	vec_clear(&map->active_buckets);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2010(%rcx), %rax
jae 0x122c7
movq -0x8(%rbp), %rdi
addq $0x2000, %rdi           # imm = 0x2000
movq -0x10(%rbp), %rsi
callq 0x11890
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x122e0
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x12264
movq -0x8(%rbp), %rdi
addq $0x2000, %rdi           # imm = 0x2000
callq 0x11da0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)