LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb230
movq 0x18(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
je 0xb240
movq -0x8(%rcx), %rax
addq $-0x8, %rcx
movq %rcx, 0x18(%rdi)
popq %rcx
retq
movq 0x10d99(%rip), %rdi     # 0x1bfd0
leaq 0x8703(%rip), %rsi      # 0x13941
jmp 0xb24e
movq 0x10d89(%rip), %rdi     # 0x1bfd0
leaq 0x8713(%rip), %rsi      # 0x13961
callq 0x3250
xorl %edi, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb678
movq 0x8(%rax), %rcx
cmpl $0x2, 0x8(%rcx)
jne 0xb697
movq (%rax), %rdi
callq 0xd4dc
movsd %xmm0, (%rsp)
movq (%rbx), %rax
movq 0x8(%rax), %rdi
callq 0xd4dc
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
movq %rax, %rdi
movl $0x2, %esi
movsd (%rsp), %xmm0
callq 0xceac
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
sarq $0x3, %rsi
movq 0x1094d(%rip), %rbx     # 0x1bfd0
movq %rbx, %rdi
callq 0x3070
leaq 0x8414(%rip), %rsi      # 0x13aa6
movq %rbx, %rdi
jmp 0xb6a5
movq 0x10932(%rip), %rdi     # 0x1bfd0
leaq 0x8432(%rip), %rsi      # 0x13ad7
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_O1/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 0xd4ba
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 0xba25
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xbb2a
incl %ebp
cmpq %rbx, 0x10(%rsp)
jb 0xba11
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0xd4dc
cvttsd2si %xmm0, %r15d
cmpl %r15d, %ebp
jle 0xbac7
testl %r15d, %r15d
jle 0xba59
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbb2a
decl %r15d
jne 0xba49
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xbb2a
movl %eax, %ebp
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
movl %ebp, %esi
callq 0x7b44
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0xcee0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbaa6
callq 0x3230
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbab9
callq 0x3230
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10502(%rip), %rdi     # 0x1bfd0
leaq 0x8081(%rip), %rsi      # 0x13b56
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %r14
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbafc
callq 0x3230
jmp 0xbafc
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
jmp 0xbb0f
jmp 0xbb0c
jmp 0xbb0c
jmp 0xbb0c
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb22
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/vm/libraries/std/../../../third_party/utf8/utf8/core.h
// Function: utf8::internal::utf_error utf8::internal::get_sequence_2<char*>(char*&, char*, unsigned int&)
utf_error get_sequence_2(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 << 6) & 0x7ff) + ((*it) & 0x3f);

        return UTF8_OK;
    }

