LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xbf(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x34a0
movq 0x28(%rsp), %rdx
leaq 0x162b3(%rip), %rsi     # 0x2b21d
leaq 0xc0(%rsp), %rdi
callq 0x3390
jmp 0x14f79
movq 0x20(%rsp), %rdi
leaq 0x476b(%rip), %rdx      # 0x196f0
leaq 0xc0(%rsp), %rsi
callq 0x1e7e0
jmp 0x14f94
leaq 0xc0(%rsp), %rdi
callq 0x31f0
leaq 0xbf(%rsp), %rdi
callq 0x3310
leaq 0x87(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x34a0
movq 0x18(%rsp), %rdx
leaq 0x16b29(%rip), %rsi     # 0x2baf5
leaq 0x88(%rsp), %rdi
callq 0x3390
jmp 0x14fdb
movq 0x20(%rsp), %rdi
leaq 0x47a9(%rip), %rdx      # 0x19790
leaq 0x88(%rsp), %rsi
callq 0x1e7e0
jmp 0x14ff6
leaq 0x88(%rsp), %rdi
callq 0x31f0
leaq 0x87(%rsp), %rdi
callq 0x3310
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x34a0
movq 0x10(%rsp), %rdx
leaq 0x16ace(%rip), %rsi     # 0x2baf9
leaq 0x60(%rsp), %rdi
callq 0x3390
jmp 0x15037
movq 0x20(%rsp), %rdi
leaq 0x49bd(%rip), %rdx      # 0x19a00
leaq 0x60(%rsp), %rsi
callq 0x1e7e0
jmp 0x1504f
leaq 0x60(%rsp), %rdi
callq 0x31f0
leaq 0x5f(%rsp), %rdi
callq 0x3310
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x34a0
movq 0x8(%rsp), %rdx
leaq 0x16a7f(%rip), %rsi     # 0x2bafd
leaq 0x38(%rsp), %rdi
callq 0x3390
jmp 0x1508a
movq 0x20(%rsp), %rdi
leaq 0x4baa(%rip), %rdx      # 0x19c40
leaq 0x38(%rsp), %rsi
callq 0x1e7e0
jmp 0x150a2
leaq 0x38(%rsp), %rdi
callq 0x31f0
leaq 0x37(%rsp), %rdi
callq 0x3310
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x150f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x31f0
leaq 0xbf(%rsp), %rdi
callq 0x3310
jmp 0x151cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x1513e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x31f0
leaq 0x87(%rsp), %rdi
callq 0x3310
jmp 0x151cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x15181
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x31f0
leaq 0x5f(%rsp), %rdi
callq 0x3310
jmp 0x151cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x151c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x31f0
leaq 0x37(%rsp), %rdi
callq 0x3310
movq 0xb0(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x28, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
callq 0x13e50
jmp 0x1792c
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x1e060
movq 0x20(%rsp), %rdi
callq 0x13e80
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x32b0
movq 0x18(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: kram[P]kram/./src/vm/libraries/std/List.h
// Function: List::kr_push(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* kr_push(Value* self, std::vector<Value*> val) {

		if (val.size() == 0) {
			std::cout << "List.Push() expects at least 1 parameter\n";
			exit(0);
		}

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

		for (Value* i : val) {
			list->content.push_back(i);
		}

		return list;
	}

// Assembly:
subq $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, %rax
movq (%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rax, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
callq 0x16fc0
cmpq $0x0, %rax
jne 0x179c3
movq 0x22628(%rip), %rdi     # 0x39fd8
leaq 0x13eba(%rip), %rsi     # 0x2b871
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x8(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x17d20
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x17d50
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x17d80
testb $0x1, %al
jne 0x17a0a
jmp 0x17a3b
leaq 0x20(%rsp), %rdi
callq 0x17dc0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
leaq 0x10(%rsp), %rsi
callq 0x13bd0
leaq 0x20(%rsp), %rdi
callq 0x17dd0
jmp 0x179f5
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, %rax
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
callq 0x16fc0
cmpq $0x0, %rax
je 0x17a8e
movq 0x2255d(%rip), %rdi     # 0x39fd8
leaq 0x13e19(%rip), %rsi     # 0x2b89b
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x16fc0
cmpq $0x0, %rax
jne 0x17ac6
movq 0x22525(%rip), %rdi     # 0x39fd8
leaq 0x13e01(%rip), %rsi     # 0x2b8bb
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x134e0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x13c40
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: kram[P]kram/./src/vm/libraries/std/List.h
// Function: List::kr_at(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* kr_at(Value* self, std::vector<Value*> val) {

		if (val.size() == 0) {
			std::cout << "List.At() expects exactly 1 parameter\n";
			exit(0);
		}

		if (val[0]->type != Type::NUMBER) {
			std::cout << "List.At() expects parameter 1 to be of type NUMBER\n";
			exit(0);
		}

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

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

		if (at < 0 || at >= list->content.size()) {
			std::cout << "List.At() out of bounds\n";
			exit(0);
		}

		return list->content.at(at);
	}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rax, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
callq 0x16fc0
cmpq $0x0, %rax
jne 0x17b45
movq 0x224a6(%rip), %rdi     # 0x39fd8
leaq 0x13dbb(%rip), %rsi     # 0x2b8f4
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x16fe0
movq (%rax), %rax
cmpl $0x2, 0x8(%rax)
je 0x17b76
movq 0x22475(%rip), %rdi     # 0x39fd8
leaq 0x13db1(%rip), %rsi     # 0x2b91b
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x16fe0
movq (%rax), %rdi
callq 0x1ea10
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x18(%rsp), %xmm0
ja 0x17bf2
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
callq 0x16fc0
movsd (%rsp), %xmm0
movq %rax, %xmm1
movaps 0x1381f(%rip), %xmm2    # 0x2b3f0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x13823(%rip), %xmm2    # 0x2b400
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x17c0c
movq 0x223df(%rip), %rdi     # 0x39fd8
leaq 0x13d4f(%rip), %rsi     # 0x2b94f
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x137fd(%rip), %xmm2    # 0x2b420
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
andq %rcx, %rax
orq %rax, %rsi
callq 0x17e20
movq (%rax), %rax
addq $0x38, %rsp
retq
nop
// File: kram[P]kram/./src/vm/libraries/std/List.h
// Function: List::kr_size(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* kr_size(Value* self, std::vector<Value*> val) {

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

		List* list = static_cast<List*>(self);
		
		return new Value(Type::NUMBER, list->content.size());
	}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rax
movq 0x18(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
callq 0x16fc0
cmpq $0x0, %rax
je 0x17c90
movq 0x2235b(%rip), %rdi     # 0x39fd8
leaq 0x13d2e(%rip), %rsi     # 0x2b9b2
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x10, %edi
callq 0x32e0
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
callq 0x16fc0
movq 0x10(%rsp), %rdi
movq %rax, %xmm0
movaps 0x13723(%rip), %xmm1    # 0x2b3f0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x13727(%rip), %xmm1    # 0x2b400
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movl $0x2, %esi
callq 0x1dee0
jmp 0x17cf4
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x32b0
movq 0x28(%rsp), %rdi
callq 0x3490
// File: kram[P]kram/./src/vm/libraries/IO/io.h
// Function: IO::println(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* println(Value* self, std::vector<Value*> val) {
		
		for (auto i : val) {
			(*kram_output_stream) << i->print();
		}

		(*kram_output_stream) << "\n";

		return new Value();
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x17d20
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x17d50
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x17d80
testb $0x1, %al
jne 0x18166
jmp 0x181de
leaq 0x58(%rsp), %rdi
callq 0x17dc0
movq (%rax), %rax
movq %rax, 0x48(%rsp)
leaq 0x22131(%rip), %rax     # 0x3a2b0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
xorl %edx, %edx
callq 0x1e430
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x18380
jmp 0x181ae
leaq 0x28(%rsp), %rdi
callq 0x31f0
leaq 0x58(%rsp), %rdi
callq 0x17dd0
jmp 0x18151
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x31f0
jmp 0x1822f
leaq 0x220cb(%rip), %rax     # 0x3a2b0
movq (%rax), %rdi
leaq 0x13672(%rip), %rsi     # 0x2b861
callq 0x18350
movl $0x10, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
callq 0x1de00
jmp 0x1820f
movq (%rsp), %rax
addq $0x78, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x32b0
movq 0x20(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rax, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
callq 0x16fc0
cmpq $0x2, %rax
je 0x1840e
movq 0x18(%rsp), %rdi
callq 0x16fc0
movq %rax, %rsi
movq 0x21be9(%rip), %rdi     # 0x39fd8
callq 0x30a0
movq 0x21bdd(%rip), %rdi     # 0x39fd8
leaq 0x135fe(%rip), %rsi     # 0x2ba00
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x16fe0
movq (%rax), %rax
cmpl $0x2, 0x8(%rax)
je 0x18440
movq 0x21bab(%rip), %rdi     # 0x39fd8
leaq 0x135fd(%rip), %rsi     # 0x2ba31
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x16fe0
movq (%rax), %rdi
callq 0x1ea10
movq 0x18(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
movl $0x1, %esi
callq 0x16fe0
movq (%rax), %rdi
callq 0x1ea10
movaps %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x10, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movsd 0x30(%rsp), %xmm0
movl $0x2, %esi
callq 0x1dee0
jmp 0x184ad
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x32b0
movq 0x28(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: kram[P]kram/./src/vm/libraries/std/String.h
// Function: String::length(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* length(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;

		return new Value(Type::NUMBER, length);
	}

// Assembly:
subq $0x88, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rax, 0x80(%rsp)
movq %rdi, 0x78(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x16fe0
movq (%rax), %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1e9e0
movq 0x10(%rsp), %rdi
callq 0x3130
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3150
movq %rax, %rcx
movq 0x18(%rsp), %rax
leaq 0x1(%rax,%rcx), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x18c50
movq %rax, 0x20(%rsp)
jmp 0x1886c
movq 0x20(%rsp), %rax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
decl %eax
movl %eax, 0x3c(%rsp)
movl $0x10, %edi
callq 0x32e0
movq %rax, (%rsp)
jmp 0x1888f
movq (%rsp), %rdi
cvtsi2sdl 0x3c(%rsp), %xmm0
movl $0x2, %esi
callq 0x1dee0
jmp 0x188a5
leaq 0x58(%rsp), %rdi
callq 0x31f0
movq (%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x188e2
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x32b0
leaq 0x58(%rsp), %rdi
callq 0x31f0
movq 0x30(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: kram[P]kram/./src/vm/libraries/std/../../../third_party/utf8/utf8/checked.h
// Function: std::iterator_traits<char*>::difference_type utf8::distance<char*>(char*, char*)
typename std::iterator_traits<octet_iterator>::difference_type
    distance (octet_iterator first, octet_iterator last)
    {
        typename std::iterator_traits<octet_iterator>::difference_type dist;
        for (dist = 0; first < last; ++dist)
            utf8::next(first, last);
        return dist;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x18c8f
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x18ca0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x18c66
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x48, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x40(%rdi)
callq 0x14f00
jmp 0x19734
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x1e060
movq 0x20(%rsp), %rdi
callq 0x14f30
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x32b0
movq 0x18(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kram[P]kram/./src/vm/libraries/std/Map.h
// Function: Map::set(Value*, std::vector<Value*, std::allocator<Value*>>)
static Value* set(Value* self, std::vector<Value*> val) {
		Map* map = static_cast<Map*>(self);

		if (val.size() != 2) {
			std::cout << "Map.Set() expects exacly two parameters\n";
			exit(0);
		}

		if (val[0]->type != Type::STRING) {
			std::cout << "Map.Set() expects first parameter to be of type String\n";
			exit(0);
		}

		map->content.insert( {{ val[0]->getString(), val[1] }} );

		return val[1];
	}

// Assembly:
subq $0xe8, %rsp
movq %rsi, 0x50(%rsp)
movq %rdi, %rax
movq 0x50(%rsp), %rdi
movq %rdi, 0x58(%rsp)
movq %rax, 0xe0(%rsp)
movq %rdi, 0xd8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0xd0(%rsp)
callq 0x16fc0
cmpq $0x2, %rax
je 0x197ee
movq 0x207fd(%rip), %rdi     # 0x39fd8
leaq 0x1231f(%rip), %rsi     # 0x2bb01
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x58(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x16fe0
movq (%rax), %rax
cmpl $0x1, 0x8(%rax)
je 0x1981f
movq 0x207cc(%rip), %rdi     # 0x39fd8
leaq 0x12317(%rip), %rsi     # 0x2bb2a
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x58(%rsp), %rdi
movq 0xd0(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x48(%rsp)
movb $0x1, 0x63(%rsp)
leaq 0x98(%rsp), %rax
movq %rax, 0x90(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x16fe0
movq (%rax), %rsi
leaq 0x70(%rsp), %rdi
callq 0x1e9e0
jmp 0x19862
movq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x16fe0
movq %rax, %rdx
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x19dd0
jmp 0x19888
movq 0x48(%rsp), %rdi
movb $0x0, 0x63(%rsp)
leaq 0x98(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq $0x1, 0xc8(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
callq 0x15440
jmp 0x198c5
leaq 0x98(%rsp), %rax
movq %rax, 0x38(%rsp)
addq $0x28, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x30(%rsp)
callq 0x154c0
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x40(%rsp)
jne 0x198db
leaq 0x70(%rsp), %rdi
callq 0x31f0
movq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x16fe0
movq (%rax), %rax
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x1999d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x19993
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x98(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x28, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x18(%rsp)
callq 0x154c0
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0x1996a
jmp 0x19993
leaq 0x70(%rsp), %rdi
callq 0x31f0
testb $0x1, 0x63(%rsp)
jne 0x199a6
jmp 0x199ec
movq 0x90(%rsp), %rax
leaq 0x98(%rsp), %rcx
cmpq %rax, %rcx
movq %rax, 0x10(%rsp)
je 0x199ea
movq 0x10(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x8(%rsp)
callq 0x154c0
movq 0x8(%rsp), %rax
leaq 0x98(%rsp), %rcx
cmpq %rcx, %rax
movq %rax, 0x10(%rsp)
jne 0x199c0
jmp 0x199ec
jmp 0x199ee
movq 0x68(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: 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:
subq $0x108, %rsp            # imm = 0x108
movq %rsi, 0x48(%rsp)
movq %rdi, %rax
movq 0x48(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movq %rax, 0x100(%rsp)
movq %rdi, 0xf8(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x58(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x16fe0
movq (%rax), %rsi
leaq 0xc8(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x1e9e0
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x153e0
movq %rax, 0x68(%rsp)
jmp 0x19a7e
movq 0x68(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
addq $0x10, %rdi
callq 0x15410
movq %rax, 0xb0(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x16810
movb %al, 0x47(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x31f0
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0x19ad7
jmp 0x19b9b
movq 0x204fa(%rip), %rdi     # 0x39fd8
leaq 0x1207d(%rip), %rsi     # 0x2bb62
callq 0x32d0
movq 0x50(%rsp), %rdi
movq %rax, 0x28(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x16fe0
movq (%rax), %rsi
leaq 0x90(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x1e9e0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x32a0
movq %rax, 0x38(%rsp)
jmp 0x19b28
movq 0x38(%rsp), %rdi
leaq 0x12047(%rip), %rsi     # 0x2bb7b
callq 0x32d0
jmp 0x19b3b
leaq 0x90(%rsp), %rdi
callq 0x31f0
xorl %edi, %edi
callq 0x3330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x31f0
jmp 0x19c24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x31f0
jmp 0x19c24
movq 0x50(%rsp), %rdi
movq 0xf0(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x16fe0
movq (%rax), %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1e9e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x19e10
movq %rax, 0x20(%rsp)
jmp 0x19be2
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x31f0
movq 0x8(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x31f0
movq 0xc0(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rax
movq 0x18(%rsp), %rdi
movq %rax, 0x88(%rsp)
movq %rdi, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x16fe0
movq (%rax), %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1e9e0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x153e0
movq %rax, 0x30(%rsp)
jmp 0x19cb0
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
addq $0x10, %rdi
callq 0x15410
movq %rax, 0x38(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x16810
movb %al, 0x17(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x31f0
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x19cf4
jmp 0x19d5e
movl $0x10, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0x3, %esi
xorps %xmm0, %xmm0
callq 0x1dee0
jmp 0x19d18
movq 0x8(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x19dad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x31f0
jmp 0x19dbd
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x32b0
jmp 0x19dbd
movl $0x10, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movl $0x3, %esi
movsd 0x116a9(%rip), %xmm0    # 0x2b428
callq 0x1dee0
jmp 0x19d86
movq (%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x19dad
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x32b0
jmp 0x19dbd
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x10, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
xorl %esi, %esi
callq 0x1de20
jmp 0x1d611
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x20(%rax)
movl $0x0, 0x30(%rsp)
cmpl $0xff, 0x30(%rsp)
jge 0x1d6b7
movl $0x10, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
cvtsi2sdl 0x30(%rsp), %xmm0
movl $0x2, %esi
callq 0x1dee0
jmp 0x1d65c
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdx
movslq 0x30(%rsp), %rcx
movq %rdx, 0x28(%rax,%rcx,8)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x1d627
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x32b0
jmp 0x1d75d
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x32b0
jmp 0x1d75d
movl $0x10, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl $0x3, %esi
xorps %xmm0, %xmm0
callq 0x1dee0
jmp 0x1d6db
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x820(%rax)
movl $0x10, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0x3, %esi
movsd 0xdd1a(%rip), %xmm0     # 0x2b428
callq 0x1dee0
jmp 0x1d715
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x828(%rax)
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x32b0
jmp 0x1d75d
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x32b0
movq 0x38(%rsp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x18(%rax)
je 0x1d95c
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x1d8e0
jmp 0x1d973
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rdx
callq 0x1d8e0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x1da30
testb $0x1, %al
jne 0x1d9ad
jmp 0x1d9d1
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x16830
movq (%rsp), %rcx
movq %rcx, (%rax)
jmp 0x1da2a
movq 0x8(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x1da12
movq 0x1c5f5(%rip), %rdi     # 0x39fd8
leaq 0xe25e(%rip), %rsi      # 0x2bc48
callq 0x32d0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x32a0
movq %rax, %rdi
leaq 0xde5b(%rip), %rsi      # 0x2b861
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1d980
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
callq 0x1da30
testb $0x1, %al
jne 0x1da98
jmp 0x1dab4
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x16830
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1db0d
movq 0x8(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x1daf5
movq 0x1c512(%rip), %rdi     # 0x39fd8
leaq 0xe17b(%rip), %rsi      # 0x2bc48
callq 0x32d0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x32a0
movq %rax, %rdi
leaq 0xdd78(%rip), %rsi      # 0x2b861
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x1da70
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: kram[P]kram/./src/vm/environment.cpp
// Function: Environment::push()
Environment* Environment::push() {
	Environment* env = new Environment();
	env->parent = this;

	if (this->is_root) {
		env->root = this;
	} else {
		env->root = this->root;
	}

	return env;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x20, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x1d8a0
jmp 0x1dbaf
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movq %rax, 0x8(%rcx)
testb $0x1, 0x18(%rax)
je 0x1dbf7
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1dc09
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x32b0
jmp 0x1dc13
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x18(%rax)
je 0x1dc62
movq 0x1c398(%rip), %rdi     # 0x39fd8
leaq 0xe010(%rip), %rsi      # 0x2bc57
callq 0x32d0
movq %rax, %rdi
leaq 0xdc0b(%rip), %rsi      # 0x2b861
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x18, %rsp
retq
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x1dce0
cmpq $0x1, %rax
jne 0x1dca2
movb $0x1, 0x27(%rsp)
jmp 0x1dccd
movq 0x8(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x1dcb4
movb $0x0, 0x27(%rsp)
jmp 0x1dccd
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x1dc70
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %eax
movq %rax, 0x20(%rsp)
subq $0x7, %rax
ja 0x1ded2
movq 0x20(%rsp), %rax
leaq 0xde2c(%rip), %rcx      # 0x2bc88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x1ded2
movl $0x20, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
callq 0x33a0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1ded2
movl $0x38, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x31a0
movq 0x8(%rsp), %rdi
callq 0x1eb80
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1ded2
jmp 0x1ded2
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: kram[P]kram/./src/vm/value.cpp
// Function: Value::Value(Type, double)
Value::Value(Type t, double val) {
	type = t;
	data.number = val;

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

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x1df28
jmp 0x1df1a
movl 0xc(%rsp), %eax
addl $-0x2, %eax
subl $0x1, %eax
ja 0x1df38
jmp 0x1df28
movq (%rsp), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x1df52
movq 0x1c099(%rip), %rdi     # 0x39fd8
leaq 0xddde(%rip), %rsi      # 0x2bd24
callq 0x32d0
xorl %edi, %edi
callq 0x3330
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x4c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x28(%rsp)
subl $0x6, %eax
ja 0x1e035
movq 0x28(%rsp), %rax
leaq 0xdcff(%rip), %rcx      # 0x2bca8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x20, %edi
callq 0x32e0
movq 0x18(%rsp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x3140
jmp 0x1dfd3
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x1e04f
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x32b0
jmp 0x1e054
movl $0x38, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x31a0
movq 0x8(%rsp), %rdi
callq 0x1eb80
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1e04f
jmp 0x1e04f
movq 0x1bf9c(%rip), %rdi     # 0x39fd8
leaq 0xdd20(%rip), %rsi      # 0x2bd63
callq 0x32d0
xorl %edi, %edi
callq 0x3330
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x3490
nop
// File: kram[P]kram/./src/vm/value.cpp
// Function: Value::set_type(Type)
void Value::set_type(Type type) {
	this->type = type;

	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;

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x2c(%rsp), %eax
movq %rax, 0x20(%rsp)
subq $0x7, %rax
ja 0x1e113
movq 0x20(%rsp), %rax
leaq 0xdc27(%rip), %rcx      # 0x2bcc4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x1e12d
movl $0x20, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
callq 0x33a0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1e12d
movl $0x38, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x31a0
movq 0x8(%rsp), %rdi
callq 0x1eb80
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1e12d
jmp 0x1e12d
movq 0x1bebe(%rip), %rdi     # 0x39fd8
leaq 0xdc86(%rip), %rsi      # 0x2bda7
callq 0x32d0
xorl %edi, %edi
callq 0x3330
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kram[P]kram/./src/vm/value.cpp
// Function: Value::clone()
Value* Value::clone() {

	Value* val = new Value();
	val->type = this->type;

	switch (val->type) {
		case Type::NUMBER:
		case Type::BOOL:
			val->data.number = this->data.number;
			break;

		case Type::STRING:
			val->data.strval = new std::string(*this->data.strval);
			break;

		case Type::REFERENCE:
		case Type::FUNCTION:
		case Type::CLASS:
			delete val;
			return this;
			break;

		default:
			std::cout << "Unable to clone value\n";
			exit(0);
			break;
	}

	return val;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x10, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
callq 0x1de00
jmp 0x1ea4f
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movl 0x8(%rax), %ecx
movq 0x40(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x40(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
subl $0x1, %eax
je 0x1ead3
jmp 0x1ea7c
movl 0x1c(%rsp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x1eabc
jmp 0x1ea8a
movl 0x1c(%rsp), %eax
addl $-0x4, %eax
subl $0x3, %eax
jb 0x1eb20
jmp 0x1eb46
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x32b0
jmp 0x1eb74
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x1eb60
movl $0x20, %edi
callq 0x32e0
movq %rax, %rdi
movq 0x20(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rsi
callq 0x3140
jmp 0x1eaf7
movq 0x10(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1eb60
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x32b0
jmp 0x1eb74
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1eb3a
movq 0x8(%rsp), %rdi
callq 0x32b0
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x1eb6a
movq 0x1b48b(%rip), %rdi     # 0x39fd8
leaq 0xd36a(%rip), %rsi      # 0x2bebe
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x3490
nop
// File: kram[P]kram/./src/parser/parser.cpp
// Function: Parser::advance()
void Parser::advance() {
	if (this->has_advanced) {
		this->index++;
	} else {
		this->has_advanced = true;
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
testb $0x1, 0x20(%rax)
je 0x21245
movq -0x10(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x2124e
movq -0x10(%rsp), %rax
movb $0x1, 0x20(%rax)
retq
nop
// File: kram[P]kram/./src/parser/parser.cpp
// Function: Parser::symbol(lexer::Token*, ON)
Instruction* Parser::symbol(lexer::Token* tok, ON on) {
	switch (tok->type) {

		// Keywords have yet another switch, go there.
		case lexer::Type::KEYWORD: return this->keyword(tok); break;

		// Operators also have another switch, go there.
		case lexer::Type::OPERATOR: return this->oper(tok); break;

		// Literals
		case lexer::Type::NUMBER: return this->number(tok, on); break;
		case lexer::Type::STRING: return this->string(tok, on); break;
		case lexer::Type::NAME: return this->name(tok, on); break;
		case lexer::Type::BOOL: return this->boolean(tok, on); break;

		case lexer::Type::T_EOL:
		case lexer::Type::T_EOF:
			return this->ignore();
			break;

		// Just a bit of silencing
		default: break;
	}

	std::cout << "Unknown symbol: " << tok->print() << "\n";
	exit(0);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x20(%rsp)
subq $0x11, %rax
ja 0x21351
movq 0x20(%rsp), %rax
leaq 0xac4a(%rip), %rcx      # 0x2bed8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x22b90
movq %rax, 0x70(%rsp)
jmp 0x213d1
movq 0x18(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x22cf0
movq %rax, 0x70(%rsp)
jmp 0x213d1
movq 0x18(%rsp), %rdi
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %edx
callq 0x22df0
movq %rax, 0x70(%rsp)
jmp 0x213d1
movq 0x18(%rsp), %rdi
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %edx
callq 0x22e90
movq %rax, 0x70(%rsp)
jmp 0x213d1
movq 0x18(%rsp), %rdi
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %edx
callq 0x22f30
movq %rax, 0x70(%rsp)
jmp 0x213d1
movq 0x18(%rsp), %rdi
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %edx
callq 0x23020
movq %rax, 0x70(%rsp)
jmp 0x213d1
movq 0x18(%rsp), %rdi
callq 0x230c0
movq %rax, 0x70(%rsp)
jmp 0x213d1
jmp 0x21353
movq 0x18c7e(%rip), %rdi     # 0x39fd8
leaq 0xac4d(%rip), %rsi      # 0x2bfae
callq 0x32d0
movq %rax, (%rsp)
movq 0x60(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd9e0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x32a0
movq %rax, 0x10(%rsp)
jmp 0x21393
movq 0x10(%rsp), %rdi
leaq 0xa4c2(%rip), %rsi      # 0x2b861
callq 0x32d0
jmp 0x213a6
leaq 0x38(%rsp), %rdi
callq 0x31f0
xorl %edi, %edi
callq 0x3330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x31f0
jmp 0x213db
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: kram[P]kram/./src/parser/parser.cpp
// Function: Parser::push_class(Instruction*)
Instruction* Parser::push_class(Instruction* prev) {
	Instruction* ins = new Instruction(Ins::PUSH_CLASS);
	ins->left = std::vector<Instruction*>{ prev };
	ins->right = std::vector<Instruction*>{ this->symbol_next(ON::DEFAULT) };

	return this->lookahead(ins, ON::PUSH_CLASS);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x80, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movl $0x7, %esi
callq 0x26dd0
jmp 0x21645
movq 0x28(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x70(%rsp), %rax
movq %rax, 0x78(%rsp)
movq $0x1, 0x80(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x16cc0
movq 0x18(%rsp), %rcx
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
leaq 0x88(%rsp), %rdi
callq 0x26e70
jmp 0x216a5
movq 0xb0(%rsp), %rdi
addq $0x38, %rdi
leaq 0x88(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x26e30
movq 0x8(%rsp), %rdi
callq 0x5560
leaq 0x6f(%rsp), %rdi
callq 0x7010
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x22b50
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x1, 0x48(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x16cc0
movq 0x10(%rsp), %rcx
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x26e70
jmp 0x21725
movq 0xb0(%rsp), %rdi
addq $0x50, %rdi
leaq 0x50(%rsp), %rsi
callq 0x26e30
leaq 0x50(%rsp), %rdi
callq 0x5560
leaq 0x37(%rsp), %rdi
callq 0x7010
movq 0x20(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movl $0x3, %edx
callq 0x213f0
addq $0xc8, %rsp
retq
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
callq 0x32b0
jmp 0x217cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x6f(%rsp), %rdi
callq 0x7010
jmp 0x217cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x7010
movq 0xa8(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: kram[P]kram/./src/parser/parser.cpp
// Function: Parser::assign(Instruction*)
Instruction* Parser::assign(Instruction* prev) {
	Instruction* ins = new Instruction(Ins::ASSIGN);

	if (prev->instruction != Ins::NAME) {
		std::cout << ":= expects previous instruction to be of type NAME";
		exit(0);
	}

	// Get name from previous OP
	ins->name = prev->name;
	ins->right = this->read_until_eol();

	return ins;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x80, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
xorl %esi, %esi
callq 0x26dd0
jmp 0x21d26
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpl $0x3, (%rax)
je 0x21d6e
movq 0x18297(%rip), %rdi     # 0x39fd8
leaq 0xa31c(%rip), %rsi      # 0x2c064
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x32b0
jmp 0x21dbb
movq 0x48(%rsp), %rsi
addq $0x8, %rsi
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0x3040
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x20c30
movq 0x40(%rsp), %rdi
addq $0x50, %rdi
leaq 0x18(%rsp), %rsi
callq 0x26e30
leaq 0x18(%rsp), %rdi
callq 0x5560
movq 0x40(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: kram[P]kram/./src/parser/parser.cpp
// Function: Parser::set(Instruction*)
Instruction* Parser::set(Instruction* prev) {
	Instruction* ins = new Instruction(Ins::SET);

	if (prev->instruction != Ins::NAME) {
		std::cout << "= expects previous instruction to be of type NAME";
		exit(0);
	}

	// Get name from previous OP
	ins->name = prev->name;
	ins->right = this->read_until_eol();

	return ins;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x80, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl $0x1, %esi
callq 0x26dd0
jmp 0x221b9
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpl $0x3, (%rax)
je 0x22201
movq 0x17e04(%rip), %rdi     # 0x39fd8
leaq 0x9e8a(%rip), %rsi      # 0x2c065
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x32b0
jmp 0x2224e
movq 0x48(%rsp), %rsi
addq $0x8, %rsi
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0x3040
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x20c30
movq 0x40(%rsp), %rdi
addq $0x50, %rdi
leaq 0x18(%rsp), %rsi
callq 0x26e30
leaq 0x18(%rsp), %rdi
callq 0x5560
movq 0x40(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)