LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rsi, %r14
movq (%rsi), %rax
movq (%rax), %rsi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xc030
movq (%rbx), %r15
movq %r15, (%rsp)
movq %r15, %rdi
callq 0x3110
leaq (%r15,%rax), %rbx
incq %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa749
movq %rax, %r15
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0xc042
decl %r15d
cvttsd2si %xmm0, %eax
cmpl %eax, %r15d
jle 0xa6f8
xorl %ebp, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
movq %rsp, %r14
subl $0x1, %ebp
jb 0xa6a2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa787
jmp 0xa690
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xa787
movl %eax, %ebp
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x6fac
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xbb82
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0x28(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x108d1(%rip), %rdi     # 0x1afd0
leaq 0x7392(%rip), %rsi      # 0x11a98
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3130
jmp 0xa724
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0xa737
jmp 0xa734
jmp 0xa734
jmp 0xa734
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
xorl %r15d, %r15d
cmpq %rbx, %rdi
jae 0xa77a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa787
incq %r15
movq 0x8(%rsp), %rdi
jmp 0xa760
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r8
pushq $0x1
popq %rax
cmpq %rsi, %r8
je 0xa98b
movzbl (%r8), %ecx
movl %ecx, (%rdx)
incq %r8
movq %r8, (%rdi)
cmpq %rsi, %r8
je 0xa98b
movzbl (%r8), %eax
movl %eax, %esi
andb $-0x40, %sil
negb %sil
jno 0xa98c
andl $0x1f, %ecx
shll $0x6, %ecx
andl $0x3f, %eax
orl %ecx, %eax
movl %eax, (%rdx)
xorl %eax, %eax
retq
pushq $0x3
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/libraries/std/../../../third_party/utf8/utf8/core.h
// Function: utf8::internal::utf_error utf8::internal::get_sequence_3<char*>(char*&, char*, unsigned int&)
utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_point)
    {
        if (it == end)
            return NOT_ENOUGH_ROOM;
            
        code_point = utf8::internal::mask8(*it);

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

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

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point += (*it) & 0x3f;

        return UTF8_OK;
    }

// Assembly:
movq (%rdi), %r8
pushq $0x1
popq %rax
cmpq %rsi, %r8
je 0xa9f8
movzbl (%r8), %r10d
movl %r10d, (%rdx)
leaq 0x1(%r8), %rcx
movq %rcx, (%rdi)
cmpq %rsi, %rcx
je 0xa9f8
movzbl (%rcx), %ecx
movl %ecx, %r11d
andb $-0x40, %r11b
pushq $0x3
popq %r9
negb %r11b
jno 0xa9f9
shll $0xc, %r10d
movzwl %r10w, %r10d
andl $0x3f, %ecx
shll $0x6, %ecx
orl %r10d, %ecx
movl %ecx, (%rdx)
addq $0x2, %r8
movq %r8, (%rdi)
cmpq %rsi, %r8
je 0xa9f8
movzbl (%r8), %esi
movl %esi, %eax
andb $-0x40, %al
negb %al
movl %r9d, %eax
jno 0xa9f8
andl $0x3f, %esi
orl %esi, %ecx
movl %ecx, (%rdx)
xorl %eax, %eax
retq
movl %r9d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rax
cmpq %rsi, %rcx
je 0xaa98
movzbl (%rcx), %r10d
movl %r10d, (%rdx)
leaq 0x1(%rcx), %r8
movq %r8, (%rdi)
cmpq %rsi, %r8
je 0xaa98
movzbl (%r8), %r9d
movl %r9d, %r11d
andb $-0x40, %r11b
pushq $0x3
popq %r8
negb %r11b
jno 0xaa99
andl $0x7, %r10d
shll $0x12, %r10d
andl $0x3f, %r9d
shll $0xc, %r9d
orl %r10d, %r9d
movl %r9d, (%rdx)
leaq 0x2(%rcx), %r10
movq %r10, (%rdi)
cmpq %rsi, %r10
je 0xaa98
movzbl (%r10), %r10d
movl %r10d, %r11d
andb $-0x40, %r11b
negb %r11b
jno 0xaa99
andl $0x3f, %r10d
shll $0x6, %r10d
orl %r9d, %r10d
movl %r10d, (%rdx)
addq $0x3, %rcx
movq %rcx, (%rdi)
cmpq %rsi, %rcx
je 0xaa98
movzbl (%rcx), %ecx
movl %ecx, %eax
andb $-0x40, %al
negb %al
movl %r8d, %eax
jno 0xaa98
andl $0x3f, %ecx
orl %ecx, %r10d
movl %r10d, (%rdx)
xorl %eax, %eax
retq
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %r14
movq (%rsi), %rax
movq (%rax), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0xc030
movq %r14, %rdi
movq %r15, %rsi
callq 0x9614
movq %rax, %r15
movq %rsp, %rdi
callq 0x3130
testq %r15, %r15
je 0xacc5
movq (%rbx), %rax
movq (%rax), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xc030
movq %r14, %rdi
movq %rbx, %rsi
callq 0xade6
movq (%rax), %rbx
movq %rsp, %rdi
callq 0x3130
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x10304(%rip), %rdi     # 0x1afd0
leaq 0x6e77(%rip), %rsi      # 0x11b4a
callq 0x3220
movq %rax, %r14
movq (%rbx), %rax
movq (%rax), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xc030
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3200
leaq 0x6e65(%rip), %rsi      # 0x11b63
movq %rax, %rdi
callq 0x3220
movq %rsp, %rdi
callq 0x3130
xorl %edi, %edi
callq 0x3280
jmp 0xad19
jmp 0xad19
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9614
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3130
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
testq %r14, %r14
je 0xad8a
pushq $0x3
popq %rsi
movsd 0x66a8(%rip), %xmm0     # 0x11428
movq %rbx, %rdi
callq 0xbb54
jmp 0xad98
pushq $0x3
popq %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0xbb54
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0xada5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0xadbf
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0xbade
movq %rbx, 0x20(%r14)
xorl %r12d, %r12d
pushq $0x10
popq %r15
pushq $0x2
popq %rbp
movq %r15, %rdi
callq 0x3230
movq %rax, %rbx
cmpq $0xff, %r12
je 0xb78f
cvtsi2sd %r12d, %xmm0
movq %rbx, %rdi
movl %ebp, %esi
callq 0xbb54
movq %rbx, 0x28(%r14,%r12,8)
incq %r12
jmp 0xb762
pushq $0x3
popq %rsi
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0xbb54
movq %rbx, 0x820(%r14)
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
pushq $0x3
popq %rsi
movsd 0x5c6d(%rip), %xmm0     # 0x11428
movq %rax, %rdi
callq 0xbb54
movq %rbx, 0x828(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb7d9
jmp 0xb7d9
jmp 0xb7d9
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb946
testb %al, %al
jne 0xb8fe
cmpb $0x1, 0x18(%r15)
je 0xb912
movq 0x8(%r15), %r15
jmp 0xb8e2
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x9ab0
movq %r14, (%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0xf6b7(%rip), %rdi      # 0x1afd0
leaq 0x6310(%rip), %rsi      # 0x11c30
callq 0x3220
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3200
leaq 0x5f12(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
xorl %edi, %edi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/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 0xb946
testb %al, %al
jne 0xb97e
cmpb $0x1, 0x18(%r14)
je 0xb994
movq 0x8(%r14), %r14
jmp 0xb962
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x9ab0
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xf635(%rip), %rdi      # 0x1afd0
leaq 0x628e(%rip), %rsi      # 0x11c30
callq 0x3220
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3200
leaq 0x5e90(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
xorl %edi, %edi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/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, %rbx
pushq $0x20
popq %rdi
callq 0x3230
movq %rax, %r14
movq %rax, %rdi
callq 0xb878
movq %rbx, 0x8(%r14)
cmpb $0x0, 0x18(%rbx)
jne 0xba04
movq 0x10(%rbx), %rbx
movq %rbx, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x3210
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0xba31
movq 0x8(%rdi), %rax
retq
pushq %rax
movq 0xf597(%rip), %rdi      # 0x1afd0
leaq 0x61ff(%rip), %rsi      # 0x11c3f
callq 0x3220
leaq 0x5dfd(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
xorl %edi, %edi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xba94
cmpq $0x1, %rax
je 0xba84
cmpb $0x0, 0x18(%r14)
jne 0xba84
movq 0x8(%r14), %r14
jmp 0xba66
cmpq $0x1, %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbb52
pushq %rbx
movq %rdi, %rbx
pushq $0xd
popq %rax
btl %esi, %eax
jb 0xbb16
movl $0x82, %eax
btl %esi, %eax
jae 0xbb1c
pushq $0x20
popq %rdi
callq 0x3230
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
jmp 0xbb4e
andq $0x0, (%rbx)
jmp 0xbb51
cmpl $0x4, %esi
jne 0xbb51
pushq $0x38
popq %rdi
callq 0x3230
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
leaq 0x30(%rax), %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movq %rax, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbbfb
movq %rdi, %rbx
leaq 0x60d5(%rip), %rax      # 0x11c70
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rdx, %r15
pushq $0x20
popq %rdi
callq 0x3230
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x32b0
jmp 0xbbf2
pushq $0x38
popq %rdi
callq 0x3230
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
addq $0x30, %rax
movq %rax, (%r14)
movq $0x1, 0x8(%r14)
movups %xmm0, 0x10(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0xf3ce(%rip), %rdi      # 0x1afd0
leaq 0x6122(%rip), %rsi      # 0x11d2b
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
movq %r14, %rdi
callq 0x3210
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbc98
movq %rdi, %rbx
movl %esi, %eax
leaq 0x604f(%rip), %rcx      # 0x11c8c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
andq $0x0, (%rbx)
jmp 0xbc96
pushq $0x20
popq %rdi
callq 0x3230
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
jmp 0xbc93
pushq $0x38
popq %rdi
callq 0x3230
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
leaq 0x30(%rax), %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movq %rax, (%rbx)
popq %rbx
retq
movq 0xf331(%rip), %rdi      # 0x1afd0
leaq 0x60c9(%rip), %rsi      # 0x11d6f
callq 0x3220
xorl %edi, %edi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbd56
movq %rdx, %r15
cmpl $0x5, %eax
je 0xbd20
cmpl $0x6, %eax
je 0xbdbe
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xc0de
testq %rax, %rax
je 0xbdce
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xc1ae
movq (%rax), %r12
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x8ee6
movq %rbx, %rdi
movq %r14, %rsi
callq *%r12
jmp 0xbd3c
movq (%rbx), %r12
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x8ee6
movq %rbx, %rdi
movq %r14, %rsi
callq *%r12
movq %rax, %rbx
movq %r14, %rdi
callq 0x41b6
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xf273(%rip), %r15      # 0x1afd0
leaq 0x6042(%rip), %rsi      # 0x11da6
movq %r15, %rdi
callq 0x3220
movq %rax, %rdi
movq %r14, %rsi
callq 0x3200
leaq 0x6041(%rip), %rsi      # 0x11dbf
movq %rax, %rdi
callq 0x3220
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xbe30
movq %r15, %rdi
movq %r14, %rsi
callq 0x3200
leaq 0x5a9f(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
leaq 0x8(%rsp), %rdi
callq 0x3130
jmp 0xbdfb
movq 0xf20b(%rip), %rdi      # 0x1afd0
leaq 0x602b(%rip), %rsi      # 0x11df7
jmp 0xbdf6
movq 0xf1fb(%rip), %rdi      # 0x1afd0
leaq 0x6086(%rip), %rsi      # 0x11e62
callq 0x3220
movq %rax, %rdi
movq %r14, %rsi
callq 0x3200
leaq 0x5a56(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xbe14
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x41b6
jmp 0xbe28
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/vm/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
pushq $0x10
popq %rdi
callq 0x3230
movq %rax, %rbx
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
leal -0x4(%rax), %ecx
cmpl $0x3, %ecx
jb 0xc07d
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0xc08a
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
jmp 0xc0a8
movq %rbx, %rdi
callq 0x3210
movq %r14, %rbx
jmp 0xc0a8
cmpl $0x1, %eax
jne 0xc0b1
pushq $0x20
popq %rdi
callq 0x3230
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
callq 0x32b0
movq %r15, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xef18(%rip), %rdi      # 0x1afd0
leaq 0x5dc7(%rip), %rsi      # 0x11e86
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
movq %r15, %rdi
callq 0x3210
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0xce2c
leaq 0x50f1(%rip), %rcx      # 0x11ea0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xddde
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xdcea
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xdd84
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xdc90
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xdba0
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xdc36
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xdac4
movq 0xe19d(%rip), %rdi      # 0x1afd0
leaq 0x5183(%rip), %rsi      # 0x11fbd
callq 0x3220
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6518
movq %r14, %rdi
movq %r15, %rsi
callq 0x3200
leaq 0x49e7(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
movq %rsp, %rdi
callq 0x3130
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x80, %edi
callq 0x3230
movq %rax, %r14
movl $0x7, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%r14)
andq $0x0, 0x10(%r14)
movb $0x0, 0x18(%r14)
leaq 0x38(%r14), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
andq $0x0, 0x78(%r14)
movups %xmm0, 0x68(%r14)
movl $0x2, 0x30(%r14)
leaq 0x8(%rsp), %r13
movq %r15, (%r13)
leaq 0x10(%rsp), %r15
pushq $0x1
popq %rbp
leaq 0x7(%rsp), %rcx
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xf808
movq %r12, %rdi
movq %r15, %rsi
callq 0x10148
movq %r15, %rdi
callq 0x42f2
movq %rbx, %rdi
xorl %esi, %esi
callq 0xda9c
movq %rax, (%r13)
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rcx
movq %r15, %rdi
movq %rbp, %rdx
callq 0xf808
leaq 0x50(%r14), %rdi
movq %r15, %rsi
callq 0x10148
movq %r15, %rdi
callq 0x42f2
pushq $0x3
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xce8c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3230
movq %rax, %rbx
andl $0x0, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
andq $0x0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movl $0x2, 0x30(%rbx)
cmpl $0x3, (%r15)
jne 0xd3c5
leaq 0x8(%rbx), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0x3160
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xcaaa
movq %rbx, %rdi
addq $0x50, %rdi
movq %r15, %rsi
callq 0x10148
movq %r15, %rdi
callq 0x42f2
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xdc04(%rip), %rdi      # 0x1afd0
leaq 0x4ca0(%rip), %rsi      # 0x12073
callq 0x3220
xorl %edi, %edi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r15
cmpl $0xb, (%rsi)
jne 0xd4ed
movq %rdi, %r12
leaq 0x47be(%rip), %rsi      # 0x11bc3
leaq 0x48(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x30f0
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x63f2
leaq 0xa8(%rsp), %rbx
leaq 0x3e49(%rip), %rsi      # 0x11282
leaq 0x28(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x30f0
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x63f2
leaq 0x10(%rsp), %rdi
leaq 0x80(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0xd(%rsp), %rcx
callq 0xf720
leaq 0x68(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r12, %rsi
callq 0xca06
leaq 0x50(%r15), %rdi
leaq 0x68(%rsp), %rbx
movq %rbx, %rsi
callq 0x10148
movq %rbx, %rdi
callq 0x42f2
leaq 0x10(%rsp), %rdi
callq 0xf75a
pushq $0x30
popq %rbx
leaq (%rsp,%rbx), %rdi
addq $0x80, %rdi
callq 0x3130
addq $-0x28, %rbx
cmpq $-0x20, %rbx
jne 0xd4a7
leaq 0x28(%rsp), %rdi
callq 0x3130
leaq 0x48(%rsp), %rdi
callq 0x3130
decl 0x18(%r12)
movq %r15, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xdadc(%rip), %rdi      # 0x1afd0
leaq 0x4b2f(%rip), %rsi      # 0x1202a
callq 0x3220
movq %r15, %rdi
xorl %esi, %esi
callq 0x3be8
pushq $0x1
popq %rdi
callq 0x3280
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0xf75a
jmp 0xd524
movq %rax, %r15
pushq $0x30
popq %r12
leaq (%rsp,%r12), %rdi
addq $0x80, %rdi
callq 0x3130
addq $-0x28, %r12
cmpq $-0x20, %r12
jne 0xd528
movb $0x1, %bpl
jmp 0xd54c
movq %rax, %r15
xorl %ebp, %ebp
leaq 0x28(%rsp), %rdi
callq 0x3130
jmp 0xd567
movq %rax, %r15
xorl %ebp, %ebp
jmp 0xd567
movq %rax, %r15
xorl %ebp, %ebp
movq %r14, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3130
cmpq %rbx, %r14
sete %al
orb %bpl, %al
jne 0xd59c
leaq 0x80(%rsp), %r14
leaq -0x28(%rbx), %r12
addq $-0x20, %rbx
movq %rbx, %rdi
callq 0x3130
movq %r12, %rbx
cmpq %r14, %r12
jne 0xd584
movq %r15, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3230
movq %rax, %rbx
movl $0x1, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
andq $0x0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movl $0x2, 0x30(%rbx)
cmpl $0x3, (%r15)
jne 0xd640
leaq 0x8(%rbx), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0x3160
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xcaaa
movq %rbx, %rdi
addq $0x50, %rdi
movq %r15, %rsi
callq 0x10148
movq %r15, %rdi
callq 0x42f2
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xd989(%rip), %rdi      # 0x1afd0
leaq 0x4a26(%rip), %rsi      # 0x12074
callq 0x3220
xorl %edi, %edi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::assign_with_type(Instruction*)
Instruction* Parser::assign_with_type(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;

	// Read the rest of the row
	std::vector<Instruction*> row = this->read_until_eol();

	// Expect exactly one name
	if (row.size() != 1 || row[0]->instruction != Ins::NAME) {
		std::cout << ": needs to be followed by exactly one NAME (aka the type)";
		exit(0);
	}

	std::string type = row[0]->name;

	if (type == "Number") {
		ins->right.push_back(this->number_init());
	} else if (type == "String") {
		ins->right.push_back(this->string_init());
	} else if (type == "Bool") {
		ins->right.push_back(this->boolean_init());
	} else {
		std::cout << "Does not know how to init type " << type << " after :";
		exit(0);
	}

	return ins;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x80, %edi
callq 0x3230
movq %rax, %rbx
andl $0x0, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
andq $0x0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movl $0x2, 0x30(%rbx)
cmpl $0x3, (%r15)
jne 0xd7b6
leaq 0x8(%rbx), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0x3160
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xcaaa
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0xd7a1
movq (%rax), %rsi
cmpl $0x3, (%rsi)
jne 0xd7a1
addq $0x8, %rsi
leaq 0x8(%rsp), %rdi
callq 0x32b0
leaq 0x3f7f(%rip), %rsi      # 0x11687
leaq 0x8(%rsp), %rdi
callq 0x3b79
testb %al, %al
je 0xd72c
callq 0xe08e
leaq 0x50(%rbx), %rdi
movq %rsp, %rsi
movq %rax, (%rsi)
callq 0x10210
jmp 0xd780
leaq 0x3f5b(%rip), %rsi      # 0x1168e
leaq 0x8(%rsp), %rdi
callq 0x3b79
testb %al, %al
je 0xd757
callq 0xf356
leaq 0x50(%rbx), %rdi
movq %rsp, %rsi
movq %rax, (%rsi)
callq 0x10210
jmp 0xd780
leaq 0x49b4(%rip), %rsi      # 0x12112
leaq 0x8(%rsp), %rdi
callq 0x3b79
testb %al, %al
je 0xd7d0
callq 0xf408
leaq 0x50(%rbx), %rdi
movq %rsp, %rsi
movq %rax, (%rsi)
callq 0x10210
leaq 0x8(%rsp), %rdi
callq 0x3130
leaq 0x28(%rsp), %rdi
callq 0x42f2
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xd828(%rip), %rdi      # 0x1afd0
leaq 0x4929(%rip), %rsi      # 0x120d8
callq 0x3220
jmp 0xd7c9
movq 0xd813(%rip), %rdi      # 0x1afd0
leaq 0x48e2(%rip), %rsi      # 0x120a6
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq 0xd7f9(%rip), %rdi      # 0x1afd0
leaq 0x4939(%rip), %rsi      # 0x12117
callq 0x3220
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x3200
leaq 0x4940(%rip), %rsi      # 0x12137
movq %rax, %rdi
callq 0x3220
jmp 0xd7c9
jmp 0xd807
jmp 0xd807
jmp 0xd807
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3130
jmp 0xd81b
jmp 0xd818
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x42f2
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3230
movq %rax, %rbx
movl $0xf, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
leaq 0x38(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
andq $0x0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movl $0x2, 0x30(%rbx)
leaq 0x50(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x28(%rsp), %r15
pushq $0x1
popq %rdx
leaq 0xe(%rsp), %rcx
movq %r15, %rdi
callq 0xf808
movq %r12, %rdi
movq %r15, %rsi
callq 0x10148
movq %r15, %rdi
callq 0x42f2
leaq 0x39eb(%rip), %rsi      # 0x112b3
leaq 0x68(%rsp), %r15
leaq 0xe(%rsp), %rdx
movq %r15, %rdi
callq 0x30f0
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x63f2
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0xf(%rsp), %rcx
callq 0xf720
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq 0xca06
movq %rbx, %rdi
addq $0x50, %rdi
leaq 0x50(%rsp), %r14
movq %r14, %rsi
callq 0x10148
movq %r14, %rdi
callq 0x42f2
leaq 0x10(%rsp), %rdi
callq 0xf75a
leaq 0x30(%rsp), %rdi
callq 0x3130
leaq 0x68(%rsp), %rdi
callq 0x3130
movq 0x58(%rbx), %rax
subq 0x50(%rbx), %rax
cmpq $0x8, %rax
jne 0xd96a
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xd65f(%rip), %rdi      # 0x1afd0
leaq 0x4669(%rip), %rsi      # 0x11fe1
callq 0x3220
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf75a
jmp 0xd996
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3130
jmp 0xd9a5
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xdb3f
leaq 0x4406(%rip), %rcx      # 0x11ee8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xe330
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf0d4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xe58e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf2d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xe9d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xed58
movq 0xd48a(%rip), %rdi      # 0x1afd0
leaq 0x44cb(%rip), %rsi      # 0x12018
callq 0x3220
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6518
movq %r14, %rdi
movq %r15, %rsi
callq 0x3200
leaq 0x3cd4(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
movq %rsp, %rdi
callq 0x3130
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/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
movl 0x4(%rsi), %eax
cmpl $0x22, %eax
je 0xdbc4
cmpl $0x2e, %eax
jne 0xdbd2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xde3a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xe076
movq %rsi, %rbx
movq 0xd3f4(%rip), %rdi      # 0x1afd0
leaq 0x43eb(%rip), %rsi      # 0x11fce
callq 0x3220
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6518
movq %r14, %rdi
movq %r15, %rsi
callq 0x3200
leaq 0x3c3e(%rip), %rsi      # 0x11849
movq %rax, %rdi
callq 0x3220
movq %rsp, %rdi
callq 0x3130
xorl %edi, %edi
callq 0x3280
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/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 0x3230
movq %rax, %r12
addq $0x18, %rax
leal 0x3(,%r13,8), %ecx
movl %ecx, (%r12)
movq %rax, 0x8(%r12)
andq $0x0, 0x10(%r12)
leaq 0x8(%r12), %rdi
movb $0x0, 0x18(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r12)
movups %xmm0, 0x48(%r12)
andq $0x0, 0x78(%r12)
movups %xmm0, 0x58(%r12)
movups %xmm0, 0x68(%r12)
movl $0x2, 0x30(%r12)
addq $0x8, %r15
movq %r15, %rsi
callq 0x3160
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xce8c
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::oper_list_creation()
Instruction* Parser::oper_list_creation() {
	Instruction* ins = new Instruction(Ins::LIST_CREATE);

	// Get all peices (seperated by commas)
	do {
		ins->right = this->read_until(std::vector<lexer::Token>{
			lexer::Token::OPERATOR("]"),
			lexer::Token::OPERATOR(","),
		}, ins->right);
	} while (this->get_token()->sub == lexer::Type::OPERATOR_COMMA);

	return ins;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %r15
movl $0x80, %edi
callq 0x3230
movq %rax, %r13
movl $0xe, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%r13)
andq $0x0, 0x10(%r13)
movb $0x0, 0x18(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r13)
movups %xmm0, 0x48(%r13)
movups %xmm0, 0x58(%r13)
movups %xmm0, 0x68(%r13)
andq $0x0, 0x78(%r13)
movl $0x2, 0x30(%r13)
leaq 0x60(%rsp), %rbx
movq %r13, 0x18(%rsp)
addq $0x50, %r13
movq %r13, 0x10(%rsp)
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
leaq 0x33f7(%rip), %rsi      # 0x112b3
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x63f2
leaq 0x88(%rsp), %r12
movq %r12, %rdi
leaq 0x339d(%rip), %rsi      # 0x11282
leaq 0xe(%rsp), %rdx
callq 0x30f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x63f2
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0xd(%rsp), %rcx
callq 0xf720
leaq 0xa8(%rsp), %rbp
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x40b0
movq %r14, %r12
leaq 0xe0(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdx
movq %rbp, %rcx
callq 0xccf2
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x10148
movq %r13, %rdi
callq 0x42f2
movq %rbp, %rdi
callq 0x42f2
movq %r14, %rdi
callq 0xf75a
pushq $0x30
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x38, %rdi
callq 0x3130
addq $-0x28, %r14
cmpq $-0x20, %r14
jne 0xdf70
leaq 0x88(%rsp), %rdi
callq 0x3130
movq %r12, %r14
movq %r12, %rdi
callq 0x3130
movslq 0x18(%r15), %rax
movq (%r15), %rcx
movq (%rcx,%rax,8), %rax
cmpl $0x12, 0x4(%rax)
je 0xdeb2
movq 0x18(%rsp), %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
xorl %ebp, %ebp
leaq 0x38(%rsp), %rbx
jmp 0xe034
movq %rax, %r14
xorl %ebp, %ebp
jmp 0xe034
movq %rax, %r14
xorl %ebp, %ebp
jmp 0xe027
movq %rax, %r14
jmp 0xe009
movq %rax, %r14
jmp 0xdfff
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0x42f2
leaq 0x20(%rsp), %rdi
callq 0xf75a
pushq $0x30
popq %r15
leaq (%rsp,%r15), %rdi
addq $0x38, %rdi
callq 0x3130
addq $-0x28, %r15
cmpq $-0x20, %r15
jne 0xe00d
movb $0x1, %bpl
leaq 0x88(%rsp), %rdi
callq 0x3130
leaq 0xc0(%rsp), %rdi
callq 0x3130
leaq 0x38(%rsp), %rax
cmpq %rbx, %rax
sete %al
orb %bpl, %al
jne 0xe06e
leaq 0x38(%rsp), %r15
leaq -0x28(%rbx), %r12
addq $-0x20, %rbx
movq %rbx, %rdi
callq 0x3130
movq %r12, %rbx
cmpq %r15, %r12
jne 0xe056
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::keyword_class()
Instruction* Parser::keyword_class() {
	Instruction* ins = new Instruction(Ins::DEFINE_CLASS);

	this->advance();

	lexer::Token* n = this->get_and_expect_token(lexer::Token::NAME(""));
	ins->name = n->value;

	this->advance();
	this->get_and_expect_token(lexer::Token::OPERATOR("{"));

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

	return ins;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %r14
movl $0x80, %edi
callq 0x3230
movq %rax, %rbx
movl $0x9, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
andq $0x0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movl $0x2, 0x30(%rbx)
cmpb $0x1, 0x20(%r14)
jne 0xe391
incl 0x18(%r14)
jmp 0xe396
movb $0x1, 0x20(%r14)
leaq 0x34ad(%rip), %rsi      # 0x1184a
leaq 0x90(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x30f0
leaq 0xd8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x6478
leaq 0xd8(%rsp), %rsi
movq %r14, %rdi
callq 0xd9bc
movq %rax, %r15
leaq 0x8(%rbx), %r12
leaq 0xe0(%rsp), %rdi
callq 0x3130
leaq 0x90(%rsp), %rdi
callq 0x3130
addq $0x8, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x3160
cmpb $0x1, 0x20(%r14)
jne 0xe411
incl 0x18(%r14)
jmp 0xe416
movb $0x1, 0x20(%r14)
leaq 0x2e90(%rip), %rsi      # 0x112ad
leaq 0x70(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x30f0
leaq 0xb0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x63f2
leaq 0xb0(%rsp), %rsi
movq %r14, %rdi
callq 0xd9bc
leaq 0xb8(%rsp), %rdi
callq 0x3130
leaq 0x70(%rsp), %rdi
callq 0x3130
cmpb $0x1, 0x20(%r14)
jne 0xe472
incl 0x18(%r14)
jmp 0xe477
movb $0x1, 0x20(%r14)
leaq 0x2e31(%rip), %rsi      # 0x112af
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
leaq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x63f2
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0xe(%rsp), %rcx
callq 0xf720
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq 0xca06
movq %rbx, %rdi
addq $0x50, %rdi
leaq 0x100(%rsp), %r14
movq %r14, %rsi
callq 0x10148
movq %r14, %rdi
callq 0x42f2
leaq 0x10(%rsp), %rdi
callq 0xf75a
leaq 0x30(%rsp), %rdi
callq 0x3130
leaq 0x50(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf75a
jmp 0xe529
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3130
jmp 0xe538
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0xe57c
jmp 0xe583
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x3130
jmp 0xe556
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0xe57c
jmp 0xe583
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x3130
jmp 0xe574
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x3130
jmp 0xe586
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3390