LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/value.cpp
// Function: Value::set_type(Type)
void Value::set_type(Type type) {
	this->type = type;

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

		case Type::STRING:
		case Type::NAME:
			data.strval = new std::string();
			break;

		case Type::REFERENCE:
			data.methods = new Methods();
			break;

		case Type::FUNCTION:
		case Type::CLASS:
			break;

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

// Assembly:
pushq %rbx
movl %esi, 0x8(%rdi)
cmpl $0x7, %esi
ja 0xcebc
movq %rdi, %rbx
movl %esi, %eax
leaq 0x5edd(%rip), %rcx      # 0x12d34
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0xceba
movl $0x20, %edi
callq 0x3260
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
jmp 0xceb7
movl $0x38, %edi
callq 0x3260
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
leaq 0x30(%rax), %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movq %rax, (%rbx)
popq %rbx
retq
movq 0xe10d(%rip), %rdi      # 0x1afd0
leaq 0x5f91(%rip), %rsi      # 0x12e5b
callq 0x3250
xorl %edi, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/value.cpp
// Function: Value::exec_method(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Value*, std::allocator<Value*>>)
Value* Value::exec_method(std::string name, std::vector<Value*> val) {

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

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

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

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

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

	return m(this, val);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leal -0x4(%rax), %ecx
cmpl $0x3, %ecx
jae 0xcf93
movq %rdx, %r15
cmpl $0x5, %eax
je 0xcf56
cmpl $0x6, %eax
je 0xd00d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd41e
testq %rax, %rax
je 0xd01d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd41e
testq %rax, %rax
je 0xd051
movq 0x28(%rax), %r12
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x9fe4
movq %rbx, %rdi
movq %r14, %rsi
callq *%r12
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0xcf7a
movq (%rbx), %r12
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x9fe4
movq %rbx, %rdi
movq %r14, %rsi
callq *%r12
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xcf84
callq 0x3230
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xe036(%rip), %r15      # 0x1afd0
leaq 0x5ef1(%rip), %rsi      # 0x12e92
movl $0x18, %edx
movq %r15, %rdi
callq 0x32a0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x32a0
leaq 0x5ee7(%rip), %rsi      # 0x12eab
movl $0x37, %edx
movq %rax, %rdi
callq 0x32a0
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd094
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x32a0
leaq 0x58fa(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
leaq 0x38(%rsp), %rdi
callq 0x3120
jmp 0xd04a
movq 0xdfbc(%rip), %rdi      # 0x1afd0
leaq 0x5ec8(%rip), %rsi      # 0x12ee3
jmp 0xd045
movq 0xdfac(%rip), %rdi      # 0x1afd0
leaq 0x5f23(%rip), %rsi      # 0x12f4e
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0x58b1(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
xorl %edi, %edi
callq 0x32c0
leaq 0x5bb8(%rip), %rdi      # 0x12c10
callq 0x32e0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0xd06f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xd079
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xd074
jmp 0xd079
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/vm/value.cpp
// Function: Value::clone()
Value* Value::clone() {

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

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

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

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

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

	return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x3260
movq %rax, %rbx
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
leal -0x4(%rax), %ecx
cmpl $0x3, %ecx
jb 0xd3a9
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0xd3b6
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
jmp 0xd3e7
movq %rbx, %rdi
callq 0x3230
movq %r14, %rbx
jmp 0xd3e7
cmpl $0x1, %eax
jne 0xd3f0
movl $0x20, %edi
callq 0x3260
movq %rax, %r15
movq (%r14), %rax
leaq 0x10(%r15), %rcx
movq %rcx, (%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x473c
movq %r15, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xdbd9(%rip), %rdi      # 0x1afd0
leaq 0x5b74(%rip), %rsi      # 0x12f72
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
movq %r15, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::symbol(lexer::Token*, ON)
Instruction* Parser::symbol(lexer::Token* tok, ON on) {
	switch (tok->type) {

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl (%rsi), %eax
cmpq $0x11, %rax
ja 0xe1ac
leaq 0x4e9d(%rip), %rcx      # 0x12f90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x80, %edi
callq 0x3260
movl $0x6, (%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movb $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x68(%rax)
movq %rcx, 0x78(%rax)
movl $0x2, 0x30(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf34c
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf3e6
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf2ca
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf188
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf248
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf098
movq 0xce1d(%rip), %r14      # 0x1afd0
leaq 0x4f77(%rip), %rsi      # 0x13131
movl $0x10, %edx
movq %r14, %rdi
callq 0x32a0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6eaa
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0x4708(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
movq %rsp, %rdi
callq 0x3120
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe218
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::push_class(Instruction*)
Instruction* Parser::push_class(Instruction* prev) {
	Instruction* ins = new Instruction(Ins::PUSH_CLASS);
	ins->left = std::vector<Instruction*>{ prev };
	ins->right = std::vector<Instruction*>{ this->symbol_next(ON::DEFAULT) };

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x80, %edi
callq 0x3260
movq %rax, %r14
movl $0x7, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%r14)
xorl %r12d, %r12d
movq %r12, 0x10(%r14)
movb $0x0, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x68(%r14)
movq %r12, 0x78(%r14)
movl $0x2, 0x30(%r14)
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x10(%rsp), %r15
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
movq %r15, %rdi
callq 0x112c8
movq 0x38(%r14), %rdi
movaps (%r15), %xmm0
movups %xmm0, 0x38(%r14)
movq 0x10(%r15), %rax
movq %rax, 0x48(%r14)
movq %r12, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
testq %rdi, %rdi
je 0xe421
callq 0x3230
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xe421
callq 0x3230
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf070
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %r15
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
movq %r15, %rdi
callq 0x112c8
movq 0x50(%r14), %rdi
movaps (%r15), %xmm0
movups %xmm0, 0x50(%r14)
movq 0x10(%r15), %rax
movq %rax, 0x60(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0xe487
callq 0x3230
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xe487
callq 0x3230
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0xe220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::assign(Instruction*)
Instruction* Parser::assign(Instruction* prev) {
	Instruction* ins = new Instruction(Ins::ASSIGN);

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

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

	return ins;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x80, %edi
callq 0x3260
movq %rax, %rbx
movl $0x0, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rax, 0x78(%rbx)
movl $0x2, 0x30(%rbx)
cmpl $0x3, (%r15)
jne 0xe851
movq %rbx, %rdi
addq $0x8, %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0x3150
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xdd8e
movq 0x50(%rbx), %rdi
movaps (%r15), %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x60(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0xe844
callq 0x3230
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xe844
callq 0x3230
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xc778(%rip), %rdi      # 0x1afd0
leaq 0x4988(%rip), %rsi      # 0x131e7
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::function_parameter_with_default_value(Instruction*)
Instruction* Parser::function_parameter_with_default_value(Instruction* ins) {

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

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

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

	return ins;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
cmpl $0xb, (%rsi)
jne 0xe99c
movq %rdi, %r15
leaq 0x68(%rsp), %r12
movq %r12, -0x10(%r12)
movw $0x29, (%r12)
movq $0x1, -0x8(%r12)
leaq 0x78(%rsp), %rbx
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0x6d4c
leaq 0xa0(%rsp), %rbx
leaq 0x48(%rsp), %r13
movq %r13, -0x10(%r13)
movw $0x2c, (%r13)
movq $0x1, -0x8(%r13)
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x6d4c
leaq 0x8(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x7(%rsp), %rcx
movl $0x2, %edx
callq 0x111aa
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
callq 0xdcd2
movq 0x50(%r14), %rdi
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x50(%r14)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%r14)
testq %rdi, %rdi
je 0xe931
callq 0x3230
leaq 0x8(%rsp), %rdi
callq 0x111ec
leaq 0xb8(%rsp), %rbx
xorl %ebp, %ebp
movq 0xa8(%rsp,%rbp), %rdi
leaq (%rbx,%rbp), %rax
cmpq %rdi, %rax
je 0xe95b
callq 0x3230
addq $-0x28, %rbp
cmpq $-0x50, %rbp
jne 0xe945
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0xe974
callq 0x3230
movq 0x58(%rsp), %rdi
cmpq %r12, %rdi
je 0xe983
callq 0x3230
decl 0x18(%r15)
movq %r14, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc62d(%rip), %rdi      # 0x1afd0
leaq 0x47f4(%rip), %rsi      # 0x1319e
callq 0x3250
movq %r14, %rdi
xorl %esi, %esi
callq 0x3ee0
movl $0x1, %edi
callq 0x32c0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x111ec
jmp 0xe9d5
movq %rax, %r14
movq $-0x50, %r15
leaq 0xb8(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rdi, %rbp
je 0xe9f2
callq 0x3230
addq $-0x28, %rbp
addq $0x28, %r15
jne 0xe9e4
movb $0x1, %bpl
jmp 0xea06
movq %rax, %r14
xorl %ebp, %ebp
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0xea1c
callq 0x3230
jmp 0xea1c
movq %rax, %r14
xorl %ebp, %ebp
movq 0x58(%rsp), %rdi
cmpq %r12, %rdi
je 0xea2b
callq 0x3230
leaq 0x78(%rsp), %r15
cmpq %rbx, %r15
sete %al
orb %al, %bpl
jne 0xea5d
addq $-0x10, %rbx
movq -0x10(%rbx), %rdi
cmpq %rdi, %rbx
je 0xea4d
callq 0x3230
leaq -0x28(%rbx), %rax
addq $-0x18, %rbx
cmpq %r15, %rbx
movq %rax, %rbx
jne 0xea3f
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::set(Instruction*)
Instruction* Parser::set(Instruction* prev) {
	Instruction* ins = new Instruction(Ins::SET);

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

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

	return ins;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x80, %edi
callq 0x3260
movq %rax, %rbx
movl $0x1, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rax, 0x78(%rbx)
movl $0x2, 0x30(%rbx)
cmpl $0x3, (%r15)
jne 0xeb27
movq %rbx, %rdi
addq $0x8, %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0x3150
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xdd8e
movq 0x50(%rbx), %rdi
movaps (%r15), %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x60(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0xeb1a
callq 0x3230
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xeb1a
callq 0x3230
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xc4a2(%rip), %rdi      # 0x1afd0
leaq 0x46b3(%rip), %rsi      # 0x131e8
callq 0x3250
xorl %edi, %edi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::oper_list_extraction(Instruction*)
Instruction* Parser::oper_list_extraction(Instruction* prev) {
	Instruction* ins = new Instruction(Ins::LIST_EXTRACT);

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

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

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

	return ins;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x80, %edi
callq 0x3260
movq %rax, %rbx
movl $0xf, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
xorl %r12d, %r12d
movq %r12, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %r12, 0x78(%rbx)
movl $0x2, 0x30(%rbx)
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x40(%rsp), %r15
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
movq %r15, %rdi
callq 0x112c8
movq 0x38(%rbx), %rdi
movaps (%r15), %xmm0
movups %xmm0, 0x38(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x48(%rbx)
movq %r12, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
testq %rdi, %rdi
je 0xee39
callq 0x3230
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xee39
callq 0x3230
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movw $0x5d, (%r15)
movq $0x1, -0x8(%r15)
leaq 0x40(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x6d4c
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x111aa
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq 0xdcd2
movq 0x50(%rbx), %rdi
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rbx)
testq %rdi, %rdi
je 0xeeaa
callq 0x3230
leaq 0x28(%rsp), %rdi
callq 0x111ec
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeec7
callq 0x3230
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0xeed6
callq 0x3230
movq 0x58(%rbx), %rax
subq 0x50(%rbx), %rax
cmpq $0x8, %rax
jne 0xeef6
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xc0d3(%rip), %rdi      # 0x1afd0
leaq 0x4251(%rip), %rsi      # 0x13155
callq 0x3250
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x111ec
jmp 0xef22
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xef3a
callq 0x3230
jmp 0xef3a
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0xef49
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::keyword(lexer::Token*)
Instruction* Parser::keyword(lexer::Token* tok) {
	switch (tok->sub) {
		case lexer::Type::KEYWORD_CLASS: return this->keyword_class(); break;
		case lexer::Type::KEYWORD_FN: return this->keyword_fn(); break;
		case lexer::Type::KEYWORD_IF: return this->keyword_if(); break;
		case lexer::Type::KEYWORD_NEW: return this->keyword_new(); break;
		case lexer::Type::KEYWORD_WHILE: return this->keyword_while(); break;
		case lexer::Type::KEYWORD_RETURN: return this->keyword_return(); break;
		default: break;
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl 0x4(%rsi), %eax
addl $-0xa, %eax
cmpl $0x6, %eax
ja 0xf113
leaq 0x3f22(%rip), %rcx      # 0x12fd8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xfab6
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x10a2e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xfd64
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x10c64
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1023c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x10636
movq 0xbeb6(%rip), %r14      # 0x1afd0
leaq 0x406b(%rip), %rsi      # 0x1318c
movl $0x11, %edx
movq %r14, %rdi
callq 0x32a0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6eaa
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0x37a1(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
movq %rsp, %rdi
callq 0x3120
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf17f
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::oper(lexer::Token*)
Instruction* Parser::oper(lexer::Token* tok) {
	switch (tok->sub) {
		case lexer::Type::OPERATOR_SQUARE_PAREN_LEFT: return this->oper_list_creation(); break;
		case lexer::Type::OPERATOR_MINUS:             return this->oper_minus();         break;
		default: break;
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movl 0x4(%rsi), %eax
cmpl $0x22, %eax
je 0xf1b2
cmpl $0x2e, %eax
jne 0xf1d0
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf4c4
callq 0xf76a
movq %r14, %rdi
movq %rax, %rsi
movl $0x2, %edx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf7ee
movq %rsi, %rbx
movq 0xbdf6(%rip), %r14      # 0x1afd0
leaq 0x3f61(%rip), %rsi      # 0x13142
movl $0x12, %edx
movq %r14, %rdi
callq 0x32a0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6eaa
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0x36e1(%rip), %rsi      # 0x128f3
movq %rax, %rdi
callq 0x3250
movq %rsp, %rdi
callq 0x3120
xorl %edi, %edi
callq 0x32c0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf23f
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::oper_list_creation()
Instruction* Parser::oper_list_creation() {
	Instruction* ins = new Instruction(Ins::LIST_CREATE);

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

	return ins;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %r15
movl $0x80, %edi
callq 0x3260
movq %rax, %r12
movl $0xe, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%r12)
xorl %eax, %eax
movq %rax, 0x10(%r12)
movb $0x0, 0x18(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r12)
movups %xmm0, 0x48(%r12)
movups %xmm0, 0x58(%r12)
movups %xmm0, 0x68(%r12)
movq %rax, 0x78(%r12)
movl $0x2, 0x30(%r12)
leaq 0x18(%rsp), %r13
movq %r12, %rax
addq $0x50, %rax
movq %rax, 0x48(%rsp)
leaq 0xc0(%rsp), %rbx
leaq 0x80(%rsp), %r14
leaq 0xd0(%rsp), %rbp
movq %r13, 0x8(%rsp)
movw $0x5d, 0x18(%rsp)
movq $0x1, 0x10(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0x6d4c
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movw $0x2c, 0x38(%rsp)
movq $0x1, 0x30(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6d4c
movl $0x2, %edx
movq %rbp, %rdi
movq %r14, %rsi
leaq 0x7(%rsp), %rcx
callq 0x111aa
leaq 0x68(%rsp), %r13
movq %r13, %rdi
movq 0x48(%rsp), %rsi
callq 0x450e
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0xe02a
movq 0x50(%r12), %rdi
movaps 0x50(%rsp), %xmm0
movups %xmm0, 0x50(%r12)
movq 0x60(%rsp), %rax
movq %rax, 0x60(%r12)
testq %rdi, %rdi
je 0xf5ff
callq 0x3230
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0xf60e
callq 0x3230
movq %rbp, %rdi
callq 0x111ec
xorl %r13d, %r13d
movq 0xb0(%rsp,%r13), %rdi
leaq (%rbx,%r13), %rax
cmpq %rdi, %rax
je 0xf62f
callq 0x3230
addq $-0x28, %r13
cmpq $-0x50, %r13
jne 0xf619
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xf64d
callq 0x3230
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %r13
cmpq %r13, %rdi
je 0xf661
callq 0x3230
movslq 0x18(%r15), %rax
movq (%r15), %rcx
movq (%rcx,%rax,8), %rax
cmpl $0x12, 0x4(%rax)
je 0xf553
movq %r12, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
xorl %ebx, %ebx
jmp 0xf704
movq %rax, %r15
xorl %ebx, %ebx
jmp 0xf6e3
movq %rax, %r15
jmp 0xf6c2
movq %rax, %r15
jmp 0xf6b5
movq %rax, %r15
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0xf6b5
callq 0x3230
leaq 0xd0(%rsp), %rdi
callq 0x111ec
movq $-0x50, %r14
movq -0x10(%rbx), %rdi
cmpq %rdi, %rbx
je 0xf6d7
callq 0x3230
addq $-0x28, %rbx
addq $0x28, %r14
jne 0xf6c9
movb $0x1, %bl
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xf6f7
callq 0x3230
leaq 0xa8(%rsp), %r14
leaq 0x18(%rsp), %r13
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xf713
callq 0x3230
leaq 0x80(%rsp), %r12
cmpq %r14, %r12
sete %al
orb %al, %bl
jne 0xf747
addq $-0x10, %r14
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0xf737
callq 0x3230
leaq -0x28(%r14), %rax
addq $-0x18, %r14
cmpq %r12, %r14
movq %rax, %r14
jne 0xf729
movq %r15, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::keyword_while()
Instruction* Parser::keyword_while() {
	Instruction* ins = new Instruction(Ins::WHILE);

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

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

	return ins;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
movl $0x80, %edi
callq 0x3260
movq %rax, %rbx
movl $0xd, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rax, 0x78(%rbx)
movl $0x2, 0x30(%rbx)
leaq 0xb8(%rsp), %r15
movq %r15, -0x10(%r15)
movw $0x7b, (%r15)
movq $0x1, -0x8(%r15)
leaq 0x30(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x6d4c
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x111aa
leaq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rdx
movq %r14, %rsi
callq 0xdcd2
movq 0x38(%rbx), %rdi
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x38(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rbx)
testq %rdi, %rdi
je 0x10af9
callq 0x3230
leaq 0x70(%rsp), %rdi
callq 0x111ec
leaq 0x48(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x10b17
callq 0x3230
movq 0xa8(%rsp), %rdi
cmpq %r15, %rdi
je 0x10b29
callq 0x3230
cmpb $0x1, 0x20(%r14)
jne 0x10b36
incl 0x18(%r14)
jmp 0x10b3b
movb $0x1, 0x20(%r14)
leaq 0x98(%rsp), %r15
movq %r15, -0x10(%r15)
movw $0x7d, (%r15)
movq $0x1, -0x8(%r15)
leaq 0x30(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x6d4c
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x111aa
leaq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rdx
movq %r14, %rsi
callq 0xdcd2
movq 0x50(%rbx), %rdi
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rbx)
testq %rdi, %rdi
je 0x10bb2
callq 0x3230
leaq 0x58(%rsp), %rdi
callq 0x111ec
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x10bcb
callq 0x3230
movq 0x88(%rsp), %rdi
cmpq %r15, %rdi
je 0x10bdd
callq 0x3230
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x111ec
jmp 0x10c01
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x10c15
callq 0x3230
jmp 0x10c15
movq %rax, %rbx
movq 0x88(%rsp), %rdi
jmp 0x10c51
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x111ec
jmp 0x10c31
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10c49
callq 0x3230
jmp 0x10c49
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
cmpq %r15, %rdi
je 0x10c5b
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kram[P]kram/./src/parser/parser.cpp
// Function: Parser::boolean_init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Instruction* Parser::boolean_init(std::string val) {
	Instruction* ins = new Instruction(Ins::LITERAL);

	if (val == "true") {
		ins->value = new Value(Type::BOOL, 1);
	} else {
		ins->value = new Value(Type::BOOL, 0);
	}

	return ins;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl $0x80, %edi
callq 0x3260
movq %rax, %rbx
movl $0x2, %eax
movl %eax, (%rbx)
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rcx, 0x78(%rbx)
movl %eax, 0x30(%rbx)
leaq 0x145d(%rip), %rsi      # 0x122ff
movq %r14, %rdi
callq 0x30a0
movl %eax, %ebp
movl $0x10, %edi
callq 0x3260
movq %rax, %r14
testl %ebp, %ebp
je 0x10ecf
xorps %xmm0, %xmm0
movq %r14, %rdi
movl $0x3, %esi
callq 0xcd5a
jmp 0x10ee4
movsd 0x1619(%rip), %xmm0     # 0x124f0
movq %r14, %rdi
movl $0x3, %esi
callq 0xcd5a
movq %r14, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x10ef2
movq %rax, %rbx
movq %r14, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/backend.cpp
// Function: BackEnd::initialize()
void BackEnd::initialize()
{
    decodedFrequencies.clear();
    realFrequenciesIndices.clear();

    // peeling engine checks for singletons only in the updated (changed) bins
    // initialize all to true so that all the bins are check on the first run through
    for (int binAbsoluteIndex = 0; binAbsoluteIndex < config->getBinsSum(); binAbsoluteIndex++)
    {
        changed[binAbsoluteIndex] = true;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x30, %rdi
callq 0x43e6
movq 0x68(%rbx), %rax
cmpq %rax, 0x70(%rbx)
je 0x3e90
movq %rax, 0x70(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6cde
testl %eax, %eax
jle 0x3ebf
xorl %r14d, %r14d
movq 0x80(%rbx), %rax
movb $0x1, (%rax,%r14)
incq %r14
movq 0x10(%rbx), %rdi
callq 0x6cde
cltq
cmpq %rax, %r14
jl 0x3ea0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/backend.cpp
// Function: BackEnd::printObservations()
void BackEnd::printObservations() {
    for (int stagePrint = 0; stagePrint < config->getBinsNb(); stagePrint++) {
        std::cout<< "-------------------------------" << std::endl;
        for (int r = 0; r < config->getBinNumItems(stagePrint); r++) {
            for (int c = 0; c < config->getDelaysNb(); c++) {
                std::cout << observationMatrix[r + config->getBinOffset(stagePrint)][c] << ", ";
            }
            std::cout << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x6ce2
testl %eax, %eax
jle 0x420d
xorl %r14d, %r14d
movq 0x10ee0(%rip), %r15     # 0x14fc8
movl $0x1f, %edx
movq %r15, %rdi
leaq 0x9f41(%rip), %rsi      # 0xe038
callq 0x32b0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq 0x10(%rbx), %rdi
movl %r14d, %esi
callq 0x6c48
testl %eax, %eax
jle 0x41f8
xorl %eax, %eax
movq %r14, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movq 0x10(%rbx), %rdi
callq 0x6cf0
testl %eax, %eax
leaq 0xadb7(%rip), %rbp      # 0xef0b
jle 0x41b0
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rdi
movq %r15, %r14
movq 0x28(%rbx), %r15
movq 0x10(%rsp), %rsi
callq 0x6cd2
addl 0xc(%rsp), %eax
cltq
movq (%r15,%rax,8), %rsi
movq %r14, %r15
addq %r12, %rsi
movq %r14, %rdi
callq 0x32d0
movl $0x2, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x32b0
incq %r13
movq 0x10(%rbx), %rdi
callq 0x6cf0
cltq
addq $0x10, %r12
cmpq %rax, %r13
jl 0x415c
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movl 0xc(%rsp), %ebp
incl %ebp
movq 0x10(%rbx), %rdi
movq 0x10(%rsp), %r14
movl %r14d, %esi
callq 0x6c48
cmpl %eax, %ebp
movl %ebp, %eax
jl 0x413e
incl %r14d
movq 0x10(%rbx), %rdi
callq 0x6ce2
cmpl %eax, %r14d
jl 0x40e8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/backend.cpp
// Function: BackEnd::getHash(int, int)
int BackEnd::getHash(int stage, int spectralIndex)
{
    bool** subsamplingMatrix = config->getSubsamplingMatrix(stage);
    int ret = 0;

    for (int r = 0; r < config->getBinNumIndices(stage); r++) {
        bool currState = false;
        for (int c = 0; c < config->getSignalBitLength(); c++) {
            // currState = currState ^ (subsamplingMatrix[r][c] & (spectralIndexBinary[c] == 1));
            int shifted = 1 << (config->getSignalBitLength() - c - 1);
            currState = currState ^ (subsamplingMatrix[r][c] & ( (spectralIndex & shifted) == shifted));

        }
        if (currState)
            ret += 1<< (config->getBinNumIndices(stage)- r-1);
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r12
movq 0x10(%rdi), %rdi
callq 0x6d24
movq %rax, %r14
movq 0x10(%r12), %rdi
movl %ebx, %esi
callq 0x6c94
testl %eax, %eax
jle 0x4349
xorl %r13d, %r13d
movl $0x0, 0xc(%rsp)
movl %ebx, 0x10(%rsp)
movq %r14, 0x20(%rsp)
movl %r15d, 0x14(%rsp)
movq 0x10(%r12), %rdi
callq 0x6c18
testl %eax, %eax
jle 0x432d
movq %r12, %r14
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorl %ebp, %ebp
xorl %ebx, %ebx
movq %r13, 0x18(%rsp)
movq 0x10(%r14), %rdi
callq 0x6c18
leal (%rax,%r12), %ecx
movzbl %bl, %r15d
andl $0x1, %r15d
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movzbl (%rax,%rbp), %eax
movl 0x14(%rsp), %r13d
shrl %cl, %r13d
andl %eax, %r13d
cmpl %r15d, %r13d
setne %bl
incq %rbp
movq 0x10(%r14), %rdi
callq 0x6c18
cltq
decl %r12d
cmpq %rax, %rbp
jl 0x42a5
movq 0x18(%rsp), %rbp
movq %r14, %r12
cmpl %r15d, %r13d
je 0x4326
movq 0x10(%r12), %rdi
movl 0x10(%rsp), %ebx
movl %ebx, %esi
callq 0x6c94
movq %rbp, %r13
movl %ebp, %ecx
notl %ecx
addl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
addl %eax, 0xc(%rsp)
jmp 0x432d
movl 0x10(%rsp), %ebx
movq %rbp, %r13
incq %r13
movq 0x10(%r12), %rdi
movl %ebx, %esi
callq 0x6c94
cltq
cmpq %rax, %r13
jl 0x4281
jmp 0x4351
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::BinProcessor(Chrono*, Config const*, std::complex<double>**, std::vector<int, std::allocator<int>> const&)
BinProcessor::BinProcessor(Chrono *newChrono, const Config* newConfig, ffast_complex** newObservationMatrix, const std::vector<int>& newDelays):
    Step(newChrono, newConfig), observationMatrix(newObservationMatrix), delays(newDelays)
{
    signalLength     = config->getSignalLength();
    delaysNb         = config->getDelaysNb();
    chainsNb         = config->getChainsNb();
    delaysPerBunchNb = config->getDelaysPerBunchNb();

    MLdetection         = config->needToUseMaximumLikelihoodDetection();

    signalVector    = (ffast_complex*) malloc(delaysNb * sizeof(ffast_complex));
    thresholds      = (ffast_real*) malloc(config->getBinsNb() * sizeof(ffast_real));
    directionVector = (ffast_complex*) malloc(delaysNb * sizeof(ffast_complex));
    computeThresholds();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
leaq 0xff09(%rip), %rax      # 0x14900
movq %rax, (%rdi)
movq %rcx, 0x18(%rdi)
leaq 0x88(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq %r14, %rdi
movq %r8, %rsi
callq 0x539c
movq 0x10(%rbx), %rdi
callq 0x6c28
movl %eax, 0x20(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6cf0
movl %eax, 0x24(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6cf4
movl %eax, 0x28(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6cf8
movl %eax, 0x2c(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6c2c
movb %al, 0x68(%rbx)
movslq 0x24(%rbx), %rdi
shlq $0x4, %rdi
callq 0x3320
movq %rax, 0x50(%rbx)
movq 0x10(%rbx), %rdi
callq 0x6ce2
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x3320
movq %rax, 0x78(%rbx)
movslq 0x24(%rbx), %rdi
shlq $0x4, %rdi
callq 0x3320
movq %rax, 0x80(%rbx)
movq %rbx, %rdi
callq 0x4ac2
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4ab9
movq 0x98(%rbx), %rsi
subq %rdi, %rsi
callq 0x3270
movq %r15, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::process()
void BinProcessor::process()
{
    if (MLdetection)
    {
        // MLprocess tries out all possible locations and estimates bin signal
        MLprocess();
    }
    else
    {
        computeLocation();
        estimateBinSignal();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x68(%rdi)
jne 0x4e2d
movq %rbx, %rdi
popq %rbx
jmp 0x4e3e
movq %rbx, %rdi
callq 0x5006
movq %rbx, %rdi
popq %rbx
jmp 0x5122
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::computeLocation()
void BinProcessor::computeLocation()
{
    int tempLoc = 0;

    for(int q = 0; q < config->getSignalBitLength(); q++) {
        int runningSum = 0;
        for (int i = 0; i <config->getChainsNb(); i++) {
            ffast_complex Dp = observationMatrix[binAbsoluteIndex][(config->getSignalBitLength()+1)*i];
            ffast_complex Dpq = observationMatrix[binAbsoluteIndex][(config->getSignalBitLength()+1)*i+q+1];
            bool sgn1 = std::real(Dp) > 0;
            bool sgn2 = std::real(Dpq) > 0;
            bool sgn = sgn1 ^ sgn2;
            runningSum+= 2*sgn - 1;            
        }
        if (runningSum >=0)
            tempLoc += 1<<(config->getSignalBitLength() - 1- q);
    }
    location = tempLoc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x6c18
xorl %ebp, %ebp
testl %eax, %eax
jle 0x5110
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
callq 0x6cf4
testl %eax, %eax
jle 0x50e2
movl %ebp, 0xc(%rsp)
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rax
movslq 0x58(%rbx), %rcx
movq (%rax,%rcx,8), %r13
callq 0x6c18
incl %eax
imull %r15d, %eax
cltq
shlq $0x4, %rax
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rcx
movslq 0x58(%rbx), %rdx
movq (%rcx,%rdx,8), %rbp
movsd (%r13,%rax), %xmm0
movapd %xmm0, 0x10(%rsp)
callq 0x6c18
incl %eax
imull %r15d, %eax
addl %r14d, %eax
cltq
shlq $0x4, %rax
xorpd %xmm0, %xmm0
cmpltpd 0x10(%rsp), %xmm0
movsd 0x10(%rbp,%rax), %xmm1
xorpd %xmm2, %xmm2
cmpltpd %xmm1, %xmm2
xorpd %xmm0, %xmm2
movd %xmm2, %eax
notl %eax
orl $0x1, %eax
addl %eax, %r12d
incl %r15d
movq 0x10(%rbx), %rdi
callq 0x6cf4
cmpl %eax, %r15d
jl 0x5048
testl %r12d, %r12d
movl 0xc(%rsp), %ebp
js 0x50fb
movq 0x10(%rbx), %rdi
callq 0x6c18
movl %r14d, %ecx
notl %ecx
addl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
addl %eax, %ebp
incl %r14d
movq 0x10(%rbx), %rdi
callq 0x6c18
cmpl %eax, %r14d
jl 0x502d
movl %ebp, 0x38(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::estimateBinSignal()
void BinProcessor::estimateBinSignal()
{
    int delayIndex = 0;
    amplitude      = 0;

    for(auto delayIterator=delays.begin(); delayIterator != delays.end(); ++delayIterator)
    {
        directionVector[delayIndex] = (numOnes(*delayIterator & location) % 2) ? -1 : 1;
        amplitude += directionVector[delayIndex] * observationMatrix[binAbsoluteIndex][delayIndex];
        delayIndex++;
    }

    // average the found amplitudes
    amplitude /= delaysNb;

    noise = 0;

    for (int delayIndex=0; delayIndex<delaysNb; delayIndex++)
    {
        // compute the bin signal that would result from a tone with such amplitude and location
        signalVector[delayIndex] = amplitude*directionVector[delayIndex];
        // the residual between the actual bin measurement and the computed one is the noise
        noise += std::norm(observationMatrix[binAbsoluteIndex][delayIndex]-signalVector[delayIndex]);
    } 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x40(%rdi)
movq 0x88(%rdi), %r15
cmpq 0x90(%rdi), %r15
je 0x51d4
xorl %r12d, %r12d
movq %rsp, %r14
movl 0x38(%rbx), %eax
andl (%r15), %eax
movl %eax, %ecx
shrl $0x10, %ecx
xorl %eax, %ecx
xorl %eax, %eax
xorb %ch, %cl
setp %al
leal -0x1(,%rax,2), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq 0x80(%rbx), %rax
movsd %xmm0, (%rax,%r12)
movq $0x0, 0x8(%rax,%r12)
movq 0x18(%rbx), %rax
movq 0x80(%rbx), %rcx
movslq 0x58(%rbx), %rdx
movq (%rax,%rdx,8), %rsi
addq %r12, %rsi
movups (%rcx,%r12), %xmm0
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0x5438
movupd 0x40(%rbx), %xmm0
addpd (%rsp), %xmm0
movupd %xmm0, 0x40(%rbx)
addq $0x4, %r15
addq $0x10, %r12
cmpq 0x90(%rbx), %r15
jne 0x5155
movl 0x24(%rbx), %eax
cvtsi2sd %eax, %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm0
movupd %xmm0, 0x40(%rbx)
movq $0x0, 0x70(%rbx)
testl %eax, %eax
jle 0x527c
leaq 0x40(%rbx), %r15
xorl %r12d, %r12d
movq %rsp, %r14
xorl %r13d, %r13d
movq 0x80(%rbx), %rsi
addq %r12, %rsi
movups (%r15), %xmm0
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0x5438
movaps (%rsp), %xmm0
movq 0x50(%rbx), %rax
movups %xmm0, (%rax,%r12)
movslq 0x58(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x50(%rbx), %rdx
movq (%rcx,%rax,8), %rax
movsd (%rax,%r12), %xmm0
movsd 0x8(%rax,%r12), %xmm1
subsd (%rdx,%r12), %xmm0
subsd 0x8(%rdx,%r12), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
addsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x70(%rbx)
incq %r13
movslq 0x24(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x5205
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::adjustTo(int, int, int)
void BinProcessor::adjustTo(int newBinAbsoluteIndex, int newBinRelativeIndex, int newStage)
{
    binAbsoluteIndex = newBinAbsoluteIndex;
    binRelativeIndex = newBinRelativeIndex;
    stage   = newStage;
    samplingPattern = config->getSamplingPattern(stage);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x58(%rdi)
movl %edx, 0x5c(%rdi)
movl %ecx, 0x60(%rdi)
movq 0x10(%rdi), %rdi
movl %ecx, %esi
callq 0x6c3c
movl %eax, 0x64(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::isSingleton()
bool BinProcessor::isSingleton()
{
    // a singleton is not zero-ton
    if (isZeroTon())
    {
        return false;
    }
    process();
    
    // if the bin is a singleton, when we peel the frequency from the bin
    // the remaining power should be coming from noise only
    // also we need the singleton to have energy larger than a threshold (minimumEnergy)

    if (noise / delaysNb <= thresholds[stage] && config->getDelaysNb()*std::norm(amplitude) > minimumEnergy)
    {
        // The bin is a singleton
        return true;
    }

    // The bin is a 'multi-ton'
    return false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5316
testb %al, %al
jne 0x5312
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movsd 0x70(%rbx), %xmm0
cvtsi2sdl 0x24(%rbx), %xmm1
divsd %xmm1, %xmm0
movq 0x78(%rbx), %rax
movslq 0x60(%rbx), %rcx
movsd (%rax,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jb 0x5312
movq 0x10(%rbx), %rdi
callq 0x6cf0
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x40(%rbx), %xmm1
movsd 0x48(%rbx), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movb $0x1, %al
ucomisd 0x30(%rbx), %xmm1
ja 0x5314
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/binprocessor.cpp
// Function: BinProcessor::isZeroTon() const
bool BinProcessor::isZeroTon() const
{
    ffast_real energy = 0;

    for (int delayIndex=0; delayIndex<delaysNb; delayIndex++)
    {
        energy += std::norm(observationMatrix[binAbsoluteIndex][delayIndex]);
    }
    if (energy <= thresholds[stage])
    {
        return true;
    }

    return false;
}

// Assembly:
movslq 0x24(%rdi), %rax
testq %rax, %rax
jle 0x535b
movq 0x18(%rdi), %rcx
movslq 0x58(%rdi), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x4, %rax
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%rcx,%rdx), %xmm1
movsd 0x8(%rcx,%rdx), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0x5335
jmp 0x535f
xorpd %xmm0, %xmm0
movq 0x78(%rdi), %rax
movslq 0x60(%rdi), %rcx
movsd (%rax,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/chrono.cpp
// Function: Chrono::average(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double Chrono::average(const std::string& section)
{
    if (notEmpty(section))
    {
        double sum = 0;
        unsigned int timesNb = getSectionStopTimes(section).size();

        for (unsigned int i=0; i<timesNb; i++)
        {

	    sum += getSectionTime(section, i);
        }

        return sum/timesNb;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x5c44
leaq 0x48(%r14), %rcx
cmpq %rcx, %rax
je 0x5bb4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5bc8
movq 0x8(%rax), %r15
subq (%rax), %r15
shrq $0x3, %r15
xorpd %xmm1, %xmm1
testl %r15d, %r15d
je 0x5ba3
xorl %ebp, %ebp
movsd %xmm1, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5aba
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
incl %ebp
cmpl %ebp, %r15d
jne 0x5b81
movl %r15d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
jmp 0x5bb8
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UCBASiCS[P]SPRIGHT/src/config.cpp
// Function: Config::Config(int, char**)
Config::Config(int newArgc, char** newArgv):argc(newArgc), argv(newArgv), helpDisplayed(false)
{
    bins.clear();
    setDefaultOptions();

    setOptionsFromCommandLine();

    if(distribution.size() == 0)
    {
      preprocessDistribution((char*) "1");
    }

    setBinOffsetsAndBinsSum();
    setSubsamplingMatrices();

    maxSNRdB = (maxSNRdB < SNRdB) ? SNRdB : maxSNRdB;


    chainsNb = (chainsNb >= 1) ? chainsNb : 1;
    if (!noisy)
      chainsNb = 1;

    delaysPerBunchNb = getSignalBitLength()+1;
    delaysNb = chainsNb * delaysPerBunchNb;
    


   assert( signalLength >= signalSparsity );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
movb $0x0, 0x11(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x40(%rdi), %r15
leaq 0x78(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rdi)
xorl %eax, %eax
movq %rax, 0x88(%rdi)
leaq 0xb8(%rdi), %rbp
movups %xmm0, 0xb8(%rdi)
movq %rax, 0xc8(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
callq 0x624a
movq %rbx, %rdi
callq 0x62d2
movq 0x80(%rbx), %rax
cmpq 0x78(%rbx), %rax
jne 0x6192
leaq 0x805a(%rip), %rsi      # 0xe1e4
movq %rbx, %rdi
callq 0x646c
movq %rbx, %rdi
callq 0x661e
movq %rbx, %rdi
callq 0x6a2e
movss 0x6c(%rbx), %xmm0
maxss 0x94(%rbx), %xmm0
movss %xmm0, 0x94(%rbx)
movl 0x18(%rbx), %eax
movl 0x60(%rbx), %ecx
cmpl $0x2, %ecx
movl $0x1, %edx
cmovll %edx, %ecx
cmpb $0x0, 0x68(%rbx)
cmovel %edx, %ecx
movl %ecx, 0x60(%rbx)
movl 0xb0(%rbx), %edx
incl %edx
movl %edx, 0x64(%rbx)
imull %ecx, %edx
movl %edx, 0x5c(%rbx)
cmpl 0x24(%rbx), %eax
jl 0x61f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7fe8(%rip), %rdi      # 0xe1e6
leaq 0x8000(%rip), %rsi      # 0xe205
leaq 0x8008(%rip), %rcx      # 0xe214
movl $0x2d, %edx
callq 0x3160
movq %rax, %r13
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x6231
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3270
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3555
movq %r13, %rdi
callq 0x3490