LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::name(Instruction*, vm::ON)
Value* VM::name(Instruction* ins, vm::ON on) {

	// Check if the value exists on the pushed class
	if (on == vm::ON::PUSHED_CLASS) {
		Value* top = this->lib_stack.back();

		// Get value from Class directly
		if (top->type == Type::CLASS) {
			Class* cl = static_cast<Class*>(top);
			return cl->get_value(ins->name);
		}

		// Create a Value of type NAME that can be used later
		if (top->type == Type::REFERENCE) {

			if (top->has_method(ins->name)) {
				return new Value(Type::NAME, ins->name);
			}

			std::cout << "REFERENCE: Undefined name: " << ins->name << "\n";
			exit(0);
		}

		// The type is something else, usually a builtin (eg. NUMBER)
		return new Value(Type::NAME, ins->name);
	}

	// Check if the value exists on the stack
	return this->name_get(ins->name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
cmpl $0x1, %edx
jne 0x7253
movq 0x8(%rdi), %rax
movq -0x8(%rax), %rbx
movl 0x8(%rbx), %eax
cmpl $0x4, %eax
je 0x726b
cmpl $0x6, %eax
jne 0x72c9
addq $0x8, %r14
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x32b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8b5a
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
jmp 0x72f4
addq $0x8, %r14
movq %r14, %rsi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6f70
addq $0x8, %r14
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x32b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc012
movl %eax, %ebx
leaq 0x40(%rsp), %rdi
callq 0x3130
testb %bl, %bl
je 0x7309
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x32b0
pushq $0x7
popq %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0xbb82
leaq 0x20(%rsp), %rdi
jmp 0x72f4
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
addq $0x8, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x32b0
pushq $0x7
popq %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xbb82
movq %rsp, %rdi
callq 0x3130
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x13cc0(%rip), %rdi     # 0x1afd0
leaq 0xa1cb(%rip), %rsi      # 0x114e2
callq 0x3220
movq %rax, %rdi
movq %r14, %rsi
callq 0x3200
leaq 0xa51b(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x734f
jmp 0x7356
movq %rax, %r14
movq %rsp, %rdi
callq 0x3130
jmp 0x7359
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0x737a
movq %rax, %r14
leaq 0x40(%rsp), %rdi
jmp 0x7375
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::math(Instruction*)
Value* VM::math(Instruction* ins) {
	Value* left = this->run(ins->left[0]);
	Value* right = this->run(ins->right[0]);

	if (left->type != right->type) {
		std::cout << "math() expects equal types, got " << left->print(true) << " and " << right->print(true) << "\n";
		exit(0);
	}
	
	switch (left->type) {
		case Type::NUMBER:
			return this->math_number(ins, left, right);
			break;
		case Type::STRING:
			return this->math_string(ins, left, right);
			break;

		// Silence the compiler
		default: break;
	}

	std::cout << "math() Does not know how to handle " << left->print() << "\n";
	exit(0);

	return this->get_value_null();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r12
movq 0x38(%rsi), %rax
movq (%rax), %rsi
callq 0x7136
movq %rax, %r14
movq 0x50(%r15), %rax
movq (%rax), %rsi
movq %r12, %rdi
callq 0x7136
movq %rax, %rbx
movl 0x8(%r14), %eax
cmpl 0x8(%rbx), %eax
jne 0x7403
cmpl $0x1, %eax
je 0x73e7
cmpl $0x2, %eax
jne 0x7481
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x74fc
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x762c
movq 0x13bc6(%rip), %rdi     # 0x1afd0
leaq 0xa0ed(%rip), %rsi      # 0x114fe
callq 0x3220
movq %rax, %r15
leaq 0x8(%rsp), %r12
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xbe30
movq %r15, %rdi
movq %r12, %rsi
callq 0x3200
leaq 0xa0e1(%rip), %rsi      # 0x1151f
movq %rax, %rdi
callq 0x3220
movq %rax, %r14
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0xbe30
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x3200
leaq 0xa3dc(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
leaq 0x28(%rsp), %rdi
callq 0x3130
jmp 0x74c3
movq 0x13b48(%rip), %rdi     # 0x1afd0
leaq 0xa096(%rip), %rsi      # 0x11525
callq 0x3220
movq %rax, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xbe30
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3200
leaq 0xa38e(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
leaq 0x8(%rsp), %rdi
callq 0x3130
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3130
jmp 0x74ea
jmp 0x74e7
jmp 0x74e7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::math_number(Instruction*, Value*, Value*)
Value* VM::math_number(Instruction* ins, Value* left, Value* right) {

	double res_number = 0;
	bool res_bool = false;
	bool is_bool = false;
	double l = left->getNumber();
	double r = right->getNumber();

	switch (ins->type) {
		case lexer::Type::OPERATOR_PLUS:
			res_number = l + r;
			break;

		case lexer::Type::OPERATOR_MINUS:
			res_number = l - r;
			break;

		case lexer::Type::OPERATOR_DIV:
			res_number = l / r;
			break;

		case lexer::Type::OPERATOR_MUL:
			res_number = l * r;
			break;

		case lexer::Type::OPERATOR_LT:
			res_bool = l < r;
			is_bool = true;
			break;

		case lexer::Type::OPERATOR_GTEQ:
			res_bool = l >= r;
			is_bool = true;
			break;

		case lexer::Type::OPERATOR_GT:
			res_bool = l > r;
			is_bool = true;
			break;

		case lexer::Type::OPERATOR_LTEQ:
			res_bool = l <= r;
			is_bool = true;
			break;

		case lexer::Type::OPERATOR_EQEQ:
			res_bool = l == r;
			is_bool = true;
			break;

		case lexer::Type::OPERATOR_NOT_EQ:
			res_bool = l != r;
			is_bool = true;
			break;

		case lexer::Type::OPERATOR_2DOT:
		case lexer::Type::OPERATOR_3DOT:
			return this->list_range(l, r, ins->type == lexer::Type::OPERATOR_3DOT);

		default:
			std::cout << "Unknown math_number() operator\n";
			exit(0);
			break;
	}

	if (is_bool) {
		return this->get_value_bool(res_bool);
	}

	return this->get_value_number(res_number);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xc042
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0xc042
movl 0x30(%r15), %eax
leal -0x17(%rax), %ecx
cmpl $0x16, %ecx
ja 0x7611
leaq 0x9e05(%rip), %rdx      # 0x11340
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cvttsd2si 0x8(%rsp), %esi
cvttsd2si %xmm0, %edx
xorl %ecx, %ecx
cmpl $0x2d, %eax
sete %cl
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x76ea
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
jmp 0x75d3
mulsd 0x8(%rsp), %xmm0
jmp 0x7600
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setb %al
jmp 0x75e6
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
sete %al
jmp 0x75e6
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setne %al
jmp 0x75e6
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setbe %al
jmp 0x75e6
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
jmp 0x75e6
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x7600
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setae %al
movzbl %al, %esi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xb86c
addsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xb7f2
movq 0x139b8(%rip), %rdi     # 0x1afd0
leaq 0x9f2a(%rip), %rsi      # 0x11549
callq 0x3220
xorl %edi, %edi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::math_string(Instruction*, Value*, Value*)
Value* VM::math_string(Instruction* ins, Value* left, Value* right) {

	bool res_bool = false;
	bool is_bool = false;
	std::string l = left->getString();
	std::string r = right->getString();

	switch (ins->type) {
		case lexer::Type::OPERATOR_EQEQ:
			res_bool = l == r;
			is_bool = true;
			break;

		case lexer::Type::OPERATOR_NOT_EQ:
			res_bool = l != r;
			is_bool = true;
			break;

		default:
			std::cout << "Unknown math_string() operator\n";
			exit(0);
			break;
	}

	if (is_bool) {
		return this->get_value_bool(res_bool);
	}

	return this->get_value_number(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0xc030
movq %rsp, %rdi
movq %r15, %rsi
callq 0xc030
movl 0x30(%r14), %eax
cmpl $0x17, %eax
je 0x7673
cmpl $0x18, %eax
jne 0x76ad
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x514e
jmp 0x7680
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x8bbf
movzbl %al, %esi
movq %rbx, %rdi
callq 0xb86c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3130
leaq 0x20(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x1391c(%rip), %rdi     # 0x1afd0
leaq 0x9eae(%rip), %rsi      # 0x11569
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
jmp 0x76d7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3130
leaq 0x20(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::list_range(int, int, bool)
Value* VM::list_range(int start, int end, bool inclusive) {
	List* list = new List();
	list->set_type(Type::REFERENCE);
	list->init();

	if (!inclusive) {
		end--;
	}

	if (end < start) {
		std::cout << "Range: End needs to be bigger or equal to Start\n";
		exit(0);
	}

	std::vector<Value*> items;

	for (int i = start; i <= end; i++) {
		items.push_back(this->get_value_number(i));
	}

	list->push(items);

	return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r12d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
pushq $0x28
popq %rdi
callq 0x3230
movq %rax, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rax)
movapd %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movq %rax, %rdi
callq 0x8d1c
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xbc28
movq %rbx, %rdi
callq 0x8d34
xorb $0x1, %r12b
movzbl %r12b, %eax
subl %eax, %ebp
cmpl %r14d, %ebp
jl 0x77d1
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movapd %xmm0, (%r12)
andq $0x0, 0x10(%r12)
leaq 0x8(%rsp), %r13
cmpl %ebp, %r14d
jg 0x778f
cvtsi2sd %r14d, %xmm0
movq %r15, %rdi
callq 0xb7f2
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xb4f2
incl %r14d
jmp 0x7768
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8ee6
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x8ea2
leaq 0x30(%rsp), %rdi
callq 0x41b6
leaq 0x10(%rsp), %rdi
callq 0x41b6
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x137f8(%rip), %rdi     # 0x1afd0
leaq 0x9e6d(%rip), %rsi      # 0x1164c
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x41b6
jmp 0x780c
jmp 0x7809
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0x7816
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x41b6
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::if_case(Instruction*)
Value* VM::if_case(Instruction* ins) {

	this->env_push();

	Value* res = this->run(ins->center[0]);

	if (res->type != Type::BOOL) {
		std::cout << "If-case must evaluate to a BOOL\n";
		exit(0);
	}

	// Was true
	if (res->getBool()) {
		auto res = this->run(ins->left);
		this->env_pop();
		return res;
	}

	// Has else-part
	if (ins->right.size() > 0) {
		auto res = this->run(ins->right);
		this->env_pop();
		return res;
	}

	this->env_pop();

	// Return NUL otherwise
	return this->get_value_null();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x6f98
movq 0x68(%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x7136
cmpl $0x3, 0x8(%rax)
jne 0x78e0
movq %rax, %rdi
callq 0xc024
testb %al, %al
je 0x7880
addq $0x38, %r15
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x40b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7910
movq %rax, %r15
leaq 0x18(%rsp), %rdi
jmp 0x78ad
movq 0x58(%r15), %rax
cmpq 0x50(%r15), %rax
je 0x78c7
addq $0x50, %r15
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x40b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7910
movq %rax, %r15
movq %rsp, %rdi
callq 0x42f2
movq %rbx, %rdi
callq 0x6f84
movq %r15, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x6f84
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xb7ec
movq 0x136e9(%rip), %rdi     # 0x1afd0
leaq 0x9c9b(%rip), %rsi      # 0x11589
callq 0x3220
xorl %edi, %edi
callq 0x3280
jmp 0x78fc
movq %rax, %rbx
movq %r14, %rdi
callq 0x42f2
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::run(std::vector<Instruction*, std::allocator<Instruction*>>)
Value* VM::run(std::vector<Instruction*> ins) {

	Value* last = this->get_value_null();

	for (Instruction* i : ins) {

		last = this->run(i, vm::ON::DEFAULT);

		if (i->instruction == Ins::RETURN) {
			return last;
		}

		if (this->function_should_return()) {
			return last;
		}
	}

	return last;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0xb7ec
movq %rax, %r14
movq (%r15), %r12
movq 0x8(%r15), %r13
cmpq %r13, %r12
je 0x795d
movq (%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x7b26
movq %rax, %r14
cmpl $0x10, (%r15)
je 0x795d
movq %rbx, %rdi
callq 0x7aa0
addq $0x8, %r12
testb %al, %al
je 0x792e
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::loop_while(Instruction*)
Value* VM::loop_while(Instruction* ins) {

	while (true) {
		Value* res = this->run(ins->left[0]);

		if (res->type != Type::BOOL) {
			std::cout << "While-case must evaluate to a BOOL\n";
			return this->get_value_null();
		}

		// Not true anymore
		if (res->getBool() == false) {
			return this->get_value_null();
		}

		this->env_push();
		this->run(ins->right);
		this->env_pop();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsi), %r15
movq %rsp, %r12
movq 0x38(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x7136
cmpl $0x3, 0x8(%rax)
jne 0x79d3
movq %rax, %rdi
callq 0xc024
testb %al, %al
je 0x79e6
movq %rbx, %rdi
callq 0x6f98
movq %r12, %rdi
movq %r15, %rsi
callq 0x40b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7910
movq %r12, %rdi
callq 0x42f2
movq %rbx, %rdi
callq 0x6f84
jmp 0x7982
movq 0x135f6(%rip), %rdi     # 0x1afd0
leaq 0x9bc9(%rip), %rsi      # 0x115aa
callq 0x3220
movq %rbx, %rdi
callq 0xb7ec
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x42f2
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::kw_return(Instruction*)
Value* VM::kw_return(Instruction* ins) {

	auto res = this->run(ins->right);

	this->function_return_stack.pop_back();
	this->function_return_stack.push_back(true);

	return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x50, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x40b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7910
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x42f2
leaq 0x830(%rbx), %r15
addq $0x840, %rbx            # imm = 0x840
movq %rbx, %rdi
callq 0xafd0
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x8bca
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x42f2
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::push_class(Instruction*)
Value* VM::push_class(Instruction* ins) {
	// Run what we should push
	// Can be a name (name.method() or name::method()),
	// a literal (100.Sqrt())
	// or something else
	Value* push = this->run(ins->left[0]);

	// Add a pointer to the class to the back (aka top) of the stack
	this->lib_stack.push_back(push);

	if (ins->right.size() != 1) {
		std::cout << "push_class() expects exactly 1 child. This is a bug, please report it! :)\n";
		exit(0);
	}

	// Run the right part
	auto res = this->run(ins->right[0], vm::ON::PUSHED_CLASS);

	this->lib_stack.pop_back();

	return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
movq (%rax), %rsi
callq 0x7136
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x8c36
movq 0x50(%r14), %rax
movq 0x58(%r14), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x7b0c
movq (%rax), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x7b26
addq $-0x8, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x134bd(%rip), %rdi     # 0x1afd0
leaq 0x9ab4(%rip), %rsi      # 0x115ce
callq 0x3220
xorl %edi, %edi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::run(Instruction*, vm::ON)
Value* VM::run(Instruction* ins, vm::ON on) {
	switch (ins->instruction) {
		case Ins::ASSIGN:          return this->assign(ins, on);      break;
		case Ins::SET:             return this->set(ins, on);         break;
		case Ins::LITERAL:         return this->literal(ins);         break;
		case Ins::NAME:            return this->name(ins, on);        break;
		case Ins::MATH:            return this->math(ins);            break;
		case Ins::IF:              return this->if_case(ins);         break;
		case Ins::IGNORE:          return this->ignore(ins);          break;
		case Ins::PUSH_CLASS:      return this->push_class(ins);      break;
		case Ins::CALL:            return this->call(ins, on);        break;
		case Ins::FUNCTION:        return this->function(ins);        break;
		case Ins::CREATE_INSTANCE: return this->create_instance(ins); break;
		case Ins::WHILE:           return this->loop_while(ins);      break;
		case Ins::DEFINE_CLASS:    return this->define_class(ins);    break;
		case Ins::LIST_CREATE:     return this->list_create(ins);     break;
		case Ins::LIST_EXTRACT:    return this->list_extract(ins);    break;
		case Ins::RETURN:          return this->kw_return(ins);       break;

		case Ins::FUNCTION_PARAMETER:
			std::cout << "Could not evaluate FUNCTION_PARAMETER\n";
			exit(1);
			break;
	}

	return this->get_value_null();
}

// Assembly:
movl (%rsi), %eax
cmpq $0x10, %rax
ja 0xb7ec
leaq 0x9863(%rip), %rcx      # 0x1139c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x7080
jmp 0x7db8
jmp 0x796a
jmp 0x7382
jmp 0x7c90
movq 0x28(%rsi), %rax
retq
jmp 0x71fa
jmp 0x7abc
jmp 0x713e
jmp 0x7a0e
jmp 0x781e
jmp 0xb7ec
jmp 0x7bae
jmp 0x80ce
jmp 0x7f7a
jmp 0x7ec0
pushq %rax
movq 0x13436(%rip), %rdi     # 0x1afd0
leaq 0x9b15(%rip), %rsi      # 0x116b6
callq 0x3220
pushq $0x1
popq %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::function(Instruction*)
Value* VM::function(Instruction* ins) {
	Function* fn = new Function();
	fn->set_type(Type::FUNCTION);
	fn->init();
	
	fn->set_parameters(ins->left);
	fn->set_content(ins->right);

	fn->vm = this;

	return fn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r14
pushq $0x50
popq %rdi
callq 0x3230
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movq %rax, %rdi
callq 0x8c54
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0xbc28
leaq 0x1fec(%rip), %rax      # 0x9be6
movq %rax, (%rbx)
leaq 0x38(%r15), %rsi
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x40b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8c6e
leaq 0x20(%rsp), %rdi
callq 0x42f2
addq $0x50, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x40b0
movq %rbx, %rdi
addq $0x10, %rdi
movq %r12, %rsi
callq 0x9d64
leaq 0x8(%rsp), %rdi
callq 0x42f2
movq %r14, 0x48(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x7c75
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x42f2
jmp 0x7c87
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::define_class(Instruction*)
Value* VM::define_class(Instruction* ins) {
	Class* cl = new Class();
	cl->set_type(Type::CLASS);
	cl->init();

	cl->vm = this;

	for (Instruction* sub : ins->right) {
		if (sub->instruction != Ins::ASSIGN) {
			std::cout << "Class definitions can only contain assignments\n";
			exit(0);
		}

		cl->set_value(sub->name, this->run(sub->right[0]));
	}

	// Set in the global scope
	this->name_create_root(ins->name, cl);

	return cl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
pushq $0x50
popq %rdi
callq 0x3230
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movq %rax, %rdi
callq 0x8cee
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0xbc28
movq %r14, 0x10(%rbx)
movq 0x50(%r15), %r13
movq %r15, (%rsp)
movq 0x58(%r15), %rbp
leaq 0x28(%rsp), %r12
cmpq %rbp, %r13
je 0x7d33
movq (%r13), %r15
cmpl $0x0, (%r15)
jne 0x7d72
leaq 0x8(%r15), %rsi
movq %r12, %rdi
callq 0x32b0
movq 0x50(%r15), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x7136
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x8970
movq %r12, %rdi
callq 0x3130
addq $0x8, %r13
jmp 0x7ced
movq (%rsp), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x32b0
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x6dea
leaq 0x8(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x13257(%rip), %rdi     # 0x1afd0
leaq 0x9899(%rip), %rsi      # 0x11619
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x7dab
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0x7db0
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::list_create(Instruction*)
Value* VM::list_create(Instruction* ins) {
	List* list = new List();
	list->set_type(Type::REFERENCE);
	list->init();

	if (ins->right.size() > 0) {
		std::vector<Value*> values;

		for (Instruction* i : ins->right) {
			values.push_back(this->run(i));
		}

		list->push(values);
	}

	return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x3230
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movq %rax, %rdi
callq 0x8d1c
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xbc28
movq %rbx, %rdi
callq 0x8d34
movq 0x50(%r15), %r13
movq 0x58(%r15), %rbp
cmpq %r13, %rbp
je 0x7e7b
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
leaq 0x8(%rsp), %r12
cmpq %rbp, %r13
je 0x7e4b
movq (%r13), %rsi
movq %r14, %rdi
callq 0x7136
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xb4f2
addq $0x8, %r13
jmp 0x7e24
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8ee6
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x8ea2
leaq 0x30(%rsp), %rdi
callq 0x41b6
leaq 0x10(%rsp), %rdi
callq 0x41b6
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x41b6
jmp 0x7eae
jmp 0x7eab
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0x7eb8
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x41b6
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::create_instance(Instruction*)
Value* VM::create_instance(Instruction* ins) {
	Value* original = this->name_get(ins->name);

	// Kram-defined classes
	if (original->type == Type::CLASS) {
		// Cast as class
		Class* cl = static_cast<Class*>(original);
		return cl->new_instance();
	}

	Value* instance = original->exec_method("new", this->run_vector(ins->right));
	return instance;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r15
movq %rdi, %r14
addq $0x8, %rsi
callq 0x6f70
movq %rax, %rbx
cmpl $0x6, 0x8(%rax)
jne 0x7fac
movq %rbx, %rdi
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x8f6a
leaq 0x9266(%rip), %rsi      # 0x11219
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
addq $0x50, %r15
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x40b0
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq 0x8058
leaq 0x40(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0xbcb2
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x41b6
leaq 0x10(%rsp), %rdi
callq 0x42f2
leaq 0x40(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x41b6
jmp 0x8037
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x42f2
jmp 0x8046
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::run_vector(std::vector<Instruction*, std::allocator<Instruction*>>)
std::vector<Value*> VM::run_vector(std::vector<Instruction*> instructions) {
	std::vector<Value*> res;

	for (Instruction* i : instructions) {
		res.push_back(this->run(i));
	}

	return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rdx), %r12
movq 0x8(%rdx), %r13
leaq 0x8(%rsp), %r15
cmpq %r13, %r12
je 0x80a9
movq (%r12), %rsi
movq %r14, %rdi
callq 0x7136
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb4f2
addq $0x8, %r12
jmp 0x8082
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x41b6
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::call_builtin(Instruction*, Value*)
Value* VM::call_builtin(Instruction* ins, Value* name) {

	// Get the value from the top of the stack
	Value* builtin_value = this->lib_stack.back();

	// Get library
	std::string lib_name;// = new std::string;

	switch (builtin_value->type) {
		case Type::NUMBER: lib_name = "Number"; break;
		case Type::STRING: lib_name = "String"; break;
		default:
			std::cout << "call_builtin(): Can not call on " << builtin_value->print() << "\n";
			exit(0);
			break;
	}

	Value* lib = this->name_get(lib_name);

	// Initialize parameter vector with the first value beeing the bultin itself
	std::vector<Value*> params { builtin_value };

	for (auto param : ins->right) {
		params.push_back(this->run(param));
	}

	// Call the method
	return lib->exec_method(name->getString(), params);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq -0x8(%rax), %r12
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %r13
movb $0x0, (%rax)
movl 0x8(%r12), %eax
cmpl $0x1, %eax
je 0x8377
cmpl $0x2, %eax
jne 0x845d
leaq 0x9312(%rip), %rsi      # 0x11687
jmp 0x837e
leaq 0x9310(%rip), %rsi      # 0x1168e
leaq 0x58(%rsp), %rdi
callq 0x33c0
leaq 0x58(%rsp), %rsi
movq %r14, %rdi
callq 0x6f70
movq %rax, 0x38(%rsp)
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rdx
leaq 0xf(%rsp), %rcx
callq 0x8f34
movq 0x50(%r13), %rbp
movq 0x58(%r13), %rbx
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
cmpq %rbx, %rbp
je 0x83ed
movq (%rbp), %rsi
movq %r14, %rdi
callq 0x7136
movq %rax, 0x10(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xb4f2
addq $0x8, %rbp
jmp 0x83c6
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
callq 0xc030
leaq 0x40(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x8ee6
movq 0x38(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xbcb2
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x41b6
leaq 0x78(%rsp), %rdi
callq 0x3130
leaq 0x18(%rsp), %rdi
callq 0x41b6
leaq 0x58(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x12b6c(%rip), %rdi     # 0x1afd0
leaq 0x922a(%rip), %rsi      # 0x11695
callq 0x3220
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xbe30
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3200
leaq 0x93b3(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
leaq 0x18(%rsp), %rdi
callq 0x3130
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3130
jmp 0x84f6
jmp 0x84e4
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x41b6
jmp 0x84d2
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x3130
jmp 0x84ec
jmp 0x84e9
jmp 0x84e4
jmp 0x84e4
movq %rax, %rbx
jmp 0x84f6
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x41b6
leaq 0x58(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/vm.cpp
// Function: VM::call_library(Instruction*)
Value* VM::call_library(Instruction* ins) {

	// Get the method name
	Value* name = this->name(ins->left[0], vm::ON::DEFAULT);

	// Get the library from the top of the stack
	Value* lib = this->lib_stack.back();

	// Execute the parameters and call the method
	return lib->exec_method(name->getString(), this->run_vector(ins->right));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x38(%rsi), %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x71fa
movq 0x8(%r14), %rcx
movq -0x8(%rcx), %rbx
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0xc030
addq $0x50, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x40b0
leaq 0x18(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq 0x8058
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0xbcb2
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x41b6
movq %rsp, %rdi
callq 0x42f2
leaq 0x30(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x41b6
jmp 0x85a9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x42f2
jmp 0x85b6
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/user/class.h
// Function: Class::set_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Value*)
void set_value(std::string name, Value* val) {
			
			if (this->values.find(name) != this->values.end()) {
				std::cout << "The value, " << name << ", already exists in this Class. Did you mean to use = ?\n";
				exit(0);
			}

			this->values.insert( {{ name, val }} );
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %r14
movq %r14, %rdi
callq 0x9614
testq %rax, %rax
jne 0x89cc
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x32b0
movq %r15, 0x20(%r12)
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x96e4
movq %rsp, %rdi
callq 0x3130
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x125fd(%rip), %rdi     # 0x1afd0
leaq 0x8d14(%rip), %rsi      # 0x116ee
callq 0x3220
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3200
leaq 0x8d09(%rip), %rsi      # 0x116fa
movq %rax, %rdi
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/user/class.h
// Function: Class::update_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Value*)
void update_value(std::string name, Value* val) {

			// Not found
			if (this->values.find(name) == this->values.end()) {
				std::cout << "No such value, " << name << ", did you mean to use the := operation?\n";
				exit(0);
			}

			// The values needs to be of the same type
			if (this->values[name]->type != val->type) {
				std::cout << "Can not update (with =) a variable of type " << this->values[name]->print(true) << " to " << val->print(true) << "\n";
				exit(0);
			}

			this->values[name] = val;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x18, %r15
movq %r15, %rdi
callq 0x9614
testq %rax, %rax
je 0x8a69
movq %r15, %rdi
movq %r14, %rsi
callq 0x9ab0
movq (%rax), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rbx), %eax
jne 0x8a9d
movq %r15, %rdi
movq %r14, %rsi
callq 0x9ab0
movq %rbx, (%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x12560(%rip), %rdi     # 0x1afd0
leaq 0x8cbc(%rip), %rsi      # 0x11733
callq 0x3220
movq %rax, %rdi
movq %r14, %rsi
callq 0x3200
leaq 0x8cb5(%rip), %rsi      # 0x11743
movq %rax, %rdi
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq 0x1252c(%rip), %rdi     # 0x1afd0
leaq 0x8861(%rip), %rsi      # 0x1130c
callq 0x3220
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x9ab0
movq (%rax), %rsi
leaq 0x28(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0xbe30
movq %r12, %rdi
movq %r14, %rsi
callq 0x3200
leaq 0x8855(%rip), %rsi      # 0x11338
movq %rax, %rdi
callq 0x3220
movq %rax, %r14
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0xbe30
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3200
leaq 0x8d37(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0x28(%rsp), %rdi
callq 0x3130
jmp 0x8a96
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3130
jmp 0x8b47
jmp 0x8b44
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/user/class.h
// Function: Class::get_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Value* get_value(std::string name) {

			if (this->values.find(name) == this->values.end()) {
				std::cout << "Class has no such value, " << name << "\n";
				exit(0);
			}

			return this->values[name];
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %r14
movq %r14, %rdi
callq 0x9614
testq %rax, %rax
je 0x8b8b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9ab0
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1243e(%rip), %rdi     # 0x1afd0
leaq 0x8bd3(%rip), %rsi      # 0x1176c
callq 0x3220
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3200
leaq 0x8c99(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
xorl %edi, %edi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/user/function.h
// Function: Function::set_parameters(std::vector<Instruction*, std::allocator<Instruction*>>)
void set_parameters(std::vector<Instruction*> ins) {
			this->parameters = ins;

			this->required_parameter_count = 0;

			// Pre-calculated values and validation
			for (Instruction* i : ins) {

				if (i->instruction != Ins::FUNCTION_PARAMETER) {
					std::cout << "A function can only take parameters of type FUNCTION_PARAMETER\n";
					exit(1);
				}

				if (i->right.size() == 0) {
					this->required_parameter_count++;
					continue;
				}

				if (i->right.size() > 1) {
					std::cout << "Function: The size of a default parameter can only be one!\n";
					exit(1);
				}
			}
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x9d64
andq $0x0, 0x40(%rbx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
xorl %edx, %edx
cmpq %rcx, %rax
je 0x8cbb
movq (%rax), %rsi
cmpl $0xb, (%rsi)
jne 0x8cc3
movq 0x58(%rsi), %rdi
subq 0x50(%rsi), %rdi
je 0x8cae
cmpq $0x9, %rdi
jb 0x8cb5
jmp 0x8cd3
incq %rdx
movq %rdx, 0x40(%rbx)
addq $0x8, %rax
jmp 0x8c8f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x12306(%rip), %rdi     # 0x1afd0
leaq 0x8afe(%rip), %rsi      # 0x117cf
jmp 0x8ce1
movq 0x122f6(%rip), %rdi     # 0x1afd0
leaq 0x8b2e(%rip), %rsi      # 0x1180f
callq 0x3220
pushq $0x1
popq %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/std/List.h
// Function: List::init()
void init() {
			this->add_method("new", this->kr_constructor);

			this->add_method("Push", this->kr_push);
			this->add_method("Pop", this->kr_pop);
			this->add_method("At", this->kr_at);
			this->add_method("Size", this->kr_size);
		}

// Assembly:
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x84d3(%rip), %rsi      # 0x11219
leaq 0x90(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x10f9(%rip), %rdx      # 0x9e58
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x90(%rsp), %rdi
callq 0x3130
leaq 0x8ac8(%rip), %rsi      # 0x1184b
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x1117(%rip), %rdx      # 0x9eb0
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x70(%rsp), %rdi
callq 0x3130
leaq 0x8a99(%rip), %rsi      # 0x11850
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x1153(%rip), %rdx      # 0x9f20
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x50(%rsp), %rdi
callq 0x3130
leaq 0x885e(%rip), %rsi      # 0x11649
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x116b(%rip), %rdx      # 0x9f6c
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x30(%rsp), %rdi
callq 0x3130
leaq 0x8a35(%rip), %rsi      # 0x11854
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x1201(%rip), %rdx      # 0xa036
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x10(%rsp), %rdi
callq 0x3130
addq $0xb0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x8e90
jmp 0x8e97
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x8e90
jmp 0x8e97
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x8e90
jmp 0x8e97
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x8e90
jmp 0x8e97
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x3130
jmp 0x8e9a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/user/class.h
// Function: Class::new_instance()
Value* new_instance() {

			Class* cl = new Class();
			cl->type = Type::CLASS;
			cl->vm = this->vm;

			for (auto i : this->values) {
				cl->values.insert( {{ i.first, i.second->clone() }} );
			}

			return cl;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
pushq $0x50
popq %rdi
callq 0x3230
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movq %rax, %rdi
callq 0x8cee
movl $0x6, 0x8(%r15)
movq 0x10(%r14), %rax
movq %rax, 0x10(%r15)
addq $0x28, %r14
movq %r15, (%rsp)
addq $0x18, %r15
leaq 0x30(%rsp), %r12
leaq 0x30(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq (%r14), %r14
testq %r14, %r14
je 0x9020
leaq 0x8(%r14), %rsi
movq %r13, %rdi
callq 0x990e
movq 0x50(%rsp), %rdi
callq 0xc048
movq %rax, %rbx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x32b0
movq %rbx, 0x28(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x96e4
movq %rbp, %rdi
callq 0x3130
movq %r13, %rdi
callq 0x3130
jmp 0x8fcf
movq (%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x3210
jmp 0x905c
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3130
jmp 0x9052
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/std/Number.h
// Function: Number::init()
void init() {
			this->add_method("Add", this->add);

			this->add_method("Abs", this->abs);
			this->add_method("Sqrt", this->sqrt);

			this->add_method("Sin", this->sin);
			this->add_method("Cos", this->cos);
			this->add_method("Tan", this->tan);
		}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x887d(%rip), %rsi      # 0x119cf
leaq 0xb0(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x1179(%rip), %rdx      # 0xa2e4
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0xb0(%rsp), %rdi
callq 0x3130
leaq 0x8844(%rip), %rsi      # 0x119d3
leaq 0x90(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x11f2(%rip), %rdx      # 0xa39a
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x90(%rsp), %rdi
callq 0x3130
leaq 0x880b(%rip), %rsi      # 0x119d7
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x1206(%rip), %rdx      # 0xa3e8
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x70(%rsp), %rdi
callq 0x3130
leaq 0x87dc(%rip), %rsi      # 0x119dc
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x121c(%rip), %rdx      # 0xa432
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x50(%rsp), %rdi
callq 0x3130
leaq 0x87ac(%rip), %rsi      # 0x119e0
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x1234(%rip), %rdx      # 0xa47e
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x30(%rsp), %rdi
callq 0x3130
leaq 0x877c(%rip), %rsi      # 0x119e4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x124c(%rip), %rdx      # 0xa4ca
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x10(%rsp), %rdi
callq 0x3130
addq $0xd0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x92e8
jmp 0x92ef
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x92e8
jmp 0x92ef
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x92e8
jmp 0x92ef
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x92e8
jmp 0x92ef
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x92e8
jmp 0x92ef
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x3130
jmp 0x92f2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/std/Map.h
// Function: Map::Map()
static Value* constructor(Value* self, std::vector<Value*> val) {
		Map* instance = new Map();
		instance->set_type(Type::REFERENCE);
		instance->init();

		return instance;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xbad8
leaq 0x40(%rbx), %rax
movq %rax, 0x10(%rbx)
movq $0x1, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movl $0x3f800000, 0x30(%rbx) # imm = 0x3F800000
movups %xmm0, 0x38(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/std/Map.h
// Function: Map::init()
void init() {
			this->add_method("new", this->constructor);

			this->add_method("Set", this->set);
			this->add_method("Get", this->get);
			this->add_method("Has", this->has);
		}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x7e03(%rip), %rsi      # 0x11219
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x16fa(%rip), %rdx      # 0xab26
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x70(%rsp), %rdi
callq 0x3130
leaq 0x8693(%rip), %rsi      # 0x11add
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x1726(%rip), %rdx      # 0xab86
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x50(%rsp), %rdi
callq 0x3130
leaq 0x8663(%rip), %rsi      # 0x11ae1
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x17be(%rip), %rdx      # 0xac52
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x30(%rsp), %rdi
callq 0x3130
leaq 0x8633(%rip), %rsi      # 0x11ae5
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x1864(%rip), %rdx      # 0xad2c
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfb8
leaq 0x10(%rsp), %rdi
callq 0x3130
addq $0x90, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x9514
jmp 0x951b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x9514
jmp 0x951b
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x9514
jmp 0x951b
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x3130
jmp 0x951e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/std/List.h
// Function: List::kr_constructor(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* kr_constructor(Value* self, std::vector<Value*> val) {
		List* instance = new List();
		instance->set_type(Type::REFERENCE);
		instance->init();

		return instance;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
pushq $0x28
popq %rdi
callq 0x3230
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movq %rax, %rdi
callq 0x8d1c
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xbc28
movq %rbx, %rdi
callq 0x8d34
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/std/List.h
// Function: List::kr_pop(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* kr_pop(Value* self, std::vector<Value*> val) {

		if (val.size() != 0) {
			std::cout << "List.Pop() takes no parameters\n";
			exit(0);
		}

		List* list = static_cast<List*>(self);

		if (list->content.size() == 0) {
			std::cout << "List.Pop() requires the list to contain at least 1 item\n";
			exit(0);
		}

		Value* res = list->content.back();

		list->content.pop_back();

		return res;
	}

// Assembly:
pushq %rax
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
jne 0x9f42
movq 0x18(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
je 0x9f52
movq -0x8(%rcx), %rax
addq $-0x8, %rcx
movq %rcx, 0x18(%rdi)
popq %rcx
retq
movq 0x11087(%rip), %rdi     # 0x1afd0
leaq 0x7933(%rip), %rsi      # 0x11883
jmp 0x9f60
movq 0x11077(%rip), %rdi     # 0x1afd0
leaq 0x7943(%rip), %rsi      # 0x118a3
callq 0x3220
xorl %edi, %edi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/std/Number.h
// Function: Number::add(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* add(Value* self, std::vector<Value*> val) {

		if (val.size() != 2) {
			std::cout << val.size();
			std::cout << "Number::Add(Number) Excepts exactly 1 parameter\n";
			exit(0);
		}

		if (val[1]->type != Type::NUMBER) {
			std::cout << "Number::Add() Expects the first parameter to be of type Number\n";
			exit(0);
		}

		auto num = val[0]->getNumber();

		num += val[1]->getNumber();

		return new Value(Type::NUMBER, num);

	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
subq %rax, %rsi
cmpq $0x10, %rsi
jne 0xa34e
movq 0x8(%rax), %rcx
cmpl $0x2, 0x8(%rcx)
jne 0xa36d
movq (%rax), %rdi
callq 0xc042
movsd %xmm0, (%rsp)
movq (%rbx), %rax
movq 0x8(%rax), %rdi
callq 0xc042
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
pushq $0x2
popq %rsi
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0xbb54
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
sarq $0x3, %rsi
movq 0x10c77(%rip), %rbx     # 0x1afd0
movq %rbx, %rdi
callq 0x3080
leaq 0x7680(%rip), %rsi      # 0x119e8
movq %rbx, %rdi
jmp 0xa37b
movq 0x10c5c(%rip), %rdi     # 0x1afd0
leaq 0x769e(%rip), %rsi      # 0x11a19
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3390