// Assembly:
movq (%rdi), %rcx
cmpq %rsi, %rcx
je 0xbd3f
movzbl (%rcx), %r8d
movl %r8d, (%rdx)
incq %rcx
movq %rcx, (%rdi)
cmpq %rsi, %rcx
je 0xbd45
movb (%rcx), %al
andb $-0x40, %al
xorl %esi, %esi
negb %al
setno %sil
leal (%rsi,%rsi,2), %eax
jmp 0xbd4a
movl $0x1, %eax
retq
movl $0x1, %eax
testl %eax, %eax
je 0xbd4f
retq
andl $0x1f, %r8d
shll $0x6, %r8d
movzbl (%rcx), %eax
andl $0x3f, %eax
orl %r8d, %eax
movl %eax, (%rdx)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
cmpq %rsi, %rcx
je 0xbd93
movzbl (%rcx), %r8d
movl %r8d, (%rdx)
leaq 0x1(%rcx), %rax
movq %rax, (%rdi)
cmpq %rsi, %rax
je 0xbd99
movb (%rax), %al
andb $-0x40, %al
xorl %r9d, %r9d
negb %al
setno %r9b
leal (%r9,%r9,2), %eax
jmp 0xbd9e
movl $0x1, %eax
retq
movl $0x1, %eax
testl %eax, %eax
je 0xbda3
retq
shll $0xc, %r8d
movzwl %r8w, %r9d
movzbl 0x1(%rcx), %r8d
andl $0x3f, %r8d
shll $0x6, %r8d
orl %r9d, %r8d
movl %r8d, (%rdx)
addq $0x2, %rcx
movq %rcx, (%rdi)
cmpq %rsi, %rcx
je 0xbddf
movb (%rcx), %sil
andb $-0x40, %sil
xorl %edi, %edi
negb %sil
setno %dil
leal (%rdi,%rdi,2), %esi
jmp 0xbde4
movl $0x1, %esi
testl %esi, %esi
cmovnel %esi, %eax
jne 0xbda2
movzbl (%rcx), %eax
andl $0x3f, %eax
orl %eax, %r8d
movl %r8d, (%rdx)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq %rsi, %rcx
je 0xbe28
movzbl (%rcx), %r8d
movl %r8d, (%rdx)
leaq 0x1(%rcx), %rax
movq %rax, (%rdi)
cmpq %rsi, %rax
je 0xbe2e
movb (%rax), %al
andb $-0x40, %al
xorl %r9d, %r9d
negb %al
setno %r9b
leal (%r9,%r9,2), %eax
jmp 0xbe33
movl $0x1, %eax
retq
movl $0x1, %eax
testl %eax, %eax
je 0xbe38
retq
andl $0x7, %r8d
shll $0x12, %r8d
movzbl 0x1(%rcx), %r9d
andl $0x3f, %r9d
shll $0xc, %r9d
orl %r8d, %r9d
movl %r9d, (%rdx)
leaq 0x2(%rcx), %r8
movq %r8, (%rdi)
cmpq %rsi, %r8
je 0xbe76
movb (%r8), %r8b
andb $-0x40, %r8b
xorl %r10d, %r10d
negb %r8b
setno %r10b
leal (%r10,%r10,2), %r8d
jmp 0xbe7c
movl $0x1, %r8d
testl %r8d, %r8d
cmovnel %r8d, %eax
jne 0xbe37
movzbl 0x2(%rcx), %r8d
andl $0x3f, %r8d
shll $0x6, %r8d
orl %r9d, %r8d
movl %r8d, (%rdx)
addq $0x3, %rcx
movq %rcx, (%rdi)
cmpq %rsi, %rcx
je 0xbeb9
movb (%rcx), %sil
andb $-0x40, %sil
xorl %edi, %edi
negb %sil
setno %dil
leal (%rdi,%rdi,2), %esi
jmp 0xbebe
movl $0x1, %esi
testl %esi, %esi
cmovnel %esi, %eax
jne 0xbe37
movzbl (%rcx), %eax
andl $0x3f, %eax
orl %eax, %r8d
movl %r8d, (%rdx)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xce14
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 0xcfa6
movq %rbx, %rdi
callq 0xa700
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_O1/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 0xd4ba
movq %r14, %rdi
movq %r15, %rsi
callq 0xa934
movq %rax, %r15
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0xc134
callq 0x3230
testq %r15, %r15
je 0xc17e
movq (%rbx), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xd4ba
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa934
testq %rax, %rax
je 0xc1db
movq 0x28(%rax), %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc16f
callq 0x3230
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xfe4b(%rip), %r14      # 0x1bfd0
leaq 0x7a7c(%rip), %rsi      # 0x13c08
movl $0x18, %edx
movq %r14, %rdi
callq 0x32a0
movq (%rbx), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xd4ba
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0x7a5f(%rip), %rsi      # 0x13c21
movq %rax, %rdi
callq 0x3250
leaq 0x8(%rsp), %rdi
callq 0x3120
xorl %edi, %edi
callq 0x32c0
leaq 0x7a42(%rip), %rdi      # 0x13c24
callq 0x32e0
jmp 0xc1fc
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xc209
jmp 0xc20e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc20e
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/vm/libraries/std/Map.h
// Function: Map::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 0xd4ba
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa934
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc258
callq 0x3230
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
testq %r14, %r14
je 0xc281
movsd 0x727e(%rip), %xmm0     # 0x134f0
movq %rbx, %rdi
movl $0x3, %esi
callq 0xceac
jmp 0xc291
xorps %xmm0, %xmm0
movq %rbx, %rdi
movl $0x3, %esi
callq 0xceac
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0xc29e
movq %rax, %r14
movq %rbx, %rdi
jmp 0xc2b7
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc2bc
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xce1c
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 0xceac
movq %r14, 0x28(%rbx,%r15,8)
incq %r15
cmpq $0xff, %r15
jne 0xca4e
movl $0x10, %edi
callq 0x3260
movq %rax, %r14
xorpd %xmm0, %xmm0
movq %rax, %rdi
movl $0x3, %esi
callq 0xceac
movq %r14, 0x820(%rbx)
movl $0x10, %edi
callq 0x3260
movq %rax, %r14
movsd 0x6a35(%rip), %xmm0     # 0x134f0
movq %rax, %rdi
movl $0x3, %esi
callq 0xceac
movq %r14, 0x828(%rbx)
popq %rbx
popq %r14
popq %r15
retq
jmp 0xcadb
jmp 0xcadb
jmp 0xcadb
movq %rax, %rbx
movq %r14, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcbd8
movq 0x10(%rdi), %rdi
movq (%rdi), %rdi
callq 0xad5c
movq %rbx, (%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 (%r15), %rdi
movq %rbx, %rsi
callq 0xcdd8
testq %rax, %rax
jne 0xcc11
cmpb $0x1, 0x18(%r15)
je 0xcc25
movq 0x8(%r15), %r15
jmp 0xcbf4
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xad5c
movq %r14, (%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0xf3a4(%rip), %rdi      # 0x1bfd0
leaq 0x70b5(%rip), %rsi      # 0x13ce8
callq 0x3250
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3220
leaq 0x6cbd(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/vm/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 (%r14), %rdi
movq %rbx, %rsi
callq 0xcdd8
testq %rax, %rax
jne 0xcc93
cmpb $0x1, 0x18(%r14)
je 0xcca9
movq 0x8(%r14), %r14
jmp 0xcc76
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xad5c
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xf320(%rip), %rdi      # 0x1bfd0
leaq 0x7031(%rip), %rsi      # 0x13ce8
callq 0x3250
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3220
leaq 0x6c39(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/vm/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x20, %edi
callq 0x3260
movq %rax, %rbx
movb $0x0, 0x18(%rax)
movl $0x38, %edi
callq 0x3260
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
cmpb $0x0, 0x18(%r14)
jne 0xcd4a
movq 0x10(%r14), %r14
movq %r14, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcd77
movq 0x8(%rdi), %rax
retq
pushq %rax
movq 0xf251(%rip), %rdi      # 0x1bfd0
leaq 0x6f71(%rip), %rsi      # 0x13cf7
callq 0x3250
leaq 0x6b75(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/vm/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xcdd8
testq %rax, %rax
jne 0xcdc9
cmpb $0x0, 0x18(%r14)
jne 0xcdcd
movq 0x8(%r14), %r14
jmp 0xcdac
movb $0x1, %al
jmp 0xcdcf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xceab
pushq %rbx
movq %rdi, %rbx
movl $0xd, %eax
btl %esi, %eax
jb 0xce5f
movl $0x82, %eax
btl %esi, %eax
jae 0xce68
movl $0x20, %edi
callq 0x3260
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
jmp 0xcea7
movq $0x0, (%rbx)
jmp 0xceaa
cmpl $0x4, %esi
jne 0xceaa
movl $0x38, %edi
callq 0x3260
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movq $0x0, 0x30(%rax)
leaq 0x30(%rax), %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %esi, 0x8(%rdi)
movsd %xmm0, (%rdi)
leal -0x2(%rsi), %eax
cmpl $0x2, %eax
jb 0xcebf
testl %esi, %esi
jne 0xcec4
movsd %xmm0, (%rdi)
retq
pushq %rax
movq 0xf104(%rip), %rdi      # 0x1bfd0
leaq 0x6f15(%rip), %rsi      # 0x13de8
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcf79
movq %rdi, %rbx
leaq 0x6e2b(%rip), %rax      # 0x13d28
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 0xcf70
movl $0x38, %edi
callq 0x3260
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movq $0x0, 0x30(%rax)
addq $0x30, %rax
movq %rax, (%r14)
movq $0x1, 0x8(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0xf050(%rip), %rdi      # 0x1bfd0
leaq 0x6ea0(%rip), %rsi      # 0x13e27
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movl %esi, 0x8(%rdi)
cmpl $0x7, %esi
ja 0xd02b
movq %rdi, %rbx
movl %esi, %eax
leaq 0x6d89(%rip), %rcx      # 0x13d44
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0xd029
movl $0x20, %edi
callq 0x3260
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
jmp 0xd026
movl $0x38, %edi
callq 0x3260
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movq $0x0, 0x30(%rax)
leaq 0x30(%rax), %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movq %rax, (%rbx)
popq %rbx
retq
movq 0xef9e(%rip), %rdi      # 0x1bfd0
leaq 0x6e32(%rip), %rsi      # 0x13e6b
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/vm/value.cpp
// Function: Value::exec_method(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Value*, std::allocator<Value*>>)
Value* Value::exec_method(std::string name, std::vector<Value*> val) {

	if (this->type != Type::REFERENCE && this->type != Type::FUNCTION && this->type != Type::CLASS) {
		std::cout << "Can not execute method '" << name << "': Parent is not of type REFERENCE, CLASS, or FUNCTION\n";
		std::cout << this->print() << "\n";	
		exit(0);
	}

	if (this->type == Type::CLASS) {
		std::cout << "Value::exec_method() Should not be used together with Type::CLASS. This is an error, please report it! :)\n";
		exit(0);
	}

	if (this->type == Type::FUNCTION) {
		return this->data.single_method(this, val);
	}

	if (this->data.methods->find(name) == this->data.methods->end()) {
		std::cout << "UNKNOWN METHOD: " << name << "\n";
		exit(0);
	}

	Method m = this->data.methods->at(name);

	return m(this, val);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leal -0x4(%rax), %ecx
cmpl $0x3, %ecx
jae 0xd103
movq %rdx, %r15
cmpl $0x5, %eax
je 0xd0c6
cmpl $0x6, %eax
je 0xd17d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd594
testq %rax, %rax
je 0xd18d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd594
testq %rax, %rax
je 0xd1c1
movq 0x28(%rax), %r12
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xa09c
movq %rbx, %rdi
movq %r14, %rsi
callq *%r12
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0xd0ea
movq (%rbx), %r12
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xa09c
movq %rbx, %rdi
movq %r14, %rsi
callq *%r12
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xd0f4
callq 0x3230
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xeec6(%rip), %r15      # 0x1bfd0
leaq 0x6d91(%rip), %rsi      # 0x13ea2
movl $0x18, %edx
movq %r15, %rdi
callq 0x32a0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x32a0
leaq 0x6d87(%rip), %rsi      # 0x13ebb
movl $0x37, %edx
movq %rax, %rdi
callq 0x32a0
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd204
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x32a0
leaq 0x679e(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
leaq 0x38(%rsp), %rdi
callq 0x3120
jmp 0xd1ba
movq 0xee4c(%rip), %rdi      # 0x1bfd0
leaq 0x6d68(%rip), %rsi      # 0x13ef3
jmp 0xd1b5
movq 0xee3c(%rip), %rdi      # 0x1bfd0
leaq 0x6dc3(%rip), %rsi      # 0x13f5e
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0x6755(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
leaq 0x6a5c(%rip), %rdi      # 0x13c24
callq 0x32e0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0xd1df
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xd1e9
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xd1e4
jmp 0xd1e9
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
movl $0x0, 0x8(%rax)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
leal -0x4(%rax), %ecx
cmpl $0x3, %ecx
jb 0xd520
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0xd52d
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
jmp 0xd55e
movq %rbx, %rdi
callq 0x3230
movq %r14, %rbx
jmp 0xd55e
cmpl $0x1, %eax
jne 0xd567
movl $0x20, %edi
callq 0x3260
movq %rax, %r15
movq (%r14), %rax
leaq 0x10(%r15), %rcx
movq %rcx, (%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x473c
movq %r15, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xea62(%rip), %rdi      # 0x1bfd0
leaq 0x6a0d(%rip), %rsi      # 0x13f82
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq %r15, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl (%rsi), %eax
cmpq $0x11, %rax
ja 0xe39c
leaq 0x5cbd(%rip), %rcx      # 0x13fa0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x80, %edi
callq 0x3260
movl $0x6, (%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movb $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x68(%rax)
movq %rcx, 0x78(%rax)
movl $0x2, 0x30(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf622
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf6bc
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf5a0
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf45e
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf51e
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf36e
movq 0xdc2d(%rip), %r14      # 0x1bfd0
leaq 0x5d97(%rip), %rsi      # 0x14141
movl $0x10, %edx
movq %r14, %rdi
callq 0x32a0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6ed2
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0x552c(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
movq %rsp, %rdi
callq 0x3120
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe408
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x80, %edi
callq 0x3260
movq %rax, %r14
movl $0x7, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%r14)
xorl %r12d, %r12d
movq %r12, 0x10(%r14)
movb $0x0, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x68(%r14)
movq %r12, 0x78(%r14)
movl $0x2, 0x30(%r14)
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x10(%rsp), %r15
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
movq %r15, %rdi
callq 0x11798
movq 0x38(%r14), %rdi
movaps (%r15), %xmm0
movq 0x10(%r15), %rax
movq %rdi, (%r15)
movups 0x40(%r14), %xmm1
movups %xmm0, 0x38(%r14)
movq %rax, 0x48(%r14)
movups %xmm1, 0x8(%r15)
movq %r12, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
testq %rdi, %rdi
je 0xe619
callq 0x3230
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xe628
callq 0x3230
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf34c
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %r15
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
movq %r15, %rdi
callq 0x11798
movq 0x50(%r14), %rdi
movaps (%r15), %xmm0
movq 0x10(%r15), %rax
movq %rdi, (%r15)
movups 0x58(%r14), %xmm1
movups %xmm0, 0x50(%r14)
movq %rax, 0x60(%r14)
movups %xmm1, 0x8(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0xe68c
callq 0x3230
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xe69b
callq 0x3230
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0xe410
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x80, %edi
callq 0x3260
movq %rax, %rbx
movl $0x0, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rax, 0x78(%rbx)
movl $0x2, 0x30(%rbx)
cmpl $0x3, (%r15)
jne 0xeaab
movq %rbx, %rdi
addq $0x8, %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0x3150
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xdf08
movq 0x50(%rbx), %rdi
movaps (%r15), %xmm0
movq 0x10(%r15), %rax
movq %rdi, (%r15)
movups 0x58(%rbx), %xmm1
movups %xmm0, 0x50(%rbx)
movq %rax, 0x60(%rbx)
movups %xmm1, 0x8(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0xea90
callq 0x3230
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xea9e
callq 0x3230
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xd51e(%rip), %rdi      # 0x1bfd0
leaq 0x573e(%rip), %rsi      # 0x141f7
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::function_parameter_with_default_value(Instruction*)
Instruction* Parser::function_parameter_with_default_value(Instruction* ins) {

	if (ins->instruction != Ins::FUNCTION_PARAMETER) {
		std::cout << "Parameter default value expected Ins::FUNCTION_PARAMETER before =, got:\n";
		ins->print();
		exit(1);
	}

	ins->right = this->read_until(std::vector<lexer::Token>{
		lexer::Token::OPERATOR(")"),
		lexer::Token::OPERATOR(","),
	});

	// Reverse one step because Parser::keyword_fn() is consuming the same tokens
	this->reverse();

	return ins;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
cmpl $0xb, (%rsi)
jne 0xec2b
movq %rdi, %r15
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movw $0x29, (%r12)
movq $0x1, -0x8(%r12)
leaq 0x88(%rsp), %rbx
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x6d74
leaq 0xb0(%rsp), %rbx
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movw $0x2c, (%r13)
movq $0x1, -0x8(%r13)
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x6d74
leaq 0x30(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x2, %edx
callq 0x11680
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %r15, %rsi
callq 0xde4a
movq 0x50(%r14), %rdi
movaps 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq %rdi, 0x10(%rsp)
movups 0x58(%r14), %xmm1
movups %xmm0, 0x50(%r14)
movq %rax, 0x60(%r14)
movups %xmm1, 0x18(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0xebb1
callq 0x3230
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xebc0
callq 0x3230
leaq 0x30(%rsp), %rdi
callq 0x116c2
leaq 0xc8(%rsp), %rbx
xorl %ebp, %ebp
movq 0xb8(%rsp,%rbp), %rdi
leaq (%rbx,%rbp), %rax
cmpq %rdi, %rax
je 0xebea
callq 0x3230
addq $-0x28, %rbp
cmpq $-0x50, %rbp
jne 0xebd4
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0xec03
callq 0x3230
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0xec12
callq 0x3230
decl 0x18(%r15)
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd39e(%rip), %rdi      # 0x1bfd0
leaq 0x5575(%rip), %rsi      # 0x141ae
callq 0x3250
movq %r14, %rdi
xorl %esi, %esi
callq 0x3ee0
movl $0x1, %edi
callq 0x32c0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x116c2
jmp 0xec64
movq %rax, %r14
movq $-0x50, %r15
leaq 0xc8(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rdi, %rbp
je 0xec81
callq 0x3230
addq $-0x28, %rbp
addq $0x28, %r15
jne 0xec73
movb $0x1, %bpl
jmp 0xec95
movq %rax, %r14
xorl %ebp, %ebp
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0xecab
callq 0x3230
jmp 0xecab
movq %rax, %r14
xorl %ebp, %ebp
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0xecba
callq 0x3230
leaq 0x88(%rsp), %r15
cmpq %rbx, %r15
sete %al
orb %al, %bpl
jne 0xecef
addq $-0x10, %rbx
movq -0x10(%rbx), %rdi
cmpq %rdi, %rbx
je 0xecdf
callq 0x3230
leaq -0x28(%rbx), %rax
addq $-0x18, %rbx
cmpq %r15, %rbx
movq %rax, %rbx
jne 0xecd1
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x80, %edi
callq 0x3260
movq %rax, %rbx
movl $0x1, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rax, 0x78(%rbx)
movl $0x2, 0x30(%rbx)
cmpl $0x3, (%r15)
jne 0xedc5
movq %rbx, %rdi
addq $0x8, %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0x3150
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xdf08
movq 0x50(%rbx), %rdi
movaps (%r15), %xmm0
movq 0x10(%r15), %rax
movq %rdi, (%r15)
movups 0x58(%rbx), %xmm1
movups %xmm0, 0x50(%rbx)
movq %rax, 0x60(%rbx)
movups %xmm1, 0x8(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0xedaa
callq 0x3230
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xedb8
callq 0x3230
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xd204(%rip), %rdi      # 0x1bfd0
leaq 0x5425(%rip), %rsi      # 0x141f8
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::oper_list_extraction(Instruction*)
Instruction* Parser::oper_list_extraction(Instruction* prev) {
	Instruction* ins = new Instruction(Ins::LIST_EXTRACT);

	/*if (prev->size() != 1) {
		std::cout << "oper_list_extraction: There can only be one list to extract from\n";
		exit(0);
	}*/

	ins->left = std::vector<Instruction*>{ prev };
	ins->right = this->read_until(std::vector<lexer::Token>{ lexer::Token::OPERATOR("]"), });

	if (ins->right.size() != 1) {
		std::cout << "oper_list_extraction: Only one value can be extracted\n";
		exit(0);
	}

	return ins;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x80, %edi
callq 0x3260
movq %rax, %rbx
movl $0xf, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
xorl %r12d, %r12d
movq %r12, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %r12, 0x78(%rbx)
movl $0x2, 0x30(%rbx)
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x40(%rsp), %r15
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
movq %r15, %rdi
callq 0x11798
movq 0x38(%rbx), %rdi
movaps (%r15), %xmm0
movq 0x10(%r15), %rax
movq %rdi, (%r15)
movups 0x40(%rbx), %xmm1
movups %xmm0, 0x38(%rbx)
movq %rax, 0x48(%rbx)
movups %xmm1, 0x8(%r15)
movq %r12, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
testq %rdi, %rdi
je 0xf0d8
callq 0x3230
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xf0e7
callq 0x3230
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movw $0x5d, (%r15)
movq $0x1, -0x8(%r15)
leaq 0x40(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x6d74
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x11680
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq 0xde4a
movq 0x50(%rbx), %rdi
movaps 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq %rdi, 0x10(%rsp)
movups 0x58(%rbx), %xmm1
movups %xmm0, 0x50(%rbx)
movq %rax, 0x60(%rbx)
movups %xmm1, 0x18(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0xf177
callq 0x3230
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xf186
callq 0x3230
leaq 0x28(%rsp), %rdi
callq 0x116c2
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf1a3
callq 0x3230
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0xf1b2
callq 0x3230
movq 0x58(%rbx), %rax
subq 0x50(%rbx), %rax
cmpq $0x8, %rax
jne 0xf1d2
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xcdf7(%rip), %rdi      # 0x1bfd0
leaq 0x4f85(%rip), %rsi      # 0x14165
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x116c2
jmp 0xf1fe
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf216
callq 0x3230
jmp 0xf216
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0xf225
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::keyword(lexer::Token*)
Instruction* Parser::keyword(lexer::Token* tok) {
	switch (tok->sub) {
		case lexer::Type::KEYWORD_CLASS: return this->keyword_class(); break;
		case lexer::Type::KEYWORD_FN: return this->keyword_fn(); break;
		case lexer::Type::KEYWORD_IF: return this->keyword_if(); break;
		case lexer::Type::KEYWORD_NEW: return this->keyword_new(); break;
		case lexer::Type::KEYWORD_WHILE: return this->keyword_while(); break;
		case lexer::Type::KEYWORD_RETURN: return this->keyword_return(); break;
		default: break;
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl 0x4(%rsi), %eax
addl $-0xa, %eax
cmpl $0x6, %eax
ja 0xf3e9
leaq 0x4c5c(%rip), %rcx      # 0x13fe8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xfdf0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x10eaa
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x100d4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1113c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x10608
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x10a84
movq 0xcbe0(%rip), %r14      # 0x1bfd0
leaq 0x4da5(%rip), %rsi      # 0x1419c
movl $0x11, %edx
movq %r14, %rdi
callq 0x32a0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6ed2
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0x44df(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
movq %rsp, %rdi
callq 0x3120
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf455
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::oper(lexer::Token*)
Instruction* Parser::oper(lexer::Token* tok) {
	switch (tok->sub) {
		case lexer::Type::OPERATOR_SQUARE_PAREN_LEFT: return this->oper_list_creation(); break;
		case lexer::Type::OPERATOR_MINUS:             return this->oper_minus();         break;
		default: break;
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movl 0x4(%rsi), %eax
cmpl $0x22, %eax
je 0xf488
cmpl $0x2e, %eax
jne 0xf4a6
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf79a
callq 0xfa70
movq %r14, %rdi
movq %rax, %rsi
movl $0x2, %edx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xfaf4
movq %rsi, %rbx
movq 0xcb20(%rip), %r14      # 0x1bfd0
leaq 0x4c9b(%rip), %rsi      # 0x14152
movl $0x12, %edx
movq %r14, %rdi
callq 0x32a0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6ed2
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0x441f(%rip), %rsi      # 0x13907
movq %rax, %rdi
callq 0x3250
movq %rsp, %rdi
callq 0x3120
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf515
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::name(lexer::Token*, ON)
Instruction* Parser::name(lexer::Token* tok, ON on) {

	Instruction* ins;

	if (on == ON::FUNCTION_PARAMETER_LIST) {
		ins = new Instruction(Ins::FUNCTION_PARAMETER);
	} else {
		ins = new Instruction(Ins::NAME);
	}
	
	ins->name = tok->value;

	return this->lookahead(ins, on);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $0x4, %edx
sete %r13b
movl $0x80, %edi
callq 0x3260
movq %rax, %r12
leaq 0x8(%rax), %rdi
addq $0x18, %rax
leal 0x3(,%r13,8), %ecx
movl %ecx, (%r12)
movq %rax, 0x8(%r12)
xorl %eax, %eax
movq %rax, 0x10(%r12)
movb $0x0, 0x18(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r12)
movups %xmm0, 0x48(%r12)
movups %xmm0, 0x58(%r12)
movups %xmm0, 0x68(%r12)
movq %rax, 0x78(%r12)
movl $0x2, 0x30(%r12)
addq $0x8, %r15
movq %r15, %rsi
callq 0x3150
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe410
nop