LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/negativeview[P]Software-Business-Sim/Company.cpp
// Function: Company::learnAboutEmployees()
void Company::learnAboutEmployees() {
	for (vector<Person *>::iterator it = this->_knownPeople->begin(); it != this->_knownPeople->end(); ++it) {
		Person *person = *it;
		if (rand() % 10 == 0) {
			list<Trait *> *allTraits = person->getRealTraits();
			for (list<Trait *>::iterator it2 = allTraits->begin(); it2 != allTraits->end(); ++it2) {
				Trait *t = *it2;
				if (rand() % 10 == 0) {
					t->discoverMore();
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
movq 0x18(%rdi), %rax
movq (%rax), %r12
cmpq 0x8(%rax), %r12
je 0x76b0
movl $0x19999998, %r13d      # imm = 0x19999998
movq (%r12), %r14
callq 0x30c0
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
addl %r13d, %eax
rorl %eax
cmpl %r13d, %eax
ja 0x769e
movq %r14, %rdi
callq 0x8b16
movq (%rax), %rbx
cmpq %rax, %rbx
je 0x769e
movq %rax, %r14
movq 0x10(%rbx), %r15
callq 0x30c0
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
addl %r13d, %eax
rorl %eax
cmpl %r13d, %eax
ja 0x7696
movq %r15, %rdi
callq 0xa798
movq (%rbx), %rbx
cmpq %r14, %rbx
jne 0x7675
addq $0x8, %r12
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
cmpq 0x8(%rax), %r12
jne 0x7649
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/negativeview[P]Software-Business-Sim/Company.cpp
// Function: Company::addKnownPerson(Person*)
void Company::addKnownPerson(Person *person) {
	for (vector<Person *>::iterator it = this->_employees->begin(); it != this->_employees->end(); ++it) {
		Person *p = *it;
		if (p == person)
			return;
	}
	this->_knownPeople->push_back(person);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
movq 0x10(%rdi), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0x76f1
cmpq %rsi, (%rax)
je 0x7715
addq $0x8, %rax
jmp 0x76e1
movq 0x18(%rdi), %rdi
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x7709
movq %rsi, (%rax)
addq $0x8, 0x8(%rdi)
jmp 0x7715
leaq -0x8(%rbp), %rdx
movq %rax, %rsi
callq 0x7ba2
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/negativeview[P]Software-Business-Sim/Company.cpp
// Function: Company::doPayments(int)
void Company::doPayments(int time) {
	// Every two weeks, pay your people.
	int totalPayout = 0;
	if (time % 14 == 0) {
		for (vector<Person *>::iterator it = this->_employees->begin(); it != this->_employees->end(); ++it) {
			int salary = (int)((*it)->getCurrentSalary() / 26.0);
			this->payWages(salary);
			(*it)->addMoney(salary);
			totalPayout += salary;
		}
	}

	int overheadCost = this->getOverheadCost();
	this->payOverhead(overheadCost);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
imull $0xb6db6db7, %esi, %eax # imm = 0xB6DB6DB7
movl $0x12492492, %ecx       # imm = 0x12492492
addl %ecx, %eax
rorl %eax
cmpl %ecx, %eax
jbe 0x7749
movq %rbx, %rdi
callq 0x7790
subl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x10(%rbx), %rax
movq (%rax), %r14
cmpq 0x8(%rax), %r14
je 0x7739
movq (%r14), %rdi
callq 0x8a2e
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x4043(%rip), %xmm0     # 0xb7b0
cvttsd2si %xmm0, %esi
subl %esi, 0x8(%rbx)
movq (%r14), %rdi
callq 0x8b2a
addq $0x8, %r14
movq 0x10(%rbx), %rax
jmp 0x7750
// File: /workspace/github_cpp_makefile_star2_O3/negativeview[P]Software-Business-Sim/Company.cpp
// Function: Company::getOverheadCost()
int Company::getOverheadCost() {
	// No matter what, you cannot get away scot free.
	int overhead = 1;

	overhead += this->_employees->size() * 10;

	// Every 10 days something random happens.
	// The higher your everyday costs, the more
	// an occurence costs.
	if (rand() % 10 == 0)
		overhead *= (rand() % 100) / 50.0;

	return overhead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ebx
incl %ebx
callq 0x30c0
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
movl $0x19999998, %ecx       # imm = 0x19999998
addl %ecx, %eax
rorl %eax
cmpl %ecx, %eax
ja 0x77fc
callq 0x30c0
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
cvtsi2sd %eax, %xmm0
divsd 0x3fc8(%rip), %xmm0     # 0xb7b8
cvtsi2sd %ebx, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/negativeview[P]Software-Business-Sim/Company.cpp
// Function: Company::~Company()
Company::~Company() {
	free(this->_name);
	this->_name = NULL;
	delete this->_employees;
	this->_employees = NULL;
	delete this->_platformSkills;
	this->_platformSkills = NULL;
	delete this->_knownPeople;
	this->_knownPeople = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x33b0
movq $0x0, (%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x7864
movq (%r14), %rdi
testq %rdi, %rdi
je 0x7864
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x3320
movl $0x18, %esi
movq %r14, %rdi
callq 0x3320
movq $0x0, 0x10(%rbx)
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x788a
movq %r14, %rdi
callq 0x7a04
movl $0x30, %esi
movq %r14, %rdi
callq 0x3320
movq $0x0, 0x28(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x78bc
movq (%r14), %rdi
testq %rdi, %rdi
je 0x78bc
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x3320
movl $0x18, %esi
movq %r14, %rdi
callq 0x3320
movq $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/negativeview[P]Software-Business-Sim/Person.cpp
// Function: Person::acceptWages(int)
bool Person::acceptWages(int money) {
	int traitInfluence = 0;
	for (list<Trait *>::iterator it = this->_believedTraits->begin(); it != this->_believedTraits->end(); ++it) {
		traitInfluence += (*it)->influenceOnSalaryRequirements();
	}

	float randomInfluence = ((rand() % 100) / 100.0);

	if (money >= traitInfluence * randomInfluence)
		return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq 0x78(%rdi), %rax
movq (%rax), %r15
cmpq %rax, %r15
je 0x8a77
movq %rdi, %r14
xorl %r12d, %r12d
movq 0x10(%r15), %rdi
movq (%rdi), %rax
callq *(%rax)
addl %eax, %r12d
movq (%r15), %r15
cmpq 0x78(%r14), %r15
jne 0x8a5b
cvtsi2ss %r12d, %xmm0
jmp 0x8a7a
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
callq 0x30c0
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x2d12(%rip), %xmm0     # 0xb7c0
cvtsd2ss %xmm0, %xmm0
mulss -0x24(%rbp), %xmm0
cvtsi2ss %ebx, %xmm1
ucomiss %xmm0, %xmm1
setae %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/negativeview[P]Software-Business-Sim/Person.cpp
// Function: Person::~Person()
Person::~Person() {
	list<Trait *>::iterator traitIterator;
	for (traitIterator = this->_believedTraits->begin(); traitIterator != this->_believedTraits->end(); ++traitIterator) {
		Trait *t = *traitIterator;
		delete t;
	}	
	delete this->_believedTraits;
	this->_believedTraits = NULL;

	for (traitIterator = this->_actualTraits->begin(); traitIterator != this->_actualTraits->end(); ++traitIterator) {
		Trait *t = *traitIterator;
		delete t;
	}
	delete this->_actualTraits;
	this->_actualTraits = NULL;
	delete this->_platformSkills;
	this->_platformSkills = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %r14
movq (%r14), %r15
cmpq %r14, %r15
je 0x8b7c
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x8b5e
movq %r14, %rdi
callq 0xaa16
movl $0x38, %esi
movq %r14, %rdi
callq 0x3320
movq 0x78(%rbx), %r14
movq (%r15), %r15
cmpq %r14, %r15
jne 0x8b4d
testq %r14, %r14
je 0x8b9b
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x8b9e
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3320
movq %r15, %rdi
cmpq %r14, %r15
jne 0x8b84
jmp 0x8b9e
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x3320
movq $0x0, 0x78(%rbx)
movq 0x70(%rbx), %r14
movq (%r14), %r15
cmpq %r14, %r15
je 0x8bee
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x8bd0
movq %r14, %rdi
callq 0xaa16
movl $0x38, %esi
movq %r14, %rdi
callq 0x3320
movq 0x70(%rbx), %r14
movq (%r15), %r15
cmpq %r14, %r15
jne 0x8bbf
testq %r14, %r14
je 0x8c0d
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x8c10
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3320
movq %r15, %rdi
cmpq %r14, %r15
jne 0x8bf6
jmp 0x8c10
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x3320
movq $0x0, 0x70(%rbx)
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x8c36
movq %r14, %rdi
callq 0x7a04
movl $0x30, %esi
movq %r14, %rdi
callq 0x3320
movq $0x0, 0x60(%rbx)
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x8c63
movq (%rax), %rsi
incq %rsi
callq 0x3320
movq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x8c7b
movq (%rax), %rsi
incq %rsi
callq 0x3320
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x43bc
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/negativeview[P]Software-Business-Sim/MasterState.cpp
// Function: MasterState::clearMessages()
void MasterState::clearMessages() {
	for (vector<char *>::iterator it = this->_messages->begin(); it != this->_messages->end(); ++it) {
		char *tmp = *it;
		free(tmp);
	}

	this->_messages->clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x48(%rdi), %rax
movq (%rax), %r14
cmpq 0x8(%rax), %r14
je 0x9a39
movq %rdi, %rbx
movq (%r14), %rdi
callq 0x33b0
addq $0x8, %r14
movq 0x48(%rbx), %rax
cmpq 0x8(%rax), %r14
jne 0x9a17
movq (%rax), %rcx
cmpq %rcx, %r14
je 0x9a39
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/negativeview[P]Software-Business-Sim/MasterState.cpp
// Function: MasterState::advanceTime[abi:cxx11](int)
list <string> *MasterState::advanceTime(int amount) {
	for (int i = 0; i < amount; i++) {
		this->_time++;

		// One in ten chance of creating a new person.
		if (rand() % (this->_allWorkers->size() + 1) == 0) {
			this->_createWorkers(1);
		}

		for (list<Company *>::iterator it = this->_allCompanies->begin(); it != this->_allCompanies->end(); ++it) {
			Company *c = *it;
			c->doPayments(this->_time);

			for (list<Person *>::iterator it = this->_allWorkers->begin(); it != this->_allWorkers->end(); ++it) {
				int found = 0;
				vector<Person *> *knownPeople = c->getKnownPeople();
				for (vector<Person *>::iterator it2 = knownPeople->begin(); it2 != knownPeople->end(); ++it2) {
					if (*it == *it2) {
						found = 1;
						break;
					}
				}
				if (found == 0) {
					// Every person that's not already known has a 1 in 10
					// chance of becoming discovered by the company. This number
					// needs to be tweaked as it causes way too many employees
					// too early.
					if (rand() % 10) {
						c->addKnownPerson(*it);
					}
				}
			}

			c->advanceTime(this->_time);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
incl 0x20(%rbx)
callq 0x30c0
cltq
movq 0x10(%rbx), %rcx
movq 0x10(%rcx), %rcx
incq %rcx
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
jne 0x9b00
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9b9c
movq 0x8(%rbx), %rax
movq (%rax), %r15
cmpq %rax, %r15
je 0x9ad4
movq 0x10(%r15), %r14
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x771c
movq 0x10(%rbx), %rax
movq (%rax), %r12
cmpq %rax, %r12
je 0x9b7e
movq %r14, %rdi
callq 0x76c0
movq (%rax), %rcx
movq 0x8(%rax), %rax
cmpq %rax, %rcx
je 0x9b4e
movq 0x10(%r12), %rdx
cmpq (%rcx), %rdx
je 0x9b74
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0x9b40
callq 0x30c0
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
addl $0x19999998, %eax       # imm = 0x19999998
rorl %eax
cmpl $0x19999999, %eax       # imm = 0x19999999
jb 0x9b74
movq 0x10(%r12), %rsi
movq %r14, %rdi
callq 0x76ca
movq (%r12), %r12
cmpq 0x10(%rbx), %r12
jne 0x9b27
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x761a
movq (%r15), %r15
cmpq 0x8(%rbx), %r15
jne 0x9b0c
jmp 0x9ad4
nop
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/grammar.cpp
// Function: p(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool p(string& in) {
	if (in[0]=='P') {consume(in);}
	else {return false;}

	if (callStack.size()>0) {programCounter=callStack[callStack.size()-1];callStack.pop_back();}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movb (%rax), %bl
cmpb $0x50, %bl
jne 0x3ba8
callq 0x32d4
movq 0x45ff(%rip), %rax      # 0x8188
cmpq 0x45f0(%rip), %rax      # 0x8180
je 0x3ba8
movq -0x8(%rax), %rcx
movq %rcx, 0x45fb(%rip)      # 0x8198
addq $-0x8, %rax
movq %rax, 0x45e0(%rip)      # 0x8188
cmpb $0x50, %bl
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/wolf.cpp
// Function: cleanInput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string cleanInput(string s) {
	string ret="";
	for (size_t i=0;i<s.size();++i) {
		if (s[i]==';') {break;}
		if (s[i]!=' ') {ret+=s[i];}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x2cd1(%rip), %rdx      # 0x5798
movq %rdx, %rsi
callq 0x3010
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2b04
xorl %r12d, %r12d
movq (%r14), %rcx
movzbl (%rcx,%r12), %ecx
cmpl $0x20, %ecx
je 0x2afc
cmpl $0x3b, %ecx
je 0x2b04
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x2110
movq 0x8(%r14), %rax
incq %r12
cmpq %rax, %r12
jb 0x2adb
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2b26
movq (%r15), %rsi
incq %rsi
callq 0x2150
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/grammar.cpp
// Function: write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void write(string bin,int start, int end) {
	for (size_t i=0;i<bin.size();++i) {
		if (end>0 && start+i>=end) {return;}
		bool val=(bool)(bin[i]-'0');			
		if (start+i>=systape.size()) {systape.push_back(val);}
		else {systape[start+i]=val;}
	}
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x34e4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movslq %esi, %r12
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movl %edx, %r15d
xorl %r13d, %r13d
addq $0x3f, %rax
movq %rax, -0x30(%rbp)
testl %ebx, %ebx
setle %al
leaq (%r12,%r13), %rcx
cmpq %r15, %rcx
setb %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x34d6
movq (%r14), %rax
movb (%rax,%r13), %al
movq 0x4d05(%rip), %rsi      # 0x8150
movl 0x4d07(%rip), %edi      # 0x8158
movq 0x4ce8(%rip), %rdx      # 0x8140
subq %rdx, %rsi
leaq (%rdi,%rsi,8), %rsi
cmpq %rsi, %rcx
jae 0x34ac
leaq 0x3f(%rcx), %rdi
testq %rcx, %rcx
cmovnsq %rcx, %rdi
sarq $0x6, %rdi
movq %rcx, %rsi
andq -0x30(%rbp), %rsi
xorl %r8d, %r8d
movabsq $-0x8000000000000000, %r9 # imm = 0x8000000000000000
cmpq %r9, %rsi
setbe %r8b
movl $0x1, %esi
shlq %cl, %rsi
leaq (%rdx,%rdi,8), %rcx
leaq -0x8(,%r8,8), %rdx
cmpb $0x30, %al
je 0x34c2
orq %rsi, (%rcx,%rdx)
jmp 0x34c9
xorl %esi, %esi
cmpb $0x30, %al
setne %sil
leaq 0x4c85(%rip), %rdi      # 0x8140
callq 0x4306
jmp 0x34c9
notq %rsi
andq %rsi, (%rcx,%rdx)
incq %r13
cmpq 0x8(%r14), %r13
jb 0x3423
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/grammar.cpp
// Function: inter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Interval inter(string& in) {
	Interval error={-1,-1};	
	Interval i={0,0};

	if (in[0]=='[') {consume(in);}
	else {i.end=systape.size()-1;return i;}
	i.start=number(in);

	if (in[0]==',') {consume(in);}
	else {return error;}

	i.end=number(in);
	if (i.end<i.start) {return error;}
	if (in[0]==']') {consume(in);}
	else {return error;}

	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq (%rdi), %rax
cmpb $0x5b, (%rax)
jne 0x3538
movq %rdi, %rbx
callq 0x32d4
movq %rbx, %rdi
callq 0x3329
movq %rax, %r14
movq (%rbx), %rax
cmpb $0x2c, (%rax)
jne 0x3531
movq %rbx, %rdi
callq 0x32d4
movq %rbx, %rdi
callq 0x3329
movq %rax, %r15
cmpl %r14d, %r15d
jge 0x3566
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3556
movq 0x4c11(%rip), %rax      # 0x8150
subq 0x4bfa(%rip), %rax      # 0x8140
movl 0x4c0c(%rip), %ecx      # 0x8158
addq %r12, %rcx
leaq (%rcx,%rax,8), %rax
xorl %r12d, %r12d
shlq $0x20, %rax
orq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
cmpb $0x5d, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x3556
movq %rbx, %rdi
callq 0x32d4
movl %r14d, %r12d
movq %r15, %rax
jmp 0x3556
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/grammar.cpp
// Function: t(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool t(string& in) {
	if (in[0]=='T') {consume(in);}
	else {return false;}

	unsigned int start=number(in);
	if (in[0]==',') {consume(in);}
	else {return false;}
	if (start>systape.size()) {systape.resize(start);}

	string binary_string;
	string binStr=binaryString(in);
	if (binStr.size()==0) {return false;}
	
	write(binStr,start);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq (%rdi), %rax
cmpb $0x54, (%rax)
jne 0x368e
movq %rdi, %rbx
callq 0x32d4
movq %rbx, %rdi
callq 0x3329
movq %rax, %r14
movq (%rbx), %rax
cmpb $0x2c, (%rax)
jne 0x368e
movq %rbx, %rdi
callq 0x32d4
movl %r14d, %esi
movq 0x4b81(%rip), %rax      # 0x8150
movl 0x4b83(%rip), %ecx      # 0x8158
subq 0x4b64(%rip), %rax      # 0x8140
leaq (%rcx,%rax,8), %rax
cmpq %rax, %rsi
jbe 0x35f3
leaq 0x4b54(%rip), %rdi      # 0x8140
xorl %edx, %edx
callq 0x435a
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x3374
movq -0x58(%rbp), %rdx
testq %rdx, %rdx
setne %bl
je 0x365e
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x60(%rbp), %rsi
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x2f72
leaq -0x40(%rbp), %rdi
movl %r14d, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x33ea
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x365e
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2150
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3677
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2150
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x3690
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x3690
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x36bc
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x36bc
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36da
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x36da
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x36ef
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/grammar.cpp
// Function: x(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool x(string& in) {
	if (in[0]=='X') {consume(in);}
	else {return false;}
	systape.resize(0);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movb (%rax), %bl
cmpb $0x58, %bl
jne 0x371c
callq 0x32d4
leaq 0x4a2d(%rip), %rdi      # 0x8140
xorl %esi, %esi
xorl %edx, %edx
callq 0x435a
cmpb $0x58, %bl
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/grammar.cpp
// Function: j(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool j(string& in) {
	if (in[0]=='J') {consume(in);}
	else {return false;}

	int newLine=number(in);

	Interval interv=inter(in);
	if (interv.start<0 || interv.end<0) {return false;}

	for (size_t i=interv.start;i<=interv.end;++i) {
		if (systape[i]) {programCounter=newLine-1;return true;}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
cmpb $0x4a, (%rax)
jne 0x3a58
movq %rdi, %r14
callq 0x32d4
movq %r14, %rdi
callq 0x3329
movq %rax, %rbx
movq %r14, %rdi
callq 0x34e5
movq %rax, %rcx
movabsq $-0x7fffffff80000000, %rax # imm = 0x8000000080000000
testq %rax, %rcx
je 0x3a5f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rcx, %rdx
shrq $0x20, %rcx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movb $0x1, %al
cmpq %rcx, %rdx
ja 0x3a5a
movq 0x46c6(%rip), %rsi      # 0x8140
incq %rcx
movq %rdx, %rdi
shrq $0x6, %rdi
movq (%rsi,%rdi,8), %rdi
btq %rdx, %rdi
jb 0x3a98
incq %rdx
cmpq %rdx, %rcx
jne 0x3a7d
jmp 0x3a5a
decl %ebx
movslq %ebx, %rcx
movq %rcx, 0x46f4(%rip)      # 0x8198
jmp 0x3a5a
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/grammar.cpp
// Function: c(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool c(string& in) {
	if (in[0]=='C') {consume(in);}
	else {return false;}

	int newLine=number(in);

	Interval interv=inter(in);
	if (interv.start<0 || interv.end<0) {return false;}

	for (size_t i=interv.start;i<=interv.end;++i) {
		if (systape[i]) {
			callStack.push_back(programCounter);
			programCounter=newLine-1;
			return true;}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
cmpb $0x43, (%rax)
jne 0x3adf
movq %rdi, %rbx
callq 0x32d4
movq %rbx, %rdi
callq 0x3329
movq %rax, %r14
movq %rbx, %rdi
callq 0x34e5
movabsq $-0x7fffffff80000000, %rcx # imm = 0x8000000080000000
testq %rcx, %rax
je 0x3ae8
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rcx
shrq $0x20, %rax
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movb $0x1, %bl
cmpq %rax, %rcx
ja 0x3ae1
movq 0x463d(%rip), %rdx      # 0x8140
incq %rax
movq %rcx, %rsi
shrq $0x6, %rsi
movq (%rdx,%rsi,8), %rsi
btq %rcx, %rsi
jb 0x3b21
incq %rcx
cmpq %rcx, %rax
jne 0x3b06
jmp 0x3ae1
movq 0x4660(%rip), %rsi      # 0x8188
cmpq 0x4661(%rip), %rsi      # 0x8190
je 0x3b48
movq 0x4660(%rip), %rax      # 0x8198
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x4642(%rip)      # 0x8188
jmp 0x3b5b
leaq 0x4631(%rip), %rdi      # 0x8180
leaq 0x4642(%rip), %rdx      # 0x8198
callq 0x4d42
decl %r14d
movslq %r14d, %rax
movq %rax, 0x4630(%rip)      # 0x8198
jmp 0x3ae1
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/grammar.cpp
// Function: o(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool o(string& in) {
	if (in[0]=='O') {consume(in);}
	else {return false;}

	Interval interval=inter(in);
	if (interval.start<0 || interval.end<0) {return false;}

	cout << "[";
	for (size_t i=interval.start;i<systape.size() && i<=interval.end;++i) {
		cout << systape[i] << ((i==systape.size()-1 || i==interval.end)?"":",");
	}
	cout << "]" << endl;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpb $0x4f, (%rax)
jne 0x3bed
movq %rdi, %rbx
callq 0x32d4
movq %rbx, %rdi
callq 0x34e5
movq %rax, %r14
movabsq $-0x7fffffff80000000, %rax # imm = 0x8000000080000000
testq %rax, %r14
je 0x3bfe
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %r12
shrq $0x20, %r14
movq 0x43bc(%rip), %rdi      # 0x7fc8
leaq 0x1c39(%rip), %rsi      # 0x584c
movl $0x1, %edx
callq 0x2170
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
cmpq %r14, %r12
ja 0x3ce6
movq 0x451c(%rip), %rcx      # 0x8150
movl 0x451e(%rip), %edx      # 0x8158
movq 0x44ff(%rip), %rax      # 0x8140
subq %rax, %rcx
leaq (%rdx,%rcx,8), %rcx
cmpq %rcx, %r12
jae 0x3ce6
movq 0x4370(%rip), %r15      # 0x7fc8
leaq 0x1bef(%rip), %r13      # 0x584e
leaq 0x1b32(%rip), %rbx      # 0x5798
movq %r12, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
xorl %esi, %esi
btq %r12, %rax
setb %sil
movq %r15, %rdi
callq 0x21e0
movq 0x44c6(%rip), %rcx      # 0x8150
movl 0x44c8(%rip), %edx      # 0x8158
subq 0x44a9(%rip), %rcx      # 0x8140
leaq (%rdx,%rcx,8), %rcx
decq %rcx
cmpq %rcx, %r12
setne %cl
cmpq %r12, %r14
setne %dl
andb %cl, %dl
movq %rbx, %rsi
cmovneq %r13, %rsi
movzbl %dl, %edx
movq %rax, %rdi
callq 0x2170
cmpq %r14, %r12
jae 0x3ce6
incq %r12
movq 0x4483(%rip), %rcx      # 0x8150
movl 0x4485(%rip), %edx      # 0x8158
movq 0x4466(%rip), %rax      # 0x8140
subq %rax, %rcx
leaq (%rdx,%rcx,8), %rcx
cmpq %rcx, %r12
jb 0x3c66
leaq 0x1b63(%rip), %rsi      # 0x5850
movl $0x1, %edx
movq 0x42cf(%rip), %rbx      # 0x7fc8
movq %rbx, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movb $0x1, %al
jmp 0x3bef
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/grammar.cpp
// Function: s(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool s(string& in) {
	if (in[0]=='S') {consume(in);}
	else {return false;}

	Interval interval=inter(in);
	if (interval.start<0 || interval.end<0) {return false;}

	cout << "[";
	char accum=0;
	for (size_t i=interval.start;i<systape.size() && i<=interval.end;++i) {
		accum=accum<<1;
		if (systape[i]) {accum|=1;}
		if ((i-interval.start)%8==7) {
			cout << accum << ((i>=systape.size()-8 || i>=interval.end-7)?"":",");
			accum=0;
		}
	}
	cout << "]" << endl;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpb $0x53, (%rax)
jne 0x3d67
movq %rdi, %rbx
callq 0x32d4
movq %rbx, %rdi
callq 0x34e5
movq %rax, %r13
movabsq $-0x7fffffff80000000, %rax # imm = 0x8000000080000000
testq %rax, %r13
je 0x3d78
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rbx
shrq $0x20, %rbx
movq 0x4242(%rip), %rdi      # 0x7fc8
leaq 0x1abf(%rip), %rsi      # 0x584c
movl $0x1, %edx
callq 0x2170
movl %r13d, %r14d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
cmpq %rbx, %r14
ja 0x3ea5
movq 0x439f(%rip), %rax      # 0x8150
movl 0x43a1(%rip), %ecx      # 0x8158
movq 0x4382(%rip), %rdx      # 0x8140
movq %rax, %rsi
subq %rdx, %rsi
leaq (%rcx,%rsi,8), %rsi
cmpq %rsi, %r14
jae 0x3ea5
movabsq $-0x700000000, %r15     # imm = 0xFFFFFFF900000000
addq %r13, %r15
sarq $0x20, %r15
negq %r13
xorl %esi, %esi
leaq 0x19aa(%rip), %r12      # 0x5798
movl %esi, %edi
addb %sil, %dil
movq %r14, %rsi
shrq $0x6, %rsi
movq (%rdx,%rsi,8), %rsi
btq %r14, %rsi
setb %sil
orb %dil, %sil
leal (%r14,%r13), %edi
notl %edi
testb $0x7, %dil
jne 0x3e87
movb %sil, -0x29(%rbp)
movl $0x1, %edx
movq 0x41a3(%rip), %rdi      # 0x7fc8
leaq -0x29(%rbp), %rsi
callq 0x2170
movq 0x431b(%rip), %rcx      # 0x8150
movl 0x431d(%rip), %edx      # 0x8158
subq 0x42fe(%rip), %rcx      # 0x8140
leaq (%rdx,%rcx,8), %rcx
addq $-0x8, %rcx
cmpq %rcx, %r14
setb %cl
cmpq %r15, %r14
setb %dl
andb %cl, %dl
movq %r12, %rsi
leaq 0x19ec(%rip), %rcx      # 0x584e
cmovneq %rcx, %rsi
movzbl %dl, %edx
movq %rax, %rdi
callq 0x2170
movq 0x42d8(%rip), %rax      # 0x8150
movl 0x42da(%rip), %ecx      # 0x8158
xorl %esi, %esi
movq 0x42b9(%rip), %rdx      # 0x8140
cmpq %rbx, %r14
jae 0x3ea5
incq %r14
movq %rax, %rdi
subq %rdx, %rdi
movl %ecx, %r8d
leaq (%r8,%rdi,8), %rdi
cmpq %rdi, %r14
jb 0x3dee
leaq 0x19a4(%rip), %rsi      # 0x5850
movl $0x1, %edx
movq 0x4110(%rip), %rbx      # 0x7fc8
movq %rbx, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movb $0x1, %al
jmp 0x3d69
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/grammar.cpp
// Function: i(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool i(string& in) {
	if (in[0]=='I') {consume(in);}
	else {return false;}

	Interval i=inter(in);
	if (i.start<0 || i.end<0) {return false;}

	cout << "BINARY INPUT:";
	string input;
	getline(cin,input);

	write(input,i.start,i.end);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %rax
cmpb $0x49, (%rax)
jne 0x3f25
movq %rdi, %rbx
callq 0x32d4
movq %rbx, %rdi
callq 0x34e5
movq %rax, %rbx
movabsq $-0x7fffffff80000000, %rax # imm = 0x8000000080000000
testq %rax, %rbx
je 0x3f32
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x408f(%rip), %rdi      # 0x7fc8
leaq 0x1912(%rip), %rsi      # 0x5852
movl $0xd, %edx
callq 0x2170
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x4073(%rip), %rdi      # 0x7fd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %edx
movq 0x4058(%rip), %rdi      # 0x7fd8
leaq -0x38(%rbp), %rsi
callq 0x2220
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x2f72
movq %rbx, %rdx
shrq $0x20, %rdx
leaq -0x58(%rbp), %rdi
movl %ebx, %esi
callq 0x33ea
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x3fcc
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2150
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x3fe1
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2150
movb $0x1, %al
jmp 0x3f27
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x4005
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x4005
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x401a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/JD557[P]Wolf/grammar.cpp
// Function: f(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool f(string& in) {
	if (in[0]=='F') {consume(in);}
	else {return false;}

	Interval i=inter(in);
	if (i.start<0 || i.end<0) {return false;}

	cout << "STRING INPUT:";
	string input;
	cin >> input;

	string converted_input;
	for (size_t x=0;x<input.size();++x) {
		for (int y=7;y>=0;--y) {
			converted_input+=((input[x]&(1<<y))!=0?'1':'0');
		}
	}

	write(converted_input,i.start,i.end);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq (%rdi), %rax
cmpb $0x46, (%rax)
jne 0x405d
movq %rdi, %rbx
callq 0x32d4
movq %rbx, %rdi
callq 0x34e5
movq %rax, %rbx
movabsq $-0x7fffffff80000000, %rax # imm = 0x8000000080000000
testq %rax, %rbx
je 0x406e
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3f53(%rip), %rdi      # 0x7fc8
leaq 0x17e4(%rip), %rsi      # 0x5860
movl $0xd, %edx
callq 0x2170
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x3f34(%rip), %rdi      # 0x7fd8
leaq -0x48(%rbp), %rsi
callq 0x2190
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
xorl %r14d, %r14d
cmpq $0x0, -0x40(%rbp)
je 0x4110
leaq -0x68(%rbp), %r15
movl $0x7, %r12d
movq -0x48(%rbp), %rax
movsbl (%rax,%r14), %eax
btl %r12d, %eax
movl $0x0, %esi
adcl $0x30, %esi
movq %r15, %rdi
callq 0x2110
addl $-0x1, %r12d
jb 0x40d6
incq %r14
cmpq -0x40(%rbp), %r14
jb 0x40d0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %r14
leaq -0x38(%rbp), %r12
jmp 0x4113
movq %r13, %rsi
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
addq %rsi, %r14
leaq -0x88(%rbp), %rdi
movq %r14, %rdx
callq 0x2f72
movq %rbx, %rdx
shrq $0x20, %rdx
leaq -0x88(%rbp), %rdi
movl %ebx, %esi
callq 0x33ea
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x415a
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2150
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x416f
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2150
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x4184
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2150
movb $0x1, %al
jmp 0x405f
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x41b2
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x41b2
jmp 0x41af
movq %rax, %rbx
jmp 0x41c7
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x41c7
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2150
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x41e0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/base64_dec.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 2)
	{
		printf("Usage: base64_dec file.base64\r\n");
		return -1;
	}

	unsigned int size = 0;

	char *buffer = get_file(argv[1], &size);
	if (buffer == NULL)
	{
		printf("Unable to open %s\r\n", argv[1]);
		return -1;
	}

	unsigned char *decode = (unsigned char *)malloc(size);
	if (decode == NULL)
	{
		perror("malloc failed");
		return -1;
	}
	memset(decode, 0, size);
	size_t length = size;



	printf("Base64: %s\n", buffer);
	base64decode(buffer, strlen(buffer), decode, &length);
	printf("decode: %s\nlength %d\n", decode, (int)length);


	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %edi
jg 0x1350
leaq 0xd44(%rip), %rdi       # 0x208a
callq 0x1040
jmp 0x13e3
movq %rsi, %rbx
leaq -0x24(%rbp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rbx), %rdi
callq 0x11fc
testq %rax, %rax
je 0x13d1
movq %rax, %r14
movl -0x24(%rbp), %ebx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1090
testq %rax, %rax
je 0x13f7
movq %rax, %r15
leaq -0x30(%rbp), %r12
movq %rbx, (%r12)
leaq 0xcb7(%rip), %rdi       # 0x204c
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1080
movq %r14, %rdi
callq 0x1070
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1569
movl (%r12), %edx
leaq 0xc93(%rip), %rdi       # 0x2058
movq %r15, %rsi
xorl %eax, %eax
callq 0x1080
jmp 0x13e8
movq 0x8(%rbx), %rsi
leaq 0xc4e(%rip), %rdi       # 0x202a
xorl %eax, %eax
callq 0x1080
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc40(%rip), %rdi       # 0x203e
callq 0x10e0
jmp 0x13e3
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/base64.c
// Function: base64decode
int base64decode(char *in, size_t inLen, unsigned char *out, size_t *outLen)
{
	char *end = in + inLen;
	char iter = 0;
	uint32_t buf = 0;
	size_t len = 0;

	while (in < end) {
		unsigned char c = d[*in++];

		switch (c) {
		case WHITESPACE: continue;   /* skip whitespace */
		case INVALID:    return 1;   /* invalid input, return error */
		case EQUALS:                 /* pad character, end of data */
			in = end;
			continue;
		default:
			buf = buf << 6 | c;
			iter++; // increment the number of iteration
					/* If the buffer is full, split it into bytes */
			if (iter == 4) {
				if ((len += 3) > *outLen) return 1; /* buffer overflow */
				*(out++) = (buf >> 16) & 255;
				*(out++) = (buf >> 8) & 255;
				*(out++) = buf & 255;
				buf = 0; iter = 0;

			}
		}
	}

	if (iter == 3) {
		if ((len += 2) > *outLen) return 1; /* buffer overflow */
		*(out++) = (buf >> 10) & 255;
		*(out++) = (buf >> 2) & 255;
	}
	else if (iter == 2) {
		if (++len > *outLen) return 1; /* buffer overflow */
		*(out++) = (buf >> 4) & 255;
	}

	*outLen = len; /* modify to reflect the actual output size */
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq %rcx, %r8
xorl %r9d, %r9d
testq %rsi, %rsi
jle 0x1628
addq %rdi, %rsi
xorl %r9d, %r9d
leaq 0xb76(%rip), %rcx       # 0x2100
xorl %ebx, %ebx
xorl %r10d, %r10d
movsbq (%rdi), %rax
movzbl (%rax,%rcx), %r11d
movl $0x1, %eax
cmpl $0x40, %r11d
je 0x15e6
cmpl $0x41, %r11d
je 0x15ee
cmpl $0x42, %r11d
je 0x162d
shll $0x6, %ebx
orl %ebx, %r11d
incb %r10b
cmpb $0x4, %r10b
jne 0x15e3
addq $0x3, %r9
cmpq (%r8), %r9
ja 0x162d
movl %ebx, %r10d
shrl $0x10, %r10d
movb %r10b, (%rdx)
movb %bh, 0x1(%rdx)
movb %r11b, 0x2(%rdx)
addq $0x3, %rdx
xorl %r10d, %r10d
xorl %ebx, %ebx
jmp 0x15e6
movl %r11d, %ebx
incq %rdi
cmpq %rsi, %rdi
jb 0x158f
cmpb $0x2, %r10b
je 0x1617
movzbl %r10b, %ecx
cmpl $0x3, %ecx
jne 0x1628
addq $0x2, %r9
cmpq (%r8), %r9
ja 0x162d
movl %ebx, %eax
shrl $0xa, %eax
movb %al, (%rdx)
incq %rdx
movl $0x2, %ecx
jmp 0x1624
incq %r9
movl $0x4, %ecx
cmpq (%r8), %r9
ja 0x162d
shrl %cl, %ebx
movb %bl, (%rdx)
movq %r9, (%r8)
xorl %eax, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testClient/testBenchmark.cpp
// Function: _send_req(int, int, char*, int, char const*)
static int __send_req(int fd, int cmd, char *reqbuf, int size, const char *tag)
{
	struct proto_h16_head *h = (struct proto_h16_head *)reqbuf;
	int msize = size + sizeof(*h);

	h->len = msize;
	h->cmd = cmd;
	h->ver = 1;
	h->syn = 2;
	h->ack = 3;
	*(int *)(h + 1) = 0; // to tell echo rsp immediately

	while (true) {
		ssize_t wlen = beyondy::XbsWriteN(fd, reqbuf, msize, timeout);
		if (wlen < 0 && errno == EINTR) continue;
		if (wlen != msize) {
			fprintf(stdout, "FAIL: %s pkg-size=%d, write req failed: %m\n", tag, size);
			return -1;	
		}

		break;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %r14d
movq %rdx, %r15
movl %edi, %ebp
leal 0x10(%r14), %eax
movl %eax, (%rdx)
movw %si, 0x4(%rdx)
movw $0x1, 0x6(%rdx)
movabsq $0x300000002, %rcx      # imm = 0x300000002
movq %rcx, 0x8(%rdx)
movl $0x0, 0x10(%rdx)
movslq %eax, %r12
movl $0x2710, %ecx           # imm = 0x2710
movl %ebp, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2c33
movq %rax, %r13
testq %rax, %rax
jns 0x2ae3
callq 0x2040
cmpl $0x4, (%rax)
je 0x2abf
xorl %eax, %eax
cmpq %r12, %r13
je 0x2b0d
movq 0x34c7(%rip), %rax      # 0x5fb8
movq (%rax), %rdi
leaq 0x1694(%rip), %rsi      # 0x418f
movq %rbx, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x2200
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testClient/testBenchmark.cpp
// Function: _read_rsp(int, char*, int, char const*)
static int __read_rsp(int fd, char *rspbuf, int size, const char *tag)
{
	while (true) {
		int msize = size + sizeof(struct proto_h16_head);
		ssize_t rlen = beyondy::XbsReadN(fd, rspbuf, msize, timeout);

		if (rlen != msize) {
			fprintf(stdout, "FAIL: %s pkg-size=%d, read rsp failed: %m\n", tag, msize);
			return -1;	
		}

		break;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
addl $0x10, %ebp
movslq %ebp, %rbx
movl $0x2710, %ecx           # imm = 0x2710
movq %rbx, %rdx
callq 0x2e2d
movq %rax, %r15
cmpq %rbx, %rax
je 0x2b60
movq 0x346e(%rip), %rax      # 0x5fb8
movq (%rax), %rdi
leaq 0x1667(%rip), %rsi      # 0x41bb
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2200
xorl %eax, %eax
cmpq %rbx, %r15
setne %al
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/base64_enc.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 2)
	{
		printf("Usage: base64_enc file.bin\r\n");
		return -1;
	}

	unsigned int size = 0;

	char *encode = get_file(argv[1], &size);
	int buf_size = (size / 3) * 4;
	if (size % 3)
		buf_size += 4;

	char *buffer = (char *)malloc(buf_size);
	if (buffer == NULL)
	{
		perror("malloc failed");
		return -1;
	}

	memset(buffer, 0, buf_size);
	base64encode(encode, size, buffer, buf_size);
	buffer[buf_size] = 0;
	printf("Base64: %s\n", buffer);

	write_file((char *)"file.base64", buffer, buf_size);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %edi
jg 0x1345
leaq 0xd36(%rip), %rdi       # 0x206c
callq 0x1040
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x13d7
leaq -0x24(%rbp), %rbx
movl $0x0, (%rbx)
movq 0x8(%rsi), %rdi
movq %rbx, %rsi
callq 0x11ec
movq %rax, %r15
movl (%rbx), %ebx
movl $0xaaaaaaab, %eax       # imm = 0xAAAAAAAB
imulq %rbx, %rax
shrq $0x20, %rax
addl %eax, %eax
andl $-0x4, %eax
imull $0xaaaaaaab, %ebx, %ecx # imm = 0xAAAAAAAB
leal 0x4(%rax), %edx
cmpl $0x55555556, %ecx       # imm = 0x55555556
cmovbl %eax, %edx
movslq %edx, %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x1080
testq %rax, %rax
je 0x13e6
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x13f8
movb $0x0, (%r12,%r14)
leaq 0xc7f(%rip), %rdi       # 0x2038
xorl %ebx, %ebx
movq %r12, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0xc78(%rip), %rdi       # 0x2044
movq %r12, %rsi
movl %r14d, %edx
callq 0x129e
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc3d(%rip), %rdi       # 0x202a
callq 0x10d0
jmp 0x133b
nop
// File: /workspace/github_cpp_makefile_star2_O3/eschwabe[P]interview-practice/src/towers.cpp
// Function: MoveDisc(Adapter<std::stack<int, std::deque<int, std::allocator<int>>>>&, Adapter<std::stack<int, std::deque<int, std::allocator<int>>>>&, Adapter<std::stack<int, std::deque<int, std::allocator<int>>>>&, int)
void MoveDisc(MyStack& source, MyStack& dest, MyStack& temp, int count) {
    if(count == 0) {
        return;
    }
    if(count > 1) {
        MoveDisc(source, dest, temp, count-1);
    }

    MoveDisc(dest, temp, source, count-1);
    dest.push(source.top());
    source.pop();
    PrintStacks(s_source, s_dest, s_temp);
    MoveDisc(temp, dest, source, count-1);

}

// Assembly:
testl %ecx, %ecx
je 0x1677
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2ba8(%rip), %r12      # 0x4170
leaq 0x2b51(%rip), %r13      # 0x4120
movq %rdx, %r15
movl %ebp, %eax
leal -0x1(%rax), %ebp
cmpl $0x2, %eax
jl 0x15ec
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x15a6
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x15a6
movq 0x30(%r14), %rsi
cmpq 0x38(%r14), %rsi
jne 0x1616
movq 0x48(%r14), %rax
movq -0x8(%rax), %rsi
movl $0x200, %eax            # imm = 0x200
addq %rax, %rsi
addq $-0x4, %rsi
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x1639
movl (%rsi), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x1641
movq %rbx, %rdi
callq 0x1916
movq %r14, %rdi
callq 0x1b2a
leaq 0x2a80(%rip), %rdi      # 0x40d0
movq %r12, %rsi
movq %r13, %rdx
callq 0x136c
movq %r14, %rdx
movq %r15, %r14
testl %ebp, %ebp
jne 0x15cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/eschwabe[P]interview-practice/src/towers.cpp
// Function: main
int main()
{

    const int N = 3;
    for(int i = N; i > 0; --i) {
        s_source.push(i);
    }

    PrintStacks(s_source, s_dest, s_temp);

    MoveDisc(s_source, s_dest, s_temp, N);

    PrintStacks(s_source, s_dest, s_temp);

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movl $0x3, (%rbx)
movq 0x2a6d(%rip), %rax      # 0x4100
movl $0x3, %edx
movq 0x2a71(%rip), %rcx      # 0x4110
leaq 0x2a2a(%rip), %r14      # 0x40d0
leaq -0x4(%rcx), %rsi
cmpq %rsi, %rax
je 0x16be
movl %edx, (%rax)
addq $0x4, %rax
movq %rax, 0x2a44(%rip)      # 0x4100
jmp 0x16d7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1916
movq 0x2a30(%rip), %rax      # 0x4100
movq 0x2a39(%rip), %rcx      # 0x4110
movl 0xc(%rsp), %esi
leal -0x1(%rsi), %edx
movl %edx, 0xc(%rsp)
cmpl $0x1, %esi
jg 0x16a6
leaq 0x29e2(%rip), %rbx      # 0x40d0
leaq 0x2a7b(%rip), %r14      # 0x4170
leaq 0x2a24(%rip), %r15      # 0x4120
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x136c
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x3, %ecx
callq 0x15a6
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x136c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/graphitemaster[P]smbf/smbf.cpp
// Function: u::getline[abi:cxx11](u::file&)
u::optional<u::string> getline(u::file &fp) {
    u::string s;
    for (;;) {
        char buf[256];
        if (!fgets(buf, sizeof(buf), fp.get())) {
            if (feof(fp.get())) {
                if (s.empty())
                    return u::none;
                else
                    return u::move(s);
            }
            abort();
        }
        size_t n = strlen(buf);
        if (n && buf[n - 1] == '\n')
            --n;
        s.append(buf, n);
        if (n < sizeof(buf) - 1)
            return u::move(s);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
movq (%rsi), %rdx
leaq 0x20(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x21d0
testq %rax, %rax
je 0x254b
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
callq 0x2080
testq %rax, %rax
je 0x251c
movq %rax, %r13
cmpb $0xa, 0x1f(%rsp,%rax)
jne 0x251f
decq %r13
jmp 0x251f
xorl %r13d, %r13d
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2040
cmpq $0xfe, %r13
jbe 0x257e
movq (%r14), %rdx
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x21d0
testq %rax, %rax
jne 0x2500
movq (%r14), %rdi
callq 0x21b0
testl %eax, %eax
je 0x25ce
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
je 0x25a0
movb $0x1, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%rsp), %rsi
addq %rsi, %rdx
callq 0x5306
jmp 0x25a3
movb $0x1, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
callq 0x5306
jmp 0x25a3
movb $0x0, (%rbx)
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x25b9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2120
movq %rbx, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20b0
jmp 0x25d7
jmp 0x25d7
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x25f0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2120
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/graphitemaster[P]smbf/smbf.cpp
// Function: vertexCacheData::findTriangle(unsigned long)
size_t vertexCacheData::findTriangle(size_t triangle) {
    for (size_t i = 0; i < indices.size(); i++)
        if (indices[i] == triangle)
            return i;
    return (size_t)-1;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq $-0x1, %rax
subq %rcx, %rdx
je 0x262d
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %edi, %edi
cmpq %rsi, (%rcx,%rdi,8)
je 0x262e
incq %rdi
cmpq %rdi, %rdx
jne 0x261f
retq
movq %rdi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/graphitemaster[P]smbf/smbf.cpp
// Function: vertexCacheData::moveTriangle(unsigned long)
void vertexCacheData::moveTriangle(size_t triangle) {
    size_t index = findTriangle(triangle);
    assert(index != (size_t)-1);

    // Erase the index and add it to the end
    indices.erase(indices.begin() + index,
                  indices.begin() + index + 1);
    indices.push_back(triangle);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rsi, 0x8(%rsp)
movq (%rdi), %r12
movq 0x8(%rdi), %rsi
movq %rsi, %rdx
subq %r12, %rdx
je 0x2683
movq %rdi, %rbx
movq %rdx, %rdi
sarq $0x3, %rdi
xorl %eax, %eax
cmpq $0x1, %rdi
movl $0x0, %ecx
sbbq %rdi, %rcx
xorl %r13d, %r13d
cmpq %r14, (%r12,%r13)
je 0x26a2
addq $0x8, %r13
decq %rax
cmpq %rax, %rcx
jne 0x2671
leaq 0x4a7e(%rip), %rdi      # 0x7108
leaq 0x4a8b(%rip), %rsi      # 0x711c
leaq 0x4a8d(%rip), %rcx      # 0x7125
movl $0x324, %edx            # imm = 0x324
callq 0x20c0
cmpq $0x1, %rax
je 0x2683
leaq (%r12,%r13), %r15
leaq (%r12,%r13), %rax
addq $0x8, %rax
cmpq %rsi, %rax
je 0x26d2
subq %r13, %rdx
addq $-0x8, %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x21e0
movq 0x8(%rbx), %rax
movq %rax, %rsi
subq %r12, %rax
subq %r13, %rax
addq %r15, %rax
addq $-0x8, %rax
cmpq %rax, %rsi
je 0x26eb
movq %rax, 0x8(%rbx)
movq %rax, %rsi
cmpq 0x10(%rbx), %rsi
je 0x26fe
movq %r14, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x270b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5c16
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop