LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc99a
leaq 0x9b25(%rip), %rcx      # 0x12454
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x7bd2
jmp 0x8c40
jmp 0x86cc
jmp 0x7fa0
jmp 0x8aa8
movq 0x28(%rsi), %rax
retq
jmp 0x7dac
jmp 0x8898
jmp 0x7cc0
jmp 0x8794
jmp 0x851e
jmp 0xc99a
jmp 0x89a6
jmp 0x8ffc
jmp 0x8e5e
jmp 0x8d86
pushq %rax
movq 0x12640(%rip), %rdi     # 0x1afd0
leaq 0x9dc9(%rip), %rsi      # 0x12760
callq 0x3250
movl $0x1, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xccd0
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0xce42
leaq 0x23d0(%rip), %rax      # 0xadda
movq %rax, (%rbx)
leaq 0x38(%r15), %rsi
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x450e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x9d4c
addq $0x10, %r12
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8a3c
callq 0x3230
addq $0x50, %r15
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x450e
movq %r12, %rdi
movq %r13, %rsi
callq 0xaf8c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8a67
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 0x8a8d
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
jne 0x8a9a
jmp 0x8a9f
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xccd0
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 0xce42
movq %rbp, 0x10(%rbx)
movq 0x50(%r15), %r13
movq %r15, (%rsp)
movq 0x58(%r15), %r15
cmpq %r15, %r13
je 0x8b9a
leaq 0x8(%rsp), %r12
movq (%r13), %r14
cmpl $0x0, (%r14)
jne 0x8bef
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 0x891c
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9a64
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8b91
callq 0x3230
addq $0x8, %r13
cmpq %r15, %r13
jne 0x8b33
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 0x78da
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x8bdd
callq 0x3230
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x123da(%rip), %rdi     # 0x1afd0
leaq 0x9ad0(%rip), %rsi      # 0x126cd
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
jne 0x8c32
jmp 0x8c37
movq %rax, %r14
movq %rbx, %rdi
jmp 0x8c32
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8c37
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xccd0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
movl $0x4, %esi
callq 0xce42
movq %rbx, %rdi
callq 0x9dd4
movq 0x50(%r15), %r13
movq 0x58(%r15), %rbp
cmpq %r13, %rbp
je 0x8d3c
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 0x891c
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x8cf1
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x8cfc
movq %r15, %rdi
movq %r12, %rdx
callq 0xc6a8
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x8cc7
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x9fe4
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x9f94
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8d2e
callq 0x3230
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8d3c
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 0x8d6f
callq 0x3230
jmp 0x8d6f
jmp 0x8d6c
movq %rax, %r14
movq %rbx, %rdi
jmp 0x8d78
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8d7d
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7ab4
movq %rax, %rbx
cmpl $0x6, 0x8(%rax)
jne 0x8e94
movq %rbx, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa0a2
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 0x8f66
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0xced6
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8ef6
callq 0x3230
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8f05
callq 0x3230
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x8f14
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 0x8f3a
callq 0x3230
jmp 0x8f3a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8f4e
callq 0x3230
jmp 0x8f4e
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x8f5d
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8fd3
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq (%r12), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x891c
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8fbf
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x8fca
movq %rbx, %rdi
movq %r15, %rdx
callq 0xc6a8
addq $0x8, %r12
cmpq %r13, %r12
jne 0x8f98
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 0x8ff4
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7ab4
movq 0x8(%rbx), %rcx
movq -0x8(%rcx), %r14
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0xd34a
addq $0x50, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x450e
leaq 0x18(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x8f66
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0xced6
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9573
callq 0x3230
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9581
callq 0x3230
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9594
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 0x95b8
callq 0x3230
jmp 0x95b8
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x95cb
callq 0x3230
jmp 0x95cb
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x95de
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa87c
testq %rax, %rax
jne 0x9adc
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 0xa978
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x9ad0
callq 0x3230
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x114ed(%rip), %rdi     # 0x1afd0
leaq 0x8cae(%rip), %rsi      # 0x12798
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0x8ca3(%rip), %rsi      # 0x127a4
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x9b22
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa87c
testq %rax, %rax
je 0x9b7f
movq %r15, %rdi
movq %r14, %rsi
callq 0xaca2
movq (%rax), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rbx), %eax
jne 0x9bb3
movq %r15, %rdi
movq %r14, %rsi
callq 0xaca2
movq %rbx, (%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1144a(%rip), %rdi     # 0x1afd0
leaq 0x8c50(%rip), %rsi      # 0x127dd
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0x8c49(%rip), %rsi      # 0x127ed
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq 0x11416(%rip), %r12     # 0x1afd0
leaq 0x8803(%rip), %rsi      # 0x123c4
movl $0x2b, %edx
movq %r12, %rdi
callq 0x32a0
movq %r15, %rdi
movq %r14, %rsi
callq 0xaca2
movq (%rax), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x1, %edx
callq 0xd094
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x32a0
movq %rax, %r14
leaq 0x87e9(%rip), %rsi      # 0x123f0
movl $0x4, %edx
movq %rax, %rdi
callq 0x32a0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd094
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0x8cb4(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
leaq 0x8(%rsp), %rdi
callq 0x3120
leaq 0x28(%rsp), %rdi
callq 0x3120
jmp 0x9bac
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c7d
callq 0x3230
jmp 0x9c7d
jmp 0x9c7a
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c90
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa87c
testq %rax, %rax
je 0x9cc9
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaca2
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x11300(%rip), %rdi     # 0x1afd0
leaq 0x8b3f(%rip), %rsi      # 0x12816
callq 0x3250
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3220
leaq 0x8c05(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaf8c
movq $0x0, 0x40(%rbx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x9d9f
xorl %edx, %edx
movq (%rax), %rsi
cmpl $0xb, (%rsi)
jne 0x9da7
movq 0x58(%rsi), %rdi
subq 0x50(%rsi), %rdi
je 0x9d8f
cmpq $0x9, %rdi
jb 0x9d96
jmp 0x9db7
incq %rdx
movq %rdx, 0x40(%rbx)
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x9d75
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x11222(%rip), %rdi     # 0x1afd0
leaq 0x8ac4(%rip), %rsi      # 0x12879
jmp 0x9dc5
movq 0x11212(%rip), %rdi     # 0x1afd0
leaq 0x8af4(%rip), %rsi      # 0x128b9
callq 0x3250
movl $0x1, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x84db(%rip), %rsi      # 0x122d1
leaq 0x84d7(%rip), %rdx      # 0x122d4
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x1254(%rip), %rdx      # 0xb068
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x9e31
callq 0x3230
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8ab4(%rip), %rsi      # 0x128f5
leaq 0x8ab1(%rip), %rdx      # 0x128f9
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x127a(%rip), %rdx      # 0xb0d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x9e76
callq 0x3230
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8a74(%rip), %rsi      # 0x128fa
leaq 0x8a70(%rip), %rdx      # 0x128fd
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x12b7(%rip), %rdx      # 0xb158
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x9ebb
callq 0x3230
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8832(%rip), %rsi      # 0x126fd
leaq 0x882d(%rip), %rdx      # 0x126ff
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x12be(%rip), %rdx      # 0xb1a4
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x9f00
callq 0x3230
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x89ee(%rip), %rsi      # 0x128fe
leaq 0x89eb(%rip), %rdx      # 0x12902
movq %rsp, %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x1351(%rip), %rdx      # 0xb27a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x9f42
callq 0x3230
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x9f81
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x9f81
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0x9f81
movq %rax, %rbx
movq 0x60(%rsp), %rdi
jmp 0x9f81
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x9f8b
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xccd0
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 0xa1c3
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 0xd372
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 0xa978
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0xa1a7
callq 0x3230
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0xa1b6
callq 0x3230
movq (%r13), %r13
testq %r13, %r13
jne 0xa139
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 0xa200
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0xa1f6
callq 0x3230
jmp 0xa1f6
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0xa205
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8739(%rip), %rsi      # 0x12a79
leaq 0x8735(%rip), %rdx      # 0x12a7c
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x11f6(%rip), %rdx      # 0xb554
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0xa37b
callq 0x3230
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x86ef(%rip), %rsi      # 0x12a7d
leaq 0x86eb(%rip), %rdx      # 0x12a80
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x1262(%rip), %rdx      # 0xb60e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0xa3c9
callq 0x3230
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x86a8(%rip), %rsi      # 0x12a81
leaq 0x86a5(%rip), %rdx      # 0x12a85
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x126c(%rip), %rdx      # 0xb660
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0xa40e
callq 0x3230
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8668(%rip), %rsi      # 0x12a86
leaq 0x8664(%rip), %rdx      # 0x12a89
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x1275(%rip), %rdx      # 0xb6ae
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0xa453
callq 0x3230
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8627(%rip), %rsi      # 0x12a8a
leaq 0x8623(%rip), %rdx      # 0x12a8d
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x1280(%rip), %rdx      # 0xb6fe
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xa498
callq 0x3230
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x85e6(%rip), %rsi      # 0x12a8e
leaq 0x85e2(%rip), %rdx      # 0x12a91
movq %rsp, %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x128d(%rip), %rdx      # 0xb74e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa4da
callq 0x3230
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xa526
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0xa526
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0xa526
movq %rax, %rbx
movq 0x60(%rsp), %rdi
jmp 0xa526
movq %rax, %rbx
movq 0x80(%rsp), %rdi
jmp 0xa526
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0xa530
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7c6a(%rip), %rsi      # 0x122d1
leaq 0x7c66(%rip), %rdx      # 0x122d4
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x1762(%rip), %rdx      # 0xbde4
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0xa69c
callq 0x3230
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x84db(%rip), %rsi      # 0x12b87
leaq 0x84d7(%rip), %rdx      # 0x12b8a
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x17a9(%rip), %rdx      # 0xbe70
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0xa6e1
callq 0x3230
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x849a(%rip), %rsi      # 0x12b8b
leaq 0x8496(%rip), %rdx      # 0x12b8e
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x1898(%rip), %rdx      # 0xbfa4
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xa726
callq 0x3230
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8459(%rip), %rsi      # 0x12b8f
leaq 0x8455(%rip), %rdx      # 0x12b92
movq %rsp, %r14
movq %r14, %rdi
callq 0x47d2
leaq 0x1981(%rip), %rdx      # 0xc0d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2aa
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa768
callq 0x3230
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xa79a
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0xa79a
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0xa79a
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0xa7a4
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xccd0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
movl $0x4, %esi
callq 0xce42
movq %rbx, %rdi
callq 0x9dd4
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb17a
movq 0x18(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
je 0xb18a
movq -0x8(%rcx), %rax
addq $-0x8, %rcx
movq %rcx, 0x18(%rdi)
popq %rcx
retq
movq 0xfe4f(%rip), %rdi      # 0x1afd0
leaq 0x77a5(%rip), %rsi      # 0x1292d
jmp 0xb198
movq 0xfe3f(%rip), %rdi      # 0x1afd0
leaq 0x77b5(%rip), %rsi      # 0x1294d
callq 0x3250
xorl %edi, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb5c2
movq 0x8(%rax), %rcx
cmpl $0x2, 0x8(%rcx)
jne 0xb5e1
movq (%rax), %rdi
callq 0xd36c
movsd %xmm0, (%rsp)
movq (%rbx), %rax
movq 0x8(%rax), %rdi
callq 0xd36c
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
movq %rax, %rdi
movl $0x2, %esi
movsd (%rsp), %xmm0
callq 0xcd5a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
sarq $0x3, %rsi
movq 0xfa03(%rip), %rbx      # 0x1afd0
movq %rbx, %rdi
callq 0x3070
leaq 0x74b6(%rip), %rsi      # 0x12a92
movq %rbx, %rdi
jmp 0xb5ef
movq 0xf9e8(%rip), %rdi      # 0x1afd0
leaq 0x74d4(%rip), %rsi      # 0x12ac3
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/libraries/std/String.h
// Function: String::at(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* at(Value* self, std::vector<Value*> val) {
		std::string full_string = val[0]->getString();
		char* c_str = (char*) full_string.c_str();

		char* str_iterator = c_str;
		char* str_end = c_str + strlen(c_str) + 1;

		int length = utf8::distance(str_iterator, str_end);

		// Do not include NUL
		--length;

		int get_char_at = val[1]->getNumber();

		if (get_char_at >= length) {
			std::cout << "String::At() expects a number smaller than the lenght of the string\n";
			exit(0);
		}

		for (int i = 0; i < get_char_at; i++) {
			utf8::next(str_iterator, str_end);
		}

		auto res = utf8::next(str_iterator, str_end);
		return new Value(Type::STRING, utf8chr(res));

		std::cout << "String::At() failed\n";
		exit(0);

		return new Value(Type::NUL);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq (%rsi), %rax
movq (%rax), %rsi
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0xd34a
movq (%rbx), %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
callq 0x3110
leaq (%r15,%rax), %rbx
incq %rbx
movq %r15, 0x10(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %rbx, %r15
jae 0xb96f
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xba74
incl %ebp
cmpq %rbx, 0x10(%rsp)
jb 0xb95b
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0xd36c
cvttsd2si %xmm0, %r15d
cmpl %r15d, %ebp
jle 0xba11
testl %r15d, %r15d
jle 0xb9a3
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xba74
decl %r15d
jne 0xb993
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xba74
movl %eax, %ebp
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
movl %ebp, %esi
callq 0x7af0
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0xcd8a
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb9f0
callq 0x3230
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xba03
callq 0x3230
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xf5b8(%rip), %rdi      # 0x1afd0
leaq 0x7123(%rip), %rsi      # 0x12b42
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %r14
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xba46
callq 0x3230
jmp 0xba46
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
jmp 0xba59
jmp 0xba56
jmp 0xba56
jmp 0xba56
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xba6c
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/libraries/std/../../../third_party/utf8/utf8/core.h
// Function: utf8::internal::utf_error utf8::internal::get_sequence_3<char*>(char*&, char*, unsigned int&)
utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_point)
    {
        if (it == end)
            return NOT_ENOUGH_ROOM;
            
        code_point = utf8::internal::mask8(*it);

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point += (*it) & 0x3f;

        return UTF8_OK;
    }

// Assembly:
movq (%rdi), %r8
movl $0x1, %eax
cmpq %rsi, %r8
je 0xbcec
movzbl (%r8), %r9d
movl %r9d, (%rdx)
leaq 0x1(%r8), %rcx
movq %rcx, (%rdi)
cmpq %rsi, %rcx
je 0xbcec
movzbl (%rcx), %ecx
movl %ecx, %r10d
andb $-0x40, %r10b
negb %r10b
jno 0xbced
shll $0xc, %r9d
movzwl %r9w, %r9d
andl $0x3f, %ecx
shll $0x6, %ecx
orl %r9d, %ecx
movl %ecx, (%rdx)
addq $0x2, %r8
movq %r8, (%rdi)
cmpq %rsi, %r8
je 0xbcec
movzbl (%r8), %esi
movl %esi, %eax
andb $-0x40, %al
negb %al
movl $0x3, %eax
jno 0xbcec
andl $0x3f, %esi
orl %esi, %ecx
movl %ecx, (%rdx)
xorl %eax, %eax
retq
movl $0x3, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/libraries/std/../../../third_party/utf8/utf8/core.h
// Function: utf8::internal::utf_error utf8::internal::get_sequence_4<char*>(char*&, char*, unsigned int&)
utf_error get_sequence_4(octet_iterator& it, octet_iterator end, uint32_t& code_point)
    {
        if (it == end)
           return NOT_ENOUGH_ROOM;

        code_point = utf8::internal::mask8(*it);

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point += (utf8::internal::mask8(*it) << 6) & 0xfff;

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point += (*it) & 0x3f;

        return UTF8_OK;
    }

// Assembly:
movq (%rdi), %rcx
movl $0x1, %eax
cmpq %rsi, %rcx
je 0xbd8e
movzbl (%rcx), %r9d
movl %r9d, (%rdx)
leaq 0x1(%rcx), %r8
movq %r8, (%rdi)
cmpq %rsi, %r8
je 0xbd8e
movzbl (%r8), %r8d
movl %r8d, %r10d
andb $-0x40, %r10b
negb %r10b
jno 0xbd8f
andl $0x7, %r9d
shll $0x12, %r9d
andl $0x3f, %r8d
shll $0xc, %r8d
orl %r9d, %r8d
movl %r8d, (%rdx)
leaq 0x2(%rcx), %r9
movq %r9, (%rdi)
cmpq %rsi, %r9
je 0xbd8e
movzbl (%r9), %r9d
movl %r9d, %r10d
andb $-0x40, %r10b
negb %r10b
jno 0xbd8f
andl $0x3f, %r9d
shll $0x6, %r9d
orl %r8d, %r9d
movl %r9d, (%rdx)
addq $0x3, %rcx
movq %rcx, (%rdi)
cmpq %rsi, %rcx
je 0xbd8e
movzbl (%rcx), %ecx
movl %ecx, %eax
andb $-0x40, %al
negb %al
movl $0x3, %eax
jno 0xbd8e
andl $0x3f, %ecx
orl %ecx, %r9d
movl %r9d, (%rdx)
xorl %eax, %eax
retq
movl $0x3, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/libraries/std/Map.h
// Function: Map::constructor(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* constructor(Value* self, std::vector<Value*> val) {
		Map* instance = new Map();
		instance->set_type(Type::REFERENCE);
		instance->init();

		return instance;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x48, %edi
callq 0x3260
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movq $0x0, 0x40(%rax)
movq %rax, %rdi
callq 0xccd0
movq %rbx, %rax
addq $0x40, %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)
movq %rbx, %rdi
movl $0x4, %esi
callq 0xce42
movq %rbx, %rdi
callq 0xa648
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
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/libraries/std/Map.h
// Function: Map::get(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* get(Value* self, std::vector<Value*> val) {
		Map* map = static_cast<Map*>(self);

		if (map->content.find(val[0]->getString()) == map->content.end()) {
			std::cout << "Map.Get() unknown key, \"" << val[0]->getString() << "\"\n";
			exit(0);
		}

		return map->content.at(val[0]->getString());
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %r14
movq (%rsi), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xd34a
movq %r14, %rdi
movq %r15, %rsi
callq 0xa87c
movq %rax, %r15
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0xbfee
callq 0x3230
testq %r15, %r15
je 0xc038
movq (%rbx), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xd34a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa87c
testq %rax, %rax
je 0xc095
movq 0x28(%rax), %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc029
callq 0x3230
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xef91(%rip), %r14      # 0x1afd0
leaq 0x6bae(%rip), %rsi      # 0x12bf4
movl $0x18, %edx
movq %r14, %rdi
callq 0x32a0
movq (%rbx), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xd34a
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0x6b91(%rip), %rsi      # 0x12c0d
movq %rax, %rdi
callq 0x3250
leaq 0x8(%rsp), %rdi
callq 0x3120
xorl %edi, %edi
callq 0x32c0
leaq 0x6b74(%rip), %rdi      # 0x12c10
callq 0x32e0
jmp 0xc0b6
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xc0c3
jmp 0xc0c8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc0c8
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/libraries/std/Map.h
// Function: Map::has(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* has(Value* self, std::vector<Value*> val) {
		Map* map = static_cast<Map*>(self);

		if (map->content.find(val[0]->getString()) == map->content.end()) {
			return new Value(Type::BOOL, 0);
		}

		return new Value(Type::BOOL, 1);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x10, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xd34a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa87c
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc112
callq 0x3230
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
testq %r14, %r14
je 0xc13b
movsd 0x63c4(%rip), %xmm0     # 0x124f0
movq %rbx, %rdi
movl $0x3, %esi
callq 0xcd5a
jmp 0xc14b
xorps %xmm0, %xmm0
movq %rbx, %rdi
movl $0x3, %esi
callq 0xcd5a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0xc158
movq %rax, %r14
movq %rbx, %rdi
jmp 0xc171
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc176
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/vm_values.cpp
// Function: VM::init_default_values()
void VM::init_default_values() {
	this->value_null = new Value(Type::NUL);

	for (int i = 0; i < 255; i++) {
		this->value_number[i] = new Value(Type::NUMBER, i);
	}

	this->value_bool[0] = new Value(Type::BOOL, false);
	this->value_bool[1] = new Value(Type::BOOL, true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x10, %edi
callq 0x3260
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0xccd8
movq %r14, 0x20(%rbx)
xorl %r15d, %r15d
movl $0x10, %edi
callq 0x3260
movq %rax, %r14
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movq %rax, %rdi
movl $0x2, %esi
callq 0xcd5a
movq %r14, 0x28(%rbx,%r15,8)
incq %r15
cmpq $0xff, %r15
jne 0xc8fa
movl $0x10, %edi
callq 0x3260
movq %rax, %r14
xorpd %xmm0, %xmm0
movq %rax, %rdi
movl $0x3, %esi
callq 0xcd5a
movq %r14, 0x820(%rbx)
movl $0x10, %edi
callq 0x3260
movq %rax, %r14
movsd 0x5b89(%rip), %xmm0     # 0x124f0
movq %rax, %rdi
movl $0x3, %esi
callq 0xcd5a
movq %r14, 0x828(%rbx)
popq %rbx
popq %r14
popq %r15
retq
jmp 0xc987
jmp 0xc987
jmp 0xc987
movq %rax, %rbx
movq %r14, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/environment.cpp
// Function: Environment::set_root(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Value*)
void Environment::set_root(std::string name, Value* val) {
	if (this->is_root) {
		this->set(name, val);
	} else {
		this->root->set(name, val);
	}
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
cmpb $0x0, 0x18(%rdi)
jne 0xca84
movq 0x10(%rdi), %rdi
movq (%rdi), %rdi
callq 0xaca2
movq %rbx, (%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/environment.cpp
// Function: Environment::update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Value*)
void Environment::update(const std::string &name, Value* val) {

	if (this->has(name)) {
		(*this->names)[name] = val;
		return;
	}

	if (this->is_root) {
		std::cout << "Unknown name: " << name << "\n";
		exit(0);
	}

	this->parent->update(name, val);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
callq 0xcc96
testq %rax, %rax
jne 0xcac0
cmpb $0x1, 0x18(%r15)
je 0xcad4
movq 0x8(%r15), %r15
movq (%r15), %rdi
movq %rbx, %rsi
jmp 0xcaa3
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xaca2
movq %r14, (%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0xe4f5(%rip), %rdi      # 0x1afd0
leaq 0x61f6(%rip), %rsi      # 0x12cd8
callq 0x3250
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3220
leaq 0x5dfa(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/environment.cpp
// Function: Environment::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Value* Environment::get(const std::string &name) {

	if (this->has(name)) {
		return (*this->names)[name];
	}

	if (this->is_root) {
		std::cout << "Unknown name: " << name << "\n";
		exit(0);
	}

	return this->parent->get(name);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xcc96
testq %rax, %rax
jne 0xcb44
cmpb $0x1, 0x18(%r14)
je 0xcb5a
movq 0x8(%r14), %r14
movq (%r14), %rdi
movq %rbx, %rsi
jmp 0xcb27
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xaca2
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xe46f(%rip), %rdi      # 0x1afd0
leaq 0x6170(%rip), %rsi      # 0x12cd8
callq 0x3250
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3220
leaq 0x5d74(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/environment.cpp
// Function: Environment::pop()
Environment* Environment::pop() {
	if (this->is_root) {
		std::cout << "Environment: You can not pop the root level!" << "\n";
		exit(0);
	}

	return this->parent;
}

// Assembly:
cmpb $0x1, 0x18(%rdi)
je 0xcc27
movq 0x8(%rdi), %rax
retq
pushq %rax
movq 0xe3a1(%rip), %rdi      # 0x1afd0
leaq 0x60b1(%rip), %rsi      # 0x12ce7
callq 0x3250
leaq 0x5cb1(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/environment.cpp
// Function: Environment::exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Environment::exists(const std::string &name) {

	if (this->names->count(name) == 1) {
		return true;
	}

	if (this->is_root) {
		return false;
	}

	return this->parent->exists(name);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xcc96
movb $0x1, %bpl
testq %rax, %rax
jne 0xcc8f
jmp 0xcc82
movq 0x8(%r14), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xcc96
testq %rax, %rax
jne 0xcc8b
movb 0x18(%r14), %bpl
testb %bpl, %bpl
je 0xcc6e
xorb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/value.cpp
// Function: Value::Value(Type)
Value::Value(Type t) {
	type = t;

	switch (type) {
		case Type::NUL:
		case Type::BOOL:
		case Type::NUMBER:
			data.number = 0;
			break;

		case Type::STRING:
		case Type::NAME:
			data.strval = new std::string();
			break;

		case Type::REFERENCE:
			data.methods = new Methods();
			break;

		case Type::FUNCTION:
		case Type::CLASS:
			break;
	}
}

// Assembly:
movl %esi, 0x8(%rdi)
cmpl $0x7, %esi
ja 0xcd58
pushq %rbx
movq %rdi, %rbx
movl $0xd, %eax
btl %esi, %eax
jb 0xcd17
movl $0x82, %eax
btl %esi, %eax
jae 0xcd20
movl $0x20, %edi
callq 0x3260
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
jmp 0xcd54
movq $0x0, (%rbx)
jmp 0xcd57
cmpl $0x4, %esi
jne 0xcd57
movl $0x38, %edi
callq 0x3260
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
leaq 0x30(%rax), %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movq %rax, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/value.cpp
// Function: Value::Value(Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Value::Value(Type t, std::string val) {
	type = t;

	switch (type) {
		case Type::STRING:
		case Type::NAME:
			data.strval = new std::string(val);
			break;

		case Type::REFERENCE:
			data.methods = new Methods();
			break;

		case Type::FUNCTION:
		case Type::CLASS:
			break;

		default:
			std::cout << "Value::Value(Type, std::string) should not be used with this type!\n";
			exit(0);
			break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, 0x8(%rdi)
decl %esi
cmpl $0x6, %esi
ja 0xce15
movq %rdi, %rbx
leaq 0x5f75(%rip), %rax      # 0x12d18
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rdx, %r15
movl $0x20, %edi
callq 0x3260
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x473c
jmp 0xce0c
movl $0x38, %edi
callq 0x3260
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
addq $0x30, %rax
movq %rax, (%r14)
movq $0x1, 0x8(%r14)
movups %xmm0, 0x10(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0xe1b4(%rip), %rdi      # 0x1afd0
leaq 0x5ff4(%rip), %rsi      # 0x12e17
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x33c0