LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kram[P]kram/./src/lexer/token.cpp
// Function: lexer::Token::print[abi:cxx11](lexer::Type)
std::string Token::print(Type in) {
	for (const auto& kv : opTrans) {
		if (kv.second == in) {
			return kv.first;
		}
	}

	return "UNKNOWN";
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
leaq 0x2c4f7(%rip), %rax     # 0x3a2c8
movq %rax, 0x50(%rsp)
leaq 0x2c4eb(%rip), %rdi     # 0x3a2c8
callq 0xe0c0
movq %rax, 0x48(%rsp)
leaq 0x2c4da(%rip), %rdi     # 0x3a2c8
callq 0xe0f0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xe120
testb $0x1, %al
jne 0xde0d
jmp 0xde49
leaq 0x48(%rsp), %rdi
callq 0xe140
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl 0x20(%rax), %eax
cmpl 0x5c(%rsp), %eax
jne 0xde3b
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3140
jmp 0xde96
jmp 0xde3d
leaq 0x48(%rsp), %rdi
callq 0xe160
jmp 0xddf8
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x34a0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x1d2c0(%rip), %rsi     # 0x2b129
callq 0x3390
jmp 0xde70
leaq 0x37(%rsp), %rdi
callq 0x3310
jmp 0xde96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x3310
jmp 0xdea0
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: kram[P]kram/./src/vm/vm_environment.cpp
// Function: VM::name_update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Value*)
void VM::name_update(const std::string& name, Value* val) {

	// Verify that the variable exists first
	if (!this->environment->exists(name)) {
		std::cout << "No such variable, " << name << ", did you mean to use := ?\n";
		exit(0);
	}

	Value* previous = this->environment->get(name);

	if (previous->type != val->type) {
		std::cout << "Can not update (with =) a variable of type " << previous->print(true) << " to " << val->print(true) << "\n";
		exit(0);
	}

	this->environment->update(name, val);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rax), %rdi
movq 0x98(%rsp), %rsi
callq 0x1dc70
testb $0x1, %al
jne 0xfd3a
movq 0x2a2d0(%rip), %rdi     # 0x39fd8
leaq 0x1b5d2(%rip), %rsi     # 0x2b2e1
callq 0x32d0
movq %rax, %rdi
movq 0x98(%rsp), %rsi
callq 0x32a0
movq %rax, %rdi
leaq 0x1b5c6(%rip), %rsi     # 0x2b2f4
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x98(%rsp), %rsi
callq 0x1da70
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x90(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0xfe67
movq 0x2a25d(%rip), %rdi     # 0x39fd8
leaq 0x1b58e(%rip), %rsi     # 0x2b310
callq 0x32d0
movq %rax, 0x18(%rsp)
movq 0x88(%rsp), %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x1, %edx
callq 0x1e430
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x32a0
movq %rax, 0x28(%rsp)
jmp 0xfdbe
movq 0x28(%rsp), %rdi
leaq 0x1b572(%rip), %rsi     # 0x2b33c
callq 0x32d0
movq %rax, 0x10(%rsp)
jmp 0xfdd6
movq 0x90(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movl $0x1, %edx
callq 0x1e430
jmp 0xfdef
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x32a0
movq %rax, 0x8(%rsp)
jmp 0xfe05
movq 0x8(%rsp), %rdi
leaq 0x1ba50(%rip), %rsi     # 0x2b861
callq 0x32d0
jmp 0xfe18
leaq 0x38(%rsp), %rdi
callq 0x31f0
leaq 0x68(%rsp), %rdi
callq 0x31f0
xorl %edi, %edi
callq 0x3330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xfe5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x31f0
leaq 0x68(%rsp), %rdi
callq 0x31f0
jmp 0xfe8d
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x1d980
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: kram[P]kram/./src/vm/libraries/std/String.h
// Function: utf8chr[abi:cxx11](int)
std::string utf8chr(int cp)
{
    char c[5]={ 0x00,0x00,0x00,0x00,0x00 };
    if     (cp<=0x7F) { c[0] = cp;  }
    else if(cp<=0x7FF) { c[0] = (cp>>6)+192; c[1] = (cp&63)+128; }
    else if(0xd800<=cp && cp<=0xdfff) {} //invalid block of utf8
    else if(cp<=0xFFFF) { c[0] = (cp>>12)+224; c[1]= ((cp>>6)&63)+128; c[2]=(cp&63)+128; }
    else if(cp<=0x10FFFF) { c[0] = (cp>>18)+240; c[1] = ((cp>>12)&63)+128; c[2] = ((cp>>6)&63)+128; c[3]=(cp&63)+128; }
    return std::string(c);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
leaq 0x37(%rsp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x31a0
cmpl $0x7f, 0x3c(%rsp)
jg 0xff9f
movl 0x3c(%rsp), %eax
movb %al, 0x37(%rsp)
jmp 0x1007f
cmpl $0x7ff, 0x3c(%rsp)      # imm = 0x7FF
jg 0xffce
movl 0x3c(%rsp), %eax
sarl $0x6, %eax
addl $0xc0, %eax
movb %al, 0x37(%rsp)
movl 0x3c(%rsp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, 0x38(%rsp)
jmp 0x1007d
movl $0xd800, %eax           # imm = 0xD800
cmpl 0x3c(%rsp), %eax
jg 0xffe8
cmpl $0xdfff, 0x3c(%rsp)     # imm = 0xDFFF
jg 0xffe8
jmp 0x1007b
cmpl $0xffff, 0x3c(%rsp)     # imm = 0xFFFF
jg 0x10027
movl 0x3c(%rsp), %eax
sarl $0xc, %eax
addl $0xe0, %eax
movb %al, 0x37(%rsp)
movl 0x3c(%rsp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, 0x38(%rsp)
movl 0x3c(%rsp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, 0x39(%rsp)
jmp 0x10079
cmpl $0x10ffff, 0x3c(%rsp)   # imm = 0x10FFFF
jg 0x10077
movl 0x3c(%rsp), %eax
sarl $0x12, %eax
addl $0xf0, %eax
movb %al, 0x37(%rsp)
movl 0x3c(%rsp), %eax
sarl $0xc, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, 0x38(%rsp)
movl 0x3c(%rsp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, 0x39(%rsp)
movl 0x3c(%rsp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, 0x3a(%rsp)
jmp 0x10079
jmp 0x1007b
jmp 0x1007d
jmp 0x1007f
leaq 0x36(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x34a0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x37(%rsp), %rsi
callq 0x3390
jmp 0x100a4
leaq 0x36(%rsp), %rdi
callq 0x3310
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x36(%rsp), %rdi
callq 0x3310
movq 0x28(%rsp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::assign(Instruction*, vm::ON)
Value* VM::assign(Instruction* ins, vm::ON on) {

	if (on == vm::ON::PUSHED_CLASS) {
		Value* top = this->lib_stack.back();

		if (top->type != Type::CLASS) {
			std::cout << "The assign operation (:=) is not allowed on this object (userland classes only)\n";
			exit(0);
		}

		// Convert top to a Class*
		Class* cl = static_cast<Class*>(top);
		cl->set_value(ins->name, this->run(ins->right[0]));
	} else {
		this->name_create(ins->name, this->run(ins->right[0]));
	}

	return this->get_value_null();
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x1, 0x64(%rsp)
jne 0x101c7
movq 0x18(%rsp), %rdi
callq 0x134e0
movq (%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
cmpl $0x6, 0x8(%rax)
je 0x1013e
movq 0x29ead(%rip), %rdi     # 0x39fd8
leaq 0x1b32a(%rip), %rsi     # 0x2b45c
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rsi
addq $0x8, %rsi
leaq 0x30(%rsp), %rdi
callq 0x3140
movq 0x68(%rsp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13710
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
callq 0x10220
movq %rax, 0x10(%rsp)
jmp 0x1018b
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x13520
jmp 0x101a1
leaq 0x30(%rsp), %rdi
callq 0x31f0
jmp 0x10204
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x31f0
jmp 0x10213
movq 0x68(%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13710
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
callq 0x10220
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movq %rax, %rdx
callq 0xfc10
movq 0x18(%rsp), %rdi
callq 0x1d770
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::set(Instruction*, vm::ON)
Value* VM::set(Instruction* ins, vm::ON on) {
	if (on == vm::ON::PUSHED_CLASS) {
		Value* top = this->lib_stack.back();

		if (top->type != Type::CLASS) {
			std::cout << "The set operation (=) is not allowed on this object (userland classes only)\n";
			exit(0);
		}

		// Convert top to a Class*
		Class* cl = static_cast<Class*>(top);
		cl->update_value(ins->name, this->run(ins->right[0]));
	} else {
		this->name_update(ins->name, this->run(ins->right[0]));
	}

	return this->get_value_null();
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x1, 0x64(%rsp)
jne 0x10337
movq 0x18(%rsp), %rdi
callq 0x134e0
movq (%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
cmpl $0x6, 0x8(%rax)
je 0x102ae
movq 0x29d3d(%rip), %rdi     # 0x39fd8
leaq 0x1b20b(%rip), %rsi     # 0x2b4ad
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rsi
addq $0x8, %rsi
leaq 0x30(%rsp), %rdi
callq 0x3140
movq 0x68(%rsp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13710
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
callq 0x10220
movq %rax, 0x10(%rsp)
jmp 0x102fb
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x13730
jmp 0x10311
leaq 0x30(%rsp), %rdi
callq 0x31f0
jmp 0x10374
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x31f0
jmp 0x10383
movq 0x68(%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13710
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
callq 0x10220
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movq %rax, %rdx
callq 0xfcc0
movq 0x18(%rsp), %rdi
callq 0x1d770
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::math_string(Instruction*, Value*, Value*)
Value* VM::math_string(Instruction* ins, Value* left, Value* right) {

	bool res_bool = false;
	bool is_bool = false;
	std::string l = left->getString();
	std::string r = right->getString();

	switch (ins->type) {
		case lexer::Type::OPERATOR_EQEQ:
			res_bool = l == r;
			is_bool = true;
			break;

		case lexer::Type::OPERATOR_NOT_EQ:
			res_bool = l != r;
			is_bool = true;
			break;

		default:
			std::cout << "Unknown math_string() operator\n";
			exit(0);
			break;
	}

	if (is_bool) {
		return this->get_value_bool(res_bool);
	}

	return this->get_value_number(0);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq %rcx, 0x80(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x7f(%rsp)
movb $0x0, 0x7e(%rsp)
movq 0x88(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x1e9e0
movq 0x80(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x1e9e0
jmp 0x10c74
movq 0x90(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x1c(%rsp)
subl $0x17, %eax
je 0x10cc4
jmp 0x10c8a
movl 0x1c(%rsp), %eax
subl $0x18, %eax
je 0x10ca8
jmp 0x10ce0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x10d9d
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x9b60
andb $0x1, %al
movb %al, 0x7f(%rsp)
movb $0x1, 0x7e(%rsp)
jmp 0x10d19
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x139f0
andb $0x1, %al
movb %al, 0x7f(%rsp)
movb $0x1, 0x7e(%rsp)
jmp 0x10d19
movq 0x292f1(%rip), %rdi     # 0x39fd8
leaq 0x1a893(%rip), %rsi     # 0x2b581
callq 0x32d0
jmp 0x10cf5
xorl %edi, %edi
callq 0x3330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x31f0
jmp 0x10d9d
testb $0x1, 0x7e(%rsp)
je 0x10d50
movq 0x20(%rsp), %rdi
movzbl 0x7f(%rsp), %esi
andl $0x1, %esi
callq 0x1d850
movq %rax, 0x10(%rsp)
jmp 0x10d39
movq 0x10(%rsp), %rax
movq %rax, 0xa0(%rsp)
movl $0x1, 0x28(%rsp)
jmp 0x10d79
movq 0x20(%rsp), %rdi
xorps %xmm0, %xmm0
callq 0x1d780
movq %rax, 0x8(%rsp)
jmp 0x10d64
movq 0x8(%rsp), %rax
movq %rax, 0xa0(%rsp)
movl $0x1, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x31f0
leaq 0x58(%rsp), %rdi
callq 0x31f0
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
leaq 0x58(%rsp), %rdi
callq 0x31f0
movq 0x30(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::list_range(int, int, bool)
Value* VM::list_range(int start, int end, bool inclusive) {
	List* list = new List();
	list->set_type(Type::REFERENCE);
	list->init();

	if (!inclusive) {
		end--;
	}

	if (end < start) {
		std::cout << "Range: End needs to be bigger or equal to Start\n";
		exit(0);
	}

	std::vector<Value*> items;

	for (int i = start; i <= end; i++) {
		items.push_back(this->get_value_number(i));
	}

	list->push(items);

	return list;
}

// Assembly:
subq $0x98, %rsp
movb %cl, %al
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movl %edx, 0x88(%rsp)
andb $0x1, %al
movb %al, 0x87(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x28, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
callq 0x13e50
jmp 0x10e23
movq 0x20(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movl $0x4, %esi
callq 0x1e060
movq 0x78(%rsp), %rdi
callq 0x13e80
testb $0x1, 0x87(%rsp)
jne 0x10e80
movl 0x88(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x88(%rsp)
jmp 0x10e80
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0x32b0
jmp 0x10f94
movl 0x88(%rsp), %eax
cmpl 0x8c(%rsp), %eax
jge 0x10eaa
movq 0x29141(%rip), %rdi     # 0x39fd8
leaq 0x1a7c6(%rip), %rsi     # 0x2b664
callq 0x32d0
xorl %edi, %edi
callq 0x3330
leaq 0x50(%rsp), %rdi
callq 0x56d0
movl 0x8c(%rsp), %eax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x88(%rsp), %eax
jg 0x10f1d
movq 0x18(%rsp), %rdi
cvtsi2sdl 0x4c(%rsp), %xmm0
callq 0x1d780
movq %rax, 0x10(%rsp)
jmp 0x10ee3
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x141e0
jmp 0x10efe
jmp 0x10f00
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x10ebf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x10f8a
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x14280
jmp 0x10f38
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x14210
jmp 0x10f49
leaq 0x28(%rsp), %rdi
callq 0x5850
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5850
movq (%rsp), %rax
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5850
leaq 0x50(%rsp), %rdi
callq 0x5850
movq 0x70(%rsp), %rdi
callq 0x3490
nop
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::if_case(Instruction*)
Value* VM::if_case(Instruction* ins) {

	this->env_push();

	Value* res = this->run(ins->center[0]);

	if (res->type != Type::BOOL) {
		std::cout << "If-case must evaluate to a BOOL\n";
		exit(0);
	}

	// Was true
	if (res->getBool()) {
		auto res = this->run(ins->left);
		this->env_pop();
		return res;
	}

	// Has else-part
	if (ins->right.size() > 0) {
		auto res = this->run(ins->right);
		this->env_pop();
		return res;
	}

	this->env_pop();

	// Return NUL otherwise
	return this->get_value_null();
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xff30
movq 0x80(%rsp), %rdi
addq $0x68, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13710
movq 0x20(%rsp), %rdi
movq (%rax), %rsi
callq 0x10220
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
cmpl $0x3, 0x8(%rax)
je 0x11015
movq 0x28fd6(%rip), %rdi     # 0x39fd8
leaq 0x1a598(%rip), %rsi     # 0x2b5a1
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x78(%rsp), %rdi
callq 0x1e9b0
testb $0x1, %al
jne 0x11025
jmp 0x110a3
movq 0x80(%rsp), %rsi
addq $0x38, %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5460
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11170
movq %rax, 0x18(%rsp)
jmp 0x11056
leaq 0x58(%rsp), %rdi
callq 0x5560
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x70(%rsp)
callq 0xff00
movq 0x70(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x1114c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5560
jmp 0x1115c
movq 0x80(%rsp), %rdi
addq $0x50, %rdi
callq 0x56b0
cmpq $0x0, %rax
jbe 0x11130
movq 0x80(%rsp), %rsi
addq $0x50, %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5460
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x11170
movq %rax, 0x8(%rsp)
jmp 0x110e9
leaq 0x28(%rsp), %rdi
callq 0x5560
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0xff00
movq 0x40(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x1114c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5560
jmp 0x1115c
movq 0x20(%rsp), %rdi
callq 0xff00
movq 0x20(%rsp), %rdi
callq 0x1d770
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::run(std::vector<Instruction*, std::allocator<Instruction*>>)
Value* VM::run(std::vector<Instruction*> ins) {

	Value* last = this->get_value_null();

	for (Instruction* i : ins) {

		last = this->run(i, vm::ON::DEFAULT);

		if (i->instruction == Ins::RETURN) {
			return last;
		}

		if (this->function_should_return()) {
			return last;
		}
	}

	return last;
}

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1d770
movq 0x10(%rsp), %rsi
movq %rax, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4240
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4270
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x42a0
testb $0x1, %al
jne 0x111d4
jmp 0x1123c
leaq 0x28(%rsp), %rdi
callq 0x42e0
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x11570
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x10, (%rax)
jne 0x11212
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x11246
movq 0x8(%rsp), %rdi
callq 0x11450
testb $0x1, %al
jne 0x11222
jmp 0x1122e
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x11246
jmp 0x11230
leaq 0x28(%rsp), %rdi
callq 0x5410
jmp 0x111bf
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::loop_while(Instruction*)
Value* VM::loop_while(Instruction* ins) {

	while (true) {
		Value* res = this->run(ins->left[0]);

		if (res->type != Type::BOOL) {
			std::cout << "While-case must evaluate to a BOOL\n";
			return this->get_value_null();
		}

		// Not true anymore
		if (res->getBool() == false) {
			return this->get_value_null();
		}

		this->env_push();
		this->run(ins->right);
		this->env_pop();
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13710
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0x10220
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x3, 0x8(%rax)
je 0x112be
movq 0x28d3a(%rip), %rdi     # 0x39fd8
leaq 0x1a31d(%rip), %rsi     # 0x2b5c2
callq 0x32d0
movq 0x8(%rsp), %rdi
callq 0x1d770
movq %rax, 0x50(%rsp)
jmp 0x11347
movq 0x38(%rsp), %rdi
callq 0x1e9b0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x112e3
movq 0x8(%rsp), %rdi
callq 0x1d770
movq %rax, 0x50(%rsp)
jmp 0x11347
movq 0x8(%rsp), %rdi
callq 0xff30
movq 0x40(%rsp), %rsi
addq $0x50, %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5460
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x11170
jmp 0x11314
leaq 0x20(%rsp), %rdi
callq 0x5560
movq 0x8(%rsp), %rdi
callq 0xff00
jmp 0x11268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x5560
jmp 0x11351
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::kw_return(Instruction*)
Value* VM::kw_return(Instruction* ins) {

	auto res = this->run(ins->right);

	this->function_return_stack.pop_back();
	this->function_return_stack.push_back(true);

	return res;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rsi
addq $0x50, %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5460
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11170
movq %rax, 0x10(%rsp)
jmp 0x113a4
leaq 0x28(%rsp), %rdi
callq 0x5560
movq 0x10(%rsp), %rax
movq (%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x830, %rdi            # imm = 0x830
callq 0x13a20
movq (%rsp), %rdi
addq $0x830, %rdi            # imm = 0x830
movl $0x1, %esi
callq 0x13a40
movq 0x40(%rsp), %rax
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5560
movq 0x20(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::push_class(Instruction*)
Value* VM::push_class(Instruction* ins) {
	// Run what we should push
	// Can be a name (name.method() or name::method()),
	// a literal (100.Sqrt())
	// or something else
	Value* push = this->run(ins->left[0]);

	// Add a pointer to the class to the back (aka top) of the stack
	this->lib_stack.push_back(push);

	if (ins->right.size() != 1) {
		std::cout << "push_class() expects exactly 1 child. This is a bug, please report it! :)\n";
		exit(0);
	}

	// Run the right part
	auto res = this->run(ins->right[0], vm::ON::PUSHED_CLASS);

	this->lib_stack.pop_back();

	return res;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13710
movq (%rsp), %rdi
movq (%rax), %rsi
callq 0x10220
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x13bd0
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
callq 0x56b0
cmpq $0x1, %rax
je 0x11526
movq 0x28ac5(%rip), %rdi     # 0x39fd8
leaq 0x1a0cc(%rip), %rsi     # 0x2b5e6
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13710
movq (%rsp), %rdi
movq (%rax), %rsi
movl $0x1, %edx
callq 0x11570
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x13c40
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::function(Instruction*)
Value* VM::function(Instruction* ins) {
	Function* fn = new Function();
	fn->set_type(Type::FUNCTION);
	fn->init();
	
	fn->set_parameters(ins->left);
	fn->set_content(ins->right);

	fn->vm = this;

	return fn;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x50, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x13c60
jmp 0x117e3
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movl $0x5, %esi
callq 0x1e060
movq 0x70(%rsp), %rdi
callq 0x13ca0
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rsi
addq $0x38, %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5460
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x13cc0
jmp 0x11839
leaq 0x48(%rsp), %rdi
callq 0x5560
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movq 0x78(%rsp), %rsi
addq $0x50, %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5460
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x13de0
jmp 0x11874
leaq 0x30(%rsp), %rdi
callq 0x5560
movq 0x20(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x70(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x32b0
jmp 0x118e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5560
jmp 0x118e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5560
movq 0x68(%rsp), %rdi
callq 0x3490
nop
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::define_class(Instruction*)
Value* VM::define_class(Instruction* ins) {
	Class* cl = new Class();
	cl->set_type(Type::CLASS);
	cl->init();

	cl->vm = this;

	for (Instruction* sub : ins->right) {
		if (sub->instruction != Ins::ASSIGN) {
			std::cout << "Class definitions can only contain assignments\n";
			exit(0);
		}

		cl->set_value(sub->name, this->run(sub->right[0]));
	}

	// Set in the global scope
	this->name_create_root(ins->name, cl);

	return cl;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x50, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x13e10
jmp 0x11946
movq 0x28(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
movl $0x6, %esi
callq 0x1e060
movq 0xa0(%rsp), %rdi
callq 0x13e40
movq 0x20(%rsp), %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0xa8(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x4240
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x4270
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x42a0
testb $0x1, %al
jne 0x119d9
jmp 0x11acd
leaq 0x80(%rsp), %rdi
callq 0x42e0
movq (%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
cmpl $0x0, (%rax)
je 0x11a35
movq 0x285d9(%rip), %rdi     # 0x39fd8
leaq 0x19c2b(%rip), %rsi     # 0x2b631
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x32b0
jmp 0x11b39
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rsi
addq $0x8, %rsi
leaq 0x50(%rsp), %rdi
callq 0x3140
movq 0x70(%rsp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13710
movq 0x20(%rsp), %rdi
movq (%rax), %rsi
callq 0x10220
movq %rax, 0x18(%rsp)
jmp 0x11a7b
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x13520
jmp 0x11a91
leaq 0x50(%rsp), %rdi
callq 0x31f0
leaq 0x80(%rsp), %rdi
callq 0x5410
jmp 0x119be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x31f0
jmp 0x11b39
movq 0xa8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3140
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0xfc40
jmp 0x11b01
leaq 0x30(%rsp), %rdi
callq 0x31f0
movq 0xa0(%rsp), %rax
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x31f0
movq 0x98(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::list_create(Instruction*)
Value* VM::list_create(Instruction* ins) {
	List* list = new List();
	list->set_type(Type::REFERENCE);
	list->init();

	if (ins->right.size() > 0) {
		std::vector<Value*> values;

		for (Instruction* i : ins->right) {
			values.push_back(this->run(i));
		}

		list->push(values);
	}

	return list;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x28, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
callq 0x13e50
jmp 0x11ba2
movq 0x20(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movl $0x4, %esi
callq 0x1e060
movq 0x90(%rsp), %rdi
callq 0x13e80
movq 0x98(%rsp), %rdi
addq $0x50, %rdi
callq 0x56b0
cmpq $0x0, %rax
jbe 0x11d33
leaq 0x68(%rsp), %rdi
callq 0x56d0
movq 0x98(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x4240
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x4270
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x42a0
testb $0x1, %al
jne 0x11c3a
jmp 0x11cc4
leaq 0x58(%rsp), %rdi
callq 0x42e0
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rsi
callq 0x10220
movq %rax, 0x10(%rsp)
jmp 0x11c62
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x141e0
jmp 0x11c7d
jmp 0x11c7f
leaq 0x58(%rsp), %rdi
callq 0x5410
jmp 0x11c22
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
callq 0x32b0
jmp 0x11d43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x11d27
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x14280
jmp 0x11ce2
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x14210
jmp 0x11cf3
leaq 0x28(%rsp), %rdi
callq 0x5850
leaq 0x68(%rsp), %rdi
callq 0x5850
jmp 0x11d33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5850
leaq 0x68(%rsp), %rdi
callq 0x5850
jmp 0x11d43
movq 0x90(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x3490
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::create_instance(Instruction*)
Value* VM::create_instance(Instruction* ins) {
	Value* original = this->name_get(ins->name);

	// Kram-defined classes
	if (original->type == Type::CLASS) {
		// Cast as class
		Class* cl = static_cast<Class*>(original);
		return cl->new_instance();
	}

	Value* instance = original->exec_method("new", this->run_vector(ins->right));
	return instance;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0xa0(%rsp), %rsi
addq $0x8, %rsi
callq 0xfea0
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
cmpl $0x6, 0x8(%rax)
jne 0x11f95
movq 0x98(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rdi
callq 0x14410
movq %rax, 0xb0(%rsp)
jmp 0x120bf
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x34a0
movq 0x10(%rsp), %rdx
leaq 0x19260(%rip), %rsi     # 0x2b21d
leaq 0x68(%rsp), %rdi
callq 0x3390
jmp 0x11fc9
movq 0xa0(%rsp), %rsi
addq $0x50, %rsi
leaq 0x20(%rsp), %rdi
callq 0x5460
jmp 0x11fe1
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x120e0
jmp 0x11ff7
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x1e140
movq %rax, (%rsp)
jmp 0x12011
leaq 0x38(%rsp), %rdi
callq 0x5850
leaq 0x20(%rsp), %rdi
callq 0x5560
leaq 0x68(%rsp), %rdi
callq 0x31f0
leaq 0x67(%rsp), %rdi
callq 0x3310
movq (%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0xb0(%rsp)
jmp 0x120bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x120b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x120a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1209f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5850
leaq 0x20(%rsp), %rdi
callq 0x5560
leaq 0x68(%rsp), %rdi
callq 0x31f0
leaq 0x67(%rsp), %rdi
callq 0x3310
jmp 0x120cf
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::run_vector(std::vector<Instruction*, std::allocator<Instruction*>>)
std::vector<Value*> VM::run_vector(std::vector<Instruction*> instructions) {
	std::vector<Value*> res;

	for (Instruction* i : instructions) {
		res.push_back(this->run(i));
	}

	return res;
}

// Assembly:
subq $0x88, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x6f(%rsp)
callq 0x56d0
movq 0x28(%rsp), %rdx
movq %rdx, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x4240
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x4270
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x42a0
testb $0x1, %al
jne 0x1215c
jmp 0x121c7
leaq 0x58(%rsp), %rdi
callq 0x42e0
movq 0x20(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rsi
callq 0x10220
movq %rax, 0x8(%rsp)
jmp 0x12184
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x141e0
jmp 0x1219f
jmp 0x121a1
leaq 0x58(%rsp), %rdi
callq 0x5410
jmp 0x12147
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x5850
jmp 0x121ea
movb $0x1, 0x6f(%rsp)
testb $0x1, 0x6f(%rsp)
jne 0x121dd
movq 0x10(%rsp), %rdi
callq 0x5850
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: kram[P]kram/./src/vm/vm.cpp
// Function: VM::call_library(Instruction*)
Value* VM::call_library(Instruction* ins) {

	// Get the method name
	Value* name = this->name(ins->left[0], vm::ON::DEFAULT);

	// Get the library from the top of the stack
	Value* lib = this->lib_stack.back();

	// Execute the parameters and call the method
	return lib->exec_method(name->getString(), this->run_vector(ins->right));
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x98(%rsp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, 0x14(%rsp)
movl %eax, %esi
callq 0x13710
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
callq 0x103b0
movq 0x18(%rsp), %rdi
movq %rax, 0x90(%rsp)
callq 0x134e0
movq (%rax), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x90(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x1e9e0
movq 0x98(%rsp), %rsi
addq $0x50, %rsi
leaq 0x38(%rsp), %rdi
callq 0x5460
jmp 0x12b02
movq 0x18(%rsp), %rsi
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x120e0
jmp 0x12b18
movq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1e140
movq %rax, 0x8(%rsp)
jmp 0x12b33
leaq 0x50(%rsp), %rdi
callq 0x5850
leaq 0x38(%rsp), %rdi
callq 0x5560
leaq 0x68(%rsp), %rdi
callq 0x31f0
movq 0x8(%rsp), %rax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x12ba0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x12b96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5850
leaq 0x38(%rsp), %rdi
callq 0x5560
leaq 0x68(%rsp), %rdi
callq 0x31f0
movq 0x30(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: kram[P]kram/./src/vm/libraries/user/class.h
// Function: Class::set_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Value*)
void set_value(std::string name, Value* val) {
			
			if (this->values.find(name) != this->values.end()) {
				std::cout << "The value, " << name << ", already exists in this Class. Did you mean to use = ?\n";
				exit(0);
			}

			this->values.insert( {{ name, val }} );
		}

// Assembly:
subq $0xd8, %rsp
movq %rsi, 0x50(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xd0(%rsp), %rdi
movq %rdi, 0x58(%rsp)
addq $0x18, %rdi
callq 0x153e0
movq 0x58(%rsp), %rdi
movq %rax, 0xb8(%rsp)
addq $0x18, %rdi
callq 0x15410
movq %rax, 0xb0(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x153c0
testb $0x1, %al
jne 0x13593
jmp 0x135c9
movq 0x26a3e(%rip), %rdi     # 0x39fd8
leaq 0x18165(%rip), %rsi     # 0x2b706
callq 0x32d0
movq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
leaq 0x18155(%rip), %rsi     # 0x2b712
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x48(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x70(%rsp)
leaq 0xc0(%rsp), %rdx
callq 0x15480
jmp 0x135f5
movq 0x48(%rsp), %rdi
leaq 0x78(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq $0x1, 0xa8(%rsp)
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x15440
jmp 0x1362a
leaq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
addq $0x28, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x30(%rsp)
callq 0x154c0
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x40(%rsp)
jne 0x1363d
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
movq 0x70(%rsp), %rax
leaq 0x78(%rsp), %rcx
cmpq %rax, %rcx
movq %rax, 0x28(%rsp)
je 0x136b5
movq 0x28(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x20(%rsp)
callq 0x154c0
movq 0x20(%rsp), %rax
leaq 0x78(%rsp), %rcx
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0x1368e
jmp 0x13701
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x28, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x8(%rsp)
callq 0x154c0
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x136d8
jmp 0x13701
movq 0x68(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: kram[P]kram/./src/vm/libraries/user/class.h
// Function: Class::update_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Value*)
void update_value(std::string name, Value* val) {

			// Not found
			if (this->values.find(name) == this->values.end()) {
				std::cout << "No such value, " << name << ", did you mean to use the := operation?\n";
				exit(0);
			}

			// The values needs to be of the same type
			if (this->values[name]->type != val->type) {
				std::cout << "Can not update (with =) a variable of type " << this->values[name]->print(true) << " to " << val->print(true) << "\n";
				exit(0);
			}

			this->values[name] = val;
		}

// Assembly:
subq $0xb8, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
addq $0x18, %rdi
callq 0x153e0
movq 0x38(%rsp), %rdi
movq %rax, 0x98(%rsp)
addq $0x18, %rdi
callq 0x15410
movq %rax, 0x90(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x16810
testb $0x1, %al
jne 0x137a3
jmp 0x137d9
movq 0x2682e(%rip), %rdi     # 0x39fd8
leaq 0x17f9a(%rip), %rsi     # 0x2b74b
callq 0x32d0
movq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
leaq 0x17f8e(%rip), %rsi     # 0x2b75b
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdi
addq $0x18, %rdi
callq 0x16830
movq (%rax), %rax
movl 0x8(%rax), %eax
movq 0xa0(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x13904
movq 0x267ce(%rip), %rdi     # 0x39fd8
leaq 0x17aff(%rip), %rsi     # 0x2b310
callq 0x32d0
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, 0x18(%rsp)
addq $0x18, %rdi
callq 0x16830
movq (%rax), %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x1, %edx
callq 0x1e430
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x32a0
movq %rax, 0x28(%rsp)
jmp 0x1385b
movq 0x28(%rsp), %rdi
leaq 0x17ad5(%rip), %rsi     # 0x2b33c
callq 0x32d0
movq %rax, 0x10(%rsp)
jmp 0x13873
movq 0xa0(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl $0x1, %edx
callq 0x1e430
jmp 0x1388c
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x32a0
movq %rax, 0x8(%rsp)
jmp 0x138a2
movq 0x8(%rsp), %rdi
leaq 0x17fb3(%rip), %rsi     # 0x2b861
callq 0x32d0
jmp 0x138b5
leaq 0x40(%rsp), %rdi
callq 0x31f0
leaq 0x70(%rsp), %rdi
callq 0x31f0
xorl %edi, %edi
callq 0x3330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x138f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x31f0
leaq 0x70(%rsp), %rdi
callq 0x31f0
jmp 0x13932
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdi
movq 0xa0(%rsp), %rax
movq %rax, (%rsp)
addq $0x18, %rdi
callq 0x16830
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0xb8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: kram[P]kram/./src/vm/libraries/user/class.h
// Function: Class::get_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Value* get_value(std::string name) {

			if (this->values.find(name) == this->values.end()) {
				std::cout << "Class has no such value, " << name << "\n";
				exit(0);
			}

			return this->values[name];
		}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x18, %rdi
callq 0x153e0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x18, %rdi
callq 0x15410
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x16810
testb $0x1, %al
jne 0x13993
jmp 0x139c9
movq 0x2663e(%rip), %rdi     # 0x39fd8
leaq 0x17de3(%rip), %rsi     # 0x2b784
callq 0x32d0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
leaq 0x17ea4(%rip), %rsi     # 0x2b861
callq 0x32d0
xorl %edi, %edi
callq 0x3330
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x16830
movq (%rax), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: kram[P]kram/./src/vm/libraries/user/function.h
// Function: Function::set_parameters(std::vector<Instruction*, std::allocator<Instruction*>>)
void set_parameters(std::vector<Instruction*> ins) {
			this->parameters = ins;

			this->required_parameter_count = 0;

			// Pre-calculated values and validation
			for (Instruction* i : ins) {

				if (i->instruction != Ins::FUNCTION_PARAMETER) {
					std::cout << "A function can only take parameters of type FUNCTION_PARAMETER\n";
					exit(1);
				}

				if (i->right.size() == 0) {
					this->required_parameter_count++;
					continue;
				}

				if (i->right.size() > 1) {
					std::cout << "Function: The size of a default parameter can only be one!\n";
					exit(1);
				}
			}
		}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x28, %rdi
callq 0x17000
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq $0x0, 0x40(%rax)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4240
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4270
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x42a0
testb $0x1, %al
jne 0x13d33
jmp 0x13dd5
leaq 0x28(%rsp), %rdi
callq 0x42e0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0xb, (%rax)
je 0x13d6c
movq 0x26282(%rip), %rdi     # 0x39fd8
leaq 0x17a8a(%rip), %rsi     # 0x2b7e7
callq 0x32d0
movl $0x1, %edi
callq 0x3330
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
callq 0x56b0
cmpq $0x0, %rax
jne 0x13d93
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x13dc6
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
callq 0x56b0
cmpq $0x1, %rax
jbe 0x13dc4
movq 0x2622a(%rip), %rdi     # 0x39fd8
leaq 0x17a72(%rip), %rsi     # 0x2b827
callq 0x32d0
movl $0x1, %edi
callq 0x3330
jmp 0x13dc6
leaq 0x28(%rsp), %rdi
callq 0x5410
jmp 0x13d1b
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: kram[P]kram/./src/vm/libraries/user/class.h
// Function: Class::new_instance()
Value* new_instance() {

			Class* cl = new Class();
			cl->type = Type::CLASS;
			cl->vm = this->vm;

			for (auto i : this->values) {
				cl->values.insert( {{ i.first, i.second->clone() }} );
			}

			return cl;
		}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x110(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x60(%rsp)
movl $0x50, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x68(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x13e10
jmp 0x1445e
movq 0x60(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, 0x108(%rsp)
movq 0x108(%rsp), %rcx
movl $0x6, 0x8(%rcx)
movq 0x10(%rax), %rdx
movq 0x108(%rsp), %rcx
movq %rdx, 0x10(%rcx)
addq $0x18, %rax
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rdi
callq 0x17ed0
movq %rax, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
callq 0x15410
movq %rax, 0xe0(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x153c0
testb $0x1, %al
jne 0x144e3
jmp 0x146ca
leaq 0xe8(%rsp), %rdi
callq 0x17f00
movq %rax, %rsi
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x16100
movq 0x108(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x50(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xd8(%rsp), %rdi
callq 0x1ea20
movq %rax, 0x58(%rsp)
jmp 0x14537
movq 0x48(%rsp), %rsi
movq 0x58(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x17f20
jmp 0x1455a
movq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq $0x1, 0xb0(%rsp)
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
callq 0x15440
jmp 0x14592
leaq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
addq $0x28, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x30(%rsp)
callq 0x154c0
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x40(%rsp)
jne 0x145a8
leaq 0xb8(%rsp), %rdi
callq 0x154c0
leaq 0xe8(%rsp), %rdi
callq 0x17f60
jmp 0x144c5
movq 0x68(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
callq 0x32b0
jmp 0x146da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
movq 0x78(%rsp), %rax
leaq 0x80(%rsp), %rcx
cmpq %rax, %rcx
movq %rax, 0x28(%rsp)
je 0x14666
movq 0x28(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x20(%rsp)
callq 0x154c0
movq 0x20(%rsp), %rax
leaq 0x80(%rsp), %rcx
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0x1463c
jmp 0x146bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x28, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x8(%rsp)
callq 0x154c0
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x14692
jmp 0x146bb
leaq 0xb8(%rsp), %rdi
callq 0x154c0
jmp 0x146da
movq 0x108(%rsp), %rax
addq $0x118, %rsp            # imm = 0x118
retq
movq 0x100(%rsp), %rdi
callq 0x3490
nopw (%rax,%rax)