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

	int n_choices = this->_masterState->getLanguages()->size();
    keypad(stdscr, TRUE);
	MENU *my_menu = this->setupMenu((vector<NamedObject *> *)(this->_masterState->getLanguages()));
	WINDOW *my_menu_win = this->setupWindow(my_menu, "Language");
	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 = (Language *)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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9b50
movq 0x8(%rax), %r12
subq (%rax), %r12
shrq $0x3, %r12
movq 0x932e(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3130
movq 0x8(%rbx), %rdi
callq 0x9b50
movq %rax, %rsi
callq 0x6a80
movq %rax, %rbx
leaq 0x4ab9(%rip), %rdx      # 0xb783
movq %rax, %rsi
callq 0x6b42
movq %rax, %r15
callq 0x34e0
xorl %r14d, %r14d
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3120
cmpl $0x101, %eax            # imm = 0x101
jg 0x6cfb
cmpl $0xa, %eax
je 0x6d13
cmpl $0x1b, %eax
je 0x6d26
jmp 0x6d3b
cmpl $0x103, %eax            # imm = 0x103
je 0x6d2e
cmpl $0x102, %eax            # imm = 0x102
jne 0x6d3b
movq %rbx, %rdi
movl $0x203, %esi            # imm = 0x203
jmp 0x6d36
movq %rbx, %rdi
callq 0x3490
movq %rax, %rdi
callq 0x34b0
movq %rax, %r14
movl $0x1, %r13d
jmp 0x6d3b
movq %rbx, %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x3270
movq %r15, %rdi
callq 0x3380
testl %r13d, %r13d
je 0x6ce0
movq %rbx, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x30b0
testl %r12d, %r12d
jle 0x6d7b
movq %rax, %r15
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
callq 0x33c0
incq %r13
cmpq %r13, %r12
jne 0x6d6a
callq 0x33a0
movq %rbx, %rdi
callq 0x3100
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/negativeview[P]Software-Business-Sim/CommandFunctor.cpp
// Function: CommandFunctor::platformChoiceMenu()
Platform *CommandFunctor::platformChoiceMenu() {
	Platform *ret = NULL;

	int n_choices = this->_masterState->getPlatforms()->size();
    keypad(stdscr, TRUE);
	MENU *my_menu = this->setupMenu((vector<NamedObject *> *)(this->_masterState->getPlatforms()));
	WINDOW *my_menu_win = this->setupWindow(my_menu, "Platform");
	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 = (Platform *)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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9b46
movq 0x8(%rax), %r12
subq (%rax), %r12
shrq $0x3, %r12
movq 0x920a(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3130
movq 0x8(%rbx), %rdi
callq 0x9b46
movq %rax, %rsi
callq 0x6a80
movq %rax, %rbx
leaq 0x499e(%rip), %rdx      # 0xb78c
movq %rax, %rsi
callq 0x6b42
movq %rax, %r15
callq 0x34e0
xorl %r14d, %r14d
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3120
cmpl $0x101, %eax            # imm = 0x101
jg 0x6e1f
cmpl $0xa, %eax
je 0x6e37
cmpl $0x1b, %eax
je 0x6e4a
jmp 0x6e5f
cmpl $0x103, %eax            # imm = 0x103
je 0x6e52
cmpl $0x102, %eax            # imm = 0x102
jne 0x6e5f
movq %rbx, %rdi
movl $0x203, %esi            # imm = 0x203
jmp 0x6e5a
movq %rbx, %rdi
callq 0x3490
movq %rax, %rdi
callq 0x34b0
movq %rax, %r14
movl $0x1, %r13d
jmp 0x6e5f
movq %rbx, %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x3270
movq %r15, %rdi
callq 0x3380
testl %r13d, %r13d
je 0x6e04
movq %rbx, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x30b0
testl %r12d, %r12d
jle 0x6e9f
movq %rax, %r15
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
callq 0x33c0
incq %r13
cmpq %r13, %r12
jne 0x6e8e
callq 0x33a0
movq %rbx, %rdi
callq 0x3100
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9a84
movq 0x8(%rax), %r12
subq (%rax), %r12
shrq $0x3, %r12
movq 0x90e6(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3130
movq 0x8(%rbx), %rdi
callq 0x9a84
movq %rax, %rsi
callq 0x6a80
movq %rax, %rbx
leaq 0x4883(%rip), %rdx      # 0xb795
movq %rax, %rsi
callq 0x6b42
movq %rax, %r15
callq 0x34e0
xorl %r14d, %r14d
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3120
cmpl $0x101, %eax            # imm = 0x101
jg 0x6f43
cmpl $0xa, %eax
je 0x6f5b
cmpl $0x1b, %eax
je 0x6f6e
jmp 0x6f83
cmpl $0x103, %eax            # imm = 0x103
je 0x6f76
cmpl $0x102, %eax            # imm = 0x102
jne 0x6f83
movq %rbx, %rdi
movl $0x203, %esi            # imm = 0x203
jmp 0x6f7e
movq %rbx, %rdi
callq 0x3490
movq %rax, %rdi
callq 0x34b0
movq %rax, %r14
movl $0x1, %r13d
jmp 0x6f83
movq %rbx, %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x3270
movq %r15, %rdi
callq 0x3380
testl %r13d, %r13d
je 0x6f28
movq %rbx, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x30b0
testl %r12d, %r12d
jle 0x6fc3
movq %rax, %r15
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
callq 0x33c0
incq %r13
cmpq %r13, %r12
jne 0x6fb2
callq 0x33a0
movq %rbx, %rdi
callq 0x3100
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9b5a
movq %rax, %rdi
callq 0x7702
movq 0x8(%rax), %r12
subq (%rax), %r12
shrq $0x3, %r12
movq 0x8fb7(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3130
movq 0x8(%rbx), %rdi
callq 0x9b5a
movq %rax, %rdi
callq 0x7702
movq %rax, %rsi
callq 0x6a80
movq %rax, %rbx
movq %rax, %rsi
movq %r14, %rdx
callq 0x6b42
movq %rax, %r15
callq 0x34e0
xorl %r14d, %r14d
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x3120
cmpl $0x101, %eax            # imm = 0x101
jg 0x7076
cmpl $0xa, %eax
je 0x708e
cmpl $0x1b, %eax
je 0x70a1
jmp 0x70b6
cmpl $0x103, %eax            # imm = 0x103
je 0x70a9
cmpl $0x102, %eax            # imm = 0x102
jne 0x70b6
movq %rbx, %rdi
movl $0x203, %esi            # imm = 0x203
jmp 0x70b1
movq %rbx, %rdi
callq 0x3490
movq %rax, %rdi
callq 0x34b0
movq %rax, %r14
movl $0x1, %r13d
jmp 0x70b6
movq %rbx, %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x3270
movq %r15, %rdi
callq 0x3380
testl %r13d, %r13d
je 0x705b
movq %rbx, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x30b0
testl %r12d, %r12d
jle 0x70f6
movq %rax, %r15
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
callq 0x33c0
incq %r13
cmpq %r13, %r12
jne 0x70e5
callq 0x33a0
movq %rbx, %rdi
callq 0x3100
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3170
leaq 0x1(%rax), %rdi
callq 0x3410
movq %rax, (%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x32e0
movl %r14d, 0x8(%rbx)
movl $0x18, %edi
callq 0x3300
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r14d, %r14d
movq %r14, 0x10(%rax)
movq %rax, 0x10(%rbx)
movl $0x18, %edi
callq 0x3300
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x18(%rbx)
movl $0x30, %edi
callq 0x3300
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rax, 0x28(%rbx)
movl $0x30, %edi
callq 0x3300
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rax, 0x30(%rbx)
movl $0x18, %edi
callq 0x3300
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, -0x10(%rbp)
movq 0x10(%rdi), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x72b8
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x72c1
leaq -0x10(%rbp), %rdx
callq 0x7c00
movq %rbx, %rdi
callq 0x7316
movq 0x18(%rbx), %rbx
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rax, %rdi
je 0x730e
movq -0x10(%rbp), %rcx
movq %rax, %rdx
subq %rdi, %rdx
addq $-0x8, %rdx
cmpq %rcx, (%rdi)
je 0x72fb
addq $0x8, %rdi
addq $-0x8, %rdx
cmpq %rax, %rdi
jne 0x72e7
jmp 0x730e
leaq 0x8(%rdi), %rsi
cmpq %rax, %rsi
je 0x7309
callq 0x34c0
addq $-0x8, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x76f2
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 0x76e0
movq %r14, %rdi
callq 0x8b9a
movq (%rax), %rbx
cmpq %rax, %rbx
je 0x76e0
movq %rax, %r14
movq 0x10(%rbx), %r15
callq 0x30c0
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
addl %r13d, %eax
rorl %eax
cmpl %r13d, %eax
ja 0x76d8
movq %r15, %rdi
callq 0xa814
movq (%rbx), %rbx
cmpq %r14, %rbx
jne 0x76b7
addq $0x8, %r12
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
cmpq 0x8(%rax), %r12
jne 0x768b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
cmpq %rax, %rcx
sete %dl
je 0x774c
cmpq %rsi, (%rcx)
je 0x7748
addq $0x8, %rcx
cmpq %rax, %rcx
sete %dl
je 0x774c
leaq 0x8(%rcx), %r8
cmpq %rsi, (%rcx)
movq %r8, %rcx
jne 0x7734
testb %dl, %dl
je 0x7770
movq 0x18(%rdi), %rdi
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x7764
movq %rsi, (%rax)
addq $0x8, 0x8(%rdi)
jmp 0x7770
leaq -0x8(%rbp), %rdx
movq %rax, %rsi
callq 0x7c00
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x77a3
movq %rbx, %rdi
callq 0x77ea
subl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x10(%rbx), %rax
movq (%rax), %r14
cmpq 0x8(%rax), %r14
je 0x7793
movq (%r14), %rdi
callq 0x8ab2
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x3fe9(%rip), %xmm0     # 0xb7b0
cvttsd2si %xmm0, %esi
subl %esi, 0x8(%rbx)
movq (%r14), %rdi
callq 0x8bae
addq $0x8, %r14
movq 0x10(%rbx), %rax
jmp 0x77aa
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7856
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 0x3f6e(%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_O1/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 0x78cb
movq (%r14), %rdi
testq %rdi, %rdi
je 0x78be
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 0x78f1
movq %r14, %rdi
callq 0x7a62
movl $0x30, %esi
movq %r14, %rdi
callq 0x3320
movq $0x0, 0x28(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x7923
movq (%r14), %rdi
testq %rdi, %rdi
je 0x7916
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_O1/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 0x8afb
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 0x8adf
cvtsi2ss %r12d, %xmm0
jmp 0x8afe
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 0x2c8e(%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_O1/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 0x8bf8
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x8bef
movq %r14, %rdi
callq 0xaa92
movl $0x38, %esi
movq %r14, %rdi
callq 0x3320
movq (%r15), %r15
movq 0x78(%rbx), %r14
jmp 0x8bcc
testq %r14, %r14
je 0x8c27
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x8c1a
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3320
movq %r15, %rdi
cmpq %r14, %r15
jne 0x8c05
movl $0x18, %esi
movq %r14, %rdi
callq 0x3320
movq $0x0, 0x78(%rbx)
movq 0x70(%rbx), %r14
movq (%r14), %r15
cmpq %r14, %r15
je 0x8c62
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x8c59
movq %r14, %rdi
callq 0xaa92
movl $0x38, %esi
movq %r14, %rdi
callq 0x3320
movq (%r15), %r15
movq 0x70(%rbx), %r14
jmp 0x8c36
testq %r14, %r14
je 0x8c91
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x8c84
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3320
movq %r15, %rdi
cmpq %r14, %r15
jne 0x8c6f
movl $0x18, %esi
movq %r14, %rdi
callq 0x3320
movq $0x0, 0x70(%rbx)
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x8cb7
movq %r14, %rdi
callq 0x7a62
movl $0x30, %esi
movq %r14, %rdi
callq 0x3320
movq $0x0, 0x60(%rbx)
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x8cd7
movq (%rax), %rsi
incq %rsi
callq 0x3320
movq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x8cef
movq (%rax), %rsi
incq %rsi
callq 0x3320
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x43d0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x8(%rax), %rcx
cmpq %rcx, %r14
je 0x9acb
movq %rdi, %rbx
movq (%r14), %rdi
callq 0x33b0
addq $0x8, %r14
movq 0x48(%rbx), %rax
movq 0x8(%rax), %rcx
cmpq %rcx, %r14
jne 0x9ab2
movq (%rax), %rdx
cmpq %rdx, %rcx
je 0x9ad7
movq %rdx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9b9e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9c3a
movq 0x8(%rbx), %rax
movq (%rax), %r15
cmpq %rax, %r15
je 0x9b72
movq 0x10(%r15), %r14
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x7776
movq 0x10(%rbx), %rax
movq (%rax), %r12
cmpq %rax, %r12
je 0x9c1c
movq %r14, %rdi
callq 0x7702
movq (%rax), %rcx
movq 0x8(%rax), %rax
cmpq %rax, %rcx
je 0x9bec
movq 0x10(%r12), %rdx
cmpq (%rcx), %rdx
je 0x9c12
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0x9bde
callq 0x30c0
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
addl $0x19999998, %eax       # imm = 0x19999998
rorl %eax
cmpl $0x19999999, %eax       # imm = 0x19999999
jb 0x9c12
movq 0x10(%r12), %rsi
movq %r14, %rdi
callq 0x770c
movq (%r12), %r12
cmpq 0x10(%rbx), %r12
jne 0x9bc5
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x765c
movq (%r15), %r15
cmpq 0x8(%rbx), %r15
jne 0x9baa
jmp 0x9b72
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x30(%rdi), %eax
leal 0x1(%rax), %ecx
cmpl $0x3, %eax
setl %al
movl $0x3, %edx
cmovll %ecx, %edx
movl %edx, 0x30(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c14
callq 0x3314
movq 0x4593(%rip), %rax      # 0x8188
cmpq 0x4584(%rip), %rax      # 0x8180
je 0x3c14
movq -0x8(%rax), %rcx
movq %rcx, 0x458f(%rip)      # 0x8198
addq $-0x8, %rax
movq %rax, 0x4574(%rip)      # 0x8188
cmpb $0x50, %bl
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2cb1(%rip), %rdx      # 0x5798
movq %rdx, %rsi
callq 0x302c
cmpq $0x0, 0x8(%r14)
je 0x2b1f
xorl %r12d, %r12d
movq (%r14), %rax
movzbl (%rax,%r12), %eax
cmpl $0x20, %eax
je 0x2b16
cmpl $0x3b, %eax
je 0x2b1f
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2110
incq %r12
cmpq 0x8(%r14), %r12
jb 0x2af9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2b41
movq (%r15), %rsi
incq %rsi
callq 0x2150
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3524
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 0x3516
movq (%r14), %rax
movb (%rax,%r13), %al
movq 0x4cc5(%rip), %rsi      # 0x8150
movl 0x4cc7(%rip), %edi      # 0x8158
movq 0x4ca8(%rip), %rdx      # 0x8140
subq %rdx, %rsi
leaq (%rdi,%rsi,8), %rsi
cmpq %rsi, %rcx
jae 0x34ec
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 0x3502
orq %rsi, (%rcx,%rdx)
jmp 0x3509
xorl %esi, %esi
cmpb $0x30, %al
setne %sil
leaq 0x4c45(%rip), %rdi      # 0x8140
callq 0x4376
jmp 0x3509
notq %rsi
andq %rsi, (%rcx,%rdx)
incq %r13
cmpq 0x8(%r14), %r13
jb 0x3463
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3578
movq %rdi, %rbx
callq 0x3314
movq %rbx, %rdi
callq 0x3369
movq %rax, %r14
movq (%rbx), %rax
cmpb $0x2c, (%rax)
jne 0x3571
movq %rbx, %rdi
callq 0x3314
movq %rbx, %rdi
callq 0x3369
movq %rax, %r15
cmpl %r14d, %r15d
jge 0x35a6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3596
movq 0x4bd1(%rip), %rax      # 0x8150
subq 0x4bba(%rip), %rax      # 0x8140
movl 0x4bcc(%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 0x3596
movq %rbx, %rdi
callq 0x3314
movl %r14d, %r12d
movq %r15, %rax
jmp 0x3596
// File: /workspace/github_cpp_makefile_star2_O1/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 0x36ce
movq %rdi, %rbx
callq 0x3314
movq %rbx, %rdi
callq 0x3369
movq %rax, %r14
movq (%rbx), %rax
cmpb $0x2c, (%rax)
jne 0x36ce
movq %rbx, %rdi
callq 0x3314
movl %r14d, %esi
movq 0x4b41(%rip), %rax      # 0x8150
movl 0x4b43(%rip), %ecx      # 0x8158
subq 0x4b24(%rip), %rax      # 0x8140
leaq (%rcx,%rax,8), %rax
cmpq %rax, %rsi
jbe 0x3633
leaq 0x4b14(%rip), %rdi      # 0x8140
xorl %edx, %edx
callq 0x43ca
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x33b4
movq -0x58(%rbp), %rdx
testq %rdx, %rdx
setne %bl
je 0x369e
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x60(%rbp), %rsi
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x2f92
leaq -0x40(%rbp), %rdi
movl %r14d, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x342a
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x369e
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2150
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36b7
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2150
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x36d0
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x36d0
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 0x36fc
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x36fc
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x371a
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x371a
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x372f
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x375c
callq 0x3314
leaq 0x49ed(%rip), %rdi      # 0x8140
xorl %esi, %esi
xorl %edx, %edx
callq 0x43ca
cmpb $0x58, %bl
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3afa
movq %rdi, %r14
callq 0x3314
movq %r14, %rdi
callq 0x3369
movq %rax, %rbx
movq %r14, %rdi
callq 0x3525
movq %rax, %rcx
movabsq $-0x7fffffff80000000, %rax # imm = 0x8000000080000000
testq %rax, %rcx
sete %al
jne 0x3afc
movq %rcx, %rdx
shrq $0x20, %rcx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movb $0x1, %al
cmpq %rcx, %rdx
ja 0x3afc
movq 0x4664(%rip), %rsi      # 0x8140
incq %rcx
movq %rdx, %rdi
shrq $0x6, %rdi
movq (%rsi,%rdi,8), %rdi
btq %rdx, %rdi
jb 0x3b01
incq %rdx
cmpq %rdx, %rcx
jne 0x3adf
jmp 0x3afc
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
decl %ebx
movslq %ebx, %rcx
movq %rcx, 0x468b(%rip)      # 0x8198
jmp 0x3afc
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3b86
movq %rdi, %r14
callq 0x3314
movq %r14, %rdi
callq 0x3369
movq %rax, %rbx
movq %r14, %rdi
callq 0x3525
movabsq $-0x7fffffff80000000, %rcx # imm = 0x8000000080000000
testq %rcx, %rax
sete %r14b
jne 0x3b89
movq %rax, %rcx
shrq $0x20, %rax
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movb $0x1, %r14b
cmpq %rax, %rcx
ja 0x3b89
movq 0x45d8(%rip), %rdx      # 0x8140
incq %rax
movq %rcx, %rsi
shrq $0x6, %rsi
movq (%rdx,%rsi,8), %rsi
btq %rcx, %rsi
jb 0x3b91
incq %rcx
cmpq %rcx, %rax
jne 0x3b6b
jmp 0x3b89
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x45f0(%rip), %rsi      # 0x8188
cmpq 0x45f1(%rip), %rsi      # 0x8190
je 0x3bb8
movq 0x45f0(%rip), %rax      # 0x8198
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x45d2(%rip)      # 0x8188
jmp 0x3bcb
leaq 0x45c1(%rip), %rdi      # 0x8180
leaq 0x45d2(%rip), %rdx      # 0x8198
callq 0x4da2
decl %ebx
movslq %ebx, %rax
movq %rax, 0x45c1(%rip)      # 0x8198
jmp 0x3b89
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d92
movq %rdi, %rbx
callq 0x3314
movq %rbx, %rdi
callq 0x3525
movq %rax, %r14
movabsq $-0x7fffffff80000000, %rax # imm = 0x8000000080000000
testq %rax, %r14
sete %al
jne 0x3d94
movq %r14, %r12
shrq $0x20, %r14
movq 0x4356(%rip), %rdi      # 0x7fc8
leaq 0x1bd3(%rip), %rsi      # 0x584c
movl $0x1, %edx
callq 0x2170
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
cmpq %r14, %r12
ja 0x3d4c
movq 0x44b6(%rip), %rcx      # 0x8150
movl 0x44b8(%rip), %edx      # 0x8158
movq 0x4499(%rip), %rax      # 0x8140
subq %rax, %rcx
leaq (%rdx,%rcx,8), %rcx
cmpq %rcx, %r12
jae 0x3d4c
movq 0x430a(%rip), %r15      # 0x7fc8
leaq 0x1b89(%rip), %r13      # 0x584e
leaq 0x1acc(%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 0x4460(%rip), %rcx      # 0x8150
movl 0x4462(%rip), %edx      # 0x8158
subq 0x4443(%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 0x3d4c
incq %r12
movq 0x441d(%rip), %rcx      # 0x8150
movl 0x441f(%rip), %edx      # 0x8158
movq 0x4400(%rip), %rax      # 0x8140
subq %rax, %rcx
leaq (%rdx,%rcx,8), %rcx
cmpq %rcx, %r12
jb 0x3ccc
leaq 0x1afd(%rip), %rsi      # 0x5850
movl $0x1, %edx
movq 0x4269(%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 0x3d94
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f4b
movq %rdi, %rbx
callq 0x3314
movq %rbx, %rdi
callq 0x3525
movq %rax, %r13
movabsq $-0x7fffffff80000000, %rax # imm = 0x8000000080000000
testq %rax, %r13
sete %al
jne 0x3f4d
movq %r13, %rbx
shrq $0x20, %rbx
movq 0x41d4(%rip), %rdi      # 0x7fc8
leaq 0x1a51(%rip), %rsi      # 0x584c
movl $0x1, %edx
callq 0x2170
movl %r13d, %r14d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
cmpq %rbx, %r14
ja 0x3f05
movq 0x4331(%rip), %rax      # 0x8150
movl 0x4333(%rip), %edx      # 0x8158
movq 0x4314(%rip), %rcx      # 0x8140
subq %rcx, %rax
leaq (%rdx,%rax,8), %rax
cmpq %rax, %r14
jae 0x3f05
movabsq $-0x700000000, %r15     # imm = 0xFFFFFFF900000000
addq %r13, %r15
sarq $0x20, %r15
negq %r13
xorl %eax, %eax
leaq 0x193f(%rip), %r12      # 0x5798
movl %eax, %edx
addb %al, %dl
movq %r14, %rax
shrq $0x6, %rax
movq (%rcx,%rax,8), %rax
btq %r14, %rax
setb %al
orb %dl, %al
leal (%r14,%r13), %ecx
notl %ecx
testb $0x7, %cl
jne 0x3ed9
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq 0x413d(%rip), %rdi      # 0x7fc8
leaq -0x29(%rbp), %rsi
callq 0x2170
movq 0x42b5(%rip), %rcx      # 0x8150
movl 0x42b7(%rip), %edx      # 0x8158
subq 0x4298(%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 0x1986(%rip), %rcx      # 0x584e
cmovneq %rcx, %rsi
movzbl %dl, %edx
movq %rax, %rdi
callq 0x2170
xorl %eax, %eax
cmpq %rbx, %r14
jae 0x3f05
incq %r14
movq 0x4268(%rip), %rdx      # 0x8150
movl 0x426a(%rip), %esi      # 0x8158
movq 0x424b(%rip), %rcx      # 0x8140
subq %rcx, %rdx
leaq (%rsi,%rdx,8), %rdx
cmpq %rdx, %r14
jb 0x3e59
leaq 0x1944(%rip), %rsi      # 0x5850
movl $0x1, %edx
movq 0x40b0(%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 0x3f4d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4051
movq %rdi, %rbx
callq 0x3314
movq %rbx, %rdi
callq 0x3525
movq %rax, %rbx
movabsq $-0x7fffffff80000000, %rax # imm = 0x8000000080000000
testq %rax, %rbx
sete %al
jne 0x4053
movq 0x4023(%rip), %rdi      # 0x7fc8
leaq 0x18a6(%rip), %rsi      # 0x5852
movl $0xd, %edx
callq 0x2170
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x4007(%rip), %rdi      # 0x7fd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %edx
movq 0x3fec(%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 0x2f92
movq %rbx, %rdx
shrq $0x20, %rdx
leaq -0x58(%rbp), %rdi
movl %ebx, %esi
callq 0x342a
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x4038
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2150
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x404d
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2150
movb $0x1, %al
jmp 0x4053
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x407b
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x407b
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x4090
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41ee
movq %rdi, %rbx
callq 0x3314
movq %rbx, %rdi
callq 0x3525
movq %rax, %rbx
movabsq $-0x7fffffff80000000, %rax # imm = 0x8000000080000000
testq %rax, %rbx
sete %al
jne 0x41f0
movq 0x3ee3(%rip), %rdi      # 0x7fc8
leaq 0x1774(%rip), %rsi      # 0x5860
movl $0xd, %edx
callq 0x2170
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x3ec8(%rip), %rdi      # 0x7fd8
leaq -0x48(%rbp), %rsi
callq 0x2190
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpq $0x0, -0x40(%rbp)
je 0x4170
xorl %r13d, %r13d
leaq -0x68(%rbp), %r14
movl $0x7, %r15d
movq -0x48(%rbp), %rax
movsbl (%rax,%r13), %eax
btl %r15d, %eax
movl $0x0, %esi
adcl $0x30, %esi
movq %r14, %rdi
callq 0x2110
addl $-0x1, %r15d
jb 0x4144
incq %r13
cmpq -0x40(%rbp), %r13
jb 0x413e
leaq -0x78(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x2f92
movq %rbx, %rdx
shrq $0x20, %rdx
leaq -0x88(%rbp), %rdi
movl %ebx, %esi
callq 0x342a
movq -0x88(%rbp), %rdi
cmpq %r14, %rdi
je 0x41bc
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2150
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x41d1
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2150
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x41ea
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2150
movb $0x1, %al
jmp 0x41f0
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r14, %rdi
je 0x4226
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x4226
jmp 0x4223
movq %rax, %rbx
jmp 0x423b
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x423b
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2150
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4254
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH08_TheIOLibrary/examples/buf.cc
// Function: main
int main()
{
	// writes hi and a newline, then flushes the buffer
    cout << "hi!" << endl;  

	// writes hi, then flushes the buffer; adds no data
    cout << "hi!" << flush; 

	// writes hi and a null, then flushes the buffer
    cout << "hi!" << ends;  

    cout << unitbuf;         // all writes will be flushed immediately

	// any output is flushed immediately, no buffering
    cout << "first" << " second" << endl;

	cout << nounitbuf;       // returns to normal buffering

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2dfe(%rip), %rbx      # 0x3fd8
leaq 0xe23(%rip), %r14       # 0x2004
movl $0x3, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1070
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movl $0x3, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1070
movq %rbx, %rdi
callq 0x1040
movl $0x3, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1070
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1030
movq (%rbx), %rax
movq -0x18(%rax), %rax
orl $0x2000, 0x18(%rbx,%rax) # imm = 0x2000
leaq 0xda8(%rip), %rsi       # 0x2008
movl $0x5, %edx
movq %rbx, %rdi
callq 0x1070
leaq 0xd9a(%rip), %rsi       # 0x200e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x1070
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq (%rbx), %rax
movq -0x18(%rax), %rax
andl $0xffffdfff, 0x18(%rbx,%rax) # imm = 0xFFFFDFFF
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq