LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/prophyle[P]prophasm/src/prophasm.cpp
// Function: contig_t::new_contig(char const*)
int32_t new_contig(const char *base_kmer){
		assert(static_cast<int32_t>(strlen(base_kmer))==k);

		l_ext = r_ext = &seq_buffer[max_contig_length];
		*r_ext='\0';

		for(int32_t i=0;i<k;i++){
			r_extend(base_kmer[i]);
		}
		return 0;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20f0
cmpl %eax, (%r14)
jne 0x52ac
movq 0x8(%r14), %rax
leaq 0x989680(%rax), %rcx
movq %rcx, 0x18(%r14)
movq %rcx, 0x10(%r14)
movb $0x0, 0x989680(%rax)
movl (%r14), %esi
testl %esi, %esi
jle 0x52a2
xorl %eax, %eax
leaq 0xddd(%rip), %rcx       # 0x6040
leaq 0x1260(%rip), %rdx      # 0x64ca
movsbq (%rbx,%rax), %rdi
movzbl (%rdi,%rcx), %edi
cmpq $0x4, %rdi
je 0x5297
movb (%rdi,%rdx), %sil
movq 0x18(%r14), %rdi
movb %sil, (%rdi)
movq 0x18(%r14), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x18(%r14)
movb $0x0, 0x1(%rsi)
movl (%r14), %esi
incq %rax
movslq %esi, %rdi
cmpq %rdi, %rax
jl 0x526a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1529(%rip), %rdi      # 0x67dc
leaq 0x1386(%rip), %rsi      # 0x6640
leaq 0x1546(%rip), %rcx      # 0x6807
movl $0xf9, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O3/prophyle[P]prophasm/src/prophasm.cpp
// Function: contig_t::print_to_fasta(_IO_FILE*, char const*, char const*) const
int32_t print_to_fasta(FILE* fasta_file, const char* contig_name, const char *comment=nullptr) const {
		if (comment==nullptr){
			fprintf(fasta_file,">%s\n",contig_name);
		} else {
			fprintf(fasta_file,">%s %s\n",contig_name,comment);
		}

		char print_buffer[fasta_line_length+1]={0};

		for (char *p=l_ext;p<r_ext;p+=fasta_line_length){
			strncpy(print_buffer,p,fasta_line_length);
			fprintf(fasta_file, "%s\n", print_buffer);
		}

		return 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rcx, %rcx
je 0x52f7
leaq 0x154c(%rip), %rsi      # 0x6837
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22e0
jmp 0x5308
leaq 0x1534(%rip), %rsi      # 0x6832
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22e0
xorl %eax, %eax
movq %rax, 0x35(%rsp)
movq %rax, 0x30(%rsp)
movq 0x10(%r14), %r15
cmpq 0x18(%r14), %r15
jae 0x5352
movq %rsp, %r12
leaq 0x1513(%rip), %r13      # 0x683b
movl $0x3c, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2110
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x22e0
addq $0x3c, %r15
cmpq 0x18(%r14), %r15
jb 0x5328
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::Lexer()
Lexer::Lexer() {
	// Initialize all  keywords
	keywords["class"] = true;
	keywords["fn"] = true;
	keywords["if"] = true;
	keywords["else"] = true;
	keywords["new"] = true;
	keywords["while"] = true;
	keywords["return"] = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
leaq 0x48(%rdi), %r15
movq %r15, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movb $0x0, 0x48(%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xd9cc(%rip), %rsi      # 0x122c0
leaq 0xd9ca(%rip), %rdx      # 0x122c5
leaq 0x8(%rsp), %rdi
callq 0x47d2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5686
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4924
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xd993(%rip), %rsi      # 0x122c6
leaq 0xd98e(%rip), %rdx      # 0x122c8
callq 0x47d2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5686
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x495e
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xd95c(%rip), %rsi      # 0x122c9
leaq 0xd957(%rip), %rdx      # 0x122cb
callq 0x47d2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5686
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4998
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xd925(%rip), %rsi      # 0x122cc
leaq 0xd922(%rip), %rdx      # 0x122d0
callq 0x47d2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5686
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x49d2
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xd8f0(%rip), %rsi      # 0x122d1
leaq 0xd8ec(%rip), %rdx      # 0x122d4
callq 0x47d2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5686
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4a0c
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xd8ba(%rip), %rsi      # 0x122d5
leaq 0xd8b8(%rip), %rdx      # 0x122da
callq 0x47d2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5686
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4a46
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xd886(%rip), %rsi      # 0x122db
leaq 0xd885(%rip), %rdx      # 0x122e1
callq 0x47d2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5686
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4a80
callq 0x3230
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4aa4
jmp 0x4ab8
jmp 0x4aa4
jmp 0x4ab8
jmp 0x4aa4
jmp 0x4ab8
jmp 0x4aa4
jmp 0x4ab8
jmp 0x4aa4
jmp 0x4ab8
jmp 0x4aa4
jmp 0x4ab8
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4abb
callq 0x3230
jmp 0x4abb
movq %rax, %r14
movq 0x38(%rbx), %rdi
cmpq %r15, %rdi
je 0x4ac9
callq 0x3230
movq %rbx, %rdi
callq 0x46a6
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::parse_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<Token*> Lexer::parse_file(std::string filename) {
	std::vector<Token*> result;

	std::ifstream file(filename);

	if (file.fail()) {
		std::cout << "Could not open " << filename << "\n";
		exit(0);
	}

    while (std::getline(file, this->row))
    {
    	this->index = 0;

    	while (true) {
        	Token* tok = this->next();

        	this->index++;

        	if (tok->type == Type::IGNORE) {
        		continue;
        	}

        	result.push_back(tok);

        	if (tok->type == Type::T_EOF || tok->type == Type::T_EOL) {
        		break;
        	}
        }
    }

    // Indicate end of file
    result.push_back(new Token(Type::T_EOF));

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x3360
movq (%r12), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x4c0b
leaq 0x38(%r14), %r15
leaq 0x8(%rsp), %r12
movq %rsp, %r13
leaq (%rsp,%rax), %rdi
addq $0x8, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x33e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4bb3
movq $0x0, 0x58(%r14)
movq %r14, %rdi
callq 0x4c82
movq %rax, (%rsp)
incq 0x58(%r14)
cmpl $0x2, (%rax)
je 0x4b6b
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4b94
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x4b9f
movq %rbx, %rdi
movq %r13, %rdx
callq 0x5a98
movq (%rsp), %rax
cmpl $0x2, (%rax)
jae 0x4b6b
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
jmp 0x4b35
movl $0x28, %edi
callq 0x3260
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x5ce6
movq %r15, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4be2
movq %r15, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x4bed
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x5bb2
leaq 0x8(%rsp), %rdi
callq 0x3080
movq %rbx, %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x163be(%rip), %rdi     # 0x1afd0
leaq 0xd6c9(%rip), %rsi      # 0x122e2
movl $0xf, %edx
callq 0x32a0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x1639f(%rip), %rdi     # 0x1afd0
callq 0x32a0
leaq 0xdcb6(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
jmp 0x4c5f
movq %rax, %r14
movq %r15, %rdi
callq 0x3230
jmp 0x4c62
jmp 0x4c5f
jmp 0x4c5f
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3080
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4c79
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::comment()
Token* Lexer::comment() {
	while(true) {
		this->index += 1;
		char current = this->char_at_pos(this->index + 1);

		if (current == '\n' || current == '\r' || current == '\0') {
			break;
		}
	}

	return new Token(Type::T_EOL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
movq 0x58(%rdi), %rdx
addq $0x2, %rdx
movl $0x2401, %esi           # imm = 0x2401
leaq -0x1(%rdx), %r8
movq %r8, 0x58(%rdi)
cmpq %rdx, %rcx
jbe 0x4f26
movzbl (%rax,%rdx), %r8d
incq %rdx
cmpl $0xd, %r8d
ja 0x4f05
btl %r8d, %esi
jae 0x4f05
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
movq %rax, %rdi
movl $0x1, %esi
callq 0x5ce6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::name()
Token* Lexer::name() {
	std::string s(1, this->current);

	while (true) {
		char c = this->char_at_pos(this->index + 1);

		// After the beginning, a name can be a-Z0-9_
		if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_') {
			s += c;
			this->index += 1;
		} else {
			break;
		}
	}

	if (s == "true" || s == "false") {
		return new Token(Type::BOOL, s);
	}

	if (this->keywords.find(s) != this->keywords.end()) {
		return new Token(Type::KEYWORD, s);
	}

	return new Token(Type::NAME, s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movsbl 0x60(%rdi), %edx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdi
callq 0x32b0
movq 0x58(%rbx), %rax
incq %rax
cmpq %rax, 0x40(%rbx)
jbe 0x4fb1
movq 0x38(%rbx), %rcx
movb (%rcx,%rax), %al
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jae 0x4fb3
jmp 0x4fc5
xorl %eax, %eax
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
setae %cl
cmpb $0x5f, %al
setne %dl
testb %cl, %dl
jne 0x4fdd
movsbl %al, %esi
movq %r14, %rdi
callq 0x3200
movq 0x58(%rbx), %rax
incq %rax
movq %rax, 0x58(%rbx)
jmp 0x4f92
leaq 0xd31b(%rip), %rsi      # 0x122ff
leaq 0x8(%rsp), %rdi
callq 0x30a0
testl %eax, %eax
je 0x5064
leaq 0xd30b(%rip), %rsi      # 0x12304
leaq 0x8(%rsp), %rdi
callq 0x30a0
testl %eax, %eax
je 0x5064
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5c88
testq %rax, %rax
je 0x50d4
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x473c
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
movl $0x9, %esi
callq 0x5d04
movq 0x48(%rsp), %rdi
jmp 0x50a9
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
callq 0x473c
leaq 0x68(%rsp), %rdx
movq %rbx, %rdi
movl $0x6, %esi
callq 0x5d04
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x50b3
callq 0x3230
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x50c2
callq 0x3230
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x473c
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x5d04
movq 0x28(%rsp), %rdi
jmp 0x50a9
movq %rax, %r14
movq 0x28(%rsp), %rdi
jmp 0x513d
jmp 0x5149
movq %rax, %r14
movq 0x48(%rsp), %rdi
jmp 0x513d
jmp 0x5149
jmp 0x5158
movq %rax, %r14
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x514c
callq 0x3230
jmp 0x514c
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
jmp 0x515b
jmp 0x5158
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x516a
callq 0x3230
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::number()
Token* Lexer::number() {
	std::string s(1, this->current);

	// Look for more digits.
	while(true) {
		char c = this->char_at_pos(this->index + 1);

		if ((c < '0' || c > '9') && c != '.') {
			break;
		}

		// A dot needs to be followed by another digit to be valid
		if (c == '.') {
			char cc = this->char_at_pos(this->index + 2);

			if (cc < '0' || cc > '9') {
				break;
			}
		}

		this->index += 1;
		s += c;
	}

	// TODO Decimal
	// TODO Verify that it ends with a space?

	return new Token(Type::NUMBER, s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movsbl 0x60(%rdi), %edx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdi
callq 0x32b0
movq 0x40(%rbx), %rsi
movq 0x58(%rbx), %rdx
leaq 0x1(%rdx), %rax
cmpq %rax, %rsi
jbe 0x51f9
movq 0x38(%rbx), %rdi
movb (%rdi,%rax), %cl
leal -0x3a(%rcx), %r8d
cmpb $-0xa, %r8b
setb %r8b
cmpb $0x2e, %cl
setne %r9b
testb %r8b, %r9b
jne 0x51f9
cmpb $0x2e, %cl
jne 0x51e8
addq $0x2, %rdx
cmpq %rdx, %rsi
jbe 0x51f9
movb (%rdi,%rdx), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x51f9
movq %rax, 0x58(%rbx)
movsbl %cl, %esi
movq %r14, %rdi
callq 0x3200
jmp 0x519f
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x473c
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5d04
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x5248
callq 0x3230
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5257
callq 0x3230
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x527d
callq 0x3230
jmp 0x527d
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
jmp 0x528c
jmp 0x5289
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x529b
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::string()
Token* Lexer::string() {
	std::string s = "";

	this->index += 1;

	while(true) {

		// End of string
		if (this->char_at_pos(this->index) == '"') {
			break;
		}

		// Escaping
		if (this->char_at_pos(this->index) == '\\') {

			// In case of eg. \n or \t

			switch (this->char_at_pos(this->index + 1)) {
				case 't': s += '\t'; break;
				case 'n': s += '\n'; break;
				case 'r': s += '\r'; break;
				default: 
					s += this->char_at_pos(this->index + 1);
					break;
			}

			this->index += 2;
			continue;
		}

		s += this->char_at_pos(this->index);
		this->index += 1;
	}

	return new Token(Type::STRING, s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd632(%rip), %rdx      # 0x128f4
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x47d2
movq 0x58(%rbx), %r12
incq %r12
movq %r12, 0x58(%rbx)
movq 0x40(%rbx), %rcx
cmpq %r12, %rcx
jbe 0x52fb
movq 0x38(%rbx), %rdx
movzbl (%rdx,%r12), %eax
cmpl $0x5c, %eax
je 0x5310
cmpl $0x22, %eax
jne 0x52fd
jmp 0x5353
xorl %eax, %eax
movl $0x1, %r12d
movsbl %al, %esi
movq %r14, %rdi
callq 0x3200
jmp 0x5345
incq %r12
cmpq %r12, %rcx
jbe 0x5332
movzbl (%rdx,%r12), %ecx
cmpl $0x6e, %ecx
je 0x534f
cmpl $0x72, %ecx
je 0x534b
movb $0x9, %al
cmpl $0x74, %ecx
je 0x5334
movl %ecx, %eax
jmp 0x5334
xorl %eax, %eax
movl $0x2, %r12d
movsbl %al, %esi
movq %r14, %rdi
callq 0x3200
addq 0x58(%rbx), %r12
jmp 0x52d9
movb $0xd, %al
jmp 0x5334
movb $0xa, %al
jmp 0x5334
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x473c
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5d04
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x53a2
callq 0x3230
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x53b1
callq 0x3230
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x53d7
callq 0x3230
jmp 0x53d7
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
jmp 0x53e6
jmp 0x53e3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x53f5
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/lexer/lexer.cpp
// Function: lexer::Lexer::oper()
Token* Lexer::oper() {
	std::string s(1, this->current);

	while(true) {

		char next = this->char_at_pos(this->index + 1);

		// EOF
		if (next == '\0') {
			break;
		}

		std::string combined = s + next;

		if (Token::Trans(combined) != Type::IGNORE) {
			s += next;
			this->index += 1;
		} else {
			break;
		}
	}

	return new Token(Type::OPERATOR, s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movsbl 0x60(%rdi), %edx
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x32b0
leaq 0x78(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x68(%rsp), %r12
movq 0x58(%rbx), %rax
incq %rax
cmpq %rax, 0x40(%rbx)
jbe 0x5501
movq 0x38(%rbx), %rcx
movb (%rcx,%rax), %bpl
testb %bpl, %bpl
je 0x5501
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x473c
movq 0x10(%rsp), %rsi
movsbl %bpl, %ebp
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl %ebp, %r8d
callq 0x33f0
movq %r14, 0x68(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x473c
movq %r12, %rdi
callq 0x5daa
movl %eax, %r13d
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x54cd
callq 0x3230
cmpl $0x2, %r13d
je 0x54e3
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x3200
incq 0x58(%rbx)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x54f7
callq 0x3230
cmpl $0x2, %r13d
jne 0x543d
movl $0x28, %edi
callq 0x3260
movq %rax, %r14
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x473c
leaq 0x48(%rsp), %rdx
movq %r14, %rdi
movl $0x11, %esi
callq 0x5d04
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x554f
callq 0x3230
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5563
callq 0x3230
movq %r14, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x558f
callq 0x3230
jmp 0x558f
movq %rax, %rbx
movq %r14, %rdi
jmp 0x55c3
jmp 0x55ac
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x55b4
callq 0x3230
jmp 0x55b4
jmp 0x55b1
movq %rax, %rbx
jmp 0x55c8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x55c8
callq 0x3230
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x55dc
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/lexer/token.cpp
// Function: lexer::Token::KEYWORD(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Token Token::KEYWORD(std::string val) {
	Token tok;
	tok.type = Type::KEYWORD;
	tok.value = val;
	tok.sub = Token::Trans(val);

	return tok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movabsq $0x200000009, %rax      # imm = 0x200000009
movq %rax, (%rdi)
movq %rbx, %rdi
callq 0x3150
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x473c
movq %rsp, %rdi
callq 0x5daa
movl %eax, 0x4(%r14)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6d0f
callq 0x3230
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6d36
callq 0x3230
jmp 0x6d36
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6d43
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
leaq 0x14045(%rip), %rax     # 0x1b260
movq (%rax), %rax
testq %rax, %rax
je 0x7244
cmpl %esi, 0x28(%rax)
jne 0x721b
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x473c
jmp 0x7261
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xae93(%rip), %rsi      # 0x120e5
leaq 0xae93(%rip), %rdx      # 0x120ec
movq %rbx, %rdi
callq 0x47d2
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rdi
callq 0xcc52
testb %al, %al
je 0x79a6
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0xcb1a
movq %rax, %r12
movl 0x8(%rax), %eax
cmpl 0x8(%rbx), %eax
jne 0x79da
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xca92
movq 0x13623(%rip), %rdi     # 0x1afd0
leaq 0xa9e1(%rip), %rsi      # 0x12395
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0xa9dd(%rip), %rsi      # 0x123a8
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq 0x135ef(%rip), %r14     # 0x1afd0
leaq 0xa9dc(%rip), %rsi      # 0x123c4
movl $0x2b, %edx
movq %r14, %rdi
callq 0x32a0
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0xd094
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x32a0
movq %rax, %r14
leaq 0xa9cd(%rip), %rsi      # 0x123f0
movl $0x4, %edx
movq %rax, %rdi
callq 0x32a0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd094
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0xae98(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
leaq 0x8(%rsp), %rdi
callq 0x3120
leaq 0x28(%rsp), %rdi
callq 0x3120
jmp 0x79d3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7a99
callq 0x3230
jmp 0x7a99
jmp 0x7a96
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7aac
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x4(%rsp)
movl $0x0, (%rsp)
cmpl $0x7f, %esi
jg 0x7b11
movb %sil, (%rsp)
jmp 0x7ba5
movl %esi, %eax
cmpl $0x7ff, %esi            # imm = 0x7FF
ja 0x7b32
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rsp)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x1(%rsp)
jmp 0x7ba5
andl $0x7ffff800, %eax       # imm = 0x7FFFF800
cmpl $0xd800, %eax           # imm = 0xD800
je 0x7ba5
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x7b6c
movl %esi, %eax
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%rsp)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsp)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x2(%rsp)
jmp 0x7ba5
cmpl $0x10ffff, %esi         # imm = 0x10FFFF
ja 0x7ba5
movl %esi, %eax
shrl $0x12, %eax
orb $-0x10, %al
movb %al, (%rsp)
movl %esi, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsp)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rsp)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x3(%rsp)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x3110
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x47d2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, %edx
jne 0x7c4c
movq 0x8(%rbx), %rax
movq -0x8(%rax), %r15
cmpl $0x6, 0x8(%r15)
jne 0x7c83
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x473c
movq 0x50(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x891c
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x9a64
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7c6f
callq 0x3230
jmp 0x7c6f
movq 0x50(%r14), %rax
addq $0x8, %r14
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x891c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x78d0
movq %rbx, %rdi
callq 0xc99a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x13346(%rip), %rdi     # 0x1afd0
leaq 0xa867(%rip), %rsi      # 0x124f8
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7caf
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, %edx
jne 0x7d3a
movq 0x8(%rbx), %rax
movq -0x8(%rax), %r15
cmpl $0x6, 0x8(%r15)
jne 0x7d71
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x473c
movq 0x50(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x891c
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x9b2a
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7d5d
callq 0x3230
jmp 0x7d5d
movq 0x50(%r14), %rax
addq $0x8, %r14
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x891c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7954
movq %rbx, %rdi
callq 0xc99a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x13258(%rip), %rdi     # 0x1afd0
leaq 0xa7ca(%rip), %rsi      # 0x12549
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7d9d
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/vm.cpp
// Function: VM::name(Instruction*, vm::ON)
Value* VM::name(Instruction* ins, vm::ON on) {

	// Check if the value exists on the pushed class
	if (on == vm::ON::PUSHED_CLASS) {
		Value* top = this->lib_stack.back();

		// Get value from Class directly
		if (top->type == Type::CLASS) {
			Class* cl = static_cast<Class*>(top);
			return cl->get_value(ins->name);
		}

		// Create a Value of type NAME that can be used later
		if (top->type == Type::REFERENCE) {

			if (top->has_method(ins->name)) {
				return new Value(Type::NAME, ins->name);
			}

			std::cout << "REFERENCE: Undefined name: " << ins->name << "\n";
			exit(0);
		}

		// The type is something else, usually a builtin (eg. NUMBER)
		return new Value(Type::NAME, ins->name);
	}

	// Check if the value exists on the stack
	return this->name_get(ins->name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
cmpl $0x1, %edx
jne 0x7e14
movq 0x8(%rdi), %rax
movq -0x8(%rax), %rbx
movl 0x8(%rbx), %eax
cmpl $0x4, %eax
je 0x7e2e
cmpl $0x6, %eax
jne 0x7eb8
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x473c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9c98
movq %rax, %rbx
movq 0x68(%rsp), %rdi
jmp 0x7efa
addq $0x8, %r14
movq %r14, %rsi
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7ab4
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x473c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd32c
movl %eax, %ebx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x7e6c
callq 0x3230
testb %bl, %bl
je 0x7f16
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x473c
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x7, %esi
callq 0xcd8a
movq 0x28(%rsp), %rdi
jmp 0x7efa
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x473c
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x7, %esi
callq 0xcd8a
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7f04
callq 0x3230
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x8, %r14
movq 0x130af(%rip), %rdi     # 0x1afd0
leaq 0xa66e(%rip), %rsi      # 0x12596
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0xa9b4(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %r14
movq 0x28(%rsp), %rdi
jmp 0x7f62
jmp 0x7f6e
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7f71
callq 0x3230
jmp 0x7f71
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x33c0
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
jne 0x7f74
jmp 0x7f79
movq %rax, %r14
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
jne 0x7f74
jmp 0x7f79
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/vm.cpp
// Function: VM::math(Instruction*)
Value* VM::math(Instruction* ins) {
	Value* left = this->run(ins->left[0]);
	Value* right = this->run(ins->right[0]);

	if (left->type != right->type) {
		std::cout << "math() expects equal types, got " << left->print(true) << " and " << right->print(true) << "\n";
		exit(0);
	}
	
	switch (left->type) {
		case Type::NUMBER:
			return this->math_number(ins, left, right);
			break;
		case Type::STRING:
			return this->math_string(ins, left, right);
			break;

		// Silence the compiler
		default: break;
	}

	std::cout << "math() Does not know how to handle " << left->print() << "\n";
	exit(0);

	return this->get_value_null();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r12
movq 0x38(%rsi), %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x891c
movq %rax, %r14
movq 0x50(%r15), %rax
movq (%rax), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x891c
movq %rax, %rbx
movl 0x8(%r14), %eax
cmpl 0x8(%rbx), %eax
jne 0x8025
cmpl $0x1, %eax
je 0x8009
cmpl $0x2, %eax
jne 0x80bc
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8152
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8282
movq 0x12fa4(%rip), %r15     # 0x1afd0
leaq 0xa57f(%rip), %rsi      # 0x125b2
movl $0x20, %edx
movq %r15, %rdi
callq 0x32a0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xd094
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x32a0
movq %rax, %r14
leaq 0xa563(%rip), %rsi      # 0x125d3
movl $0x5, %edx
movq %rax, %rdi
callq 0x32a0
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd094
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0xa84b(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
leaq 0x28(%rsp), %rdi
callq 0x3120
jmp 0x8107
movq 0x12f0d(%rip), %rbx     # 0x1afd0
leaq 0xa50f(%rip), %rsi      # 0x125d9
movl $0x23, %edx
movq %rbx, %rdi
callq 0x32a0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd094
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x32a0
leaq 0xa7f4(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
leaq 0x8(%rsp), %rdi
callq 0x3120
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8137
callq 0x3230
jmp 0x8137
jmp 0x8134
jmp 0x8134
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x814a
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/vm.cpp
// Function: VM::math_number(Instruction*, Value*, Value*)
Value* VM::math_number(Instruction* ins, Value* left, Value* right) {

	double res_number = 0;
	bool res_bool = false;
	bool is_bool = false;
	double l = left->getNumber();
	double r = right->getNumber();

	switch (ins->type) {
		case lexer::Type::OPERATOR_PLUS:
			res_number = l + r;
			break;

		case lexer::Type::OPERATOR_MINUS:
			res_number = l - r;
			break;

		case lexer::Type::OPERATOR_DIV:
			res_number = l / r;
			break;

		case lexer::Type::OPERATOR_MUL:
			res_number = l * r;
			break;

		case lexer::Type::OPERATOR_LT:
			res_bool = l < r;
			is_bool = true;
			break;

		case lexer::Type::OPERATOR_GTEQ:
			res_bool = l >= r;
			is_bool = true;
			break;

		case lexer::Type::OPERATOR_GT:
			res_bool = l > r;
			is_bool = true;
			break;

		case lexer::Type::OPERATOR_LTEQ:
			res_bool = l <= r;
			is_bool = true;
			break;

		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;

		case lexer::Type::OPERATOR_2DOT:
		case lexer::Type::OPERATOR_3DOT:
			return this->list_range(l, r, ins->type == lexer::Type::OPERATOR_3DOT);

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

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

	return this->get_value_number(res_number);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xd36c
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0xd36c
movl 0x30(%r15), %eax
leal -0x17(%rax), %ecx
cmpl $0x16, %ecx
ja 0x8267
leaq 0xa267(%rip), %rdx      # 0x123f8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cvttsd2si 0x8(%rsp), %esi
cvttsd2si %xmm0, %edx
xorl %ecx, %ecx
cmpl $0x2d, %eax
sete %cl
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x83a4
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
jmp 0x8229
mulsd 0x8(%rsp), %xmm0
jmp 0x8256
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setb %al
jmp 0x823c
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
sete %al
jmp 0x823c
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setne %al
jmp 0x823c
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setbe %al
jmp 0x823c
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
jmp 0x823c
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x8256
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setae %al
movzbl %al, %esi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xca1e
addsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xc9a0
movq 0x12d62(%rip), %rdi     # 0x1afd0
leaq 0xa388(%rip), %rsi      # 0x125fd
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0xd34a
movq %rsp, %rdi
movq %r15, %rsi
callq 0xd34a
movl 0x30(%r14), %eax
cmpl $0x17, %eax
je 0x82e4
cmpl $0x18, %eax
jne 0x8353
movq 0x28(%rsp), %rdx
cmpq 0x8(%rsp), %rdx
jne 0x830c
testq %rdx, %rdx
je 0x8310
movq (%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x3270
testl %eax, %eax
sete %al
jmp 0x8312
movq 0x28(%rsp), %rdx
movb $0x1, %al
cmpq 0x8(%rsp), %rdx
jne 0x8312
testq %rdx, %rdx
je 0x830c
movq (%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x3270
testl %eax, %eax
setne %al
jmp 0x8312
xorl %eax, %eax
jmp 0x8312
movb $0x1, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0xca1e
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8333
callq 0x3230
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8346
callq 0x3230
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x12c76(%rip), %rdi     # 0x1afd0
leaq 0xa2bc(%rip), %rsi      # 0x1261d
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
jmp 0x8388
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8388
callq 0x3230
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x839b
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
movl $0x28, %edi
callq 0x3260
movq %rax, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rax)
movapd %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, %rdi
callq 0xccd0
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
movl $0x4, %esi
callq 0xce42
movq %rbx, %rdi
callq 0x9dd4
xorb $0x1, %r12b
movzbl %r12b, %eax
movl %r15d, %ecx
subl %eax, %ecx
cmpl %ebp, %ecx
jl 0x84cc
negl %eax
xorpd %xmm0, %xmm0
movq %rsp, %r12
movapd %xmm0, (%r12)
movq $0x0, 0x10(%r12)
leal (%r15,%rax), %r13d
incl %r13d
leaq 0x18(%rsp), %r15
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movq %r14, %rdi
callq 0xc9a0
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x8471
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x847c
movq %r12, %rdi
movq %r15, %rdx
callq 0xc6a8
incl %ebp
cmpl %ebp, %r13d
jne 0x8446
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x9fe4
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x9f94
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x84ac
callq 0x3230
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x84ba
callq 0x3230
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x12afd(%rip), %rdi     # 0x1afd0
leaq 0xa226(%rip), %rsi      # 0x12700
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8507
callq 0x3230
jmp 0x8507
jmp 0x8504
movq %rax, %r14
movq %rbx, %rdi
jmp 0x8510
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8515
callq 0x3230
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7adc
movq 0x68(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x891c
cmpl $0x3, 0x8(%rax)
jne 0x85e8
movq %rax, %rdi
callq 0xd33e
testb %al, %al
je 0x8582
addq $0x38, %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x450e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8626
movq %rax, %r14
movq 0x18(%rsp), %rdi
jmp 0x85b0
movq 0x58(%r14), %rax
cmpq 0x50(%r14), %rax
je 0x85cf
addq $0x50, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x450e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8626
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x85ba
callq 0x3230
movq %rbx, %rdi
callq 0x7ac8
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x7ac8
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xc99a
movq 0x129e1(%rip), %rdi     # 0x1afd0
leaq 0xa047(%rip), %rsi      # 0x1263d
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x8613
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x861d
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/vm.cpp
// Function: VM::run(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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xc99a
movq (%r14), %r12
movq 0x8(%r14), %r15
cmpq %r15, %r12
je 0x86bd
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
addq $0x8, %r12
leaq 0x3f(%r13), %rbp
movq -0x8(%r12), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x891c
cmpl $0x10, (%r14)
je 0x86bd
movl 0x848(%rbx), %ecx
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
shlq $0x3, %rcx
addq 0x840(%rbx), %rcx
movq %rdx, %rsi
andq %rbp, %rsi
xorl %edi, %edi
cmpq %r13, %rsi
setbe %dil
movq -0x8(%rcx,%rdi,8), %rcx
btq %rdx, %rcx
jb 0x86bd
leaq 0x8(%r12), %rcx
cmpq %r15, %r12
movq %rcx, %r12
jne 0x865a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x891c
cmpl $0x3, 0x8(%rax)
jne 0x874f
leaq 0x50(%r14), %r15
movq %rsp, %r12
movq %rax, %rdi
callq 0xd33e
testb %al, %al
je 0x8767
movq %rbx, %rdi
callq 0x7adc
movq %r12, %rdi
movq %r15, %rsi
callq 0x450e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8626
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8730
callq 0x3230
movq %rbx, %rdi
callq 0x7ac8
movq 0x38(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x891c
cmpl $0x3, 0x8(%rax)
je 0x86f8
movq 0x1287a(%rip), %rdi     # 0x1afd0
leaq 0x9f01(%rip), %rsi      # 0x1265e
movl $0x23, %edx
callq 0x32a0
movq %rbx, %rdi
callq 0xc99a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x878c
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x50, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x450e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8626
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x87c9
callq 0x3230
subl $0x1, 0x848(%rbx)
jae 0x87e4
movl $0x3f, 0x848(%rbx)
addq $-0x8, 0x840(%rbx)
addq $0x830, %rbx            # imm = 0x830
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9cfe
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8814
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x891c
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x88c8
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x88d3
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xc1e6
movq 0x50(%r14), %rax
movq 0x58(%r14), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x8901
movq (%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x891c
addq $-0x8, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x126c8(%rip), %rdi     # 0x1afd0
leaq 0x9d73(%rip), %rsi      # 0x12682
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop