LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
cmpl $0x1, %edx
jne 0x7e68
movq 0x8(%rdi), %rax
movq -0x8(%rax), %rbx
movl 0x8(%rbx), %eax
cmpl $0x4, %eax
je 0x7e82
cmpl $0x6, %eax
jne 0x7f0c
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x473c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9d50
movq %rax, %rbx
movq 0x68(%rsp), %rdi
jmp 0x7f4e
addq $0x8, %r14
movq %r14, %rsi
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7b08
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x473c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd49c
movl %eax, %ebx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x7ec0
callq 0x3230
testb %bl, %bl
je 0x7f6a
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x473c
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x7, %esi
callq 0xcee0
movq 0x28(%rsp), %rdi
jmp 0x7f4e
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x473c
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x7, %esi
callq 0xcee0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7f58
callq 0x3230
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x8, %r14
movq 0x1405b(%rip), %rdi     # 0x1bfd0
leaq 0xb62e(%rip), %rsi      # 0x135aa
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0xb974(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %r14
movq 0x28(%rsp), %rdi
jmp 0x7fb6
jmp 0x7fc2
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7fc5
callq 0x3230
jmp 0x7fc5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x33c0
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
jne 0x7fc8
jmp 0x7fcd
movq %rax, %r14
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
jne 0x7fc8
jmp 0x7fcd
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %edx, %edx
callq 0x89c2
movq %rax, %r14
movq 0x50(%r15), %rax
movq (%rax), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x89c2
movq %rax, %rbx
movl 0x8(%r14), %eax
cmpl 0x8(%rbx), %eax
jne 0x8079
cmpl $0x1, %eax
je 0x805d
cmpl $0x2, %eax
jne 0x8110
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x81a6
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x82e6
movq 0x13f50(%rip), %r15     # 0x1bfd0
leaq 0xb53f(%rip), %rsi      # 0x135c6
movl $0x20, %edx
movq %r15, %rdi
callq 0x32a0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xd204
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x32a0
movq %rax, %r14
leaq 0xb523(%rip), %rsi      # 0x135e7
movl $0x5, %edx
movq %rax, %rdi
callq 0x32a0
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd204
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0xb80b(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
leaq 0x28(%rsp), %rdi
callq 0x3120
jmp 0x815b
movq 0x13eb9(%rip), %rbx     # 0x1bfd0
leaq 0xb4cf(%rip), %rsi      # 0x135ed
movl $0x23, %edx
movq %rbx, %rdi
callq 0x32a0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd204
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x32a0
leaq 0xb7b4(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
leaq 0x8(%rsp), %rdi
callq 0x3120
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x818b
callq 0x3230
jmp 0x818b
jmp 0x8188
jmp 0x8188
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x819e
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd4dc
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0xd4dc
movl 0x30(%r15), %eax
leal -0x17(%rax), %ecx
cmpl $0x16, %ecx
ja 0x82cc
leaq 0xb213(%rip), %rdx      # 0x133f8
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 0x8408
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
jmp 0x827a
mulsd 0x8(%rsp), %xmm0
jmp 0x829f
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setb %al
jmp 0x8291
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
sete %al
jmp 0x8291
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setne %al
jmp 0x8291
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setbe %al
jmp 0x8291
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
jmp 0x8291
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
xorl %eax, %eax
xorl %ecx, %ecx
movapd %xmm1, %xmm0
jmp 0x82a3
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setae %al
xorpd %xmm0, %xmm0
movb $0x1, %cl
jmp 0x82a3
addsd 0x8(%rsp), %xmm0
xorl %eax, %eax
xorl %ecx, %ecx
testb %cl, %cl
je 0x82bb
movzbl %al, %esi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xcb72
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xcaf4
movq 0x13cfd(%rip), %rdi     # 0x1bfd0
leaq 0xb337(%rip), %rsi      # 0x13611
callq 0x3250
xorl %edi, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd4ba
movq %rsp, %rdi
movq %r15, %rsi
callq 0xd4ba
movl 0x30(%r14), %eax
cmpl $0x17, %eax
je 0x8348
cmpl $0x18, %eax
jne 0x83b7
movq 0x28(%rsp), %rdx
cmpq 0x8(%rsp), %rdx
jne 0x8370
testq %rdx, %rdx
je 0x8374
movq (%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x3270
testl %eax, %eax
sete %al
jmp 0x8376
movq 0x28(%rsp), %rdx
movb $0x1, %al
cmpq 0x8(%rsp), %rdx
jne 0x8376
testq %rdx, %rdx
je 0x8370
movq (%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x3270
testl %eax, %eax
setne %al
jmp 0x8376
xorl %eax, %eax
jmp 0x8376
movb $0x1, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0xcb72
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8397
callq 0x3230
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83aa
callq 0x3230
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x13c12(%rip), %rdi     # 0x1bfd0
leaq 0xb26c(%rip), %rsi      # 0x13631
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
jmp 0x83ec
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83ec
callq 0x3230
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83ff
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movl %ecx, %r12d
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rax)
movapd %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, %rdi
callq 0xce14
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
movl $0x4, %esi
callq 0xcfa6
movq %rbx, %rdi
callq 0x9e8c
xorb $0x1, %r12b
movzbl %r12b, %eax
movl %r15d, %ecx
subl %eax, %ecx
cmpl %ebp, %ecx
jl 0x8530
negl %eax
xorpd %xmm0, %xmm0
movq %rsp, %r12
movapd %xmm0, (%r12)
movq $0x0, 0x10(%r12)
leal (%r15,%rax), %r13d
incl %r13d
leaq 0x18(%rsp), %r15
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movq %r14, %rdi
callq 0xcaf4
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x84d5
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x84e0
movq %r12, %rdi
movq %r15, %rdx
callq 0xc7ee
incl %ebp
cmpl %ebp, %r13d
jne 0x84aa
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xa09c
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xa04c
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8510
callq 0x3230
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x851e
callq 0x3230
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x13a99(%rip), %rdi     # 0x1bfd0
leaq 0xb1d6(%rip), %rsi      # 0x13714
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x856b
callq 0x3230
jmp 0x856b
jmp 0x8568
movq %rax, %r14
movq %rbx, %rdi
jmp 0x8574
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8579
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
callq 0x7b30
movq 0x68(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x89c2
cmpl $0x3, 0x8(%rax)
jne 0x864c
movq %rax, %rdi
callq 0xd4ae
testb %al, %al
je 0x85e6
addq $0x38, %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x450e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x868a
movq %rax, %r14
movq 0x18(%rsp), %rdi
jmp 0x8614
movq 0x58(%r14), %rax
cmpq 0x50(%r14), %rax
je 0x8633
addq $0x50, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x450e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x868a
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x861e
callq 0x3230
movq %rbx, %rdi
callq 0x7b1c
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x7b1c
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xcaee
movq 0x1397d(%rip), %rdi     # 0x1bfd0
leaq 0xaff7(%rip), %rsi      # 0x13651
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x8677
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8681
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xcaee
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x8745
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
addq $0x3f, %rax
movq %rax, (%rsp)
movq (%r15), %r14
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x89c2
cmpl $0x10, (%r14)
movq %rax, %rcx
je 0x872f
movl 0x848(%rbx), %ecx
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
shlq $0x3, %rcx
addq 0x840(%rbx), %rcx
movq %rdx, %rsi
andq (%rsp), %rsi
xorl %edi, %edi
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
cmpq %r8, %rsi
setbe %dil
movq -0x8(%rcx,%rdi,8), %rcx
btq %rdx, %rcx
setae %bpl
movq %rax, %rcx
cmovaeq %r13, %rcx
testb %bpl, %bpl
je 0x8742
addq $0x8, %r15
movq %rcx, %r13
cmpq %r12, %r15
jne 0x86c2
jmp 0x8745
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x13858(%rip), %r13     # 0x1bfd0
leaq 0xaef3(%rip), %r15      # 0x13672
movq 0x38(%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x89c2
cmpl $0x3, 0x8(%rax)
jne 0x87e8
movq %rax, %rdi
callq 0xd4ae
testb %al, %al
je 0x87f8
movq %r13, %rbp
movq %r14, %rdi
callq 0x7b30
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x450e
movq %r14, %rdi
movq %r13, %rsi
callq 0x868a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
movq %rbp, %r13
je 0x87dc
callq 0x3230
movq %r14, %rdi
callq 0x7b1c
movb $0x1, %al
jmp 0x8805
movl $0x23, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x32a0
movq %r14, %rdi
callq 0xcaee
movq %rax, %r12
xorl %eax, %eax
testb %al, %al
jne 0x877f
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8831
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x50, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x450e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x868a
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x886f
callq 0x3230
subl $0x1, 0x848(%rbx)
jae 0x888a
movl $0x3f, 0x848(%rbx)
addq $-0x8, 0x840(%rbx)
addq $0x830, %rbx            # imm = 0x830
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9db6
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x88ba
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %edx, %edx
callq 0x89c2
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x896e
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x8979
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xc32c
movq 0x50(%r14), %rax
movq 0x58(%r14), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x89a7
movq (%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x89c2
addq $-0x8, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x13622(%rip), %rdi     # 0x1bfd0
leaq 0xace1(%rip), %rsi      # 0x13696
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcaee
leaq 0xaa7f(%rip), %rcx      # 0x13454
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x7c26
jmp 0x8ce6
jmp 0x8754
jmp 0x7ff4
jmp 0x8b4e
movq 0x28(%rsi), %rax
retq
jmp 0x7e00
jmp 0x893e
jmp 0x7d14
jmp 0x883a
jmp 0x8582
jmp 0xcaee
jmp 0x8a4c
jmp 0x90a2
jmp 0x8f04
jmp 0x8e2c
pushq %rax
movq 0x1359a(%rip), %rdi     # 0x1bfd0
leaq 0xad37(%rip), %rsi      # 0x13774
callq 0x3250
movl $0x1, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x50, %edi
callq 0x3260
movq %rax, %r12
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 0xce14
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0xcfa6
leaq 0x23ee(%rip), %rax      # 0xae9e
movq %rax, (%rbx)
leaq 0x38(%r15), %rsi
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x450e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x9e04
addq $0x10, %r12
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8ae2
callq 0x3230
addq $0x50, %r15
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x450e
movq %r12, %rdi
movq %r13, %rsi
callq 0xb050
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8b0d
callq 0x3230
movq %r14, 0x48(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
jmp 0x8b33
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
jne 0x8b40
jmp 0x8b45
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbp
movl $0x50, %edi
callq 0x3260
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 0xce14
movq %rbx, %rax
addq $0x48, %rax
movq %rax, 0x18(%rbx)
movq $0x1, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl $0x3f800000, 0x38(%rbx) # imm = 0x3F800000
movups %xmm0, 0x40(%rbx)
movq %rbx, %rdi
movl $0x6, %esi
callq 0xcfa6
movq %rbp, 0x10(%rbx)
movq 0x50(%r15), %r13
movq %r15, (%rsp)
movq 0x58(%r15), %r15
cmpq %r15, %r13
je 0x8c40
leaq 0x8(%rsp), %r12
movq (%r13), %r14
cmpl $0x0, (%r14)
jne 0x8c95
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x473c
movq 0x50(%r14), %rax
movq (%rax), %rsi
movq %rbp, %rdi
xorl %edx, %edx
callq 0x89c2
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9b1c
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8c37
callq 0x3230
addq $0x8, %r13
cmpq %r15, %r13
jne 0x8bd9
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x473c
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x792e
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x8c83
callq 0x3230
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x13334(%rip), %rdi     # 0x1bfd0
leaq 0xaa3e(%rip), %rsi      # 0x136e1
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
jne 0x8cd8
jmp 0x8cdd
movq %rax, %r14
movq %rbx, %rdi
jmp 0x8cd8
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8cdd
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, %rdi
callq 0xce14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
movl $0x4, %esi
callq 0xcfa6
movq %rbx, %rdi
callq 0x9e8c
movq 0x50(%r15), %r13
movq 0x58(%r15), %rbp
cmpq %r13, %rbp
je 0x8de2
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
leaq 0x18(%rsp), %r12
movq (%r13), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x89c2
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x8d97
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x8da2
movq %r15, %rdi
movq %r12, %rdx
callq 0xc7ee
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x8d6d
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xa09c
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xa04c
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8dd4
callq 0x3230
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8de2
callq 0x3230
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8e15
callq 0x3230
jmp 0x8e15
jmp 0x8e12
movq %rax, %r14
movq %rbx, %rdi
jmp 0x8e1e
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8e23
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %r14
addq $0x8, %rsi
callq 0x7b08
movq %rax, %rbx
cmpl $0x6, 0x8(%rax)
jne 0x8f3a
movq %rbx, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa15a
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movl $0x77656e, (%r12)       # imm = 0x77656E
movq $0x3, -0x8(%r12)
addq $0x50, %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x450e
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x900c
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0xd046
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8f9c
callq 0x3230
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8fab
callq 0x3230
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x8fba
callq 0x3230
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8fe0
callq 0x3230
jmp 0x8fe0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8ff4
callq 0x3230
jmp 0x8ff4
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x9003
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %r12
movq 0x8(%rdx), %r13
cmpq %r13, %r12
je 0x9079
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq (%r12), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x89c2
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x9065
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x9070
movq %rbx, %rdi
movq %r15, %rdx
callq 0xc7ee
addq $0x8, %r12
cmpq %r13, %r12
jne 0x903e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x909a
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq 0x38(%rsi), %rax
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x7b08
movq 0x8(%rbx), %rcx
movq -0x8(%rcx), %r14
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0xd4ba
addq $0x50, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x450e
leaq 0x18(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x900c
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0xd046
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9619
callq 0x3230
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9627
callq 0x3230
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x963a
callq 0x3230
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x965e
callq 0x3230
jmp 0x965e
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9671
callq 0x3230
jmp 0x9671
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9684
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rbx
movq %rbx, %rdi
callq 0xa934
testq %rax, %rax
jne 0x9b94
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x473c
movq %r15, 0x20(%r14)
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa30
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x9b88
callq 0x3230
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x12435(%rip), %rdi     # 0x1bfd0
leaq 0x9c0a(%rip), %rsi      # 0x137ac
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0x9bff(%rip), %rsi      # 0x137b8
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x9bda
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa934
testq %rax, %rax
je 0x9c37
movq %r15, %rdi
movq %r14, %rsi
callq 0xad5c
movq (%rax), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rbx), %eax
jne 0x9c6b
movq %r15, %rdi
movq %r14, %rsi
callq 0xad5c
movq %rbx, (%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x12392(%rip), %rdi     # 0x1bfd0
leaq 0x9bac(%rip), %rsi      # 0x137f1
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0x9ba5(%rip), %rsi      # 0x13801
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq 0x1235e(%rip), %r12     # 0x1bfd0
leaq 0x974b(%rip), %rsi      # 0x133c4
movl $0x2b, %edx
movq %r12, %rdi
callq 0x32a0
movq %r15, %rdi
movq %r14, %rsi
callq 0xad5c
movq (%rax), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x1, %edx
callq 0xd204
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x32a0
movq %rax, %r14
leaq 0x9731(%rip), %rsi      # 0x133f0
movl $0x4, %edx
movq %rax, %rdi
callq 0x32a0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd204
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0x9c10(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
leaq 0x8(%rsp), %rdi
callq 0x3120
leaq 0x28(%rsp), %rdi
callq 0x3120
jmp 0x9c64
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9d35
callq 0x3230
jmp 0x9d35
jmp 0x9d32
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9d48
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa934
testq %rax, %rax
je 0x9d81
movq %r14, %rdi
movq %rbx, %rsi
callq 0xad5c
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x12248(%rip), %rdi     # 0x1bfd0
leaq 0x9a9b(%rip), %rsi      # 0x1382a
callq 0x3250
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3220
leaq 0x9b61(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb050
movq $0x0, 0x40(%rbx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x9e57
xorl %edx, %edx
movq (%rax), %rsi
cmpl $0xb, (%rsi)
jne 0x9e5f
movq 0x58(%rsi), %rdi
subq 0x50(%rsi), %rdi
je 0x9e47
cmpq $0x9, %rdi
jb 0x9e4e
jmp 0x9e6f
incq %rdx
movq %rdx, 0x40(%rbx)
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x9e2d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1216a(%rip), %rdi     # 0x1bfd0
leaq 0x9a20(%rip), %rsi      # 0x1388d
jmp 0x9e7d
movq 0x1215a(%rip), %rdi     # 0x1bfd0
leaq 0x9a50(%rip), %rsi      # 0x138cd
callq 0x3250
movl $0x1, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9423(%rip), %rsi      # 0x132d1
leaq 0x941f(%rip), %rdx      # 0x132d4
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x1252(%rip), %rdx      # 0xb11e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x9ee9
callq 0x3230
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9a10(%rip), %rsi      # 0x13909
leaq 0x9a0d(%rip), %rdx      # 0x1390d
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x1278(%rip), %rdx      # 0xb18c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x9f2e
callq 0x3230
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x99d0(%rip), %rsi      # 0x1390e
leaq 0x99cc(%rip), %rdx      # 0x13911
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x12b5(%rip), %rdx      # 0xb20e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x9f73
callq 0x3230
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x978e(%rip), %rsi      # 0x13711
leaq 0x9789(%rip), %rdx      # 0x13713
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x12bc(%rip), %rdx      # 0xb25a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x9fb8
callq 0x3230
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x994a(%rip), %rsi      # 0x13912
leaq 0x9947(%rip), %rdx      # 0x13916
movq %rsp, %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x134f(%rip), %rdx      # 0xb330
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x9ffa
callq 0x3230
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xa039
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0xa039
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0xa039
movq %rax, %rbx
movq 0x60(%rsp), %rdi
jmp 0xa039
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0xa043
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x68, %rsp
movq %rdi, %r14
movl $0x50, %edi
callq 0x3260
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 0xce14
leaq 0x48(%rbx), %rax
movq %rax, 0x18(%rbx)
movq $0x1, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl $0x3f800000, 0x38(%rbx) # imm = 0x3F800000
movups %xmm0, 0x40(%rbx)
movl $0x6, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rbx, 0x8(%rsp)
movq %rax, 0x10(%rbx)
movq 0x28(%r14), %r13
testq %r13, %r13
je 0xa27b
movq 0x8(%rsp), %r14
addq $0x18, %r14
leaq 0x28(%rsp), %r15
leaq 0x50(%rsp), %rbx
leaq 0x40(%rsp), %r12
movq %r15, 0x18(%rsp)
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x473c
movq 0x28(%r13), %rdi
movq %rdi, 0x38(%rsp)
callq 0xd4e2
movq %rax, %rbp
movq %rbx, 0x40(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x473c
movq %rbp, 0x60(%rsp)
movq %r14, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rsi
leaq 0x10(%rsp), %rdx
callq 0xaa30
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0xa25f
callq 0x3230
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0xa26e
callq 0x3230
movq (%r13), %r13
testq %r13, %r13
jne 0xa1f1
movq 0x8(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
jmp 0xa2b8
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0xa2ae
callq 0x3230
jmp 0xa2ae
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0xa2bd
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
leaq 0xb0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9695(%rip), %rsi      # 0x13a8d
leaq 0x9691(%rip), %rdx      # 0x13a90
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x11f4(%rip), %rdx      # 0xb60a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0xa433
callq 0x3230
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x964b(%rip), %rsi      # 0x13a91
leaq 0x9647(%rip), %rdx      # 0x13a94
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x1260(%rip), %rdx      # 0xb6c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0xa481
callq 0x3230
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9604(%rip), %rsi      # 0x13a95
leaq 0x9601(%rip), %rdx      # 0x13a99
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x126a(%rip), %rdx      # 0xb716
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0xa4c6
callq 0x3230
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x95c4(%rip), %rsi      # 0x13a9a
leaq 0x95c0(%rip), %rdx      # 0x13a9d
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x1273(%rip), %rdx      # 0xb764
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0xa50b
callq 0x3230
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9583(%rip), %rsi      # 0x13a9e
leaq 0x957f(%rip), %rdx      # 0x13aa1
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x127e(%rip), %rdx      # 0xb7b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xa550
callq 0x3230
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9542(%rip), %rsi      # 0x13aa2
leaq 0x953e(%rip), %rdx      # 0x13aa5
movq %rsp, %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x128b(%rip), %rdx      # 0xb804
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa592
callq 0x3230
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xa5de
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0xa5de
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0xa5de
movq %rax, %rbx
movq 0x60(%rsp), %rdi
jmp 0xa5de
movq %rax, %rbx
movq 0x80(%rsp), %rdi
jmp 0xa5de
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0xa5e8
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8bb2(%rip), %rsi      # 0x132d1
leaq 0x8bae(%rip), %rdx      # 0x132d4
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x17ec(%rip), %rdx      # 0xbf26
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0xa754
callq 0x3230
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9437(%rip), %rsi      # 0x13b9b
leaq 0x9433(%rip), %rdx      # 0x13b9e
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x1833(%rip), %rdx      # 0xbfb2
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0xa799
callq 0x3230
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x93f6(%rip), %rsi      # 0x13b9f
leaq 0x93f2(%rip), %rdx      # 0x13ba2
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x1926(%rip), %rdx      # 0xc0ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xa7de
callq 0x3230
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x93b5(%rip), %rsi      # 0x13ba3
leaq 0x93b1(%rip), %rdx      # 0x13ba6
movq %rsp, %r14
movq %r14, %rdi
callq 0x47cc
leaq 0x1a0f(%rip), %rdx      # 0xc216
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd41a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa820
callq 0x3230
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xa852
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0xa852
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0xa852
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0xa85c
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, %rdi
callq 0xce14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
movl $0x4, %esi
callq 0xcfa6
movq %rbx, %rdi
callq 0x9e8c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop