LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: negativeview[P]Software-Business-Sim/CommandFunctor.cpp
// Function: CommandFunctor::marketChoiceMenu()
Market *CommandFunctor::marketChoiceMenu() {
	Market *ret = NULL;

	int n_choices = this->_masterState->getMarkets()->size();
    keypad(stdscr, TRUE);
	MENU *my_menu = this->setupMenu((vector<NamedObject *> *)(this->_masterState->getMarkets()));
	WINDOW *my_menu_win = this->setupWindow(my_menu, "Market");
	refresh();

    int c;
    int done = 0;
	while(!done) {
		c = wgetch(my_menu_win);
		switch(c) {
			case KEY_DOWN:
				menu_driver(my_menu, REQ_DOWN_ITEM);
				break;
			case KEY_UP:
				menu_driver(my_menu, REQ_UP_ITEM);
				break;
			case 10:	// Enter key, select the user.
				{
					ITEM *currentItem = current_item(my_menu);
					ret = (Market *)item_userptr(currentItem);
					done = 1;
				}
				break;
			case 27:
				done = 1;
				break;
		}
		wrefresh(my_menu_win);
	}

	/* Unpost and free all the memory taken up */
	unpost_menu(my_menu);

	ITEM **my_items = menu_items(my_menu);
	for(int i = 0; i < n_choices; ++i)
		free_item(my_items[i]);
	endwin();
	free_menu(my_menu);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x12ca0
movq %rax, %rdi
callq 0xb480
movl %eax, -0x14(%rbp)
movq 0x18fd9(%rip), %rax     # 0x23fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3140
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x12ca0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xaa40
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0xd756(%rip), %rdx      # 0x18786
callq 0xab50
movq %rax, -0x28(%rbp)
callq 0x35b0
movl $0x0, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb057
jmp 0xb0ea
movq -0x28(%rbp), %rdi
callq 0x3130
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
subl $0xa, %eax
je 0xb0b2
jmp 0xb070
movl -0x54(%rbp), %eax
subl $0x1b, %eax
je 0xb0d5
jmp 0xb07a
movl -0x54(%rbp), %eax
subl $0x102, %eax            # imm = 0x102
je 0xb092
jmp 0xb086
movl -0x54(%rbp), %eax
subl $0x103, %eax            # imm = 0x103
je 0xb0a2
jmp 0xb0dc
movq -0x20(%rbp), %rdi
movl $0x203, %esi            # imm = 0x203
callq 0x32d0
jmp 0xb0dc
movq -0x20(%rbp), %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x32d0
jmp 0xb0dc
movq -0x20(%rbp), %rdi
callq 0x3560
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3580
movq %rax, -0x10(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0xb0dc
movl $0x1, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3430
jmp 0xb045
movq -0x20(%rbp), %rdi
callq 0x3290
movq -0x20(%rbp), %rdi
callq 0x30d0
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb12b
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3470
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xb107
callq 0x3450
movq -0x20(%rbp), %rdi
callq 0x3110
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: negativeview[P]Software-Business-Sim/CommandFunctor.cpp
// Function: CommandFunctor::personChoiceMenu(char const*)
Person *CommandFunctor::personChoiceMenu(const char *title) {
	Person *ret = NULL;

	int n_choices = this->_masterState->getPlayerCompany()->getKnownPeople()->size();
    keypad(stdscr, TRUE);
	MENU *my_menu = this->setupMenu((vector<NamedObject *> *)(this->_masterState->getPlayerCompany()->getKnownPeople()));
	WINDOW *my_menu_win = this->setupWindow(my_menu, title);
	refresh();

    int c;
    int done = 0;
	while(!done) {
		c = wgetch(my_menu_win);
		switch(c) {
			case KEY_DOWN:
				menu_driver(my_menu, REQ_DOWN_ITEM);
				break;
			case KEY_UP:
				menu_driver(my_menu, REQ_UP_ITEM);
				break;
			case 10:	// Enter key, select the user.
				{
					ITEM *currentItem = current_item(my_menu);
					ret = (Person *)item_userptr(currentItem);
					done = 1;
				}
				break;
			case 27:
				done = 1;
				break;
		}
		wrefresh(my_menu_win);
	}

	/* Unpost and free all the memory taken up */
	unpost_menu(my_menu);

	ITEM **my_items = menu_items(my_menu);
	for(int i = 0; i < n_choices; ++i)
		free_item(my_items[i]);
	endwin();
	free_menu(my_menu);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x8(%rax), %rdi
callq 0x12e20
movq %rax, %rdi
callq 0xbfd0
movq %rax, %rdi
callq 0x4060
movl %eax, -0x1c(%rbp)
movq 0x18e3d(%rip), %rax     # 0x23fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3140
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x12e20
movq %rax, %rdi
callq 0xbfd0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xaa40
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xab50
movq %rax, -0x30(%rbp)
callq 0x35b0
movl $0x0, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb1f8
jmp 0xb28b
movq -0x30(%rbp), %rdi
callq 0x3130
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
subl $0xa, %eax
je 0xb253
jmp 0xb211
movl -0x5c(%rbp), %eax
subl $0x1b, %eax
je 0xb276
jmp 0xb21b
movl -0x5c(%rbp), %eax
subl $0x102, %eax            # imm = 0x102
je 0xb233
jmp 0xb227
movl -0x5c(%rbp), %eax
subl $0x103, %eax            # imm = 0x103
je 0xb243
jmp 0xb27d
movq -0x28(%rbp), %rdi
movl $0x203, %esi            # imm = 0x203
callq 0x32d0
jmp 0xb27d
movq -0x28(%rbp), %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x32d0
jmp 0xb27d
movq -0x28(%rbp), %rdi
callq 0x3560
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3580
movq %rax, -0x18(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0xb27d
movl $0x1, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3430
jmp 0xb1e6
movq -0x28(%rbp), %rdi
callq 0x3290
movq -0x28(%rbp), %rdi
callq 0x30d0
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb2cc
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3470
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xb2a8
callq 0x3450
movq -0x28(%rbp), %rdi
callq 0x3110
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: negativeview[P]Software-Business-Sim/Company.cpp
// Function: Company::Company(char const*, int)
Company::Company(const char *name, int money) {
	this->_name = (char *)malloc(strlen(name) + 1);
	strcpy(this->_name, name);
	this->_money = money;
	this->_employees = new vector<Person *>();
	this->_knownPeople = new vector<Person *>();
	this->_platformSkills = new map<Platform *, int>();
	this->_languageSkills = new map<Language *, int>();
	this->_allProjects = new vector<Project *>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x34d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3350
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0x18, %edi
callq 0x3370
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x31e0
movq -0x48(%rbp), %rdi
callq 0xc350
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x18, %edi
callq 0x3370
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x31e0
movq -0x40(%rbp), %rdi
callq 0xc350
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x30, %edi
callq 0x3370
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x31e0
movq -0x38(%rbp), %rdi
callq 0xc370
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x30, %edi
callq 0x3370
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x31e0
movq -0x30(%rbp), %rdi
callq 0xc390
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movl $0x18, %edi
callq 0x3370
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x31e0
movq -0x28(%rbp), %rdi
callq 0xc3b0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
// File: negativeview[P]Software-Business-Sim/Company.cpp
// Function: Company::addEmployee(Person*)
void Company::addEmployee(Person *person) {
	this->_employees->push_back(person);
	this->recomputeCompanySkills();

	for (vector<Person *>::iterator it = this->_knownPeople->begin(); it != this->_knownPeople->end(); ++it) {
		Person *p = *it;
		if (p == person) {
			this->_knownPeople->erase(it);
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x10(%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0xc440
movq -0x40(%rbp), %rdi
callq 0xb730
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xa6b0
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xa720
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa6e0
testb $0x1, %al
jne 0xb6d3
jmp 0xb726
leaq -0x18(%rbp), %rdi
callq 0xa750
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xb719
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xc520
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xc4b0
movq %rax, -0x38(%rbp)
jmp 0xb726
jmp 0xb71b
leaq -0x18(%rbp), %rdi
callq 0xa770
jmp 0xb6af
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x18(%rax), %rdi
callq 0xa6b0
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xa720
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa6e0
testb $0x1, %al
jne 0xbf18
jmp 0xbfbe
leaq -0x10(%rbp), %rdi
callq 0xa750
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x30e0
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xbfae
movq -0x20(%rbp), %rdi
callq 0x10f10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8fa0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9000
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8fd0
testb $0x1, %al
jne 0xbf74
jmp 0xbfac
leaq -0x30(%rbp), %rdi
callq 0x9030
movq (%rax), %rax
movq %rax, -0x40(%rbp)
callq 0x30e0
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xbf9f
movq -0x40(%rbp), %rdi
callq 0x17050
jmp 0xbfa1
leaq -0x30(%rbp), %rdi
callq 0x9060
jmp 0xbf54
jmp 0xbfae
jmp 0xbfb0
leaq -0x10(%rbp), %rdi
callq 0xa770
jmp 0xbef1
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rax), %rdi
callq 0xa6b0
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa720
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa6e0
testb $0x1, %al
jne 0xc039
jmp 0xc062
leaq -0x18(%rbp), %rdi
callq 0xa750
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xc055
jmp 0xc073
jmp 0xc057
leaq -0x18(%rbp), %rdi
callq 0xa770
jmp 0xc015
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0xc440
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl $0xe, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xc145
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa6b0
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa720
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa6e0
testb $0x1, %al
jne 0xc0e7
jmp 0xc143
leaq -0x18(%rbp), %rdi
callq 0xa750
movq (%rax), %rdi
callq 0x10db0
movq -0x30(%rbp), %rdi
cvtsi2sd %eax, %xmm0
movsd 0xc698(%rip), %xmm1     # 0x187a0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
callq 0xc170
leaq -0x18(%rbp), %rdi
callq 0xa750
movq (%rax), %rdi
movl -0x24(%rbp), %esi
callq 0x10f50
movl -0x24(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xa770
jmp 0xc0c3
jmp 0xc145
movq -0x30(%rbp), %rdi
callq 0xc190
movq -0x30(%rbp), %rdi
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
callq 0xc210
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, -0xc(%rbp)
movq 0x10(%rax), %rdi
callq 0x4060
imulq $0xa, %rax, %rcx
movslq -0xc(%rbp), %rax
addq %rcx, %rax
movl %eax, -0xc(%rbp)
callq 0x30e0
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xc1fd
callq 0x30e0
movl $0x64, %ecx
cltd
idivl %ecx
cvtsi2sd %edx, %xmm1
movsd 0xc5bf(%rip), %xmm0     # 0x187a8
divsd %xmm0, %xmm1
cvtsi2sdl -0xc(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
callq 0x3460
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xc2dc
movq -0x10(%rbp), %rdi
callq 0xc840
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x3390
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xc30d
movq -0x20(%rbp), %rdi
callq 0xc820
movq -0x20(%rbp), %rdi
movl $0x30, %esi
callq 0x3390
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xc33e
movq -0x28(%rbp), %rdi
callq 0xc840
movq -0x28(%rbp), %rdi
movl $0x18, %esi
callq 0x3390
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x18(%rbp)
movq 0x78(%rax), %rdi
callq 0x8fa0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x9000
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8fd0
testb $0x1, %al
jne 0x10e1f
jmp 0x10e41
leaq -0x20(%rbp), %rdi
callq 0x9030
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9060
jmp 0x10dfb
callq 0x30e0
movl $0x64, %ecx
cltd
idivl %ecx
cvtsi2sd %edx, %xmm0
movsd 0x7956(%rip), %xmm1     # 0x187b0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
cvtsi2ssl -0x14(%rbp), %xmm0
cvtsi2ssl -0x18(%rbp), %xmm1
mulss -0x2c(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jb 0x10e81
movb $0x1, -0x1(%rbp)
jmp 0x10e85
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x111b0
movq -0x48(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x8fa0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x9000
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8fd0
testb $0x1, %al
jne 0x10fca
jmp 0x1100c
leaq -0x10(%rbp), %rdi
callq 0x9030
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x10fff
movq -0x50(%rbp), %rdi
callq 0x17530
movq -0x50(%rbp), %rdi
movl $0x38, %esi
callq 0x3390
jmp 0x11001
leaq -0x10(%rbp), %rdi
callq 0x9060
jmp 0x10fa6
movq -0x48(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x11035
movq -0x58(%rbp), %rdi
callq 0x111d0
movq -0x58(%rbp), %rdi
movl $0x18, %esi
callq 0x3390
movq -0x48(%rbp), %rax
movq $0x0, 0x78(%rax)
movq 0x70(%rax), %rdi
callq 0x8fa0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x9000
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8fd0
testb $0x1, %al
jne 0x1107a
jmp 0x110bc
leaq -0x10(%rbp), %rdi
callq 0x9030
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x110af
movq -0x60(%rbp), %rdi
callq 0x17530
movq -0x60(%rbp), %rdi
movl $0x38, %esi
callq 0x3390
jmp 0x110b1
leaq -0x10(%rbp), %rdi
callq 0x9060
jmp 0x11056
movq -0x48(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x110e5
movq -0x68(%rbp), %rdi
callq 0x111d0
movq -0x68(%rbp), %rdi
movl $0x18, %esi
callq 0x3390
movq -0x48(%rbp), %rax
movq $0x0, 0x70(%rax)
movq 0x60(%rax), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x11116
movq -0x70(%rbp), %rdi
callq 0xc820
movq -0x70(%rbp), %rdi
movl $0x30, %esi
callq 0x3390
movq -0x48(%rbp), %rdi
movq $0x0, 0x60(%rdi)
addq $0x30, %rdi
callq 0x3210
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
callq 0x3210
movq -0x48(%rbp), %rdi
callq 0x57b0
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x48(%rax), %rdi
callq 0x138c0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x13930
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x138f0
testb $0x1, %al
jne 0x12d25
jmp 0x12d49
leaq -0x10(%rbp), %rdi
callq 0x13960
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3460
leaq -0x10(%rbp), %rdi
callq 0x13980
jmp 0x12d01
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x139a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: negativeview[P]Software-Business-Sim/Trait.cpp
// Function: Trait::discoverMore()
bool Trait::discoverMore() {
	bool ret = false;

	this->_discoveryLevel++;
	if (this->_discoveryLevel > 3)
		this->_discoveryLevel = 3;
	else
		ret = true;

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x9(%rbp)
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
cmpl $0x3, 0x30(%rax)
jle 0x17080
movq -0x18(%rbp), %rax
movl $0x3, 0x30(%rax)
jmp 0x17084
movb $0x1, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2310
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x6e29(%rip), %rsi      # 0x9798
callq 0x2ee0
jmp 0x2976
leaq -0x12(%rbp), %rdi
callq 0x2220
movq $0x0, -0x30(%rbp)
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x2130
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x2a56
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2360
movq %rax, -0x60(%rbp)
jmp 0x29bb
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x29fd
jmp 0x2a56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x2220
jmp 0x2a73
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2100
jmp 0x2a73
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2360
movq %rax, -0x68(%rbp)
jmp 0x2a10
movq -0x68(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x2a43
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2360
movq %rax, -0x70(%rbp)
jmp 0x2a2f
movq -0x40(%rbp), %rdi
movq -0x70(%rbp), %rax
movsbl (%rax), %esi
callq 0x2110
jmp 0x2a41
jmp 0x2a43
jmp 0x2a45
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2987
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2a69
movq -0x40(%rbp), %rdi
callq 0x2100
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2130
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x403c
cmpl $0x0, -0x10(%rbp)
jle 0x3f9b
movslq -0xc(%rbp), %rax
addq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jb 0x3f9b
jmp 0x403c
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2360
movsbl (%rax), %eax
subl $0x30, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movslq -0xc(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0xa214(%rip), %rdi      # 0xe1e0
callq 0x51a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jb 0x3ff3
movb -0x19(%rbp), %al
leaq 0xa1f9(%rip), %rdi      # 0xe1e0
andb $0x1, %al
movzbl %al, %esi
callq 0x5220
jmp 0x4029
movb -0x19(%rbp), %al
movb %al, -0x49(%rbp)
movslq -0xc(%rbp), %rsi
addq -0x18(%rbp), %rsi
leaq 0xa1d8(%rip), %rdi      # 0xe1e0
callq 0x52f0
movq %rax, %rcx
movb -0x49(%rbp), %al
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x5350
jmp 0x402b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3f5e
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x5819(%rip), %rax      # 0x987c
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x20e0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x4097
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x40b7
leaq 0xa142(%rip), %rdi      # 0xe1e0
callq 0x51a0
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x413d
movq -0x10(%rbp), %rdi
callq 0x3d80
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x40e3
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x40ed
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x413d
movq -0x10(%rbp), %rdi
callq 0x3d80
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x410b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x413d
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x412b
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x4135
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x413d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x54, %eax
jne 0x417f
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x4188
movb $0x0, -0x1(%rbp)
jmp 0x42cb
movq -0x10(%rbp), %rdi
callq 0x3d80
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x41b4
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x41bd
movb $0x0, -0x1(%rbp)
jmp 0x42cb
movl -0x14(%rbp), %eax
movq %rax, -0x90(%rbp)
leaq 0xa012(%rip), %rdi      # 0xe1e0
callq 0x51a0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jbe 0x41f5
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq 0x9ff2(%rip), %rdi      # 0xe1e0
xorl %edx, %edx
callq 0x53a0
leaq -0x38(%rbp), %rdi
callq 0x22a0
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x3e10
jmp 0x420d
leaq -0x58(%rbp), %rdi
callq 0x2130
cmpq $0x0, %rax
jne 0x423a
movb $0x0, -0x1(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x42a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x42c0
leaq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x20b0
jmp 0x424c
movl -0x14(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3f40
jmp 0x4262
leaq -0x88(%rbp), %rdi
callq 0x2100
movb $0x1, -0x1(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x42a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x42b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2100
jmp 0x42b7
leaq -0x58(%rbp), %rdi
callq 0x2100
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x42cb
leaq -0x58(%rbp), %rdi
callq 0x2100
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x42d9
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x58, %eax
jne 0x431c
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x4322
movb $0x0, -0x1(%rbp)
jmp 0x4338
leaq 0x9eb7(%rip), %rdi      # 0xe1e0
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x53a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x4a, %eax
jne 0x474c
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x4755
movb $0x0, -0x1(%rbp)
jmp 0x47e5
movq -0x10(%rbp), %rdi
callq 0x3d80
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4050
movq %rax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x477a
cmpl $0x0, -0x18(%rbp)
jge 0x4780
movb $0x0, -0x1(%rbp)
jmp 0x47e5
movslq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq %rcx, %rax
ja 0x47e1
movq -0x28(%rbp), %rsi
leaq 0x9a40(%rip), %rdi      # 0xe1e0
callq 0x52f0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x56b0
testb $0x1, %al
jne 0x47bc
jmp 0x47d1
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, 0x9a6d(%rip)      # 0xe238
movb $0x1, -0x1(%rbp)
jmp 0x47e5
jmp 0x47d3
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4788
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0x481c
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x4825
movb $0x0, -0x1(%rbp)
jmp 0x48c8
movq -0x10(%rbp), %rdi
callq 0x3d80
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4050
movq %rax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x484a
cmpl $0x0, -0x18(%rbp)
jge 0x4850
movb $0x0, -0x1(%rbp)
jmp 0x48c8
movslq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq %rcx, %rax
ja 0x48c4
movq -0x28(%rbp), %rsi
leaq 0x9970(%rip), %rdi      # 0xe1e0
callq 0x52f0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x56b0
testb $0x1, %al
jne 0x488c
jmp 0x48b4
leaq 0x998d(%rip), %rdi      # 0xe220
leaq 0x999e(%rip), %rsi      # 0xe238
callq 0x5840
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, 0x998a(%rip)      # 0xe238
movb $0x1, -0x1(%rbp)
jmp 0x48c8
jmp 0x48b6
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4858
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x50, %eax
jne 0x490c
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x4912
movb $0x0, -0x1(%rbp)
jmp 0x495d
leaq 0x9907(%rip), %rdi      # 0xe220
callq 0x58b0
cmpq $0x0, %rax
jbe 0x4959
leaq 0x98f5(%rip), %rdi      # 0xe220
callq 0x58b0
movq %rax, %rsi
subq $0x1, %rsi
leaq 0x98e2(%rip), %rdi      # 0xe220
callq 0x58d0
movq (%rax), %rax
movq %rax, 0x98eb(%rip)      # 0xe238
leaq 0x98cc(%rip), %rdi      # 0xe220
callq 0x58f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x4f, %eax
jne 0x499c
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x49a5
movb $0x0, -0x1(%rbp)
jmp 0x4aed
movq -0x10(%rbp), %rdi
callq 0x4050
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x49be
cmpl $0x0, -0x14(%rbp)
jge 0x49c7
movb $0x0, -0x1(%rbp)
jmp 0x4aed
movq 0x95fa(%rip), %rdi      # 0xdfc8
leaq 0x4e4b(%rip), %rsi      # 0x9820
callq 0x21c0
movslq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x97ef(%rip), %rdi      # 0xe1e0
callq 0x51a0
movq -0x40(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x31(%rbp)
jae 0x4a18
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
setbe %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4a24
jmp 0x4ac7
movq -0x20(%rbp), %rsi
leaq 0x97b1(%rip), %rdi      # 0xe1e0
callq 0x52f0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x56b0
movzbl %al, %esi
andl $0x1, %esi
movq 0x9576(%rip), %rdi      # 0xdfc8
callq 0x2320
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x9776(%rip), %rdi      # 0xe1e0
callq 0x51a0
movq -0x50(%rbp), %rcx
movq %rax, %rdx
subq $0x1, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x41(%rbp)
je 0x4a95
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
sete %al
movb %al, -0x41(%rbp)
movq -0x58(%rbp), %rdi
movb -0x41(%rbp), %cl
leaq 0x4d7f(%rip), %rsi      # 0x9822
leaq 0x4cee(%rip), %rax      # 0x9798
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x21c0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x49e2
movq 0x94fa(%rip), %rdi      # 0xdfc8
leaq 0x4d4f(%rip), %rsi      # 0x9824
callq 0x21c0
movq %rax, %rdi
movq 0x94d4(%rip), %rsi      # 0xdfb8
callq 0x2200
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x53, %eax
jne 0x4b2c
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x4b35
movb $0x0, -0x1(%rbp)
jmp 0x4cb8
movq -0x10(%rbp), %rdi
callq 0x4050
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x4b4e
cmpl $0x0, -0x14(%rbp)
jge 0x4b57
movb $0x0, -0x1(%rbp)
jmp 0x4cb8
movq 0x946a(%rip), %rdi      # 0xdfc8
leaq 0x4cbb(%rip), %rsi      # 0x9820
callq 0x21c0
movb $0x0, -0x19(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x965b(%rip), %rdi      # 0xe1e0
callq 0x51a0
movq -0x48(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x39(%rbp)
jae 0x4bac
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
setbe %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x4bb8
jmp 0x4c92
movsbl -0x19(%rbp), %eax
shll %eax
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rsi
leaq 0x9614(%rip), %rdi      # 0xe1e0
callq 0x52f0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x56b0
testb $0x1, %al
jne 0x4be8
jmp 0x4bf2
movsbl -0x19(%rbp), %eax
orl $0x1, %eax
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
subq %rcx, %rax
andq $0x7, %rax
cmpq $0x7, %rax
jne 0x4c7f
movq 0x93ba(%rip), %rdi      # 0xdfc8
movsbl -0x19(%rbp), %esi
callq 0x2250
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x95b6(%rip), %rdi      # 0xe1e0
callq 0x51a0
movq -0x58(%rbp), %rcx
movq %rax, %rdx
subq $0x8, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x49(%rbp)
jae 0x4c5a
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x7, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
setae %al
movb %al, -0x49(%rbp)
movq -0x60(%rbp), %rdi
movb -0x49(%rbp), %cl
leaq 0x4bba(%rip), %rsi      # 0x9822
leaq 0x4b29(%rip), %rax      # 0x9798
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x21c0
movb $0x0, -0x19(%rbp)
jmp 0x4c81
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4b76
movq 0x932f(%rip), %rdi      # 0xdfc8
leaq 0x4b84(%rip), %rsi      # 0x9824
callq 0x21c0
movq %rax, %rdi
movq 0x9309(%rip), %rsi      # 0xdfb8
callq 0x2200
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x49, %eax
jne 0x4cfc
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x4d05
movb $0x0, -0x1(%rbp)
jmp 0x4dbf
movq -0x10(%rbp), %rdi
callq 0x4050
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x4d1e
cmpl $0x0, -0x14(%rbp)
jge 0x4d27
movb $0x0, -0x1(%rbp)
jmp 0x4dbf
movq 0x929a(%rip), %rdi      # 0xdfc8
leaq 0x4af1(%rip), %rsi      # 0x9826
callq 0x21c0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x22a0
movq -0x70(%rbp), %rsi
movq 0x9286(%rip), %rdi      # 0xdfd8
callq 0x2050
jmp 0x4d59
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x20b0
jmp 0x4d68
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0x68(%rbp), %rdi
callq 0x3f40
jmp 0x4d79
leaq -0x68(%rbp), %rdi
callq 0x2100
movb $0x1, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x4dbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4db4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2100
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x4dca
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x46, %eax
jne 0x4e0f
movq -0x10(%rbp), %rdi
callq 0x3d30
jmp 0x4e18
movb $0x0, -0x1(%rbp)
jmp 0x4fa2
movq -0x10(%rbp), %rdi
callq 0x4050
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x4e31
cmpl $0x0, -0x14(%rbp)
jge 0x4e3a
movb $0x0, -0x1(%rbp)
jmp 0x4fa2
movq 0x9187(%rip), %rdi      # 0xdfc8
leaq 0x49ec(%rip), %rsi      # 0x9834
callq 0x21c0
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x22a0
movq -0xa0(%rbp), %rsi
movq 0x916d(%rip), %rdi      # 0xdfd8
callq 0x2290
jmp 0x4e72
leaq -0x68(%rbp), %rdi
callq 0x22a0
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jae 0x4f2c
movl $0x7, -0x74(%rbp)
cmpl $0x0, -0x74(%rbp)
jl 0x4f19
movq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2360
movq %rax, -0xb0(%rbp)
jmp 0x4ecd
movq -0xb0(%rbp), %rax
movsbl (%rax), %eax
movl -0x74(%rbp), %ecx
xorl %esi, %esi
btl %ecx, %eax
adcl $0x30, %esi
leaq -0x68(%rbp), %rdi
callq 0x2110
jmp 0x4eed
jmp 0x4eef
movl -0x74(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x4eb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4f97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4f8e
jmp 0x4f1b
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x4e83
leaq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x20b0
jmp 0x4f3e
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0x98(%rbp), %rdi
callq 0x3f40
jmp 0x4f52
leaq -0x98(%rbp), %rdi
callq 0x2100
movb $0x1, -0x1(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2100
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x4fa2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2100
leaq -0x68(%rbp), %rdi
callq 0x2100
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x4fb0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/./StrBlob.h
// Function: StrBlobPtr::incr()
inline
StrBlobPtr& StrBlobPtr::incr()
{
	// if curr already points past the end of the container, can't increment it
	check(curr, "increment past end of StrBlobPtr");
	++curr;	// advance the current state
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x21e0
movq -0x58(%rbp), %rdx
leaq 0x3512(%rip), %rsi      # 0x6086
leaq -0x38(%rbp), %rdi
callq 0x2160
jmp 0x2b7f
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rsi
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rcx
callq 0x5460
jmp 0x2b96
leaq -0x18(%rbp), %rdi
callq 0x4e70
leaq -0x38(%rbp), %rdi
callq 0x20d0
leaq -0x39(%rbp), %rdi
callq 0x2150
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2bea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20d0
leaq -0x39(%rbp), %rdi
callq 0x2150
movq -0x48(%rbp), %rdi
callq 0x21d0
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/./StrBlob.h
// Function: eq(StrBlobPtr const&, StrBlobPtr const&)
inline
bool eq(const StrBlobPtr& lhs, const StrBlobPtr& rhs)
{
	auto l = lhs.wptr.lock();
	auto r = rhs.wptr.lock();
	// if the underlying vector is the same
	if (l == r)
		// then they're equal if they're both null or
		// if they point to the same element
		return (!r || lhs.curr == rhs.curr);
	else
		return false;	// if they point to difference vectors, they're not equal
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x50f0
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x50f0
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5120
testb $0x1, %al
jne 0x507d
jmp 0x50bb
leaq -0x38(%rbp), %rdi
callq 0x5160
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x3d(%rbp)
jne 0x5094
jmp 0x50aa
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x50c6
movb $0x0, -0x1(%rbp)
movl $0x1, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4e70
leaq -0x28(%rbp), %rdi
callq 0x4e70
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)